- Camlp5 -

Version 5.07

• Introduction
• Transitional and Strict
• Parsing and printing tools

• Parsing tools
  • Stream parsers
  • Stream lexers
  • Functional parsers
  • Backtracking parsers
  • Extensible grammars
• Printing tools
  • Extensible printers
  • Pprintf
  • Pretty print
• Language extensions
  • Locations
  • Syntax tree
  • Syntax tree - transi
  • Syntax tree - strict
  • Quotation kit q_ast.cmo
  • The Pcaml module
  • Extensions of syntax
  • Extensions of printing
  • Quotations
  • Revised syntax
  • Scheme syntax
  • Macros
  • Pragma directive
  • Extensible functions
• Conclusion
  • Future work
• Appendix
  • Commands and Files
  • Library
  • Camlp5 sources
  • About Camlp5

Syntax tree - strict mode

This chapter presents the Camlp5 syntax tree when Camlp5 is installed in strict mode.

Introduction

This syntax tree is defined in the module "MLast" provided by Camlp5. Each node corresponds to a syntactic entity of the corresponding type.

For example, the syntax tree of the statement "if" can be written:

  MLast.ExIfe loc e1 e2 e3

where "loc" is the location in the source, and "e1", "e2" and "e3" are respectively the expression after the "if", the one after the "then" and the one after the "else".

If a program needs to manipulate syntax trees, it can use the nodes defined in the module "MLast". The programmer must know how the concrete syntax is transformed into this abstract syntax.

A simpler solution is to use one of the quotation kits "q_MLast.cmo" or "q_ast.cmo". Both propose quotations which represent the abstract syntax (the nodes of the module "MLast") into concrete syntax with antiquotations to bind variables inside. The example above can be written:

  <:expr< if $e1$ then $e2$ else $e3$ >>

This representation is very interesting when one wants to manipulate complicated syntax trees. Here is an example taken from the Camlp5 sources themselves:

  <:expr<
    match try Some $f$ with [ Stream.Failure -> None ] with
    [ Some $p$ -> $e$
    | _ -> raise (Stream.Error $e2$) ]
  >>

This example was in a position of a pattern. In abstract syntax, it should have been written:

  MLast.ExMat _
    (MLast.ExTry _ (MLast.ExApp _ (MLast.ExUid _ (Ploc.VaVal "Some")) f)
       (Ploc.VaVal
          [(MLast.PaAcc _ (MLast.PaUid _ (Ploc.VaVal "Stream"))
             (MLast.PaUid _ (Ploc.VaVal "Failure")),
            Ploc.VaVal None, MLast.ExUid _ (Ploc.VaVal "None"))]))
    (Ploc.VaVal
       [(MLast.PaApp _ (MLast.PaUid _ (Ploc.VaVal "Some")) p,
         Ploc.VaVal None, e);
        (MLast.PaAny _, Ploc.VaVal None,
         MLast.ExApp _ (MLast.ExLid _ (Ploc.VaVal "raise"))
           (MLast.ExApp _
              (MLast.ExAcc _ (MLast.ExUid _ (Ploc.VaVal "Stream"))
                 (MLast.ExUid _ (Ploc.VaVal "Error")))
              e2))])

Which is less readable and much more complicated to build and update.

Instead of thinking of "a syntax tree", the programmer can think of "a piece of program".

Location

In all syntax tree nodes, the first parameter is the source location of the node.

In expressions

When a quotation is in the context of an expression, the location parameter is "loc" in the node and in all its possible sub-nodes. Example: if we consider the quotation:

  <:sig_item< value foo : int -> bool >>

This quotation, in a context of an expression, is equivalent to:

  MLast.SgVal loc (Ploc.VaVal "foo")
    (MLast.TyArr loc (MLast.TyLid loc (Ploc.VaVal "int"))
       (MLast.TyLid loc (Ploc.VaVal "bool")));

The name "loc" is predefined. However, it is possible to change it, using the argument "-loc" of the Camlp5 shell commands.

Consequently, if there is no variable "loc" defined in the context of the quotation, or if it is not of the good type, a semantic error occur in the OCaml compiler ("Unbound value loc").

Note that in the extensible grammars, the variable "loc" is bound, in all semantic actions, to the location of the rule.

If the created node has no location, the programmer can define a variable named "loc" equal to "Ploc.dummy".

In patterns

When a quotation is in the context of a pattern, the location parameter of all nodes and possible sub-nodes is set to the wildcard ("_"). The same example above:

  <:sig_item< value foo : int -> bool >>

is equivalent, in a pattern, to:

  MLast.SgVal _ (Ploc.VaVal "foo")
    (MLast.TyArr _ (MLast.TyLid _ (Ploc.VaVal "int"))
       (MLast.TyLid _ (Ploc.VaVal "bool")))

Antiquotations

The expressions or patterns between dollar ($) characters are called antiquotations. In opposition to quotations which has its own syntax rules, the antiquotation is an area in the syntax of the enclosing context (expression or pattern). See the chapter about quotations.

If a quotation is in the context of an expression, the antiquotation must be an expression. It could be any expression, including function calls. Examples:

  value f e el = <:expr< [$e$ :: $loop False el$] >>;
  value patt_list p pl = <:patt< ( $list:[p::pl]$) >>;

If a quotation is in the context of an pattern, the antiquotation is a pattern. Any pattern is possible, including the wildcard character ("_"). Examples:

   fun [ <:expr< $lid:op$ $_$ $_$ >> -> op ]
   match p with [ <:patt< $_$ | $_$ >> -> Some p ]

Two kinds of antiquotations

Preliminary remark

In strict mode, we remark that most constructors defined of the module "MLast" are of type "Ploc.vala". This type is defined like this:

  type vala 'a =
    [ VaAnt of string
    | VaVal of 'a ]
  ;

The type argument is the real type of the node. For example, a value of type "bool" in transitional mode is frequently represented by a value of type "Ploc.vala bool".

The first case of the type "vala" corresponds to an antiquotation in the concrete syntax. The second case to a normal syntax situation, without antiquotation.

Example: in the "let" statement, the fact that it is "rec" or not is represented by a boolean. This boolean is, in the syntax tree, encapsulated with the type "Ploc.vala". The syntax tree of the two following lines:

  let x = y in z
  let rec x = y in z

start with, respectively:

  MLast.ExLet loc (Ploc.VaVal False)
    ... (* and so on *)

and:

  MLast.ExLet loc (Ploc.VaVal True)
    ... (* and so on *)

The case "Ploc.VaAnt s" is internally used by the parsers and by the quotation kit "q_ast.cmo" to record antiquotation strings representing the expression or the patterns having this value. For example, in this "let" statement:

  MLast.ExLet loc (Ploc.VaAnt s)
    ... (* and so on *)

The contents of this "s" is internally handled. For information, it contains the antiquotation string (kind included) together with representation of the location of the antiquotation in the quotation. See the next section.

Antiquoting

To antiquotate the fact that the "let" is with or without rec (a flag of type boolean), there are two ways.

direct antiquoting

The first way, hidding the type "Ploc.val", can be written with the antiquotation kind "flag":

  <:expr< let $flag:rf$ x = y in z >>

This corresponds to the syntax tree:

  MLast.ExLet loc (Ploc.VaVal rf)
     ... (* and so on *)

And, therefore, the type of the variable "rf" is simply "bool".

general antiquoting

The second way, introducing variables of type "Ploc.vala" can be written a kind prefixed by "_", namely here "_flag":

  <:expr< let $_flag:rf$ x = y in z >>

In that case, it corresponds to the syntax tree:

  MLast.ExLet loc rf
     ... (* and so on *)

And, therefore, the type of the variable "rf" is now "Ploc.vala bool".

Remarks

The first form of antiquotation ensures the compatibility with previous versions of Camlp5. The syntax tree is not the same, but the bound variables keep the same type.

All antiquotations kinds have these two forms: one with some name (e.g. "flag") and one with the same name prefixed by "a" (e.g. "aflag").

Nodes and Quotations

This section describes all nodes defined in the module "MLast" of Camlp5 and how to write them with quotations. Notice that, inside quotations, one is not restricted to these elementary cases, but any complex value can be used, resulting on possibly complex combined nodes.

The quotation forms are described here in revised syntax (like the rest of this document). In reality, it depends on which quotation kit is loaded:

• If "q_MLast.cmo" is used, the revised syntax is mandatory: the quotations must be in that syntax without any extension.
• If "q_ast.cmo" is used, the quotation syntax must be in the current user syntax with all extensions added to compile the file.

Last remark: in the following tables, the variables names give information of their types. The details can be found in the distributed source file "mLast.mli".

• e, e1, e2, e3: expr
• p, p1, p2, p3: patt
• t, t1, t2, e3: ctyp
• s: string
• b: bool
• me, me1, me2: module_expr
• mt, mt1, mt2: module_type
• le: list expr
• lp: list patt
• lt: list ctyp
• ls: list string
• lse: list (string * expr)
• lpe: list (patt * expr)
• lpp: list (patt * patt)
• lpoee: list (patt * option expr * expr)
• op: option patt
• lcstri: list class_str_item
• lcsigi: list class_sig_item

expr

Expressions of the language.

- access

<:expr< $e1$ . $e2$ >>
MLast.ExAcc loc e1 e2

- antiquotation (1)

<:expr< $anti:e$ >>
MLast.ExAnt loc e

- application

<:expr< $e1$ $e2$ >>
MLast.ExApp loc e1 e2

- array access

<:expr< $e1$ .( $e2$ ) >>
MLast.ExAre loc e1 e2

- array

<:expr< [| $list:le$ |] >>
MLast.ExArr loc (Ploc.VaVal le)

<:expr< [| $_list:le$ |] >>
MLast.ExArr loc le

- assert

<:expr< assert $e$ >>
MLast.ExAsr loc e

- assignment

<:expr< $e1$ := $e2$ >>
MLast.ExAss loc e1 e2

- big array access

<:expr< $e$ .{ $list:le$ } >>
MLast.ExBae loc e (Ploc.VaVal le)

<:expr< $e$ .{ $_list:le$ } >>
MLast.ExBae loc e le

- character constant

<:expr< $chr:s$ >>
MLast.ExChr loc (Ploc.VaVal s)

<:expr< $_chr:s$ >>
MLast.ExChr loc s

- coercion with type constraint

<:expr< ($e$ : $t1$ :> $t2$) >>
MLast.ExCoe loc e (Some t1) t2

- coercion without type constraint

<:expr< ($e$ :> $t2$) >>
MLast.ExCoe loc e None t2

- float constant

<:expr< $flo:s$ >>
MLast.ExFlo loc (Ploc.VaVal s)

<:expr< $_flo:s$ >>
MLast.ExFlo loc s

- for loop

<:expr< for $lid:s$ = $e1$ $to:b$ $e2$ do { $list:le$ } >>
MLast.ExFor loc (Ploc.VaVal s) e1 e2 (Ploc.VaVal b) (Ploc.VaVal le)

<:expr< for $_lid:s$ = $e1$ $_to:b$ $e2$ do { $_list:le$ } >>
MLast.ExFor loc s e1 e2 b le

- function

<:expr< fun [ $list:lpwe$ ] >>
MLast.ExFun loc (Ploc.VaVal lpwe)

<:expr< fun [ $_list:lpwe$ ] >>
MLast.ExFun loc lpwe

- if

<:expr< if $e1$ then $e2$ else $e3$ >>
MLast.ExIfe loc e1 e2 e3

- integer constant

<:expr< $int:s$ >>
MLast.ExInt loc (Ploc.VaVal s) ""

<:expr< $_int:s$ >>
MLast.ExInt loc s ""

- integer 32 bits

<:expr< $int32:s$ >>
MLast.ExInt loc (Ploc.VaVal s) "l"

<:expr< $_int32:s$ >>
MLast.ExInt loc s "l"

- integer 64 bits

<:expr< $int64:s$ >>
MLast.ExInt loc (Ploc.VaVal s) "L"

<:expr< $_int64:s$ >>
MLast.ExInt loc s "L"

- native integer

<:expr< $nativeint:s$ >>
MLast.ExInt loc (Ploc.VaVal s) "n"

<:expr< $_nativeint:s$ >>
MLast.ExInt loc s "n"

- label

<:expr< ~$s$ >>
MLast.ExLab loc (Ploc.VaVal s) None

<:expr< ~$_:s$ >>
MLast.ExLab loc s None

<:expr< ~$s$: $e$ >>
MLast.ExLab loc (Ploc.VaVal s) (Some e)

<:expr< ~$_:s$: $e$ >>
MLast.ExLab loc s (Some e)

- lazy

<:expr< lazy $e$ >>
MLast.ExLaz loc e

- let binding

<:expr< let $flag:b$ $list:lpe$ in $e$ >>
MLast.ExLet loc (Ploc.VaVal b) (Ploc.VaVal lpe) e

<:expr< let $_flag:b$ $_list:lpe$ in $e$ >>
MLast.ExLet loc b lpe e

- lowercase identifier

<:expr< $lid:s$ >>
MLast.ExLid loc (Ploc.VaVal s)

<:expr< $_lid:s$ >>
MLast.ExLid loc s

- let module

<:expr< let module $uid:s$ = $me$ in $e$ >>
MLast.ExLmd loc (Ploc.VaVal s) me e

<:expr< let module $_uid:s$ = $me$ in $e$ >>
MLast.ExLmd loc s me e

- match

<:expr< match $e$ with [ $list:lpwe$ ] >>
MLast.ExMat loc e (Ploc.VaVal lpwe)

<:expr< match $e$ with [ $_list:lpwe$ ] >>
MLast.ExMat loc e lpwe

- new

<:expr< new $list:ls$ >>
MLast.ExNew loc (Ploc.VaVal ls)

<:expr< new $_list:ls$ >>
MLast.ExNew loc ls

- object expression

<:expr< object $opt:op$ $list:lcstri$ end >>
MLast.ExObj loc (Ploc.VaVal op) (Ploc.VaVal lcstri)

<:expr< object $_opt:op$ $_list:lcstri$ end >>
MLast.ExObj loc op lcstri

- optional label

<:expr< ?$s$ >>
MLast.ExOlb loc (Ploc.VaVal s) None

<:expr< ?$_:s$ >>
MLast.ExOlb loc s None

<:expr< ?$s$: $e$ >>
MLast.ExOlb loc (Ploc.VaVal s) (Some e)

<:expr< ?$_:s$: $e$ >>
MLast.ExOlb loc s (Some e)

- override

<:expr< {< $list:lse$ >} >>
MLast.ExOvr loc (Ploc.VaVal lse)

<:expr< {< $_list:lse$ >} >>
MLast.ExOvr loc lse

- record

<:expr< { $list:lpe$ } >>
MLast.ExRec loc (Ploc.VaVal lpe) None

<:expr< { $_list:lpe$ } >>
MLast.ExRec loc lpe None

<:expr< { ($e$) with $list:lpe$ } >>
MLast.ExRec loc (Ploc.VaVal lpe) (Some e)

<:expr< { ($e$) with $_list:lpe$ } >>
MLast.ExRec loc lpe (Some e)

- sequence

<:expr< do { $list:le$ } >>
MLast.ExSeq loc (Ploc.VaVal le)

<:expr< do { $_list:le$ } >>
MLast.ExSeq loc le

- send

<:expr< $e$ # $lid:s$ >>
MLast.ExSnd loc e (Ploc.VaVal s)

<:expr< $e$ # $_lid:s$ >>
MLast.ExSnd loc e s

- string element

<:expr< $e1$ .[ $e2$ ] >>
MLast.ExSte loc e1 e2

- string

<:expr< $str:s$ >>
MLast.ExStr loc (Ploc.VaVal s)

<:expr< $_str:s$ >>
MLast.ExStr loc s

- try

<:expr< try $e$ with [ $list:lpwe$ ] >>
MLast.ExTry loc e (Ploc.VaVal lpwe)

<:expr< try $e$ with [ $_list:lpwe$ ] >>
MLast.ExTry loc e lpwe

- tuple

<:expr< ($list:le$) >>
MLast.ExTup loc (Ploc.VaVal le)

<:expr< ($_list:le$) >>
MLast.ExTup loc le

- type constraint

<:expr< ($e$ : $t$) >>
MLast.ExTyc loc e t

- uppercase identifier

<:expr< $uid:s$ >>
MLast.ExUid loc (Ploc.VaVal s)

<:expr< $_uid:s$ >>
MLast.ExUid loc s

- variant

<:expr< `$s$ >>
MLast.ExVrn loc (Ploc.VaVal s)

<:expr< `$_:s$ >>
MLast.ExVrn loc s

- while loop

<:expr< while $e$ do { $list:le$ } >>
MLast.ExWhi loc e (Ploc.VaVal le)

<:expr< while $e$ do { $_list:le$ } >>
MLast.ExWhi loc e le

- extra node (2)

... no representation ...
MLast.ExXtr loc s oe

patt

Patterns of the language.

- access

<:patt< $p1$ . $p2$ >>
MLast.PaAcc loc p1 p2

- alias

<:patt< ($p1$ as $p2$) >>
MLast.PaAli loc p1 p2

- antiquotation (1)

<:patt< $anti:p$ >>
MLast.PaAnt loc p

- any

<:patt< _ >>
MLast.PaAny loc

- application

<:patt< $p1$ $p2$ >>
MLast.PaApp loc p1 p2

- array

<:patt< [| $list:lp$ |] >>
MLast.PaArr loc (Ploc.VaVal lp)

<:patt< [| $_list:lp$ |] >>
MLast.PaArr loc lp

- character

<:patt< $chr:s$ >>
MLast.PaChr loc (Ploc.VaVal s)

<:patt< $_chr:s$ >>
MLast.PaChr loc s

- integer constant

<:patt< $int:s$ >>
MLast.PaInt loc (Ploc.VaVal s) ""

<:patt< $_int:s$ >>
MLast.PaInt loc s ""

- integer 32 bits

<:patt< $int32:s$ >>
MLast.PaInt loc (Ploc.VaVal s) "l"

<:patt< $_int32:s$ >>
MLast.PaInt loc s "l"

- integer 64 bits

<:patt< $int64:s$ >>
MLast.PaInt loc (Ploc.VaVal s) "L"

<:patt< $_int:s$ >>
MLast.PaInt loc s "L"

- native integer

<:patt< $nativeint:s$ >>
MLast.PaInt loc (Ploc.VaVal s) "n"

<:patt< $_nativeint:s$ >>
MLast.PaInt loc s "n"

- float

<:patt< $flo:s$ >>
MLast.PaFlo loc (Ploc.VaVal s)

<:patt< $_flo:s$ >>
MLast.PaFlo loc s

- label

<:patt< ~$s$ >>
MLast.PaLab loc (Ploc.VaVal s) None

<:patt< ~$_:s$ >>
MLast.PaLab loc s None

<:patt< ~$s$: $p$ >>
MLast.PaLab loc (Ploc.VaVal s) (Some p)

<:patt< ~$_s$: $p$ >>
MLast.PaLab loc s (Some p)

- lowercase identifier

<:patt< $lid:s$ >>
MLast.PaLid loc (Ploc.VaVal s)

<:patt< $_lid:s$ >>
MLast.PaLid loc s

- optional label

<:patt< ?$s$ >>
MLast.PaOlb loc (Ploc.VaVal s) None

<:patt< ?$_:s$ >>
MLast.PaOlb loc s None

<:patt< ?$s$: ($p$) >>
MLast.PaOlb loc (Ploc.VaVal s) (Some (p, Ploc.VaVal None))

<:patt< ?$_:s$: ($p$) >>
MLast.PaOlb loc s (Some (p, Ploc.VaVal None))

<:patt< ?$s$: ($p$ = $e$) >>
MLast.PaOlb loc (Ploc.VaVal s) (Some (p, Ploc.VaVal (Some e)))

<:patt< ?$_:s$: ($p$ = $e$) >>
MLast.PaOlb loc s (Some (p, Ploc.VaVal (Some e)))

- or

<:patt< $p1$ | $p2$ >>
MLast.PaOrp loc p1 p2

- range

<:patt< $p1$ .. $p2$ >>
MLast.PaRng loc p1 p2

- record

<:patt< { $list:lpp$ } >>
MLast.PaRec loc (Ploc.VaVal lpp)

<:patt< { $_list:lpp$ } >>
MLast.PaRec loc lpp

- string

<:patt< $str:s$ >>
MLast.PaStr loc (Ploc.VaVal s)

<:patt< $_str:s$ >>
MLast.PaStr loc s

- tuple

<:patt< ($list:lp$) >>
MLast.PaTup loc (Ploc.VaVal lp)

<:patt< ($_list:lp$) >>
MLast.PaTup loc lp

- type constraint

<:patt< ($p$ : $t$) >>
MLast.PaTyc loc p t

- type pattern

<:patt< # $list:ls$ >>
MLast.PaTyp loc (Ploc.VaVal ls)

<:patt< # $_list:ls$ >>
MLast.PaTyp loc ls

- uppercase identifier

<:patt< $uid:s$ >>
MLast.PaUid loc (Ploc.VaVal s)

<:patt< $_uid:s$ >>
MLast.PaUid loc s

- variant

<:patt< ` $s$ >>
MLast.PaVrn loc (Ploc.VaVal s)

<:patt< ` $_:s$ >>
MLast.PaVrn loc s

- extra node (2)

... no representation ...
MLast.PaXtr loc s op

ctyp

Type expressions of the language.

- access

<:ctyp< $t1$ . $t2$ >>
MLast.TyAcc loc t1 t2

- alias

<:ctyp< $t1$ as $t2$ >>
MLast.TyAli loc t1 t2

- any

<:ctyp< _ >>
MLast.TyAny loc

- application

<:ctyp< $t1$ $t2$ >>
MLast.TyApp loc t1 t2

- arrow

<:ctyp< $t1$ -> $t2$ >>
MLast.TyArr loc t1 t2

- class

<:ctyp< # $list:ls$ >>
MLast.TyCls loc (Ploc.VaVal ls)

<:ctyp< # $_list:ls$ >>
MLast.TyCls loc ls

- label

<:ctyp< ~$s$: $t$ >>
MLast.TyLab loc (Ploc.VaVal s) t

<:ctyp< ~$_:s$: $t$ >>
MLast.TyLab loc s t

- lowercase identifier

<:ctyp< $lid:s$ >>
MLast.TyLid loc (Ploc.VaVal s)

<:ctyp< $_lid:s$ >>
MLast.TyLid loc s

- manifest

<:ctyp< $t1$ == $t2$ >>
MLast.TyMan loc t1 t2

- object

<:ctyp< < $list:lst$ > >>
MLast.TyObj loc (Ploc.VaVal lst) (Ploc.VaVal False)

<:ctyp< < $_list:lst$ > >>
MLast.TyObj loc lst (Ploc.VaVal False)

<:ctyp< < $list:lst$ .. > >>
MLast.TyObj loc (Ploc.VaVal lst) (Ploc.VaVal True)

<:ctyp< < $_list:lst$ .. > >>
MLast.TyObj loc lst (Ploc.VaVal True)

<:ctyp< < $list:lst$ $flag:b$ > >>
MLast.TyObj loc (Ploc.VaVal lst) (Ploc.VaVal b)

<:ctyp< < $_list:lst$ $_flag:b$ > >>
MLast.TyObj loc lst b

- optional label

<:ctyp< ?$s$: $t$ >>
MLast.TyOlb loc (Ploc.VaVal s) t

<:ctyp< ?$_:s$: $t$ >>
MLast.TyOlb loc s t

- polymorph

<:ctyp< ! $list:ls$ . $t$ >>
MLast.TyPol loc (Ploc.VaVal ls) t

<:ctyp< ! $_list:ls$ . $t$ >>
MLast.TyPol loc ls t

- variable

<:ctyp< ' $s$ >>
MLast.TyQuo loc (Ploc.VaVal s)

<:ctyp< ' $_:s$ >>
MLast.TyQuo loc s

- record

<:ctyp< { $list:llsbt$ } >>
MLast.TyRec loc (Ploc.VaVal llsbt)

<:ctyp< { $_list:llsbt$ } >>
MLast.TyRec loc llsbt

- sum

<:ctyp< [ $list:llslt$ ] >>
MLast.TySum loc (Ploc.VaVal llslt)

<:ctyp< [ $_list:llslt$ ] >>
MLast.TySum loc llslt

- tuple

<:ctyp< ( $list:lt$ ) >>
MLast.TyTup loc (Ploc.VaVal lt)

<:ctyp< ( $_list:lt$ ) >>
MLast.TyTup loc lt

- uppercase identifier

<:ctyp< $uid:s$ >>
MLast.TyUid loc (Ploc.VaVal s)

<:ctyp< $_uid:s$ >>
MLast.TyUid loc s

- variant

<:ctyp< [ = $list:lpv$ ] >>
MLast.TyVrn loc (Ploc.VaVal lpv) None

<:ctyp< [ = $_list:lpv$ ] >>
MLast.TyVrn loc lpv None

<:ctyp< [ > $list:lpv$ ] >>
MLast.TyVrn loc (Ploc.VaVal lpv) (Some None)

<:ctyp< [ > $_list:lpv$ ] >>
MLast.TyVrn loc lpv (Some None)

<:ctyp< [ < $list:lpv$ ] >>
MLast.TyVrn loc (Ploc.VaVal lpv) (Some(Some (Ploc.VaVal [])))

<:ctyp< [ < $_list:lpv$ ] >>
MLast.TyVrn loc lpv (Some (Some (Ploc.VaVal [])))

<:ctyp< [ < $list:lpv$ > $list:ls$ ] >>
MLast.TyVrn loc (Ploc.VaVal lpv) (Some (Some (Ploc.VaVal ls)))

<:ctyp< [ < $_list:lpv$ > $_list:ls$ ] >>
MLast.TyVrn loc lpv (Some (Some ls))

- extra node (1)

... no representation ...
MLast.TyXtr loc s ot

modules...

str_item

Structure items, i.e. phrases in a ".ml" file or "struct"s elements.

- class declaration

<:str_item< class $list:lcd$ >>
MLast.StCls loc (Ploc.VaVal lcd)

<:str_item< class $_list:lcd$ >>
MLast.StCls loc lcd

- class type declaration

<:str_item< class type $list:lctd$ >>
MLast.StClt loc (Ploc.VaVal lctd)

<:str_item< class type $_list:lctd$ >>
MLast.StClt loc lctd

- declare

<:str_item< declare $list:lstri$ end >>
MLast.StDcl loc (Ploc.VaVal lstri)

<:str_item< declare $_list:lstri$ end >>
MLast.StDcl loc lstri

- directive

<:str_item< # $s$ >>
MLast.StDir loc (Ploc.VaVal s) (Ploc.VaVal None)

<:str_item< # $_:s$ >>
MLast.StDir loc s (Ploc.VaVal None)

<:str_item< # $s$ $e$ >>
MLast.StDir loc (Ploc.VaVal s) (Ploc.VaVal (Some e))

<:str_item< # $_:s$ $e$ >>
MLast.StDir loc s (Ploc.VaVal (Some e))

<:str_item< # $s$ $opt:oe$ >>
MLast.StDir loc (Ploc.VaVal s) (Ploc.VaVal oe)

<:str_item< # $_:s$ $_opt:oe$ >>
MLast.StDir loc s oe

- exception

<:str_item< exception $s$ of $list:lt$ >>
MLast.StExc loc (Ploc.VaVal s) (Ploc.VaVal lt) (Ploc.VaVal [])

<:str_item< exception $_:s$ of $_list:lt$ >>
MLast.StExc loc s lt (Ploc.VaVal [])

<:str_item< exception $s$ of $list:lt$ = $list:ls$ >>
MLast.StExc loc (Ploc.VaVal s) (Ploc.VaVal lt) (Ploc.VaVal ls)

<:str_item< exception $_:s$ of $_list:lt$ = $_list:ls$ >>
MLast.StExc loc s lt ls

- expression

<:str_item< $exp:e$ >>
MLast.StExp loc e

- external

<:str_item< external $s$ : $t$ = $list:ls$ >>
MLast.StExt loc (Ploc.VaVal s) t (Ploc.VaVal ls)

<:str_item< external $_:s$ : $t$ = $_list:ls$ >>
MLast.StExt loc s t ls

- include

<:str_item< include $me$ >>
MLast.StInc loc me

- module

<:str_item< module $flag:b$ $list:lsme$ >>
MLast.StMod loc (Ploc.VaVal b) (Ploc.VaVal lsme)

<:str_item< module $_flag:b$ $_list:lsme$ >>
MLast.StMod loc b lsme

- module type

<:str_item< module type $s$ = $mt$ >>
MLast.StMty loc (Ploc.VaVal s) mt

<:str_item< module type $_:s$ = $mt$ >>
MLast.StMty loc s mt

- open

<:str_item< open $list:ls$ >>
MLast.StOpn loc (Ploc.VaVal ls)

<:str_item< open $_list:ls$ >>
MLast.StOpn loc ls

- type declaration

<:str_item< type $list:ltd$ >>
MLast.StTyp loc (Ploc.VaVal ltd)

<:str_item< type $_list:ltd$ >>
MLast.StTyp loc ltd

- use (1)

<:str_item< ...internal use... >>
MLast.StUse loc s lstrib

- value

<:str_item< value $flag:b$ $list:lpe$ >>
MLast.StVal loc (Ploc.VaVal b) (Ploc.VaVal lpe)

<:str_item< value $_flag:b$ $_list:lpe$ >>
MLast.StVal loc b lpe

- extra node (2)

... no representation ...
MLast.StXtr loc s ot

sig_item

Signature items, i.e. phrases in a ".mli" file or "sig"s elements.

- class

<:sig_item< class $list:lcd$ >>
MLast.SgCls loc (Ploc.VaVal lcd)

<:sig_item< class $_list:lcd$ >>
MLast.SgCls loc lcd

- class type

<:sig_item< class type $list:lct$ >>
MLast.SgClt loc (Ploc.VaVal lct)

<:sig_item< class type $_list:lct$ >>
MLast.SgClt loc lct

- declare

<:sig_item< declare $list:lsigi$ end >>
MLast.SgDcl loc (Ploc.VaVal lsigi)

<:sig_item< declare $_list:lsigi$ end >>
MLast.SgDcl loc lsigi

- directive

<:sig_item< # $s$ >>
MLast.SgDir loc (Ploc.VaVal s) (Ploc.VaVal None)

<:sig_item< # $_:s$ >>
MLast.SgDir loc s (Ploc.VaVal None)

<:sig_item< # $s$ $e$ >>
MLast.SgDir loc (Ploc.VaVal s) (Ploc.VaVal (Some e))

<:sig_item< # $_:s$ $e$ >>
MLast.SgDir loc s (Ploc.VaVal (Some e))

<:sig_item< # $s$ $opt:oe$ >>
MLast.SgDir loc (Ploc.VaVal s) (Ploc.VaVal oe)

<:sig_item< # $_:s$ $_opt:oe$ >>
MLast.SgDir loc s oe

- exception

<:sig_item< exception $s$ >>
MLast.SgExc loc (Ploc.VaVal s) (Ploc.VaVal [])

<:sig_item< exception $_:s$ >>
MLast.SgExc loc s (Ploc.VaVal [])

<:sig_item< exception $s$ of $list:lt$ >>
MLast.SgExc loc (Ploc.VaVal s) (Ploc.VaVal lt)

<:sig_item< exception $_:s$ of $_list:lt$ >>
MLast.SgExc loc s lt

- external

<:sig_item< external $s$ : $t$ = $list:ls$ >>
MLast.SgExt loc (Ploc.VaVal s) t (Ploc.VaVal ls)

<:sig_item< external $_:s$ : $t$ = $_list:ls$ >>
MLast.SgExt loc s t ls

- include

<:sig_item< include $me$ >>
MLast.SgInc loc me

- module

<:sig_item< module $flag:b$ $list:lsmt$ >>
MLast.SgMod loc (Ploc.VaVal b) (Ploc.VaVal lsmt)

<:sig_item< module $_flag:b$ $_list:lsmt$ >>
MLast.SgMod loc b lsmt

- module type

<:sig_item< module type $s$ = $mt$ >>
MLast.SgMty loc (Ploc.VaVal s) mt

<:sig_item< module type $_:s$ = $mt$ >>
MLast.SgMty loc s mt

- open

<:sig_item< open $list:ls$ >>
MLast.SgOpn loc (Ploc.VaVal ls)

<:sig_item< open $_list:ls$ >>
MLast.SgOpn loc ls

- type declaration

<:sig_item< type $list:ltd$ >>
MLast.SgTyp loc (Ploc.VaVal ltd)

<:sig_item< type $_list:ltd$ >>
MLast.SgTyp loc ltd

- use (1)

<:sig_item< ...internal use... >>
MLast.SgUse loc s lstrib

- value

<:sig_item< value $s$ : $t$ >>
MLast.SgVal loc (Ploc.VaVal s) t

<:sig_item< value $_:s$ : $t$ >>
MLast.SgVal loc s t

- extra node (2)

... no representation ...
MLast.SgXtr loc s ot

module_expr

- access

<:module_expr< $me1$ . $me2$ >>
MLast.MeAcc loc me1 me2

- application

<:module_expr< $me1$ $me2$ >>
MLast.MeApp loc me1 me2

- functor

<:module_expr< functor ($s$ : $mt$) -> $me$ >>
MLast.MeFun loc (Ploc.VaVal s) mt me

<:module_expr< functor ($_:s$ : $mt$) -> $me$ >>
MLast.MeFun loc s mt me

- struct

<:module_expr< struct $list:lstri$ end >>
MLast.MeStr loc (Ploc.VaVal lstri)

<:module_expr< struct $_list:lstri$ end >>
MLast.MeStr loc lstri

- module type constraint

<:module_expr< ($me$ : $mt$) >>
MLast.MeTyc loc me mt

- uppercase identifier

<:module_expr< $uid:s$ >>
MLast.MeUid loc (Ploc.VaVal s)

<:module_expr< $_uid:s$ >>
MLast.MeUid loc s

- extra node (1)

... no representation ...
MLast.MeXtr loc s ot

module_type

- access

<:module_type< $mt1$ . $mt2$ >>
MLast.MtAcc loc mt1 mt2

- application

<:module_type< $mt1$ $mt2$ >>
MLast.MtApp loc mt1 mt2

- functor

<:module_type< functor ($s$ : $mt1$) -> $mt2$ >>
MLast.MtFun loc (Ploc.VaVal s) mt1 mt2

<:module_type< functor ($_:s$ : $mt1$) -> $mt2$ >>
MLast.MtFun loc s mt1 mt2

- lowercase identifier

<:module_type< $lid:s$ >>
MLast.MtLid loc (Ploc.VaVal s)

<:module_type< $_lid:s$ >>
MLast.MtLid loc s

- abstract

<:module_type< ' $s$ >>
MLast.MtQuo loc (Ploc.VaVal s)

<:module_type< ' $_:s$ >>
MLast.MtQuo loc s

- signature

<:module_type< sig $list:lsigi$ end >>
MLast.MtSig loc (Ploc.VaVal lsigi)

<:module_type< sig $_list:lsigi$ end >>
MLast.MtSig loc lsigi

- uppercase identifier

<:module_type< $uid:s$ >>
MLast.MtUid loc (Ploc.VaVal s)

<:module_type< $_uid:s$ >>
MLast.MtUid loc s

- with construction

<:module_type< $mt$ with $list:lwc$ >>
MLast.MtWit loc mt (Ploc.VaVal lwc)

<:module_type< $mt$ with $_list:lwc$ >>
MLast.MtWit loc mt lwc

- extra node (1)

... no representation ...
MLast.MtXtr loc s ot

classes...

class_expr

- application

<:class_expr< $ce$ $e$ >>
MLast.CeApp loc ce e

- constructor

<:class_expr< $list:ls$ [ $list:lt$ ] >>
MLast.CeCon loc (Ploc.VaVal ls) (Ploc.VaVal lt)

<:class_expr< $_list:ls$ [ $_list:lt$ ] >>
MLast.CeCon loc ls lt

- function

<:class_expr< fun $p$ -> $ce$ >>
MLast.CeFun loc p ce

- let binding

<:class_expr< let $flag:b$ $list:lpe$ in $ce$ >>
MLast.CeLet loc (Ploc.VaVal b) (Ploc.VaVal lpe) ce

<:class_expr< let $_flag:b$ $_list:lpe$ in $ce$ >>
MLast.CeLet loc b lpe ce

- object

<:class_expr< object $opt:op$ $list:lcstri$ end >>
MLast.CeStr loc (Ploc.VaVal op) (Ploc.VaVal lcstri)

<:class_expr< object $_opt:op$ $_list:lcstri$ end >>
MLast.CeStr loc op lcstri

- class type constraint

<:class_expr< ($ce$ : $ct$) >>
MLast.CeTyc loc ce ct

class_type

- constructor

<:class_type< $list:ls$ [ $list:lt$ ] >>
MLast.CtCon loc (Ploc.VaVal ls) (Ploc.VaVal lt)

<:class_type< $_list:ls$ [ $_list:lt$ ] >>
MLast.CtCon loc ls lt

- arrow

<:class_type< [ $t$ ] -> $ct$ >>
MLast.CtFun loc t ct

- object

<:class_type< object $list:lcsigi$ end >>
MLast.CtSig loc (Ploc.VaVal None) (Ploc.VaVal lcsigi)

<:class_type< object $_list:lcsigi$ end >>
MLast.CtSig loc (Ploc.VaVal None) lcsigi

<:class_type< object ($t$) $list:lcsigi$ end >>
MLast.CtSig loc (Ploc.VaVal (Some t)) (Ploc.VaVal lcsigi)

<:class_type< object ($t$) $_list:lcsigi$ end >>
MLast.CtSig loc (Ploc.VaVal (Some t)) lcsigi

<:class_type< object $opt:ot$ $list:lcsigi$ end >>
MLast.CtSig loc (Ploc.VaVal ot) (Ploc.VaVal lcsigi)

<:class_type< object $_opt:ot$ $_list:lcsigi$ end >>
MLast.CtSig loc ot lcsigi

class_str_item

- type constraint

<:class_str_item< type $t1$ = $t2$ >>
MLast.CrCtr loc t1 t2

- declaration list

<:class_str_item< declare $list:lcstri$ end >>
MLast.CrDcl loc (Ploc.VaVal lcstri)

<:class_str_item< declare $_list:lcstri$ end >>
MLast.CrDcl loc lcstri

- inheritance

<:class_str_item< inherit $ce$ >>
MLast.CrInh loc ce (Ploc.VaVal None)

<:class_str_item< inherit $ce$ $_opt:os$ >>
MLast.CrInh loc ce os

- initialization

<:class_str_item< initializer $e$ >>
MLast.CrIni loc e

- method

<:class_str_item< method $s$ = $e$ >>
MLast.CrMth loc (Ploc.VaVal s) (Ploc.VaVal False) e (Ploc.VaVal None)

<:class_str_item< method $_:s$ = $e$ >>
MLast.CrMth loc s (Ploc.VaVal False) e (Ploc.VaVal None)

<:class_str_item< method $s$ : $t$ = $e$ >>
MLast.CrMth loc (Ploc.VaVal s) (Ploc.VaVal False) e (Ploc.VaVal (Some t))

<:class_str_item< method $_:s$ : $t$ = $e$ >>
MLast.CrMth loc s (Ploc.VaVal False) e (Ploc.VaVal (Some t))

<:class_str_item< method private $s$ = $e$ >>
MLast.CrMth loc (Ploc.VaVal s) (Ploc.VaVal True) e (Ploc.VaVal None)

<:class_str_item< method private $_:s$ = $e$ >>
MLast.CrMth loc s (Ploc.VaVal True) e (Ploc.VaVal None)

<:class_str_item< method private $s$ : $t$ = $e$ >>
MLast.CrMth loc (Ploc.VaVal s) (Ploc.VaVal True) e (Ploc.VaVal (Some t))

<:class_str_item< method private $_:s$ : $t$ = $e$ >>
MLast.CrMth loc s (Ploc.VaVal True) e (Ploc.VaVal (Some t))

<:class_str_item< method $flag:b$ $s$ $opt:ot$ = $e$ >>
MLast.CrMth loc (Ploc.VaVal s) (Ploc.VaVal b) e (Ploc.VaVal ot)
<:class_str_item< method $_flag:b$ $_:s$ $_opt:ot$ = $e$ >>
MLast.CrMth loc s b e ot

- value

<:class_str_item< value $s$ = $e$ >>
MLast.CrVal loc (Ploc.VaVal s) (Ploc.VaVal False) e

<:class_str_item< value $_:s$ = $e$ >>
MLast.CrVal loc s (Ploc.VaVal False) e

<:class_str_item< value mutable $s$ = $e$ >>
MLast.CrVal loc (Ploc.VaVal s) (Ploc.VaVal True) e

<:class_str_item< value mutable $_:s$ = $e$ >>
MLast.CrVal loc s (Ploc.VaVal True) e

<:class_str_item< value $flag:b$ $s$ = $e$ >>
MLast.CrVal loc (Ploc.VaVal s) (Ploc.VaVal b) e

<:class_str_item< value $_flag:b$ $_:s$ = $e$ >>
MLast.CrVal loc s b e

- virtual method

<:class_str_item< method virtual $s$ : $t$ >>
MLast.CrVir loc (Ploc.VaVal s) (Ploc.VaVal False) t

<:class_str_item< method virtual $_:s$ : $t$ >>
MLast.CrVir loc s (Ploc.VaVal False) t

<:class_str_item< method virtual private $s$ : $t$ >>
MLast.CrVir loc (Ploc.VaVal s) (Ploc.VaVal True) t

<:class_str_item< method virtual private $_:s$ : $t$ >>
MLast.CrVir loc s (Ploc.VaVal True) t

<:class_str_item< method virtual $flag:b$ $s$ : $t$ >>
MLast.CrVir loc (Ploc.VaVal s) (Ploc.VaVal b) t

<:class_str_item< method virtual $_flag:b$ $_:s$ : $t$ >>
MLast.CrVir loc s b t

class_sig_item

- type constraint

<:class_sig_item< type $t1$ = $t2$ >>
MLast.CgCtr loc t1 t2

- declare

<:class_sig_item< declare $list:lcsigi$ end >>
MLast.CgDcl loc (Ploc.VaVal lcsigi)

<:class_sig_item< declare $_list:lcsigi$ end >>
MLast.CgDcl loc lcsigi

- inheritance

<:class_sig_item< inherit $ct$ >>
MLast.CgInh loc ct

- method

<:class_sig_item< method $s$ : $t$ >>
MLast.CgMth loc (Ploc.VaVal s) (Ploc.VaVal False) t

<:class_sig_item< method $_:s$ : $t$ >>
MLast.CgMth loc s (Ploc.VaVal False) t

<:class_sig_item< method private $s$ : $t$ >>
MLast.CgMth loc (Ploc.VaVal s) (Ploc.VaVal True) t

<:class_sig_item< method private $_:s$ : $t$ >>
MLast.CgMth loc s (Ploc.VaVal True) t

<:class_sig_item< method $flag:b$ $s$ : $t$ >>
MLast.CgMth loc (Ploc.VaVal s) (Ploc.VaVal b) t

<:class_sig_item< method $_flag:b$ $_:s$ : $t$ >>
MLast.CgMth loc s b t

- value

<:class_sig_item< value $s$ : $t$ >>
MLast.CgVal loc (Ploc.VaVal s) (Ploc.VaVal False) t

<:class_sig_item< value $_:s$ : $t$ >>
MLast.CgVal loc s (Ploc.VaVal False) t

<:class_sig_item< value mutable $s$ : $t$ >>
MLast.CgVal loc (Ploc.VaVal s) (Ploc.VaVal True) t

<:class_sig_item< value mutable $_:s$ : $t$ >>
MLast.CgVal loc s (Ploc.VaVal True) t

<:class_sig_item< value $flag:b$ $s$ : $t$ >>
MLast.CgVal loc (Ploc.VaVal s) (Ploc.VaVal b) t

<:class_sig_item< value $_flag:b$ $_:s$ : $t$ >>
MLast.CgVal loc s b t

- method virtual

<:class_sig_item< method virtual $s$ : $t$ >>
MLast.CgVir loc (Ploc.VaVal s) (Ploc.VaVal False) t

<:class_sig_item< method virtual $_:s$ : $t$ >>
MLast.CgVir loc s (Ploc.VaVal False) t

<:class_sig_item< method virtual private $s$ : $t$ >>
MLast.CgVir loc (Ploc.VaVal s) (Ploc.VaVal True) t

<:class_sig_item< method virtual private $_:s$ : $t$ >>
MLast.CgVir loc s (Ploc.VaVal True) t

<:class_sig_item< method virtual $flag:b$ $s$ : $t$ >>
MLast.CgVir loc (Ploc.VaVal s) (Ploc.VaVal b) t

<:class_sig_item< method virtual $_flag:b$ $_:s$ : $t$ >>
MLast.CgVir loc s b t

other

with_constr

"With" possibly following a module type.

- with type

<:with_constr< type $s$ $list:ltv$ = $t$ >>
MLast.WcTyp loc (Ploc.VaVal s) (Ploc.VaVal ltv) (Ploc.VaVal False) t

<:with_constr< type $_:s$ $_list:ltv$ = $t$ >>
MLast.WcTyp loc s ltv (Ploc.VaVal False) t

<:with_constr< type $s$ $list:ltv$ = private $t$ >>
MLast.WcTyp loc (Ploc.VaVal s) (Ploc.VaVal ltv) (Ploc.VaVal True) t

<:with_constr< type $_:s$ $_list:ltv$ = private $t$ >>
MLast.WcTyp loc s ltv (Ploc.VaVal True) t

<:with_constr< type $s$ $list:ltv$ = $flag:b$ $t$ >>
MLast.WcTyp loc (Ploc.VaVal s) (Ploc.VaVal ltv) (Ploc.VaVal b) t

<:with_constr< type $_:s$ $_list:ltv$ = $_flag:b$ $t$ >>
MLast.WcTyp loc s ltv b t

- with module

<:with_constr< module $list:ls$ = $me$ >>
MLast.WcMod loc (Ploc.VaVal ls) me

<:with_constr< module $_list:ls$ = $me$ >>
MLast.WcMod loc ls me

poly_variant

Polymorphic variants.

- constructor

<:poly_variant< ` $s$ >>
MLast.PvTag (Ploc.VaVal s) (Ploc.VaVal True) (Ploc.VaVal [])

<:poly_variant< ` $_:s$ >>
MLast.PvTag s (Ploc.VaVal True) (Ploc.VaVal [])

<:poly_variant< ` $s$ of $list:lt$ >>
MLast.PvTag (Ploc.VaVal s) (Ploc.VaVal False) (Ploc.VaVal lt)

<:poly_variant< ` $_:s$ of $_list:lt$ >>
MLast.PvTag s (Ploc.VaVal False) lt

<:poly_variant< ` $s$ of & $list:lt$ >>
MLast.PvTag (Ploc.VaVal s) (Ploc.VaVal True) (Ploc.VaVal lt)

<:poly_variant< ` $_:s$ of & $_list:lt$ >>
MLast.PvTag s (Ploc.VaVal True) lt

<:poly_variant< ` $s$ of $flag:b$ $list:lt$ >>
MLast.PvTag (Ploc.VaVal s) (Ploc.VaVal b) (Ploc.VaVal lt)

<:poly_variant< ` $_:s$ of $_flag:b$ $_list:lt$ >>
MLast.PvTag s b lt

- type

<:poly_variant< $t$ >>
MLast.PvInh t

Nodes without quotations

Some types defined in the AST tree module "MLast" don't have an associated quotation. They are:

• type_var
• type_decl
• class_infos

type_var

The type "type_var" is defined as:

  type type_var = (Ploc.vala string * (bool * bool));

The first boolean is "True" if the type variable is prefixed by "+" ("plus" sign). The second boolean is "True" if the type variable is prefixed by "-" ("minus" sign).

type_decl

The type "type_decl" is a record type corresponding to a type declaration. Its definition is:

  type type_decl =
    { tdNam : (loc * Ploc.vaval string);
      tdPrm : Ploc.vala (list type_var);
      tdPrv : Ploc.vala bool;
      tdDef : ctyp;
      tdCon : Ploc.vala (list (ctyp * ctyp)) }
  ;

The field "tdNam" is the type identifier (together with its location in the source).

The field "tdPrm" is the list of its possible parameters.

The field "tdPrv" tells if the type is private or not.

The field "tdDef" is the definition of the type.

The field "tdCon" is the possible list of type constraints.

class_infos

The type "class_infos" is a record type parametrized with a type variable. It is common to:

• the "class declaration" ("class ..." as structure item), the type variable being "class_expr",
• the "class description" ("class ..." as signature item), the type variable being "class_type",
• the "class type declaration" ("class type ..."), the type variable being "class_type".

It is defined as:

  type class_infos 'a =
    { ciLoc : loc;
      ciVir : Ploc.vala bool;
      ciPrm : (loc * Ploc.vala (list type_var));
      ciNam : Ploc.vala string;
      ciExp : 'a }
  ;

The field "ciLoc" is the location of the whole definition.

The field "ciVir" tells whether the type is virtual or not.

The field "ciPrm" is the list of its possible parameters.

The field "ciNam" is the class identifier.

The field "ciExp" is the class definition, depending of its kind.

↑