Module Ocaml_parsing.Parsetree

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

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

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

Character such as 'c'.

Untagged character such as #'c'.

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

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

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

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

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

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

: SIG in an attribute or an extension point

: T in an attribute or an extension point

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

_ or _ : k

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

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.

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.

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.

Ptyp_constr(lident, l) represents:

• tconstr when l=[],
• T tconstr when l=[T],
• (T1, ..., Tn) tconstr when l=[T1 ; ... ; Tn].

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

• < l1:T1; ...; ln:Tn > when flag is Closed,
• < l1:T1; ...; ln:Tn; .. > when flag is Open.

Ptyp_class(tconstr, l) represents:

• #tconstr when l=[],
• T #tconstr when l=[T],
• (T1, ..., Tn) #tconstr when l=[T1 ; ... ; Tn].

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

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

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"].

'a1 ... 'an. T ('a1 : k1) ... ('an : kn). 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 ...

• Under Cfk_virtual for methods (not values).

• As the core_type of a Pctf_method node.

• As the core_type of a Pexp_poly node.

• As the pld_type field of a label_declaration.

• As a core_type of a Ptyp_object node.

• As the pval_type field of a value_description.

• As the core_type of a Pparam_val.

(module S).

M.(T)

<[T]>

$T

(type : k)

[%id].

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)

[ | t ]

The pattern _.

A variable pattern such as x

An alias pattern such as P as 'a

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

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

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

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.

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

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)

Ppat_variant(`A, pat) represents:

• `A when pat is None,
• `A P when pat is Some P

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

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

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

Pattern P1 | P2

Ppat_constraint(tyopt, modes) represents:

• (P : ty @@ modes) when tyopt is Some ty
• (P @ modes) when tyopt is None

Pattern #tconst

Pattern lazy P

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)

Pattern exception P

Pattern [%id]

Pattern M.(P)

Identifiers such as x and M.x

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

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

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.

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

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

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

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

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

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])

Pexp_variant(`A, exp) represents

• `A when exp is None
• `A E when exp is Some E

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

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

E.l

E.#l

E1.l <- E2

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

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

if E1 then E2 else E3

E1; E2

while E1 do E2 done

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

(E : T @@ modes)

Pexp_coerce(E, from, T) represents

• (E :> T) when from is None,
• (E : T0 :> T) when from is Some T0.

E # m

new M.c

x <- 2

Represents both setting an instance variable and setting a mutable variable.

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

let module M = ME in E

let exception C in E

assert E.

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

lazy E

Used for method bodies.

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

object ... end

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

(module ME).

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

• M.(E)
• let open M in E
• let open! M in E

• let* P = E0 in E1
• let* P0 = E00 and* P1 = E01 in E1

[%id]

.

stack_ exp

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

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

overwrite_ exp with exp

runtime metaprogramming quotations <E>

runtime metaprogramming splicing $(E)

_

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

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

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

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.

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.

.foo

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

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

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

.#foo

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

"in EXPR"

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

"when EXPR"

[BODY ...CLAUSES...]

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

Invariant: non-empty list

Invariant: non-empty 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 [...].

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 : k);...],
  • c_args is [T1; ... ; Tn],
  • t_opt is Some T0.

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

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

object ... end

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.

%id

let open M in CT

inherit CT

val x: T

method x: T

Note: T can be a Ptyp_poly.

constraint T1 = T2

[\@\@\@id]

[%%id]

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

object ... end

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.

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

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.

(CE : CT)

[%id]

let open M in CE

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

Pcf_val(x,flag, kind) represents:

• val x = E when flag is Immutable and kind is Cfk_concrete(Fresh, E)
• val virtual x: T when flag is Immutable and kind is Cfk_virtual(T)
• val mutable x = E when flag is Mutable and kind is Cfk_concrete(Fresh, E)
• val mutable virtual x: T when flag is Mutable and kind is Cfk_virtual(T)

• method x = E (E can be a Pexp_poly)
• method virtual x: T (T can be a Ptyp_poly)

constraint T1 = T2

initializer E

[\@\@\@id]

[%%id]

Pmty_ident(S) represents S

sig ... end

functor(X : MT1 @@ modes) -> MT2 @ modes

MT with ...

module type of ME

[%id]

(module M)

MT with S

()

Named(name, MT) represents:

• (X : MT @@ modes) when name is Some X,
• (_ : MT @@ modes) when name is None

• val x: T
• external x: T = "s1" ... "sn"

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

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

type t1 += ...

exception C of T

module X = M and module X : MT

module X := M

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

module type S = MT and module type S

module type S := ...

open X

include MT

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

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

[\@\@\@id]

[%%id]

kind_abbrev_ name = k

with type X.t = ...

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

with module X.Y = Z

with module type X.Y = Z

with module type X.Y := sig end

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

with module X.Y := Z

X

struct ... end

functor(X : MT1) -> ME

ME1(ME2)

ME1()

• (ME : MT @@ modes)
• (ME @ modes)
• (ME : MT)

(val E)

[%id]

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

The name of an instance module. Gets converted to Global.Name.t in the OxCaml compiler.

E

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.

• val x: T
• external x: T = "s1" ... "sn"

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

type t1 += ...

• exception C of T
• exception C = M.X

module X = ME

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

module type S = MT

open X

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

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

include ME

[\@\@\@id]

[%%id]

kind_abbrev_ name = k

• 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

#use, #load ...