Module `Ppxlib`Source

Standard library for ppx rewriters

ppxlib is meant to be opened globally in your PPX source files.

Opening it comes with two advantages. First, it will shadow the compiler-libs modules. The compiler-libs modules are unstable and aren't meant to be used, so shadowing them is a good protection mechanism. In case you don't want to open Ppxlib, you can open Ocaml_shadow to get the same protection. Second, it will bring several modules in scope, that are useful to have when writing a rewriter:

The main ppxlib modules, such as modules to help manipulate the AST (Ast_builder, Ast_pattern), and a few functions.
Modules from other libraries, such as Ast_helper or Pprintast,
The whole AST types (by including the Ast module).

The core `ppxlib` entries

Manipulating the AST

Sourcemodule Ast_builder : sig ... end

Ast_builder is a module to generate OCaml AST fragments. It provides a shorter syntax than directly using the Parsetree constructors, as well as a better stability than the constructors.

Sourcemodule Ast_pattern : sig ... end

This module implements first class AST patterns. It allows to destruct and extract values from AST fragments. This gives the same functionality as a pattern-match, but with simpler syntax and more stability than directly pattern-matching on the Parsetree constructors.

Sourcemodule Ast_traverse : sig ... end

This module provides AST traversal classes, such as maps, iterations, folds, etc. on the Parsetree types.

Context-free rewriting

Sourcemodule Context_free : sig ... end

Context free rewriting, to define local rewriting rules that will all be applied at once by the driver.

Sourcemodule Deriving : sig ... end

Deriving code from type declarations.

Sourcemodule Extension : sig ... end

Declare extenders to rewrite extension nodes.

Sourcemodule Expansion_context : sig ... end

The context given to rewriting rules when expanding.

Sourcemodule Code_path : sig ... end

This module contains type and functions for representing and manipulating path to AST nodes.

Other helpers

Sourcemodule Expansion_helpers : sig ... end

Various helpers for expansion, such as quoting expressions in their context, or mangling names.

Sourcemodule Merlin_helpers : sig ... end

Some helpers to annotate the AST so merlin can decide which branches to look at and which branches to ignore.

Sourcemodule Spellcheck : sig ... end

Helpers to provide hints to PPX users for typos or spellchecks.

Sourcemodule Keyword : sig ... end

Small module to check if a string is an OCaml keyword.

Sourcemodule Pp_ast : sig ... end

This module implements pretty printers for the OCaml AST's version used by ppxlib.

Sourcemodule Driver : sig ... end

Interaction with the driver, such as getting/seeting cookies, adding arguments.

Sourcemodule Caller_id : sig ... end

Small helper to find out who is the caller of a function

Sourcemodule Ast_io : sig ... end

A small module to help read bin-annots generated files.

Checks

Sourcemodule Attribute : sig ... end

This module provides hygiene for attributes. The goal is to report misuses of attributes to the user as soon as possible so that no mistyped attribute get silently ignored.

Sourcemodule Reserved_namespaces : sig ... end

Small module to reserve namespaces in attribute names.

Common helper functions

Sourceval lident : string -> Longident.t

Source

val core_type_of_type_declaration : 
  Astlib.Ast_500.Parsetree.type_declaration ->
  Astlib.Ast_500.Parsetree.core_type

Source

val name_type_params_in_td_res : 
  Astlib.Ast_500.Parsetree.type_declaration ->
  (Astlib.Ast_500.Parsetree.type_declaration,
    Location.Error.t Stdppx.NonEmptyList.t)
    result

Source

val name_type_params_in_td : 
  Astlib.Ast_500.Parsetree.type_declaration ->
  Astlib.Ast_500.Parsetree.type_declaration

Source

val combinator_type_of_type_declaration : 
  Astlib.Ast_500.Parsetree.type_declaration ->
  f:
    (loc:Location.t ->
      Astlib.Ast_500.Parsetree.core_type ->
      Astlib.Ast_500.Parsetree.core_type) ->
  Astlib.Ast_500.Parsetree.core_type

Sourceval gen_symbol : ?prefix:string -> unit -> string

gen_symbol ?prefix () generates a fresh variable name with prefix.

parameter prefix
default = "_x"

Sourceval string_of_core_type : Astlib.Ast_500.Parsetree.core_type -> string

Sourceval assert_no_attributes : Astlib.Ast_500.Parsetree.attribute list -> unit

Sourceval assert_no_attributes_in : Ppxlib__.Ast_traverse0.iter

Source

val attributes_errors : 
  Astlib.Ast_500.Parsetree.attribute list ->
  Location.Error.t list

Source

val collect_attributes_errors : 
  Location.Error.t list Ppxlib__.Ast_traverse0.fold

Source

val get_type_param_name_res : 
  (Astlib.Ast_500.Parsetree.core_type
   * (Astlib.Ast_500.Asttypes.variance * Astlib.Ast_500.Asttypes.injectivity)) ->
  (string Loc.t, Location.Error.t Stdppx.NonEmptyList.t) result

get_type_param_name_res tp returns the string identifier associated with tp if it is a type parameter, as a result.

Source

val get_type_param_name : 
  (Astlib.Ast_500.Parsetree.core_type
   * (Astlib.Ast_500.Asttypes.variance * Astlib.Ast_500.Asttypes.injectivity)) ->
  string Loc.t

See get_type_param_name_res. Raises a located error in case of failure.

Source

class type_is_recursive : Astlib.Ast_500.Asttypes.rec_flag -> Astlib.Ast_500.Parsetree.type_declaration
                                         list -> object ... end

(new type_is_recursive rec_flag tds)#go () returns whether rec_flag, tds is really a recursive type. We disregard recursive occurrences appearing in arrow types. You can override the search for certain type expressions by inheriting from this class.

Source

val really_recursive : 
  Astlib.Ast_500.Asttypes.rec_flag ->
  Astlib.Ast_500.Parsetree.type_declaration list ->
  Astlib.Ast_500.Asttypes.rec_flag

really_recursive rec_flag tds = (new type_is_recursive rec_flag tds)#go ()

Sourceval loc_of_payload : Astlib.Ast_500.Parsetree.attribute -> Location.t

Sourceval loc_of_attribute : Astlib.Ast_500.Parsetree.attribute -> Location.t

Source

val loc_of_extension : 
  (string Astlib.Location.loc * Astlib.Ast_500.Parsetree.payload) ->
  Location.t

Source

val curry_applications : 
  Astlib.Ast_500.Parsetree.expression ->
  Astlib.Ast_500.Parsetree.expression

convert multi-arg function applications into a cascade of 1-arg applications

Source

val attribute_of_warning : 
  Location.t ->
  string ->
  Astlib.Ast_500.Parsetree.attribute

Encode a warning message into an 'ocaml.ppwarning' attribute which can be inserted in a generated Parsetree. The compiler will be responsible for reporting the warning.

Source

val is_polymorphic_variant : 
  Astlib.Ast_500.Parsetree.type_declaration ->
  sig_:bool ->
  [> `Definitely | `Maybe | `Surely_not ]

Source

val mk_named_sig : 
  loc:Location.t ->
  sg_name:string ->
  handle_polymorphic_variant:bool ->
  Astlib.Ast_500.Parsetree.type_declaration list ->
  Astlib.Ast_500.Parsetree.module_type Astlib.Ast_500.Parsetree.include_infos
    option

mk_named_sig ~loc ~sg_name:"Foo" ~handle_polymorphic_variant tds will generate

  include Foo (* or Foo1, Foo2, Foo3 *)
    with type (* ('a, 'b, 'c) *) t := (* ('a, 'b, 'c) *) t

when:

there is only one type declaration
the type is named t
there are less than 4 type parameters
there are no constraints on the type parameters

It will take care of giving fresh names to unnamed type parameters.

Sourceval exn_to_loc_error : exn -> Location.Error.t

Convert exn to a located error if possible or reraise it otherwise

Sourcemodule With_errors : sig ... end

Modules from other libraries

Expose some modules from Ppxlib_ast.

Sourcemodule Ast = Ppxlib_ast.Ast

Sourcemodule Ast_helper = Ppxlib_ast.Ast_helper

Sourcemodule Asttypes = Ppxlib_ast.Asttypes

Sourcemodule Parse = Ppxlib_ast.Parse

Sourcemodule Parsetree = Ppxlib_ast.Parsetree

Sourcemodule Pprintast = Ppxlib_ast.Pprintast

Sourcemodule Selected_ast = Ppxlib_ast.Selected_ast

Sourcemodule Location : sig ... end

Overrides the Location module of OCaml

Sourcemodule Longident : sig ... end

Overrides the Longident module of OCaml

Sourcemodule Loc : sig ... end

Located items

The whole AST types

Include all the Ast definitions since we need them in every single ppx

include module type of struct include Ast end

Sourcetype position = Lexing.position = {

pos_fname : string;
pos_lnum : int;
pos_bol : int;
pos_cnum : int;

}

Sourceand location = Astlib.Location.t = {

loc_start : position;
loc_end : position;
loc_ghost : bool;

}

Sourceand location_stack = location list

Sourceand 'a loc = 'a Astlib.Location.loc = {

txt : 'a;
loc : location;

}

Sourceand longident = Astlib.Longident.t =

| Lident of string
| Ldot of longident * string
| Lapply of longident * longident

Sourceand longident_loc = longident loc

Auxiliary AST types used by parsetree and typedtree.

Sourceand rec_flag = Astlib.Ast_500.Asttypes.rec_flag =

| Nonrecursive
| Recursive

Sourceand direction_flag = Astlib.Ast_500.Asttypes.direction_flag =

| Upto
| Downto

Sourceand private_flag = Astlib.Ast_500.Asttypes.private_flag =

| Private
| Public

Sourceand mutable_flag = Astlib.Ast_500.Asttypes.mutable_flag =

| Immutable
| Mutable

Sourceand virtual_flag = Astlib.Ast_500.Asttypes.virtual_flag =

| Virtual
| Concrete

Sourceand override_flag = Astlib.Ast_500.Asttypes.override_flag =

| Override
| Fresh

Sourceand closed_flag = Astlib.Ast_500.Asttypes.closed_flag =

| Closed
| Open

Sourceand label = string

Sourceand arg_label = Astlib.Ast_500.Asttypes.arg_label =

| Nolabel
| Labelled of string
(*
label:T -> ...
*)
| Optional of string
(*
?label:T -> ...
*)

Sourceand variance = Astlib.Ast_500.Asttypes.variance =

| Covariant
| Contravariant
| NoVariance

Sourceand injectivity = Astlib.Ast_500.Asttypes.injectivity =

| Injective
| NoInjectivity

Abstract syntax tree produced by parsing

Sourceand constant = Astlib.Ast_500.Parsetree.constant =

| 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
*)
| Pconst_char of char
(*
Character such as 'c'.
*)
| 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.
*)
| Pconst_float of string * char option
(*
Float constant such as 3.4, 2e5 or 1.4e-4.
Suffixes g-zG-Z are accepted by the parser. Suffixes are rejected by the typechecker.
*)

Extension points

Sourceand attribute = Astlib.Ast_500.Parsetree.attribute = {

attr_name : string loc;
attr_payload : payload;
attr_loc : location;

}

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

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

Sourceand extension = string loc * payload

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

Sub-language placeholder -- rejected by the typechecker.

Sourceand attributes = attribute list

Sourceand payload = Astlib.Ast_500.Parsetree.payload =

| PStr of structure
| PSig of signature
(*
: SIG in an attribute or an extension point
*)
| PTyp of core_type
(*
: T in an attribute or an extension point
*)
| PPat of pattern * expression option
(*
? P or ? P when E, in an attribute or an extension point
*)

Core language

Type expressions

Sourceand core_type = Astlib.Ast_500.Parsetree.core_type = {

ptyp_desc : core_type_desc;
ptyp_loc : location;
ptyp_loc_stack : location_stack;
ptyp_attributes : attributes;
(*
... [@id1] [@id2]
*)

}

Sourceand core_type_desc = Astlib.Ast_500.Parsetree.core_type_desc =

| Ptyp_any
(*
_
*)
| Ptyp_var of string
(*
A type variable such as 'a
*)
| Ptyp_arrow of arg_label * core_type * core_type
(*
Ptyp_arrow(lbl, T1, T2) represents:
- T1 -> T2 when lbl is Nolabel,
- ~l:T1 -> T2 when lbl is Labelled,
- ?l:T1 -> T2 when lbl is Optional.
*)
| Ptyp_tuple of core_type list
(*
Ptyp_tuple([T1 ; ... ; Tn]) represents a product type T1 * ... * Tn.
Invariant: n >= 2.
*)
| 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].
*)
| 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.
*)
| 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].
*)
| Ptyp_alias of core_type * string
(*
T as 'a.
*)
| 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"].
*)
| Ptyp_poly of string loc list * core_type
(*
'a1 ... 'an. T
Can only appear in the following context:
- As the core_type of a Ppat_constraint node corresponding to a constraint on a let-binding:
```
  let x : 'a1 ... 'an. T = e ...
```
- 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.
*)
| Ptyp_package of package_type
(*
(module S).
*)
| Ptyp_extension of extension
(*
[%id].
*)

Sourceand 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).

Sourceand row_field = Astlib.Ast_500.Parsetree.row_field = {

prf_desc : row_field_desc;
prf_loc : location;
prf_attributes : attributes;

}

Sourceand row_field_desc = Astlib.Ast_500.Parsetree.row_field_desc =

| 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)
*)
| Rinherit of core_type
(*
[ | t ]
*)

Sourceand object_field = Astlib.Ast_500.Parsetree.object_field = {

pof_desc : object_field_desc;
pof_loc : location;
pof_attributes : attributes;

}

Sourceand object_field_desc = Astlib.Ast_500.Parsetree.object_field_desc =

| Otag of label loc * core_type
| Oinherit of core_type

Patterns

Sourceand pattern = Astlib.Ast_500.Parsetree.pattern = {

ppat_desc : pattern_desc;
ppat_loc : location;
ppat_loc_stack : location_stack;
ppat_attributes : attributes;
(*
... [@id1] [@id2]
*)

}

Sourceand pattern_desc = Astlib.Ast_500.Parsetree.pattern_desc =

| Ppat_any
(*
The pattern _.
*)
| Ppat_var of string loc
(*
A variable pattern such as x
*)
| Ppat_alias of pattern * string loc
(*
An alias pattern such as P as 'a
*)
| Ppat_constant of constant
(*
Patterns such as 1, 'a', "true", 1.0, 1l, 1L, 1n
*)
| 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.
*)
| Ppat_tuple of pattern list
(*
Patterns (P1, ..., Pn).
Invariant: n >= 2
*)
| Ppat_construct of longident_loc * (string loc list * pattern) option
(*
Ppat_construct(C, args) represents:
- C when args is None,
- C P when args is Some ([], P)
- C (P1, ..., Pn) when args is Some ([], Ppat_tuple [P1; ...; Pn])
- C (type a b) P when args is Some ([a; b], P)
*)
| Ppat_variant of label * pattern option
(*
Ppat_variant(`A, pat) represents:
- `A when pat is None,
- `A P when pat is Some P
*)
| 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
*)
| Ppat_array of pattern list
(*
Pattern [| P1; ...; Pn |]
*)
| Ppat_or of pattern * pattern
(*
Pattern P1 | P2
*)
| Ppat_constraint of pattern * core_type
(*
Pattern (P : T)
*)
| Ppat_type of longident_loc
(*
Pattern #tconst
*)
| Ppat_lazy of pattern
(*
Pattern lazy P
*)
| 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)
*)
| Ppat_exception of pattern
(*
Pattern exception P
*)
| Ppat_extension of extension
(*
Pattern [%id]
*)
| Ppat_open of longident_loc * pattern
(*
Pattern M.(P)
*)

Value expressions

Sourceand expression = Astlib.Ast_500.Parsetree.expression = {

pexp_desc : expression_desc;
pexp_loc : location;
pexp_loc_stack : location_stack;
pexp_attributes : attributes;
(*
... [@id1] [@id2]
*)

}

Sourceand expression_desc = Astlib.Ast_500.Parsetree.expression_desc =

| Pexp_ident of longident_loc
(*
Identifiers such as x and M.x
*)
| Pexp_constant of constant
(*
Expressions constant such as 1, 'a', "true", 1.0, 1l, 1L, 1n
*)
| Pexp_let of rec_flag * value_binding list * expression
(*
Pexp_let(flag, [(P1,E1) ; ... ; (Pn,En)], E) represents:
- let P1 = E1 and ... and Pn = EN in E when flag is Nonrecursive,
- let rec P1 = E1 and ... and Pn = EN in E when flag is Recursive.
*)
| Pexp_function of cases
(*
function P1 -> E1 | ... | Pn -> En
*)
| Pexp_fun of arg_label * expression option * pattern * expression
(*
Pexp_fun(lbl, exp0, P, E1) represents:
- fun P -> E1 when lbl is Nolabel and exp0 is None
- fun ~l:P -> E1 when lbl is Labelled l and exp0 is None
- fun ?l:P -> E1 when lbl is Optional l and exp0 is None
- fun ?l:(P = E0) -> E1 when lbl is Optional l and exp0 is Some E0
Notes:
- If E0 is provided, only Optional is allowed.
- fun P1 P2 .. Pn -> E1 is represented as nested Pexp_fun.
- let f P = E is represented using Pexp_fun.
*)
| 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
*)
| Pexp_match of expression * cases
(*
match E0 with P1 -> E1 | ... | Pn -> En
*)
| Pexp_try of expression * cases
(*
try E0 with P1 -> E1 | ... | Pn -> En
*)
| Pexp_tuple of expression list
(*
Expressions (E1, ..., En)
Invariant: n >= 2
*)
| 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])
*)
| Pexp_variant of label * expression option
(*
Pexp_variant(`A, exp) represents
- `A when exp is None
- `A E when exp is Some E
*)
| 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
*)
| Pexp_field of expression * longident_loc
(*
E.l
*)
| Pexp_setfield of expression * longident_loc * expression
(*
E1.l <- E2
*)
| Pexp_array of expression list
(*
[| E1; ...; En |]
*)
| Pexp_ifthenelse of expression * expression * expression option
(*
if E1 then E2 else E3
*)
| Pexp_sequence of expression * expression
(*
E1; E2
*)
| Pexp_while of expression * expression
(*
while E1 do E2 done
*)
| 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
*)
| Pexp_constraint of expression * core_type
(*
(E : T)
*)
| 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.
*)
| Pexp_send of expression * label loc
(*
E # m
*)
| Pexp_new of longident_loc
(*
new M.c
*)
| Pexp_setinstvar of label loc * expression
(*
x <- 2
*)
| Pexp_override of (label loc * expression) list
(*
{< x1 = E1; ...; xn = En >}
*)
| Pexp_letmodule of string option loc * module_expr * expression
(*
let module M = ME in E
*)
| Pexp_letexception of extension_constructor * expression
(*
let exception C in E
*)
| Pexp_assert of expression
(*
assert E.
Note: assert false is treated in a special way by the type-checker.
*)
| Pexp_lazy of expression
(*
lazy E
*)
| 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).
*)
| Pexp_object of class_structure
(*
object ... end
*)
| Pexp_newtype of string loc * expression
(*
fun (type t) -> E
*)
| Pexp_pack of module_expr
(*
(module ME).
(module ME : S) is represented as Pexp_constraint(Pexp_pack ME, Ptyp_package S)
*)
| Pexp_open of open_declaration * expression
(*
- M.(E)
- let open M in E
- let open! M in E
*)
| Pexp_letop of letop
(*
- let* P = E0 in E1
- let* P0 = E00 and* P1 = E01 in E1
*)
| Pexp_extension of extension
(*
[%id]
*)
| Pexp_unreachable
(*
.
*)

Sourceand case = Astlib.Ast_500.Parsetree.case = {

pc_lhs : pattern;
pc_guard : expression option;
pc_rhs : expression;

}

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

Sourceand letop = Astlib.Ast_500.Parsetree.letop = {

let_ : binding_op;
ands : binding_op list;
body : expression;

}

Sourceand binding_op = Astlib.Ast_500.Parsetree.binding_op = {

pbop_op : string loc;
pbop_pat : pattern;
pbop_exp : expression;
pbop_loc : location;

}

Value descriptions

Sourceand value_description = Astlib.Ast_500.Parsetree.value_description = {

pval_name : string loc;
pval_type : core_type;
pval_prim : string list;
pval_attributes : attributes;
(*
... [@@id1] [@@id2]
*)
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

Sourceand type_declaration = Astlib.Ast_500.Parsetree.type_declaration = {

ptype_name : string loc;
ptype_params : (core_type * (variance * injectivity)) list;
(*
('a1,...'an) t
*)
ptype_cstrs : (core_type * core_type * location) list;
(*
... constraint T1=T1' ... constraint Tn=Tn'
*)
ptype_kind : type_kind;
ptype_private : private_flag;
(*
for = private ...
*)
ptype_manifest : core_type option;
(*
represents = T
*)
ptype_attributes : attributes;
(*
... [@@id1] [@@id2]
*)
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.

Sourceand type_kind = Astlib.Ast_500.Parsetree.type_kind =

| Ptype_abstract
| Ptype_variant of constructor_declaration list
| Ptype_record of label_declaration list
(*
Invariant: non-empty list
*)
| Ptype_open

Sourceand label_declaration = Astlib.Ast_500.Parsetree.label_declaration = {

pld_name : string loc;
pld_mutable : mutable_flag;
pld_type : core_type;
pld_loc : location;
pld_attributes : attributes;
(*
l : T [@id1] [@id2]
*)

}

{ ...; l: T; ... } when pld_mutable is Immutable,
{ ...; mutable l: T; ... } when pld_mutable is Mutable.

Note: T can be a Ptyp_poly.

Source

and constructor_declaration = Astlib.Ast_500.Parsetree.constructor_declaration =
  {

pcd_name : string loc;
pcd_vars : string loc list;
pcd_args : constructor_arguments;
pcd_res : core_type option;
pcd_loc : location;
pcd_attributes : attributes;
(*
C of ... [@id1] [@id2]
*)

}

Sourceand constructor_arguments = Astlib.Ast_500.Parsetree.constructor_arguments =

| Pcstr_tuple of core_type list
| 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 [...].
*)

Sourceand type_extension = Astlib.Ast_500.Parsetree.type_extension = {

ptyext_path : longident_loc;
ptyext_params : (core_type * (variance * injectivity)) list;
ptyext_constructors : extension_constructor list;
ptyext_private : private_flag;
ptyext_loc : location;
ptyext_attributes : attributes;
(*
... @@id1 @@id2
*)

}

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

Sourceand extension_constructor = Astlib.Ast_500.Parsetree.extension_constructor = {

pext_name : string loc;
pext_kind : extension_constructor_kind;
pext_loc : location;
pext_attributes : attributes;
(*
C of ... [@id1] [@id2]
*)

}

Sourceand type_exception = Astlib.Ast_500.Parsetree.type_exception = {

ptyexn_constructor : extension_constructor;
ptyexn_loc : location;
ptyexn_attributes : attributes;
(*
... [@@id1] [@@id2]
*)

}

Definition of a new exception (exception E).

Source

and extension_constructor_kind =
  Astlib.Ast_500.Parsetree.extension_constructor_kind =

| Pext_decl of string loc list * constructor_arguments * core_type option
(*
Pext_decl(existentials, c_args, t_opt) describes a new extension constructor. It can be:
- C of T1 * ... * Tn when:
  - existentials is [],
  - c_args is [T1; ...; Tn],
  - t_opt is None.
- C: T0 when
  - existentials is [],
  - c_args is [],
  - t_opt is Some T0.
- C: T1 * ... * Tn -> T0 when
  - existentials is [],
  - c_args is [T1; ...; Tn],
  - t_opt is Some T0.
- C: 'a... . T1 * ... * Tn -> T0 when
  - existentials is ['a;...],
  - c_args is [T1; ... ; Tn],
  - t_opt is Some T0.
*)
| 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

Sourceand class_type = Astlib.Ast_500.Parsetree.class_type = {

pcty_desc : class_type_desc;
pcty_loc : location;
pcty_attributes : attributes;
(*
... [@id1] [@id2]
*)

}

Sourceand class_type_desc = Astlib.Ast_500.Parsetree.class_type_desc =

| Pcty_constr of longident_loc * core_type list
(*
- c
- ['a1, ..., 'an] c
*)
| Pcty_signature of class_signature
(*
object ... end
*)
| Pcty_arrow of arg_label * core_type * class_type
(*
Pcty_arrow(lbl, T, CT) represents:
- T -> CT when lbl is Nolabel,
- ~l:T -> CT when lbl is Labelled l,
- ?l:T -> CT when lbl is Optional l.
*)
| Pcty_extension of extension
(*
%id
*)
| Pcty_open of open_description * class_type
(*
let open M in CT
*)

Sourceand class_signature = Astlib.Ast_500.Parsetree.class_signature = {

pcsig_self : core_type;
pcsig_fields : class_type_field list;

}

Values of type class_signature represents:

object('selfpat) ... end
object ... end when pcsig_self is Ptyp_any

Sourceand class_type_field = Astlib.Ast_500.Parsetree.class_type_field = {

pctf_desc : class_type_field_desc;
pctf_loc : location;
pctf_attributes : attributes;
(*
... [@@id1] [@@id2]
*)

}

Sourceand class_type_field_desc = Astlib.Ast_500.Parsetree.class_type_field_desc =

| Pctf_inherit of class_type
(*
inherit CT
*)
| Pctf_val of label loc * mutable_flag * virtual_flag * core_type
(*
val x: T
*)
| Pctf_method of label loc * private_flag * virtual_flag * core_type
(*
method x: T
Note: T can be a Ptyp_poly.
*)
| Pctf_constraint of core_type * core_type
(*
constraint T1 = T2
*)
| Pctf_attribute of attribute
(*
[@@@id]
*)
| Pctf_extension of extension
(*
[%%id]
*)

Sourceand 'a class_infos = 'a Astlib.Ast_500.Parsetree.class_infos = {

pci_virt : virtual_flag;
pci_params : (core_type * (variance * injectivity)) list;
pci_name : string loc;
pci_expr : 'a;
pci_loc : location;
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.

Sourceand class_description = class_type class_infos

Sourceand class_type_declaration = class_type class_infos

Value expressions for the class language

Sourceand class_expr = Astlib.Ast_500.Parsetree.class_expr = {

pcl_desc : class_expr_desc;
pcl_loc : location;
pcl_attributes : attributes;
(*
... [@id1] [@id2]
*)

}

Sourceand class_expr_desc = Astlib.Ast_500.Parsetree.class_expr_desc =

| Pcl_constr of longident_loc * core_type list
(*
c and ['a1, ..., 'an] c
*)
| Pcl_structure of class_structure
(*
object ... end
*)
| 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.
*)
| 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
*)
| 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.
*)
| Pcl_constraint of class_expr * class_type
(*
(CE : CT)
*)
| Pcl_extension of extension
(*
[%id]
*)
| Pcl_open of open_description * class_expr
(*
let open M in CE
*)

Sourceand class_structure = Astlib.Ast_500.Parsetree.class_structure = {

pcstr_self : pattern;
pcstr_fields : class_field list;

}

Values of type class_structure represents:

object(selfpat) ... end
object ... end when pcstr_self is Ppat_any

Sourceand class_field = Astlib.Ast_500.Parsetree.class_field = {

pcf_desc : class_field_desc;
pcf_loc : location;
pcf_attributes : attributes;
(*
... [@@id1] [@@id2]
*)

}

Sourceand class_field_desc = Astlib.Ast_500.Parsetree.class_field_desc =

| 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
*)
| Pcf_val of label loc * mutable_flag * class_field_kind
(*
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)
*)
| Pcf_method of label loc * private_flag * class_field_kind
(*
- method x = E (E can be a Pexp_poly)
- method virtual x: T (T can be a Ptyp_poly)
*)
| Pcf_constraint of core_type * core_type
(*
constraint T1 = T2
*)
| Pcf_initializer of expression
(*
initializer E
*)
| Pcf_attribute of attribute
(*
[@@@id]
*)
| Pcf_extension of extension
(*
[%%id]
*)

Sourceand class_field_kind = Astlib.Ast_500.Parsetree.class_field_kind =

| Cfk_virtual of core_type
| Cfk_concrete of override_flag * expression

Sourceand class_declaration = class_expr class_infos

Module language

Type expressions for the module language

Sourceand module_type = Astlib.Ast_500.Parsetree.module_type = {

pmty_desc : module_type_desc;
pmty_loc : location;
pmty_attributes : attributes;
(*
... [@id1] [@id2]
*)

}

Sourceand module_type_desc = Astlib.Ast_500.Parsetree.module_type_desc =

| Pmty_ident of longident_loc
(*
Pmty_ident(S) represents S
*)
| Pmty_signature of signature
(*
sig ... end
*)
| Pmty_functor of functor_parameter * module_type
(*
functor(X : MT1) -> MT2
*)
| Pmty_with of module_type * with_constraint list
(*
MT with ...
*)
| Pmty_typeof of module_expr
(*
module type of ME
*)
| Pmty_extension of extension
(*
[%id]
*)
| Pmty_alias of longident_loc
(*
(module M)
*)

Sourceand functor_parameter = Astlib.Ast_500.Parsetree.functor_parameter =

| Unit
(*
()
*)
| Named of string option loc * module_type
(*
Named(name, MT) represents:
- (X : MT) when name is Some X,
- (_ : MT) when name is None
*)

Sourceand signature = signature_item list

Sourceand signature_item = Astlib.Ast_500.Parsetree.signature_item = {

psig_desc : signature_item_desc;
psig_loc : location;

}

Sourceand signature_item_desc = Astlib.Ast_500.Parsetree.signature_item_desc =

| Psig_value of value_description
(*
- val x: T
- external x: T = "s1" ... "sn"
*)
| Psig_type of rec_flag * type_declaration list
(*
type t1 = ... and ... and tn = ...
*)
| Psig_typesubst of type_declaration list
(*
type t1 := ... and ... and tn := ...
*)
| Psig_typext of type_extension
(*
type t1 += ...
*)
| Psig_exception of type_exception
(*
exception C of T
*)
| Psig_module of module_declaration
(*
module X = M and module X : MT
*)
| Psig_modsubst of module_substitution
(*
module X := M
*)
| Psig_recmodule of module_declaration list
(*
module rec X1 : MT1 and ... and Xn : MTn
*)
| Psig_modtype of module_type_declaration
(*
module type S = MT and module type S
*)
| Psig_modtypesubst of module_type_declaration
(*
module type S := ...
*)
| Psig_open of open_description
(*
open X
*)
| Psig_include of include_description
(*
include MT
*)
| Psig_class of class_description list
(*
class c1 : ... and ... and cn : ...
*)
| Psig_class_type of class_type_declaration list
(*
class type ct1 = ... and ... and ctn = ...
*)
| Psig_attribute of attribute
(*
[@@@id]
*)
| Psig_extension of extension * attributes
(*
[%%id]
*)

Sourceand module_declaration = Astlib.Ast_500.Parsetree.module_declaration = {

pmd_name : string option loc;
pmd_type : module_type;
pmd_attributes : attributes;
(*
... [@@id1] [@@id2]
*)
pmd_loc : location;

}

Values of type module_declaration represents S : MT

Sourceand module_substitution = Astlib.Ast_500.Parsetree.module_substitution = {

pms_name : string loc;
pms_manifest : longident_loc;
pms_attributes : attributes;
(*
... [@@id1] [@@id2]
*)
pms_loc : location;

}

Values of type module_substitution represents S := M

Source

and module_type_declaration = Astlib.Ast_500.Parsetree.module_type_declaration =
  {

pmtd_name : string loc;
pmtd_type : module_type option;
pmtd_attributes : attributes;
(*
... [@@id1] [@@id2]
*)
pmtd_loc : location;

}

Values of type module_type_declaration represents:

S = MT,
S for abstract module type declaration, when pmtd_type is None.

Sourceand 'a open_infos = 'a Astlib.Ast_500.Parsetree.open_infos = {

popen_expr : 'a;
popen_override : override_flag;
popen_loc : location;
popen_attributes : attributes;

}

Values of type 'a open_infos represents:

open! X when popen_override is Override (silences the "used identifier shadowing" warning)
open X when popen_override is Fresh

Sourceand open_description = longident_loc open_infos

Values of type open_description represents:

open M.N
open M(N).O

Sourceand open_declaration = module_expr open_infos

Values of type open_declaration represents:

open M.N
open M(N).O
open struct ... end

Sourceand 'a include_infos = 'a Astlib.Ast_500.Parsetree.include_infos = {

pincl_mod : 'a;
pincl_loc : location;
pincl_attributes : attributes;

}

Sourceand include_description = module_type include_infos

Values of type include_description represents include MT

Sourceand include_declaration = module_expr include_infos

Values of type include_declaration represents include ME

Sourceand with_constraint = Astlib.Ast_500.Parsetree.with_constraint =

| 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.
*)
| Pwith_module of longident_loc * longident_loc
(*
with module X.Y = Z
*)
| Pwith_modtype of longident_loc * module_type
(*
with module type X.Y = Z
*)
| Pwith_modtypesubst of longident_loc * module_type
(*
with module type X.Y := sig end
*)
| Pwith_typesubst of longident_loc * type_declaration
(*
with type X.t := ..., same format as [Pwith_type]
*)
| Pwith_modsubst of longident_loc * longident_loc
(*
with module X.Y := Z
*)

Value expressions for the module language

Sourceand module_expr = Astlib.Ast_500.Parsetree.module_expr = {

pmod_desc : module_expr_desc;
pmod_loc : location;
pmod_attributes : attributes;
(*
... [@id1] [@id2]
*)

}

Sourceand module_expr_desc = Astlib.Ast_500.Parsetree.module_expr_desc =

| Pmod_ident of longident_loc
(*
X
*)
| Pmod_structure of structure
(*
struct ... end
*)
| Pmod_functor of functor_parameter * module_expr
(*
functor(X : MT1) -> ME
*)
| Pmod_apply of module_expr * module_expr
(*
ME1(ME2)
*)
| Pmod_constraint of module_expr * module_type
(*
(ME : MT)
*)
| Pmod_unpack of expression
(*
(val E)
*)
| Pmod_extension of extension
(*
[%id]
*)

Sourceand structure = structure_item list

Sourceand structure_item = Astlib.Ast_500.Parsetree.structure_item = {

pstr_desc : structure_item_desc;
pstr_loc : location;

}

Sourceand structure_item_desc = Astlib.Ast_500.Parsetree.structure_item_desc =

| Pstr_eval of expression * attributes
(*
E
*)
| 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.
*)
| Pstr_primitive of value_description
(*
- val x: T
- external x: T = "s1" ... "sn"
*)
| Pstr_type of rec_flag * type_declaration list
(*
type t1 = ... and ... and tn = ...
*)
| Pstr_typext of type_extension
(*
type t1 += ...
*)
| Pstr_exception of type_exception
(*
- exception C of T
- exception C = M.X
*)
| Pstr_module of module_binding
(*
module X = ME
*)
| Pstr_recmodule of module_binding list
(*
module rec X1 = ME1 and ... and Xn = MEn
*)
| Pstr_modtype of module_type_declaration
(*
module type S = MT
*)
| Pstr_open of open_declaration
(*
open X
*)
| Pstr_class of class_declaration list
(*
class c1 = ... and ... and cn = ...
*)
| Pstr_class_type of class_type_declaration list
(*
class type ct1 = ... and ... and ctn = ...
*)
| Pstr_include of include_declaration
(*
include ME
*)
| Pstr_attribute of attribute
(*
[@@@id]
*)
| Pstr_extension of extension * attributes
(*
[%%id]
*)

Sourceand value_binding = Astlib.Ast_500.Parsetree.value_binding = {

pvb_pat : pattern;
pvb_expr : expression;
pvb_attributes : attributes;
pvb_loc : location;

}

Sourceand module_binding = Astlib.Ast_500.Parsetree.module_binding = {

pmb_name : string option loc;
pmb_expr : module_expr;
pmb_attributes : attributes;
pmb_loc : location;

}

Values of type module_binding represents module X = ME

Toplevel

Toplevel phrases

Sourceand toplevel_phrase = Astlib.Ast_500.Parsetree.toplevel_phrase =

| Ptop_def of structure
| Ptop_dir of toplevel_directive
(*
#use, #load ...
*)

Sourceand toplevel_directive = Astlib.Ast_500.Parsetree.toplevel_directive = {

pdir_name : string loc;
pdir_arg : directive_argument option;
pdir_loc : location;

}

Sourceand directive_argument = Astlib.Ast_500.Parsetree.directive_argument = {

pdira_desc : directive_argument_desc;
pdira_loc : location;

}

Source

and directive_argument_desc = Astlib.Ast_500.Parsetree.directive_argument_desc =

| Pdir_string of string
| Pdir_int of string * char option
| Pdir_ident of longident
| Pdir_bool of bool

Sourceand cases = case list

Sourceclass virtual map : object ... end

Sourceclass virtual iter : object ... end

Sourceclass virtual 'acc fold : object ... end

Sourceclass virtual 'acc fold_map : object ... end

Sourceclass virtual 'ctx map_with_context : object ... end

Sourceclass virtual 'res lift : object ... end

Sourceclass virtual ['ctx, 'res] lift_map_with_context : object ... end

Make sure code using Ppxlib doesn't refer to compiler-libs without being explicit about it:

include sig ... end

include module type of struct include Ocaml_shadow end
  with module Ast_helper := Ocaml_shadow.Ast_helper
  with module Asttypes := Ocaml_shadow.Asttypes
  with module Docstrings := Ocaml_shadow.Docstrings
  with module Identifiable := Ocaml_shadow.Identifiable
  with module Lexer := Ocaml_shadow.Lexer
  with module Location := Ocaml_shadow.Location
  with module Longident := Ocaml_shadow.Longident
  with module Parse := Ocaml_shadow.Parse
  with module Parsetree := Ocaml_shadow.Parsetree
  with module Pprintast := Ocaml_shadow.Pprintast
  with module Syntaxerr := Ocaml_shadow.Syntaxerr

Sourcemodule Do_not_use_directly = Ocaml_shadow.Do_not_use_directly

Sourcemodule Afl_instrument = Ocaml_shadow.Afl_instrument

Sourcemodule Alias_analysis = Ocaml_shadow.Alias_analysis

Sourcemodule Allocated_const = Ocaml_shadow.Allocated_const

Sourcemodule Annot = Ocaml_shadow.Annot

Sourcemodule Arch = Ocaml_shadow.Arch

Sourcemodule Arg_helper = Ocaml_shadow.Arg_helper

Sourcemodule Asmgen = Ocaml_shadow.Asmgen

Sourcemodule Asmlibrarian = Ocaml_shadow.Asmlibrarian

Sourcemodule Asmlink = Ocaml_shadow.Asmlink

Sourcemodule Asmpackager = Ocaml_shadow.Asmpackager

Sourcemodule Ast_invariants = Ocaml_shadow.Ast_invariants

Sourcemodule Ast_iterator = Ocaml_shadow.Ast_iterator

Sourcemodule Ast_mapper = Ocaml_shadow.Ast_mapper

Sourcemodule Attr_helper = Ocaml_shadow.Attr_helper

Sourcemodule Augment_specialised_args = Ocaml_shadow.Augment_specialised_args

Sourcemodule Backend_intf = Ocaml_shadow.Backend_intf

Sourcemodule Backend_var = Ocaml_shadow.Backend_var

Sourcemodule Binutils = Ocaml_shadow.Binutils

Sourcemodule Branch_relaxation = Ocaml_shadow.Branch_relaxation

Sourcemodule Branch_relaxation_intf = Ocaml_shadow.Branch_relaxation_intf

Sourcemodule Btype = Ocaml_shadow.Btype

Sourcemodule Build_export_info = Ocaml_shadow.Build_export_info

Sourcemodule Build_path_prefix_map = Ocaml_shadow.Build_path_prefix_map

Sourcemodule Builtin_attributes = Ocaml_shadow.Builtin_attributes

Sourcemodule Bytegen = Ocaml_shadow.Bytegen

Sourcemodule Bytelibrarian = Ocaml_shadow.Bytelibrarian

Sourcemodule Bytelink = Ocaml_shadow.Bytelink

Sourcemodule Bytepackager = Ocaml_shadow.Bytepackager

Sourcemodule Bytesections = Ocaml_shadow.Bytesections

Sourcemodule CSE = Ocaml_shadow.CSE

Sourcemodule CSEgen = Ocaml_shadow.CSEgen

Sourcemodule CamlinternalMenhirLib = Ocaml_shadow.CamlinternalMenhirLib

Sourcemodule Ccomp = Ocaml_shadow.Ccomp

Sourcemodule Clambda = Ocaml_shadow.Clambda

Sourcemodule Clambda_primitives = Ocaml_shadow.Clambda_primitives

Sourcemodule Clflags = Ocaml_shadow.Clflags

Sourcemodule Closure = Ocaml_shadow.Closure

Sourcemodule Closure_conversion = Ocaml_shadow.Closure_conversion

Sourcemodule Closure_conversion_aux = Ocaml_shadow.Closure_conversion_aux

Sourcemodule Closure_element = Ocaml_shadow.Closure_element

Sourcemodule Closure_id = Ocaml_shadow.Closure_id

Sourcemodule Closure_middle_end = Ocaml_shadow.Closure_middle_end

Sourcemodule Closure_offsets = Ocaml_shadow.Closure_offsets

Sourcemodule Closure_origin = Ocaml_shadow.Closure_origin

Sourcemodule Cmi_format = Ocaml_shadow.Cmi_format

Sourcemodule Cmm = Ocaml_shadow.Cmm

Sourcemodule Cmm_helpers = Ocaml_shadow.Cmm_helpers

Sourcemodule Cmm_invariants = Ocaml_shadow.Cmm_invariants

Sourcemodule Cmmgen = Ocaml_shadow.Cmmgen

Sourcemodule Cmmgen_state = Ocaml_shadow.Cmmgen_state

Sourcemodule Cmo_format = Ocaml_shadow.Cmo_format

Sourcemodule Cmt2annot = Ocaml_shadow.Cmt2annot

Sourcemodule Cmt_format = Ocaml_shadow.Cmt_format

Sourcemodule Cmx_format = Ocaml_shadow.Cmx_format

Sourcemodule Cmxs_format = Ocaml_shadow.Cmxs_format

Sourcemodule Coloring = Ocaml_shadow.Coloring

Sourcemodule Comballoc = Ocaml_shadow.Comballoc

Sourcemodule Compenv = Ocaml_shadow.Compenv

Sourcemodule Compilation_unit = Ocaml_shadow.Compilation_unit

Sourcemodule Compile = Ocaml_shadow.Compile

Sourcemodule Compile_common = Ocaml_shadow.Compile_common

Sourcemodule Compilenv = Ocaml_shadow.Compilenv

Sourcemodule Compmisc = Ocaml_shadow.Compmisc

Sourcemodule Compression = Ocaml_shadow.Compression

Sourcemodule Config = Ocaml_shadow.Config

Sourcemodule Config_boot = Ocaml_shadow.Config_boot

Sourcemodule Config_main = Ocaml_shadow.Config_main

Sourcemodule Consistbl = Ocaml_shadow.Consistbl

Sourcemodule Convert_primitives = Ocaml_shadow.Convert_primitives

Sourcemodule Ctype = Ocaml_shadow.Ctype

Sourcemodule Dataflow = Ocaml_shadow.Dataflow

Sourcemodule Datarepr = Ocaml_shadow.Datarepr

Sourcemodule Deadcode = Ocaml_shadow.Deadcode

Sourcemodule Debuginfo = Ocaml_shadow.Debuginfo

Sourcemodule Depend = Ocaml_shadow.Depend

Sourcemodule Diffing = Ocaml_shadow.Diffing

Sourcemodule Diffing_with_keys = Ocaml_shadow.Diffing_with_keys

Sourcemodule Dll = Ocaml_shadow.Dll

Sourcemodule Domainstate = Ocaml_shadow.Domainstate

Sourcemodule Effect_analysis = Ocaml_shadow.Effect_analysis

Sourcemodule Emit = Ocaml_shadow.Emit

Sourcemodule Emitaux = Ocaml_shadow.Emitaux

Sourcemodule Emitcode = Ocaml_shadow.Emitcode

Sourcemodule Emitenv = Ocaml_shadow.Emitenv

Sourcemodule Env = Ocaml_shadow.Env

Sourcemodule Envaux = Ocaml_shadow.Envaux

Sourcemodule Errors = Ocaml_shadow.Errors

Sourcemodule Errortrace = Ocaml_shadow.Errortrace

Sourcemodule Errortrace_report = Ocaml_shadow.Errortrace_report

Sourcemodule Export_id = Ocaml_shadow.Export_id

Sourcemodule Export_info = Ocaml_shadow.Export_info

Sourcemodule Export_info_for_pack = Ocaml_shadow.Export_info_for_pack

Sourcemodule Expunge = Ocaml_shadow.Expunge

Sourcemodule Extract_projections = Ocaml_shadow.Extract_projections

Sourcemodule Find_recursive_functions = Ocaml_shadow.Find_recursive_functions

Sourcemodule Flambda = Ocaml_shadow.Flambda

Sourcemodule Flambda_invariants = Ocaml_shadow.Flambda_invariants

Sourcemodule Flambda_iterators = Ocaml_shadow.Flambda_iterators

Sourcemodule Flambda_middle_end = Ocaml_shadow.Flambda_middle_end

Sourcemodule Flambda_to_clambda = Ocaml_shadow.Flambda_to_clambda

Sourcemodule Flambda_utils = Ocaml_shadow.Flambda_utils

Sourcemodule Format_doc = Ocaml_shadow.Format_doc

Sourcemodule Freshening = Ocaml_shadow.Freshening

Sourcemodule Genprintval = Ocaml_shadow.Genprintval

Sourcemodule Gprinttyp = Ocaml_shadow.Gprinttyp

Sourcemodule Id_types = Ocaml_shadow.Id_types

Sourcemodule Ident = Ocaml_shadow.Ident

Sourcemodule Import_approx = Ocaml_shadow.Import_approx

Sourcemodule Includeclass = Ocaml_shadow.Includeclass

Sourcemodule Includecore = Ocaml_shadow.Includecore

Sourcemodule Includemod = Ocaml_shadow.Includemod

Sourcemodule Includemod_errorprinter = Ocaml_shadow.Includemod_errorprinter

Sourcemodule Inconstant_idents = Ocaml_shadow.Inconstant_idents

Source

module Initialize_symbol_to_let_symbol =
  Ocaml_shadow.Initialize_symbol_to_let_symbol

Sourcemodule Inline_and_simplify = Ocaml_shadow.Inline_and_simplify

Sourcemodule Inline_and_simplify_aux = Ocaml_shadow.Inline_and_simplify_aux

Sourcemodule Inlining_cost = Ocaml_shadow.Inlining_cost

Sourcemodule Inlining_decision = Ocaml_shadow.Inlining_decision

Sourcemodule Inlining_decision_intf = Ocaml_shadow.Inlining_decision_intf

Sourcemodule Inlining_stats = Ocaml_shadow.Inlining_stats

Sourcemodule Inlining_stats_types = Ocaml_shadow.Inlining_stats_types

Sourcemodule Inlining_transforms = Ocaml_shadow.Inlining_transforms

Sourcemodule Instruct = Ocaml_shadow.Instruct

Source

module Int_replace_polymorphic_compare =
  Ocaml_shadow.Int_replace_polymorphic_compare

Sourcemodule Interf = Ocaml_shadow.Interf

Sourcemodule Internal_variable_names = Ocaml_shadow.Internal_variable_names

Sourcemodule Interval = Ocaml_shadow.Interval

Sourcemodule Invariant_params = Ocaml_shadow.Invariant_params

Sourcemodule Lambda = Ocaml_shadow.Lambda

Sourcemodule Lazy_backtrack = Ocaml_shadow.Lazy_backtrack

Sourcemodule Lift_code = Ocaml_shadow.Lift_code

Sourcemodule Lift_constants = Ocaml_shadow.Lift_constants

Source

module Lift_let_to_initialize_symbol =
  Ocaml_shadow.Lift_let_to_initialize_symbol

Sourcemodule Linear = Ocaml_shadow.Linear

Sourcemodule Linear_format = Ocaml_shadow.Linear_format

Sourcemodule Linearize = Ocaml_shadow.Linearize

Sourcemodule Linkage_name = Ocaml_shadow.Linkage_name

Sourcemodule Linkdeps = Ocaml_shadow.Linkdeps

Sourcemodule Linscan = Ocaml_shadow.Linscan

Sourcemodule Liveness = Ocaml_shadow.Liveness

Sourcemodule Load_path = Ocaml_shadow.Load_path

Sourcemodule Local_store = Ocaml_shadow.Local_store

Sourcemodule Mach = Ocaml_shadow.Mach

Sourcemodule Main = Ocaml_shadow.Main

Sourcemodule Main_args = Ocaml_shadow.Main_args

Sourcemodule Maindriver = Ocaml_shadow.Maindriver

Sourcemodule Makedepend = Ocaml_shadow.Makedepend

Sourcemodule Matching = Ocaml_shadow.Matching

Sourcemodule Meta = Ocaml_shadow.Meta

Sourcemodule Misc = Ocaml_shadow.Misc

Sourcemodule Mtype = Ocaml_shadow.Mtype

Sourcemodule Mutable_variable = Ocaml_shadow.Mutable_variable

Sourcemodule Numbers = Ocaml_shadow.Numbers

Sourcemodule Opcodes = Ocaml_shadow.Opcodes

Sourcemodule Oprint = Ocaml_shadow.Oprint

Sourcemodule Optcompile = Ocaml_shadow.Optcompile

Sourcemodule Opterrors = Ocaml_shadow.Opterrors

Sourcemodule Optmain = Ocaml_shadow.Optmain

Sourcemodule Optmaindriver = Ocaml_shadow.Optmaindriver

Sourcemodule Out_type = Ocaml_shadow.Out_type

Sourcemodule Outcometree = Ocaml_shadow.Outcometree

Sourcemodule Parameter = Ocaml_shadow.Parameter

Sourcemodule Parmatch = Ocaml_shadow.Parmatch

Sourcemodule Parser = Ocaml_shadow.Parser

Sourcemodule Pass_wrapper = Ocaml_shadow.Pass_wrapper

Sourcemodule Path = Ocaml_shadow.Path

Sourcemodule Patterns = Ocaml_shadow.Patterns

Sourcemodule Persistent_env = Ocaml_shadow.Persistent_env

Sourcemodule Polling = Ocaml_shadow.Polling

Sourcemodule Pparse = Ocaml_shadow.Pparse

Sourcemodule Predef = Ocaml_shadow.Predef

Sourcemodule Primitive = Ocaml_shadow.Primitive

Sourcemodule Printast = Ocaml_shadow.Printast

Sourcemodule Printclambda = Ocaml_shadow.Printclambda

Sourcemodule Printclambda_primitives = Ocaml_shadow.Printclambda_primitives

Sourcemodule Printcmm = Ocaml_shadow.Printcmm

Sourcemodule Printinstr = Ocaml_shadow.Printinstr

Sourcemodule Printlambda = Ocaml_shadow.Printlambda

Sourcemodule Printlinear = Ocaml_shadow.Printlinear

Sourcemodule Printmach = Ocaml_shadow.Printmach

Sourcemodule Printpat = Ocaml_shadow.Printpat

Sourcemodule Printtyp = Ocaml_shadow.Printtyp

Sourcemodule Printtyped = Ocaml_shadow.Printtyped

Sourcemodule Proc = Ocaml_shadow.Proc

Sourcemodule Profile = Ocaml_shadow.Profile

Sourcemodule Projection = Ocaml_shadow.Projection

Sourcemodule Rawprinttyp = Ocaml_shadow.Rawprinttyp

Sourcemodule Ref_to_variables = Ocaml_shadow.Ref_to_variables

Sourcemodule Reg = Ocaml_shadow.Reg

Sourcemodule Reload = Ocaml_shadow.Reload

Sourcemodule Reloadgen = Ocaml_shadow.Reloadgen

Source

module Remove_free_vars_equal_to_args =
  Ocaml_shadow.Remove_free_vars_equal_to_args

Sourcemodule Remove_unused_arguments = Ocaml_shadow.Remove_unused_arguments

Sourcemodule Remove_unused_closure_vars = Ocaml_shadow.Remove_unused_closure_vars

Source

module Remove_unused_program_constructs =
  Ocaml_shadow.Remove_unused_program_constructs

Sourcemodule Runtimedef = Ocaml_shadow.Runtimedef

Sourcemodule Schedgen = Ocaml_shadow.Schedgen

Sourcemodule Scheduling = Ocaml_shadow.Scheduling

Sourcemodule Selectgen = Ocaml_shadow.Selectgen

Sourcemodule Selection = Ocaml_shadow.Selection

Sourcemodule Semantics_of_primitives = Ocaml_shadow.Semantics_of_primitives

Sourcemodule Set_of_closures_id = Ocaml_shadow.Set_of_closures_id

Sourcemodule Set_of_closures_origin = Ocaml_shadow.Set_of_closures_origin

Sourcemodule Shape = Ocaml_shadow.Shape

Sourcemodule Shape_reduce = Ocaml_shadow.Shape_reduce

Sourcemodule Share_constants = Ocaml_shadow.Share_constants

Sourcemodule Signature_group = Ocaml_shadow.Signature_group

Sourcemodule Simple_value_approx = Ocaml_shadow.Simple_value_approx

Sourcemodule Simplif = Ocaml_shadow.Simplif

Sourcemodule Simplify_boxed_integer_ops = Ocaml_shadow.Simplify_boxed_integer_ops

Source

module Simplify_boxed_integer_ops_intf =
  Ocaml_shadow.Simplify_boxed_integer_ops_intf

Sourcemodule Simplify_common = Ocaml_shadow.Simplify_common

Sourcemodule Simplify_primitives = Ocaml_shadow.Simplify_primitives

Sourcemodule Spill = Ocaml_shadow.Spill

Sourcemodule Split = Ocaml_shadow.Split

Sourcemodule Stackframe = Ocaml_shadow.Stackframe

Sourcemodule Stackframegen = Ocaml_shadow.Stackframegen

Sourcemodule Static_exception = Ocaml_shadow.Static_exception

Sourcemodule Strmatch = Ocaml_shadow.Strmatch

Source

module Strongly_connected_components =
  Ocaml_shadow.Strongly_connected_components

Sourcemodule Stypes = Ocaml_shadow.Stypes

Sourcemodule Subst = Ocaml_shadow.Subst

Sourcemodule Switch = Ocaml_shadow.Switch

Sourcemodule Symbol = Ocaml_shadow.Symbol

Sourcemodule Symtable = Ocaml_shadow.Symtable

Sourcemodule Tag = Ocaml_shadow.Tag

Sourcemodule Targetint = Ocaml_shadow.Targetint

Sourcemodule Tast_iterator = Ocaml_shadow.Tast_iterator

Sourcemodule Tast_mapper = Ocaml_shadow.Tast_mapper

Sourcemodule Terminfo = Ocaml_shadow.Terminfo

Sourcemodule Thread_sanitizer = Ocaml_shadow.Thread_sanitizer

Sourcemodule Tmc = Ocaml_shadow.Tmc

Sourcemodule Topcommon = Ocaml_shadow.Topcommon

Sourcemodule Topdirs = Ocaml_shadow.Topdirs

Sourcemodule Topeval = Ocaml_shadow.Topeval

Sourcemodule Tophooks = Ocaml_shadow.Tophooks

Sourcemodule Toploop = Ocaml_shadow.Toploop

Sourcemodule Topmain = Ocaml_shadow.Topmain

Sourcemodule Topprinters = Ocaml_shadow.Topprinters

Sourcemodule Topstart = Ocaml_shadow.Topstart

Sourcemodule Trace = Ocaml_shadow.Trace

Sourcemodule Translattribute = Ocaml_shadow.Translattribute

Sourcemodule Translclass = Ocaml_shadow.Translclass

Sourcemodule Translcore = Ocaml_shadow.Translcore

Sourcemodule Translmod = Ocaml_shadow.Translmod

Sourcemodule Translobj = Ocaml_shadow.Translobj

Sourcemodule Translprim = Ocaml_shadow.Translprim

Source

module Traverse_for_exported_symbols =
  Ocaml_shadow.Traverse_for_exported_symbols

Sourcemodule Type_immediacy = Ocaml_shadow.Type_immediacy

Sourcemodule Typeclass = Ocaml_shadow.Typeclass

Sourcemodule Typecore = Ocaml_shadow.Typecore

Sourcemodule Typedecl = Ocaml_shadow.Typedecl

Sourcemodule Typedecl_immediacy = Ocaml_shadow.Typedecl_immediacy

Sourcemodule Typedecl_properties = Ocaml_shadow.Typedecl_properties

Sourcemodule Typedecl_separability = Ocaml_shadow.Typedecl_separability

Sourcemodule Typedecl_unboxed = Ocaml_shadow.Typedecl_unboxed

Sourcemodule Typedecl_variance = Ocaml_shadow.Typedecl_variance

Sourcemodule Typedtree = Ocaml_shadow.Typedtree

Sourcemodule Typemod = Ocaml_shadow.Typemod

Sourcemodule Typeopt = Ocaml_shadow.Typeopt

Sourcemodule Types = Ocaml_shadow.Types

Sourcemodule Typetexp = Ocaml_shadow.Typetexp

Sourcemodule Un_anf = Ocaml_shadow.Un_anf

Sourcemodule Unbox_closures = Ocaml_shadow.Unbox_closures

Sourcemodule Unbox_free_vars_of_closures = Ocaml_shadow.Unbox_free_vars_of_closures

Sourcemodule Unbox_specialised_args = Ocaml_shadow.Unbox_specialised_args

Sourcemodule Unit_info = Ocaml_shadow.Unit_info

Sourcemodule Untypeast = Ocaml_shadow.Untypeast

Sourcemodule Value_rec_check = Ocaml_shadow.Value_rec_check

Sourcemodule Value_rec_compiler = Ocaml_shadow.Value_rec_compiler

Sourcemodule Value_rec_types = Ocaml_shadow.Value_rec_types

Sourcemodule Var_within_closure = Ocaml_shadow.Var_within_closure

Sourcemodule Variable = Ocaml_shadow.Variable

Sourcemodule Warnings = Ocaml_shadow.Warnings

Sourcemodule X86_ast = Ocaml_shadow.X86_ast

Sourcemodule X86_dsl = Ocaml_shadow.X86_dsl

Sourcemodule X86_gas = Ocaml_shadow.X86_gas

Sourcemodule X86_masm = Ocaml_shadow.X86_masm

Sourcemodule X86_proc = Ocaml_shadow.X86_proc

Install

Dune Dependency

Authors

Maintainers

Sources

doc/ppxlib/Ppxlib/index.html

Module `Ppxlib`Source

The core `ppxlib` entries

Manipulating the AST

Context-free rewriting

Other helpers

Checks

Common helper functions

Modules from other libraries

The whole AST types

Extension points

Core language

Type expressions

Patterns

Value expressions

Value descriptions

Type declarations

Class language

Type expressions for the class language

Value expressions for the class language

Module language

Type expressions for the module language

Value expressions for the module language

Toplevel

Toplevel phrases

package ppxlib

Install

Dune Dependency

Authors

Maintainers

Sources

doc/ppxlib/Ppxlib/index.html

Module PpxlibSource

The core ppxlib entries

Manipulating the AST

Context-free rewriting

Other helpers

Driver-related modules

Checks

Common helper functions

Modules from other libraries

The whole AST types

Extension points

Core language

Type expressions

Patterns

Value expressions

Value descriptions

Type declarations

Class language

Type expressions for the class language

Value expressions for the class language

Module language

Type expressions for the module language

Value expressions for the module language

Toplevel

Toplevel phrases

Module `Ppxlib`Source

The core `ppxlib` entries