Module Private.Import

include sig ... end
include module type of struct include Ppxlib.Ast end
type position = Lexing.position = {
  1. pos_fname : string;
  2. pos_lnum : int;
  3. pos_bol : int;
  4. pos_cnum : int;
}
and location = Astlib.Location.t = {
  1. loc_start : position;
  2. loc_end : position;
  3. loc_ghost : bool;
}
and location_stack = location list
and include_kind = Astlib.Ast_500.Parsetree.include_kind =
  1. | Structure
  2. | Functor
and 'a loc = 'a Astlib.Location.loc = {
  1. txt : 'a;
  2. loc : location;
}
and longident = Astlib.Longident.t =
  1. | Lident of string
  2. | Ldot of longident * string
  3. | Lapply of longident * longident
and longident_loc = longident loc

Auxiliary AST types used by parsetree and typedtree.

and rec_flag = Astlib.Ast_500.Asttypes.rec_flag =
  1. | Nonrecursive
  2. | Recursive
and direction_flag = Astlib.Ast_500.Asttypes.direction_flag =
  1. | Upto
  2. | Downto
and private_flag = Astlib.Ast_500.Asttypes.private_flag =
  1. | Private
  2. | Public
and mutable_flag = Astlib.Ast_500.Asttypes.mutable_flag =
  1. | Immutable
  2. | Mutable
and virtual_flag = Astlib.Ast_500.Asttypes.virtual_flag =
  1. | Virtual
  2. | Concrete
and override_flag = Astlib.Ast_500.Asttypes.override_flag =
  1. | Override
  2. | Fresh
and closed_flag = Astlib.Ast_500.Asttypes.closed_flag =
  1. | Closed
  2. | Open
and label = string
and arg_label = Astlib.Ast_500.Asttypes.arg_label =
  1. | Nolabel
  2. | Labelled of string
    (*

    label:T -> ...

    *)
  3. | Optional of string
    (*

    ?label:T -> ...

    *)
and variance = Astlib.Ast_500.Asttypes.variance =
  1. | Covariant
  2. | Contravariant
  3. | NoVariance
and injectivity = Astlib.Ast_500.Asttypes.injectivity =
  1. | Injective
  2. | NoInjectivity
and index_kind = Astlib.Ast_500.Asttypes.index_kind =
  1. | Index_int
  2. | Index_unboxed_int64
  3. | Index_unboxed_int32
  4. | Index_unboxed_int16
  5. | Index_unboxed_int8
  6. | Index_unboxed_nativeint

Abstract syntax tree produced by parsing

and constant = Astlib.Ast_500.Parsetree.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_unboxed_integer of string * char
    (*

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

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

    *)
  3. | Pconst_char of char
    (*

    Character such as 'c'.

    *)
  4. | Pconst_untagged_char of char
    (*

    Untagged character such as #'c'.

    *)
  5. | Pconst_string of string * location * string option
    (*

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

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

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

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

    Suffixes [g-z][G-Z] are accepted by the parser. Suffixes are rejected by the typechecker.

    *)
  7. | Pconst_unboxed_float of string * char option
    (*

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

    Suffixes [g-z][G-Z] are accepted by the parser. Suffixes except 's' are rejected by the typechecker.

    *)

Extension points

and attribute = Astlib.Ast_500.Parsetree.attribute = {
  1. attr_name : string loc;
  2. attr_payload : payload;
  3. attr_loc : location;
}

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

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

and extension = string loc * payload

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

Sub-language placeholder -- rejected by the typechecker.

and attributes = attribute list
and payload = Astlib.Ast_500.Parsetree.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 = Astlib.Ast_500.Parsetree.core_type = {
  1. ptyp_desc : core_type_desc;
  2. ptyp_loc : location;
  3. ptyp_loc_stack : location_stack;
  4. ptyp_attributes : attributes;
    (*

    ... [@id1] [@id2]

    *)
}
and core_type_desc = Astlib.Ast_500.Parsetree.core_type_desc =
  1. | Ptyp_any of Astlib.Ast_500.Parsetree.jkind_annotation option
    (*

    _ or _ : k

    *)
  2. | Ptyp_var of string * Astlib.Ast_500.Parsetree.jkind_annotation option
    (*

    A type variable such as 'a or 'a : k

    *)
  3. | Ptyp_arrow of arg_label * core_type * core_type * modes * modes
    (*

    Ptyp_arrow(lbl, T1, T2, M1, M2) represents:

    • T1 @ M1 -> T2 @ M2 when lbl is Nolabel,
    • ~l:(T1 @ M1) -> T2 @ M2 when lbl is Labelled,
    • ?l:(T1 @ M1) -> T2 @ M2 when lbl is Optional.
    *)
  4. | Ptyp_tuple of (string option * core_type) list
    (*

    Ptyp_tuple(tl) represents a product type:

    • T1 * ... * Tn when tl is (None,T1);...;(None,Tn)
    • L1:T1 * ... * Ln:Tn when tl is (Some L1,T1);...;(Some Ln,Tn)
    • A mix, e.g. L1:T1 * T2 when tl is (Some L1,T1);(None,T2)

    Invariant: n >= 2.

    *)
  5. | Ptyp_unboxed_tuple of (string option * core_type) list
    (*

    Unboxed tuple types: Ptyp_unboxed_tuple([(Some l1,P1);...;(Some l2,Pn)] represents a product type #(l1:T1 * ... * l2:Tn), and the labels are optional.

    Invariant: n >= 2.

    *)
  6. | Ptyp_constr of longident_loc * core_type list
    (*

    Ptyp_constr(lident, l) represents:

    • tconstr when l=[],
    • T tconstr when l=[T],
    • (T1, ..., Tn) tconstr when l=[T1 ; ... ; Tn].
    *)
  7. | Ptyp_object of object_field list * 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.
    *)
  8. | Ptyp_class of longident_loc * core_type list
    (*

    Ptyp_class(tconstr, l) represents:

    • #tconstr when l=[],
    • T #tconstr when l=[T],
    • (T1, ..., Tn) #tconstr when l=[T1 ; ... ; Tn].
    *)
  9. | Ptyp_alias of core_type * string loc option * Astlib.Ast_500.Parsetree.jkind_annotation option
    (*

    T as 'a or T as ('a : k) or T as (_ : k).

    Invariant: the name or jkind annotation is non-None.

    *)
  10. | Ptyp_variant of row_field list * closed_flag * 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"].
    *)
  11. | Ptyp_poly of (string loc * Astlib.Ast_500.Parsetree.jkind_annotation option) list * core_type
    (*

    'a1 ... 'an. T ('a1 : k1) ... ('an : kn). T

    Can only appear in the following context:

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

    (module S).

    *)
  13. | Ptyp_quote of core_type
    (*

    <[T]>

    *)
  14. | Ptyp_splice of core_type
    (*

    $T

    *)
  15. | Ptyp_of_kind of Astlib.Ast_500.Parsetree.jkind_annotation
    (*

    (type : k)

    *)
  16. | Ptyp_extension of extension
    (*

    [%id].

    *)
and package_type = longident_loc * (longident_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 = Astlib.Ast_500.Parsetree.row_field = {
  1. prf_desc : row_field_desc;
  2. prf_loc : location;
  3. prf_attributes : attributes;
}
and row_field_desc = Astlib.Ast_500.Parsetree.row_field_desc =
  1. | Rtag of label 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 = Astlib.Ast_500.Parsetree.object_field = {
  1. pof_desc : object_field_desc;
  2. pof_loc : location;
  3. pof_attributes : attributes;
}
and object_field_desc = Astlib.Ast_500.Parsetree.object_field_desc =
  1. | Otag of label loc * core_type
  2. | Oinherit of core_type

Patterns

and pattern = Astlib.Ast_500.Parsetree.pattern = {
  1. ppat_desc : pattern_desc;
  2. ppat_loc : location;
  3. ppat_loc_stack : location_stack;
  4. ppat_attributes : attributes;
    (*

    ... [@id1] [@id2]

    *)
}
and pattern_desc = Astlib.Ast_500.Parsetree.pattern_desc =
  1. | Ppat_any
    (*

    The pattern _.

    *)
  2. | Ppat_var of string loc
    (*

    A variable pattern such as x

    *)
  3. | Ppat_alias of pattern * string 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 (string option * pattern) list * closed_flag
    (*

    Ppat_tuple(pl, Closed) represents

    • (P1, ..., Pn) when pl is (None, P1);...;(None, Pn)
    • (~L1:P1, ..., ~Ln:Pn) when pl is (Some L1, P1);...;(Some Ln, Pn)
    • A mix, e.g. (~L1:P1, P2) when pl is (Some L1, P1);(None, P2)
    • If pattern is open, then it also ends in a ..

    Invariant:

    • If Closed, n >= 2.
    • If Open, n >= 1.
    *)
  7. | Ppat_unboxed_tuple of (string option * pattern) list * closed_flag
    (*

    Unboxed tuple patterns: #(l1:P1, ..., ln:Pn) is ([(Some l1,P1);...;(Some l2,Pn)], Closed), and the labels are optional. An Open pattern ends in ...

    Invariant:

    • If Closed, n >= 2
    • If Open, n >= 1
    *)
  8. | Ppat_construct of longident_loc * ((string loc * Astlib.Ast_500.Parsetree.jkind_annotation option) 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, None; b, None], P)
    • C (type (a : k) b) P when args is Some ([a, Some k; b, None], P)
    *)
  9. | Ppat_variant of label * pattern option
    (*

    Ppat_variant(`A, pat) represents:

    • `A when pat is None,
    • `A P when pat is Some P
    *)
  10. | Ppat_record of (longident_loc * pattern) list * 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

    *)
  11. | Ppat_record_unboxed_product of (longident_loc * pattern) list * closed_flag
    (*

    Ppat_record_unboxed_product([(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

    *)
  12. | Ppat_array of mutable_flag * pattern list
    (*

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

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

    Pattern P1 | P2

    *)
  14. | Ppat_constraint of pattern * core_type option * modes
    (*

    Ppat_constraint(tyopt, modes) represents:

    • (P : ty @@ modes) when tyopt is Some ty
    • (P @ modes) when tyopt is None
    *)
  15. | Ppat_type of longident_loc
    (*

    Pattern #tconst

    *)
  16. | Ppat_lazy of pattern
    (*

    Pattern lazy P

    *)
  17. | Ppat_unpack of string option 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)

    *)
  18. | Ppat_exception of pattern
    (*

    Pattern exception P

    *)
  19. | Ppat_extension of extension
    (*

    Pattern [%id]

    *)
  20. | Ppat_open of longident_loc * pattern
    (*

    Pattern M.(P)

    *)

Value expressions

and expression = Astlib.Ast_500.Parsetree.expression = {
  1. pexp_desc : expression_desc;
  2. pexp_loc : location;
  3. pexp_loc_stack : location_stack;
  4. pexp_attributes : attributes;
    (*

    ... [@id1] [@id2]

    *)
}
and expression_desc = Astlib.Ast_500.Parsetree.expression_desc =
  1. | Pexp_ident of longident_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 mutable_flag * rec_flag * value_binding list * expression
    (*

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

    • let P1 = E1 and ... and Pn = EN in E when rec is Nonrecursive and mut = Immutable.
    • let rec P1 = E1 and ... and Pn = EN in E when rec is Recursive and mut = Immutable.
    • let mutable P1 = E1 in E when rec is Nonrecursive and mut = Mutable. Invariant: If mut = Mutable then n = 1 and rec = Nonrecursive
    *)
  4. | Pexp_function of function_param list * function_constraint * function_body
    (*

    Pexp_function ([P1; ...; Pn], C, body) represents any construct involving fun or function, including:

    • fun P1 ... Pn -> E when body = Pfunction_body E
    • fun P1 ... Pn -> function p1 -> e1 | ... | pm -> em when body = Pfunction_cases [ p1 -> e1; ...; pm -> em ]

    C represents a type constraint or coercion placed immediately before the arrow, e.g. fun P1 ... Pn : ty -> ... when C = Some (Pconstraint ty).

    A function must have parameters. Pexp_function (params, _, body) must have non-empty params or a Pfunction_cases _ body.

    *)
  5. | Pexp_apply of expression * (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

    *)
  6. | Pexp_match of expression * cases
    (*

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

    *)
  7. | Pexp_try of expression * cases
    (*

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

    *)
  8. | Pexp_tuple of (string option * expression) list
    (*

    Pexp_tuple(el) represents

    • (E1, ..., En) when el is (None, E1);...;(None, En)
    • (~L1:E1, ..., ~Ln:En) when el is (Some L1, E1);...;(Some Ln, En)
    • A mix, e.g.: (~L1:E1, E2) when el is (Some L1, E1); (None, E2)

    Invariant: n >= 2

    *)
  9. | Pexp_unboxed_tuple of (string option * expression) list
    (*

    Unboxed tuple expressions: Pexp_unboxed_tuple([(Some l1,P1);...;(Some l2,Pn)]) represents #(l1:E1, ..., ln:En), and the labels are optional.

    Invariant: n >= 2

    *)
  10. | Pexp_construct of longident_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 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_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_record_unboxed_product of (longident_loc * expression) list * expression option
    (*

    Pexp_record_unboxed_product([(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

    *)
  14. | Pexp_field of expression * longident_loc
    (*

    E.l

    *)
  15. | Pexp_unboxed_field of expression * longident_loc
    (*

    E.#l

    *)
  16. | Pexp_setfield of expression * longident_loc * expression
    (*

    E1.l <- E2

    *)
  17. | Pexp_array of mutable_flag * expression list
    (*

    [| E1; ...; En |] or [: E1; ...; En :]

    *)
  18. | Pexp_idx of block_access * unboxed_access list
    (*

    (BA1 UA1 UA2 ...) e.g. (.foo.#bar.#baz) Above, BA1=.foo, UA1=.#bar, and UA2=#.baz

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

    if E1 then E2 else E3

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

    E1; E2

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

    while E1 do E2 done

    *)
  22. | Pexp_for of pattern * expression * expression * 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
    *)
  23. | Pexp_constraint of expression * core_type option * modes
    (*

    (E : T @@ modes)

    *)
  24. | 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.
    *)
  25. | Pexp_send of expression * label loc
    (*

    E # m

    *)
  26. | Pexp_new of longident_loc
    (*

    new M.c

    *)
  27. | Pexp_setvar of label loc * expression
    (*

    x <- 2

    *)
  28. | Pexp_override of (label loc * expression) list
    (*

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

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

    let module M = ME in E

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

    let exception C in E

    *)
  31. | Pexp_assert of expression
    (*

    assert E.

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

    *)
  32. | Pexp_lazy of expression
    (*

    lazy E

    *)
  33. | 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).

    *)
  34. | Pexp_object of class_structure
    (*

    object ... end

    *)
  35. | Pexp_newtype of string loc * Astlib.Ast_500.Parsetree.jkind_annotation option * expression
    (*

    fun (type t) -> E or fun (type t : k) -> E

    *)
  36. | Pexp_pack of module_expr
    (*

    (module ME).

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

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

    [%id]

    *)
  40. | Pexp_unreachable
    (*

    .

    *)
  41. | Pexp_stack of expression
  42. | Pexp_comprehension of comprehension_expression
    (*

    [? BODY ...CLAUSES... ?], where:

    • ? is either "" (list), : (immutable array), or | (array).
    • BODY is an expression.
    • CLAUSES is a series of comprehension_clause.
    *)
  43. | Pexp_overwrite of expression * expression
  44. | Pexp_quote of expression
    (*

    runtime metaprogramming quotations <E>

    *)
  45. | Pexp_splice of expression
    (*

    runtime metaprogramming splicing $(E)

    *)
  46. | Pexp_hole
and case = Astlib.Ast_500.Parsetree.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 = Astlib.Ast_500.Parsetree.letop = {
  1. let_ : binding_op;
  2. ands : binding_op list;
  3. body : expression;
}
and binding_op = Astlib.Ast_500.Parsetree.binding_op = {
  1. pbop_op : string loc;
  2. pbop_pat : pattern;
  3. pbop_exp : expression;
  4. pbop_loc : location;
}
and function_param_desc = Astlib.Ast_500.Parsetree.function_param_desc =
  1. | Pparam_val of arg_label * expression option * pattern
    (*

    Pparam_val (lbl, exp0, P) represents the parameter:

    Note: If E0 is provided, only Optional is allowed.

    *)
  2. | Pparam_newtype of string loc * Astlib.Ast_500.Parsetree.jkind_annotation option
    (*

    Pparam_newtype x represents the parameter (type x). x carries the location of the identifier, whereas the pparam_loc on the enclosing function_param node is the location of the (type x) as a whole.

    Multiple parameters (type a b c) are represented as multiple Pparam_newtype nodes, let's say:

     [ { pparam_kind = Pparam_newtype a; pparam_loc = loc1 };
    { pparam_kind = Pparam_newtype b; pparam_loc = loc2 };
    { pparam_kind = Pparam_newtype c; pparam_loc = loc3 };
  ]

    Here, the first loc loc1 is the location of (type a b c), and the subsequent locs loc2 and loc3 are the same as loc1, except marked as ghost locations. The locations on a, b, c, correspond to the variables a, b, and c in the source code.

    *)
and function_param = Astlib.Ast_500.Parsetree.function_param = {
  1. pparam_loc : location;
  2. pparam_desc : function_param_desc;
}
and function_body = Astlib.Ast_500.Parsetree.function_body =
  1. | Pfunction_body of expression
  2. | Pfunction_cases of case list * location * attributes
    (*

    In Pfunction_cases (_, loc, attrs), the location extends from the start of the function keyword to the end of the last case. The compiler will only use typechecking-related attributes from attrs, e.g. enabling or disabling a warning.

    *)

See the comment on Pexp_function.

and type_constraint = Astlib.Ast_500.Parsetree.type_constraint =
  1. | Pconstraint of core_type
  2. | Pcoerce of core_type option * core_type
    (*

    See the comment on Pexp_function.

    *)
and function_constraint = Astlib.Ast_500.Parsetree.function_constraint = {
  1. mode_annotations : modes;
    (*

    The mode annotation placed on a function let-binding, e.g. let local_ f x : int -> int = .... The local_ syntax is parsed into two nodes: the field here, and pvb_modes. This field only affects the interpretation of ret_type_constraint, while the latter is translated in typecore to Pexp_constraint to contrain the mode of the function.

    *)
  2. ret_mode_annotations : modes;
    (*

    The mode annotation placed on a function's body, e.g. let f x : int -> int @@ local = .... This field constrains the mode of function's body.

    *)
  3. ret_type_constraint : type_constraint option;
    (*

    The type constraint placed on a function's body.

    *)
}

See the comment on Pexp_function.

and block_access = Astlib.Ast_500.Parsetree.block_access =
  1. | Baccess_field of longident_loc
    (*

    .foo

    *)
  2. | Baccess_array of mutable_flag * index_kind * expression
    (*

    Mutable array accesses: .(E), .L(E), .l(E), .n(E) Immutable array accesses: .:(E), .:L(E), .:l(E), .:n(E)

    Indexed by int, int64#, int32#, or nativeint#, respectively.

    *)
  3. | Baccess_block of mutable_flag * expression
    (*

    Access using another block index: .idx_imm(E), .idx_mut(E) (usually followed by unboxed accesses, to deepen the index).

    *)
and unboxed_access = Astlib.Ast_500.Parsetree.unboxed_access =
  1. | Uaccess_unboxed_field of longident_loc
    (*

    .#foo

    *)
and comprehension_iterator = Astlib.Ast_500.Parsetree.comprehension_iterator =
  1. | Pcomp_range of {
    1. start : expression;
    2. stop : expression;
    3. direction : direction_flag;
    }
    (*

    "= START to STOP" (direction = Upto) "= START downto STOP" (direction = Downto)

    *)
  2. | Pcomp_in of expression
    (*

    "in EXPR"

    *)
and comprehension_clause_binding = Astlib.Ast_500.Parsetree.comprehension_clause_binding = {
  1. pcomp_cb_pattern : pattern;
  2. pcomp_cb_iterator : comprehension_iterator;
  3. pcomp_cb_attributes : attributes;
}

@... PAT (in/=) ...

and comprehension_clause = Astlib.Ast_500.Parsetree.comprehension_clause =
  1. | Pcomp_for of comprehension_clause_binding list
    (*

    "for PAT (in/=) ... and PAT (in/=) ... and ..."; must be nonempty

    *)
  2. | Pcomp_when of expression
    (*

    "when EXPR"

    *)
and comprehension = Astlib.Ast_500.Parsetree.comprehension = {
  1. pcomp_body : expression;
    (*

    The body/generator of the comprehension

    *)
  2. pcomp_clauses : comprehension_clause list;
    (*

    The clauses of the comprehension; must be nonempty

    *)
}
and comprehension_expression = Astlib.Ast_500.Parsetree.comprehension_expression =
  1. | Pcomp_list_comprehension of comprehension
    (*

    [BODY ...CLAUSES...]

    *)
  2. | Pcomp_array_comprehension of mutable_flag * comprehension
    (*

    [|BODY ...CLAUSES...|] (flag = Mutable) [:BODY ...CLAUSES...:] (flag = Immutable) (only allowed with -extension immutable_arrays)

    *)

Value descriptions

and value_description = Astlib.Ast_500.Parsetree.value_description = {
  1. pval_name : string loc;
  2. pval_type : core_type;
  3. pval_modalities : modalities;
  4. pval_prim : string list;
  5. pval_attributes : attributes;
    (*

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

    *)
  6. pval_loc : location;
}

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 = Astlib.Ast_500.Parsetree.type_declaration = {
  1. ptype_name : string loc;
  2. ptype_params : (core_type * (variance * injectivity)) list;
    (*

    ('a1,...'an) t

    *)
  3. ptype_cstrs : (core_type * core_type * location) list;
    (*

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

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

    for = private ...

    *)
  6. ptype_manifest : core_type option;
    (*

    represents = T

    *)
  7. ptype_attributes : attributes;
    (*

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

    *)
  8. ptype_jkind_annotation : Astlib.Ast_500.Parsetree.jkind_annotation option;
    (*

    for : jkind

    *)
  9. ptype_loc : location;
}

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 = Astlib.Ast_500.Parsetree.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_record_unboxed_product of label_declaration list
    (*

    Invariant: non-empty list

    *)
  5. | Ptype_open
and label_declaration = Astlib.Ast_500.Parsetree.label_declaration = {
  1. pld_name : string loc;
  2. pld_mutable : mutable_flag;
  3. pld_modalities : modalities;
  4. pld_type : core_type;
  5. pld_loc : location;
  6. pld_attributes : attributes;
    (*

    l : T [@id1] [@id2]

    *)
}

Note: T can be a Ptyp_poly.

and constructor_declaration = Astlib.Ast_500.Parsetree.constructor_declaration = {
  1. pcd_name : string loc;
  2. pcd_vars : (string loc * Astlib.Ast_500.Parsetree.jkind_annotation option) list;
    (*

    jkind annotations are C : ('a : kind1) ('a2 : kind2). ...

    *)
  3. pcd_args : constructor_arguments;
  4. pcd_res : core_type option;
  5. pcd_loc : location;
  6. pcd_attributes : attributes;
    (*

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

    *)
}
and constructor_argument = Astlib.Ast_500.Parsetree.constructor_argument = {
  1. pca_modalities : modalities;
  2. pca_type : core_type;
  3. pca_loc : location;
}
and constructor_arguments = Astlib.Ast_500.Parsetree.constructor_arguments =
  1. | Pcstr_tuple of constructor_argument 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 = Astlib.Ast_500.Parsetree.type_extension = {
  1. ptyext_path : longident_loc;
  2. ptyext_params : (core_type * (variance * injectivity)) list;
  3. ptyext_constructors : extension_constructor list;
  4. ptyext_private : private_flag;
  5. ptyext_loc : location;
  6. ptyext_attributes : attributes;
    (*

    ... @@id1 @@id2

    *)
}

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

and extension_constructor = Astlib.Ast_500.Parsetree.extension_constructor = {
  1. pext_name : string loc;
  2. pext_kind : extension_constructor_kind;
  3. pext_loc : location;
  4. pext_attributes : attributes;
    (*

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

    *)
}
and type_exception = Astlib.Ast_500.Parsetree.type_exception = {
  1. ptyexn_constructor : extension_constructor;
  2. ptyexn_loc : location;
  3. ptyexn_attributes : attributes;
    (*

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

    *)
}

Definition of a new exception (exception E).

and extension_constructor_kind = Astlib.Ast_500.Parsetree.extension_constructor_kind =
  1. | Pext_decl of (string loc * Astlib.Ast_500.Parsetree.jkind_annotation option) 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 : k)... . T1 * ... * Tn -> T0 when

      • existentials is ['a;...],
      • c_args is [T1; ... ; Tn],
      • t_opt is Some T0.
    *)
  2. | Pext_rebind of longident_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 = Astlib.Ast_500.Parsetree.class_type = {
  1. pcty_desc : class_type_desc;
  2. pcty_loc : location;
  3. pcty_attributes : attributes;
    (*

    ... [@id1] [@id2]

    *)
}
and class_type_desc = Astlib.Ast_500.Parsetree.class_type_desc =
  1. | Pcty_constr of longident_loc * core_type list
    (*
    • c
    • ['a1, ..., 'an] c
    *)
  2. | Pcty_signature of class_signature
    (*

    object ... end

    *)
  3. | Pcty_arrow of arg_label * core_type * class_type
    (*

    Pcty_arrow(lbl, T, CT) represents:

    *)
  4. | Pcty_extension of extension
    (*

    %id

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

    let open M in CT

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

Values of type class_signature represents:

and class_type_field = Astlib.Ast_500.Parsetree.class_type_field = {
  1. pctf_desc : class_type_field_desc;
  2. pctf_loc : location;
  3. pctf_attributes : attributes;
    (*

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

    *)
}
and class_type_field_desc = Astlib.Ast_500.Parsetree.class_type_field_desc =
  1. | Pctf_inherit of class_type
    (*

    inherit CT

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

    val x: T

    *)
  3. | Pctf_method of label loc * private_flag * 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 = 'a Astlib.Ast_500.Parsetree.class_infos = {
  1. pci_virt : virtual_flag;
  2. pci_params : (core_type * (variance * injectivity)) list;
  3. pci_name : string loc;
  4. pci_expr : 'a;
  5. pci_loc : location;
  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 = Astlib.Ast_500.Parsetree.class_expr = {
  1. pcl_desc : class_expr_desc;
  2. pcl_loc : location;
  3. pcl_attributes : attributes;
    (*

    ... [@id1] [@id2]

    *)
}
and class_expr_desc = Astlib.Ast_500.Parsetree.class_expr_desc =
  1. | Pcl_constr of longident_loc * core_type list
    (*

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

    *)
  2. | Pcl_structure of class_structure
    (*

    object ... end

    *)
  3. | Pcl_fun of 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 * (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 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 = Astlib.Ast_500.Parsetree.class_structure = {
  1. pcstr_self : pattern;
  2. pcstr_fields : class_field list;
}

Values of type class_structure represents:

and class_field = Astlib.Ast_500.Parsetree.class_field = {
  1. pcf_desc : class_field_desc;
  2. pcf_loc : location;
  3. pcf_attributes : attributes;
    (*

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

    *)
}
and class_field_desc = Astlib.Ast_500.Parsetree.class_field_desc =
  1. | Pcf_inherit of override_flag * class_expr * string 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 label loc * mutable_flag * class_field_kind
    (*

    Pcf_val(x,flag, kind) represents:

    *)
  3. | Pcf_method of label loc * 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 = Astlib.Ast_500.Parsetree.class_field_kind =
  1. | Cfk_virtual of core_type
  2. | Cfk_concrete of override_flag * expression
and class_declaration = class_expr class_infos

Module language

Type expressions for the module language

and module_type = Astlib.Ast_500.Parsetree.module_type = {
  1. pmty_desc : module_type_desc;
  2. pmty_loc : location;
  3. pmty_attributes : attributes;
    (*

    ... [@id1] [@id2]

    *)
}
and module_type_desc = Astlib.Ast_500.Parsetree.module_type_desc =
  1. | Pmty_ident of longident_loc
    (*

    Pmty_ident(S) represents S

    *)
  2. | Pmty_signature of signature
    (*

    sig ... end

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

    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_loc
    (*

    (module M)

    *)
  8. | Pmty_strengthen of module_type * longident_loc
    (*

    MT with S

    *)
and functor_parameter = Astlib.Ast_500.Parsetree.functor_parameter =
  1. | Unit
    (*

    ()

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

    Named(name, MT) represents:

    • (X : MT) when name is Some X,
    • (_ : MT) when name is None
    *)
and signature = Astlib.Ast_500.Parsetree.signature = {
  1. psg_modalities : modalities;
  2. psg_items : signature_items;
  3. psg_loc : location;
}
and signature_items = signature_item list
and signature_item = Astlib.Ast_500.Parsetree.signature_item = {
  1. psig_desc : signature_item_desc;
  2. psig_loc : location;
}
and signature_item_desc = Astlib.Ast_500.Parsetree.signature_item_desc =
  1. | Psig_value of value_description
    (*
    • val x: T
    • external x: T = "s1" ... "sn"
    *)
  2. | Psig_type of 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 * modalities
    (*

    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]

    *)
  17. | Psig_kind_abbrev of string loc * Astlib.Ast_500.Parsetree.jkind_annotation
    (*

    kind_abbrev_ name = k

    *)
and module_declaration = Astlib.Ast_500.Parsetree.module_declaration = {
  1. pmd_name : string option loc;
  2. pmd_type : module_type;
  3. pmd_modalities : modalities;
  4. pmd_attributes : attributes;
    (*

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

    *)
  5. pmd_loc : location;
}

Values of type module_declaration represents S : MT

and module_substitution = Astlib.Ast_500.Parsetree.module_substitution = {
  1. pms_name : string loc;
  2. pms_manifest : longident_loc;
  3. pms_attributes : attributes;
    (*

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

    *)
  4. pms_loc : location;
}

Values of type module_substitution represents S := M

and module_type_declaration = Astlib.Ast_500.Parsetree.module_type_declaration = {
  1. pmtd_name : string loc;
  2. pmtd_type : module_type option;
  3. pmtd_attributes : attributes;
    (*

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

    *)
  4. pmtd_loc : location;
}

Values of type module_type_declaration represents:

  • S = MT,
  • S for abstract module type declaration, when pmtd_type is None.
and 'a open_infos = 'a Astlib.Ast_500.Parsetree.open_infos = {
  1. popen_expr : 'a;
  2. popen_override : override_flag;
  3. popen_loc : location;
  4. popen_attributes : attributes;
}

Values of type 'a open_infos represents:

and open_description = longident_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 = 'a Astlib.Ast_500.Parsetree.include_infos = {
  1. pincl_kind : include_kind;
  2. pincl_mod : 'a;
  3. pincl_loc : location;
  4. 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 = Astlib.Ast_500.Parsetree.with_constraint =
  1. | Pwith_type of longident_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_loc * longident_loc
    (*

    with module X.Y = Z

    *)
  3. | Pwith_modtype of longident_loc * module_type
    (*

    with module type X.Y = Z

    *)
  4. | Pwith_modtypesubst of longident_loc * module_type
    (*

    with module type X.Y := sig end

    *)
  5. | Pwith_typesubst of longident_loc * type_declaration
    (*

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

    *)
  6. | Pwith_modsubst of longident_loc * longident_loc
    (*

    with module X.Y := Z

    *)

Value expressions for the module language

and module_expr = Astlib.Ast_500.Parsetree.module_expr = {
  1. pmod_desc : module_expr_desc;
  2. pmod_loc : location;
  3. pmod_attributes : attributes;
    (*

    ... [@id1] [@id2]

    *)
}
and module_expr_desc = Astlib.Ast_500.Parsetree.module_expr_desc =
  1. | Pmod_ident of longident_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_constraint of module_expr * module_type option * modes
    (*

    (ME : MT)

    *)
  6. | Pmod_unpack of expression
    (*

    (val E)

    *)
  7. | Pmod_extension of extension
    (*

    [%id]

    *)
  8. | Pmod_instance of module_instance
    (*

    Foo(Param1)(Arg1(Param2)(Arg2)) [@jane.non_erasable.instances]

    *)
and module_instance = Astlib.Ast_500.Parsetree.module_instance = {
  1. pmod_instance_head : string;
  2. pmod_instance_args : (string * module_instance) list;
}

M(P1)(MI1)...(Pn)(MIn)

and structure = structure_item list
and structure_item = Astlib.Ast_500.Parsetree.structure_item = {
  1. pstr_desc : structure_item_desc;
  2. pstr_loc : location;
}
and structure_item_desc = Astlib.Ast_500.Parsetree.structure_item_desc =
  1. | Pstr_eval of expression * attributes
    (*

    E

    *)
  2. | Pstr_value of 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 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]

    *)
  16. | Pstr_kind_abbrev of string loc * Astlib.Ast_500.Parsetree.jkind_annotation
    (*

    kind_abbrev_ name = k

    *)
and value_binding = Astlib.Ast_500.Parsetree.value_binding = {
  1. pvb_pat : pattern;
  2. pvb_expr : expression;
  3. pvb_modes : modes;
  4. pvb_attributes : attributes;
  5. pvb_loc : location;
}
and module_binding = Astlib.Ast_500.Parsetree.module_binding = {
  1. pmb_name : string option loc;
  2. pmb_expr : module_expr;
  3. pmb_attributes : attributes;
  4. pmb_loc : location;
}

Values of type module_binding represents module X = ME

and jkind_annotation_desc = Astlib.Ast_500.Parsetree.jkind_annotation_desc =
  1. | Pjk_default
  2. | Pjk_abbreviation of string
  3. | Pjk_mod of Astlib.Ast_500.Parsetree.jkind_annotation * modes
  4. | Pjk_with of Astlib.Ast_500.Parsetree.jkind_annotation * core_type * modalities
  5. | Pjk_kind_of of core_type
  6. | Pjk_product of Astlib.Ast_500.Parsetree.jkind_annotation list

Toplevel

Toplevel phrases

and toplevel_phrase = Astlib.Ast_500.Parsetree.toplevel_phrase =
  1. | Ptop_def of structure
  2. | Ptop_dir of toplevel_directive
    (*

    #use, #load ...

    *)
and toplevel_directive = Astlib.Ast_500.Parsetree.toplevel_directive = {
  1. pdir_name : string loc;
  2. pdir_arg : directive_argument option;
  3. pdir_loc : location;
}
and directive_argument = Astlib.Ast_500.Parsetree.directive_argument = {
  1. pdira_desc : directive_argument_desc;
  2. pdira_loc : location;
}
and directive_argument_desc = Astlib.Ast_500.Parsetree.directive_argument_desc =
  1. | Pdir_string of string
  2. | Pdir_int of string * char option
  3. | Pdir_ident of longident
  4. | Pdir_bool of bool
and cases = case list
class virtual map : object ... end
class virtual iter : object ... end
class virtual 'acc fold : object ... end
class virtual 'acc fold_map : object ... end
class virtual 'ctx map_with_context : object ... end
class virtual 'res lift : object ... end
class virtual ['ctx, 'res] lift_map_with_context : object ... end
module Ast_pattern : sig ... end
module Attribute = Ppxlib.Attribute
module Context_free = Ppxlib.Context_free
module Driver = Ppxlib.Driver
module Extension = Ppxlib.Extension
module Loc = Ppxlib.Loc
module Location : sig ... end
include sig ... end
module Ast_traverse = Ppxlib_jane.Ast_traverse
type jkind_annotation = Ppxlib_jane.Shim.jkind_annotation
type mode = Ppxlib_jane.Shim.Mode.t =
  1. | Mode of string
type modality = Ppxlib_jane.Shim.Modality.t =
  1. | Modality of string
module Ast_builder : sig ... end
include sig ... end
module Sexp = Sexplib0.Sexp
include module type of struct include Sexplib0.Sexp_conv end
Conversion of OCaml-values to S-expressions
val default_string_of_float : (float -> string) Basement.Dynamic.t @@ portable

default_string_of_float reference to the default function used to convert floats to strings.

Initially set to fun n -> sprintf "%.20G" n.

val write_old_option_format : bool Basement.Dynamic.t @@ portable

write_old_option_format reference for the default option format used to write option values. If set to true, the old-style option format will be used, the new-style one otherwise.

Initially set to true.

val read_old_option_format : bool Basement.Dynamic.t @@ portable

read_old_option_format reference for the default option format used to read option values. Of_sexp_error will be raised with old-style option values if this reference is set to false. Reading new-style option values is always supported. Using a global reference instead of changing the converter calling conventions is the only way to avoid breaking old code with the standard macros.

Initially set to true.

val list_map : ('a -> 'b) -> 'a list -> 'b list @@ portable

We re-export a tail recursive map function, because some modules override the standard library functions (e.g. StdLabels) which wrecks havoc with the camlp4 extension.

val list_map__stack : ('a @ local -> 'b @ local) @ local -> ('a list @ local -> 'b list @ local) @ local @@ portable

As list_map, but operating over locally-allocated values.

val sexp_of_unit : unit -> Sexplib0.Sexp.t @@ portable

sexp_of_unit () converts a value of type unit to an S-expression.

val sexp_of_unit__stack : unit @ local -> Sexplib0.Sexp.t @ local @@ portable

As sexp_of_unit, but returning a locally-allocated sexp.

val sexp_of_bool : bool -> Sexplib0.Sexp.t @@ portable

sexp_of_bool b converts the value x of type bool to an S-expression.

val sexp_of_bool__stack : bool @ local -> Sexplib0.Sexp.t @ local @@ portable

As sexp_of_bool, but returning a locally-allocated sexp.

val sexp_of_string : string -> Sexplib0.Sexp.t @@ portable

sexp_of_string str converts the value str of type string to an S-expression.

val sexp_of_string__stack : string @ local -> Sexplib0.Sexp.t @ local @@ portable

As sexp_of_string, but returning a locally-allocated sexp.

val sexp_of_bytes : bytes -> Sexplib0.Sexp.t @@ portable

sexp_of_bytes str converts the value str of type bytes to an S-expression.

val sexp_of_bytes__stack : bytes @ local -> Sexplib0.Sexp.t @ local @@ portable

As sexp_of_bytes, but returning a locally-allocated sexp.

val sexp_of_char : char -> Sexplib0.Sexp.t @@ portable

sexp_of_char c converts the value c of type char to an S-expression.

val sexp_of_char__stack : char @ local -> Sexplib0.Sexp.t @ local @@ portable

As sexp_of_char, but returning a locally-allocated sexp. Currently, the sexp will contain a one-character string which is heap-allocated.

val sexp_of_int : int -> Sexplib0.Sexp.t @@ portable

sexp_of_int n converts the value n of type int to an S-expression.

val sexp_of_int__stack : int @ local -> Sexplib0.Sexp.t @ local @@ portable

As sexp_of_int, but returning a locally-allocated sexp. Currently, the sexp will contain a formatted string which is heap-allocated.

val sexp_of_float : float -> Sexplib0.Sexp.t @@ portable

sexp_of_float n converts the value n of type float to an S-expression.

val sexp_of_float__stack : float @ local -> Sexplib0.Sexp.t @ local @@ portable

As sexp_of_float, but returning a locally-allocated sexp. Currently, the float will be copied to the heap, and the sexp will contain a formatted string which is heap-allocated.

val sexp_of_int32 : int32 -> Sexplib0.Sexp.t @@ portable

sexp_of_int32 n converts the value n of type int32 to an S-expression.

val sexp_of_int32__stack : int32 @ local -> Sexplib0.Sexp.t @ local @@ portable

As sexp_of_int32, but returning a locally-allocated sexp. Currently, the sexp will contain a formatted string which is heap-allocated.

val sexp_of_int64 : int64 -> Sexplib0.Sexp.t @@ portable

sexp_of_int64 n converts the value n of type int64 to an S-expression.

val sexp_of_int64__stack : int64 @ local -> Sexplib0.Sexp.t @ local @@ portable

As sexp_of_int64, but returning a locally-allocated sexp. Currently, the sexp will contain a formatted string which is heap-allocated.

val sexp_of_nativeint : nativeint -> Sexplib0.Sexp.t @@ portable

sexp_of_nativeint n converts the value n of type nativeint to an S-expression.

val sexp_of_nativeint__stack : nativeint @ local -> Sexplib0.Sexp.t @ local @@ portable

As sexp_of_nativeint, but returning a locally-allocated sexp. Currently, the sexp will contain a formatted string which is heap-allocated.

val sexp_of_ref : 'a. ('a -> Sexplib0.Sexp.t) -> 'a ref -> Sexplib0.Sexp.t @@ portable

sexp_of_ref conv r converts the value r of type 'a ref to an S-expression. Uses conv to convert values of type 'a to an S-expression.

val sexp_of_ref__stack : 'a. ('a @ local -> Sexplib0.Sexp.t @ local) -> 'a ref @ local -> Sexplib0.Sexp.t @ local @@ portable

As sexp_of_ref, but returning a locally-allocated sexp.

val sexp_of_lazy_t : 'a. ('a -> Sexplib0.Sexp.t) -> 'a lazy_t -> Sexplib0.Sexp.t @@ portable

sexp_of_lazy_t conv l converts the value l of type 'a lazy_t to an S-expression. Uses conv to convert values of type 'a to an S-expression.

val sexp_of_lazy_t__stack : 'a. ('a @ local -> Sexplib0.Sexp.t @ local) -> 'a lazy_t @ local -> Sexplib0.Sexp.t @ local @@ portable

As sexp_of_lazy_t, but returning a locally-allocated sexp.

val sexp_of_option : 'a. ('a -> Sexplib0.Sexp.t) -> 'a option -> Sexplib0.Sexp.t @@ portable

sexp_of_option conv opt converts the value opt of type 'a option to an S-expression. Uses conv to convert values of type 'a to an S-expression.

val sexp_of_option__stack : 'a. ('a @ local -> Sexplib0.Sexp.t @ local) -> 'a option @ local -> Sexplib0.Sexp.t @ local @@ portable

As sexp_of_option, but returning a locally-allocated sexp.

val sexp_of_or_null : 'a. ('a -> Sexplib0.Sexp.t) -> 'a Basement.Or_null_shim.t -> Sexplib0.Sexp.t @@ portable

sexp_of_or_null conv orn converts the value orn of type 'a or_null to an S-expression. Uses conv to convert values of type 'a to an S-expression.

val sexp_of_or_null__stack : 'a. ('a @ local -> Sexplib0.Sexp.t @ local) -> 'a Basement.Or_null_shim.t @ local -> Sexplib0.Sexp.t @ local @@ portable

As sexp_of_or_null, but returning a locally-allocated sexp.

val sexp_of_pair : 'a 'b. ('a -> Sexplib0.Sexp.t) -> ('b -> Sexplib0.Sexp.t) -> ('a * 'b) -> Sexplib0.Sexp.t @@ portable

sexp_of_pair conv1 conv2 pair converts a pair to an S-expression. It uses its first argument to convert the first element of the pair, and its second argument to convert the second element of the pair.

val sexp_of_triple : 'a 'b 'c. ('a -> Sexplib0.Sexp.t) -> ('b -> Sexplib0.Sexp.t) -> ('c -> Sexplib0.Sexp.t) -> ('a * 'b * 'c) -> Sexplib0.Sexp.t @@ portable

sexp_of_triple conv1 conv2 conv3 triple converts a triple to an S-expression using conv1, conv2, and conv3 to convert its elements.

val sexp_of_list : 'a. ('a -> Sexplib0.Sexp.t) -> 'a list -> Sexplib0.Sexp.t @@ portable

sexp_of_list conv lst converts the value lst of type 'a list to an S-expression. Uses conv to convert values of type 'a to an S-expression.

val sexp_of_list__stack : 'a. ('a @ local -> Sexplib0.Sexp.t @ local) -> 'a list @ local -> Sexplib0.Sexp.t @ local @@ portable

As sexp_of_list, but returning a locally-allocated sexp.

val sexp_of_array : 'a. ('a -> Sexplib0.Sexp.t) -> 'a array -> Sexplib0.Sexp.t @@ portable

sexp_of_array conv ar converts the value ar of type 'a array to an S-expression. Uses conv to convert values of type 'a to an S-expression.

val sexp_of_array__stack : 'a. ('a @ local -> Sexplib0.Sexp.t @ local) -> 'a array @ local -> Sexplib0.Sexp.t @ local @@ portable

As sexp_of_array, but returning a locally-allocated sexp.

val sexp_of_hashtbl : 'a 'b. ('a -> Sexplib0.Sexp.t) -> ('b -> Sexplib0.Sexp.t) -> ('a, 'b) Hashtbl.t -> Sexplib0.Sexp.t @@ portable

sexp_of_hashtbl conv_key conv_value htbl converts the value htbl of type ('a, 'b) Hashtbl.t to an S-expression. Uses conv_key to convert the hashtable keys of type 'a, and conv_value to convert hashtable values of type 'b to S-expressions.

val sexp_of_opaque : 'a. 'a @ local contended -> Sexplib0.Sexp.t @@ portable

sexp_of_opaque x converts the value x of opaque type to an S-expression. This means the user need not provide converters, but the result cannot be interpreted.

val sexp_of_fun : ('a -> 'b) @ local -> Sexplib0.Sexp.t @@ portable

sexp_of_fun f converts the value f of function type to a dummy S-expression. Functions cannot be serialized as S-expressions, but at least a placeholder can be generated for pretty-printing.

Conversion of S-expressions to OCaml-values
exception Of_sexp_error of exn * Sexplib0.Sexp.t

Of_sexp_error (exn, sexp) the exception raised when an S-expression could not be successfully converted to an OCaml-value.

val record_check_extra_fields : bool Basement.Dynamic.t @@ portable

record_check_extra_fields checks for extra (= unknown) fields in record S-expressions.

val of_sexp_error : string -> Sexplib0.Sexp.t -> 'a @@ portable

of_sexp_error reason sexp

val of_sexp_error_exn : exn -> Sexplib0.Sexp.t -> 'a @@ portable

of_sexp_error exc sexp

val unit_of_sexp : Sexplib0.Sexp.t -> unit @@ portable

unit_of_sexp sexp converts S-expression sexp to a value of type unit.

val bool_of_sexp : Sexplib0.Sexp.t -> bool @@ portable

bool_of_sexp sexp converts S-expression sexp to a value of type bool.

val string_of_sexp : Sexplib0.Sexp.t -> string @@ portable

string_of_sexp sexp converts S-expression sexp to a value of type string.

val bytes_of_sexp : Sexplib0.Sexp.t -> bytes @@ portable

bytes_of_sexp sexp converts S-expression sexp to a value of type bytes.

val char_of_sexp : Sexplib0.Sexp.t -> char @@ portable

char_of_sexp sexp converts S-expression sexp to a value of type char.

val int_of_sexp : Sexplib0.Sexp.t -> int @@ portable

int_of_sexp sexp converts S-expression sexp to a value of type int.

val float_of_sexp : Sexplib0.Sexp.t -> float @@ portable

float_of_sexp sexp converts S-expression sexp to a value of type float.

val int32_of_sexp : Sexplib0.Sexp.t -> int32 @@ portable

int32_of_sexp sexp converts S-expression sexp to a value of type int32.

val int64_of_sexp : Sexplib0.Sexp.t -> int64 @@ portable

int64_of_sexp sexp converts S-expression sexp to a value of type int64.

val nativeint_of_sexp : Sexplib0.Sexp.t -> nativeint @@ portable

nativeint_of_sexp sexp converts S-expression sexp to a value of type nativeint.

val ref_of_sexp : 'a. (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a ref @@ portable

ref_of_sexp conv sexp converts S-expression sexp to a value of type 'a ref using conversion function conv, which converts an S-expression to a value of type 'a.

val lazy_t_of_sexp : 'a. (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a lazy_t @@ portable

lazy_t_of_sexp conv sexp converts S-expression sexp to a value of type 'a lazy_t using conversion function conv, which converts an S-expression to a value of type 'a.

val option_of_sexp : 'a. (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a option @@ portable

option_of_sexp conv sexp converts S-expression sexp to a value of type 'a option using conversion function conv, which converts an S-expression to a value of type 'a.

val or_null_of_sexp : 'a. (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a Basement.Or_null_shim.t @@ portable

option_of_sexp conv sexp converts S-expression sexp to a value of type 'a or_null using conversion function conv, which converts an S-expression to a value of type 'a.

val pair_of_sexp : 'a 'b. (Sexplib0.Sexp.t -> 'a) -> (Sexplib0.Sexp.t -> 'b) -> Sexplib0.Sexp.t -> 'a * 'b @@ portable

pair_of_sexp conv1 conv2 sexp converts S-expression sexp to a pair of type 'a * 'b using conversion functions conv1 and conv2, which convert S-expressions to values of type 'a and 'b respectively.

val triple_of_sexp : 'a 'b 'c. (Sexplib0.Sexp.t -> 'a) -> (Sexplib0.Sexp.t -> 'b) -> (Sexplib0.Sexp.t -> 'c) -> Sexplib0.Sexp.t -> 'a * 'b * 'c @@ portable

triple_of_sexp conv1 conv2 conv3 sexp converts S-expression sexp to a triple of type 'a * 'b * 'c using conversion functions conv1, conv2, and conv3, which convert S-expressions to values of type 'a, 'b, and 'c respectively.

val list_of_sexp : 'a. (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a list @@ portable

list_of_sexp conv sexp converts S-expression sexp to a value of type 'a list using conversion function conv, which converts an S-expression to a value of type 'a.

val array_of_sexp : 'a. (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a array @@ portable

array_of_sexp conv sexp converts S-expression sexp to a value of type 'a array using conversion function conv, which converts an S-expression to a value of type 'a.

val hashtbl_of_sexp : 'a 'b. (Sexplib0.Sexp.t -> 'a) -> (Sexplib0.Sexp.t -> 'b) -> Sexplib0.Sexp.t -> ('a, 'b) Hashtbl.t @@ portable

hashtbl_of_sexp conv_key conv_value sexp converts S-expression sexp to a value of type ('a, 'b) Hashtbl.t using conversion function conv_key, which converts an S-expression to hashtable key of type 'a, and function conv_value, which converts an S-expression to hashtable value of type 'b.

val opaque_of_sexp : Sexplib0.Sexp.t -> 'a @@ portable

opaque_of_sexp sexp

  • raises Of_sexp_error

    when attempting to convert an S-expression to an opaque value.

val fun_of_sexp : Sexplib0.Sexp.t -> 'a @@ portable

fun_of_sexp sexp

  • raises Of_sexp_error

    when attempting to convert an S-expression to a function.

Sexp Grammars

val sexp_grammar_with_tags : Sexplib0.Sexp_grammar.grammar -> tags:(string * Sexplib0.Sexp.t) list -> Sexplib0.Sexp_grammar.grammar @@ portable
val sexp_grammar_with_tag_list : 'a Sexplib0.Sexp_grammar.with_tag_list -> tags:(string * Sexplib0.Sexp.t) list -> 'a Sexplib0.Sexp_grammar.with_tag_list @@ portable

Sexp grammar definitions.

val unit_sexp_grammar : unit Sexplib0.Sexp_grammar.t @@ portable
val bool_sexp_grammar : bool Sexplib0.Sexp_grammar.t @@ portable
val string_sexp_grammar : string Sexplib0.Sexp_grammar.t @@ portable
val bytes_sexp_grammar : bytes Sexplib0.Sexp_grammar.t @@ portable
val char_sexp_grammar : char Sexplib0.Sexp_grammar.t @@ portable
val int_sexp_grammar : int Sexplib0.Sexp_grammar.t @@ portable
val float_sexp_grammar : float Sexplib0.Sexp_grammar.t @@ portable
val int32_sexp_grammar : int32 Sexplib0.Sexp_grammar.t @@ portable
val int64_sexp_grammar : int64 Sexplib0.Sexp_grammar.t @@ portable
val nativeint_sexp_grammar : nativeint Sexplib0.Sexp_grammar.t @@ portable
val sexp_t_sexp_grammar : Sexplib0.Sexp.t Sexplib0.Sexp_grammar.t @@ portable
val ref_sexp_grammar : 'a. 'a Sexplib0.Sexp_grammar.t -> 'a ref Sexplib0.Sexp_grammar.t @@ portable
val lazy_t_sexp_grammar : 'a Sexplib0.Sexp_grammar.t -> 'a lazy_t Sexplib0.Sexp_grammar.t @@ portable
val option_sexp_grammar : 'a. 'a Sexplib0.Sexp_grammar.t -> 'a option Sexplib0.Sexp_grammar.t @@ portable
val list_sexp_grammar : 'a. 'a Sexplib0.Sexp_grammar.t -> 'a list Sexplib0.Sexp_grammar.t @@ portable
val array_sexp_grammar : 'a. 'a Sexplib0.Sexp_grammar.t -> 'a array Sexplib0.Sexp_grammar.t @@ portable
val opaque_sexp_grammar : 'a. 'a Sexplib0.Sexp_grammar.t @@ portable
val fun_sexp_grammar : 'a Sexplib0.Sexp_grammar.t @@ portable

Exception converters

val sexp_of_exn : exn -> Sexplib0.Sexp.t @@ portable

sexp_of_exn exc converts exception exc to an S-expression. If no suitable converter is found, the standard converter in Printexc will be used to generate an atomic S-expression.

val printexc_prefer_sexp : exn -> string @@ portable

Converts an exception to a string via sexp, falling back to Printexc.to_string if no sexp conversion is registered for this exception.

This is different from Printexc.to_string in that it additionally uses the sexp converters registered with ~printexc:false. Another difference is that the behavior of Printexc can be overridden with Printexc.register, but here we always try sexp conversion first.

val sexp_of_exn_opt : exn -> Sexplib0.Sexp.t option @@ portable

sexp_of_exn_opt exc converts exception exc to Some sexp. If no suitable converter is found, None is returned instead.

module Exn_converter = Sexplib0.Sexp_conv.Exn_converter
module Result : sig ... end
val map_snd : ('a * 'b) -> f:('b -> 'c) -> 'a * 'c
type _sexp = Sexplib0.Sexp.t =
  1. | Atom of string
  2. | List of Sexplib0.Sexp.t list