archetype 1.2.14 · OCaml Package

type 'a with_annot = {

node : 'a;
annotation : Ident.ident option;

}

val pp_with_annot : 
  'a. (Ppx_deriving_runtime.Format.formatter ->
        'a ->
        Ppx_deriving_runtime.unit) ->
  Ppx_deriving_runtime.Format.formatter ->
  'a with_annot ->
  Ppx_deriving_runtime.unit

val show_with_annot : 
  'a. (Ppx_deriving_runtime.Format.formatter ->
        'a ->
        Ppx_deriving_runtime.unit) ->
  'a with_annot ->
  Ppx_deriving_runtime.string

type type_node =

| Taddress
| Tbig_map of type_ * type_
| Tbool
| Tbytes
| Tchain_id
| Tcontract of type_
| Tint
| Tkey
| Tkey_hash
| Tlambda of type_ * type_
| Tlist of type_
| Tmap of type_ * type_
| Tmutez
| Tnat
| Toperation
| Toption of type_
| Tor of type_ * type_
| Tpair of type_ * type_
| Tset of type_
| Tsignature
| Tstring
| Ttimestamp
| Tunit
| Tticket of type_
| Tsapling_state of int
| Tsapling_transaction of int
| Tbls12_381_fr
| Tbls12_381_g1
| Tbls12_381_g2
| Tnever
| Tchest
| Tchest_key

and type_ = type_node with_annot

val pp_type_node : 
  Ppx_deriving_runtime.Format.formatter ->
  type_node ->
  Ppx_deriving_runtime.unit

val show_type_node : type_node -> Ppx_deriving_runtime.string

val pp_type_ : 
  Ppx_deriving_runtime.Format.formatter ->
  type_ ->
  Ppx_deriving_runtime.unit

val show_type_ : type_ -> Ppx_deriving_runtime.string

type data =

| Dint of Core.big_int
| Dstring of string
| Dbytes of string
| Dunit
| Dtrue
| Dfalse
| Dpair of data * data
| Dleft of data
| Dright of data
| Dsome of data
| Dnone
| Dlist of data list
| Delt of data * data
| Dvar of Ident.ident * type_
| DIrCode of Ident.ident * instruction
| Dcode of code

and code_node =

| SEQ of code list
| APPLY
| EXEC
| FAILWITH
| IF of code list * code list
| IF_CONS of code list * code list
| IF_LEFT of code list * code list
| IF_NONE of code list * code list
| ITER of code list
| LAMBDA of type_ * type_ * code list
| LOOP of code list
| LOOP_LEFT of code list
| DIG of int
| DIP of int * code list
| DROP of int
| DUG of int
| DUP
| DUP_N of int
| PUSH of type_ * data
| SWAP
| ABS
| ADD
| COMPARE
| EDIV
| EQ
| GE
| GT
| INT
| ISNAT
| LE
| LSL
| LSR
| LT
| MUL
| NEG
| NEQ
| SUB
| SUB_MUTEZ
| AND
| NOT
| OR
| XOR
| BLAKE2B
| CHECK_SIGNATURE
| HASH_KEY
| KECCAK
| PAIRING_CHECK
| SAPLING_EMPTY_STATE of int
| SAPLING_VERIFY_UPDATE
| SHA256
| SHA512
| SHA3
| ADDRESS
| AMOUNT
| BALANCE
| CHAIN_ID
| CONTRACT of type_ * Ident.ident option
| CREATE_CONTRACT of type_ * type_ * code
| IMPLICIT_ACCOUNT
| LEVEL
| NOW
| SELF of Ident.ident option
| SELF_ADDRESS
| SENDER
| SET_DELEGATE
| SOURCE
| TOTAL_VOTING_POWER
| TRANSFER_TOKENS
| VOTING_POWER
| CAR
| CDR
| CONCAT
| CONS
| EMPTY_BIG_MAP of type_ * type_
| EMPTY_MAP of type_ * type_
| EMPTY_SET of type_
| GET
| GET_N of int
| GET_AND_UPDATE
| LEFT of type_
| MAP of code list
| MEM
| NEVER
| NIL of type_
| NONE of type_
| PACK
| PAIR
| PAIR_N of int
| RIGHT of type_
| SIZE
| SLICE
| SOME
| UNIT
| UNPACK of type_
| UNPAIR
| UNPAIR_N of int
| UPDATE
| UPDATE_N of int
| JOIN_TICKETS
| READ_TICKET
| SPLIT_TICKET
| TICKET
| CAST of type_
| RENAME
| VIEW of Ident.ident * type_
| OPEN_CHEST
| CAR_N of int
| CDR_N of int

and code = {

node : code_node;
type_ : type_ list option ref;

}

and z_operator =

| Znow
| Zamount
| Zbalance
| Zsource
| Zsender
| Zaddress
| Zchain_id
| Zself of Ident.ident option
| Zself_address
| Znone of type_
| Zunit
| Znil of type_
| Zemptyset of type_
| Zemptymap of type_ * type_
| Zemptybigmap of type_ * type_
| Ztotalvotingpower
| Zlevel
| Zsapling_empty_state of int

and un_operator =

| Ucar
| Ucdr
| Uleft of type_
| Uright of type_
| Uneg
| Uint
| Unot
| Uabs
| Uisnat
| Usome
| Usize
| Upack
| Uunpack of type_
| Ublake2b
| Usha256
| Usha512
| Usha3
| Ukeccak
| Uhash_key
| Ufail
| Ucontract of type_ * Ident.ident option
| Usetdelegate
| Uimplicitaccount
| Ueq
| Une
| Ugt
| Uge
| Ult
| Ule
| Uvotingpower
| Ureadticket
| Ujointickets
| Upairing_check
| Uconcat
| Uaddress
| UcarN of int
| UcdrN of int

and bin_operator =

| Badd
| Bsub
| Bmul
| Bediv
| Blsl
| Blsr
| Bor
| Band
| Bxor
| Bcompare
| Bget
| Bmem
| Bconcat
| Bcons
| Bpair
| Bexec
| Bapply
| Bcreateticket
| Bsplitticket
| Bsapling_verify_update
| Bview of Ident.ident * type_
| Bsubmutez

and ter_operator =

| Tcheck_signature
| Tslice
| Tupdate
| Ttransfer_tokens
| Topen_chest

and g_operator = [

| `Zop of z_operator
| `Uop of un_operator
| `Bop of bin_operator
| `Top of ter_operator

]

and cmp_operator =

| Ceq
| Cne
| Cgt
| Cge
| Clt
| Cle

and builtin =

| Bmin of type_
| Bmax of type_
| Bfloor
| Bceil
| BlistContains of type_
| BlistNth of type_
| Btostring of type_
| Bratcmp
| Bratnorm
| Brataddsub
| Bratdiv
| Bratmul
| Bratuminus
| Bratabs
| Brattez
| Bratdur
| Bsubnat
| Bmuteztonat

and instruction =

| Iseq of instruction list
| IletIn of Ident.ident * instruction * instruction * bool
| Ivar of Ident.ident
| Icall of Ident.ident * instruction list * bool
| Iassign of Ident.ident * instruction
| Iif of instruction * instruction * instruction * type_
| Iifnone of instruction * instruction * Ident.ident * instruction * type_
| Iifleft of instruction * Ident.ident * instruction * Ident.ident * instruction * type_
| Iifcons of instruction * Ident.ident * Ident.ident * instruction * instruction * type_
| Iloop of instruction * instruction
| Iiter of Ident.ident list * instruction * instruction
| Iloopleft of instruction * Ident.ident * instruction
| Ilambda of type_ * Ident.ident * type_ * instruction
| Izop of z_operator
| Iunop of un_operator * instruction
| Ibinop of bin_operator * instruction * instruction
| Iterop of ter_operator * instruction * instruction * instruction
| Iupdate of ukind * aoperator
| Iconst of type_ * data
| Icompare of cmp_operator * instruction * instruction
| Iset of type_ * instruction list
| Ilist of type_ * instruction list
| Imap of bool * type_ * type_ * (instruction * instruction) list
| Irecord of ritem
| Irecupdate of instruction * ruitem
| Imap_ of instruction * Ident.ident * instruction
| Ifold of Ident.ident * Ident.ident option * Ident.ident * instruction * instruction * instruction
| Imichelson of instruction list * code * Ident.ident list

and ritem =

| Rtuple of instruction list
| Rnodes of ritem list

and ruitem =

| RUnodes of int * (int * ruitem) list
| RUassign of int * (int * instruction) list

and aoperator =

| Aunop of un_operator
| Abinop of bin_operator * instruction
| Aterop of ter_operator * instruction * instruction

and ukind =

| Uvar of Ident.ident
| Urec of Ident.ident * (int * int) list

val pp_data : 
  Ppx_deriving_runtime.Format.formatter ->
  data ->
  Ppx_deriving_runtime.unit

val show_data : data -> Ppx_deriving_runtime.string

val pp_code_node : 
  Ppx_deriving_runtime.Format.formatter ->
  code_node ->
  Ppx_deriving_runtime.unit

val show_code_node : code_node -> Ppx_deriving_runtime.string

val pp_code : 
  Ppx_deriving_runtime.Format.formatter ->
  code ->
  Ppx_deriving_runtime.unit

val show_code : code -> Ppx_deriving_runtime.string

val pp_z_operator : 
  Ppx_deriving_runtime.Format.formatter ->
  z_operator ->
  Ppx_deriving_runtime.unit

val show_z_operator : z_operator -> Ppx_deriving_runtime.string

val pp_un_operator : 
  Ppx_deriving_runtime.Format.formatter ->
  un_operator ->
  Ppx_deriving_runtime.unit

val show_un_operator : un_operator -> Ppx_deriving_runtime.string

val pp_bin_operator : 
  Ppx_deriving_runtime.Format.formatter ->
  bin_operator ->
  Ppx_deriving_runtime.unit

val show_bin_operator : bin_operator -> Ppx_deriving_runtime.string

val pp_ter_operator : 
  Ppx_deriving_runtime.Format.formatter ->
  ter_operator ->
  Ppx_deriving_runtime.unit

val show_ter_operator : ter_operator -> Ppx_deriving_runtime.string

val pp_g_operator : 
  Ppx_deriving_runtime.Format.formatter ->
  g_operator ->
  Ppx_deriving_runtime.unit

val show_g_operator : g_operator -> Ppx_deriving_runtime.string

val pp_cmp_operator : 
  Ppx_deriving_runtime.Format.formatter ->
  cmp_operator ->
  Ppx_deriving_runtime.unit

val show_cmp_operator : cmp_operator -> Ppx_deriving_runtime.string

val pp_builtin : 
  Ppx_deriving_runtime.Format.formatter ->
  builtin ->
  Ppx_deriving_runtime.unit

val show_builtin : builtin -> Ppx_deriving_runtime.string

val pp_instruction : 
  Ppx_deriving_runtime.Format.formatter ->
  instruction ->
  Ppx_deriving_runtime.unit

val show_instruction : instruction -> Ppx_deriving_runtime.string

val pp_ritem : 
  Ppx_deriving_runtime.Format.formatter ->
  ritem ->
  Ppx_deriving_runtime.unit

val show_ritem : ritem -> Ppx_deriving_runtime.string

val pp_ruitem : 
  Ppx_deriving_runtime.Format.formatter ->
  ruitem ->
  Ppx_deriving_runtime.unit

val show_ruitem : ruitem -> Ppx_deriving_runtime.string

val pp_aoperator : 
  Ppx_deriving_runtime.Format.formatter ->
  aoperator ->
  Ppx_deriving_runtime.unit

val show_aoperator : aoperator -> Ppx_deriving_runtime.string

val pp_ukind : 
  Ppx_deriving_runtime.Format.formatter ->
  ukind ->
  Ppx_deriving_runtime.unit

val show_ukind : ukind -> Ppx_deriving_runtime.string

type implem =

| Concrete of (Ident.ident * type_) list * instruction
| Abstract of builtin

val pp_implem : 
  Ppx_deriving_runtime.Format.formatter ->
  implem ->
  Ppx_deriving_runtime.unit

val show_implem : implem -> Ppx_deriving_runtime.string

type ctx_func = {

args : (Ident.ident * type_) list;
stovars : Ident.ident list;

}

val pp_ctx_func : 
  Ppx_deriving_runtime.Format.formatter ->
  ctx_func ->
  Ppx_deriving_runtime.unit

val show_ctx_func : ctx_func -> Ppx_deriving_runtime.string

type func = {

name : Ident.ident;
targ : type_;
tret : type_;
ctx : ctx_func;
body : implem;

}

val pp_func : 
  Ppx_deriving_runtime.Format.formatter ->
  func ->
  Ppx_deriving_runtime.unit

val show_func : func -> Ppx_deriving_runtime.string

type entry = {

name : Ident.ident;
args : (Ident.ident * type_) list;
eargs : (Ident.ident * type_) list;
body : instruction;

}

val pp_entry : 
  Ppx_deriving_runtime.Format.formatter ->
  entry ->
  Ppx_deriving_runtime.unit

val show_entry : entry -> Ppx_deriving_runtime.string

type ir = {

name : Ident.ident;
storage_type : type_;
storage_data : data;
storage_list : (Ident.ident * type_ * data) list;
with_operations : bool;
parameter : type_;
funs : func list;
views : func list;
entries : entry list;
parameters : Ident.ident list;

}

val pp_ir : 
  Ppx_deriving_runtime.Format.formatter ->
  ir ->
  Ppx_deriving_runtime.unit

val show_ir : ir -> Ppx_deriving_runtime.string

type view_struct = {

id : Ident.ident;
param : type_;
ret : type_;
body : code;

}

val pp_view_struct : 
  Ppx_deriving_runtime.Format.formatter ->
  view_struct ->
  Ppx_deriving_runtime.unit

val show_view_struct : view_struct -> Ppx_deriving_runtime.string

type michelson = {

storage : type_;
parameter : type_;
code : code;
views : view_struct list;
parameters : Ident.ident list;

}

val pp_michelson : 
  Ppx_deriving_runtime.Format.formatter ->
  michelson ->
  Ppx_deriving_runtime.unit

val show_michelson : michelson -> Ppx_deriving_runtime.string

type prim = {

prim : Ident.ident;
args : obj_micheline list;
annots : Ident.ident list;

}

and obj_micheline =

| Oprim of prim
| Ostring of string
| Obytes of string
| Oint of string
| Oarray of obj_micheline list
| Ovar of obj_micheline_var

and obj_micheline_var =

| OMVfree of Ident.ident
| OMVint of Ident.ident
| OMVstring of Ident.ident
| OMVbytes of Ident.ident
| OMVif of Ident.ident * obj_micheline * obj_micheline

val pp_prim : 
  Ppx_deriving_runtime.Format.formatter ->
  prim ->
  Ppx_deriving_runtime.unit

val show_prim : prim -> Ppx_deriving_runtime.string

val pp_obj_micheline : 
  Ppx_deriving_runtime.Format.formatter ->
  obj_micheline ->
  Ppx_deriving_runtime.unit

val show_obj_micheline : obj_micheline -> Ppx_deriving_runtime.string

val pp_obj_micheline_var : 
  Ppx_deriving_runtime.Format.formatter ->
  obj_micheline_var ->
  Ppx_deriving_runtime.unit

val show_obj_micheline_var : obj_micheline_var -> Ppx_deriving_runtime.string

type micheline = {

code : obj_micheline list;
storage : obj_micheline;
parameters : Ident.ident list;
views : obj_micheline list;

}

val pp_micheline : 
  Ppx_deriving_runtime.Format.formatter ->
  micheline ->
  Ppx_deriving_runtime.unit

val show_micheline : micheline -> Ppx_deriving_runtime.string

type dvar = [

| `VLocal of int
| `VGlobal of Ident.ident

]

and dexpr =

| Dvar of dvar
| Depair of dexpr * dexpr
| Ddata of type_ * data
| Dfun of g_operator * dexpr list

val pp_dvar : 
  Ppx_deriving_runtime.Format.formatter ->
  dvar ->
  Ppx_deriving_runtime.unit

val show_dvar : dvar -> Ppx_deriving_runtime.string

val pp_dexpr : 
  Ppx_deriving_runtime.Format.formatter ->
  dexpr ->
  Ppx_deriving_runtime.unit

val show_dexpr : dexpr -> Ppx_deriving_runtime.string

type dinstr =

| DIAssign of dvar * dexpr
| DIIf of dexpr * dcode * dcode
| DIMatch of dexpr * (Ident.ident * dpattern list * dcode) list
| DIFailwith of dexpr
| DIWhile of dexpr * dcode
| DIIter of dtyvar * dexpr * dcode
| DILoop of dtyvar * dcode

and dtyvar = dvar

and dpattern =

| DVar of int
| DPair of dpattern * dpattern

and dcode = dinstr list

val pp_dinstr : 
  Ppx_deriving_runtime.Format.formatter ->
  dinstr ->
  Ppx_deriving_runtime.unit

val show_dinstr : dinstr -> Ppx_deriving_runtime.string

val pp_dtyvar : 
  Ppx_deriving_runtime.Format.formatter ->
  dtyvar ->
  Ppx_deriving_runtime.unit

val show_dtyvar : dtyvar -> Ppx_deriving_runtime.string

val pp_dpattern : 
  Ppx_deriving_runtime.Format.formatter ->
  dpattern ->
  Ppx_deriving_runtime.unit

val show_dpattern : dpattern -> Ppx_deriving_runtime.string

val pp_dcode : 
  Ppx_deriving_runtime.Format.formatter ->
  dcode ->
  Ppx_deriving_runtime.unit

val show_dcode : dcode -> Ppx_deriving_runtime.string

type dprogram = {

name : Ident.ident;
storage : type_;
parameter : type_;
storage_data : data;
code : dcode;
procs : (string * (string * type_) list * dcode) list;

}

val pp_dprogram : 
  Ppx_deriving_runtime.Format.formatter ->
  dprogram ->
  Ppx_deriving_runtime.unit

val show_dprogram : dprogram -> Ppx_deriving_runtime.string

type rstack1 = [

| dvar
| `Paired of rstack1 * rstack1

]

val pp_rstack1 : 
  Ppx_deriving_runtime.Format.formatter ->
  rstack1 ->
  Ppx_deriving_runtime.unit

val show_rstack1 : rstack1 -> Ppx_deriving_runtime.string

type rstack = rstack1 list

val pp_rstack : 
  Ppx_deriving_runtime.Format.formatter ->
  rstack ->
  Ppx_deriving_runtime.unit

val show_rstack : rstack -> Ppx_deriving_runtime.string

val mk_type : ?annotation:Ident.ident -> type_node -> type_

val mk_ctx_func : 
  ?args:(Ident.ident * type_) list ->
  ?stovars:Ident.ident list ->
  'a ->
  ctx_func

val mk_code : ?type_:type_ list -> code_node -> code

val mk_func : Ident.ident -> type_ -> type_ -> ctx_func -> implem -> func

val mk_entry : 
  Ident.ident ->
  (Ident.ident * type_) list ->
  (Ident.ident * type_) list ->
  instruction ->
  entry

val mk_ir : 
  ?parameters:Ident.ident list ->
  Ident.ident ->
  type_ ->
  data ->
  (Ident.ident * type_ * data) list ->
  ?with_operations:bool ->
  type_ ->
  func list ->
  func list ->
  entry list ->
  ir

val mk_view_struct : Ident.ident -> type_ -> type_ -> code -> view_struct

val mk_michelson : 
  ?parameters:Ident.ident list ->
  type_ ->
  type_ ->
  ?views:view_struct list ->
  code ->
  michelson

val mk_prim : 
  ?args:obj_micheline list ->
  ?annots:Ident.ident list ->
  Ident.ident ->
  prim

val mk_micheline : 
  ?parameters:Ident.ident list ->
  ?views:obj_micheline list ->
  obj_micheline list ->
  obj_micheline ->
  micheline

val mk_dprogram : 
  ?procs:(string * (string * type_) list * dcode) list ->
  type_ ->
  type_ ->
  data ->
  Ident.ident ->
  dcode ->
  dprogram

val toperation : type_

val tunit : type_

val tstring : type_

val tnat : type_

val tint : type_

val tbool : type_

val tmutez : type_

val taddress : type_

val ttimestamp : type_

val tchain_id : type_

val tbytes : type_

val tpair : type_ -> type_ -> type_

val tor : type_ -> type_ -> type_

val trat : type_

val tlist : type_ -> type_

val tset : type_ -> type_

val tmap : type_ -> type_ -> type_

val tlambda : type_ -> type_ -> type_

val toption : type_ -> type_

val tcontract : type_ -> type_

val tkey_hash : type_

val tticket : type_ -> type_

val itrue : instruction

val ifalse : instruction

val iint : Core.big_int -> instruction

val inat : Core.big_int -> instruction

val istring : string -> instruction

val imutez : Core.big_int -> instruction

val isome : instruction -> instruction

val inone : type_ -> instruction

val iunit : instruction

val inil : type_ -> instruction

val iemptyset : type_ -> instruction

val iemptymap : type_ -> type_ -> instruction

val iemptybigmap : type_ -> type_ -> instruction

val icar : instruction -> instruction

val icdr : instruction -> instruction

val ifail : string -> instruction

val ifaild : instruction -> instruction

val iskip : instruction

val ileft : type_ -> instruction -> instruction

val iright : type_ -> instruction -> instruction

val ieq : instruction -> instruction -> instruction

val iadd : instruction -> instruction -> instruction

val isub : instruction -> instruction -> instruction

val isub_mutez : instruction -> instruction -> instruction

val imul : instruction -> instruction -> instruction

val idiv : instruction -> instruction -> instruction

val imod : instruction -> instruction -> instruction

val irecord : ritem -> instruction

val isrecord : instruction list -> instruction

val ipair : instruction -> instruction -> instruction

val icarn : int -> instruction -> instruction

val icdrn : int -> instruction -> instruction

val ctrue : code

val cfalse : code

val cnat : Core.big_int -> code

val cstring : string -> code

val cfail : string -> code

val cskip : code

val cseq : code list -> code

val capply : code

val cexec : code

val cfailwith : code

val cif : (code list * code list) -> code

val cifcons : (code list * code list) -> code

val cifleft : (code list * code list) -> code

val cifnone : (code list * code list) -> code

val citer : code list -> code

val clambda : (type_ * type_ * code list) -> code

val cloop : code list -> code

val cloop_left : code list -> code

val cdig : int -> code

val cdip : (int * code list) -> code

val cdrop : int -> code

val cdug : int -> code

val cdup : code

val cdup_n : int -> code

val cpush : (type_ * data) -> code

val cswap : code

val cabs : code

val cadd : code

val ccompare : code

val cediv : code

val ceq : code

val cge : code

val cgt : code

val cint : code

val cisnat : code

val cle : code

val clsl : code

val clsr : code

val clt : code

val cmul : code

val cneg : code

val cneq : code

val csub : code

val csub_mutez : code

val cand : code

val cnot : code

val cor : code

val cxor : code

val cblake2b : code

val ccheck_signature : code

val chash_key : code

val ckeccak : code

val cpairing_check : code

val csapling_empty_state : int -> code

val csapling_verify_update : code

val csha256 : code

val csha512 : code

val csha3 : code

val caddress : code

val camount : code

val cbalance : code

val cchain_id : code

val ccontract : (type_ * Ident.ident option) -> code

val ccreate_contract : (type_ * type_ * code) -> code

val cimplicit_account : code

val clevel : code

val cnow : code

val cself : Ident.ident option -> code

val cself_address : code

val csender : code

val cset_delegate : code

val csource : code

val ctotal_voting_power : code

val ctransfer_tokens : code

val cvoting_power : code

val ccar : code

val ccdr : code

val cconcat : code

val ccons : code

val cempty_big_map : (type_ * type_) -> code

val cempty_map : (type_ * type_) -> code

val cempty_set : type_ -> code

val cget : code

val cget_n : int -> code

val cget_and_update : code

val cleft : type_ -> code

val cmap : code list -> code

val cmem : code

val cnever : code

val cnil : type_ -> code

val cnone : type_ -> code

val cpack : code

val cpair : code

val cpair_n : int -> code

val cright : type_ -> code

val csize : code

val cslice : code

val csome : code

val cunit : code

val cunpair : code

val cunpair_n : int -> code

val cunpack : type_ -> code

val cupdate : code

val cupdate_n : int -> code

val cjoin_tickets : code

val cread_ticket : code

val csplit_ticket : code

val cticket : code

val ccast : type_ -> code

val crename : code

val cview : (Ident.ident * type_) -> code

val copen_chest : code

val ccarn : int -> code

val ccdrn : int -> code

val cmp_ident : Tools.String.t -> Tools.String.t -> bool

val cmp_type : type_ -> type_ -> bool

val cmp_data : data -> data -> bool

val cmp_z_operator : z_operator -> z_operator -> bool

val cmp_un_operator : un_operator -> un_operator -> bool

val cmp_bin_operator : bin_operator -> bin_operator -> bool

val cmp_ter_operator : ter_operator -> ter_operator -> bool

val cmp_code : code -> code -> bool

val cmp_builtin : builtin -> builtin -> bool

val map_type : (type_ -> type_) -> type_ -> type_

val cmp_dvar : dvar -> dvar -> bool

val cmp_dlocal : dexpr option ref -> dexpr option ref -> bool

val cmp_dexpr : dexpr -> dexpr -> bool

val map_data : (data -> data) -> data -> data

val map_code_gen : 
  (code -> code) ->
  (data -> data) ->
  (type_ -> type_) ->
  code ->
  code

val map_code : (code -> code) -> code -> code

val map_seq : (code list -> code list) -> code -> code

module Utils : sig ... end

val to_type : obj_micheline -> type_

val to_data : obj_micheline -> data

type micheline_ = Micheline_printer.node

val to_micheline_ : micheline -> micheline_

package archetype