Module Ast_builder.Make

Parameters

module Loc : Loc

Signature

module Located : sig ... end
include sig ... end
val loc : Location.t
val pdir_int : string -> char option -> Migrate_parsetree.Ast_408.Parsetree.directive_argument
val location : start:Stdlib.Lexing.position -> end_:Stdlib.Lexing.position -> ghost:bool -> Warnings.loc
val position : fname:string -> lnum:int -> bol:int -> cnum:int -> Stdlib.Lexing.position
val eint : 'a
val echar : 'a
val estring : 'a
val efloat : 'a
val eint32 : 'a
val eint64 : 'a
val enativeint : 'a
val ebool : 'a
val pint : 'a
val pchar : 'a
val pstring : 'a
val pfloat : 'a
val pint32 : 'a
val pint64 : 'a
val pnativeint : 'a
val pbool : 'a
val eunit : 'a
val punit : 'a
val evar : 'a

evar id produces a Pexp_ident _ expression, it parses its input so you can pass any dot-separated identifier, for instance: evar ~loc "Foo.bar".

val pvar : 'a
val eapply : 'a

Same as pexp_apply but without labels

val eabstract : 'a
val esequence : 'a
val ppat_tuple_opt : 'a
val pexp_tuple_opt : 'a
val elist : 'a
val plist : 'a

pstr_value_list ~loc rf vbs = pstr_value ~loc rf vbs if vbs <> [], [] otherwise.

val nonrec_type_declaration : 'a
val unapplied_type_constr_conv : 'a

unapplied_type_constr_conv is the standard way to map identifiers to conversion fonctions, for preprocessor that creates values that follow the structure of types. More precisely, path_conv path (sprintf "sexp_of_%s") is:

  • sexp_of_t if path is "t"
  • A.B.sexp_of_foo if path is "A.B.foo"
  • A.B.sexp_of_f__foo (module A1) (module A2) if path is "A.B.F(A1)(A2).foo" type_constr_conv also applies it to a list of expression, which both prevents the compiler from allocating useless closures, and almost always what is needed, since type constructors are always applied.
val type_constr_conv : 'a

Tries to simplify fun v1 v2 .. -> f v1 v2 .. into f. Only works when f is a path, not an arbitrary expression as that would change the meaning of the code. This can be used either for cleaning up the generated code, or to reduce allocation if f is a local variable (the compiler won't optimize the allocation of the closure).

Eta-reduction can change the types/behavior in some corner cases that are unlikely to show up in generated code:

  • if f has optional arguments, eta-expanding f can drop them
  • because labels commute, it can change the type of an expression: $ let f ~x y = x + y let f2 = fun x -> add x;; val f : x:int -> int -> int = <fun> val f2 : int -> x:int -> int = <fun> In fact, if f does side effects before receiving all its arguments, and if the eta-expansion is partially applied, eta-reducing could change behavior.

eta_reduce_if_possible_and_nonrec is meant for the case where the resulting expression is going to be bound in a potentially recursive let-binding, where we have to keep the eta-expansion when rec_flag is Recursive to avoid a compile error.