This library is deprecated, use Ppxlib instead

Ppx_core is our stdlib for the ppx code so we just include Base here

`module Base = Base`
`module Stdio = Stdio`
`include Base`

This module is the toplevel of the Base library; it's what you get when you write `open Base`.

The recommended way to use Base is to build with `-open Base`. Files compiled this way will have the environment described in this file as their initial environment.

Base extends some modules and data structures from the standard library, like `Array`, `Buffer`, `Bytes`, `Char`, `Hashtbl`, `Int32`, `Int64`, `Lazy`, `List`, `Map`, `Nativeint`, `Printf`, `Random`, `Set`, `String`, `Sys`, and `Uchar`. One key difference is that Base doesn't use exceptions as much as the standard library and instead makes heavy use of the `Result` type, as in:

    type ('a,'b) result = Ok of 'a | Error of 'b

Base also adds entirely new modules, most notably:

- `Comparable`, `Comparator`, and `Comparisons` in lieu of polymorphic compare.
- `Container`, which provides a consistent interface across container-like data structures (arrays, lists, strings).
- `Result`, `Error`, and `Or_error`, supporting the or-error pattern.

Broadly the goal of Base is both to be a more complete standard library, with richer APIs, and to be more consistent in its design. For instance, in the standard library some things have modules and others don't; in Base, everything is a module.

`module Applicative = Base.Applicative`
`module Array = Base.Array`
`module Avltree = Base.Avltree`
`module Backtrace = Base.Backtrace`
`module Binary_search = Base.Binary_search`
`module Binary_searchable = Base.Binary_searchable`
`module Blit = Base.Blit`
`module Bool = Base.Bool`
`module Buffer = Base.Buffer`
`module Bytes = Base.Bytes`
`module Char = Base.Char`
`module Commutative_group = Base.Commutative_group`
`module Comparable = Base.Comparable`
`module Comparator = Base.Comparator`
`module Comparisons = Base.Comparisons`
`module Container = Base.Container`
`module Either = Base.Either`
`module Equal = Base.Equal`
`module Error = Base.Error`
`module Exn = Base.Exn`
`module Field = Base.Field`
`module Float = Base.Float`
`module Floatable = Base.Floatable`
`module Fn = Base.Fn`
`module Formatter = Base.Formatter`
`module Hash = Base.Hash`
`module Hash_set = Base.Hash_set`
`module Hashable = Base.Hashable`
`module Hasher = Base.Hasher`
`module Hashtbl = Base.Hashtbl`
`module Heap_block = Base.Heap_block`
`module Identifiable = Base.Identifiable`
`module Indexed_container = Base.Indexed_container`
`module Info = Base.Info`
`module Int = Base.Int`
`module Int32 = Base.Int32`
`module Int63 = Base.Int63`
`module Int64 = Base.Int64`
`module Intable = Base.Intable`
`module Invariant = Base.Invariant`
`module Lazy = Base.Lazy`
`module List = Base.List`
`module Map = Base.Map`
`module Maybe_bound = Base.Maybe_bound`
`module Monad = Base.Monad`
`module Nativeint = Base.Nativeint`
`module Option = Base.Option`
`module Option_array = Base.Option_array`
`module Or_error = Base.Or_error`
`module Ordered_collection_common = Base.Ordered_collection_common`
`module Ordering = Base.Ordering`
`module Poly = Base.Poly`

`Poly` is a convenient shorthand for `Polymorphic_compare` in the common case that one wants to use a polymorphic comparator directly in an expression, e.g., `Poly.equal a b`.

`module Polymorphic_compare = Base.Polymorphic_compare`
`module Popcount = Base.Popcount`
`module Pretty_printer = Base.Pretty_printer`
`module Printf = Base.Printf`
`module Linked_queue = Base.Linked_queue`
`module Queue = Base.Queue`
`module Random = Base.Random`
`module Ref = Base.Ref`
`module Result = Base.Result`
`module Sequence = Base.Sequence`
`module Set = Base.Set`
`module Sexpable = Base.Sexpable`
`module Sign = Base.Sign`
`module Source_code_position = Base.Source_code_position`
`module Staged = Base.Staged`
`module String = Base.String`
`module Stringable = Base.Stringable`
`module Sys = Base.Sys`
`module T = Base.T`
`module Type_equal = Base.Type_equal`
`module Uniform_array = Base.Uniform_array`
`module Unit = Base.Unit`
`module Uchar = Base.Uchar`
`module Validate = Base.Validate`
`module Variant = Base.Variant`
`module With_return = Base.With_return`
`module Word_size = Base.Word_size`
`include T`

This module defines various abstract interfaces that are convenient when one needs a module that matches a bare signature with just a type. This sometimes occurs in functor arguments and in interfaces.

`module type T : sig ... end`
`module type T1 : sig ... end`
`module type T2 : sig ... end`
`module type T3 : sig ... end`
`module Sexp = Base.Sexp`
`module Export = Base.Export`
`include Export`
`type 'a array``= 'a Array.t```
`val compare_array : a. ('a ‑> 'a ‑> int) ‑> 'a array ‑> 'a array ‑> int`
`val array_of_sexp : a. (Sexp.t ‑> 'a) ‑> Sexp.t ‑> 'a array`
`val sexp_of_array : a. ('a ‑> Sexp.t) ‑> 'a array ‑> Sexp.t`
`type bool``= Bool.t```
`val compare_bool : bool ‑> bool ‑> int`
`val hash_fold_bool : Hash.state ‑> bool ‑> Hash.state`
`val hash_bool : bool ‑> Hash.hash_value`
`val bool_of_sexp : Sexp.t ‑> bool`
`val sexp_of_bool : bool ‑> Sexp.t`
`type char``= Char.t```
`val compare_char : char ‑> char ‑> int`
`val hash_fold_char : Hash.state ‑> char ‑> Hash.state`
`val hash_char : char ‑> Hash.hash_value`
`val char_of_sexp : Sexp.t ‑> char`
`val sexp_of_char : char ‑> Sexp.t`
`type exn``= Exn.t```
`val sexp_of_exn : exn ‑> Sexp.t`
`type float``= Float.t```
`val compare_float : float ‑> float ‑> int`
`val hash_fold_float : Hash.state ‑> float ‑> Hash.state`
`val hash_float : float ‑> Hash.hash_value`
`val float_of_sexp : Sexp.t ‑> float`
`val sexp_of_float : float ‑> Sexp.t`
`type int``= Int.t```
`val compare_int : int ‑> int ‑> int`
`val hash_fold_int : Hash.state ‑> int ‑> Hash.state`
`val hash_int : int ‑> Hash.hash_value`
`val int_of_sexp : Sexp.t ‑> int`
`val sexp_of_int : int ‑> Sexp.t`
`type int32``= Int32.t```
`val compare_int32 : int32 ‑> int32 ‑> int`
`val hash_fold_int32 : Hash.state ‑> int32 ‑> Hash.state`
`val hash_int32 : int32 ‑> Hash.hash_value`
`val int32_of_sexp : Sexp.t ‑> int32`
`val sexp_of_int32 : int32 ‑> Sexp.t`
`type int64``= Int64.t```
`val compare_int64 : int64 ‑> int64 ‑> int`
`val hash_fold_int64 : Hash.state ‑> int64 ‑> Hash.state`
`val hash_int64 : int64 ‑> Hash.hash_value`
`val int64_of_sexp : Sexp.t ‑> int64`
`val sexp_of_int64 : int64 ‑> Sexp.t`
`type 'a list``= 'a List.t```
`val compare_list : a. ('a ‑> 'a ‑> int) ‑> 'a list ‑> 'a list ‑> int`
`val hash_fold_list : a. (Hash.state ‑> 'a ‑> Hash.state) ‑> Hash.state ‑> 'a list ‑> Hash.state`
`val list_of_sexp : a. (Sexp.t ‑> 'a) ‑> Sexp.t ‑> 'a list`
`val sexp_of_list : a. ('a ‑> Sexp.t) ‑> 'a list ‑> Sexp.t`
`type nativeint``= Nativeint.t```
`val compare_nativeint : nativeint ‑> nativeint ‑> int`
`val hash_fold_nativeint : Hash.state ‑> nativeint ‑> Hash.state`
`val hash_nativeint : nativeint ‑> Hash.hash_value`
`val nativeint_of_sexp : Sexp.t ‑> nativeint`
`val sexp_of_nativeint : nativeint ‑> Sexp.t`
`type 'a option``= 'a Option.t```
`val compare_option : a. ('a ‑> 'a ‑> int) ‑> 'a option ‑> 'a option ‑> int`
`val hash_fold_option : a. (Hash.state ‑> 'a ‑> Hash.state) ‑> Hash.state ‑> 'a option ‑> Hash.state`
`val option_of_sexp : a. (Sexp.t ‑> 'a) ‑> Sexp.t ‑> 'a option`
`val sexp_of_option : a. ('a ‑> Sexp.t) ‑> 'a option ‑> Sexp.t`
`type 'a ref``= 'a Ref.t```
`val compare_ref : a. ('a ‑> 'a ‑> int) ‑> 'a ref ‑> 'a ref ‑> int`
`val ref_of_sexp : a. (Sexp.t ‑> 'a) ‑> Sexp.t ‑> 'a ref`
`val sexp_of_ref : a. ('a ‑> Sexp.t) ‑> 'a ref ‑> Sexp.t`
`type string``= String.t```
`val compare_string : string ‑> string ‑> int`
`val hash_fold_string : Hash.state ‑> string ‑> Hash.state`
`val hash_string : string ‑> Hash.hash_value`
`val string_of_sexp : Sexp.t ‑> string`
`val sexp_of_string : string ‑> Sexp.t`
`type bytes``= Bytes.t```
`val compare_bytes : bytes ‑> bytes ‑> int`
`val bytes_of_sexp : Sexp.t ‑> bytes`
`val sexp_of_bytes : bytes ‑> Sexp.t`
`type unit``= Unit.t```
`val compare_unit : unit ‑> unit ‑> int`
`val hash_fold_unit : Hash.state ‑> unit ‑> Hash.state`
`val hash_unit : unit ‑> Hash.hash_value`
`val unit_of_sexp : Sexp.t ‑> unit`
`val sexp_of_unit : unit ‑> Sexp.t`

Format stuff

`type ('a, 'b, 'c) format``= ('a, 'b, 'c) Pervasives.format```
`type ('a, 'b, 'c, 'd) format4``= ('a, 'b, 'c, 'd) Pervasives.format4```
`type ('a, 'b, 'c, 'd, 'e, 'f) format6``= ('a, 'b, 'c, 'd, 'e, 'f) Pervasives.format6```

### Sexp

Exporting the ad-hoc types that are recognized by `ppx_sexp_*` converters. `sexp_array`, `sexp_list`, and `sexp_option` allow a record field to be absent when converting from a sexp, and if absent, the field will take a default value of the appropriate type:

            sexp_array   [||]
            sexp_bool    false
            sexp_list    []
            sexp_option  None

`sexp_opaque` causes the conversion to sexp to produce the atom `<opaque>`.

For more documentation, see sexplib/README.md.

`type 'a sexp_array``= 'a array```
`type 'a sexp_list``= 'a list```
`type 'a sexp_opaque``= 'a```
`type 'a sexp_option``= 'a option```

List operators

`include List.Infix`
`val (@) : 'a Base__List.t ‑> 'a Base__List.t ‑> 'a Base__List.t`

Int operators and comparisons

`include Int.O`

A sub-module designed to be opened to make working with ints more convenient.

`include Base__.Int_intf.Operators_unbounded`
`type t`````
`val (+) : t ‑> t ‑> t`
`val (-) : t ‑> t ‑> t`
`val (*) : t ‑> t ‑> t`
`val (/) : t ‑> t ‑> t`
`val (~-) : t ‑> t`
`val (**) : t ‑> t ‑> t`
`include Base.Comparisons.Infix with type t := t`
`type t`````
`val (>=) : t ‑> t ‑> bool`
`val (<=) : t ‑> t ‑> bool`
`val (=) : t ‑> t ‑> bool`
`val (>) : t ‑> t ‑> bool`
`val (<) : t ‑> t ‑> bool`
`val (<>) : t ‑> t ‑> bool`
`val abs : t ‑> t`
`val neg : t ‑> t`
`val zero : t`
`val (%) : t ‑> t ‑> t`
`val (/%) : t ‑> t ‑> t`
`val (//) : t ‑> t ‑> float`
`val (land) : t ‑> t ‑> t`
`val (lor) : t ‑> t ‑> t`
`val (lxor) : t ‑> t ‑> t`
`val (lnot) : t ‑> t`
`val (lsl) : t ‑> int ‑> t`
`val (asr) : t ‑> int ‑> t`
`val (lsr) : t ‑> int ‑> t`
`include Base__.Import.Int_replace_polymorphic_compare`
`val (<) : int ‑> int ‑> bool`
`val (<=) : int ‑> int ‑> bool`
`val (<>) : int ‑> int ‑> bool`
`val (=) : int ‑> int ‑> bool`
`val (>) : int ‑> int ‑> bool`
`val (>=) : int ‑> int ‑> bool`
`val ascending : int ‑> int ‑> int`
`val descending : int ‑> int ‑> int`
`val compare : int ‑> int ‑> int`
`val equal : int ‑> int ‑> bool`
`val max : int ‑> int ‑> int`
`val min : int ‑> int ‑> int`

Float operators

`include Float.O_dot`

Similar to `O`, except that operators are suffixed with a dot, allowing one to have both int and float operators in scope simultaneously.

Similar to `O`, except that operators are suffixed with a dot, allowing one to have both int and float operators in scope simultaneously.

`val (+.) : Base.Float.t ‑> Base.Float.t ‑> Base.Float.t`
`val (-.) : Base.Float.t ‑> Base.Float.t ‑> Base.Float.t`
`val (*.) : Base.Float.t ‑> Base.Float.t ‑> Base.Float.t`
`val (/.) : Base.Float.t ‑> Base.Float.t ‑> Base.Float.t`
`val (**.) : Base.Float.t ‑> Base.Float.t ‑> Base.Float.t`
`val (~-.) : Base.Float.t ‑> Base.Float.t`
`external (|>) : 'a ‑> ('a ‑> 'b) ‑> 'b = "%revapply"`

Reverse application operator. `x |> g |> f` is equivalent to `f (g (x))`.

`external (@@) : ('a ‑> 'b) ‑> 'a ‑> 'b = "%apply"`

Application operator. `g @@ f @@ x` is equivalent to `g (f (x))`.

Boolean operations

`external (&&) : bool ‑> bool ‑> bool = "%sequand"`
`external (||) : bool ‑> bool ‑> bool = "%sequor"`
`external not : bool ‑> bool = "%boolnot"`
`external ignore : _ ‑> unit = "%ignore"`
`val (^) : String.t ‑> String.t ‑> String.t`

Common string operations

Reference operations

`external (!) : 'a ref ‑> 'a = "%field0"`
`external ref : 'a ‑> 'a ref = "%makemutable"`
`external (:=) : 'a ref ‑> 'a ‑> unit = "%setfield0"`

Pair operations

`val fst : ('a * 'b) ‑> 'a`
`val snd : ('a * 'b) ‑> 'b`

Exceptions stuff

`val failwith : string ‑> 'a`
`val invalid_arg : string ‑> 'a`
`val raise : exn ‑> 'a`
`val raise_s : Sexp.t ‑> 'a`

Misc

`val phys_equal : 'a ‑> 'a ‑> bool`
`external force : 'a Lazy.t ‑> 'a = "%lazy_force"`
`module Continue_or_stop = Base__.Container_intf.Export.Continue_or_stop`

`Continue_or_stop.t` is used by the `f` argument to `fold_until` in order to indicate whether folding should continue, or stop early.

`exception` `Not_found_s of Sexplib0.Sexp.t`
`module Not_exposed_properly = Base.Not_exposed_properly`
`include Stdio`
`module In_channel = Stdio.In_channel`
`module Out_channel = Stdio.Out_channel`
`val stdin : In_channel.t`

Same as In_channel.stdin

`val stdout : Out_channel.t`

Same as Out_channel.stdout

`val stderr : Out_channel.t`

Same as Out_channel.stderr

`val printf : ('a, Out_channel.t, Base.unit) Base.format ‑> 'a`

Same as Out_channel.printf

`val eprintf : ('a, Out_channel.t, Base.unit) Base.format ‑> 'a`

Same as Out_channel.eprintf

`val print_endline : Base.string ‑> Base.unit`

Same as Out_channel.print_endline

`val prerr_endline : Base.string ‑> Base.unit`

Same as Out_channel.prerr_endline

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

`include module type of sig ... 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 Parser := Ocaml_shadow.Parser with module Parsetree := Ocaml_shadow.Parsetree with module Pprintast := Ocaml_shadow.Pprintast with module Syntaxerr := Ocaml_shadow.Syntaxerr`
`module Do_not_use_directly = Ocaml_shadow.Do_not_use_directly`
`module Afl_instrument = Do_not_use_directly`
`module Alias_analysis = Do_not_use_directly`
`module Allocated_const = Do_not_use_directly`
`module Annot = Do_not_use_directly`
`module Arch = Do_not_use_directly`
`module Arg_helper = Do_not_use_directly`
`module Asmgen = Do_not_use_directly`
`module Asmlibrarian = Do_not_use_directly`
`module Asmlink = Do_not_use_directly`
`module Asmpackager = Do_not_use_directly`
`module Ast_helper = Do_not_use_directly`
`module Ast_invariants = Do_not_use_directly`
`module Ast_iterator = Do_not_use_directly`
`module Ast_mapper = Do_not_use_directly`
`module Asttypes = Do_not_use_directly`
`module Attr_helper = Do_not_use_directly`
`module Augment_specialised_args = Do_not_use_directly`
`module Backend_intf = Do_not_use_directly`
`module Branch_relaxation = Do_not_use_directly`
`module Branch_relaxation_intf = Do_not_use_directly`
`module Btype = Do_not_use_directly`
`module Build_export_info = Do_not_use_directly`
`module Builtin_attributes = Do_not_use_directly`
`module Bytegen = Do_not_use_directly`
`module Bytelibrarian = Do_not_use_directly`
`module Bytelink = Do_not_use_directly`
`module Bytepackager = Do_not_use_directly`
`module Bytesections = Do_not_use_directly`
`module CSE = Do_not_use_directly`
`module CSEgen = Do_not_use_directly`
`module Ccomp = Do_not_use_directly`
`module Clambda = Do_not_use_directly`
`module Clflags = Do_not_use_directly`
`module Closure = Do_not_use_directly`
`module Closure_conversion = Do_not_use_directly`
`module Closure_conversion_aux = Do_not_use_directly`
`module Closure_element = Do_not_use_directly`
`module Closure_id = Do_not_use_directly`
`module Closure_offsets = Do_not_use_directly`
`module Cmi_format = Do_not_use_directly`
`module Cmm = Do_not_use_directly`
`module Cmmgen = Do_not_use_directly`
`module Cmo_format = Do_not_use_directly`
`module Cmt_format = Do_not_use_directly`
`module Cmx_format = Do_not_use_directly`
`module Coloring = Do_not_use_directly`
`module Comballoc = Do_not_use_directly`
`module Compdynlink = Do_not_use_directly`
`module Compenv = Do_not_use_directly`
`module Compilation_unit = Do_not_use_directly`
`module Compile = Do_not_use_directly`
`module Compilenv = Do_not_use_directly`
`module Compmisc = Do_not_use_directly`
`module Compplugin = Do_not_use_directly`
`module Config = Do_not_use_directly`
`module Consistbl = Do_not_use_directly`
`module Ctype = Do_not_use_directly`
`module Datarepr = Do_not_use_directly`
`module Deadcode = Do_not_use_directly`
`module Debuginfo = Do_not_use_directly`
`module Depend = Do_not_use_directly`
`module Dll = Do_not_use_directly`
`module Docstrings = Do_not_use_directly`
`module Effect_analysis = Do_not_use_directly`
`module Emit = Do_not_use_directly`
`module Emitaux = Do_not_use_directly`
`module Emitcode = Do_not_use_directly`
`module Env = Do_not_use_directly`
`module Envaux = Do_not_use_directly`
`module Errors = Do_not_use_directly`
`module Export_id = Do_not_use_directly`
`module Export_info = Do_not_use_directly`
`module Export_info_for_pack = Do_not_use_directly`
`module Expunge = Do_not_use_directly`
`module Extract_projections = Do_not_use_directly`
`module Find_recursive_functions = Do_not_use_directly`
`module Flambda = Do_not_use_directly`
`module Flambda_invariants = Do_not_use_directly`
`module Flambda_iterators = Do_not_use_directly`
`module Flambda_to_clambda = Do_not_use_directly`
`module Flambda_utils = Do_not_use_directly`
`module Freshening = Do_not_use_directly`
`module Genprintval = Do_not_use_directly`
`module Id_types = Do_not_use_directly`
`module Ident = Do_not_use_directly`
`module Identifiable = Do_not_use_directly`
`module Import_approx = Do_not_use_directly`
`module Includeclass = Do_not_use_directly`
`module Includecore = Do_not_use_directly`
`module Includemod = Do_not_use_directly`
`module Inconstant_idents = Do_not_use_directly`
`module Initialize_symbol_to_let_symbol = Do_not_use_directly`
`module Inline_and_simplify = Do_not_use_directly`
`module Inline_and_simplify_aux = Do_not_use_directly`
`module Inlining_cost = Do_not_use_directly`
`module Inlining_decision = Do_not_use_directly`
`module Inlining_decision_intf = Do_not_use_directly`
`module Inlining_stats = Do_not_use_directly`
`module Inlining_stats_types = Do_not_use_directly`
`module Inlining_transforms = Do_not_use_directly`
`module Instruct = Do_not_use_directly`
`module Interf = Do_not_use_directly`
`module Interval = Do_not_use_directly`
`module Invariant_params = Do_not_use_directly`
`module Lambda = Do_not_use_directly`
`module Lexer = Do_not_use_directly`
`module Lift_code = Do_not_use_directly`
`module Lift_constants = Do_not_use_directly`
`module Lift_let_to_initialize_symbol = Do_not_use_directly`
`module Linearize = Do_not_use_directly`
`module Linkage_name = Do_not_use_directly`
`module Linscan = Do_not_use_directly`
`module Liveness = Do_not_use_directly`
`module Location = Do_not_use_directly`
`module Longident = Do_not_use_directly`
`module Mach = Do_not_use_directly`
`module Main = Do_not_use_directly`
`module Main_args = Do_not_use_directly`
`module Makedepend = Do_not_use_directly`
`module Matching = Do_not_use_directly`
`module Meta = Do_not_use_directly`
`module Middle_end = Do_not_use_directly`
`module Misc = Do_not_use_directly`
`module Mtype = Do_not_use_directly`
`module Mutable_variable = Do_not_use_directly`
`module Numbers = Do_not_use_directly`
`module Opcodes = Do_not_use_directly`
`module Oprint = Do_not_use_directly`
`module Optcompile = Do_not_use_directly`
`module Opterrors = Do_not_use_directly`
`module Optmain = Do_not_use_directly`
`module Outcometree = Do_not_use_directly`
`module Parameter = Do_not_use_directly`
`module Parmatch = Do_not_use_directly`
`module Parse = Do_not_use_directly`
`module Parser = Do_not_use_directly`
`module Parsetree = Do_not_use_directly`
`module Pass_wrapper = Do_not_use_directly`
`module Path = Do_not_use_directly`
`module Pparse = Do_not_use_directly`
`module Pprintast = Do_not_use_directly`
`module Predef = Do_not_use_directly`
`module Primitive = Do_not_use_directly`
`module Printast = Do_not_use_directly`
`module Printclambda = Do_not_use_directly`
`module Printcmm = Do_not_use_directly`
`module Printinstr = Do_not_use_directly`
`module Printlambda = Do_not_use_directly`
`module Printlinear = Do_not_use_directly`
`module Printmach = Do_not_use_directly`
`module Printtyp = Do_not_use_directly`
`module Printtyped = Do_not_use_directly`
`module Proc = Do_not_use_directly`
`module Profile = Do_not_use_directly`
`module Projection = Do_not_use_directly`
`module Ref_to_variables = Do_not_use_directly`
`module Reg = Do_not_use_directly`
`module Reload = Do_not_use_directly`
`module Reloadgen = Do_not_use_directly`
`module Remove_free_vars_equal_to_args = Do_not_use_directly`
`module Remove_unused_arguments = Do_not_use_directly`
`module Remove_unused_closure_vars = Do_not_use_directly`
`module Remove_unused_program_constructs = Do_not_use_directly`
`module Runtimedef = Do_not_use_directly`
`module Schedgen = Do_not_use_directly`
`module Scheduling = Do_not_use_directly`
`module Selectgen = Do_not_use_directly`
`module Selection = Do_not_use_directly`
`module Semantics_of_primitives = Do_not_use_directly`
`module Set_of_closures_id = Do_not_use_directly`
`module Set_of_closures_origin = Do_not_use_directly`
`module Share_constants = Do_not_use_directly`
`module Simple_value_approx = Do_not_use_directly`
`module Simplif = Do_not_use_directly`
`module Simplify_boxed_integer_ops = Do_not_use_directly`
`module Simplify_boxed_integer_ops_intf = Do_not_use_directly`
`module Simplify_common = Do_not_use_directly`
`module Simplify_primitives = Do_not_use_directly`
`module Spacetime_profiling = Do_not_use_directly`
`module Spill = Do_not_use_directly`
`module Split = Do_not_use_directly`
`module Static_exception = Do_not_use_directly`
`module Strmatch = Do_not_use_directly`
`module Strongly_connected_components = Do_not_use_directly`
`module Stypes = Do_not_use_directly`
`module Subst = Do_not_use_directly`
`module Switch = Do_not_use_directly`
`module Symbol = Do_not_use_directly`
`module Symtable = Do_not_use_directly`
`module Syntaxerr = Do_not_use_directly`
`module Tag = Do_not_use_directly`
`module Targetint = Do_not_use_directly`
`module Tast_mapper = Do_not_use_directly`
`module Tbl = Do_not_use_directly`
`module Terminfo = Do_not_use_directly`
`module Topdirs = Do_not_use_directly`
`module Toploop = Do_not_use_directly`
`module Topmain = Do_not_use_directly`
`module Topstart = Do_not_use_directly`
`module Trace = Do_not_use_directly`
`module Translattribute = Do_not_use_directly`
`module Translclass = Do_not_use_directly`
`module Translcore = Do_not_use_directly`
`module Translmod = Do_not_use_directly`
`module Translobj = Do_not_use_directly`
`module Typeclass = Do_not_use_directly`
`module Typecore = Do_not_use_directly`
`module Typedecl = Do_not_use_directly`
`module Typedtree = Do_not_use_directly`
`module TypedtreeIter = Do_not_use_directly`
`module TypedtreeMap = Do_not_use_directly`
`module Typemod = Do_not_use_directly`
`module Typeopt = Do_not_use_directly`
`module Types = Do_not_use_directly`
`module Typetexp = Do_not_use_directly`
`module Un_anf = Do_not_use_directly`
`module Unbox_closures = Do_not_use_directly`
`module Unbox_free_vars_of_closures = Do_not_use_directly`
`module Unbox_specialised_args = Do_not_use_directly`
`module Untypeast = Do_not_use_directly`
`module Var_within_closure = Do_not_use_directly`
`module Variable = Do_not_use_directly`
`module Warnings = Do_not_use_directly`
`module X86_ast = Do_not_use_directly`
`module X86_dsl = Do_not_use_directly`
`module X86_gas = Do_not_use_directly`
`module X86_masm = Do_not_use_directly`
`module X86_proc = Do_not_use_directly`
`module Std : sig ... end`
`module Light : sig ... end`

You should open this module if you intend to use Ppx_core with a standard library that is not Base.

`include Light`

You should open this module if you intend to use Ppx_core with a standard library that is not Base.

Includes the overrides from Ppxlib_ast, as well as all the Ast definitions since we need them in every single ppx

`include Ppxlib_ast`
`module Ast = Ppxlib_ast.Ast`
`module Ast_helper = Ppxlib_ast.Ast_helper`
`module Ast_magic = Ppxlib_ast__.Import.Selected_ast.Ast.Config`
`module Asttypes = Ppxlib_ast__.Import.Asttypes`
`module Docstrings = Ppxlib_ast.Docstrings`
`module Extra_warnings = Ppxlib_ast__.Warn`
`module Lexer = Ppxlib_ast.Lexer`
`module Parse = Ppxlib_ast.Parse`
`module Parser = Ppxlib_ast.Parser`
`module Parsetree = Ppxlib_ast__.Import.Parsetree`
`module Pprintast = Ppxlib_ast.Pprintast`
`module Select_ast = Ppxlib_ast__.Import.Select_ast`
`module Selected_ast = Ppxlib_ast__.Import.Selected_ast`
`module Syntaxerr = Ppxlib_ast.Syntaxerr`
`module Import_for_core = Ppxlib_ast__.Import`
`include Ast`

Definition of the OCaml AST

`type position``= Lexing.position``=` `{`

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

`}```
`type location``= Ppxlib_ast__.Import.Location.t``=` `{`

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

`}```
`type 'a loc``= 'a Ppxlib_ast__.Import.Location.loc``=` `{`

`txt : 'a;`
`loc : location;`

`}```
`type longident``= Ppxlib_ast__.Import.Longident.t``=`

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

``
`type longident_loc``= longident loc```

Auxiliary AST types used by parsetree and typedtree.

`type rec_flag``= Ppxlib_ast__.Import.Asttypes.rec_flag``=`

`|` `Nonrecursive`
`|` `Recursive`

``
`type direction_flag``= Ppxlib_ast__.Import.Asttypes.direction_flag``=`

`|` `Upto`
`|` `Downto`

``
`type private_flag``= Ppxlib_ast__.Import.Asttypes.private_flag``=`

`|` `Private`
`|` `Public`

``
`type mutable_flag``= Ppxlib_ast__.Import.Asttypes.mutable_flag``=`

`|` `Immutable`
`|` `Mutable`

``
`type virtual_flag``= Ppxlib_ast__.Import.Asttypes.virtual_flag``=`

`|` `Virtual`
`|` `Concrete`

``
`type override_flag``= Ppxlib_ast__.Import.Asttypes.override_flag``=`

`|` `Override`
`|` `Fresh`

``
`type closed_flag``= Ppxlib_ast__.Import.Asttypes.closed_flag``=`

`|` `Closed`
`|` `Open`

``
`type label``= string```
`type arg_label``= Ppxlib_ast__.Import.Asttypes.arg_label``=`

`|` `Nolabel`
`|` `Labelled of string`
`|` `Optional of string`

``
`type variance``= Ppxlib_ast__.Import.Asttypes.variance``=`

`|` `Covariant`
`|` `Contravariant`
`|` `Invariant`

``

Abstract syntax tree produced by parsing

`type constant``= Ppxlib_ast__.Import.Parsetree.constant``=`

`|` `Pconst_integer of string * char option`
`|` `Pconst_char of char`
`|` `Pconst_string of string * string option`
`|` `Pconst_float of string * char option`

``

### Extension points

`type attribute``= string loc * payload```
`type extension``= string loc * payload```
`type attributes``= attribute list```
`type payload``= Ppxlib_ast__.Import.Parsetree.payload``=`

`|` `PStr of structure`
`|` `PSig of signature`
`|` `PTyp of core_type`
`|` `PPat of pattern * expression option`

``

### Core language

`type core_type``= Ppxlib_ast__.Import.Parsetree.core_type``=` `{`

`ptyp_desc : core_type_desc;`
`ptyp_loc : location;`
`ptyp_attributes : attributes;`

`}```
`type core_type_desc``= Ppxlib_ast__.Import.Parsetree.core_type_desc``=`

`|` `Ptyp_any`
`|` `Ptyp_var of string`
`|` `Ptyp_arrow of arg_label * core_type * core_type`
`|` `Ptyp_tuple of core_type list`
`|` `Ptyp_constr of longident_loc * core_type list`
`|` `Ptyp_object of (string loc * attributes * core_type) list * closed_flag`
`|` `Ptyp_class of longident_loc * core_type list`
`|` `Ptyp_alias of core_type * string`
`|` `Ptyp_variant of row_field list * closed_flag * label list option`
`|` `Ptyp_poly of string loc list * core_type`
`|` `Ptyp_package of package_type`
`|` `Ptyp_extension of extension`

``
`type package_type``= longident_loc * (longident_loc * core_type) list```
`type row_field``= Ppxlib_ast__.Import.Parsetree.row_field``=`

`|` `Rtag of label * attributes * bool * core_type list`
`|` `Rinherit of core_type`

``
`type pattern``= Ppxlib_ast__.Import.Parsetree.pattern``=` `{`

`ppat_desc : pattern_desc;`
`ppat_loc : location;`
`ppat_attributes : attributes;`

`}```
`type pattern_desc``= Ppxlib_ast__.Import.Parsetree.pattern_desc``=`

`|` `Ppat_any`
`|` `Ppat_var of string loc`
`|` `Ppat_alias of pattern * string loc`
`|` `Ppat_constant of constant`
`|` `Ppat_interval of constant * constant`
`|` `Ppat_tuple of pattern list`
`|` `Ppat_construct of longident_loc * pattern option`
`|` `Ppat_variant of label * pattern option`
`|` `Ppat_record of (longident_loc * pattern) list * closed_flag`
`|` `Ppat_array of pattern list`
`|` `Ppat_or of pattern * pattern`
`|` `Ppat_constraint of pattern * core_type`
`|` `Ppat_type of longident_loc`
`|` `Ppat_lazy of pattern`
`|` `Ppat_unpack of string loc`
`|` `Ppat_exception of pattern`
`|` `Ppat_extension of extension`
`|` `Ppat_open of longident_loc * pattern`

``
`type expression``= Ppxlib_ast__.Import.Parsetree.expression``=` `{`

`pexp_desc : expression_desc;`
`pexp_loc : location;`
`pexp_attributes : attributes;`

`}```
`type expression_desc``= Ppxlib_ast__.Import.Parsetree.expression_desc``=`

`|` `Pexp_ident of longident_loc`
`|` `Pexp_constant of constant`
`|` `Pexp_let of rec_flag * value_binding list * expression`
`|` `Pexp_function of case list`
`|` `Pexp_fun of arg_label * expression option * pattern * expression`
`|` `Pexp_apply of expression * (arg_label * expression) list`
`|` `Pexp_match of expression * case list`
`|` `Pexp_try of expression * case list`
`|` `Pexp_tuple of expression list`
`|` `Pexp_construct of longident_loc * expression option`
`|` `Pexp_variant of label * expression option`
`|` `Pexp_record of (longident_loc * expression) list * expression option`
`|` `Pexp_field of expression * longident_loc`
`|` `Pexp_setfield of expression * longident_loc * expression`
`|` `Pexp_array of expression list`
`|` `Pexp_ifthenelse of expression * expression * expression option`
`|` `Pexp_sequence of expression * expression`
`|` `Pexp_while of expression * expression`
`|` `Pexp_for of pattern * expression * expression * direction_flag * expression`
`|` `Pexp_constraint of expression * core_type`
`|` `Pexp_coerce of expression * core_type option * core_type`
`|` `Pexp_send of expression * string loc`
`|` `Pexp_new of longident_loc`
`|` `Pexp_setinstvar of string loc * expression`
`|` `Pexp_override of (string loc * expression) list`
`|` `Pexp_letmodule of string loc * module_expr * expression`
`|` `Pexp_letexception of extension_constructor * expression`
`|` `Pexp_assert of expression`
`|` `Pexp_lazy of expression`
`|` `Pexp_poly of expression * core_type option`
`|` `Pexp_object of class_structure`
`|` `Pexp_newtype of string loc * expression`
`|` `Pexp_pack of module_expr`
`|` `Pexp_open of override_flag * longident_loc * expression`
`|` `Pexp_extension of extension`
`|` `Pexp_unreachable`

``
`type case``= Ppxlib_ast__.Import.Parsetree.case``=` `{`

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

`}```
`type value_description``= Ppxlib_ast__.Import.Parsetree.value_description``=` `{`

`pval_name : string loc;`
`pval_type : core_type;`
`pval_prim : string list;`
`pval_attributes : attributes;`
`pval_loc : location;`

`}```
`type type_declaration``= Ppxlib_ast__.Import.Parsetree.type_declaration``=` `{`

`ptype_name : string loc;`
`ptype_params : (core_type * variance) list;`
`ptype_cstrs : (core_type * core_type * location) list;`
`ptype_kind : type_kind;`
`ptype_private : private_flag;`
`ptype_manifest : core_type option;`
`ptype_attributes : attributes;`
`ptype_loc : location;`

`}```
`type type_kind``= Ppxlib_ast__.Import.Parsetree.type_kind``=`

`|` `Ptype_abstract`
`|` `Ptype_variant of constructor_declaration list`
`|` `Ptype_record of label_declaration list`
`|` `Ptype_open`

``
`type label_declaration``= Ppxlib_ast__.Import.Parsetree.label_declaration``=` `{`

`pld_name : string loc;`
`pld_mutable : mutable_flag;`
`pld_type : core_type;`
`pld_loc : location;`
`pld_attributes : attributes;`

`}```
`type constructor_declaration``= Ppxlib_ast__.Import.Parsetree.constructor_declaration``=` `{`

`pcd_name : string loc;`
`pcd_args : constructor_arguments;`
`pcd_res : core_type option;`
`pcd_loc : location;`
`pcd_attributes : attributes;`

`}```
`type constructor_arguments``= Ppxlib_ast__.Import.Parsetree.constructor_arguments``=`

`|` `Pcstr_tuple of core_type list`
`|` `Pcstr_record of label_declaration list`

``
`type type_extension``= Ppxlib_ast__.Import.Parsetree.type_extension``=` `{`

`ptyext_path : longident_loc;`
`ptyext_params : (core_type * variance) list;`
`ptyext_constructors : extension_constructor list;`
`ptyext_private : private_flag;`
`ptyext_attributes : attributes;`

`}```
`type extension_constructor``= Ppxlib_ast__.Import.Parsetree.extension_constructor``=` `{`

`pext_name : string loc;`
`pext_kind : extension_constructor_kind;`
`pext_loc : location;`
`pext_attributes : attributes;`

`}```
`type extension_constructor_kind``= Ppxlib_ast__.Import.Parsetree.extension_constructor_kind``=`

`|` `Pext_decl of constructor_arguments * core_type option`
`|` `Pext_rebind of longident_loc`

``

### Class language

`type class_type``= Ppxlib_ast__.Import.Parsetree.class_type``=` `{`

`pcty_desc : class_type_desc;`
`pcty_loc : location;`
`pcty_attributes : attributes;`

`}```
`type class_type_desc``= Ppxlib_ast__.Import.Parsetree.class_type_desc``=`

`|` `Pcty_constr of longident_loc * core_type list`
`|` `Pcty_signature of class_signature`
`|` `Pcty_arrow of arg_label * core_type * class_type`
`|` `Pcty_extension of extension`

``
`type class_signature``= Ppxlib_ast__.Import.Parsetree.class_signature``=` `{`

`pcsig_self : core_type;`
`pcsig_fields : class_type_field list;`

`}```
`type class_type_field``= Ppxlib_ast__.Import.Parsetree.class_type_field``=` `{`

`pctf_desc : class_type_field_desc;`
`pctf_loc : location;`
`pctf_attributes : attributes;`

`}```
`type class_type_field_desc``= Ppxlib_ast__.Import.Parsetree.class_type_field_desc``=`

`|` `Pctf_inherit of class_type`
`|` `Pctf_val of string loc * mutable_flag * virtual_flag * core_type`
`|` `Pctf_method of string loc * private_flag * virtual_flag * core_type`
`|` `Pctf_constraint of core_type * core_type`
`|` `Pctf_attribute of attribute`
`|` `Pctf_extension of extension`

``
`type 'a class_infos``= 'a Ppxlib_ast__.Import.Parsetree.class_infos``=` `{`

`pci_virt : virtual_flag;`
`pci_params : (core_type * variance) list;`
`pci_name : string loc;`
`pci_expr : 'a;`
`pci_loc : location;`
`pci_attributes : attributes;`

`}```
`type class_description``= class_type class_infos```
`type class_type_declaration``= class_type class_infos```
`type class_expr``= Ppxlib_ast__.Import.Parsetree.class_expr``=` `{`

`pcl_desc : class_expr_desc;`
`pcl_loc : location;`
`pcl_attributes : attributes;`

`}```
`type class_expr_desc``= Ppxlib_ast__.Import.Parsetree.class_expr_desc``=`

`|` `Pcl_constr of longident_loc * core_type list`
`|` `Pcl_structure of class_structure`
`|` `Pcl_fun of arg_label * expression option * pattern * class_expr`
`|` `Pcl_apply of class_expr * (arg_label * expression) list`
`|` `Pcl_let of rec_flag * value_binding list * class_expr`
`|` `Pcl_constraint of class_expr * class_type`
`|` `Pcl_extension of extension`

``
`type class_structure``= Ppxlib_ast__.Import.Parsetree.class_structure``=` `{`

`pcstr_self : pattern;`
`pcstr_fields : class_field list;`

`}```
`type class_field``= Ppxlib_ast__.Import.Parsetree.class_field``=` `{`

`pcf_desc : class_field_desc;`
`pcf_loc : location;`
`pcf_attributes : attributes;`

`}```
`type class_field_desc``= Ppxlib_ast__.Import.Parsetree.class_field_desc``=`

`|` `Pcf_inherit of override_flag * class_expr * string loc option`
`|` `Pcf_val of string loc * mutable_flag * class_field_kind`
`|` `Pcf_method of string loc * private_flag * class_field_kind`
`|` `Pcf_constraint of core_type * core_type`
`|` `Pcf_initializer of expression`
`|` `Pcf_attribute of attribute`
`|` `Pcf_extension of extension`

``
`type class_field_kind``= Ppxlib_ast__.Import.Parsetree.class_field_kind``=`

`|` `Cfk_virtual of core_type`
`|` `Cfk_concrete of override_flag * expression`

``
`type class_declaration``= class_expr class_infos```

### Module language

`type module_type``= Ppxlib_ast__.Import.Parsetree.module_type``=` `{`

`pmty_desc : module_type_desc;`
`pmty_loc : location;`
`pmty_attributes : attributes;`

`}```
`type module_type_desc``= Ppxlib_ast__.Import.Parsetree.module_type_desc``=`

`|` `Pmty_ident of longident_loc`
`|` `Pmty_signature of signature`
`|` `Pmty_functor of string loc * module_type option * module_type`
`|` `Pmty_with of module_type * with_constraint list`
`|` `Pmty_typeof of module_expr`
`|` `Pmty_extension of extension`
`|` `Pmty_alias of longident_loc`

``
`type signature``= signature_item list```
`type signature_item``= Ppxlib_ast__.Import.Parsetree.signature_item``=` `{`

`psig_desc : signature_item_desc;`
`psig_loc : location;`

`}```
`type signature_item_desc``= Ppxlib_ast__.Import.Parsetree.signature_item_desc``=`

`|` `Psig_value of value_description`
`|` `Psig_type of rec_flag * type_declaration list`
`|` `Psig_typext of type_extension`
`|` `Psig_exception of extension_constructor`
`|` `Psig_module of module_declaration`
`|` `Psig_recmodule of module_declaration list`
`|` `Psig_modtype of module_type_declaration`
`|` `Psig_open of open_description`
`|` `Psig_include of include_description`
`|` `Psig_class of class_description list`
`|` `Psig_class_type of class_type_declaration list`
`|` `Psig_attribute of attribute`
`|` `Psig_extension of extension * attributes`

``
`type module_declaration``= Ppxlib_ast__.Import.Parsetree.module_declaration``=` `{`

`pmd_name : string loc;`
`pmd_type : module_type;`
`pmd_attributes : attributes;`
`pmd_loc : location;`

`}```
`type module_type_declaration``= Ppxlib_ast__.Import.Parsetree.module_type_declaration``=` `{`

`pmtd_name : string loc;`
`pmtd_type : module_type option;`
`pmtd_attributes : attributes;`
`pmtd_loc : location;`

`}```
`type open_description``= Ppxlib_ast__.Import.Parsetree.open_description``=` `{`

`popen_lid : longident_loc;`
`popen_override : override_flag;`
`popen_loc : location;`
`popen_attributes : attributes;`

`}```
`type 'a include_infos``= 'a Ppxlib_ast__.Import.Parsetree.include_infos``=` `{`

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

`}```
`type include_description``= module_type include_infos```
`type include_declaration``= module_expr include_infos```
`type with_constraint``= Ppxlib_ast__.Import.Parsetree.with_constraint``=`

`|` `Pwith_type of longident_loc * type_declaration`
`|` `Pwith_module of longident_loc * longident_loc`
`|` `Pwith_typesubst of type_declaration`
`|` `Pwith_modsubst of string loc * longident_loc`

``
`type module_expr``= Ppxlib_ast__.Import.Parsetree.module_expr``=` `{`

`pmod_desc : module_expr_desc;`
`pmod_loc : location;`
`pmod_attributes : attributes;`

`}```
`type module_expr_desc``= Ppxlib_ast__.Import.Parsetree.module_expr_desc``=`

`|` `Pmod_ident of longident_loc`
`|` `Pmod_structure of structure`
`|` `Pmod_functor of string loc * module_type option * module_expr`
`|` `Pmod_apply of module_expr * module_expr`
`|` `Pmod_constraint of module_expr * module_type`
`|` `Pmod_unpack of expression`
`|` `Pmod_extension of extension`

``
`type structure``= structure_item list```
`type structure_item``= Ppxlib_ast__.Import.Parsetree.structure_item``=` `{`

`pstr_desc : structure_item_desc;`
`pstr_loc : location;`

`}```
`type structure_item_desc``= Ppxlib_ast__.Import.Parsetree.structure_item_desc``=`

`|` `Pstr_eval of expression * attributes`
`|` `Pstr_value of rec_flag * value_binding list`
`|` `Pstr_primitive of value_description`
`|` `Pstr_type of rec_flag * type_declaration list`
`|` `Pstr_typext of type_extension`
`|` `Pstr_exception of extension_constructor`
`|` `Pstr_module of module_binding`
`|` `Pstr_recmodule of module_binding list`
`|` `Pstr_modtype of module_type_declaration`
`|` `Pstr_open of open_description`
`|` `Pstr_class of class_declaration list`
`|` `Pstr_class_type of class_type_declaration list`
`|` `Pstr_include of include_declaration`
`|` `Pstr_attribute of attribute`
`|` `Pstr_extension of extension * attributes`

``
`type value_binding``= Ppxlib_ast__.Import.Parsetree.value_binding``=` `{`

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

`}```
`type module_binding``= Ppxlib_ast__.Import.Parsetree.module_binding``=` `{`

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

`}```

### Toplevel

`type toplevel_phrase``= Ppxlib_ast__.Import.Parsetree.toplevel_phrase``=`

`|` `Ptop_def of structure`
`|` `Ptop_dir of string * directive_argument`

``
`type directive_argument``= Ppxlib_ast__.Import.Parsetree.directive_argument``=`

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

``
`class virtual map : object ... end`
`class virtual iter : object ... end`
`class virtual +'b fold : object ... end`
`class virtual +'b fold_map : object ... end`
`class virtual +'b map_with_context : object ... end`
`class virtual +'b lift : object ... end`
`include Std`

- Deprecated [since 2017-01] Use Ppx_core or Ppx_core.Light instead

`module Ast_builder = Ppxlib.Ast_builder`
`module Ast_pattern = Ppxlib.Ast_pattern`
`module Ast_traverse = Ppxlib.Ast_traverse`
`module Attribute = Ppxlib.Attribute`
`module Caller_id = Ppxlib.Caller_id`
`module Context_free = Ppxlib.Context_free`
`module Extension = Ppxlib.Extension`
`module File_path = Ppxlib.File_path`
`module Loc = Ppxlib.Loc`
`module Merlin_helpers = Ppxlib.Merlin_helpers`
`module Reserved_namespaces = Ppxlib.Reserved_namespaces`
`module Spellcheck = Ppxlib.Spellcheck`
`include Ppxlib.Ppxlib_private.Common`
`val lident : Ppxlib__.Import.string ‑> Ppxlib.Longident.t`
`val core_type_of_type_declaration : Ppxlib__.Import.type_declaration ‑> Ppxlib__.Import.core_type`
`val name_type_params_in_td : Ppxlib__.Import.type_declaration ‑> Ppxlib__.Import.type_declaration`
`val combinator_type_of_type_declaration : Ppxlib__.Import.type_declaration ‑> f:(loc:Ppxlib.Location.t ‑> Ppxlib__.Import.core_type ‑> Ppxlib__.Import.core_type) ‑> Ppxlib__.Import.core_type`
`val gen_symbol : ?⁠prefix:Ppxlib__.Import.string ‑> Ppxlib__.Import.unit ‑> Ppxlib__.Import.string`

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

- Parameter prefix: default = "_x"

`val string_of_core_type : Ppxlib__.Import.core_type ‑> Ppxlib__.Import.string`
`val assert_no_attributes : Ppxlib__.Import.attributes ‑> Ppxlib__.Import.unit`
`val assert_no_attributes_in : Ppxlib.Ast_traverse.iter`
`val get_type_param_name : (Ppxlib__.Import.core_type * Ppxlib__.Import.variance) ‑> Ppxlib__.Import.string Ppxlib.Loc.t`

`get_tparam_id tp` returns the string identifier associated with `tp` if it is a type parameter.

`class type_is_recursive : Ppxlib__.Import.rec_flag ‑> Ppxlib__.Import.type_declaration Ppxlib__.Import.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.

`val really_recursive : Ppxlib__.Import.rec_flag ‑> Ppxlib__.Import.type_declaration Ppxlib__.Import.list ‑> Ppxlib__.Import.rec_flag`

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

`val loc_of_payload : Ppxlib__.Import.attribute ‑> Ppxlib.Location.t`
`val loc_of_attribute : Ppxlib__.Import.attribute ‑> Ppxlib.Location.t`
`val curry_applications : Ppxlib__.Import.expression ‑> Ppxlib__.Import.expression`

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

`val attribute_of_warning : Ppxlib.Location.t ‑> Ppxlib__.Import.string ‑> Ppxlib__.Import.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.

We don't include these in `Std` as these are likely to break external code

`module Location = Ppxlib.Location`
`module Longident = Ppxlib.Longident`

The API of these modules won't change when we upgrade the AST defined by ppxlib_ast.

`module Ast_builder_403 = Ast_builder`
`module Ast_pattern_403 = Ast_pattern`