IStd (infer.IStdlib.IStd)

include module type of struct include Core end

module Applicative : sig ... end

module Arg : sig ... end

module Array : sig ... end

module Avltree : sig ... end

module Backtrace : sig ... end

module Bag : sig ... end

module Bigbuffer : sig ... end

module Bigstring : sig ... end

module Bigsubstring : sig ... end

module Bin_prot : sig ... end

module Binable : sig ... end

module Binary_search : sig ... end

module Binary_searchable : sig ... end

module Blang : sig ... end

module Blit : sig ... end

module Bool : sig ... end

module Bounded_index : sig ... end

module Buffer = Base.Buffer

module Byte_units : sig ... end

module Bytes : sig ... end

module Caml = Core.Caml

module Char : sig ... end

module Command : sig ... end

module Comparable : sig ... end

module Comparator : sig ... end

module Comparisons : sig ... end

module Container : sig ... end

module Container_intf : sig ... end

module Continue_or_stop : sig ... end

module Core_kernel_stable : sig ... end

module Core_stable : sig ... end

module Date : sig ... end

module Day_of_week : sig ... end

module Debug : sig ... end

module Deque : sig ... end

module Deriving_hash : sig ... end

module Digest : sig ... end

module Doubly_linked : sig ... end

module Either : sig ... end

module Ephemeron : sig ... end

module Equal : sig ... end

module Error : sig ... end

module Exn = Base.Exn

module Expect_test_config = Expect_test_config

module Fdeque : sig ... end

module Field : sig ... end

module Float : sig ... end

module Float_with_finite_only_serialization : sig ... end

module Floatable : sig ... end

module Fn : sig ... end

module Formatter : sig ... end

module Fqueue : sig ... end

module Gc : sig ... end

module Hash : sig ... end

module Hash_queue : sig ... end

module Hash_set : sig ... end

module Hashable : sig ... end

module Hashtbl : sig ... end

module Hashtbl_intf : sig ... end

module Heap_block : sig ... end

module Hexdump : sig ... end

module Hexdump_intf : sig ... end

module Host_and_port : sig ... end

module Identifiable : sig ... end

module Immediate_option : sig ... end

module Immediate_option_intf : sig ... end

module In_channel : sig ... end

module Indexed_container : sig ... end

module Info : sig ... end

module Int : sig ... end

module Int32 : sig ... end

module Int63 : sig ... end

module Int64 : sig ... end

module Int_conversions : sig ... end

module Int_intf : sig ... end

module Int_math : sig ... end

module Intable : sig ... end

module Interfaces : sig ... end

module Invariant : sig ... end

module Lazy : sig ... end

module Linked_queue : sig ... end

module List : sig ... end

module Map : sig ... end

module Map_intf : sig ... end

module Maybe_bound : sig ... end

module Md5 : sig ... end

module Memo : sig ... end

module Monad : sig ... end

module Month : sig ... end

module Mutex = Core.Mutex

module Nativeint : sig ... end

module No_polymorphic_compare : sig ... end

module Nothing : sig ... end

module Only_in_test : sig ... end

module Option : sig ... end

module Option_array : sig ... end

module Optional_syntax : sig ... end

module Optional_syntax_intf : sig ... end

module Or_error : sig ... end

module Ordered_collection_common : sig ... end

module Ordering : sig ... end

module Out_channel : sig ... end

module Percent : sig ... end

module Perms : sig ... end

module Pid : sig ... end

module Poly : sig ... end

module Polymorphic_compare = Poly

module Popcount = Base.Popcount

module Pretty_printer : sig ... end

module Printexc : sig ... end

module Printf : sig ... end

module Queue : sig ... end

module Quickcheck : sig ... end

module Quickcheck_intf : sig ... end

module Quickcheckable : sig ... end

module Random = Base.Random

module Ref : sig ... end

module Result : sig ... end

module Robustly_comparable : sig ... end

module Sequence : sig ... end

module Set : sig ... end

module Set_intf : sig ... end

module Set_once : sig ... end

module Sexp_maybe : sig ... end

module Sexp : sig ... end

module Sexpable : sig ... end

module Sign : sig ... end

module Signal : sig ... end

module Sign_or_nan : sig ... end

module Source_code_position : sig ... end

module Splittable_random = Splittable_random

module Stable_comparable : sig ... end

module Stable_unit_test : sig ... end

module Stack : sig ... end

module Staged = Base.Staged

module String : sig ... end

module String_id : sig ... end

module Stringable : sig ... end

module Substring : sig ... end

module Substring_intf : sig ... end

module Thread = Core.Thread

module Time : sig ... end

module Time_ns : sig ... end

module Tuple : sig ... end

module Tuple2 = Tuple.T2

module Tuple3 = Tuple.T3

module Type_equal : sig ... end

module Type_immediacy : sig ... end

module Uchar : sig ... end

module Uniform_array : sig ... end

module Union_find : sig ... end

module Unique_id : sig ... end

module Unit : sig ... end

module Unit_of_time : sig ... end

module Univ_map : sig ... end

module Validate = Validate

module Validated : sig ... end

module Variant : sig ... end

module Weak = Stdlib.Weak

module With_return : sig ... end

module Word_size : sig ... end

module type Unique_id = Core.Unique_id

module type T = Core.T

module type T1 = Core.T1

module type T2 = Core.T2

module type T3 = Core.T3

module type T_bin = Core.T_bin

val raise : exn -> 'a

val raise_notrace : exn -> 'a

exception Exit

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

deprecated [since 2014-10] Use [phys_equal]

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

deprecated [since 2014-10] Use [phys_equal]

val not : bool -> bool

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

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

deprecated [since 2010-01] {!Caml.( && )} should be used instead.

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

val or : bool -> bool -> bool

deprecated [since 2010-01] {!Caml.( || )} should be used instead.

val __LOC__ : string

val __FILE__ : string

val __LINE__ : int

val __MODULE__ : string

val __POS__ : string * int * int * int

val __FUNCTION__ : string

val __LOC_OF__ : 'a -> string * 'a

val __LINE_OF__ : 'a -> int * 'a

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

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

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

val (~-) : int -> int

val (~+) : int -> int

val succ : int -> int

val pred : int -> int

val (+) : int -> int -> int

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

val (*) : int -> int -> int

val (/) : int -> int -> int

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

val abs : int -> int

val max_int : int

deprecated [since 2014-10] Use [Int.max_value]

val min_int : int

deprecated [since 2014-10] Use [Int.min_value]

val (land) : int -> int -> int

val (lor) : int -> int -> int

val (lxor) : int -> int -> int

val lnot : int -> int

val (lsl) : int -> int -> int

val (lsr) : int -> int -> int

val (asr) : int -> int -> int

val (~-.) : float -> float

val (~+.) : float -> float

val (+.) : float -> float -> float

val (-.) : float -> float -> float

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

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

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

val sqrt : float -> float

val exp : float -> float

val log : float -> float

val log10 : float -> float

deprecated [since 2016-07] Use [Float.log10]

val expm1 : float -> float

deprecated [since 2016-07] Use [Float.expm1]

val log1p : float -> float

deprecated [since 2016-07] Use [Float.log1p]

val cos : float -> float

deprecated [since 2016-07] Use [Float.cos]

val sin : float -> float

deprecated [since 2016-07] Use [Float.sin]

val tan : float -> float

deprecated [since 2016-07] Use [Float.tan]

val acos : float -> float

deprecated [since 2016-07] Use [Float.acos]

val asin : float -> float

deprecated [since 2016-07] Use [Float.asin]

val atan : float -> float

deprecated [since 2016-07] Use [Float.atan]

val atan2 : float -> float -> float

deprecated [since 2016-07] Use [Float.atan2]

val hypot : float -> float -> float

deprecated [since 2016-07] Use [Float.hypot]

val cosh : float -> float

deprecated [since 2016-07] Use [Float.cosh]

val sinh : float -> float

deprecated [since 2016-07] Use [Float.sinh]

val tanh : float -> float

deprecated [since 2016-07] Use [Float.tanh]

val ceil : float -> float

deprecated [since 2014-10] Use [Float.round_up]

val floor : float -> float

deprecated [since 2014-10] Use [Float.round_down]

val abs_float : float -> float

deprecated [since 2014-10] Use [Float.abs]

val copysign : float -> float -> float

deprecated [since 2016-07] Use [Float.copysign]

val mod_float : float -> float -> float

deprecated [since 2014-10] Use [Float.mod_float]

val frexp : float -> float * int

deprecated [since 2014-10] Use [Float.frexp]

val ldexp : float -> int -> float

deprecated [since 2014-10] Use [Float.ldexp]

val modf : float -> float * float

deprecated [since 2014-10] Use [Float.modf]

val float : int -> float

val float_of_int : int -> float

val truncate : float -> int

deprecated [since 2014-10] Use [Float.iround_towards_zero_exn]

val int_of_float : float -> int

val infinity : float

deprecated [since 2014-10] Use [Float.infinity]

val neg_infinity : float

deprecated [since 2014-10] Use [Float.neg_infinity]

val nan : float

deprecated [since 2014-10] Use [Float.nan]

val max_float : float

deprecated [since 2014-10] Use [Float.max_value]

val min_float : float

deprecated [since 2014-10] Use [Float.min_value]

val epsilon_float : float

deprecated [since 2014-10] Use [Float.epsilon_float]

type fpclass = Caml.fpclass =

| FP_normal
| FP_subnormal
| FP_zero
| FP_infinite
| FP_nan

val classify_float : float -> fpclass

deprecated [since 2014-10] Use [Float.classify]

val (^) : string -> string -> string

val int_of_char : char -> int

val char_of_int : int -> char

val ignore : 'a -> unit

val string_of_bool : bool -> string

val bool_of_string : string -> bool

val string_of_int : int -> string

val int_of_string : string -> int

val string_of_float : float -> string

val float_of_string : string -> float

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

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

type in_channel = Caml.in_channel

deprecated [since 2016-04] Use [In_channel.t]

type out_channel = Caml.out_channel

deprecated [since 2016-04] Use [Out_channel.t]

val stdin : Caml.in_channel

deprecated [since 2016-04] Use [In_channel.stdin]

val stdout : Caml.out_channel

val stderr : Caml.out_channel

val print_char : char -> unit

deprecated [since 2016-04] Use [Out_channel.output_char stdout]

val print_string : string -> unit

val print_bytes : bytes -> unit

deprecated [since 2016-04] Core doesn't support [bytes] yet.

val print_int : int -> unit

deprecated [since 2016-04] Use [Out_channel.output_string stdout]

val print_float : float -> unit

deprecated [since 2016-04] Use [Out_channel.output_string stdout]

val print_endline : string -> unit

val print_newline : unit -> unit

deprecated [since 2016-04] Use [Out_channel.newline stdout]

val prerr_char : char -> unit

deprecated [since 2016-04] Use [Out_channel.output_char stderr]

val prerr_string : string -> unit

deprecated [since 2016-04] Use [Out_channel.output_string stderr]

val prerr_bytes : bytes -> unit

deprecated [since 2016-04] Core doesn't support [bytes] yet

val prerr_int : int -> unit

deprecated [since 2016-04] Use [Out_channel.output_string stderr]

val prerr_float : float -> unit

deprecated [since 2016-04] Use [Out_channel.output_string stderr]

val prerr_endline : string -> unit

val prerr_newline : unit -> unit

deprecated [since 2016-04] Use [Out_channel.newline stderr]

val read_line : unit -> string

deprecated [since 2016-04] Use [Out_channel.(flush stdout); In_channel.(input_line_exn stdin)]

val read_int : unit -> int

deprecated [since 2016-04] Use [Out_channel.(flush stdout); Int.of_string In_channel.(input_line_exn stdin)]

val read_float : unit -> float

deprecated [since 2016-04] Use [Out_channel.(flush stdout); Float.of_string In_channel.(input_line_exn stdin)]

type open_flag = Caml.open_flag =

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

deprecated [since 2016-04] Use [In_channel.create] and [Out_channel.create]

val open_out : string -> Caml.out_channel

deprecated [since 2016-04] Use [Out_channel.create]

val open_out_bin : string -> Caml.out_channel

deprecated [since 2016-04] Use [Out_channel.create]

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

deprecated [since 2016-04] Use [Out_channel.create]

val flush : Caml.out_channel -> unit

deprecated [since 2016-04] Use [Out_channel.flush]

val flush_all : unit -> unit

deprecated [since 2016-04]

val output_char : Caml.out_channel -> char -> unit

deprecated [since 2016-04] Use [Out_channel.output_char]

val output_string : Caml.out_channel -> string -> unit

deprecated [since 2016-04] Use [Out_channel.output_string]

val output_bytes : Caml.out_channel -> bytes -> unit

deprecated [since 2016-04] Core doesn't yet support bytes.

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

deprecated [since 2016-04] Core doesn't yet support bytes.

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

deprecated [since 2016-04] Use [Out_channel.output]

val output_byte : Caml.out_channel -> int -> unit

deprecated [since 2016-04] Use [Out_channel.output_byte]

val output_binary_int : Caml.out_channel -> int -> unit

deprecated [since 2016-04] Use [Out_channel.output_binary_int]

val output_value : Caml.out_channel -> 'a -> unit

deprecated [since 2016-04] Use [Out_channel.output_value]

val seek_out : Caml.out_channel -> int -> unit

deprecated [since 2014-10] Use [Out_channel.seek]

val pos_out : Caml.out_channel -> int

deprecated [since 2014-10] Use [Out_channel.pos]

val out_channel_length : Caml.out_channel -> int

deprecated [since 2014-10] Use [Out_channel.length]

val close_out : Caml.out_channel -> unit

deprecated [since 2014-10] Use [Out_channel.close]

val close_out_noerr : Caml.out_channel -> unit

deprecated [since 2016-04] Use [Out_channel.close] and catch exceptions

val set_binary_mode_out : Caml.out_channel -> bool -> unit

deprecated [since 2016-04] Use [Out_channel.set_binary_mode]

val open_in : string -> Caml.in_channel

deprecated [since 2016-04] Use [In_channel.create]

val open_in_bin : string -> Caml.in_channel

deprecated [since 2016-04] Use [In_channel.create]

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

deprecated [since 2016-04] Use [In_channel.create]

val input_char : Caml.in_channel -> char

deprecated [since 2016-04] Use [In_channel.input_char]

val input_line : Caml.in_channel -> string

deprecated [since 2016-04] Use [In_channel.input_line]

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

deprecated [since 2016-04] Core doesn't yet support bytes.

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

deprecated [since 2016-04] Core doesn't yet support bytes.

val really_input_string : Caml.in_channel -> int -> string

deprecated [since 2016-04] Use [In_channel.really_input_exn ~pos:0]

val input_byte : Caml.in_channel -> int

deprecated [since 2016-04] Use [In_channel.input_byte]

val input_binary_int : Caml.in_channel -> int

deprecated [since 2016-04] Use [In_channel.input_binary_int]

val input_value : Caml.in_channel -> 'a

deprecated [since 2016-04] Use [In_channel.unsafe_input_value]

val seek_in : Caml.in_channel -> int -> unit

deprecated [since 2014-10] Use [In_channel.seek]

val pos_in : Caml.in_channel -> int

deprecated [since 2014-10] Use [In_channel.pos]

val in_channel_length : Caml.in_channel -> int

deprecated [since 2014-10] Use [In_channel.length]

val close_in : Caml.in_channel -> unit

deprecated [since 2014-10] Use [In_channel.close]

val close_in_noerr : Caml.in_channel -> unit

deprecated [since 2016-04] Use [In_channel.close] and catch exceptions

val set_binary_mode_in : Caml.in_channel -> bool -> unit

deprecated [since 2016-04] Use [In_channel.set_binary_mode]

module LargeFile : sig ... end

type !'a ref = 'a Caml.ref = {

mutable contents : 'a;

}

val ref : 'a -> 'a ref

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

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

val incr : int ref -> unit

val decr : int ref -> unit

type (!'a, !'b) result = ('a, 'b) Caml.result =

| Ok of 'a
| Error of 'b

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

type (!'a, !'b, !'c, !'d) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6

type (!'a, !'b, !'c) format = ('a, 'b, 'c, 'c) format4

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

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

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

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

val valid_float_lexem : string -> string

deprecated [since 2015-11] Do not use.

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

deprecated [since 2015-11] Do not use.

val do_at_exit : unit -> unit

deprecated [since 2015-11] Do not use.

val (>=) : Core__Int.t -> Core__Int.t -> bool

val (<=) : Core__Int.t -> Core__Int.t -> bool

val (>) : Core__Int.t -> Core__Int.t -> bool

val (<) : Core__Int.t -> Core__Int.t -> bool

val (<>) : Core__Int.t -> Core__Int.t -> bool

val min : Core__Int.t -> Core__Int.t -> Core__Int.t

val max : Core__Int.t -> Core__Int.t -> Core__Int.t

val quickcheck_generator_unit : Base.unit Base_quickcheck__.Generator.t

val quickcheck_generator_bool : Base.bool Base_quickcheck__.Generator.t

val quickcheck_generator_char : Base.char Base_quickcheck__.Generator.t

val quickcheck_generator_string : Base.string Base_quickcheck__.Generator.t

val quickcheck_generator_bytes : Base.bytes Base_quickcheck__.Generator.t

val quickcheck_generator_int : Base.int Base_quickcheck__.Generator.t

val quickcheck_generator_int32 : Base.int32 Base_quickcheck__.Generator.t

val quickcheck_generator_int64 : Base.int64 Base_quickcheck__.Generator.t

val quickcheck_generator_nativeint : 
  Base.nativeint Base_quickcheck__.Generator.t

val quickcheck_generator_float : Base.float Base_quickcheck__.Generator.t

val quickcheck_observer_unit : Base.unit Base_quickcheck__.Observer.t

val quickcheck_observer_bool : Base.bool Base_quickcheck__.Observer.t

val quickcheck_observer_char : Base.char Base_quickcheck__.Observer.t

val quickcheck_observer_string : Base.string Base_quickcheck__.Observer.t

val quickcheck_observer_bytes : Base.bytes Base_quickcheck__.Observer.t

val quickcheck_observer_int : Base.int Base_quickcheck__.Observer.t

val quickcheck_observer_int32 : Base.int32 Base_quickcheck__.Observer.t

val quickcheck_observer_int64 : Base.int64 Base_quickcheck__.Observer.t

val quickcheck_observer_nativeint : Base.nativeint Base_quickcheck__.Observer.t

val quickcheck_observer_float : Base.float Base_quickcheck__.Observer.t

val quickcheck_shrinker_unit : Base.unit Base_quickcheck__.Shrinker.t

val quickcheck_shrinker_bool : Base.bool Base_quickcheck__.Shrinker.t

val quickcheck_shrinker_char : Base.char Base_quickcheck__.Shrinker.t

val quickcheck_shrinker_string : Base.string Base_quickcheck__.Shrinker.t

val quickcheck_shrinker_bytes : Base.bytes Base_quickcheck__.Shrinker.t

val quickcheck_shrinker_int : Base.int Base_quickcheck__.Shrinker.t

val quickcheck_shrinker_int32 : Base.int32 Base_quickcheck__.Shrinker.t

val quickcheck_shrinker_int64 : Base.int64 Base_quickcheck__.Shrinker.t

val quickcheck_shrinker_nativeint : Base.nativeint Base_quickcheck__.Shrinker.t

val quickcheck_shrinker_float : Base.float Base_quickcheck__.Shrinker.t

val quickcheck_generator_option : 
  'a Base_quickcheck__.Generator.t ->
  'a Base.option Base_quickcheck__.Generator.t

val quickcheck_generator_list : 
  'a Base_quickcheck__.Generator.t ->
  'a Base.list Base_quickcheck__.Generator.t

val quickcheck_generator_array : 
  'a Base_quickcheck__.Generator.t ->
  'a Base.array Base_quickcheck__.Generator.t

val quickcheck_generator_ref : 
  'a Base_quickcheck__.Generator.t ->
  'a Base.ref Base_quickcheck__.Generator.t

val quickcheck_generator_lazy_t : 
  'a Base_quickcheck__.Generator.t ->
  'a Base.Lazy.t Base_quickcheck__.Generator.t

val quickcheck_observer_option : 
  'a Base_quickcheck__.Observer.t ->
  'a Base.option Base_quickcheck__.Observer.t

val quickcheck_observer_list : 
  'a Base_quickcheck__.Observer.t ->
  'a Base.list Base_quickcheck__.Observer.t

val quickcheck_observer_array : 
  'a Base_quickcheck__.Observer.t ->
  'a Base.array Base_quickcheck__.Observer.t

val quickcheck_observer_ref : 
  'a Base_quickcheck__.Observer.t ->
  'a Base.ref Base_quickcheck__.Observer.t

val quickcheck_observer_lazy_t : 
  'a Base_quickcheck__.Observer.t ->
  'a Base.Lazy.t Base_quickcheck__.Observer.t

val quickcheck_shrinker_option : 
  'a Base_quickcheck__.Shrinker.t ->
  'a Base.option Base_quickcheck__.Shrinker.t

val quickcheck_shrinker_list : 
  'a Base_quickcheck__.Shrinker.t ->
  'a Base.list Base_quickcheck__.Shrinker.t

val quickcheck_shrinker_array : 
  'a Base_quickcheck__.Shrinker.t ->
  'a Base.array Base_quickcheck__.Shrinker.t

val quickcheck_shrinker_ref : 
  'a Base_quickcheck__.Shrinker.t ->
  'a Base.ref Base_quickcheck__.Shrinker.t

val quickcheck_shrinker_lazy_t : 
  'a Base_quickcheck__.Shrinker.t ->
  'a Base.Lazy.t Base_quickcheck__.Shrinker.t

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

deprecated [since 2016-07] Use [ |> ]

type (!'f, !'s) _either = ('f, 's) Base__Either.t =

| First of 'f
| Second of 's

type bigstring = Sexplib.Conv.bigstring

val sexp_of_bigstring : bigstring -> Sexplib0.Sexp.t

val bigstring_of_sexp : Sexplib0.Sexp.t -> bigstring

type mat = Sexplib.Conv.mat

val sexp_of_mat : mat -> Sexplib0.Sexp.t

val mat_of_sexp : Sexplib0.Sexp.t -> mat

type vec = Sexplib.Conv.vec

val sexp_of_vec : vec -> Sexplib0.Sexp.t

val vec_of_sexp : Sexplib0.Sexp.t -> vec

val sexp_of_opaque : 'a -> Base.Sexp.t

val opaque_of_sexp : Base.Sexp.t -> 'a

val sexp_of_pair : 
  ('a -> Base.Sexp.t) ->
  ('b -> Base.Sexp.t) ->
  ('a * 'b) ->
  Base.Sexp.t

val pair_of_sexp : 
  (Base.Sexp.t -> 'a) ->
  (Base.Sexp.t -> 'b) ->
  Base.Sexp.t ->
  'a * 'b

exception Of_sexp_error of Core__Import.exn * Base.Sexp.t

val of_sexp_error : Core__Import.string -> Base.Sexp.t -> 'a

val of_sexp_error_exn : Core__Import.exn -> Base.Sexp.t -> 'a

module type Applicative = Core.Applicative

module type Binable = Core.Binable

module type Comparable = Core.Comparable

module type Comparable_binable = Core.Comparable_binable

module type Floatable = Core.Floatable

module type Hashable = Core.Hashable

module type Hashable_binable = Core.Hashable_binable

module type Identifiable = Core.Identifiable

module type Infix_comparators = Core.Infix_comparators

module type Intable = Core.Intable

module type Monad = Core.Monad

module type Quickcheckable = Core.Quickcheckable

module type Robustly_comparable = Core.Robustly_comparable

module type Sexpable = Core.Sexpable

module type Stable = Core.Stable

module type Stable_int63able = Core.Stable_int63able

module type Stable_without_comparator = Core.Stable_without_comparator

module type Stable1 = Core.Stable1

module type Stable2 = Core.Stable2

module type Stable3 = Core.Stable3

module type Stable4 = Core.Stable4

module type Stringable = Core.Stringable

module type Unit = Core.Unit

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

type never_returns = Core__.Nothing.t

val sexp_of_never_returns : never_returns -> Sexplib0.Sexp.t

val never_returns : never_returns -> 'a

type _ordering = Core__Ordering.t =

| Less
| Equal
| Greater

type read = Core__Perms.Read.t

val bin_shape_read : Bin_prot.Shape.t

val bin_size_read : read Bin_prot.Size.sizer

val bin_write_read : read Bin_prot.Write.writer

val bin_writer_read : read Bin_prot.Type_class.writer

val bin_read_read : read Bin_prot.Read.reader

val __bin_read_read__ : (Core__.Import.int -> read) Bin_prot.Read.reader

val bin_reader_read : read Bin_prot.Type_class.reader

val bin_read : read Bin_prot.Type_class.t

val compare_read : read -> read -> Core__.Import.int

val hash_fold_read : 
  Ppx_hash_lib.Std.Hash.state ->
  read ->
  Ppx_hash_lib.Std.Hash.state

val hash_read : read -> Ppx_hash_lib.Std.Hash.hash_value

val sexp_of_read : read -> Sexplib0.Sexp.t

val read_of_sexp : Sexplib0.Sexp.t -> read

type write = Core__Perms.Write.t

val compare_write : write -> write -> Core__.Import.int

val hash_fold_write : 
  Ppx_hash_lib.Std.Hash.state ->
  write ->
  Ppx_hash_lib.Std.Hash.state

val hash_write : write -> Ppx_hash_lib.Std.Hash.hash_value

val sexp_of_write : write -> Sexplib0.Sexp.t

val write_of_sexp : Sexplib0.Sexp.t -> write

type immutable = Core__Perms.Immutable.t

val bin_shape_immutable : Bin_prot.Shape.t

val bin_size_immutable : immutable Bin_prot.Size.sizer

val bin_write_immutable : immutable Bin_prot.Write.writer

val bin_writer_immutable : immutable Bin_prot.Type_class.writer

val bin_read_immutable : immutable Bin_prot.Read.reader

val __bin_read_immutable__ : 
  (Core__.Import.int -> immutable) Bin_prot.Read.reader

val bin_reader_immutable : immutable Bin_prot.Type_class.reader

val bin_immutable : immutable Bin_prot.Type_class.t

val compare_immutable : immutable -> immutable -> Core__.Import.int

val hash_fold_immutable : 
  Ppx_hash_lib.Std.Hash.state ->
  immutable ->
  Ppx_hash_lib.Std.Hash.state

val hash_immutable : immutable -> Ppx_hash_lib.Std.Hash.hash_value

val sexp_of_immutable : immutable -> Sexplib0.Sexp.t

val immutable_of_sexp : Sexplib0.Sexp.t -> immutable

type read_write = Core__Perms.Read_write.t

val bin_shape_read_write : Bin_prot.Shape.t

val bin_size_read_write : read_write Bin_prot.Size.sizer

val bin_write_read_write : read_write Bin_prot.Write.writer

val bin_writer_read_write : read_write Bin_prot.Type_class.writer

val bin_read_read_write : read_write Bin_prot.Read.reader

val __bin_read_read_write__ : 
  (Core__.Import.int -> read_write) Bin_prot.Read.reader

val bin_reader_read_write : read_write Bin_prot.Type_class.reader

val bin_read_write : read_write Bin_prot.Type_class.t

val compare_read_write : read_write -> read_write -> Core__.Import.int

val hash_fold_read_write : 
  Ppx_hash_lib.Std.Hash.state ->
  read_write ->
  Ppx_hash_lib.Std.Hash.state

val hash_read_write : read_write -> Ppx_hash_lib.Std.Hash.hash_value

val sexp_of_read_write : read_write -> Sexplib0.Sexp.t

val read_write_of_sexp : Sexplib0.Sexp.t -> read_write

type !'a perms = 'a Core__Perms.Upper_bound.t

val bin_shape_perms : Bin_prot.Shape.t -> Bin_prot.Shape.t

val bin_size_perms : 'a Bin_prot.Size.sizer -> 'a perms Bin_prot.Size.sizer

val bin_write_perms : 
  'a Bin_prot.Write.writer ->
  'a perms Bin_prot.Write.writer

val bin_writer_perms : 
  'a Bin_prot.Type_class.writer ->
  'a perms Bin_prot.Type_class.writer

val bin_read_perms : 'a Bin_prot.Read.reader -> 'a perms Bin_prot.Read.reader

val __bin_read_perms__ : 
  'a Bin_prot.Read.reader ->
  (Core__.Import.int -> 'a perms) Bin_prot.Read.reader

val bin_reader_perms : 
  'a Bin_prot.Type_class.reader ->
  'a perms Bin_prot.Type_class.reader

val bin_perms : 'a Bin_prot.Type_class.t -> 'a perms Bin_prot.Type_class.t

val compare_perms : 
  ('a -> 'a -> Core__.Import.int) ->
  'a perms ->
  'a perms ->
  Core__.Import.int

val hash_fold_perms : 
  (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state) ->
  Ppx_hash_lib.Std.Hash.state ->
  'a perms ->
  Ppx_hash_lib.Std.Hash.state

val sexp_of_perms : ('a -> Sexplib0.Sexp.t) -> 'a perms -> Sexplib0.Sexp.t

val perms_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a perms

type (!'ok, !'err) _result = ('ok, 'err) Core__Result.t =

| Ok of 'ok
| Error of 'err

val is_ok : ('a, 'b) Core__Result.t -> bool

val is_error : ('a, 'b) Core__Result.t -> bool

type !-'a return = private 'a Core__.Import.With_return.return = {

return : 'b. 'a -> 'b;

}

exception Bug of Core__.Import.string

deprecated [since 2020-03] Don't use [Bug]

exception C_malloc_exn of Core__.Import.int * Core__.Import.int

exception Finally of Core__.Import.Exn.t * Core__.Import.Exn.t

val fst3 : ('a * 'b * 'c) -> 'a

val snd3 : ('a * 'b * 'c) -> 'b

val trd3 : ('a * 'b * 'c) -> 'c

val uw : 'a Core__.Import.option -> 'a

deprecated [since 2018-12] Use [Option.value_exn]

val (%) : Core__.Int.t -> Core__.Int.t -> Core__.Int.t

val (/%) : Core__.Int.t -> Core__.Int.t -> Core__.Int.t

val (//) : Core__.Int.t -> Core__.Int.t -> float

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

val bprintf : 
  Base__.Import0.Caml.Buffer.t ->
  ('a, Base__.Import0.Caml.Buffer.t, unit) Stdlib.format ->
  'a

val const : 'a -> 'b -> 'a

val eprintf : 
  ('a, Stdlib.out_channel, Core__.Import.unit) Core__.Import.format ->
  'a

val error : 
  ?here:Base__.Source_code_position0.t ->
  ?strict:unit ->
  string ->
  'a ->
  ('a -> Base__.Sexp.t) ->
  'b Core__.Or_error.t

val error_s : Base__.Sexp.t -> 'a Core__.Or_error.t

val failwithp : 
  ?strict:Core__.Import.unit ->
  Core__.Source_code_position.t ->
  Core__.Import.string ->
  'a ->
  ('a -> Core__.Sexp.t) ->
  'b

deprecated [since 2020-03] Use [failwiths] instead.

val failwiths : 
  ?strict:Core__.Import.unit ->
  here:Stdlib.Lexing.position ->
  Core__.Import.string ->
  'a ->
  ('a -> Base.Sexp.t) ->
  'b

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

val fprintf : 
  Stdlib.out_channel ->
  ('a, Stdlib.out_channel, Core__.Import.unit) Core__.Import.format ->
  'a

val ident : 'a -> 'a

deprecated [since 2021-08] Use [Fn.id] instead.

val ifprintf : 'a -> ('b, 'a, 'c, unit) Stdlib.format4 -> 'b

val is_none : 'a option -> bool

val is_some : 'a option -> bool

val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) Stdlib.format4 -> 'b

val ok_exn : 'a Core__.Or_error.t -> 'a

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

val phys_same : 'a -> 'b -> bool

val print_s : ?mach:Base.unit -> Base.Sexp.t -> Base.unit

val eprint_s : ?mach:Base.unit -> Base.Sexp.t -> Base.unit

val printf : 
  ('a, Stdlib.out_channel, Core__.Import.unit) Core__.Import.format ->
  'a

val protect : f:(unit -> 'a) -> finally:(unit -> unit) -> 'a

val protectx : f:('a -> 'b) -> 'a -> finally:('a -> unit) -> 'b

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

val round : ?dir:[ `Down | `Nearest | `Up | `Zero ] -> float -> float

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

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

val sprintf : ('a, unit, string) Stdlib.format -> 'a

val stage : 'a -> 'a Core__.Import.Staged.t

val unstage : 'a Core__.Import.Staged.t -> 'a

val with_return : ('a Core__.Import.With_return.return -> 'a) -> 'a

val with_return_option : 
  ('a Core__.Import.With_return.return -> unit) ->
  'a option

module Typerep : sig ... end

val typerep_of_int63 : Base.Int63.t Typerep.t

type tuple0 = Typerep_lib__Std_internal.tuple0

val value_tuple0 : tuple0

val typerep_of_function : 'a Typerep.t -> 'b Typerep.t -> ('a -> 'b) Typerep.t

val typerep_of_tuple0 : tuple0 Typerep.t

val typerep_of_tuple2 : 'a Typerep.t -> 'b Typerep.t -> ('a * 'b) Typerep.t

val typerep_of_tuple3 : 
  'a Typerep.t ->
  'b Typerep.t ->
  'c Typerep.t ->
  ('a * 'b * 'c) Typerep.t

val typerep_of_tuple4 : 
  'a Typerep.t ->
  'b Typerep.t ->
  'c Typerep.t ->
  'd Typerep.t ->
  ('a * 'b * 'c * 'd) Typerep.t

val typerep_of_tuple5 : 
  'a Typerep.t ->
  'b Typerep.t ->
  'c Typerep.t ->
  'd Typerep.t ->
  'e Typerep.t ->
  ('a * 'b * 'c * 'd * 'e) Typerep.t

val typename_of_int63 : Base.Int63.t Typerep_lib.Typename.t

val typename_of_function : 
  'a Typerep_lib.Typename.t ->
  'b Typerep_lib.Typename.t ->
  ('a -> 'b) Typerep_lib.Typename.t

val typename_of_tuple0 : tuple0 Typerep_lib.Typename.t

val typename_of_tuple2 : 
  'a Typerep_lib.Typename.t ->
  'b Typerep_lib.Typename.t ->
  ('a * 'b) Typerep_lib.Typename.t

val typename_of_tuple3 : 
  'a Typerep_lib.Typename.t ->
  'b Typerep_lib.Typename.t ->
  'c Typerep_lib.Typename.t ->
  ('a * 'b * 'c) Typerep_lib.Typename.t

val typename_of_tuple4 : 
  'a Typerep_lib.Typename.t ->
  'b Typerep_lib.Typename.t ->
  'c Typerep_lib.Typename.t ->
  'd Typerep_lib.Typename.t ->
  ('a * 'b * 'c * 'd) Typerep_lib.Typename.t

val typename_of_tuple5 : 
  'a Typerep_lib.Typename.t ->
  'b Typerep_lib.Typename.t ->
  'c Typerep_lib.Typename.t ->
  'd Typerep_lib.Typename.t ->
  'e Typerep_lib.Typename.t ->
  ('a * 'b * 'c * 'd * 'e) Typerep_lib.Typename.t

val bin_shape_array : Bin_prot.Shape.t -> Bin_prot.Shape.t

val bin_size_array : 
  'a Bin_prot.Size.sizer ->
  'a Core__.Import.array Bin_prot.Size.sizer

val bin_write_array : 
  'a Bin_prot.Write.writer ->
  'a Core__.Import.array Bin_prot.Write.writer

val bin_writer_array : 
  'a Bin_prot.Type_class.writer ->
  'a Core__.Import.array Bin_prot.Type_class.writer

val bin_read_array : 
  'a Bin_prot.Read.reader ->
  'a Core__.Import.array Bin_prot.Read.reader

val __bin_read_array__ : 
  'a Bin_prot.Read.reader ->
  (Core__.Import.int -> 'a Core__.Import.array) Bin_prot.Read.reader

val bin_reader_array : 
  'a Bin_prot.Type_class.reader ->
  'a Core__.Import.array Bin_prot.Type_class.reader

val bin_array : 
  'a Bin_prot.Type_class.t ->
  'a Core__.Import.array Bin_prot.Type_class.t

val compare_array : 
  ('a -> 'a -> Core__.Import.int) ->
  'a Core__.Import.array ->
  'a Core__.Import.array ->
  Core__.Import.int

val equal_array : 
  ('a -> 'a -> Core__.Import.bool) ->
  'a Core__.Import.array ->
  'a Core__.Import.array ->
  Core__.Import.bool

val sexp_of_array : 
  ('a -> Sexplib0.Sexp.t) ->
  'a Core__.Import.array ->
  Sexplib0.Sexp.t

val array_of_sexp : 
  (Sexplib0.Sexp.t -> 'a) ->
  Sexplib0.Sexp.t ->
  'a Core__.Import.array

val array_sexp_grammar : 
  'a Sexplib0.Sexp_grammar.t ->
  'a Core__.Import.array Sexplib0.Sexp_grammar.t

val typerep_of_array : 
  'a Typerep_lib.Std.Typerep.t ->
  'a Core__.Import.array Typerep_lib.Std.Typerep.t

val typename_of_array : 
  'a Typerep_lib.Std.Typename.t ->
  'a Core__.Import.array Typerep_lib.Std.Typename.t

val bin_shape_bool : Bin_prot.Shape.t

val bin_size_bool : Core__.Import.bool Bin_prot.Size.sizer

val bin_write_bool : Core__.Import.bool Bin_prot.Write.writer

val bin_writer_bool : Core__.Import.bool Bin_prot.Type_class.writer

val bin_read_bool : Core__.Import.bool Bin_prot.Read.reader

val __bin_read_bool__ : 
  (Core__.Import.int -> Core__.Import.bool) Bin_prot.Read.reader

val bin_reader_bool : Core__.Import.bool Bin_prot.Type_class.reader

val bin_bool : Core__.Import.bool Bin_prot.Type_class.t

val compare_bool : 
  Core__.Import.bool ->
  Core__.Import.bool ->
  Core__.Import.int

val equal_bool : Core__.Import.bool -> Core__.Import.bool -> Core__.Import.bool

val hash_fold_bool : 
  Ppx_hash_lib.Std.Hash.state ->
  Core__.Import.bool ->
  Ppx_hash_lib.Std.Hash.state

val hash_bool : Core__.Import.bool -> Ppx_hash_lib.Std.Hash.hash_value

val sexp_of_bool : Core__.Import.bool -> Sexplib0.Sexp.t

val bool_of_sexp : Sexplib0.Sexp.t -> Core__.Import.bool

val bool_sexp_grammar : Core__.Import.bool Sexplib0.Sexp_grammar.t

val typerep_of_bool : Core__.Import.bool Typerep_lib.Std.Typerep.t

val typename_of_bool : Core__.Import.bool Typerep_lib.Std.Typename.t

val bin_shape_char : Bin_prot.Shape.t

val bin_size_char : Core__.Import.char Bin_prot.Size.sizer

val bin_write_char : Core__.Import.char Bin_prot.Write.writer

val bin_writer_char : Core__.Import.char Bin_prot.Type_class.writer

val bin_read_char : Core__.Import.char Bin_prot.Read.reader

val __bin_read_char__ : 
  (Core__.Import.int -> Core__.Import.char) Bin_prot.Read.reader

val bin_reader_char : Core__.Import.char Bin_prot.Type_class.reader

val bin_char : Core__.Import.char Bin_prot.Type_class.t

val compare_char : 
  Core__.Import.char ->
  Core__.Import.char ->
  Core__.Import.int

val equal_char : Core__.Import.char -> Core__.Import.char -> Core__.Import.bool

val hash_fold_char : 
  Ppx_hash_lib.Std.Hash.state ->
  Core__.Import.char ->
  Ppx_hash_lib.Std.Hash.state

val hash_char : Core__.Import.char -> Ppx_hash_lib.Std.Hash.hash_value

val sexp_of_char : Core__.Import.char -> Sexplib0.Sexp.t

val char_of_sexp : Sexplib0.Sexp.t -> Core__.Import.char

val char_sexp_grammar : Core__.Import.char Sexplib0.Sexp_grammar.t

val typerep_of_char : Core__.Import.char Typerep_lib.Std.Typerep.t

val typename_of_char : Core__.Import.char Typerep_lib.Std.Typename.t

val bin_shape_float : Bin_prot.Shape.t

val bin_size_float : Core__.Import.float Bin_prot.Size.sizer

val bin_write_float : Core__.Import.float Bin_prot.Write.writer

val bin_writer_float : Core__.Import.float Bin_prot.Type_class.writer

val bin_read_float : Core__.Import.float Bin_prot.Read.reader

val __bin_read_float__ : 
  (Core__.Import.int -> Core__.Import.float) Bin_prot.Read.reader

val bin_reader_float : Core__.Import.float Bin_prot.Type_class.reader

val bin_float : Core__.Import.float Bin_prot.Type_class.t

val compare_float : 
  Core__.Import.float ->
  Core__.Import.float ->
  Core__.Import.int

val equal_float : 
  Core__.Import.float ->
  Core__.Import.float ->
  Core__.Import.bool

val hash_fold_float : 
  Ppx_hash_lib.Std.Hash.state ->
  Core__.Import.float ->
  Ppx_hash_lib.Std.Hash.state

val hash_float : Core__.Import.float -> Ppx_hash_lib.Std.Hash.hash_value

val sexp_of_float : Core__.Import.float -> Sexplib0.Sexp.t

val float_of_sexp : Sexplib0.Sexp.t -> Core__.Import.float

val float_sexp_grammar : Core__.Import.float Sexplib0.Sexp_grammar.t

val typerep_of_float : Core__.Import.float Typerep_lib.Std.Typerep.t

val typename_of_float : Core__.Import.float Typerep_lib.Std.Typename.t

val bin_shape_int : Bin_prot.Shape.t

val bin_size_int : Core__.Import.int Bin_prot.Size.sizer

val bin_write_int : Core__.Import.int Bin_prot.Write.writer

val bin_writer_int : Core__.Import.int Bin_prot.Type_class.writer

val bin_read_int : Core__.Import.int Bin_prot.Read.reader

val __bin_read_int__ : 
  (Core__.Import.int -> Core__.Import.int) Bin_prot.Read.reader

val bin_reader_int : Core__.Import.int Bin_prot.Type_class.reader

val bin_int : Core__.Import.int Bin_prot.Type_class.t

val compare_int : Core__.Import.int -> Core__.Import.int -> Core__.Import.int

val equal_int : Core__.Import.int -> Core__.Import.int -> Core__.Import.bool

val hash_fold_int : 
  Ppx_hash_lib.Std.Hash.state ->
  Core__.Import.int ->
  Ppx_hash_lib.Std.Hash.state

val hash_int : Core__.Import.int -> Ppx_hash_lib.Std.Hash.hash_value

val sexp_of_int : Core__.Import.int -> Sexplib0.Sexp.t

val int_of_sexp : Sexplib0.Sexp.t -> Core__.Import.int

val int_sexp_grammar : Core__.Import.int Sexplib0.Sexp_grammar.t

val typerep_of_int : Core__.Import.int Typerep_lib.Std.Typerep.t

val typename_of_int : Core__.Import.int Typerep_lib.Std.Typename.t

val bin_shape_int32 : Bin_prot.Shape.t

val bin_size_int32 : Core__.Import.int32 Bin_prot.Size.sizer

val bin_write_int32 : Core__.Import.int32 Bin_prot.Write.writer

val bin_writer_int32 : Core__.Import.int32 Bin_prot.Type_class.writer

val bin_read_int32 : Core__.Import.int32 Bin_prot.Read.reader

val __bin_read_int32__ : 
  (Core__.Import.int -> Core__.Import.int32) Bin_prot.Read.reader

val bin_reader_int32 : Core__.Import.int32 Bin_prot.Type_class.reader

val bin_int32 : Core__.Import.int32 Bin_prot.Type_class.t

val compare_int32 : 
  Core__.Import.int32 ->
  Core__.Import.int32 ->
  Core__.Import.int

val equal_int32 : 
  Core__.Import.int32 ->
  Core__.Import.int32 ->
  Core__.Import.bool

val hash_fold_int32 : 
  Ppx_hash_lib.Std.Hash.state ->
  Core__.Import.int32 ->
  Ppx_hash_lib.Std.Hash.state

val hash_int32 : Core__.Import.int32 -> Ppx_hash_lib.Std.Hash.hash_value

val sexp_of_int32 : Core__.Import.int32 -> Sexplib0.Sexp.t

val int32_of_sexp : Sexplib0.Sexp.t -> Core__.Import.int32

val int32_sexp_grammar : Core__.Import.int32 Sexplib0.Sexp_grammar.t

val typerep_of_int32 : Core__.Import.int32 Typerep_lib.Std.Typerep.t

val typename_of_int32 : Core__.Import.int32 Typerep_lib.Std.Typename.t

val bin_shape_int64 : Bin_prot.Shape.t

val bin_size_int64 : Core__.Import.int64 Bin_prot.Size.sizer

val bin_write_int64 : Core__.Import.int64 Bin_prot.Write.writer

val bin_writer_int64 : Core__.Import.int64 Bin_prot.Type_class.writer

val bin_read_int64 : Core__.Import.int64 Bin_prot.Read.reader

val __bin_read_int64__ : 
  (Core__.Import.int -> Core__.Import.int64) Bin_prot.Read.reader

val bin_reader_int64 : Core__.Import.int64 Bin_prot.Type_class.reader

val bin_int64 : Core__.Import.int64 Bin_prot.Type_class.t

val compare_int64 : 
  Core__.Import.int64 ->
  Core__.Import.int64 ->
  Core__.Import.int

val equal_int64 : 
  Core__.Import.int64 ->
  Core__.Import.int64 ->
  Core__.Import.bool

val hash_fold_int64 : 
  Ppx_hash_lib.Std.Hash.state ->
  Core__.Import.int64 ->
  Ppx_hash_lib.Std.Hash.state

val hash_int64 : Core__.Import.int64 -> Ppx_hash_lib.Std.Hash.hash_value

val sexp_of_int64 : Core__.Import.int64 -> Sexplib0.Sexp.t

val int64_of_sexp : Sexplib0.Sexp.t -> Core__.Import.int64

val int64_sexp_grammar : Core__.Import.int64 Sexplib0.Sexp_grammar.t

val typerep_of_int64 : Core__.Import.int64 Typerep_lib.Std.Typerep.t

val typename_of_int64 : Core__.Import.int64 Typerep_lib.Std.Typename.t

val bin_shape_lazy_t : Bin_prot.Shape.t -> Bin_prot.Shape.t

val bin_size_lazy_t : 'a Bin_prot.Size.sizer -> 'a lazy_t Bin_prot.Size.sizer

val bin_write_lazy_t : 
  'a Bin_prot.Write.writer ->
  'a lazy_t Bin_prot.Write.writer

val bin_writer_lazy_t : 
  'a Bin_prot.Type_class.writer ->
  'a lazy_t Bin_prot.Type_class.writer

val bin_read_lazy_t : 'a Bin_prot.Read.reader -> 'a lazy_t Bin_prot.Read.reader

val __bin_read_lazy_t__ : 
  'a Bin_prot.Read.reader ->
  (Core__.Import.int -> 'a lazy_t) Bin_prot.Read.reader

val bin_reader_lazy_t : 
  'a Bin_prot.Type_class.reader ->
  'a lazy_t Bin_prot.Type_class.reader

val bin_lazy_t : 'a Bin_prot.Type_class.t -> 'a lazy_t Bin_prot.Type_class.t

val compare_lazy_t : 
  ('a -> 'a -> Core__.Import.int) ->
  'a lazy_t ->
  'a lazy_t ->
  Core__.Import.int

val hash_fold_lazy_t : 
  (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state) ->
  Ppx_hash_lib.Std.Hash.state ->
  'a lazy_t ->
  Ppx_hash_lib.Std.Hash.state

val sexp_of_lazy_t : ('a -> Sexplib0.Sexp.t) -> 'a lazy_t -> Sexplib0.Sexp.t

val lazy_t_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a lazy_t

val lazy_t_sexp_grammar : 
  'a Sexplib0.Sexp_grammar.t ->
  'a lazy_t Sexplib0.Sexp_grammar.t

val typerep_of_lazy_t : 
  'a Typerep_lib.Std.Typerep.t ->
  'a lazy_t Typerep_lib.Std.Typerep.t

val typename_of_lazy_t : 
  'a Typerep_lib.Std.Typename.t ->
  'a lazy_t Typerep_lib.Std.Typename.t

val bin_shape_list : Bin_prot.Shape.t -> Bin_prot.Shape.t

val bin_size_list : 
  'a Bin_prot.Size.sizer ->
  'a Core__.Import.list Bin_prot.Size.sizer

val bin_write_list : 
  'a Bin_prot.Write.writer ->
  'a Core__.Import.list Bin_prot.Write.writer

val bin_writer_list : 
  'a Bin_prot.Type_class.writer ->
  'a Core__.Import.list Bin_prot.Type_class.writer

val bin_read_list : 
  'a Bin_prot.Read.reader ->
  'a Core__.Import.list Bin_prot.Read.reader

val __bin_read_list__ : 
  'a Bin_prot.Read.reader ->
  (Core__.Import.int -> 'a Core__.Import.list) Bin_prot.Read.reader

val bin_reader_list : 
  'a Bin_prot.Type_class.reader ->
  'a Core__.Import.list Bin_prot.Type_class.reader

val bin_list : 
  'a Bin_prot.Type_class.t ->
  'a Core__.Import.list Bin_prot.Type_class.t

val compare_list : 
  ('a -> 'a -> Core__.Import.int) ->
  'a Core__.Import.list ->
  'a Core__.Import.list ->
  Core__.Import.int

val equal_list : 
  ('a -> 'a -> Core__.Import.bool) ->
  'a Core__.Import.list ->
  'a Core__.Import.list ->
  Core__.Import.bool

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

val sexp_of_list : 
  ('a -> Sexplib0.Sexp.t) ->
  'a Core__.Import.list ->
  Sexplib0.Sexp.t

val list_of_sexp : 
  (Sexplib0.Sexp.t -> 'a) ->
  Sexplib0.Sexp.t ->
  'a Core__.Import.list

val list_sexp_grammar : 
  'a Sexplib0.Sexp_grammar.t ->
  'a Core__.Import.list Sexplib0.Sexp_grammar.t

val typerep_of_list : 
  'a Typerep_lib.Std.Typerep.t ->
  'a Core__.Import.list Typerep_lib.Std.Typerep.t

val typename_of_list : 
  'a Typerep_lib.Std.Typename.t ->
  'a Core__.Import.list Typerep_lib.Std.Typename.t

val bin_shape_nativeint : Bin_prot.Shape.t

val bin_size_nativeint : Core__.Import.nativeint Bin_prot.Size.sizer

val bin_write_nativeint : Core__.Import.nativeint Bin_prot.Write.writer

val bin_writer_nativeint : Core__.Import.nativeint Bin_prot.Type_class.writer

val bin_read_nativeint : Core__.Import.nativeint Bin_prot.Read.reader

val __bin_read_nativeint__ : 
  (Core__.Import.int -> Core__.Import.nativeint) Bin_prot.Read.reader

val bin_reader_nativeint : Core__.Import.nativeint Bin_prot.Type_class.reader

val bin_nativeint : Core__.Import.nativeint Bin_prot.Type_class.t

val compare_nativeint : 
  Core__.Import.nativeint ->
  Core__.Import.nativeint ->
  Core__.Import.int

val equal_nativeint : 
  Core__.Import.nativeint ->
  Core__.Import.nativeint ->
  Core__.Import.bool

val hash_fold_nativeint : 
  Ppx_hash_lib.Std.Hash.state ->
  Core__.Import.nativeint ->
  Ppx_hash_lib.Std.Hash.state

val hash_nativeint : 
  Core__.Import.nativeint ->
  Ppx_hash_lib.Std.Hash.hash_value

val sexp_of_nativeint : Core__.Import.nativeint -> Sexplib0.Sexp.t

val nativeint_of_sexp : Sexplib0.Sexp.t -> Core__.Import.nativeint

val nativeint_sexp_grammar : Core__.Import.nativeint Sexplib0.Sexp_grammar.t

val typerep_of_nativeint : Core__.Import.nativeint Typerep_lib.Std.Typerep.t

val typename_of_nativeint : Core__.Import.nativeint Typerep_lib.Std.Typename.t

val bin_shape_option : Bin_prot.Shape.t -> Bin_prot.Shape.t

val bin_size_option : 
  'a Bin_prot.Size.sizer ->
  'a Core__.Import.option Bin_prot.Size.sizer

val bin_write_option : 
  'a Bin_prot.Write.writer ->
  'a Core__.Import.option Bin_prot.Write.writer

val bin_writer_option : 
  'a Bin_prot.Type_class.writer ->
  'a Core__.Import.option Bin_prot.Type_class.writer

val bin_read_option : 
  'a Bin_prot.Read.reader ->
  'a Core__.Import.option Bin_prot.Read.reader

val __bin_read_option__ : 
  'a Bin_prot.Read.reader ->
  (Core__.Import.int -> 'a Core__.Import.option) Bin_prot.Read.reader

val bin_reader_option : 
  'a Bin_prot.Type_class.reader ->
  'a Core__.Import.option Bin_prot.Type_class.reader

val bin_option : 
  'a Bin_prot.Type_class.t ->
  'a Core__.Import.option Bin_prot.Type_class.t

val compare_option : 
  ('a -> 'a -> Core__.Import.int) ->
  'a Core__.Import.option ->
  'a Core__.Import.option ->
  Core__.Import.int

val equal_option : 
  ('a -> 'a -> Core__.Import.bool) ->
  'a Core__.Import.option ->
  'a Core__.Import.option ->
  Core__.Import.bool

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

val sexp_of_option : 
  ('a -> Sexplib0.Sexp.t) ->
  'a Core__.Import.option ->
  Sexplib0.Sexp.t

val option_of_sexp : 
  (Sexplib0.Sexp.t -> 'a) ->
  Sexplib0.Sexp.t ->
  'a Core__.Import.option

val option_sexp_grammar : 
  'a Sexplib0.Sexp_grammar.t ->
  'a Core__.Import.option Sexplib0.Sexp_grammar.t

val typerep_of_option : 
  'a Typerep_lib.Std.Typerep.t ->
  'a Core__.Import.option Typerep_lib.Std.Typerep.t

val typename_of_option : 
  'a Typerep_lib.Std.Typename.t ->
  'a Core__.Import.option Typerep_lib.Std.Typename.t

val bin_shape_string : Bin_prot.Shape.t

val bin_size_string : Core__.Import.string Bin_prot.Size.sizer

val bin_write_string : Core__.Import.string Bin_prot.Write.writer

val bin_writer_string : Core__.Import.string Bin_prot.Type_class.writer

val bin_read_string : Core__.Import.string Bin_prot.Read.reader

val __bin_read_string__ : 
  (Core__.Import.int -> Core__.Import.string) Bin_prot.Read.reader

val bin_reader_string : Core__.Import.string Bin_prot.Type_class.reader

val bin_string : Core__.Import.string Bin_prot.Type_class.t

val compare_string : 
  Core__.Import.string ->
  Core__.Import.string ->
  Core__.Import.int

val equal_string : 
  Core__.Import.string ->
  Core__.Import.string ->
  Core__.Import.bool

val hash_fold_string : 
  Ppx_hash_lib.Std.Hash.state ->
  Core__.Import.string ->
  Ppx_hash_lib.Std.Hash.state

val hash_string : Core__.Import.string -> Ppx_hash_lib.Std.Hash.hash_value

val sexp_of_string : Core__.Import.string -> Sexplib0.Sexp.t

val string_of_sexp : Sexplib0.Sexp.t -> Core__.Import.string

val string_sexp_grammar : Core__.Import.string Sexplib0.Sexp_grammar.t

val typerep_of_string : Core__.Import.string Typerep_lib.Std.Typerep.t

val typename_of_string : Core__.Import.string Typerep_lib.Std.Typename.t

val bin_shape_bytes : Bin_prot.Shape.t

val bin_size_bytes : Core__.Import.bytes Bin_prot.Size.sizer

val bin_write_bytes : Core__.Import.bytes Bin_prot.Write.writer

val bin_writer_bytes : Core__.Import.bytes Bin_prot.Type_class.writer

val bin_read_bytes : Core__.Import.bytes Bin_prot.Read.reader

val __bin_read_bytes__ : 
  (Core__.Import.int -> Core__.Import.bytes) Bin_prot.Read.reader

val bin_reader_bytes : Core__.Import.bytes Bin_prot.Type_class.reader

val bin_bytes : Core__.Import.bytes Bin_prot.Type_class.t

val compare_bytes : 
  Core__.Import.bytes ->
  Core__.Import.bytes ->
  Core__.Import.int

val equal_bytes : 
  Core__.Import.bytes ->
  Core__.Import.bytes ->
  Core__.Import.bool

val sexp_of_bytes : Core__.Import.bytes -> Sexplib0.Sexp.t

val bytes_of_sexp : Sexplib0.Sexp.t -> Core__.Import.bytes

val bytes_sexp_grammar : Core__.Import.bytes Sexplib0.Sexp_grammar.t

val typerep_of_bytes : Core__.Import.bytes Typerep_lib.Std.Typerep.t

val typename_of_bytes : Core__.Import.bytes Typerep_lib.Std.Typename.t

val bin_shape_ref : Bin_prot.Shape.t -> Bin_prot.Shape.t

val bin_size_ref : 'a Bin_prot.Size.sizer -> 'a ref Bin_prot.Size.sizer

val bin_write_ref : 'a Bin_prot.Write.writer -> 'a ref Bin_prot.Write.writer

val bin_writer_ref : 
  'a Bin_prot.Type_class.writer ->
  'a ref Bin_prot.Type_class.writer

val bin_read_ref : 'a Bin_prot.Read.reader -> 'a ref Bin_prot.Read.reader

val __bin_read_ref__ : 
  'a Bin_prot.Read.reader ->
  (Core__.Import.int -> 'a ref) Bin_prot.Read.reader

val bin_reader_ref : 
  'a Bin_prot.Type_class.reader ->
  'a ref Bin_prot.Type_class.reader

val bin_ref : 'a Bin_prot.Type_class.t -> 'a ref Bin_prot.Type_class.t

val compare_ref : 
  ('a -> 'a -> Core__.Import.int) ->
  'a ref ->
  'a ref ->
  Core__.Import.int

val equal_ref : 
  ('a -> 'a -> Core__.Import.bool) ->
  'a ref ->
  'a ref ->
  Core__.Import.bool

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

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

val ref_sexp_grammar : 
  'a Sexplib0.Sexp_grammar.t ->
  'a ref Sexplib0.Sexp_grammar.t

val typerep_of_ref : 
  'a Typerep_lib.Std.Typerep.t ->
  'a ref Typerep_lib.Std.Typerep.t

val typename_of_ref : 
  'a Typerep_lib.Std.Typename.t ->
  'a ref Typerep_lib.Std.Typename.t

val bin_shape_unit : Bin_prot.Shape.t

val bin_size_unit : Core__.Import.unit Bin_prot.Size.sizer

val bin_write_unit : Core__.Import.unit Bin_prot.Write.writer

val bin_writer_unit : Core__.Import.unit Bin_prot.Type_class.writer

val bin_read_unit : Core__.Import.unit Bin_prot.Read.reader

val __bin_read_unit__ : 
  (Core__.Import.int -> Core__.Import.unit) Bin_prot.Read.reader

val bin_reader_unit : Core__.Import.unit Bin_prot.Type_class.reader

val bin_unit : Core__.Import.unit Bin_prot.Type_class.t

val compare_unit : 
  Core__.Import.unit ->
  Core__.Import.unit ->
  Core__.Import.int

val equal_unit : Core__.Import.unit -> Core__.Import.unit -> Core__.Import.bool

val hash_fold_unit : 
  Ppx_hash_lib.Std.Hash.state ->
  Core__.Import.unit ->
  Ppx_hash_lib.Std.Hash.state

val hash_unit : Core__.Import.unit -> Ppx_hash_lib.Std.Hash.hash_value

val sexp_of_unit : Core__.Import.unit -> Sexplib0.Sexp.t

val unit_of_sexp : Sexplib0.Sexp.t -> Core__.Import.unit

val unit_sexp_grammar : Core__.Import.unit Sexplib0.Sexp_grammar.t

val typerep_of_unit : Core__.Import.unit Typerep_lib.Std.Typerep.t

val typename_of_unit : Core__.Import.unit Typerep_lib.Std.Typename.t

type float_array = Core__.Import.float Core__.Import.array

deprecated [since 2021-09] use [float array] or [floatarray] instead

val bin_shape_float_array : Bin_prot.Shape.t

val bin_size_float_array : float_array Bin_prot.Size.sizer

val bin_write_float_array : float_array Bin_prot.Write.writer

val bin_writer_float_array : float_array Bin_prot.Type_class.writer

val bin_read_float_array : float_array Bin_prot.Read.reader

val __bin_read_float_array__ : 
  (Core__.Import.int -> float_array) Bin_prot.Read.reader

val bin_reader_float_array : float_array Bin_prot.Type_class.reader

val bin_float_array : float_array Bin_prot.Type_class.t

val compare_float_array : float_array -> float_array -> Core__.Import.int

val sexp_of_float_array : float_array -> Sexplib0.Sexp.t

val float_array_of_sexp : Sexplib0.Sexp.t -> float_array

val float_array_sexp_grammar : float_array Sexplib0.Sexp_grammar.t

val typerep_of_float_array : float_array Typerep_lib.Std.Typerep.t

val typename_of_float_array : float_array Typerep_lib.Std.Typename.t

val sexp_of_exn : Core__.Import.Exn.t -> Sexplib0.Sexp.t

exception Not_found

deprecated [since 2018-02] Instead of raising [Not_found], consider using [raise_s] with an informative error message. If code needs to distinguish [Not_found] from other exceptions, please change it to handle both [Not_found] and [Not_found_s]. Then, instead of raising [Not_found], raise [Not_found_s] with an informative error message.

exception Not_found_s of Sexplib0.Sexp.t

type !'a _maybe_bound = 'a Maybe_bound.t =

| Incl of 'a
| Excl of 'a
| Unbounded

val am_running_inline_test : bool

val am_running_test : bool

val does_raise : (unit -> 'a) -> bool

val sec : Core__.Import.float -> Core__.Time_float.Span.t

val (^/) : Core__.Import.string -> Core__.Import.string -> Core__.Import.string

module Core_private = Core.Core_private

module Core_kernel_private = Core_private

module Unix = Core_unix

module Filename : sig ... end

module Sys : sig ... end

val compare : No_polymorphic_compare.compare

val equal : No_polymorphic_compare.compare

val (=) : No_polymorphic_compare.compare

val failwith : 'a -> [ `use_Logging_die_instead ]

val failwithf : 'a -> [ `use_Logging_die_instead ]

val invalid_arg : 'a -> [ `use_Logging_die_instead ]

val invalid_argf : 'a -> [ `use_Logging_die_instead ]

val exit : [> `In_general_prefer_using_Logging_exit_over_Pervasives_exit ]

module ANSITerminal : module type of ANSITerminal