From b41a59d2cf2ff5e5c72b6131f2a77e617cfad7a8 Mon Sep 17 00:00:00 2001 From: Pierre-Emmanuel Wulfman Date: Fri, 3 Apr 2020 17:39:48 +0200 Subject: [PATCH] ast-imperative --- .../2-concrete_to_imperative/cameligo.ml | 14 +- .../2-concrete_to_imperative/pascaligo.ml | 12 +- .../imperative_to_sugar.ml | 2 +- src/stages/1-ast_imperative/combinators.ml | 127 ++++++++---------- src/stages/1-ast_imperative/combinators.mli | 75 ++++++----- 5 files changed, 113 insertions(+), 117 deletions(-) diff --git a/src/passes/2-concrete_to_imperative/cameligo.ml b/src/passes/2-concrete_to_imperative/cameligo.ml index 371e0c784..0fea68765 100644 --- a/src/passes/2-concrete_to_imperative/cameligo.ml +++ b/src/passes/2-concrete_to_imperative/cameligo.ml @@ -294,7 +294,7 @@ let rec compile_expression : | Component index -> Z.to_string (snd index.value) in List.map aux @@ npseq_to_list path in - return @@ List.fold_left (e_accessor ~loc ) var path' + return @@ List.fold_left (e_record_accessor ~loc ) var path' in let compile_path : Raw.path -> string * label list = fun p -> match p with @@ -319,7 +319,7 @@ let rec compile_expression : let record = match path with | [] -> e_variable (Var.of_name name) | _ -> - let aux expr (Label l) = e_accessor expr l in + let aux expr (Label l) = e_record_accessor expr l in List.fold_left aux (e_variable (Var.of_name name)) path in let updates = u.updates.value.ne_elements in let%bind updates' = @@ -333,10 +333,10 @@ let rec compile_expression : let aux ur (path, expr) = let rec aux record = function | [] -> failwith "error in parsing" - | hd :: [] -> ok @@ e_update ~loc record hd expr + | hd :: [] -> ok @@ e_record_update ~loc record hd expr | hd :: tl -> - let%bind expr = (aux (e_accessor ~loc record hd) tl) in - ok @@ e_update ~loc record hd expr + let%bind expr = (aux (e_record_accessor ~loc record hd) tl) in + ok @@ e_record_update ~loc record hd expr in aux ur path in bind_fold_list aux record updates' @@ -384,11 +384,11 @@ let rec compile_expression : | hd :: [] -> if (List.length prep_vars = 1) then e_let_in hd inline rhs_b_expr body - else e_let_in hd inline (e_accessor rhs_b_expr (string_of_int ((List.length prep_vars) - 1))) body + else e_let_in hd inline (e_record_accessor rhs_b_expr (string_of_int ((List.length prep_vars) - 1))) body | hd :: tl -> e_let_in hd inline - (e_accessor rhs_b_expr (string_of_int ((List.length prep_vars) - (List.length tl) - 1))) + (e_record_accessor rhs_b_expr (string_of_int ((List.length prep_vars) - (List.length tl) - 1))) (chain_let_in tl body) | [] -> body (* Precluded by corner case assertion above *) in diff --git a/src/passes/2-concrete_to_imperative/pascaligo.ml b/src/passes/2-concrete_to_imperative/pascaligo.ml index 2eb055351..8a224f69b 100644 --- a/src/passes/2-concrete_to_imperative/pascaligo.ml +++ b/src/passes/2-concrete_to_imperative/pascaligo.ml @@ -220,7 +220,7 @@ let compile_projection : Raw.projection Region.reg -> _ = fun p -> | Component index -> (Z.to_string (snd index.value)) in List.map aux @@ npseq_to_list path in - ok @@ List.fold_left (e_accessor ~loc) var path' + ok @@ List.fold_left (e_record_accessor ~loc) var path' let rec compile_expression (t:Raw.expr) : expr result = @@ -423,10 +423,10 @@ and compile_update = fun (u:Raw.update Region.reg) -> let aux ur (path, expr) = let rec aux record = function | [] -> failwith "error in parsing" - | hd :: [] -> ok @@ e_update ~loc record hd expr + | hd :: [] -> ok @@ e_record_update ~loc record hd expr | hd :: tl -> - let%bind expr = (aux (e_accessor ~loc record hd) tl) in - ok @@ e_update ~loc record hd expr + let%bind expr = (aux (e_record_accessor ~loc record hd) tl) in + ok @@ e_record_update ~loc record hd expr in aux ur path in bind_fold_list aux record updates' @@ -614,7 +614,7 @@ and compile_fun_decl : let%bind tpl_declarations = let aux = fun i (param, type_expr) -> let expr = - e_accessor (e_variable arguments_name) (string_of_int i) in + e_record_accessor (e_variable arguments_name) (string_of_int i) in let type_variable = Some type_expr in let ass = return_let_in (Var.of_name param , type_variable) inline expr in ass @@ -677,7 +677,7 @@ and compile_fun_expression : (arguments_name , type_expression) in let%bind tpl_declarations = let aux = fun i (param, param_type) -> - let expr = e_accessor (e_variable arguments_name) (string_of_int i) in + let expr = e_record_accessor (e_variable arguments_name) (string_of_int i) in let type_variable = Some param_type in let ass = return_let_in (Var.of_name param , type_variable) false expr in ass diff --git a/src/passes/4-imperative_to_sugar/imperative_to_sugar.ml b/src/passes/4-imperative_to_sugar/imperative_to_sugar.ml index cfcc6b26e..7d0a531b7 100644 --- a/src/passes/4-imperative_to_sugar/imperative_to_sugar.ml +++ b/src/passes/4-imperative_to_sugar/imperative_to_sugar.ml @@ -612,7 +612,7 @@ and uncompile_type_operator : O.type_operator -> I.type_operator result = let rec uncompile_expression : O.expression -> I.expression result = fun e -> - let return expr = ok @@ I.make_expr ~loc:e.location expr in + let return expr = ok @@ I.make_e ~loc:e.location expr in match e.expression_content with O.E_literal lit -> return @@ I.E_literal lit | O.E_constant {cons_name;arguments} -> diff --git a/src/stages/1-ast_imperative/combinators.ml b/src/stages/1-ast_imperative/combinators.ml index a71f5268e..595471fc5 100644 --- a/src/stages/1-ast_imperative/combinators.ml +++ b/src/stages/1-ast_imperative/combinators.ml @@ -74,67 +74,74 @@ let t_operator op lst: type_expression result = | TC_contract _ , [t] -> ok @@ t_contract t | _ , _ -> fail @@ bad_type_operator op -let make_expr ?(loc = Location.generated) expression_content = +let make_e ?(loc = Location.generated) expression_content = let location = loc in { expression_content; location } -let e_var ?loc (n: string) : expression = make_expr ?loc @@ E_variable (Var.of_name n) -let e_literal ?loc l : expression = make_expr ?loc @@ E_literal l -let e_unit ?loc () : expression = make_expr ?loc @@ E_literal (Literal_unit) -let e_int ?loc n : expression = make_expr ?loc @@ E_literal (Literal_int n) -let e_nat ?loc n : expression = make_expr ?loc @@ E_literal (Literal_nat n) -let e_timestamp ?loc n : expression = make_expr ?loc @@ E_literal (Literal_timestamp n) -let e_bool ?loc b : expression = make_expr ?loc @@ E_literal (Literal_bool b) -let e_string ?loc s : expression = make_expr ?loc @@ E_literal (Literal_string s) -let e_address ?loc s : expression = make_expr ?loc @@ E_literal (Literal_address s) -let e_mutez ?loc s : expression = make_expr ?loc @@ E_literal (Literal_mutez s) -let e_signature ?loc s : expression = make_expr ?loc @@ E_literal (Literal_signature s) -let e_key ?loc s : expression = make_expr ?loc @@ E_literal (Literal_key s) -let e_key_hash ?loc s : expression = make_expr ?loc @@ E_literal (Literal_key_hash s) -let e_chain_id ?loc s : expression = make_expr ?loc @@ E_literal (Literal_chain_id s) +let e_literal ?loc l : expression = make_e ?loc @@ E_literal l +let e_unit ?loc () : expression = make_e ?loc @@ E_literal (Literal_unit) +let e_int ?loc n : expression = make_e ?loc @@ E_literal (Literal_int n) +let e_nat ?loc n : expression = make_e ?loc @@ E_literal (Literal_nat n) +let e_timestamp ?loc n : expression = make_e ?loc @@ E_literal (Literal_timestamp n) +let e_bool ?loc b : expression = make_e ?loc @@ E_literal (Literal_bool b) +let e_string ?loc s : expression = make_e ?loc @@ E_literal (Literal_string s) +let e_address ?loc s : expression = make_e ?loc @@ E_literal (Literal_address s) +let e_mutez ?loc s : expression = make_e ?loc @@ E_literal (Literal_mutez s) +let e_signature ?loc s : expression = make_e ?loc @@ E_literal (Literal_signature s) +let e_key ?loc s : expression = make_e ?loc @@ E_literal (Literal_key s) +let e_key_hash ?loc s : expression = make_e ?loc @@ E_literal (Literal_key_hash s) +let e_chain_id ?loc s : expression = make_e ?loc @@ E_literal (Literal_chain_id s) let e'_bytes b : expression_content result = let%bind bytes = generic_try (simple_error "bad hex to bytes") (fun () -> Hex.to_bytes (`Hex b)) in ok @@ E_literal (Literal_bytes bytes) let e_bytes_hex ?loc b : expression result = let%bind e' = e'_bytes b in - ok @@ make_expr ?loc e' + ok @@ make_e ?loc e' let e_bytes_raw ?loc (b: bytes) : expression = - make_expr ?loc @@ E_literal (Literal_bytes b) + make_e ?loc @@ E_literal (Literal_bytes b) let e_bytes_string ?loc (s: string) : expression = - make_expr ?loc @@ E_literal (Literal_bytes (Hex.to_bytes (Hex.of_string s))) -let e_big_map ?loc lst : expression = make_expr ?loc @@ E_big_map lst -let e_some ?loc s : expression = make_expr ?loc @@ E_constant {cons_name = C_SOME; arguments = [s]} -let e_none ?loc () : expression = make_expr ?loc @@ E_constant {cons_name = C_NONE; arguments = []} -let e_string_cat ?loc sl sr : expression = make_expr ?loc @@ E_constant {cons_name = C_CONCAT; arguments = [sl ; sr ]} -let e_map_add ?loc k v old : expression = make_expr ?loc @@ E_constant {cons_name = C_MAP_ADD; arguments = [k ; v ; old]} -let e_map ?loc lst : expression = make_expr ?loc @@ E_map lst -let e_set ?loc lst : expression = make_expr ?loc @@ E_set lst -let e_list ?loc lst : expression = make_expr ?loc @@ E_list lst -let e_constructor ?loc s a : expression = make_expr ?loc @@ E_constructor { constructor = Constructor s; element = a} -let e_matching ?loc a b : expression = make_expr ?loc @@ E_matching {matchee=a;cases=b} -let e_matching_bool ?loc a b c : expression = e_matching ?loc a (Match_bool {match_true = b ; match_false = c}) -let e_record_accessor ?loc a b = make_expr ?loc @@ E_record_accessor {record = a; path = Label b} -let e_accessor ?loc a b = e_record_accessor ?loc a b -let e_accessor_list ?loc a b = List.fold_left (fun a b -> e_accessor ?loc a b) a b -let e_variable ?loc v = make_expr ?loc @@ E_variable v -let e_skip ?loc () = make_expr ?loc @@ E_skip -let e_let_in ?loc (binder, ascr) inline rhs let_result = - make_expr ?loc @@ E_let_in { let_binder = (binder, ascr) ; rhs ; let_result; inline } -let e_annotation ?loc anno_expr ty = make_expr ?loc @@ E_ascription {anno_expr; type_annotation = ty} -let e_application ?loc a b = make_expr ?loc @@ E_application {lamb=a ; args=b} -let e_binop ?loc name a b = make_expr ?loc @@ E_constant {cons_name = name ; arguments = [a ; b]} -let e_constant ?loc name lst = make_expr ?loc @@ E_constant {cons_name=name ; arguments = lst} -let e_look_up ?loc x y = make_expr ?loc @@ E_look_up (x , y) -let e_sequence ?loc expr1 expr2 = make_expr ?loc @@ E_sequence {expr1; expr2} + make_e ?loc @@ E_literal (Literal_bytes (Hex.to_bytes (Hex.of_string s))) +let e_some ?loc s : expression = make_e ?loc @@ E_constant {cons_name = C_SOME; arguments = [s]} +let e_none ?loc () : expression = make_e ?loc @@ E_constant {cons_name = C_NONE; arguments = []} +let e_string_cat ?loc sl sr : expression = make_e ?loc @@ E_constant {cons_name = C_CONCAT; arguments = [sl ; sr ]} +let e_map_add ?loc k v old : expression = make_e ?loc @@ E_constant {cons_name = C_MAP_ADD; arguments = [k ; v ; old]} +let e_binop ?loc name a b = make_e ?loc @@ E_constant {cons_name = name ; arguments = [a ; b]} -let e_while ?loc condition body = make_expr ?loc @@ E_while {condition; body} -let e_for ?loc binder start final increment body = make_expr ?loc @@ E_for {binder;start;final;increment;body} -let e_for_each ?loc binder collection collection_type body = make_expr ?loc @@ E_for_each {binder;collection;collection_type;body} +let e_constant ?loc name lst = make_e ?loc @@ E_constant {cons_name=name ; arguments = lst} +let e_variable ?loc v = make_e ?loc @@ E_variable v +let e_application ?loc a b = make_e ?loc @@ E_application {lamb=a ; args=b} +let e_lambda ?loc binder input_type output_type result : expression = make_e ?loc @@ E_lambda {binder; input_type; output_type; result} +let e_recursive ?loc fun_name fun_type lambda = make_e ?loc @@ E_recursive {fun_name; fun_type; lambda} +let e_let_in ?loc (binder, ascr) inline rhs let_result = make_e ?loc @@ E_let_in { let_binder = (binder, ascr) ; rhs ; let_result; inline } + +let e_constructor ?loc s a : expression = make_e ?loc @@ E_constructor { constructor = Constructor s; element = a} +let e_matching ?loc a b : expression = make_e ?loc @@ E_matching {matchee=a;cases=b} + +let e_record_accessor ?loc a b = make_e ?loc @@ E_record_accessor {record = a; path = Label b} +let e_accessor_list ?loc a b = List.fold_left (fun a b -> e_record_accessor ?loc a b) a b +let e_record_update ?loc record path update = make_e ?loc @@ E_record_update {record; path=Label path; update} + +let e_annotation ?loc anno_expr ty = make_e ?loc @@ E_ascription {anno_expr; type_annotation = ty} + +let e_tuple ?loc lst : expression = make_e ?loc @@ E_tuple lst +let e_tuple_accessor ?loc tuple path : expression = make_e ?loc @@ E_tuple_accessor {tuple; path} +let e_tuple_update ?loc tuple path update : expression = make_e ?loc @@ E_tuple_update {tuple; path; update} + +let e_pair ?loc a b : expression = e_tuple ?loc [a;b] +let e_cond ?loc condition then_clause else_clause = make_e ?loc @@ E_cond {condition;then_clause;else_clause} +let e_sequence ?loc expr1 expr2 = make_e ?loc @@ E_sequence {expr1; expr2} +let e_skip ?loc () = make_e ?loc @@ E_skip + +let e_list ?loc lst : expression = make_e ?loc @@ E_list lst +let e_set ?loc lst : expression = make_e ?loc @@ E_set lst +let e_map ?loc lst : expression = make_e ?loc @@ E_map lst +let e_big_map ?loc lst : expression = make_e ?loc @@ E_big_map lst +let e_look_up ?loc x y = make_e ?loc @@ E_look_up (x , y) + +let e_while ?loc condition body = make_e ?loc @@ E_while {condition; body} +let e_for ?loc binder start final increment body = make_e ?loc @@ E_for {binder;start;final;increment;body} +let e_for_each ?loc binder collection collection_type body = make_e ?loc @@ E_for_each {binder;collection;collection_type;body} -let e_cond ?loc condition then_clause else_clause = make_expr ?loc @@ E_cond {condition;then_clause;else_clause} -(* -let e_assign ?loc a b c = location_wrap ?loc @@ E_assign (Var.of_name a , b , c) (* TODO handlethat*) -*) let ez_match_variant (lst : ((string * string) * 'a) list) = let lst = List.map (fun ((c,n),a) -> ((Constructor c, Var.of_name n), a) ) lst in Match_variant (lst,()) @@ -142,18 +149,12 @@ let e_matching_variant ?loc a (lst : ((string * string)* 'a) list) = e_matching ?loc a (ez_match_variant lst) let e_record_ez ?loc (lst : (string * expr) list) : expression = let map = List.fold_left (fun m (x, y) -> LMap.add (Label x) y m) LMap.empty lst in - make_expr ?loc @@ E_record map + make_e ?loc @@ E_record map let e_record ?loc map = let lst = Map.String.to_kv_list map in e_record_ez ?loc lst -let e_record_update ?loc record path update = - let path = Label path in - make_expr ?loc @@ E_record_update {record; path; update} -let e_update ?loc record path update = e_record_update ?loc record path update -let e_tuple ?loc lst : expression = make_expr ?loc @@ E_tuple lst -let e_pair ?loc a b : expression = e_tuple ?loc [a;b] let make_option_typed ?loc e t_opt = match t_opt with @@ -175,22 +176,10 @@ let e_typed_big_map ?loc lst k v = e_annotation ?loc (e_big_map lst) (t_big_map let e_typed_set ?loc lst k = e_annotation ?loc (e_set lst) (t_set k) -let e_lambda ?loc (binder : expression_variable) - (input_type : type_expression option) - (output_type : type_expression option) - (result : expression) - : expression = - make_expr ?loc @@ E_lambda { - binder = binder ; - input_type = input_type ; - output_type = output_type ; - result ; - } -let e_recursive ?loc fun_name fun_type lambda = make_expr ?loc @@ E_recursive {fun_name; fun_type; lambda} let e_assign ?loc variable access_path expression = - make_expr ?loc @@ E_assign {variable;access_path;expression} + make_e ?loc @@ E_assign {variable;access_path;expression} let e_ez_assign ?loc variable access_path expression = let variable = Var.of_name variable in let access_path = List.map (fun s -> Access_record s) access_path in diff --git a/src/stages/1-ast_imperative/combinators.mli b/src/stages/1-ast_imperative/combinators.mli index 3d0ae94b9..b28bc4494 100644 --- a/src/stages/1-ast_imperative/combinators.mli +++ b/src/stages/1-ast_imperative/combinators.mli @@ -46,8 +46,8 @@ val t_map : type_expression -> type_expression -> type_expression val t_operator : type_operator -> type_expression list -> type_expression result val t_set : type_expression -> type_expression -val make_expr : ?loc:Location.t -> expression_content -> expression -val e_var : ?loc:Location.t -> string -> expression +val make_e : ?loc:Location.t -> expression_content -> expression + val e_literal : ?loc:Location.t -> literal -> expression val e_unit : ?loc:Location.t -> unit -> expression val e_int : ?loc:Location.t -> int -> expression @@ -65,36 +65,55 @@ val e'_bytes : string -> expression_content result val e_bytes_hex : ?loc:Location.t -> string -> expression result val e_bytes_raw : ?loc:Location.t -> bytes -> expression val e_bytes_string : ?loc:Location.t -> string -> expression -val e_big_map : ?loc:Location.t -> ( expr * expr ) list -> expression -val e_record_ez : ?loc:Location.t -> ( string * expr ) list -> expression -val e_tuple : ?loc:Location.t -> expression list -> expression +val e_binop : ?loc:Location.t -> constant' -> expression -> expression -> expression val e_some : ?loc:Location.t -> expression -> expression val e_none : ?loc:Location.t -> unit -> expression val e_string_cat : ?loc:Location.t -> expression -> expression -> expression val e_map_add : ?loc:Location.t -> expression -> expression -> expression -> expression -val e_map : ?loc:Location.t -> ( expression * expression ) list -> expression -val e_set : ?loc:Location.t -> expression list -> expression -val e_list : ?loc:Location.t -> expression list -> expression -val e_pair : ?loc:Location.t -> expression -> expression -> expression + +val e_constant : ?loc:Location.t -> constant' -> expression list -> expression +val e_variable : ?loc:Location.t -> expression_variable -> expression +val e_application : ?loc:Location.t -> expression -> expression -> expression +val e_lambda : ?loc:Location.t -> expression_variable -> type_expression option -> type_expression option -> expression -> expression +val e_recursive : ?loc:Location.t -> expression_variable -> type_expression -> lambda -> expression +val e_let_in : ?loc:Location.t -> ( expression_variable * type_expression option ) -> bool -> expression -> expression -> expression + val e_constructor : ?loc:Location.t -> string -> expression -> expression val e_matching : ?loc:Location.t -> expression -> matching_expr -> expression -val e_matching_bool : ?loc:Location.t -> expression -> expression -> expression -> expression -val e_accessor : ?loc:Location.t -> expression -> string -> expression -val e_accessor_list : ?loc:Location.t -> expression -> string list -> expression -val e_variable : ?loc:Location.t -> expression_variable -> expression -val e_skip : ?loc:Location.t -> unit -> expression -val e_sequence : ?loc:Location.t -> expression -> expression -> expression -val e_cond: ?loc:Location.t -> expression -> expression -> expression -> expression -val e_let_in : ?loc:Location.t -> ( expression_variable * type_expression option ) -> bool -> expression -> expression -> expression -val e_annotation : ?loc:Location.t -> expression -> type_expression -> expression -val e_application : ?loc:Location.t -> expression -> expression -> expression -val e_binop : ?loc:Location.t -> constant' -> expression -> expression -> expression -val e_constant : ?loc:Location.t -> constant' -> expression list -> expression -val e_look_up : ?loc:Location.t -> expression -> expression -> expression val ez_match_variant : ((string * string ) * 'a ) list -> ('a,unit) matching_content val e_matching_variant : ?loc:Location.t -> expression -> ((string * string) * expression) list -> expression +val e_record : ?loc:Location.t -> expr Map.String.t -> expression +val e_record_ez : ?loc:Location.t -> ( string * expr ) list -> expression +val e_record_accessor : ?loc:Location.t -> expression -> string -> expression +val e_accessor_list : ?loc:Location.t -> expression -> string list -> expression +val e_record_update : ?loc:Location.t -> expression -> string -> expression -> expression + +val e_annotation : ?loc:Location.t -> expression -> type_expression -> expression + +val e_tuple : ?loc:Location.t -> expression list -> expression +val e_tuple_accessor : ?loc:Location.t -> expression -> int -> expression +val e_tuple_update : ?loc:Location.t -> expression -> int -> expression -> expression +val e_pair : ?loc:Location.t -> expression -> expression -> expression + +val e_cond: ?loc:Location.t -> expression -> expression -> expression -> expression +val e_sequence : ?loc:Location.t -> expression -> expression -> expression +val e_skip : ?loc:Location.t -> unit -> expression + +val e_list : ?loc:Location.t -> expression list -> expression +val e_set : ?loc:Location.t -> expression list -> expression +val e_map : ?loc:Location.t -> ( expression * expression ) list -> expression +val e_big_map : ?loc:Location.t -> ( expr * expr ) list -> expression +val e_look_up : ?loc:Location.t -> expression -> expression -> expression + +val e_assign : ?loc:Location.t -> expression_variable -> access list -> expression -> expression +val e_ez_assign : ?loc:Location.t -> string -> string list -> expression -> expression + +val e_while : ?loc:Location.t -> expression -> expression -> expression +val e_for : ?loc:Location.t -> expression_variable -> expression -> expression -> expression -> expression -> expression +val e_for_each : ?loc:Location.t -> expression_variable * expression_variable option -> expression -> collect_type -> expression -> expression + val make_option_typed : ?loc:Location.t -> expression -> type_expression option -> expression val e_typed_none : ?loc:Location.t -> type_expression -> expression @@ -107,19 +126,7 @@ val e_typed_big_map : ?loc:Location.t -> ( expression * expression ) list -> ty val e_typed_set : ?loc:Location.t -> expression list -> type_expression -> expression -val e_lambda : ?loc:Location.t -> expression_variable -> type_expression option -> type_expression option -> expression -> expression -val e_recursive : ?loc:Location.t -> expression_variable -> type_expression -> lambda -> expression -val e_record : ?loc:Location.t -> expr Map.String.t -> expression -val e_update : ?loc:Location.t -> expression -> string -> expression -> expression -val e_assign : ?loc:Location.t -> expression_variable -> access list -> expression -> expression -val e_ez_assign : ?loc:Location.t -> string -> string list -> expression -> expression -(* -val get_e_accessor : expression' -> ( expression * access_path ) result -*) -val e_while : ?loc:Location.t -> expression -> expression -> expression -val e_for : ?loc:Location.t -> expression_variable -> expression -> expression -> expression -> expression -> expression -val e_for_each : ?loc:Location.t -> expression_variable * expression_variable option -> expression -> collect_type -> expression -> expression val assert_e_accessor : expression_content -> unit result