Module Ppx_core

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:

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_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
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 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 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 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 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 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 core_type_of_type_declaration : Ppxlib__.Import.type_declaration ‑> 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_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