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 of string * char option
    (*

    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 of char
    (*

    Character such as 'c'.

    *)
  3. | Pconst_string of string * Location.t * string option
    (*

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

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

    *)
  4. | Pconst_float of string * char option
    (*

    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 = Location.t list

Extension points

type attribute = {
  1. attr_name : string Asttypes.loc;
  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 = string Asttypes.loc * payload

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

Sub-language placeholder -- rejected by the typechecker.

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

    : SIG in an attribute or an extension point

    *)
  3. | PTyp of core_type
    (*

    : T in an attribute or an extension point

    *)
  4. | PPat of pattern * expression option
    (*

    ? 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 of string
    (*

    A type variable such as 'a

    *)
  3. | Ptyp_arrow of 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 of core_type list
    (*

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

    Invariant: n >= 2.

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

    Ptyp_constr(lident, l) represents:

    • tconstr when l=[],
    • T tconstr when l=[T],
    • (T1, ..., Tn) tconstr when l=[T1 ; ... ; Tn].
    *)
  6. | Ptyp_object of object_field list * 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 of Longident.t Asttypes.loc * core_type list
    (*

    Ptyp_class(tconstr, l) represents:

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

    T as 'a.

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

    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 of string Asttypes.loc list * 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 of package_type
    (*

    (module S).

    *)
  12. | Ptyp_extension of extension
    (*

    [%id].

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

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 of Asttypes.label Asttypes.loc * bool * core_type list
    (*

    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 of 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 of Asttypes.label Asttypes.loc * core_type
  2. | Oinherit of 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 of string Asttypes.loc
    (*

    A variable pattern such as x

    *)
  3. | Ppat_alias of pattern * string Asttypes.loc
    (*

    An alias pattern such as P as 'a

    *)
  4. | Ppat_constant of constant
    (*

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

    *)
  5. | Ppat_interval of 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 of pattern list
    (*

    Patterns (P1, ..., Pn).

    Invariant: n >= 2

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

    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 of Asttypes.label * pattern option
    (*

    Ppat_variant(`A, pat) represents:

    • `A when pat is None,
    • `A P when pat is Some P
    *)
  9. | Ppat_record of (Longident.t Asttypes.loc * pattern) list * 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 of pattern list
    (*

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

    *)
  11. | Ppat_or of pattern * pattern
    (*

    Pattern P1 | P2

    *)
  12. | Ppat_constraint of pattern * core_type
    (*

    Pattern (P : T)

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

    Pattern #tconst

    *)
  14. | Ppat_lazy of pattern
    (*

    Pattern lazy P

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

    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 of pattern
    (*

    Pattern exception P

    *)
  17. | Ppat_extension of extension
    (*

    Pattern [%id]

    *)
  18. | Ppat_open of Longident.t Asttypes.loc * 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 of Longident.t Asttypes.loc
    (*

    Identifiers such as x and M.x

    *)
  2. | Pexp_constant of constant
    (*

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

    *)
  3. | Pexp_let of Asttypes.rec_flag * value_binding list * 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 of case list
    (*

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

    *)
  5. | Pexp_fun of Asttypes.arg_label * expression option * 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 of expression * (Asttypes.arg_label * expression) list
    (*

    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 of expression * case list
    (*

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

    *)
  8. | Pexp_try of expression * case list
    (*

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

    *)
  9. | Pexp_tuple of expression list
    (*

    Expressions (E1, ..., En)

    Invariant: n >= 2

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

    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 of Asttypes.label * expression option
    (*

    Pexp_variant(`A, exp) represents

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

    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 of expression * Longident.t Asttypes.loc
    (*

    E.l

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

    E1.l <- E2

    *)
  15. | Pexp_array of expression list
    (*

    [| E1; ...; En |]

    *)
  16. | Pexp_ifthenelse of expression * expression * expression option
    (*

    if E1 then E2 else E3

    *)
  17. | Pexp_sequence of expression * expression
    (*

    E1; E2

    *)
  18. | Pexp_while of expression * expression
    (*

    while E1 do E2 done

    *)
  19. | Pexp_for of 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 of expression * core_type
    (*

    (E : T)

    *)
  21. | Pexp_coerce of expression * core_type option * 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 of expression * Asttypes.label Asttypes.loc
    (*

    E # m

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

    new M.c

    *)
  24. | Pexp_setinstvar of Asttypes.label Asttypes.loc * expression
    (*

    x <- 2

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

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

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

    let module M = ME in E

    *)
  27. | Pexp_letexception of extension_constructor * expression
    (*

    let exception C in E

    *)
  28. | Pexp_assert of expression
    (*

    assert E.

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

    *)
  29. | Pexp_lazy of expression
    (*

    lazy E

    *)
  30. | Pexp_poly of expression * core_type option
    (*

    Used for method bodies.

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

    *)
  31. | Pexp_object of class_structure
    (*

    object ... end

    *)
  32. | Pexp_newtype of string Asttypes.loc * expression
    (*

    fun (type t) -> E

    *)
  33. | Pexp_pack of module_expr
    (*

    (module ME).

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

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

    [%id]

    *)
  37. | Pexp_unreachable
    (*

    .

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

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

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

Value descriptions

and value_description = {
  1. pval_name : string Asttypes.loc;
  2. pval_type : core_type;
  3. pval_prim : string list;
  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 : string Asttypes.loc;
  2. ptype_params : (core_type * (Asttypes.variance * Asttypes.injectivity)) list;
    (*

    ('a1,...'an) t

    *)
  3. ptype_cstrs : (core_type * core_type * Location.t) list;
    (*

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

    *)
  4. ptype_kind : type_kind;
  5. ptype_private : Asttypes.private_flag;
    (*

    for = private ...

    *)
  6. ptype_manifest : core_type option;
    (*

    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 of constructor_declaration list
  3. | Ptype_record of label_declaration list
    (*

    Invariant: non-empty list

    *)
  4. | Ptype_open
and label_declaration = {
  1. pld_name : string Asttypes.loc;
  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 : string Asttypes.loc;
  2. pcd_vars : string Asttypes.loc list;
  3. pcd_args : constructor_arguments;
  4. pcd_res : core_type option;
  5. pcd_loc : Location.t;
  6. pcd_attributes : attributes;
    (*

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

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

    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 : Longident.t Asttypes.loc;
  2. ptyext_params : (core_type * (Asttypes.variance * Asttypes.injectivity)) list;
  3. ptyext_constructors : extension_constructor list;
  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 : string Asttypes.loc;
  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 of string Asttypes.loc list * constructor_arguments * core_type option
    (*

    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 of Longident.t Asttypes.loc
    (*

    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 of Longident.t Asttypes.loc * core_type list
    (*
    • c
    • ['a1, ..., 'an] c
    *)
  2. | Pcty_signature of class_signature
    (*

    object ... end

    *)
  3. | Pcty_arrow of 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 of extension
    (*

    %id

    *)
  5. | Pcty_open of open_description * class_type
    (*

    let open M in CT

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

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 of class_type
    (*

    inherit CT

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

    val x: T

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

    method x: T

    Note: T can be a Ptyp_poly.

    *)
  4. | Pctf_constraint of core_type * core_type
    (*

    constraint T1 = T2

    *)
  5. | Pctf_attribute of attribute
    (*

    [\@\@\@id]

    *)
  6. | Pctf_extension of extension
    (*

    [%%id]

    *)
and 'a class_infos = {
  1. pci_virt : Asttypes.virtual_flag;
  2. pci_params : (core_type * (Asttypes.variance * Asttypes.injectivity)) list;
  3. pci_name : string Asttypes.loc;
  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_type class_infos
and class_type_declaration = class_type class_infos

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 of Longident.t Asttypes.loc * core_type list
    (*

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

    *)
  2. | Pcl_structure of class_structure
    (*

    object ... end

    *)
  3. | Pcl_fun of Asttypes.arg_label * expression option * 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 of class_expr * (Asttypes.arg_label * expression) list
    (*

    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 of Asttypes.rec_flag * value_binding list * 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 of class_expr * class_type
    (*

    (CE : CT)

    *)
  7. | Pcl_extension of extension
    (*

    [%id]

    *)
  8. | Pcl_open of open_description * class_expr
    (*

    let open M in CE

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

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 of Asttypes.override_flag * class_expr * string Asttypes.loc option
    (*

    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 of Asttypes.label Asttypes.loc * Asttypes.mutable_flag * class_field_kind
    (*

    Pcf_val(x,flag, kind) represents:

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

    constraint T1 = T2

    *)
  5. | Pcf_initializer of expression
    (*

    initializer E

    *)
  6. | Pcf_attribute of attribute
    (*

    [\@\@\@id]

    *)
  7. | Pcf_extension of extension
    (*

    [%%id]

    *)
and class_field_kind =
  1. | Cfk_virtual of core_type
  2. | Cfk_concrete of Asttypes.override_flag * expression
and class_declaration = class_expr class_infos

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 of Longident.t Asttypes.loc
    (*

    Pmty_ident(S) represents S

    *)
  2. | Pmty_signature of signature
    (*

    sig ... end

    *)
  3. | Pmty_functor of functor_parameter * module_type
    (*

    functor(X : MT1) -> MT2

    *)
  4. | Pmty_with of module_type * with_constraint list
    (*

    MT with ...

    *)
  5. | Pmty_typeof of module_expr
    (*

    module type of ME

    *)
  6. | Pmty_extension of extension
    (*

    [%id]

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

    (module M)

    *)
and functor_parameter =
  1. | Unit
    (*

    ()

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

    Named(name, MT) represents:

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

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

    *)
  3. | Psig_typesubst of type_declaration list
    (*

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

    *)
  4. | Psig_typext of type_extension
    (*

    type t1 += ...

    *)
  5. | Psig_exception of type_exception
    (*

    exception C of T

    *)
  6. | Psig_module of module_declaration
    (*

    module X = M and module X : MT

    *)
  7. | Psig_modsubst of module_substitution
    (*

    module X := M

    *)
  8. | Psig_recmodule of module_declaration list
    (*

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

    *)
  9. | Psig_modtype of module_type_declaration
    (*

    module type S = MT and module type S

    *)
  10. | Psig_modtypesubst of module_type_declaration
    (*

    module type S := ...

    *)
  11. | Psig_open of open_description
    (*

    open X

    *)
  12. | Psig_include of include_description
    (*

    include MT

    *)
  13. | Psig_class of class_description list
    (*

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

    *)
  14. | Psig_class_type of class_type_declaration list
    (*

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

    *)
  15. | Psig_attribute of attribute
    (*

    [\@\@\@id]

    *)
  16. | Psig_extension of extension * attributes
    (*

    [%%id]

    *)
and module_declaration = {
  1. pmd_name : string option Asttypes.loc;
  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 : string Asttypes.loc;
  2. pms_manifest : Longident.t Asttypes.loc;
  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 : string Asttypes.loc;
  2. pmtd_type : module_type option;
  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 'a open_infos = {
  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 = Longident.t Asttypes.loc open_infos

Values of type open_description represents:

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

Values of type open_declaration represents:

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

Values of type include_description represents include MT

and include_declaration = module_expr include_infos

Values of type include_declaration represents include ME

and with_constraint =
  1. | Pwith_type of Longident.t Asttypes.loc * type_declaration
    (*

    with type X.t = ...

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

    *)
  2. | Pwith_module of Longident.t Asttypes.loc * Longident.t Asttypes.loc
    (*

    with module X.Y = Z

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

    with module type X.Y = Z

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

    with module type X.Y := sig end

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

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

    *)
  6. | Pwith_modsubst of Longident.t Asttypes.loc * Longident.t Asttypes.loc
    (*

    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 of Longident.t Asttypes.loc
    (*

    X

    *)
  2. | Pmod_structure of structure
    (*

    struct ... end

    *)
  3. | Pmod_functor of functor_parameter * module_expr
    (*

    functor(X : MT1) -> ME

    *)
  4. | Pmod_apply of module_expr * module_expr
    (*

    ME1(ME2)

    *)
  5. | Pmod_apply_unit of module_expr
    (*

    ME1()

    *)
  6. | Pmod_constraint of module_expr * module_type
    (*

    (ME : MT)

    *)
  7. | Pmod_unpack of expression
    (*

    (val E)

    *)
  8. | Pmod_extension of extension
    (*

    [%id]

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

    E

    *)
  2. | Pstr_value of Asttypes.rec_flag * value_binding list
    (*

    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 of value_description
    (*
    • val x: T
    • external x: T = "s1" ... "sn"
    *)
  4. | Pstr_type of Asttypes.rec_flag * type_declaration list
    (*

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

    *)
  5. | Pstr_typext of type_extension
    (*

    type t1 += ...

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

    module X = ME

    *)
  8. | Pstr_recmodule of module_binding list
    (*

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

    *)
  9. | Pstr_modtype of module_type_declaration
    (*

    module type S = MT

    *)
  10. | Pstr_open of open_declaration
    (*

    open X

    *)
  11. | Pstr_class of class_declaration list
    (*

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

    *)
  12. | Pstr_class_type of class_type_declaration list
    (*

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

    *)
  13. | Pstr_include of include_declaration
    (*

    include ME

    *)
  14. | Pstr_attribute of attribute
    (*

    [\@\@\@id]

    *)
  15. | Pstr_extension of extension * attributes
    (*

    [%%id]

    *)
and value_constraint =
  1. | Pvc_constraint of {
    1. locally_abstract_univars : string Asttypes.loc list;
    2. typ : core_type;
    }
  2. | Pvc_coercion of {
    1. ground : core_type option;
    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 : value_constraint option;
  4. pvb_attributes : attributes;
  5. pvb_loc : Location.t;
}

let pat : type_constraint = exp

and module_binding = {
  1. pmb_name : string option Asttypes.loc;
  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 of structure
  2. | Ptop_dir of toplevel_directive
    (*

    #use, #load ...

    *)
and toplevel_directive = {
  1. pdir_name : string Asttypes.loc;
  2. pdir_arg : directive_argument option;
  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 of string
  2. | Pdir_int of string * char option
  3. | Pdir_ident of Longident.t
  4. | Pdir_bool of bool