ppx_core v0.10.0 · OCaml Package

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

include module type of struct include Base end

module Arg = Base.Arg

module ArrayLabels = Base.ArrayLabels

module BytesLabels = Base.BytesLabels

module Callback = Base.Callback

module Complex = Base.Complex

module Digest = Base.Digest

module Ephemeron = Base.Ephemeron

module Filename = Base.Filename

module Format = Base.Format

module Gc = Base.Gc

module Genlex = Base.Genlex

module ListLabels = Base.ListLabels

module Marshal = Base.Marshal

module MoreLabels = Base.MoreLabels

module Obj = Base.Obj

module Oo = Base.Oo

module Parsing = Base.Parsing

module Pervasives = Base.Pervasives

module Printexc = Base.Printexc

module Queue = Base.Queue

module Scanf = Base.Scanf

module Sort = Base.Sort

module Spacetime = Base.Spacetime

module Stack = Base.Stack

module StdLabels = Base.StdLabels

module Stream = Base.Stream

module StringLabels = Base.StringLabels

module Weak = Base.Weak

val raise_notrace : exn -> 'a

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.raise_notrace] instead

exception Exit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Refering to the stdlib directly is discouraged by Base. You should either use the equivalent functionality offered by Base, or if you really want to refer to the stdlib, use Caml.Exit instead

val (==) : 'a -> 'a -> bool

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [phys_equal] instead.

val (!=) : 'a -> 'a -> bool

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [not (phys_equal ...)] instead.

val (&) : bool -> bool -> bool

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.( & )] instead

val or : bool -> bool -> bool

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.( or )] instead

val __LOC__ : string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.__LOC__] instead

val __FILE__ : string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.__FILE__] instead

val __LINE__ : int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.__LINE__] instead

val __MODULE__ : string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.__MODULE__] instead

val __POS__ : string * int * int * int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.__POS__] instead

val __LOC_OF__ : 'a -> string * 'a

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.__LOC_OF__] instead

val __LINE_OF__ : 'a -> int * 'a

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.__LINE_OF__] instead

val __POS_OF__ : 'a -> (string * int * int * int) * 'a

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.__POS_OF__] instead

val (~+) : int -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.( ~+ )] instead

val succ : int -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Int.succ] instead.

val pred : int -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Int.pred] instead.

val (mod) : int -> int -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use (%), which has a sligtly different semantics, or Int.rem which is equivalent.

val max_int : int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Int.max_value] instead.

val min_int : int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Int.min_value] instead.

val (~+.) : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.( ~+. )] instead

val (**) : float -> float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [**.] instead.

val sqrt : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.sqrt] instead.

val exp : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.exp] instead.

val log : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.log] instead.

val log10 : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.log10] instead.

val expm1 : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.expm1] instead.

val log1p : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.log1p] instead.

val cos : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.cos] instead.

val sin : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.sin] instead.

val tan : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.tan] instead.

val acos : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.acos] instead.

val asin : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.asin] instead.

val atan : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.atan] instead.

val atan2 : float -> float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.atan2] instead.

val hypot : float -> float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.hypot] instead.

val cosh : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.cosh] instead.

val sinh : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.sinh] instead.

val tanh : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.tanh] instead.

val ceil : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.round_up] instead.

val floor : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.round_down] instead.

val abs_float : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.abs_float] instead

val copysign : float -> float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.copysign] instead.

val mod_float : float -> float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.mod_float] instead.

val frexp : float -> float * int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.frexp] instead.

val ldexp : float -> int -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.ldexp] instead.

val modf : float -> float * float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.modf] instead.

val float : int -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.of_int] instead.

val float_of_int : int -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.of_int] instead.

val truncate : float -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Int.of_float] instead.

val int_of_float : float -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Int.of_float] instead.

val infinity : float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.infinity] instead.

val neg_infinity : float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.neg_infinity] instead.

val nan : float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.nan] instead.

val max_float : float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.max_finite_value] instead.

val min_float : float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.min_positive_normal_value] instead.

val epsilon_float : float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.epsilon_float] instead.

type nonrec fpclass = Pervasives.fpclass =

| FP_normal
| FP_subnormal
| FP_zero
| FP_infinite
| FP_nan

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Refering to the stdlib directly is discouraged by Base. You should either use the equivalent functionality offered by Base, or if you really want to refer to the stdlib, use Caml.fpclass instead

val classify_float : float -> fpclass

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.classify] instead.

val int_of_char : char -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Char.to_int] instead.

val char_of_int : int -> char

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Char.of_int_exn] instead.

val string_of_bool : bool -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Bool.to_string] instead.

val bool_of_string : string -> bool

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Bool.of_string] instead.

val bool_of_string_opt : string -> bool option

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.bool_of_string_opt] instead

val string_of_int : int -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Int.to_string] instead.

val int_of_string : string -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Int.of_string] instead.

val int_of_string_opt : string -> int option

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.int_of_string_opt] instead

val string_of_float : float -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.to_string] instead.

val float_of_string : string -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.of_string] instead.

val float_of_string_opt : string -> float option

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.float_of_string_opt] instead

type nonrec in_channel = Pervasives.in_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.t] instead.

type nonrec out_channel = Pervasives.out_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.t] instead.

val print_char : char -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_char Stdio.stdout] instead.

val print_string : string -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_string Stdio.stdout] instead.

val print_bytes : bytes -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_bytes Stdio.stdout] instead.

val print_int : int -> unit

deprecated

val print_float : float -> unit

deprecated

val print_newline : unit -> unit

deprecated

val prerr_char : char -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_char Stdio.stderr] instead.

val prerr_string : string -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_string Stdio.stderr] instead.

val prerr_bytes : bytes -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_bytes Stdio.stderr] instead.

val prerr_int : int -> unit

deprecated

val prerr_float : float -> unit

deprecated

val prerr_newline : unit -> unit

deprecated

val read_line : unit -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.input_line] instead.

val read_int : unit -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.read_int] instead

val read_int_opt : unit -> int option

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.read_int_opt] instead

val read_float : unit -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.read_float] instead

val read_float_opt : unit -> float option

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.read_float_opt] instead

type nonrec open_flag = Pervasives.open_flag =

| Open_rdonly
| Open_wronly
| Open_append
| Open_creat
| Open_trunc
| Open_excl
| Open_binary
| Open_text
| Open_nonblock

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Refering to the stdlib directly is discouraged by Base. You should either use the equivalent functionality offered by Base, or if you really want to refer to the stdlib, use Caml.open_flag instead

val open_out : string -> out_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.create] instead.

val open_out_bin : string -> out_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.create] instead.

val open_out_gen : open_flag list -> int -> string -> out_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.open_out_gen] instead

val flush : out_channel -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.flush] instead.

val flush_all : unit -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.flush_all] instead

val output_char : out_channel -> char -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_char] instead.

val output_string : out_channel -> string -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_string] instead.

val output_bytes : out_channel -> bytes -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_bytes] instead.

val output : out_channel -> bytes -> int -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output] instead.

val output_substring : out_channel -> string -> int -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output] instead.

val output_byte : out_channel -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_byte] instead.

val output_binary_int : out_channel -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_binary_int] instead.

val output_value : out_channel -> 'a -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_value] instead.

val seek_out : out_channel -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.seek] instead.

val pos_out : out_channel -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.pos] instead.

val out_channel_length : out_channel -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.length] instead.

val close_out : out_channel -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.close] instead.

val close_out_noerr : out_channel -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.close] instead.

val set_binary_mode_out : out_channel -> bool -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.set_binary_mode] instead.

val open_in : string -> in_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.create] instead.

val open_in_bin : string -> in_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.create] instead.

val open_in_gen : open_flag list -> int -> string -> in_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.open_in_gen] instead

val input_char : in_channel -> char

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.input_char] instead.

val input_line : in_channel -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.input_line] instead.

val input : in_channel -> bytes -> int -> int -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.input] instead.

val really_input : in_channel -> bytes -> int -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.really_input] instead.

val really_input_string : in_channel -> int -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is no equivalent functionality in Base or Stdio but you can use [Stdio.Out_channel] instead. Alternatively, if you really want to refer the stdlib function you can use [Caml.really_input_string].

val input_byte : in_channel -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.input_byte] instead.

val input_binary_int : in_channel -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.input_binary_int] instead.

val input_value : in_channel -> 'a

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.unsafe_input_value] instead.

val seek_in : in_channel -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.seek] instead.

val pos_in : in_channel -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.pos] instead.

val in_channel_length : in_channel -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.length] instead.

val close_in : in_channel -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.close] instead.

val close_in_noerr : in_channel -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.close] instead.

val set_binary_mode_in : in_channel -> bool -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.set_binary_mode] instead.

module LargeFile = Base.LargeFile

val incr : int Pervasives.ref -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Int.incr] instead.

val decr : int Pervasives.ref -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Int.decr] instead.

type nonrec (!'a, !'b) result = ('a, 'b) Pervasives.result =

| Ok of 'a
| Error of 'b

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Refering to the stdlib directly is discouraged by Base. You should either use the equivalent functionality offered by Base, or if you really want to refer to the stdlib, use Caml.result instead

val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) Pervasives.format6 -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.string_of_format] instead

val format_of_string : 
  ('a, 'b, 'c, 'd, 'e, 'f) Pervasives.format6 ->
  ('a, 'b, 'c, 'd, 'e, 'f) Pervasives.format6

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.format_of_string] instead

val exit : int -> 'a

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.exit] instead

val at_exit : (unit -> unit) -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.at_exit] instead

val valid_float_lexem : string -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.valid_float_lexem] instead

val unsafe_really_input : in_channel -> bytes -> int -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.unsafe_really_input] instead

val do_at_exit : unit -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.do_at_exit] instead

module Applicative : sig ... end

module Applicative_intf : sig ... end

module Array : sig ... end

module Avltree : sig ... end

module Backtrace : sig ... end

module Binary_search : sig ... end

module Binary_searchable : sig ... end

module Binary_searchable_intf : sig ... end

module Blit : sig ... end

module Blit_intf : sig ... end

module Bool : sig ... end

module Buffer : sig ... end

module Bytes : sig ... end

module Char : sig ... end

module Commutative_group : sig ... end

module Comparable : sig ... end

module Comparable_intf : sig ... end

module Comparator : sig ... end

module Comparisons : sig ... end

module Container : sig ... end

module Container_intf : sig ... end

module Either : sig ... end

module Either_intf : sig ... end

module Equal : sig ... end

module Error : sig ... end

module Exn : sig ... end

module Field : sig ... end

module Float : sig ... end

module Floatable : sig ... end

module Fn : sig ... end

module Hash : sig ... end

module Hash_intf : sig ... end

module Hash_set : sig ... end

module Hash_set_intf : sig ... end

module Hasher : sig ... end

module Hashtbl : sig ... end

module Hashtbl_intf : sig ... end

module Heap_block : sig ... end

module Identifiable : sig ... end

module Indexed_container : sig ... end

module Info : sig ... end

module Info_intf : sig ... end

module Int : sig ... end

module Int32 : sig ... end

module Int63 : sig ... end

module Int64 : sig ... end

module Int_intf : sig ... end

module Intable : sig ... end

module Invariant : sig ... end

module Lazy : sig ... end

module List : sig ... end

module Map : sig ... end

module Map_intf : sig ... end

module Maybe_bound : sig ... end

module Monad : sig ... end

module Nativeint : sig ... end

module Obj_array : sig ... end

module Option : sig ... end

module Or_error : sig ... end

module Ordered_collection_common : sig ... end

module Ordering : sig ... end

module Poly : sig ... end

module Polymorphic_compare : sig ... end

module Popcount : sig ... end

module Pretty_printer : sig ... end

module Printf : sig ... end

module Linked_queue : sig ... end

module Queue_intf : sig ... end

module Random : sig ... end

module Ref : sig ... end

module Result : sig ... end

module Sequence : sig ... end

module Set : sig ... end

module Set_intf : sig ... end

module Sexpable : sig ... end

module Sign : sig ... end

module Source_code_position : sig ... end

module Staged : sig ... end

module String : sig ... end

module Stringable : sig ... end

module String_dict : sig ... end

module Sys : sig ... end

module T : sig ... end

module Type_equal : sig ... end

module Unit : sig ... end

module Uchar : sig ... end

module Validate : sig ... end

module Variant : sig ... end

module With_return : sig ... end

module Word_size : sig ... end

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 Exported_for_specific_uses = Base.Exported_for_specific_uses

module Export = Base.Export

type !'a array = 'a Array.t

val compare_array : ('a -> 'a -> int) -> 'a array -> 'a array -> int

val array_of_sexp : 
  (Base__.Sexplib.Sexp.t -> 'a) ->
  Base__.Sexplib.Sexp.t ->
  'a array

val sexp_of_array : 
  ('a -> Base__.Sexplib.Sexp.t) ->
  'a array ->
  Base__.Sexplib.Sexp.t

type bool = Bool.t

val compare_bool : bool -> bool -> int

val hash_fold_bool : 
  Base__.Ppx_hash_lib.Std.Hash.state ->
  bool ->
  Base__.Ppx_hash_lib.Std.Hash.state

val hash_bool : bool -> Base__.Ppx_hash_lib.Std.Hash.hash_value

val bool_of_sexp : Base__.Sexplib.Sexp.t -> bool

val sexp_of_bool : bool -> Base__.Sexplib.Sexp.t

type char = Char.t

val compare_char : char -> char -> int

val hash_fold_char : 
  Base__.Ppx_hash_lib.Std.Hash.state ->
  char ->
  Base__.Ppx_hash_lib.Std.Hash.state

val hash_char : char -> Base__.Ppx_hash_lib.Std.Hash.hash_value

val char_of_sexp : Base__.Sexplib.Sexp.t -> char

val sexp_of_char : char -> Base__.Sexplib.Sexp.t

type exn = Exn.t

val sexp_of_exn : exn -> Base__.Sexplib.Sexp.t

type float = Float.t

val compare_float : float -> float -> int

val hash_fold_float : 
  Base__.Ppx_hash_lib.Std.Hash.state ->
  float ->
  Base__.Ppx_hash_lib.Std.Hash.state

val hash_float : float -> Base__.Ppx_hash_lib.Std.Hash.hash_value

val float_of_sexp : Base__.Sexplib.Sexp.t -> float

val sexp_of_float : float -> Base__.Sexplib.Sexp.t

type int = Int.t

val compare_int : int -> int -> int

val hash_fold_int : 
  Base__.Ppx_hash_lib.Std.Hash.state ->
  int ->
  Base__.Ppx_hash_lib.Std.Hash.state

val hash_int : int -> Base__.Ppx_hash_lib.Std.Hash.hash_value

val int_of_sexp : Base__.Sexplib.Sexp.t -> int

val sexp_of_int : int -> Base__.Sexplib.Sexp.t

type int32 = Int32.t

val compare_int32 : int32 -> int32 -> int

val hash_fold_int32 : 
  Base__.Ppx_hash_lib.Std.Hash.state ->
  int32 ->
  Base__.Ppx_hash_lib.Std.Hash.state

val hash_int32 : int32 -> Base__.Ppx_hash_lib.Std.Hash.hash_value

val int32_of_sexp : Base__.Sexplib.Sexp.t -> int32

val sexp_of_int32 : int32 -> Base__.Sexplib.Sexp.t

type int64 = Int64.t

val compare_int64 : int64 -> int64 -> int

val hash_fold_int64 : 
  Base__.Ppx_hash_lib.Std.Hash.state ->
  int64 ->
  Base__.Ppx_hash_lib.Std.Hash.state

val hash_int64 : int64 -> Base__.Ppx_hash_lib.Std.Hash.hash_value

val int64_of_sexp : Base__.Sexplib.Sexp.t -> int64

val sexp_of_int64 : int64 -> Base__.Sexplib.Sexp.t

type !'a list = 'a List.t

val compare_list : ('a -> 'a -> int) -> 'a list -> 'a list -> int

val hash_fold_list : 
  (Base__.Ppx_hash_lib.Std.Hash.state ->
    'a ->
    Base__.Ppx_hash_lib.Std.Hash.state) ->
  Base__.Ppx_hash_lib.Std.Hash.state ->
  'a list ->
  Base__.Ppx_hash_lib.Std.Hash.state

val list_of_sexp : 
  (Base__.Sexplib.Sexp.t -> 'a) ->
  Base__.Sexplib.Sexp.t ->
  'a list

val sexp_of_list : 
  ('a -> Base__.Sexplib.Sexp.t) ->
  'a list ->
  Base__.Sexplib.Sexp.t

type nativeint = Nativeint.t

val compare_nativeint : nativeint -> nativeint -> int

val hash_fold_nativeint : 
  Base__.Ppx_hash_lib.Std.Hash.state ->
  nativeint ->
  Base__.Ppx_hash_lib.Std.Hash.state

val hash_nativeint : nativeint -> Base__.Ppx_hash_lib.Std.Hash.hash_value

val nativeint_of_sexp : Base__.Sexplib.Sexp.t -> nativeint

val sexp_of_nativeint : nativeint -> Base__.Sexplib.Sexp.t

type !'a option = 'a Option.t

val compare_option : ('a -> 'a -> int) -> 'a option -> 'a option -> int

val hash_fold_option : 
  (Base__.Ppx_hash_lib.Std.Hash.state ->
    'a ->
    Base__.Ppx_hash_lib.Std.Hash.state) ->
  Base__.Ppx_hash_lib.Std.Hash.state ->
  'a option ->
  Base__.Ppx_hash_lib.Std.Hash.state

val option_of_sexp : 
  (Base__.Sexplib.Sexp.t -> 'a) ->
  Base__.Sexplib.Sexp.t ->
  'a option

val sexp_of_option : 
  ('a -> Base__.Sexplib.Sexp.t) ->
  'a option ->
  Base__.Sexplib.Sexp.t

type !'a ref = 'a Ref.t

val compare_ref : ('a -> 'a -> int) -> 'a ref -> 'a ref -> int

val ref_of_sexp : 
  (Base__.Sexplib.Sexp.t -> 'a) ->
  Base__.Sexplib.Sexp.t ->
  'a ref

val sexp_of_ref : 
  ('a -> Base__.Sexplib.Sexp.t) ->
  'a ref ->
  Base__.Sexplib.Sexp.t

type string = String.t

val compare_string : string -> string -> int

val hash_fold_string : 
  Base__.Ppx_hash_lib.Std.Hash.state ->
  string ->
  Base__.Ppx_hash_lib.Std.Hash.state

val hash_string : string -> Base__.Ppx_hash_lib.Std.Hash.hash_value

val string_of_sexp : Base__.Sexplib.Sexp.t -> string

val sexp_of_string : string -> Base__.Sexplib.Sexp.t

type bytes = Bytes.t

val compare_bytes : bytes -> bytes -> int

val bytes_of_sexp : Base__.Sexplib.Sexp.t -> bytes

val sexp_of_bytes : bytes -> Base__.Sexplib.Sexp.t

type unit = Unit.t

val compare_unit : unit -> unit -> int

val hash_fold_unit : 
  Base__.Ppx_hash_lib.Std.Hash.state ->
  unit ->
  Base__.Ppx_hash_lib.Std.Hash.state

val hash_unit : unit -> Base__.Ppx_hash_lib.Std.Hash.hash_value

val unit_of_sexp : Base__.Sexplib.Sexp.t -> unit

val sexp_of_unit : unit -> Base__.Sexplib.Sexp.t

type nonrec (!'a, !'b, !'c) format = ('a, 'b, 'c) Pervasives.format

type nonrec (!'a, !'b, !'c, !'d) format4 = ('a, 'b, 'c, 'd) Pervasives.format4

type nonrec (!'a, !'b, !'c, !'d, !'e, !'f) format6 =
  ('a, 'b, 'c, 'd, 'e, 'f) Pervasives.format6

type !'a sexp_array = 'a array

type !'a sexp_list = 'a list

type !'a sexp_opaque = 'a

type !'a sexp_option = 'a option

val (@) : 'a Base__List.t -> 'a Base__List.t -> 'a Base__List.t

val (+) : Base__Int.t -> Base__Int.t -> Base__Int.t

val (-) : Base__Int.t -> Base__Int.t -> Base__Int.t

val (*) : Base__Int.t -> Base__Int.t -> Base__Int.t

val (/) : Base__Int.t -> Base__Int.t -> Base__Int.t

val (~-) : Base__Int.t -> Base__Int.t

val abs : Base__Int.t -> Base__Int.t

val neg : Base__Int.t -> Base__Int.t

val zero : Base__Int.t

val (%) : Base__Int.t -> Base__Int.t -> Base__Int.t

val (/%) : Base__Int.t -> Base__Int.t -> Base__Int.t

val (//) : Base__Int.t -> Base__Int.t -> float

val (land) : Base__Int.t -> Base__Int.t -> Base__Int.t

val (lor) : Base__Int.t -> Base__Int.t -> Base__Int.t

val (lxor) : Base__Int.t -> Base__Int.t -> Base__Int.t

val lnot : Base__Int.t -> Base__Int.t

val (lsl) : Base__Int.t -> int -> Base__Int.t

val (asr) : Base__Int.t -> int -> Base__Int.t

val (lsr) : Base__Int.t -> int -> Base__Int.t

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

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

val (|>) : 'a -> ('a -> 'b) -> 'b

val (@@) : ('a -> 'b) -> 'a -> 'b

val (&&) : bool -> bool -> bool

val (||) : bool -> bool -> bool

val not : bool -> bool

val ignore : 'a -> unit

val (^) : String.t -> String.t -> String.t

val (!) : 'a ref -> 'a

val ref : 'a -> 'a ref

val (:=) : 'a ref -> 'a -> unit

val fst : ('a * 'b) -> 'a

val snd : ('a * 'b) -> 'b

val failwith : string -> 'a

val invalid_arg : string -> 'a

val raise : exn -> 'a

val raise_s : Base__.Sexp.t -> 'a

val phys_equal : 'a -> 'a -> bool

val force : 'a Lazy.t -> 'a

module Continue_or_stop : sig ... end

module Finished_or_stopped_early : sig ... end

module Not_exposed_properly = Base.Not_exposed_properly

include module type of struct include Stdio end

module In_channel : sig ... end

module Out_channel : sig ... end

val stdin : In_channel.t

val stdout : Out_channel.t

val stderr : Out_channel.t

val printf : ('a, Out_channel.t, unit) Pervasives.format -> 'a

val eprintf : ('a, Out_channel.t, unit) Pervasives.format -> 'a

val print_endline : string -> unit

val prerr_endline : string -> unit

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

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 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 = Ocaml_shadow.Afl_instrument

module Alias_analysis = Ocaml_shadow.Alias_analysis

module Allocated_const = Ocaml_shadow.Allocated_const

module Annot = Ocaml_shadow.Annot

module Arch = Ocaml_shadow.Arch

module Arg_helper = Ocaml_shadow.Arg_helper

module Asmgen = Ocaml_shadow.Asmgen

module Asmlibrarian = Ocaml_shadow.Asmlibrarian

module Asmlink = Ocaml_shadow.Asmlink

module Asmpackager = Ocaml_shadow.Asmpackager

module Ast_invariants = Ocaml_shadow.Ast_invariants

module Ast_iterator = Ocaml_shadow.Ast_iterator

module Ast_mapper = Ocaml_shadow.Ast_mapper

module Attr_helper = Ocaml_shadow.Attr_helper

module Augment_specialised_args = Ocaml_shadow.Augment_specialised_args

module Backend_intf = Ocaml_shadow.Backend_intf

module Branch_relaxation = Ocaml_shadow.Branch_relaxation

module Branch_relaxation_intf = Ocaml_shadow.Branch_relaxation_intf

module Btype = Ocaml_shadow.Btype

module Build_export_info = Ocaml_shadow.Build_export_info

module Builtin_attributes = Ocaml_shadow.Builtin_attributes

module Bytegen = Ocaml_shadow.Bytegen

module Bytelibrarian = Ocaml_shadow.Bytelibrarian

module Bytelink = Ocaml_shadow.Bytelink

module Bytepackager = Ocaml_shadow.Bytepackager

module Bytesections = Ocaml_shadow.Bytesections

module CSE = Ocaml_shadow.CSE

module CSEgen = Ocaml_shadow.CSEgen

module Ccomp = Ocaml_shadow.Ccomp

module Clambda = Ocaml_shadow.Clambda

module Clflags = Ocaml_shadow.Clflags

module Closure = Ocaml_shadow.Closure

module Closure_conversion = Ocaml_shadow.Closure_conversion

module Closure_conversion_aux = Ocaml_shadow.Closure_conversion_aux

module Closure_element = Ocaml_shadow.Closure_element

module Closure_id = Ocaml_shadow.Closure_id

module Closure_offsets = Ocaml_shadow.Closure_offsets

module Cmi_format = Ocaml_shadow.Cmi_format

module Cmm = Ocaml_shadow.Cmm

module Cmmgen = Ocaml_shadow.Cmmgen

module Cmo_format = Ocaml_shadow.Cmo_format

module Cmt_format = Ocaml_shadow.Cmt_format

module Cmx_format = Ocaml_shadow.Cmx_format

module Coloring = Ocaml_shadow.Coloring

module Comballoc = Ocaml_shadow.Comballoc

module Compdynlink = Ocaml_shadow.Compdynlink

module Compenv = Ocaml_shadow.Compenv

module Compilation_unit = Ocaml_shadow.Compilation_unit

module Compile = Ocaml_shadow.Compile

module Compilenv = Ocaml_shadow.Compilenv

module Compmisc = Ocaml_shadow.Compmisc

module Compplugin = Ocaml_shadow.Compplugin

module Config = Ocaml_shadow.Config

module Consistbl = Ocaml_shadow.Consistbl

module Ctype = Ocaml_shadow.Ctype

module Datarepr = Ocaml_shadow.Datarepr

module Deadcode = Ocaml_shadow.Deadcode

module Debuginfo = Ocaml_shadow.Debuginfo

module Depend = Ocaml_shadow.Depend

module Dll = Ocaml_shadow.Dll

module Effect_analysis = Ocaml_shadow.Effect_analysis

module Emit = Ocaml_shadow.Emit

module Emitaux = Ocaml_shadow.Emitaux

module Emitcode = Ocaml_shadow.Emitcode

module Env = Ocaml_shadow.Env

module Envaux = Ocaml_shadow.Envaux

module Errors = Ocaml_shadow.Errors

module Export_id = Ocaml_shadow.Export_id

module Export_info = Ocaml_shadow.Export_info

module Export_info_for_pack = Ocaml_shadow.Export_info_for_pack

module Expunge = Ocaml_shadow.Expunge

module Extract_projections = Ocaml_shadow.Extract_projections

module Find_recursive_functions = Ocaml_shadow.Find_recursive_functions

module Flambda = Ocaml_shadow.Flambda

module Flambda_invariants = Ocaml_shadow.Flambda_invariants

module Flambda_iterators = Ocaml_shadow.Flambda_iterators

module Flambda_to_clambda = Ocaml_shadow.Flambda_to_clambda

module Flambda_utils = Ocaml_shadow.Flambda_utils

module Freshening = Ocaml_shadow.Freshening

module Genprintval = Ocaml_shadow.Genprintval

module Id_types = Ocaml_shadow.Id_types

module Ident = Ocaml_shadow.Ident

module Import_approx = Ocaml_shadow.Import_approx

module Includeclass = Ocaml_shadow.Includeclass

module Includecore = Ocaml_shadow.Includecore

module Includemod = Ocaml_shadow.Includemod

module Inconstant_idents = Ocaml_shadow.Inconstant_idents

module Initialize_symbol_to_let_symbol =
  Ocaml_shadow.Initialize_symbol_to_let_symbol

module Inline_and_simplify = Ocaml_shadow.Inline_and_simplify

module Inline_and_simplify_aux = Ocaml_shadow.Inline_and_simplify_aux

module Inlining_cost = Ocaml_shadow.Inlining_cost

module Inlining_decision = Ocaml_shadow.Inlining_decision

module Inlining_decision_intf = Ocaml_shadow.Inlining_decision_intf

module Inlining_stats = Ocaml_shadow.Inlining_stats

module Inlining_stats_types = Ocaml_shadow.Inlining_stats_types

module Inlining_transforms = Ocaml_shadow.Inlining_transforms

module Instruct = Ocaml_shadow.Instruct

module Interf = Ocaml_shadow.Interf

module Interval = Ocaml_shadow.Interval

module Invariant_params = Ocaml_shadow.Invariant_params

module Lambda = Ocaml_shadow.Lambda

module Lift_code = Ocaml_shadow.Lift_code

module Lift_constants = Ocaml_shadow.Lift_constants

module Lift_let_to_initialize_symbol =
  Ocaml_shadow.Lift_let_to_initialize_symbol

module Linearize = Ocaml_shadow.Linearize

module Linkage_name = Ocaml_shadow.Linkage_name

module Linscan = Ocaml_shadow.Linscan

module Liveness = Ocaml_shadow.Liveness

module Mach = Ocaml_shadow.Mach

module Main = Ocaml_shadow.Main

module Main_args = Ocaml_shadow.Main_args

module Makedepend = Ocaml_shadow.Makedepend

module Matching = Ocaml_shadow.Matching

module Meta = Ocaml_shadow.Meta

module Middle_end = Ocaml_shadow.Middle_end

module Misc = Ocaml_shadow.Misc

module Mtype = Ocaml_shadow.Mtype

module Mutable_variable = Ocaml_shadow.Mutable_variable

module Numbers = Ocaml_shadow.Numbers

module Opcodes = Ocaml_shadow.Opcodes

module Oprint = Ocaml_shadow.Oprint

module Optcompile = Ocaml_shadow.Optcompile

module Opterrors = Ocaml_shadow.Opterrors

module Optmain = Ocaml_shadow.Optmain

module Outcometree = Ocaml_shadow.Outcometree

module Parameter = Ocaml_shadow.Parameter

module Parmatch = Ocaml_shadow.Parmatch

module Pass_wrapper = Ocaml_shadow.Pass_wrapper

module Path = Ocaml_shadow.Path

module Pparse = Ocaml_shadow.Pparse

module Predef = Ocaml_shadow.Predef

module Primitive = Ocaml_shadow.Primitive

module Printast = Ocaml_shadow.Printast

module Printclambda = Ocaml_shadow.Printclambda

module Printcmm = Ocaml_shadow.Printcmm

module Printinstr = Ocaml_shadow.Printinstr

module Printlambda = Ocaml_shadow.Printlambda

module Printlinear = Ocaml_shadow.Printlinear

module Printmach = Ocaml_shadow.Printmach

module Printtyp = Ocaml_shadow.Printtyp

module Printtyped = Ocaml_shadow.Printtyped

module Proc = Ocaml_shadow.Proc

module Profile = Ocaml_shadow.Profile

module Projection = Ocaml_shadow.Projection

module Ref_to_variables = Ocaml_shadow.Ref_to_variables

module Reg = Ocaml_shadow.Reg

module Reload = Ocaml_shadow.Reload

module Reloadgen = Ocaml_shadow.Reloadgen

module Remove_free_vars_equal_to_args =
  Ocaml_shadow.Remove_free_vars_equal_to_args

module Remove_unused_arguments = Ocaml_shadow.Remove_unused_arguments

module Remove_unused_closure_vars = Ocaml_shadow.Remove_unused_closure_vars

module Remove_unused_program_constructs =
  Ocaml_shadow.Remove_unused_program_constructs

module Runtimedef = Ocaml_shadow.Runtimedef

module Schedgen = Ocaml_shadow.Schedgen

module Scheduling = Ocaml_shadow.Scheduling

module Selectgen = Ocaml_shadow.Selectgen

module Selection = Ocaml_shadow.Selection

module Semantics_of_primitives = Ocaml_shadow.Semantics_of_primitives

module Set_of_closures_id = Ocaml_shadow.Set_of_closures_id

module Set_of_closures_origin = Ocaml_shadow.Set_of_closures_origin

module Share_constants = Ocaml_shadow.Share_constants

module Simple_value_approx = Ocaml_shadow.Simple_value_approx

module Simplif = Ocaml_shadow.Simplif

module Simplify_boxed_integer_ops = Ocaml_shadow.Simplify_boxed_integer_ops

module Simplify_boxed_integer_ops_intf =
  Ocaml_shadow.Simplify_boxed_integer_ops_intf

module Simplify_common = Ocaml_shadow.Simplify_common

module Simplify_primitives = Ocaml_shadow.Simplify_primitives

module Spacetime_profiling = Ocaml_shadow.Spacetime_profiling

module Spill = Ocaml_shadow.Spill

module Split = Ocaml_shadow.Split

module Static_exception = Ocaml_shadow.Static_exception

module Strmatch = Ocaml_shadow.Strmatch

module Strongly_connected_components =
  Ocaml_shadow.Strongly_connected_components

module Stypes = Ocaml_shadow.Stypes

module Subst = Ocaml_shadow.Subst

module Switch = Ocaml_shadow.Switch

module Symbol = Ocaml_shadow.Symbol

module Symtable = Ocaml_shadow.Symtable

module Tag = Ocaml_shadow.Tag

module Targetint = Ocaml_shadow.Targetint

module Tast_mapper = Ocaml_shadow.Tast_mapper

module Tbl = Ocaml_shadow.Tbl

module Terminfo = Ocaml_shadow.Terminfo

module Topdirs = Ocaml_shadow.Topdirs

module Toploop = Ocaml_shadow.Toploop

module Topmain = Ocaml_shadow.Topmain

module Topstart = Ocaml_shadow.Topstart

module Trace = Ocaml_shadow.Trace

module Translattribute = Ocaml_shadow.Translattribute

module Translclass = Ocaml_shadow.Translclass

module Translcore = Ocaml_shadow.Translcore

module Translmod = Ocaml_shadow.Translmod

module Translobj = Ocaml_shadow.Translobj

module Typeclass = Ocaml_shadow.Typeclass

module Typecore = Ocaml_shadow.Typecore

module Typedecl = Ocaml_shadow.Typedecl

module Typedtree = Ocaml_shadow.Typedtree

module TypedtreeIter = Ocaml_shadow.TypedtreeIter

module TypedtreeMap = Ocaml_shadow.TypedtreeMap

module Typemod = Ocaml_shadow.Typemod

module Typeopt = Ocaml_shadow.Typeopt

module Types = Ocaml_shadow.Types

module Typetexp = Ocaml_shadow.Typetexp

module Un_anf = Ocaml_shadow.Un_anf

module Unbox_closures = Ocaml_shadow.Unbox_closures

module Unbox_free_vars_of_closures = Ocaml_shadow.Unbox_free_vars_of_closures

module Unbox_specialised_args = Ocaml_shadow.Unbox_specialised_args

module Untypeast = Ocaml_shadow.Untypeast

module Var_within_closure = Ocaml_shadow.Var_within_closure

module Variable = Ocaml_shadow.Variable

module Warnings = Ocaml_shadow.Warnings

module X86_ast = Ocaml_shadow.X86_ast

module X86_dsl = Ocaml_shadow.X86_dsl

module X86_gas = Ocaml_shadow.X86_gas

module X86_masm = Ocaml_shadow.X86_masm

module X86_proc = Ocaml_shadow.X86_proc

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 module type of struct include Light end

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

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

include module type of struct include Ppx_ast end

module Ast = Light.Ast

module Ast_helper = Light.Ast_helper

module Ast_magic = Light.Ast_magic

module Asttypes = Light.Asttypes

module Docstrings = Light.Docstrings

module Extra_warnings = Light.Extra_warnings

module Lexer = Light.Lexer

module Parse = Light.Parse

module Parser = Light.Parser

module Parsetree = Light.Parsetree

module Pprintast = Light.Pprintast

module Select_ast = Light.Select_ast

module Selected_ast = Light.Selected_ast

module Syntaxerr = Light.Syntaxerr

include module type of struct include Ast end

type position = Lexing.position = {

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

}

and location = Warnings.loc = {

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

}

and 'a loc = 'a Location.loc = {

txt : 'a;
loc : location;

}

and longident = Ppx_ast__.Import.Longident.t =

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

and longident_loc = longident loc

and rec_flag = Migrate_parsetree.Ast_404.Asttypes.rec_flag =

| Nonrecursive
| Recursive

and direction_flag = Migrate_parsetree.Ast_404.Asttypes.direction_flag =

| Upto
| Downto

and private_flag = Migrate_parsetree.Ast_404.Asttypes.private_flag =

| Private
| Public

and mutable_flag = Migrate_parsetree.Ast_404.Asttypes.mutable_flag =

| Immutable
| Mutable

and virtual_flag = Migrate_parsetree.Ast_404.Asttypes.virtual_flag =

| Virtual
| Concrete

and override_flag = Migrate_parsetree.Ast_404.Asttypes.override_flag =

| Override
| Fresh

and closed_flag = Migrate_parsetree.Ast_404.Asttypes.closed_flag =

| Closed
| Open

and label = string

and arg_label = Migrate_parsetree.Ast_404.Asttypes.arg_label =

| Nolabel
| Labelled of string
| Optional of string

and variance = Migrate_parsetree.Ast_404.Asttypes.variance =

| Covariant
| Contravariant
| Invariant

Abstract syntax tree produced by parsing

and constant = Migrate_parsetree.Ast_404.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

and attribute = string loc * payload

and extension = string loc * payload

and attributes = attribute list

and payload = Migrate_parsetree.Ast_404.Parsetree.payload =

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

Core language

and core_type = Migrate_parsetree.Ast_404.Parsetree.core_type = {

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

}

and core_type_desc = Migrate_parsetree.Ast_404.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 * 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 list * core_type
| Ptyp_package of package_type
| Ptyp_extension of extension

and package_type = longident_loc * (longident_loc * core_type) list

and row_field = Migrate_parsetree.Ast_404.Parsetree.row_field =

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

and pattern = Migrate_parsetree.Ast_404.Parsetree.pattern = {

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

}

and pattern_desc = Migrate_parsetree.Ast_404.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

and expression = Migrate_parsetree.Ast_404.Parsetree.expression = {

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

}

and expression_desc = Migrate_parsetree.Ast_404.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
| 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 * expression
| Pexp_pack of module_expr
| Pexp_open of override_flag * longident_loc * expression
| Pexp_extension of extension
| Pexp_unreachable

and case = Migrate_parsetree.Ast_404.Parsetree.case = {

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

}

and value_description = Migrate_parsetree.Ast_404.Parsetree.value_description = {

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

}

and type_declaration = Migrate_parsetree.Ast_404.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;

}

and type_kind = Migrate_parsetree.Ast_404.Parsetree.type_kind =

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

and label_declaration = Migrate_parsetree.Ast_404.Parsetree.label_declaration = {

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

}

and constructor_declaration =
  Migrate_parsetree.Ast_404.Parsetree.constructor_declaration =
  {

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

}

and constructor_arguments =
  Migrate_parsetree.Ast_404.Parsetree.constructor_arguments =

| Pcstr_tuple of core_type list
| Pcstr_record of label_declaration list

and type_extension = Migrate_parsetree.Ast_404.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;

}

and extension_constructor =
  Migrate_parsetree.Ast_404.Parsetree.extension_constructor =
  {

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

}

and extension_constructor_kind =
  Migrate_parsetree.Ast_404.Parsetree.extension_constructor_kind =

| Pext_decl of constructor_arguments * core_type option
| Pext_rebind of longident_loc

Class language

and class_type = Migrate_parsetree.Ast_404.Parsetree.class_type = {

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

}

and class_type_desc = Migrate_parsetree.Ast_404.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

and class_signature = Migrate_parsetree.Ast_404.Parsetree.class_signature = {

pcsig_self : core_type;
pcsig_fields : class_type_field list;

}

and class_type_field = Migrate_parsetree.Ast_404.Parsetree.class_type_field = {

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

}

and class_type_field_desc =
  Migrate_parsetree.Ast_404.Parsetree.class_type_field_desc =

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

and 'a class_infos = 'a Migrate_parsetree.Ast_404.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;

}

and class_description = class_type class_infos

and class_type_declaration = class_type class_infos

and class_expr = Migrate_parsetree.Ast_404.Parsetree.class_expr = {

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

}

and class_expr_desc = Migrate_parsetree.Ast_404.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

and class_structure = Migrate_parsetree.Ast_404.Parsetree.class_structure = {

pcstr_self : pattern;
pcstr_fields : class_field list;

}

and class_field = Migrate_parsetree.Ast_404.Parsetree.class_field = {

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

}

and class_field_desc = Migrate_parsetree.Ast_404.Parsetree.class_field_desc =

| Pcf_inherit of override_flag * class_expr * string 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

and class_field_kind = Migrate_parsetree.Ast_404.Parsetree.class_field_kind =

| Cfk_virtual of core_type
| Cfk_concrete of override_flag * expression

and class_declaration = class_expr class_infos

Module language

and module_type = Migrate_parsetree.Ast_404.Parsetree.module_type = {

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

}

and module_type_desc = Migrate_parsetree.Ast_404.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

and signature = signature_item list

and signature_item = Migrate_parsetree.Ast_404.Parsetree.signature_item = {

psig_desc : signature_item_desc;
psig_loc : location;

}

and signature_item_desc =
  Migrate_parsetree.Ast_404.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

and module_declaration = Migrate_parsetree.Ast_404.Parsetree.module_declaration =
  {

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

}

and module_type_declaration =
  Migrate_parsetree.Ast_404.Parsetree.module_type_declaration =
  {

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

}

and open_description = Migrate_parsetree.Ast_404.Parsetree.open_description = {

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

}

and 'a include_infos = 'a Migrate_parsetree.Ast_404.Parsetree.include_infos = {

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

}

and include_description = module_type include_infos

and include_declaration = module_expr include_infos

and with_constraint = Migrate_parsetree.Ast_404.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

and module_expr = Migrate_parsetree.Ast_404.Parsetree.module_expr = {

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

}

and module_expr_desc = Migrate_parsetree.Ast_404.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

and structure = structure_item list

and structure_item = Migrate_parsetree.Ast_404.Parsetree.structure_item = {

pstr_desc : structure_item_desc;
pstr_loc : location;

}

and structure_item_desc =
  Migrate_parsetree.Ast_404.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

and value_binding = Migrate_parsetree.Ast_404.Parsetree.value_binding = {

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

}

and module_binding = Migrate_parsetree.Ast_404.Parsetree.module_binding = {

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

}

Toplevel

and toplevel_phrase = Migrate_parsetree.Ast_404.Parsetree.toplevel_phrase =

| Ptop_def of structure
| Ptop_dir of string * directive_argument

and directive_argument = Migrate_parsetree.Ast_404.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 module type of struct include Std end

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

module Ast_builder : sig ... end

Helpers for build OCaml AST fragments

module Ast_pattern : sig ... end

First class AST patterns

module Ast_traverse : sig ... end

AST traversal classes

module Attribute : sig ... end

Attribute hygiene

module Caller_id : sig ... end

module Context_free : sig ... end

Context free rewriting

module Extension : sig ... end

module File_path : sig ... end

Return the path used as root in a file

module Loc : sig ... end

Located items

module Merlin_helpers : sig ... end

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

module Reserved_namespaces = Light.Reserved_namespaces

module Spellcheck : sig ... end

val lident : Ppx_core__.Import.String.t -> Longident.t

val core_type_of_type_declaration : 
  Migrate_parsetree.Ast_404.Parsetree.type_declaration ->
  Migrate_parsetree.Ast_404.Parsetree.core_type

val name_type_params_in_td : 
  Migrate_parsetree.Ast_404.Parsetree.type_declaration ->
  Migrate_parsetree.Ast_404.Parsetree.type_declaration

val combinator_type_of_type_declaration : 
  Migrate_parsetree.Ast_404.Parsetree.type_declaration ->
  f:
    (loc:Location.t ->
      Migrate_parsetree.Ast_404.Parsetree.core_type ->
      Migrate_parsetree.Ast_404.Parsetree.core_type) ->
  Migrate_parsetree.Ast_404.Parsetree.core_type

val gen_symbol : 
  ?prefix:Ppx_core__.Import.String.t ->
  Ppx_core__.Import.Unit.t ->
  Ppx_core__.Import.String.t

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

parameter prefix
default = "_x"

val string_of_core_type : 
  Migrate_parsetree.Ast_404.Parsetree.core_type ->
  Ppx_core__.Import.String.t

val assert_no_attributes : 
  (string Location.loc * Migrate_parsetree.Ast_404.Parsetree.payload) list ->
  Ppx_core__.Import.Unit.t

val assert_no_attributes_in : Ast_traverse.iter

val get_type_param_name : 
  (Migrate_parsetree.Ast_404.Parsetree.core_type
   * Migrate_parsetree.Ast_404.Asttypes.variance) ->
  Ppx_core__.Import.String.t Loc.t

get_tparam_id tp

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

class type_is_recursive : Migrate_parsetree.Ast_404.Asttypes.rec_flag -> Migrate_parsetree.Ast_404.Parsetree.type_declaration
                                                    Ppx_core__.Import.List.t -> 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 : 
  Migrate_parsetree.Ast_404.Asttypes.rec_flag ->
  Migrate_parsetree.Ast_404.Parsetree.type_declaration Ppx_core__.Import.List.t ->
  Migrate_parsetree.Ast_404.Asttypes.rec_flag

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

val loc_of_payload : 
  (string Location.loc * Migrate_parsetree.Ast_404.Parsetree.payload) ->
  Location.t

val loc_of_attribute : 
  (string Location.loc * Migrate_parsetree.Ast_404.Parsetree.payload) ->
  Location.t

val curry_applications : 
  Migrate_parsetree.Ast_404.Parsetree.expression ->
  Migrate_parsetree.Ast_404.Parsetree.expression

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

val attribute_of_warning : 
  Location.t ->
  Ppx_core__.Import.String.t ->
  string Location.loc * Migrate_parsetree.Ast_404.Parsetree.payload

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 : sig ... end

Overrides the Location module of OCaml

module Longident : sig ... end

Overrides the Longident module of OCaml

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

module Ast_builder_403 = Light.Ast_builder_403

module Ast_pattern_403 = Light.Ast_pattern_403

val (^^) : 
  ('a, 'b, 'c, 'd, 'e, 'f) Caml.format6 ->
  ('f, 'b, 'c, 'e, 'g, 'h) Caml.format6 ->
  ('a, 'b, 'c, 'd, 'g, 'h) Caml.format6

package ppx_core

Extension points

Core language

Class language

Module language

Toplevel