Module Melange_compiler_libs.Parsetree

Abstract syntax tree produced by parsing

Warning: this module is unstable and part of compiler-libs.

type constant =
  1. | Pconst_integer(string, option(char))
    /*

    Integer constants such as 3 3l 3L 3n.

    Suffixes [g-z][G-Z] are accepted by the parser. Suffixes except 'l', 'L' and 'n' are rejected by the typechecker

    */
  2. | Pconst_char(char)
    /*

    Character such as 'c'.

    */
  3. | Pconst_string(string, Location.t, option(string))
    /*

    Constant string such as "constant" or {delim|other constant|delim}.

    The location span the content of the string, without the delimiters.

    */
  4. | Pconst_float(string, option(char))
    /*

    Float constant such as 3.4, 2e5 or 1.4e-4.

    Suffixes g-zG-Z are accepted by the parser. Suffixes are rejected by the typechecker.

    */
;
type location_stack = list(Location.t);

Extension points

type attribute = {
  1. attr_name: Asttypes.loc(string),
  2. attr_payload: payload,
  3. attr_loc: Location.t,
};

Attributes such as [\@id ARG] and [\@\@id ARG].

Metadata containers passed around within the AST. The compiler ignores unknown attributes.

and extension = (Asttypes.loc(string), payload);

Extension points such as [%id ARG] and [%%id ARG].

Sub-language placeholder -- rejected by the typechecker.

and attributes = list(attribute);
and payload =
  1. | PStr(structure)
  2. | PSig(signature)
    /*

    : SIG in an attribute or an extension point

    */
  3. | PTyp(core_type)
    /*

    : T in an attribute or an extension point

    */
  4. | PPat(pattern, option(expression))
    /*

    ? P or ? P when E, in an attribute or an extension point

    */
;

Core language

Type expressions

and core_type = {
  1. ptyp_desc: core_type_desc,
  2. ptyp_loc: Location.t,
  3. ptyp_loc_stack: location_stack,
  4. ptyp_attributes: attributes,
    /*

    ... [\@id1] [\@id2]

    */
};
and core_type_desc =
  1. | Ptyp_any
    /*

    _

    */
  2. | Ptyp_var(string)
    /*

    A type variable such as 'a

    */
  3. | Ptyp_arrow(Asttypes.arg_label, core_type, core_type)
    /*

    Ptyp_arrow(lbl, T1, T2) represents:

    • T1 -> T2 when lbl is Nolabel,
    • ~l:T1 -> T2 when lbl is Labelled,
    • ?l:T1 -> T2 when lbl is Optional.
    */
  4. | Ptyp_tuple(list(core_type))
    /*

    Ptyp_tuple([T1 ; ... ; Tn]) represents a product type T1 * ... * Tn.

    Invariant: n >= 2.

    */
  5. | Ptyp_constr(Asttypes.loc(Longident.t), list(core_type))
    /*

    Ptyp_constr(lident, l) represents:

    • tconstr when l=[],
    • T tconstr when l=[T],
    • (T1, ..., Tn) tconstr when l=[T1 ; ... ; Tn].
    */
  6. | Ptyp_object(list(object_field), Asttypes.closed_flag)
    /*

    Ptyp_object([ l1:T1; ...; ln:Tn ], flag) represents:

    • < l1:T1; ...; ln:Tn > when flag is Closed,
    • < l1:T1; ...; ln:Tn; .. > when flag is Open.
    */
  7. | Ptyp_class(Asttypes.loc(Longident.t), list(core_type))
    /*

    Ptyp_class(tconstr, l) represents:

    • #tconstr when l=[],
    • T #tconstr when l=[T],
    • (T1, ..., Tn) #tconstr when l=[T1 ; ... ; Tn].
    */
  8. | Ptyp_alias(core_type, string)
    /*

    T as 'a.

    */
  9. | Ptyp_variant(list(row_field), Asttypes.closed_flag, option(list(Asttypes.label)))
    /*

    Ptyp_variant([`A;`B], flag, labels) represents:

    • [ `A|`B ] when flag is Closed, and labels is None,
    • [> `A|`B ] when flag is Open, and labels is None,
    • [< `A|`B ] when flag is Closed, and labels is Some [],
    • [< `A|`B > `X `Y ] when flag is Closed, and labels is Some ["X";"Y"].
    */
  10. | Ptyp_poly(list(Asttypes.loc(string)), core_type)
    /*

    'a1 ... 'an. T

    Can only appear in the following context:

    • As the core_type of a Ppat_constraint node corresponding to a constraint on a let-binding:

      let x : 'a1 ... 'an. T = e ...
    */
  11. | Ptyp_package(package_type)
    /*

    (module S).

    */
  12. | Ptyp_extension(extension)
    /*

    [%id].

    */
;
and package_type = (Asttypes.loc(Longident.t), list((Asttypes.loc(Longident.t), core_type)));

As package_type typed values:

  • (S, []) represents (module S),
  • (S, [(t1, T1) ; ... ; (tn, Tn)]) represents (module S with type t1 = T1 and ... and tn = Tn).
and row_field = {
  1. prf_desc: row_field_desc,
  2. prf_loc: Location.t,
  3. prf_attributes: attributes,
};
and row_field_desc =
  1. | Rtag(Asttypes.loc(Asttypes.label), bool, list(core_type))
    /*

    Rtag(`A, b, l) represents:

    • `A when b is true and l is [],
    • `A of T when b is false and l is [T],
    • `A of T1 & .. & Tn when b is false and l is [T1;...Tn],
    • `A of & T1 & .. & Tn when b is true and l is [T1;...Tn].
    • The bool field is true if the tag contains a constant (empty) constructor.
    • & occurs when several types are used for the same constructor (see 4.2 in the manual)
    */
  2. | Rinherit(core_type)
    /*

    [ | t ]

    */
;
and object_field = {
  1. pof_desc: object_field_desc,
  2. pof_loc: Location.t,
  3. pof_attributes: attributes,
};
and object_field_desc =
  1. | Otag(Asttypes.loc(Asttypes.label), core_type)
  2. | Oinherit(core_type)
;

Patterns

and pattern = {
  1. ppat_desc: pattern_desc,
  2. ppat_loc: Location.t,
  3. ppat_loc_stack: location_stack,
  4. ppat_attributes: attributes,
    /*

    ... [\@id1] [\@id2]

    */
};
and pattern_desc =
  1. | Ppat_any
    /*

    The pattern _.

    */
  2. | Ppat_var(Asttypes.loc(string))
    /*

    A variable pattern such as x

    */
  3. | Ppat_alias(pattern, Asttypes.loc(string))
    /*

    An alias pattern such as P as 'a

    */
  4. | Ppat_constant(constant)
    /*

    Patterns such as 1, 'a', "true", 1.0, 1l, 1L, 1n

    */
  5. | Ppat_interval(constant, constant)
    /*

    Patterns such as 'a'..'z'.

    Other forms of interval are recognized by the parser but rejected by the type-checker.

    */
  6. | Ppat_tuple(list(pattern))
    /*

    Patterns (P1, ..., Pn).

    Invariant: n >= 2

    */
  7. | Ppat_construct(Asttypes.loc(Longident.t), option((list(Asttypes.loc(string)), pattern)))
    /*

    Ppat_construct(C, args) represents:

    • C when args is None,
    • C P when args is Some ([], P)
    • C (P1, ..., Pn) when args is Some ([], Ppat_tuple [P1; ...; Pn])
    • C (type a b) P when args is Some ([a; b], P)
    */
  8. | Ppat_variant(Asttypes.label, option(pattern))
    /*

    Ppat_variant(`A, pat) represents:

    • `A when pat is None,
    • `A P when pat is Some P
    */
  9. | Ppat_record(list((Asttypes.loc(Longident.t), pattern)), Asttypes.closed_flag)
    /*

    Ppat_record([(l1, P1) ; ... ; (ln, Pn)], flag) represents:

    • { l1=P1; ...; ln=Pn } when flag is Closed
    • { l1=P1; ...; ln=Pn; _} when flag is Open

    Invariant: n > 0

    */
  10. | Ppat_array(list(pattern))
    /*

    Pattern [| P1; ...; Pn |]

    */
  11. | Ppat_or(pattern, pattern)
    /*

    Pattern P1 | P2

    */
  12. | Ppat_constraint(pattern, core_type)
    /*

    Pattern (P : T)

    */
  13. | Ppat_type(Asttypes.loc(Longident.t))
    /*

    Pattern #tconst

    */
  14. | Ppat_lazy(pattern)
    /*

    Pattern lazy P

    */
  15. | Ppat_unpack(Asttypes.loc(option(string)))
    /*

    Ppat_unpack(s) represents:

    • (module P) when s is Some "P"
    • (module _) when s is None

    Note: (module P : S) is represented as Ppat_constraint(Ppat_unpack(Some "P"), Ptyp_package S)

    */
  16. | Ppat_exception(pattern)
    /*

    Pattern exception P

    */
  17. | Ppat_extension(extension)
    /*

    Pattern [%id]

    */
  18. | Ppat_open(Asttypes.loc(Longident.t), pattern)
    /*

    Pattern M.(P)

    */
;

Value expressions

and expression = {
  1. pexp_desc: expression_desc,
  2. pexp_loc: Location.t,
  3. pexp_loc_stack: location_stack,
  4. pexp_attributes: attributes,
    /*

    ... [\@id1] [\@id2]

    */
};
and expression_desc =
  1. | Pexp_ident(Asttypes.loc(Longident.t))
    /*

    Identifiers such as x and M.x

    */
  2. | Pexp_constant(constant)
    /*

    Expressions constant such as 1, 'a', "true", 1.0, 1l, 1L, 1n

    */
  3. | Pexp_let(Asttypes.rec_flag, list(value_binding), expression)
    /*

    Pexp_let(flag, [(P1,E1) ; ... ; (Pn,En)], E) represents:

    • let P1 = E1 and ... and Pn = EN in E when flag is Nonrecursive,
    • let rec P1 = E1 and ... and Pn = EN in E when flag is Recursive.
    */
  4. | Pexp_function(list(case))
    /*

    function P1 -> E1 | ... | Pn -> En

    */
  5. | Pexp_fun(Asttypes.arg_label, option(expression), pattern, expression)
    /*

    Pexp_fun(lbl, exp0, P, E1) represents:

    • fun P -> E1 when lbl is Nolabel and exp0 is None
    • fun ~l:P -> E1 when lbl is Labelled l and exp0 is None
    • fun ?l:P -> E1 when lbl is Optional l and exp0 is None
    • fun ?l:(P = E0) -> E1 when lbl is Optional l and exp0 is Some E0

    Notes:

    • If E0 is provided, only Optional is allowed.
    • fun P1 P2 .. Pn -> E1 is represented as nested Pexp_fun.
    • let f P = E is represented using Pexp_fun.
    */
  6. | Pexp_apply(expression, list((Asttypes.arg_label, expression)))
    /*

    Pexp_apply(E0, [(l1, E1) ; ... ; (ln, En)]) represents E0 ~l1:E1 ... ~ln:En

    li can be Nolabel (non labeled argument), Labelled (labelled arguments) or Optional (optional argument).

    Invariant: n > 0

    */
  7. | Pexp_match(expression, list(case))
    /*

    match E0 with P1 -> E1 | ... | Pn -> En

    */
  8. | Pexp_try(expression, list(case))
    /*

    try E0 with P1 -> E1 | ... | Pn -> En

    */
  9. | Pexp_tuple(list(expression))
    /*

    Expressions (E1, ..., En)

    Invariant: n >= 2

    */
  10. | Pexp_construct(Asttypes.loc(Longident.t), option(expression))
    /*

    Pexp_construct(C, exp) represents:

    • C when exp is None,
    • C E when exp is Some E,
    • C (E1, ..., En) when exp is Some (Pexp_tuple[E1;...;En])
    */
  11. | Pexp_variant(Asttypes.label, option(expression))
    /*

    Pexp_variant(`A, exp) represents

    • `A when exp is None
    • `A E when exp is Some E
    */
  12. | Pexp_record(list((Asttypes.loc(Longident.t), expression)), option(expression))
    /*

    Pexp_record([(l1,P1) ; ... ; (ln,Pn)], exp0) represents

    • { l1=P1; ...; ln=Pn } when exp0 is None
    • { E0 with l1=P1; ...; ln=Pn } when exp0 is Some E0

    Invariant: n > 0

    */
  13. | Pexp_field(expression, Asttypes.loc(Longident.t))
    /*

    E.l

    */
  14. | Pexp_setfield(expression, Asttypes.loc(Longident.t), expression)
    /*

    E1.l <- E2

    */
  15. | Pexp_array(list(expression))
    /*

    [| E1; ...; En |]

    */
  16. | Pexp_ifthenelse(expression, expression, option(expression))
    /*

    if E1 then E2 else E3

    */
  17. | Pexp_sequence(expression, expression)
    /*

    E1; E2

    */
  18. | Pexp_while(expression, expression)
    /*

    while E1 do E2 done

    */
  19. | Pexp_for(pattern, expression, expression, Asttypes.direction_flag, expression)
    /*

    Pexp_for(i, E1, E2, direction, E3) represents:

    • for i = E1 to E2 do E3 done when direction is Upto
    • for i = E1 downto E2 do E3 done when direction is Downto
    */
  20. | Pexp_constraint(expression, core_type)
    /*

    (E : T)

    */
  21. | Pexp_coerce(expression, option(core_type), core_type)
    /*

    Pexp_coerce(E, from, T) represents

    • (E :> T) when from is None,
    • (E : T0 :> T) when from is Some T0.
    */
  22. | Pexp_send(expression, Asttypes.loc(Asttypes.label))
    /*

    E # m

    */
  23. | Pexp_new(Asttypes.loc(Longident.t))
    /*

    new M.c

    */
  24. | Pexp_setinstvar(Asttypes.loc(Asttypes.label), expression)
    /*

    x <- 2

    */
  25. | Pexp_override(list((Asttypes.loc(Asttypes.label), expression)))
    /*

    {< x1 = E1; ...; xn = En >}

    */
  26. | Pexp_letmodule(Asttypes.loc(option(string)), module_expr, expression)
    /*

    let module M = ME in E

    */
  27. | Pexp_letexception(extension_constructor, expression)
    /*

    let exception C in E

    */
  28. | Pexp_assert(expression)
    /*

    assert E.

    Note: assert false is treated in a special way by the type-checker.

    */
  29. | Pexp_lazy(expression)
    /*

    lazy E

    */
  30. | Pexp_poly(expression, option(core_type))
    /*

    Used for method bodies.

    Can only be used as the expression under Cfk_concrete for methods (not values).

    */
  31. | Pexp_object(class_structure)
    /*

    object ... end

    */
  32. | Pexp_newtype(Asttypes.loc(string), expression)
    /*

    fun (type t) -> E

    */
  33. | Pexp_pack(module_expr)
    /*

    (module ME).

    (module ME : S) is represented as Pexp_constraint(Pexp_pack ME, Ptyp_package S)

    */
  34. | Pexp_open(open_declaration, expression)
    /*
    • M.(E)
    • let open M in E
    • let open! M in E
    */
  35. | Pexp_letop(letop)
    /*
    • let* P = E0 in E1
    • let* P0 = E00 and* P1 = E01 in E1
    */
  36. | Pexp_extension(extension)
    /*

    [%id]

    */
  37. | Pexp_unreachable
    /*

    .

    */
;
and case = {
  1. pc_lhs: pattern,
  2. pc_guard: option(expression),
  3. pc_rhs: expression,
};

Values of type case represents (P -> E) or (P when E0 -> E)

and letop = {
  1. let_: binding_op,
  2. ands: list(binding_op),
  3. body: expression,
};
and binding_op = {
  1. pbop_op: Asttypes.loc(string),
  2. pbop_pat: pattern,
  3. pbop_exp: expression,
  4. pbop_loc: Location.t,
};

Value descriptions

and value_description = {
  1. pval_name: Asttypes.loc(string),
  2. pval_type: core_type,
  3. pval_prim: list(string),
  4. pval_attributes: attributes,
    /*

    ... [\@\@id1] [\@\@id2]

    */
  5. pval_loc: Location.t,
};

Values of type value_description represents:

  • val x: T, when pval_prim is []
  • external x: T = "s1" ... "sn" when pval_prim is ["s1";..."sn"]

Type declarations

and type_declaration = {
  1. ptype_name: Asttypes.loc(string),
  2. ptype_params: list((core_type, (Asttypes.variance, Asttypes.injectivity))),
    /*

    ('a1,...'an) t

    */
  3. ptype_cstrs: list((core_type, core_type, Location.t)),
    /*

    ... constraint T1=T1' ... constraint Tn=Tn'

    */
  4. ptype_kind: type_kind,
  5. ptype_private: Asttypes.private_flag,
    /*

    for = private ...

    */
  6. ptype_manifest: option(core_type),
    /*

    represents = T

    */
  7. ptype_attributes: attributes,
    /*

    ... [\@\@id1] [\@\@id2]

    */
  8. ptype_loc: Location.t,
};

Here are type declarations and their representation, for various ptype_kind and ptype_manifest values:

  • type t when type_kind is Ptype_abstract, and manifest is None,
  • type t = T0 when type_kind is Ptype_abstract, and manifest is Some T0,
  • type t = C of T | ... when type_kind is Ptype_variant, and manifest is None,
  • type t = T0 = C of T | ... when type_kind is Ptype_variant, and manifest is Some T0,
  • type t = {l: T; ...} when type_kind is Ptype_record, and manifest is None,
  • type t = T0 = {l : T; ...} when type_kind is Ptype_record, and manifest is Some T0,
  • type t = .. when type_kind is Ptype_open, and manifest is None.
and type_kind =
  1. | Ptype_abstract
  2. | Ptype_variant(list(constructor_declaration))
  3. | Ptype_record(list(label_declaration))
    /*

    Invariant: non-empty list

    */
  4. | Ptype_open
;
and label_declaration = {
  1. pld_name: Asttypes.loc(string),
  2. pld_mutable: Asttypes.mutable_flag,
  3. pld_type: core_type,
  4. pld_loc: Location.t,
  5. pld_attributes: attributes,
    /*

    l : T [\@id1] [\@id2]

    */
};

Note: T can be a Ptyp_poly.

and constructor_declaration = {
  1. pcd_name: Asttypes.loc(string),
  2. pcd_vars: list(Asttypes.loc(string)),
  3. pcd_args: constructor_arguments,
  4. pcd_res: option(core_type),
  5. pcd_loc: Location.t,
  6. pcd_attributes: attributes,
    /*

    C of ... [\@id1] [\@id2]

    */
};
and constructor_arguments =
  1. | Pcstr_tuple(list(core_type))
  2. | Pcstr_record(list(label_declaration))
    /*

    Values of type constructor_declaration represents the constructor arguments of:

    • C of T1 * ... * Tn when res = None, and args = Pcstr_tuple [T1; ... ; Tn],
    • C: T0 when res = Some T0, and args = Pcstr_tuple [],
    • C: T1 * ... * Tn -> T0 when res = Some T0, and args = Pcstr_tuple [T1; ... ; Tn],
    • C of {...} when res = None, and args = Pcstr_record [...],
    • C: {...} -> T0 when res = Some T0, and args = Pcstr_record [...].
    */
;
and type_extension = {
  1. ptyext_path: Asttypes.loc(Longident.t),
  2. ptyext_params: list((core_type, (Asttypes.variance, Asttypes.injectivity))),
  3. ptyext_constructors: list(extension_constructor),
  4. ptyext_private: Asttypes.private_flag,
  5. ptyext_loc: Location.t,
  6. ptyext_attributes: attributes,
    /*

    ... \@\@id1 \@\@id2

    */
};

Definition of new extensions constructors for the extensive sum type t (type t += ...).

and extension_constructor = {
  1. pext_name: Asttypes.loc(string),
  2. pext_kind: extension_constructor_kind,
  3. pext_loc: Location.t,
  4. pext_attributes: attributes,
    /*

    C of ... [\@id1] [\@id2]

    */
};
and type_exception = {
  1. ptyexn_constructor: extension_constructor,
  2. ptyexn_loc: Location.t,
  3. ptyexn_attributes: attributes,
    /*

    ... [\@\@id1] [\@\@id2]

    */
};

Definition of a new exception (exception E).

and extension_constructor_kind =
  1. | Pext_decl(list(Asttypes.loc(string)), constructor_arguments, option(core_type))
    /*

    Pext_decl(existentials, c_args, t_opt) describes a new extension constructor. It can be:

    • C of T1 * ... * Tn when:

      • existentials is [],
      • c_args is [T1; ...; Tn],
      • t_opt is None

    • C: T0 when

      • existentials is [],
      • c_args is [],
      • t_opt is Some T0.

    • C: T1 * ... * Tn -> T0 when

      • existentials is [],
      • c_args is [T1; ...; Tn],
      • t_opt is Some T0.

    • C: 'a... . T1 * ... * Tn -> T0 when

      • existentials is ['a;...],
      • c_args is [T1; ... ; Tn],
      • t_opt is Some T0.
    */
  2. | Pext_rebind(Asttypes.loc(Longident.t))
    /*

    Pext_rebind(D) re-export the constructor D with the new name C

    */
;

Class language

Type expressions for the class language

and class_type = {
  1. pcty_desc: class_type_desc,
  2. pcty_loc: Location.t,
  3. pcty_attributes: attributes,
    /*

    ... [\@id1] [\@id2]

    */
};
and class_type_desc =
  1. | Pcty_constr(Asttypes.loc(Longident.t), list(core_type))
    /*
    • c
    • ['a1, ..., 'an] c
    */
  2. | Pcty_signature(class_signature)
    /*

    object ... end

    */
  3. | Pcty_arrow(Asttypes.arg_label, core_type, class_type)
    /*

    Pcty_arrow(lbl, T, CT) represents:

    • T -> CT when lbl is Nolabel,
    • ~l:T -> CT when lbl is Labelled l,
    • ?l:T -> CT when lbl is Optional l.
    */
  4. | Pcty_extension(extension)
    /*

    %id

    */
  5. | Pcty_open(open_description, class_type)
    /*

    let open M in CT

    */
;
and class_signature = {
  1. pcsig_self: core_type,
  2. pcsig_fields: list(class_type_field),
};

Values of type class_signature represents:

and class_type_field = {
  1. pctf_desc: class_type_field_desc,
  2. pctf_loc: Location.t,
  3. pctf_attributes: attributes,
    /*

    ... [\@\@id1] [\@\@id2]

    */
};
and class_type_field_desc =
  1. | Pctf_inherit(class_type)
    /*

    inherit CT

    */
  2. | Pctf_val((Asttypes.loc(Asttypes.label), Asttypes.mutable_flag, Asttypes.virtual_flag, core_type))
    /*

    val x: T

    */
  3. | Pctf_method((Asttypes.loc(Asttypes.label), Asttypes.private_flag, Asttypes.virtual_flag, core_type))
    /*

    method x: T

    Note: T can be a Ptyp_poly.

    */
  4. | Pctf_constraint((core_type, core_type))
    /*

    constraint T1 = T2

    */
  5. | Pctf_attribute(attribute)
    /*

    [\@\@\@id]

    */
  6. | Pctf_extension(extension)
    /*

    [%%id]

    */
;
and class_infos('a) = {
  1. pci_virt: Asttypes.virtual_flag,
  2. pci_params: list((core_type, (Asttypes.variance, Asttypes.injectivity))),
  3. pci_name: Asttypes.loc(string),
  4. pci_expr: 'a,
  5. pci_loc: Location.t,
  6. pci_attributes: attributes,
    /*

    ... [\@\@id1] [\@\@id2]

    */
};

Values of type class_expr class_infos represents:

  • class c = ...
  • class ['a1,...,'an] c = ...
  • class virtual c = ...

They are also used for "class type" declaration.

and class_description = class_infos(class_type);
and class_type_declaration = class_infos(class_type);

Value expressions for the class language

and class_expr = {
  1. pcl_desc: class_expr_desc,
  2. pcl_loc: Location.t,
  3. pcl_attributes: attributes,
    /*

    ... [\@id1] [\@id2]

    */
};
and class_expr_desc =
  1. | Pcl_constr(Asttypes.loc(Longident.t), list(core_type))
    /*

    c and ['a1, ..., 'an] c

    */
  2. | Pcl_structure(class_structure)
    /*

    object ... end

    */
  3. | Pcl_fun(Asttypes.arg_label, option(expression), pattern, class_expr)
    /*

    Pcl_fun(lbl, exp0, P, CE) represents:

    • fun P -> CE when lbl is Nolabel and exp0 is None,
    • fun ~l:P -> CE when lbl is Labelled l and exp0 is None,
    • fun ?l:P -> CE when lbl is Optional l and exp0 is None,
    • fun ?l:(P = E0) -> CE when lbl is Optional l and exp0 is Some E0.
    */
  4. | Pcl_apply(class_expr, list((Asttypes.arg_label, expression)))
    /*

    Pcl_apply(CE, [(l1,E1) ; ... ; (ln,En)]) represents CE ~l1:E1 ... ~ln:En. li can be empty (non labeled argument) or start with ? (optional argument).

    Invariant: n > 0

    */
  5. | Pcl_let(Asttypes.rec_flag, list(value_binding), class_expr)
    /*

    Pcl_let(rec, [(P1, E1); ... ; (Pn, En)], CE) represents:

    • let P1 = E1 and ... and Pn = EN in CE when rec is Nonrecursive,
    • let rec P1 = E1 and ... and Pn = EN in CE when rec is Recursive.
    */
  6. | Pcl_constraint(class_expr, class_type)
    /*

    (CE : CT)

    */
  7. | Pcl_extension(extension)
    /*

    [%id]

    */
  8. | Pcl_open(open_description, class_expr)
    /*

    let open M in CE

    */
;
and class_structure = {
  1. pcstr_self: pattern,
  2. pcstr_fields: list(class_field),
};

Values of type class_structure represents:

and class_field = {
  1. pcf_desc: class_field_desc,
  2. pcf_loc: Location.t,
  3. pcf_attributes: attributes,
    /*

    ... [\@\@id1] [\@\@id2]

    */
};
and class_field_desc =
  1. | Pcf_inherit(Asttypes.override_flag, class_expr, option(Asttypes.loc(string)))
    /*

    Pcf_inherit(flag, CE, s) represents:

    • inherit CE when flag is Fresh and s is None,
    • inherit CE as x when flag is Fresh and s is Some x,
    • inherit! CE when flag is Override and s is None,
    • inherit! CE as x when flag is Override and s is Some x
    */
  2. | Pcf_val((Asttypes.loc(Asttypes.label), Asttypes.mutable_flag, class_field_kind))
    /*

    Pcf_val(x,flag, kind) represents:

    */
  3. | Pcf_method((Asttypes.loc(Asttypes.label), Asttypes.private_flag, class_field_kind))
    /**/
  4. | Pcf_constraint((core_type, core_type))
    /*

    constraint T1 = T2

    */
  5. | Pcf_initializer(expression)
    /*

    initializer E

    */
  6. | Pcf_attribute(attribute)
    /*

    [\@\@\@id]

    */
  7. | Pcf_extension(extension)
    /*

    [%%id]

    */
;
and class_field_kind =
  1. | Cfk_virtual(core_type)
  2. | Cfk_concrete(Asttypes.override_flag, expression)
;
and class_declaration = class_infos(class_expr);

Module language

Type expressions for the module language

and module_type = {
  1. pmty_desc: module_type_desc,
  2. pmty_loc: Location.t,
  3. pmty_attributes: attributes,
    /*

    ... [\@id1] [\@id2]

    */
};
and module_type_desc =
  1. | Pmty_ident(Asttypes.loc(Longident.t))
    /*

    Pmty_ident(S) represents S

    */
  2. | Pmty_signature(signature)
    /*

    sig ... end

    */
  3. | Pmty_functor(functor_parameter, module_type)
    /*

    functor(X : MT1) -> MT2

    */
  4. | Pmty_with(module_type, list(with_constraint))
    /*

    MT with ...

    */
  5. | Pmty_typeof(module_expr)
    /*

    module type of ME

    */
  6. | Pmty_extension(extension)
    /*

    [%id]

    */
  7. | Pmty_alias(Asttypes.loc(Longident.t))
    /*

    (module M)

    */
;
and functor_parameter =
  1. | Unit
    /*

    ()

    */
  2. | Named(Asttypes.loc(option(string)), module_type)
    /*

    Named(name, MT) represents:

    • (X : MT) when name is Some X,
    • (_ : MT) when name is None
    */
;
and signature = list(signature_item);
and signature_item = {
  1. psig_desc: signature_item_desc,
  2. psig_loc: Location.t,
};
and signature_item_desc =
  1. | Psig_value(value_description)
    /*
    • val x: T
    • external x: T = "s1" ... "sn"
    */
  2. | Psig_type(Asttypes.rec_flag, list(type_declaration))
    /*

    type t1 = ... and ... and tn = ...

    */
  3. | Psig_typesubst(list(type_declaration))
    /*

    type t1 := ... and ... and tn := ...

    */
  4. | Psig_typext(type_extension)
    /*

    type t1 += ...

    */
  5. | Psig_exception(type_exception)
    /*

    exception C of T

    */
  6. | Psig_module(module_declaration)
    /*

    module X = M and module X : MT

    */
  7. | Psig_modsubst(module_substitution)
    /*

    module X := M

    */
  8. | Psig_recmodule(list(module_declaration))
    /*

    module rec X1 : MT1 and ... and Xn : MTn

    */
  9. | Psig_modtype(module_type_declaration)
    /*

    module type S = MT and module type S

    */
  10. | Psig_modtypesubst(module_type_declaration)
    /*

    module type S := ...

    */
  11. | Psig_open(open_description)
    /*

    open X

    */
  12. | Psig_include(include_description)
    /*

    include MT

    */
  13. | Psig_class(list(class_description))
    /*

    class c1 : ... and ... and cn : ...

    */
  14. | Psig_class_type(list(class_type_declaration))
    /*

    class type ct1 = ... and ... and ctn = ...

    */
  15. | Psig_attribute(attribute)
    /*

    [\@\@\@id]

    */
  16. | Psig_extension(extension, attributes)
    /*

    [%%id]

    */
;
and module_declaration = {
  1. pmd_name: Asttypes.loc(option(string)),
  2. pmd_type: module_type,
  3. pmd_attributes: attributes,
    /*

    ... [\@\@id1] [\@\@id2]

    */
  4. pmd_loc: Location.t,
};

Values of type module_declaration represents S : MT

and module_substitution = {
  1. pms_name: Asttypes.loc(string),
  2. pms_manifest: Asttypes.loc(Longident.t),
  3. pms_attributes: attributes,
    /*

    ... [\@\@id1] [\@\@id2]

    */
  4. pms_loc: Location.t,
};

Values of type module_substitution represents S := M

and module_type_declaration = {
  1. pmtd_name: Asttypes.loc(string),
  2. pmtd_type: option(module_type),
  3. pmtd_attributes: attributes,
    /*

    ... [\@\@id1] [\@\@id2]

    */
  4. pmtd_loc: Location.t,
};

Values of type module_type_declaration represents:

  • S = MT,
  • S for abstract module type declaration, when pmtd_type is None.
and open_infos('a) = {
  1. popen_expr: 'a,
  2. popen_override: Asttypes.override_flag,
  3. popen_loc: Location.t,
  4. popen_attributes: attributes,
};

Values of type 'a open_infos represents:

and open_description = open_infos(Asttypes.loc(Longident.t));

Values of type open_description represents:

  • open M.N
  • open M(N).O
and open_declaration = open_infos(module_expr);

Values of type open_declaration represents:

  • open M.N
  • open M(N).O
  • open struct ... end
and include_infos('a) = {
  1. pincl_mod: 'a,
  2. pincl_loc: Location.t,
  3. pincl_attributes: attributes,
};
and include_description = include_infos(module_type);

Values of type include_description represents include MT

and include_declaration = include_infos(module_expr);

Values of type include_declaration represents include ME

and with_constraint =
  1. | Pwith_type(Asttypes.loc(Longident.t), type_declaration)
    /*

    with type X.t = ...

    Note: the last component of the longident must match the name of the type_declaration.

    */
  2. | Pwith_module(Asttypes.loc(Longident.t), Asttypes.loc(Longident.t))
    /*

    with module X.Y = Z

    */
  3. | Pwith_modtype(Asttypes.loc(Longident.t), module_type)
    /*

    with module type X.Y = Z

    */
  4. | Pwith_modtypesubst(Asttypes.loc(Longident.t), module_type)
    /*

    with module type X.Y := sig end

    */
  5. | Pwith_typesubst(Asttypes.loc(Longident.t), type_declaration)
    /*

    with type X.t := ..., same format as [Pwith_type]

    */
  6. | Pwith_modsubst(Asttypes.loc(Longident.t), Asttypes.loc(Longident.t))
    /*

    with module X.Y := Z

    */
;

Value expressions for the module language

and module_expr = {
  1. pmod_desc: module_expr_desc,
  2. pmod_loc: Location.t,
  3. pmod_attributes: attributes,
    /*

    ... [\@id1] [\@id2]

    */
};
and module_expr_desc =
  1. | Pmod_ident(Asttypes.loc(Longident.t))
    /*

    X

    */
  2. | Pmod_structure(structure)
    /*

    struct ... end

    */
  3. | Pmod_functor(functor_parameter, module_expr)
    /*

    functor(X : MT1) -> ME

    */
  4. | Pmod_apply(module_expr, module_expr)
    /*

    ME1(ME2)

    */
  5. | Pmod_apply_unit(module_expr)
    /*

    ME1()

    */
  6. | Pmod_constraint(module_expr, module_type)
    /*

    (ME : MT)

    */
  7. | Pmod_unpack(expression)
    /*

    (val E)

    */
  8. | Pmod_extension(extension)
    /*

    [%id]

    */
;
and structure = list(structure_item);
and structure_item = {
  1. pstr_desc: structure_item_desc,
  2. pstr_loc: Location.t,
};
and structure_item_desc =
  1. | Pstr_eval(expression, attributes)
    /*

    E

    */
  2. | Pstr_value(Asttypes.rec_flag, list(value_binding))
    /*

    Pstr_value(rec, [(P1, E1 ; ... ; (Pn, En))]) represents:

    • let P1 = E1 and ... and Pn = EN when rec is Nonrecursive,
    • let rec P1 = E1 and ... and Pn = EN when rec is Recursive.
    */
  3. | Pstr_primitive(value_description)
    /*
    • val x: T
    • external x: T = "s1" ... "sn"
    */
  4. | Pstr_type(Asttypes.rec_flag, list(type_declaration))
    /*

    type t1 = ... and ... and tn = ...

    */
  5. | Pstr_typext(type_extension)
    /*

    type t1 += ...

    */
  6. | Pstr_exception(type_exception)
    /*
    • exception C of T
    • exception C = M.X
    */
  7. | Pstr_module(module_binding)
    /*

    module X = ME

    */
  8. | Pstr_recmodule(list(module_binding))
    /*

    module rec X1 = ME1 and ... and Xn = MEn

    */
  9. | Pstr_modtype(module_type_declaration)
    /*

    module type S = MT

    */
  10. | Pstr_open(open_declaration)
    /*

    open X

    */
  11. | Pstr_class(list(class_declaration))
    /*

    class c1 = ... and ... and cn = ...

    */
  12. | Pstr_class_type(list(class_type_declaration))
    /*

    class type ct1 = ... and ... and ctn = ...

    */
  13. | Pstr_include(include_declaration)
    /*

    include ME

    */
  14. | Pstr_attribute(attribute)
    /*

    [\@\@\@id]

    */
  15. | Pstr_extension(extension, attributes)
    /*

    [%%id]

    */
;
and value_constraint =
  1. | Pvc_constraint of {
    1. locally_abstract_univars: list(Asttypes.loc(string)),
    2. typ: core_type,
    }
  2. | Pvc_coercion of {
    1. ground: option(core_type),
    2. coercion: core_type,
    }
    /*
    • Pvc_constraint { locally_abstract_univars=[]; typ} is a simple type constraint on a value binding: let x : typ
    • More generally, in Pvc_constraint { locally_abstract_univars; typ} locally_abstract_univars is the list of locally abstract type variables in let x: type a ... . typ
    • Pvc_coercion { ground=None; coercion } represents let x :> typ
    • Pvc_coercion { ground=Some g; coercion } represents let x : g :> typ
    */
;
and value_binding = {
  1. pvb_pat: pattern,
  2. pvb_expr: expression,
  3. pvb_constraint: option(value_constraint),
  4. pvb_attributes: attributes,
  5. pvb_loc: Location.t,
};

let pat : type_constraint = exp

and module_binding = {
  1. pmb_name: Asttypes.loc(option(string)),
  2. pmb_expr: module_expr,
  3. pmb_attributes: attributes,
  4. pmb_loc: Location.t,
};

Values of type module_binding represents module X = ME

Toplevel

Toplevel phrases

type toplevel_phrase =
  1. | Ptop_def(structure)
  2. | Ptop_dir(toplevel_directive)
    /*

    #use, #load ...

    */
;
and toplevel_directive = {
  1. pdir_name: Asttypes.loc(string),
  2. pdir_arg: option(directive_argument),
  3. pdir_loc: Location.t,
};
and directive_argument = {
  1. pdira_desc: directive_argument_desc,
  2. pdira_loc: Location.t,
};
and directive_argument_desc =
  1. | Pdir_string(string)
  2. | Pdir_int(string, option(char))
  3. | Pdir_ident(Longident.t)
  4. | Pdir_bool(bool)
;