archetype 1.4.3 · OCaml Package

module L = Location

module PT = ParseTree

module A = Ast

module T = Michelson

module Type : sig ... end

type opsig = {

osl_sig : A.ptyp list;
osl_ret : A.ptyp;

}

val pp_opsig : 
  Ppx_deriving_runtime.Format.formatter ->
  opsig ->
  Ppx_deriving_runtime.unit

val show_opsig : opsig -> Ppx_deriving_runtime.string

type namespace =

| Current
| Named of Ident.ident

val show_namespace : namespace -> Ppx_deriving_runtime.string

val uknm : namespace

type longident = namespace * Ident.ident

val show_longident : longident -> Ppx_deriving_runtime.string

type fullname = A.lident * A.lident

val pp_fullname : 
  Ppx_deriving_runtime.Format.formatter ->
  fullname ->
  Ppx_deriving_runtime.unit

val show_fullname : fullname -> Ppx_deriving_runtime.string

val unloc_longident : A.longident -> Ident.ident

val loc_longident : A.longident -> Location.t

val mknm : (Ident.ident option * 'a) -> namespace * 'a

val unloc_nm : PT.id_scope -> namespace

val unloc_nmid : (PT.id_scope * 'a Location.loced) -> namespace * 'a

val loc_nmid : (PT.id_scope * 'a Location.loced) -> Location.t

val pt_to_longident : (PT.id_scope * PT.lident) -> A.longident

type error_desc =

| TODO
| AEntryExpected of A.ptyp
| AlienPattern
| AnonymousFieldInEffect
| AssetExpected of A.ptyp
| AssetOrRecordExpected of A.ptyp
| AssetUpdateInNonFormula
| AssetWithoutFields
| AssetWithoutPKey
| BeforeIrrelevant of [ `Local | `State ]
| BeforeOrLabelInExpr
| BindingInExpr
| CannotAssignArgument of Ident.ident
| CannotAssignConstVar of Ident.ident
| CannotAssignLoopIndex of Ident.ident
| CannotAssignPatternVariable of Ident.ident
| CannotAssignStorageVariableInView of Ident.ident
| CannotCallSideEffectFunctionInView
| CannotCaptureVariables
| CannotEffectConstVar
| CannotImportFunctionWithSideEffect
| CannotImportFunctionWithStorageUsage
| CannotInfer
| CannotInferAnonAssetOrRecord
| CannotInferCollectionType
| CannotUpdatePKey
| CannotUseInstrWithSideEffectInView
| CollectionExpected
| ContainerOfNonAsset
| ContractInvariantInLocalSpec
| CreateContractStorageDuplicatedField of Ident.ident
| CreateContractStorageInvalidArgType
| CreateContractStorageInvalidAssignOperator
| CreateContractStorageInvalidField
| CreateContractStorageMissingField of Ident.ident
| CreateContractStorageRequireLitValueForConst of Ident.ident
| CreateContractStorageUnknownField of Ident.ident
| DetachInvalidExprFrom
| DetachInvalidType of Ident.ident
| DifferentMemoSizeForSaplingVerifyUpdate of int * int
| DivergentExpr
| DoesNotSupportMethodCall
| DuplicatedArgName of Ident.ident
| DuplicatedCtorName of Ident.ident
| DuplicatedFieldInAssetDecl of Ident.ident
| DuplicatedFieldInAssetOrRecordLiteral of Ident.ident
| DuplicatedFieldInRecordDecl of Ident.ident
| DuplicatedInitMarkForCtor
| DuplicatedPackingVar of Ident.ident
| DuplicatedPkeyField of Ident.ident
| DuplicatedVarDecl of Ident.ident
| EffectInGlobalSpec
| EmptyEnumDecl
| ExpressionExpected
| FileNotFound of Ident.ident
| ForeignState of Ident.ident option * Ident.ident option
| FormulaExpected
| FunctionInvalidInstructionVoid
| FunctionInvalidTypeVoid
| FunctionNoReturn
| FunctionNotFound of Ident.ident
| FunctionUnknownFunction of Ident.ident * Ident.ident
| IncompatibleSpecSig
| IncompatibleTypes of A.ptyp * A.ptyp
| IndexOutOfBoundForTuple
| InvalidApplicationKind of Ident.ident * Ident.ident
| InvalidArcheTypeDecl
| InvalidArgForGlobalConstant
| InvalidArgumentType of A.ptyp * A.ptyp
| InvalidArlFile
| InvalidAssetCollectionExpr of A.ptyp
| InvalidAssetExpression
| InvalidAssetGetContainer of A.container
| InvalidCallByAsset
| InvalidCallByExpression
| InvalidContractValueForCreateContract
| InvalidEffectForCtn of A.container * A.container list
| InvalidEntryDescription
| InvalidEntryExpression
| InvalidEventType
| InvalidExpression
| InvalidExpressionForEffect
| InvalidExprressionForTupleAccess
| InvalidFailIdType of Ident.ident * A.ptyp * A.ptyp
| InvalidFieldsCountInAssetOrRecordLiteral
| InvalidFoldInit of A.ptyp
| InvalidForIdentMap
| InvalidForIdentSimple
| InvalidFormula
| InvalidInstruction
| InvalidKeyFieldInAssetValueType
| InvalidLValue
| InvalidMapType
| InvalidMethodInExec
| InvalidMethodInFormula
| InvalidMethodWithBigMap of Ident.ident
| InvalidMethodWithIterableBigMap of Ident.ident
| InvalidNumberOfArguments of int * int
| InvalidNumberOfParameters of int * int
| InvalidPackingExpr
| InvalidPackingFormat
| InvalidRecordFieldType
| InvalidRoleExpression
| InvalidSaplingEmptyStateArg
| InvalidSecurityEntry
| InvalidSecurityRole
| InvalidSortingExpression
| InvalidSourcedByAsset
| InvalidSourcedByExpression
| InvalidStateExpression
| InvalidStorageType of A.ptyp * A.ptyp
| InvalidStringValue
| InvalidTezValueNeg
| InvalidTezValueOverflow
| InvalidTypeDeclOpt
| InvalidTypeForAddressToContract
| InvalidTypeForBigMapKey
| InvalidTypeForBigMapValue
| InvalidTypeForCallview
| InvalidTypeForContract
| InvalidTypeForDoFailIf
| InvalidTypeForDoRequire
| InvalidTypeForEntrypoint
| InvalidTypeForFail
| InvalidTypeForFailSome
| InvalidTypeForGlobalConstant
| InvalidTypeForLambdaArgument
| InvalidTypeForLambdaReturn
| InvalidTypeForMake
| InvalidTypeForMakeEvent
| InvalidTypeForMapKey
| InvalidTypeForMapOperator of A.ptyp
| InvalidTypeForMapValue
| InvalidTypeForOptionalAssign
| InvalidTypeForOrLeft
| InvalidTypeForOrRight
| InvalidTypeForParameter
| InvalidTypeForPk
| InvalidTypeForSet
| InvalidTypeForTuple
| InvalidTypePassable of A.ptyp
| InvalidTypeStorable of A.ptyp
| InvalidTzFile
| InvalidValueForCurrency
| InvalidValueForMemoSize
| InvalidVariableForMethod
| InvalidVarOrArgType
| InvalidZeroValue
| LabelInNonInvariant
| LetInElseInInstruction
| LetInElseOnNonOption
| MethodCallInPredicate
| MisorderedPkeyFields
| MissingFieldInAssetOrRecordLiteral of Ident.ident
| MixedAnonInAssetOrRecordLiteral
| MixedFieldNamesInAssetOrRecordLiteral of longident list
| MoreThanOneInitState of Ident.ident list
| MultipleAssetStateDeclaration
| MultipleInitialMarker
| MultipleMatchingFunction of longident * A.ptyp list * (A.ptyp list * A.ptyp) list
| MultipleMatchingOperator of PT.operator * A.ptyp list * opsig list
| MultipleStateDeclaration
| NameIsAlreadyBound of Ident.ident * Location.t option
| NoLetInInstruction
| NoMatchingFunction of longident * A.ptyp list
| NoMatchingOperator of PT.operator * A.ptyp list
| NonCodeLabel of Ident.ident
| NonHomogeneousPattern of Ident.ident
| NonIterable
| NonIterableBigMapAsset of longident
| NonLoopLabel of Ident.ident
| NoSuchMethod of Ident.ident
| NotAKeyOfType
| NotAnAssetType
| NotAnEnumType
| NotAPrimitiveType
| NotARole of Ident.ident
| NumericExpressionExpected
| NumericOrCurrencyExpressionExpected
| OpInRecordLiteral
| OrphanedLabel of Ident.ident
| PackUnpackOnNonPrimitive
| PartialMatch of Ident.ident list
| PostConditionInGlobalSpec
| ReadOnlyGlobal of Ident.ident
| RecordExpected
| RecordUpdateDuplicatedFieldName of Ident.ident
| RecordUpdateOnNonRecordOrAsset
| RecordUpdateOnPKey
| RecordUpdateWithInvalidFieldName
| ReturnInVoidContext
| SecurityInExpr
| SpecOperatorInExpr
| StringLiteralExpected
| TransferWithoutDest
| UninitializedVar
| UnknownAsset of Ident.ident
| UnknownAssetToProperty of Ident.ident
| UnknownCreateContractExtension of Ident.ident
| UnknownEntry of Ident.ident
| UnknownEnum of Ident.ident
| UnknownFailId of Ident.ident
| UnknownField of longident * Ident.ident
| UnknownFieldName of Ident.ident
| UnknownFunction of Ident.ident
| UnknownGetter of Ident.ident
| UnknownImport of Ident.ident
| UnknownImportExtension of Ident.ident
| UnknownLabel of Ident.ident
| UnknownLocalOrVariable of longident
| UnknownProcedure of Ident.ident
| UnknownState of Ident.ident
| UnknownTypeName of longident
| UnknownVariable of Ident.ident
| UnknownView of Ident.ident
| UpdateEffectOnPkey
| UpdateEffectWithoutDefault
| UselessPattern
| UsePkeyOfInsteadOfAsset
| ViewInvalidFsType of Ident.ident * Ident.ident
| ViewInvalidReturnType
| ViewInvalidVisibility
| VoidMethodInExpr
| VSetInExpr
| VSetOnNonAsset

val show_error_desc : error_desc -> Ppx_deriving_runtime.string

type error = L.t * error_desc

val pp_operator : Core.Format.formatter -> PT.operator -> unit

val pp_namespace : Format.formatter -> namespace -> unit

val pp_longident : 
  Format.formatter ->
  (namespace * Ident.ident) ->
  Ppx_deriving_runtime.unit

val pp_error_desc : Format.formatter -> error_desc -> Ppx_deriving_runtime.unit

type argtype = [

| `Type of A.type_
| `Effect of Ident.ident

]

val cmptypes : A.vtyp list

val grptypes : A.vtyp list

val rgtypes : A.vtyp list

val vt_comparable : A.ptyp list

val cmpsigs : (PT.operator * (A.vtyp list * A.vtyp)) list

val tsigs : (PT.operator * (A.vtyp list * A.vtyp)) list

val opsigs2 : (PT.operator * (A.vtyp list * A.ptyp)) list

val opsigs : (PT.operator * opsig) list

type acttx = [

| `Entry of PT.entry_decl
| `Transition of PT.transition_decl
| `Getter of PT.getter_decl

]

type groups = {

gr_archetypes : PT.lident Location.loced list;
gr_imports : (PT.lident option * PT.lident) Location.loced list;
gr_states : PT.enum_decl Location.loced list;
gr_enums : (PT.lident * PT.enum_decl) Location.loced list;
gr_assets : PT.asset_decl Location.loced list;
gr_records : PT.record_decl Location.loced list;
gr_events : PT.record_decl Location.loced list;
gr_vars : PT.variable_decl Location.loced list;
gr_funs : PT.s_function Location.loced list;
gr_acttxs : acttx Location.loced list;

}

val globals : (string * A.const * A.ptyp) list

val statename : string

type ('args, 'rty) gmethod_ = {

mth_name : A.const;
mth_purity : [ `Pure | `Effect of A.container list ];
mth_totality : [ `Total | `Partial ];
mth_map_type : [ `Both | `Standard ];
mth_sig : 'args * 'rty option;

}

type mthstyp = [

| `T of A.ptyp

]

type mthtyp = [

| mthstyp
| `The
| `Pk
| `OPk
| `ThePkForAggregate
| `Asset
| `Coll
| `SubColl
| `Container
| `PkOrAsset
| `OptVal
| `Cmp
| `Pred of bool
| `RExpr of bool
| `Ef of bool
| `Ref of int

]

and mthatyp = [

| `Fixed of mthtyp list
| `Multi of mthtyp

]

type smethod_ = (mthstyp list, mthstyp) gmethod_

type method_ = (mthatyp, mthtyp) gmethod_

val methods : method_ Ident.Mid.t

type opinfo = {

op_name : string;
op_const : A.const;
op_partial : [ `Partial | `Total ];
op_thety : A.type_ option;
op_sig : A.type_ list;
op_resty : [ `Self | `Ty of A.type_ ];
op_restr : Type.trestr Tools.Mint.t;
op_filter : (A.type_ list -> A.pterm list -> bool) option;

}

val op : 
  ?op_filter:(A.type_ list -> A.pterm list -> bool) ->
  string ->
  A.const ->
  [ `Partial | `Total ] ->
  A.type_ option ->
  A.type_ list ->
  [ `Self | `Ty of A.type_ ] ->
  Type.trestr Tools.Mint.t ->
  opinfo

val coreops : opinfo list

val optionops : opinfo list

val setops : opinfo list

val listops : opinfo list

val mapops : opinfo list

val bigmapops : opinfo list

val iterablebigmapops : opinfo list

val cryptoops : opinfo list

val mathops : opinfo list

val packops : opinfo list

val opsops : opinfo list

val lambdaops : opinfo list

val ticket_ops : opinfo list

val bls_ops : opinfo list

val timelock_ops : opinfo list

val allops : opinfo list

type 'env importdecl = {

id_name : A.lident;
id_path : A.lident;
id_content : Michelson.obj_micheline option;
id_ast : A.ast option;
id_entrypoints : (Ident.ident * A.type_) list;
id_views : (Ident.ident * (A.type_ * A.type_)) list;
id_funs : A.function_ list;
id_env : 'env option;

}

val pp_importdecl : 
  'env. (Ppx_deriving_runtime.Format.formatter ->
          'env ->
          Ppx_deriving_runtime.unit) ->
  Ppx_deriving_runtime.Format.formatter ->
  'env importdecl ->
  Ppx_deriving_runtime.unit

val show_importdecl : 
  'env. (Ppx_deriving_runtime.Format.formatter ->
          'env ->
          Ppx_deriving_runtime.unit) ->
  'env importdecl ->
  Ppx_deriving_runtime.string

type assetdecl = {

as_name : fullname;
as_fields : fielddecl list;
as_pkty : A.ptyp;
as_pk : A.lident list;
as_sortk : A.lident list;
as_bm : A.map_kind;
as_invs : (A.lident option * A.pterm) list;
as_init : A.pterm list list;

}

and fielddecl = {

fd_name : A.lident;
fd_type : A.ptyp;
fd_dfl : A.pterm option;

}

val pp_assetdecl : 
  Ppx_deriving_runtime.Format.formatter ->
  assetdecl ->
  Ppx_deriving_runtime.unit

val show_assetdecl : assetdecl -> Ppx_deriving_runtime.string

val pp_fielddecl : 
  Ppx_deriving_runtime.Format.formatter ->
  fielddecl ->
  Ppx_deriving_runtime.unit

val show_fielddecl : fielddecl -> Ppx_deriving_runtime.string

val get_field : Ident.ident -> assetdecl -> fielddecl option

type recorddecl = {

rd_name : fullname;
rd_fields : rfielddecl list;
rd_packing : rpacking option;

}

and rfielddecl = {

rfd_name : A.lident;
rfd_type : A.ptyp;
rfd_dfl : A.pterm option;

}

and rpacking =

| RLeaf of A.lident
| RNode of rpacking list

val pp_recorddecl : 
  Ppx_deriving_runtime.Format.formatter ->
  recorddecl ->
  Ppx_deriving_runtime.unit

val show_recorddecl : recorddecl -> Ppx_deriving_runtime.string

val pp_rfielddecl : 
  Ppx_deriving_runtime.Format.formatter ->
  rfielddecl ->
  Ppx_deriving_runtime.unit

val show_rfielddecl : rfielddecl -> Ppx_deriving_runtime.string

val pp_rpacking : 
  Ppx_deriving_runtime.Format.formatter ->
  rpacking ->
  Ppx_deriving_runtime.unit

val show_rpacking : rpacking -> Ppx_deriving_runtime.string

val get_rfield : Ident.ident -> recorddecl -> rfielddecl option

type vardecl = {

vr_name : A.longident;
vr_type : A.ptyp;
vr_kind : [ `Constant | `Variable | `Enum ];
vr_def : (A.pterm * [ `Inline | `Std ]) option;
vr_core : A.const option;

}

type fundecl = {

fs_name : A.longident;
fs_kind : A.fun_kind;
fs_args : (A.lident * A.ptyp) list;
fs_retty : A.returned_fun_type;
fs_body : A.instruction;
fs_side_effect : bool;
fs_storage_usage : bool;

}

type preddecl = {

pr_name : A.lident;
pr_args : (A.lident * A.ptyp) list;
pr_body : A.pterm;

}

type txeffect = {

tx_state : A.lident;
tx_when : A.pterm option;
tx_effect : A.instruction option;

}

type tentrydecl = {

ad_name : A.lident;
ad_args : (A.lident * A.ptyp) list;
ad_getter : bool;
ad_ret_t : A.ptyp option;
ad_srcby : A.pterm option Location.loced list * A.pterm option;
ad_callby : A.pterm option Location.loced list * A.pterm option;
ad_stateis : (A.lident * A.pterm option) option;
ad_effect : [ `Raw of A.instruction | `Tx of transition ] option;
ad_funs : fundecl option list;
ad_csts : (A.lident option * A.pterm * A.pterm option) list;
ad_reqs : (A.lident option * A.pterm * A.pterm option) list;
ad_fais : (A.lident option * A.pterm * A.pterm option) list;
ad_actfs : bool * A.pterm option;

}

and transition = A.sexpr * txeffect list

type statedecl = {

sd_name : A.longident;
sd_state : bool;
sd_ctors : ctordecl list;
sd_init : Ident.ident;

}

and ctordecl = A.lident * A.ptyp list

val get_ctor : Ident.ident -> ctordecl list -> ctordecl option

type definitiondecl = {

df_name : A.longident;
df_arg : A.lident * A.ptyp;
df_asset : A.lident;
df_body : A.pterm;

}

val pterm_arg_as_pterm : A.pterm_arg -> A.pterm option

val core_types : (string * A.ptyp) list

val ident_of_pname : ParseTree.pname -> Ident.ident

val as_pre : [> `Pre of 'a ] -> 'a

val as_full : [> `Full of 'a ] -> 'a

module Env : sig ... end

type env = Env.t

module Micheline : sig ... end

val coreloc : Location.t

val empty : ?cache:Env.cache -> ?path:string -> A.lident -> env

val normalize_type : env -> A.type_ -> A.type_

val ty_of_init_ty : env -> A.ptyp -> A.ptyp

type prekind = [

| `Record
| `Event
| `Asset
| `Enum

]

val check_and_emit_name_free : env -> ?pre:prekind -> A.lident -> bool

val select_operator : 
  Env.t ->
  ?asset:bool ->
  L.t ->
  (PT.operator * A.ptyp list) ->
  opsig option

val valid_var_or_arg_type : A.ptyp -> bool

val for_container : env -> PT.container -> A.container

val for_assignment_operator : PT.assignment_operator -> A.assignment_operator

val tt_logical_operator : PT.logical_operator -> A.logical_operator

val tt_arith_operator : PT.arithmetic_operator -> A.arithmetic_operator

val tt_cmp_operator : PT.comparison_operator -> A.comparison_operator

exception InvalidType

val for_type_exn : ?pkey:Ident.ident list -> env -> PT.type_t -> A.ptyp

val for_type : ?pkey:Ident.ident list -> env -> PT.type_t -> A.ptyp option

val for_asset_type : env -> PT.type_t -> A.longident option

val for_asset_keyof_type : env -> PT.type_t -> A.longident option

val for_literal : env -> A.type_ option -> PT.literal Location.loced -> A.bval

type ekind = [

| `Init
| `Entry
| `Getter
| `Function
| `View

]

type emode_t = {

em_kind : ekind;
em_pred : bool;

}

val decompile_match_with : 
  [< `Enum | `List of 'b | `Option of 'c | `Or of 'd ] ->
  (A.pattern * 'a) list ->
  [> `List of (A.lident * A.lident * 'a) * 'a
  | `Option of (A.lident * 'a) * 'a
  | `Or of (A.lident * 'a) * (A.lident * 'a) ]
    option

type capture = {

cp_global : bool;
cp_local : [ `Only of Ident.Sid.t | `Yes of (L.t * A.ptyp) Ident.Mid.t ref option ];

}

val capture0 : capture

val extend_capture : capture -> Ident.ident list -> capture

type pattern = [

| `Enum
| `List of A.ptyp
| `Option of A.ptyp
| `Or of A.ptyp * A.ptyp

]

val parse_archetype : string -> ParseTree.archetype option

val for_xexpr : 
  emode_t ->
  ?autoview:bool ->
  ?capture:capture ->
  env ->
  ?ety:A.ptyp ->
  PT.expr ->
  A.pterm_node A.struct_poly

val cast_expr : 
  ?autoview:bool ->
  env ->
  A.ptyp option ->
  A.pterm_node A.struct_poly ->
  A.pterm

val join_expr : 
  ?autoview:bool ->
  env ->
  A.ptyp option ->
  A.pterm_node A.struct_poly list ->
  A.type_ option * A.pterm list

val for_gen_matchwith : 
  emode_t ->
  capture ->
  env ->
  Location.t ->
  PT.expr ->
  PT.branch list ->
  (pattern
   * ctordecl list
   * A.pterm
   * (int option * int option Tools.Mstr.t * (A.lident * A.ptyp) list list)
   * PT.expr list)
    option

val for_asset_expr : 
  emode_t ->
  env ->
  PT.expr ->
  A.pterm_node A.struct_poly * Env.asset option

val for_asset_collection_expr : 
  emode_t ->
  env ->
  [ `Parsed of PT.expr | `Typed of A.pterm_node A.struct_poly ] ->
  A.pterm * (assetdecl * A.container) option

val select_mop : 
  Ident.ident ->
  A.ptyp list ->
  A.pterm_node A.struct_poly list ->
  opinfo ->
  (int * (A.const * bool * (A.ptyp list * A.ptyp))) option

val for_api_call : 
  mode:emode_t ->
  ?autoview:bool ->
  ?capture:capture ->
  env ->
  ([< `Parsed of PT.expr | `Typed of A.pterm_node A.struct_poly Typed ]
   * PT.lident
   * PT.expr list) ->
  (A.pterm * (A.const * bool * (A.ptyp list * A.ptyp)) * A.pterm list) option

val for_gen_method_call : 
  emode_t ->
  env ->
  Location.t ->
  ([ `Parsed of PT.expr | `Typed of A.pterm_node A.struct_poly ]
   * PT.lident
   * PT.expr list) ->
  (A.pterm
   * (assetdecl * A.container)
   * method_
   * A.pterm_arg list
   * A.type_ Tools.Mint.t)
    option

val for_arg_effect : 
  emode_t ->
  env ->
  update:bool ->
  assetdecl ->
  PT.expr ->
  (A.lident * A.operator * A.pterm) list option

val for_assign_expr : 
  ?autoview:bool ->
  ?asset:bool ->
  ?t:A.ptyp ->
  emode_t ->
  env ->
  Location.t ->
  (A.assignment_operator * A.ptyp * A.ptyp) ->
  PT.expr ->
  A.pterm

val for_role : env -> PT.lident -> PT.lident option

val for_expr : 
  ekind ->
  ?autoview:bool ->
  env ->
  ?ety:A.type_ ->
  PT.expr ->
  A.pterm

val for_rf : 
  ekind ->
  ?ety:A.ptyp ->
  env ->
  (PT.lident * PT.expr * PT.expr option) list ->
  env * (A.lident option * A.pterm * A.pterm option) list

val for_rfs : 
  ekind ->
  env ->
  (PT.lident * PT.expr * PT.expr option) list ->
  env * (A.lident option * A.pterm * A.pterm option) list

val for_cf : 
  ekind ->
  ?ety:A.ptyp ->
  env ->
  (PT.lident * PT.expr * PT.expr option) list ->
  env * (A.lident option * A.pterm * A.pterm option) list

val for_cfs : 
  ekind ->
  ?ety:A.ptyp ->
  env ->
  (PT.lident * PT.expr * PT.expr option) list ->
  env * (A.lident option * A.pterm * A.pterm option) list

val for_arg_decl : 
  ?can_asset:bool ->
  env ->
  PT.lident_typ ->
  env * (PT.lident * A.ptyp) option

val for_args_decl : 
  ?can_asset:bool ->
  env ->
  PT.args ->
  env * (PT.lident * A.ptyp) option list

val for_lvalue : ekind -> env -> PT.expr -> env * (A.lvalue * A.ptyp) option

val for_instruction_r : 
  ret:A.type_ option ->
  ekind ->
  env ->
  PT.expr ->
  env * A.instruction

val for_instruction : 
  ret:A.type_ option ->
  ekind ->
  env ->
  PT.expr ->
  env * A.instruction

val for_effect : 
  ret:A.type_ option ->
  ekind ->
  env ->
  PT.expr ->
  Env.t * (env * A.instruction)

val for_named_state : 
  ?enum:Ident.ident ->
  env ->
  PT.lident ->
  Ident.ident Location.loced

val for_state_formula : ?enum:Ident.ident -> env -> PT.expr -> A.sexpr

val named_sig_compatible : 
  ('a Location.loced * A.ptyp) option list ->
  ('a Location.loced * A.ptyp) option list ->
  bool

val for_function : 
  env ->
  PT.s_function Location.loced ->
  Env.t * fundecl option

val for_callby : 
  env ->
  [< `Called | `Sourced ] ->
  PT.expr ->
  A.pterm_node A.struct_poly option Location.loced list

val for_entry : 
  env ->
  PT.entry_properties ->
  PT.expr option ->
  PT.type_t option ->
  env
  * (A.ptyp option
     * (A.pterm_node A.struct_poly option Location.loced list option
        * A.pterm option)
     * (A.pterm_node A.struct_poly option Location.loced list option
        * A.pterm option)
     * (Ident.ident Location.loced * A.pterm option) option
     * (bool * A.pterm option)
     * (A.lident option * A.pterm * A.pterm option) list option
     * (A.lident option * A.pterm * A.pterm option) list option
     * (A.lident option * A.pterm * A.pterm option) list option
     * fundecl option list
     * A.instruction option)

val for_transition : 
  ?enum:Ident.ident ->
  env ->
  (PT.lident * PT.expr option * PT.expr option) ->
  env * txeffect

type enum_core = (PT.lident * PT.type_t list * PT.enum_option list) list

val for_core_enum_decl : 
  env ->
  enum_core Location.loced ->
  env * (Ident.ident * (PT.lident * A.ptyp list) list) option

val for_enum_decl : 
  env ->
  (PT.lident * PT.enum_decl) Location.loced ->
  env * statedecl option

val for_enums_decl : 
  env ->
  (PT.lident * PT.enum_decl) Location.loced list ->
  env * statedecl option list

val for_var_decl : 
  env ->
  PT.variable_decl Location.loced ->
  env * vardecl option

val for_vardecl_init : 
  env ->
  PT.variable_decl Location.loced ->
  env * vardecl option

val for_vardecls_init : 
  env ->
  PT.variable_decl Location.loced list ->
  env * vardecl option list

val for_vars_decl : 
  env ->
  PT.variable_decl Location.loced list ->
  env * vardecl option list

val for_fun_decl : 
  env ->
  PT.s_function Location.loced ->
  Env.t * fundecl option

val for_funs_decl : 
  env ->
  PT.s_function Location.loced list ->
  env * fundecl option list

type pre_assetdecl = {

pas_name : A.lident;
pas_fields : (string * A.ptyp * PT.expr option) Location.loced list;
pas_pkty : A.ptyp;
pas_pk : A.lident list;
pas_sortk : A.lident list;
pas_bm : A.map_kind;
pas_init : PT.expr list;

}

val for_asset_decl : 
  Ident.ident list ->
  env ->
  (assetdecl * PT.asset_decl Location.loced) ->
  Env.t * pre_assetdecl option

val for_assets_decl : 
  env ->
  PT.asset_decl Location.loced list ->
  env * assetdecl option list

val for_record_decl : 
  [< `Event | `Record ] ->
  env ->
  PT.record_decl Location.loced ->
  env * recorddecl option

val for_records_decl : 
  env ->
  PT.record_decl Location.loced list ->
  env * recorddecl option list

val for_events_decl : 
  env ->
  PT.record_decl Location.loced list ->
  env * recorddecl option list

val for_acttx_decl : env -> acttx Location.loced -> Env.t * tentrydecl option

val for_acttxs_decl : 
  env ->
  acttx Location.loced list ->
  env * tentrydecl option list

val group_declarations : PT.declaration list -> groups

type decls = {

state : statedecl option;
variables : vardecl option list;
enums : statedecl option list;
records : recorddecl option list;
events : recorddecl option list;
assets : assetdecl option list;
functions : fundecl option list;
acttxs : tentrydecl option list;

}

val enums_of_statedecl : statedecl list -> A.enum list

val assets_of_adecls : assetdecl option list -> A.asset list

val records_of_rdecls : recorddecl list -> A.record list

val variables_of_vdecls : vardecl option list -> A.variable list

val functions_of_fdecls : fundecl option list -> A.function_ list

val transentrys_of_tdecls : tentrydecl option list -> A.transaction list

val for_parameters : 
  ?init:PT.expr_unloc Location.loced ->
  env ->
  (A.lident * PT.type_t * PT.expr option * bool) Location.loced list
    Location.loced
    option ->
  env * A.parameter list

val sort_decl : Tools.String.t list -> A.decl_ list -> A.decl_ list

val for_import_decl : 
  env ->
  (PT.lident option * PT.lident) Location.loced list ->
  env

val for_grouped_declarations : env -> (L.t * groups) -> env * decls

val get_arl_header : 
  PT.archetype_unloc Location.loced ->
  ((PT.lident * PT.parameters * PT.metadata option) * PT.declaration list)
    option

val for_declarations : 
  ?init:PT.expr_unloc Location.loced ->
  env ->
  PT.archetype_unloc Location.loced ->
  env * A.ast

val pretype : env -> PT.archetype_unloc -> env

val typing : 
  ?init:PT.expr_unloc Location.loced ->
  (A.lident -> env) ->
  ParseTree.archetype ->
  env * A.ast

package archetype