Lam (melange.Lam)

type apply_status =

| App_na
| App_infer_full
| App_uncurry

;

type ap_info = {

ap_loc: Melange_compiler_libs.Location.t,
ap_inlined: Melange_compiler_libs.Lambda.inline_attribute,
ap_status: apply_status,

};

type ident = Ident.t;

type lambda_switch = {

sw_consts_full: bool,
sw_consts: list((int, t)),
sw_blocks_full: bool,
sw_blocks: list((int, t)),
sw_failaction: option(t),
sw_names: option(Melange_compiler_libs.Lambda.switch_names),

};

and apply = pri {

ap_func: t,
ap_args: list(t),
ap_info: ap_info,

};

and lfunction = {

arity: int,
params: list(ident),
body: t,
attr: Melange_compiler_libs.Lambda.function_attribute,

};

and prim_info = pri {

primitive: Lam_primitive.t,
args: list(t),
loc: Melange_compiler_libs.Location.t,

};

and t = pri

| Lvar(ident)
| Lmutvar(ident)
| Lglobal_module(ident)
| Lconst(Lam_constant.t)
| Lapply(apply)
| Lfunction(lfunction)
| Llet(Lam_compat.let_kind, ident, t, t)
| Lmutlet(ident, t, t)
| Lletrec(list((ident, t)), t)
| Lprim(prim_info)
| Lswitch(t, lambda_switch)
| Lstringswitch(t, list((string, t)), option(t))
| Lstaticraise(int, list(t))
| Lstaticcatch(t, (int, list(ident)), t)
| Ltrywith(t, ident, t)
| Lifthenelse(t, t, t)
| Lsequence(t, t)
| Lwhile(t, t)
| Lfor(ident, t, t, Asttypes.direction_flag, t)
| Lassign(ident, t)
| Lsend(Melange_compiler_libs.Lambda.meth_kind, t, t, list(t), Melange_compiler_libs.Location.t)
| Lifused(ident, t)

;

let inner_map: t => (t => t) => t;

let handle_bs_non_obj_ffi: 
  External_arg_spec.params =>
  External_ffi_types.return_wrapper =>
  External_ffi_types.external_spec =>
  list(t) =>
  Melange_compiler_libs.Location.t =>
  string =>
  t;

let var: ident => t;

Smart constructors

let mutvar: ident => t;

let global_module: ident => t;

let const: Lam_constant.t => t;

let apply: t => list(t) => ap_info => t;

let function_: 
  attr:Melange_compiler_libs.Lambda.function_attribute =>
  arity:int =>
  params:list(ident) =>
  body:t =>
  t;

let let_: Lam_compat.let_kind => ident => t => t => t;

let mutlet: ident => t => t => t;

let letrec: list((ident, t)) => t => t;

let if_: t => t => t => t;

constant folding

let switch: t => lambda_switch => t;

constant folding

let stringswitch: t => list((string, t)) => option(t) => t;

constant folding

let false_: t;

let unit: t;

let sequor: t => t => t;

convert l || r to if l then true else r

let sequand: t => t => t;

convert l && r to if l then r else false

let not_: Melange_compiler_libs.Location.t => t => t;

constant folding

let seq: t => t => t;

drop unused block

let while_: t => t => t;

let try_: t => ident => t => t;

let ifused: ident => t => t;

let assign: ident => t => t;

let send: 
  Melange_compiler_libs.Lambda.meth_kind =>
  t =>
  t =>
  list(t) =>
  Melange_compiler_libs.Location.t =>
  t;

let prim: 
  primitive:Lam_primitive.t =>
  args:list(t) =>
  Melange_compiler_libs.Location.t =>
  t;

constant folding

let staticcatch: t => (int, list(ident)) => t => t;

let staticraise: int => list(t) => t;

let for_: ident => t => t => Asttypes.direction_flag => t => t;

let eq_approx: t => t => bool;