Module InferStdlib.IStd

include Core
module Applicative = Core_kernel__.Import.Applicative
module Avltree = Core_kernel__.Import.Avltree
module Backtrace = Core_kernel__.Import.Backtrace
module Buffer = Base.Buffer
module Comparisons = Core_kernel__.Import.Comparisons
module Continue_or_stop = Core_kernel__.Import.Continue_or_stop
module Equal = Core_kernel__.Import.Equal
module Exn = Base.Exn
module Expect_test_config = Expect_test_config
module Field = Core_kernel__.Import.Field
module Floatable = Core_kernel__.Import.Floatable
module Formatter = Core_kernel__.Import.Formatter
module Hash = Core_kernel__.Import.Hash
module Heap_block = Core_kernel__.Heap_block
module In_channel = Core_kernel__.Import.In_channel
module Int_conversions = Base.Not_exposed_properly.Int_conversions
module Invariant = Core_kernel__.Import.Invariant
module Monad = Core_kernel__.Import.Monad
module Variant = Core_kernel__.Import.Variant
module Obj_array = Base.Not_exposed_properly.Obj_array
module Ordered_collection_common = Core_kernel__.Ordered_collection_common
module Out_channel = Core_kernel__.Import.Out_channel
module Poly = Core_kernel__.Import.Poly
module Polymorphic_compare = Poly
module Pretty_printer = Core_kernel__.Import.Pretty_printer
module Random = Base.Random
module Sexp_maybe = Core_kernel__.Sexp.Sexp_maybe
module Staged = Base.Staged
module Stringable = Core_kernel__.Import.Stringable
module Uchar = Core_kernel__.Import.Uchar
module Validate = Core_kernel__.Import.Validate
module With_return = Core_kernel__.Import.With_return
module Word_size = Core_kernel__.Import.Word_size
module Array = Core_kernel__.Array
module Binary_searchable = Core_kernel__.Binary_searchable
module Blit = Core_kernel__.Blit
module Bool = Core_kernel__.Bool
module Bytes = Core_kernel__.Bytes
module Char = Core_kernel__.Char
module Comparable = Core_kernel__.Comparable
module Comparator = Core_kernel__.Comparator
module Container = Core_kernel__.Container
module Either = Core_kernel__.Either
module Error = Core_kernel__.Error
module Float = Core_kernel__.Float
module Fn = Core_kernel__.Fn
module Hash_set = Core_kernel__.Hash_set
module Hashtbl = Core_kernel__.Hashtbl
module Hashtbl_intf = Core_kernel__.Hashtbl_intf
module Info = Core_kernel__.Info
module Int = Core_kernel__.Int
module Int_intf = Core_kernel__.Int_intf
module Int32 = Core_kernel__.Int32
module Int63 = Core_kernel__.Int63
module Int64 = Core_kernel__.Int64
module Lazy = Core_kernel__.Lazy
module Linked_queue = Core_kernel__.Linked_queue
module List = Core_kernel__.List
module Maybe_bound = Core_kernel__.Maybe_bound
module Nativeint = Core_kernel__.Nativeint
module Option = Core_kernel__.Option
module Ordering = Core_kernel__.Ordering
module Or_error = Core_kernel__.Or_error
module Printf = Core_kernel__.Printf
module Ref = Core_kernel__.Ref
module Result = Core_kernel__.Result
module Sequence = Core_kernel__.Sequence
module Set = Core_kernel__.Set
module Sexp = Core_kernel__.Sexp
module Sexpable = Core_kernel__.Sexpable
module Sign = Core_kernel__.Sign
module Sign_or_nan = Core_kernel__.Sign_or_nan
module Source_code_position = Core_kernel__.Source_code_position
module String = Core_kernel__.String
module Type_equal = Core_kernel__.Type_equal
module Unit = Core_kernel__.Unit
module Arg = Core_kernel__.Arg
module Bag = Core_kernel__.Bag
module Bigbuffer = Core_kernel__.Bigbuffer
module Bigsubstring = Core_kernel__.Bigsubstring
module Binable = Core_kernel__.Binable
module Bin_prot = Core_kernel__.Core_bin_prot
module Blang = Core_kernel__.Blang
module Bounded_index = Core_kernel__.Bounded_index
module Bounded_int_table = Core_kernel__.Bounded_int_table
module Bus = Core_kernel__.Bus
module Byte_units = Core_kernel__.Byte_units
module Day_of_week = Core_kernel__.Day_of_week
module Debug = Core_kernel__.Debug
module Deque = Core_kernel__.Deque
module Deriving_hash = Core_kernel__.Deriving_hash
module Doubly_linked = Core_kernel__.Doubly_linked
module Ephemeron = Core_kernel__.Ephemeron
module Fdeque = Core_kernel__.Fdeque
module Flags = Core_kernel__.Flags
module Float_with_finite_only_serialization = Core_kernel__.Float_with_finite_only_serialization
module Fqueue = Core_kernel__.Fqueue
module Gc = Core_kernel__.Gc
module Hash_queue = Core_kernel__.Hash_queue
module Hashable = Core_kernel__.Hashable
module Heap = Core_kernel__.Heap
module Hexdump = Core_kernel__.Hexdump
module Hexdump_intf = Core_kernel__.Hexdump_intf
module Host_and_port = Core_kernel__.Host_and_port
module Identifiable = Core_kernel__.Identifiable
module Immediate_option = Core_kernel__.Immediate_option
module Immediate_option_intf = Core_kernel__.Immediate_option_intf
module Interfaces = Core_kernel__.Interfaces
module Linked_stack = Core_kernel__.Linked_stack
module Map = Core_kernel__.Map
module Md5 = Core_kernel__.Md5
module Memo = Core_kernel__.Memo
module Month = Core_kernel__.Month
module No_polymorphic_compare = Core_kernel__.No_polymorphic_compare
module Nothing = Core_kernel__.Nothing
module Only_in_test = Core_kernel__.Only_in_test
module Option_array = Core_kernel__.Option_array
module Optional_syntax = Core_kernel__.Optional_syntax
module Percent = Core_kernel__.Percent
module Perms = Core_kernel__.Perms
module Pid = Core_kernel__.Pid
module Pool = Core_kernel__.Pool
module Pool_intf = Core_kernel__.Pool_intf
module Popcount = Base.Popcount
module Printexc = Core_kernel__.Printexc
module Queue = Core_kernel__.Queue
module Quickcheck = Core_kernel__.Quickcheck
module Quickcheck_intf = Core_kernel__.Quickcheck_intf
module Quickcheckable = Core_kernel__.Quickcheckable
module Robustly_comparable = Core_kernel__.Robustly_comparable
module Set_once = Core_kernel__.Set_once
module Splittable_random = Splittable_random
module Stable_comparable = Core_kernel__.Stable_comparable
module Stable_unit_test = Core_kernel__.Stable_unit_test
module Stack = Core_kernel__.Stack
module String_id = Core_kernel__.String_id
module Substring = Core_kernel__.Substring
module Substring_intf = Core_kernel__.Substring_intf
module Timing_wheel_ns = Core_kernel__.Timing_wheel_ns
module Tuple = Core_kernel__.Tuple
module Tuple_type = Core_kernel__.Tuple_type
module Tuple2 = Tuple.T2
module Tuple3 = Tuple.T3
module Type_immediacy = Core_kernel__.Type_immediacy
module Uniform_array = Core_kernel__.Uniform_array
module Union_find = Core_kernel__.Union_find
module Unique_id = Core_kernel__.Unique_id
module Unit_of_time = Core_kernel__.Unit_of_time
module Univ = Core_kernel__.Univ
module Univ_map = Core_kernel__.Univ_map
module Validated = Core_kernel__.Validated
module Weak = Stdlib.Weak
module type Unique_id = Unique_id.Id
module type T = sig ... end
module type T1 = sig ... end
module type T2 = sig ... end
module type T3 = sig ... end
module type T_bin = sig ... end
type 'a _maybe_bound = 'a Maybe_bound.t =
| Incl of 'a
| Excl of 'a
| Unbounded
val does_raise : (unit -> 'a) -> bool
val am_running_inline_test : bool
val am_running_test : bool
val raise : exn -> 'a
val raise_notrace : exn -> 'a
val invalid_arg : string -> 'a
val failwith : string -> 'a
exception Exit
val (=) : 'a -> 'a -> bool
val (<>) : 'a -> 'a -> bool
val (<) : 'a -> 'a -> bool
val (>) : 'a -> 'a -> bool
val (<=) : 'a -> 'a -> bool
val (>=) : 'a -> 'a -> bool
val compare : 'a -> 'a -> int
val min : 'a -> 'a -> 'a
val max : 'a -> 'a -> 'a
val (==) : 'a -> 'a -> bool
val (!=) : 'a -> 'a -> bool
val not : bool -> bool
val (&&) : bool -> bool -> bool
val (&) : bool -> bool -> bool
val (||) : bool -> bool -> bool
val or : bool -> bool -> bool
val __LOC__ : string
val __FILE__ : string
val __LINE__ : int
val __MODULE__ : string
val __POS__ : string * int * int * int
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
val min_int : int
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
val expm1 : float -> float
val log1p : float -> float
val cos : float -> float
val sin : float -> float
val tan : float -> float
val acos : float -> float
val asin : float -> float
val atan : float -> float
val atan2 : float -> float -> float
val hypot : float -> float -> float
val cosh : float -> float
val sinh : float -> float
val tanh : float -> float
val ceil : float -> float
val floor : float -> float
val abs_float : float -> float
val copysign : float -> float -> float
val mod_float : float -> float -> float
val frexp : float -> float * int
val ldexp : float -> int -> float
val modf : float -> float * float
val float : int -> float
val float_of_int : int -> float
val truncate : float -> int
val int_of_float : float -> int
val infinity : float
val neg_infinity : float
val nan : float
val max_float : float
val min_float : float
val epsilon_float : float
type fpclass = Caml.fpclass =
| FP_normal
| FP_subnormal
| FP_zero
| FP_infinite
| FP_nan
val classify_float : float -> fpclass
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
type out_channel = Caml.out_channel
val stdin : Caml.in_channel
val stdout : Caml.out_channel
val stderr : Caml.out_channel
val print_char : char -> unit
val print_string : string -> unit
val print_bytes : bytes -> unit
val print_int : int -> unit
val print_float : float -> unit
val print_endline : string -> unit
val print_newline : unit -> unit
val prerr_char : char -> unit
val prerr_string : string -> unit
val prerr_bytes : bytes -> unit
val prerr_int : int -> unit
val prerr_float : float -> unit
val prerr_endline : string -> unit
val prerr_newline : unit -> unit
val read_line : unit -> string
val read_int : unit -> int
val read_float : unit -> float
type open_flag = Caml.open_flag =
| Open_rdonly
| Open_wronly
| Open_append
| Open_creat
| Open_trunc
| Open_excl
| Open_binary
| Open_text
| Open_nonblock
val open_out : string -> Caml.out_channel
val open_out_bin : string -> Caml.out_channel
val open_out_gen : Caml.open_flag list -> int -> string -> Caml.out_channel
val flush : Caml.out_channel -> unit
val flush_all : unit -> unit
val output_char : Caml.out_channel -> char -> unit
val output_string : Caml.out_channel -> string -> unit
val output_bytes : Caml.out_channel -> bytes -> unit
val output : Caml.out_channel -> bytes -> int -> int -> unit
val output_substring : Caml.out_channel -> string -> int -> int -> unit
val output_byte : Caml.out_channel -> int -> unit
val output_binary_int : Caml.out_channel -> int -> unit
val output_value : Caml.out_channel -> 'a -> unit
val seek_out : Caml.out_channel -> int -> unit
val pos_out : Caml.out_channel -> int
val out_channel_length : Caml.out_channel -> int
val close_out : Caml.out_channel -> unit
val close_out_noerr : Caml.out_channel -> unit
val set_binary_mode_out : Caml.out_channel -> bool -> unit
val open_in : string -> Caml.in_channel
val open_in_bin : string -> Caml.in_channel
val open_in_gen : Caml.open_flag list -> int -> string -> Caml.in_channel
val input_char : Caml.in_channel -> char
val input_line : Caml.in_channel -> string
val input : Caml.in_channel -> bytes -> int -> int -> int
val really_input : Caml.in_channel -> bytes -> int -> int -> unit
val really_input_string : Caml.in_channel -> int -> string
val input_byte : Caml.in_channel -> int
val input_binary_int : Caml.in_channel -> int
val input_value : Caml.in_channel -> 'a
val seek_in : Caml.in_channel -> int -> unit
val pos_in : Caml.in_channel -> int
val in_channel_length : Caml.in_channel -> int
val close_in : Caml.in_channel -> unit
val close_in_noerr : Caml.in_channel -> unit
val set_binary_mode_in : Caml.in_channel -> bool -> unit
module LargeFile = Core_kernel__Core_pervasives.LargeFile
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 exit : int -> 'a
val at_exit : (unit -> unit) -> unit
val valid_float_lexem : string -> string
val unsafe_really_input : Caml.in_channel -> bytes -> int -> int -> unit
val do_at_exit : unit -> unit
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_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_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_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_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_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 (|!) : 'a -> ('a -> 'b) -> 'b
type ('f, 's) _either = ('f, 's) Base__Either.t =
| First of 'f
| Second of 's
val (>=.) : Core_kernel__.Import.float -> Core_kernel__.Import.float -> bool
val (<=.) : Core_kernel__.Import.float -> Core_kernel__.Import.float -> bool
val (=.) : Core_kernel__.Import.float -> Core_kernel__.Import.float -> bool
val (>.) : Core_kernel__.Import.float -> Core_kernel__.Import.float -> bool
val (<.) : Core_kernel__.Import.float -> Core_kernel__.Import.float -> bool
val (<>.) : Core_kernel__.Import.float -> Core_kernel__.Import.float -> bool
val robustly_compare : Core_kernel__.Import.float -> Core_kernel__.Import.float -> int
type bigstring = Sexplib.Conv.bigstring
val sexp_of_bigstring : bigstring -> Ppx_sexp_conv_lib.Sexp.t
val bigstring_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> bigstring
type mat = Sexplib.Conv.mat
val sexp_of_mat : mat -> Ppx_sexp_conv_lib.Sexp.t
val mat_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> mat
type vec = Sexplib.Conv.vec
val sexp_of_vec : vec -> Ppx_sexp_conv_lib.Sexp.t
val vec_of_sexp : Ppx_sexp_conv_lib.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_kernel__Import.exn * Base.Sexp.t
val of_sexp_error : Core_kernel__Import.string -> Base.Sexp.t -> 'a
val of_sexp_error_exn : Core_kernel__Import.exn -> Base.Sexp.t -> 'a
module type Applicative = Core_kernel__.Import.Applicative.S
module type Binable = Core_kernel__.Binable0.S
module type Comparable = Core_kernel__.Comparable.S
module type Comparable_binable = Core_kernel__.Comparable.S_binable
module type Floatable = Core_kernel__.Import.Floatable.S
module type Hashable = Core_kernel__.Hashable.S
module type Hashable_binable = Core_kernel__.Hashable.S_binable
module type Identifiable = Core_kernel__.Identifiable.S
module type Infix_comparators = Core_kernel__.Comparable.Infix
module type Intable = Core_kernel__.Import.Intable.S
module type Monad = Core_kernel__.Import.Monad.S
module type Quickcheckable = Core_kernel__.Quickcheckable.S
module type Robustly_comparable = Core_kernel__.Robustly_comparable.S
module type Sexpable = Core_kernel__.Sexpable.S
module type Stable = Core_kernel__.Stable_module_types.S0
module type Stable_int63able = Core_kernel__.Stable_int63able.S
module type Stable_without_comparator = Core_kernel__.Stable_module_types.S0_without_comparator
module type Stable1 = Core_kernel__.Stable_module_types.S1
module type Stable2 = Core_kernel__.Stable_module_types.S2
module type Stable3 = Core_kernel__.Stable_module_types.S3
module type Stable4 = Core_kernel__.Stable_module_types.S4
module type Stringable = Core_kernel__.Import.Stringable.S
module type Unit = Core_kernel__.Unit.S
val (@) : 'a Base__List.t -> 'a Base__List.t -> 'a Base__List.t
type never_returns = Core_kernel__.Nothing.t
val sexp_of_never_returns : never_returns -> Ppx_sexp_conv_lib.Sexp.t
val never_returns : Core_kernel__.Nothing.t -> 'a
type _ordering = Core_kernel__Ordering.t =
| Less
| Equal
| Greater
type read = Core_kernel__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_kernel__.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_kernel__.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 -> Ppx_sexp_conv_lib.Sexp.t
val read_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> read
type write = Core_kernel__Perms.Write.t
val compare_write : write -> write -> Core_kernel__.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 -> Ppx_sexp_conv_lib.Sexp.t
val write_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> write
type immutable = Core_kernel__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_kernel__.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_kernel__.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 -> Ppx_sexp_conv_lib.Sexp.t
val immutable_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> immutable
type read_write = Core_kernel__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_kernel__.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_kernel__.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 -> Ppx_sexp_conv_lib.Sexp.t
val read_write_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> read_write
type 'a perms = 'a Core_kernel__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_kernel__.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_kernel__.Import.int) -> 'a perms -> 'a perms -> Core_kernel__.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 -> Ppx_sexp_conv_lib.Sexp.t) -> 'a perms -> Ppx_sexp_conv_lib.Sexp.t
val perms_of_sexp : (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a perms
type ('ok, 'err) _result = ('ok, 'err) Core_kernel__Result.t =
| Ok of 'ok
| Error of 'err
val is_ok : ('a, 'b) Core_kernel__Result.t -> bool
val is_error : ('a, 'b) Core_kernel__Result.t -> bool
type -'a return = private 'a Core_kernel__.Import.With_return.return = {
return : b. 'a -> 'b;
}
exception Bug of Core_kernel__.Import.string
exception C_malloc_exn of Core_kernel__.Import.int * Core_kernel__.Import.int
exception Finally of Core_kernel__.Import.Exn.t * Core_kernel__.Import.Exn.t
val fst3 : ('a * 'b * 'c) -> 'a
val snd3 : ('a * 'b * 'c) -> 'b
val trd3 : ('a * 'b * 'c) -> 'c
val uw : 'a option -> 'a
val (%) : Core_kernel__.Int.t -> Core_kernel__.Int.t -> Core_kernel__.Int.t
val (/%) : Core_kernel__.Int.t -> Core_kernel__.Int.t -> Core_kernel__.Int.t
val (//) : Core_kernel__.Int.t -> Core_kernel__.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, Stdio.Out_channel.t, Base.unit) Base.format -> 'a
val error : ?⁠strict:unit -> string -> 'a -> ('a -> Base__.Sexp.t) -> 'b Core_kernel__.Or_error.t
val error_s : Base__.Sexp.t -> 'a Core_kernel__.Or_error.t
val failwithf : ('a, unit, string, unit -> 'b) Stdlib.format4 -> 'a
val failwithp : ?⁠strict:Core_kernel__.Import.unit -> Stdlib.Lexing.position -> Core_kernel__.Import.string -> 'a -> ('a -> Base.Sexp.t) -> 'b
val failwiths : ?⁠strict:Core_kernel__.Import.unit -> ?⁠here:Stdlib.Lexing.position -> Core_kernel__.Import.string -> 'a -> ('a -> Base.Sexp.t) -> 'b
val force : 'a Base.Lazy.t -> 'a
val fprintf : Stdio.Out_channel.t -> ('a, Stdio.Out_channel.t, Base.unit) Base.format -> 'a
val ident : 'a -> 'a
val invalid_argf : ('a, unit, string, unit -> 'b) Stdlib.format4 -> 'a
val ifprintf : 'a -> ('b, 'a, 'c, unit) Stdlib.format4 -> 'b
val is_none : 'a Core_kernel__.Option.t -> bool
val is_some : 'a Core_kernel__.Option.t -> bool
val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) Stdlib.format4 -> 'b
val ok_exn : 'a Core_kernel__.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 printf : ('a, Stdio.Out_channel.t, Base.unit) Base.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 ] -> Core_kernel__.Float.t -> Core_kernel__.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_kernel__.Import.Staged.t
val unstage : 'a Core_kernel__.Import.Staged.t -> 'a
val with_return : ('a Core_kernel__.Import.With_return.return -> 'a) -> 'a
val with_return_option : ('a Core_kernel__.Import.With_return.return -> unit) -> 'a option
module rec Typerep = Typerep_lib__Std_internal.Typerep
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_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_kernel__.Import.array Bin_prot.Size.sizer
val bin_write_array : 'a Bin_prot.Write.writer -> 'a Core_kernel__.Import.array Bin_prot.Write.writer
val bin_writer_array : 'a Bin_prot.Type_class.writer -> 'a Core_kernel__.Import.array Bin_prot.Type_class.writer
val bin_read_array : 'a Bin_prot.Read.reader -> 'a Core_kernel__.Import.array Bin_prot.Read.reader
val __bin_read_array__ : 'a Bin_prot.Read.reader -> (Core_kernel__.Import.int -> 'a Core_kernel__.Import.array) Bin_prot.Read.reader
val bin_reader_array : 'a Bin_prot.Type_class.reader -> 'a Core_kernel__.Import.array Bin_prot.Type_class.reader
val bin_array : 'a Bin_prot.Type_class.t -> 'a Core_kernel__.Import.array Bin_prot.Type_class.t
val compare_array : ('a -> 'a -> Core_kernel__.Import.int) -> 'a Core_kernel__.Import.array -> 'a Core_kernel__.Import.array -> Core_kernel__.Import.int
val equal_array : ('a -> 'a -> Core_kernel__.Import.bool) -> 'a Core_kernel__.Import.array -> 'a Core_kernel__.Import.array -> Core_kernel__.Import.bool
val sexp_of_array : ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a Core_kernel__.Import.array -> Ppx_sexp_conv_lib.Sexp.t
val array_of_sexp : (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a Core_kernel__.Import.array
val typerep_of_array : 'a Typerep_lib.Std.Typerep.t -> 'a Core_kernel__.Import.array Typerep_lib.Std.Typerep.t
val typename_of_array : 'a Typerep_lib.Std.Typename.t -> 'a Core_kernel__.Import.array Typerep_lib.Std.Typename.t
val bin_shape_bool : Bin_prot.Shape.t
val bin_size_bool : Core_kernel__.Import.bool Bin_prot.Size.sizer
val bin_write_bool : Core_kernel__.Import.bool Bin_prot.Write.writer
val bin_writer_bool : Core_kernel__.Import.bool Bin_prot.Type_class.writer
val bin_read_bool : Core_kernel__.Import.bool Bin_prot.Read.reader
val __bin_read_bool__ : (Core_kernel__.Import.int -> Core_kernel__.Import.bool) Bin_prot.Read.reader
val bin_reader_bool : Core_kernel__.Import.bool Bin_prot.Type_class.reader
val bin_bool : Core_kernel__.Import.bool Bin_prot.Type_class.t
val compare_bool : Core_kernel__.Import.bool -> Core_kernel__.Import.bool -> Core_kernel__.Import.int
val equal_bool : Core_kernel__.Import.bool -> Core_kernel__.Import.bool -> Core_kernel__.Import.bool
val hash_fold_bool : Ppx_hash_lib.Std.Hash.state -> Core_kernel__.Import.bool -> Ppx_hash_lib.Std.Hash.state
val hash_bool : Core_kernel__.Import.bool -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_bool : Core_kernel__.Import.bool -> Ppx_sexp_conv_lib.Sexp.t
val bool_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Core_kernel__.Import.bool
val typerep_of_bool : Core_kernel__.Import.bool Typerep_lib.Std.Typerep.t
val typename_of_bool : Core_kernel__.Import.bool Typerep_lib.Std.Typename.t
val bin_shape_char : Bin_prot.Shape.t
val bin_size_char : Core_kernel__.Import.char Bin_prot.Size.sizer
val bin_write_char : Core_kernel__.Import.char Bin_prot.Write.writer
val bin_writer_char : Core_kernel__.Import.char Bin_prot.Type_class.writer
val bin_read_char : Core_kernel__.Import.char Bin_prot.Read.reader
val __bin_read_char__ : (Core_kernel__.Import.int -> Core_kernel__.Import.char) Bin_prot.Read.reader
val bin_reader_char : Core_kernel__.Import.char Bin_prot.Type_class.reader
val bin_char : Core_kernel__.Import.char Bin_prot.Type_class.t
val compare_char : Core_kernel__.Import.char -> Core_kernel__.Import.char -> Core_kernel__.Import.int
val equal_char : Core_kernel__.Import.char -> Core_kernel__.Import.char -> Core_kernel__.Import.bool
val hash_fold_char : Ppx_hash_lib.Std.Hash.state -> Core_kernel__.Import.char -> Ppx_hash_lib.Std.Hash.state
val hash_char : Core_kernel__.Import.char -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_char : Core_kernel__.Import.char -> Ppx_sexp_conv_lib.Sexp.t
val char_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Core_kernel__.Import.char
val typerep_of_char : Core_kernel__.Import.char Typerep_lib.Std.Typerep.t
val typename_of_char : Core_kernel__.Import.char Typerep_lib.Std.Typename.t
val bin_shape_float : Bin_prot.Shape.t
val bin_size_float : Core_kernel__.Import.float Bin_prot.Size.sizer
val bin_write_float : Core_kernel__.Import.float Bin_prot.Write.writer
val bin_writer_float : Core_kernel__.Import.float Bin_prot.Type_class.writer
val bin_read_float : Core_kernel__.Import.float Bin_prot.Read.reader
val __bin_read_float__ : (Core_kernel__.Import.int -> Core_kernel__.Import.float) Bin_prot.Read.reader
val bin_reader_float : Core_kernel__.Import.float Bin_prot.Type_class.reader
val bin_float : Core_kernel__.Import.float Bin_prot.Type_class.t
val compare_float : Core_kernel__.Import.float -> Core_kernel__.Import.float -> Core_kernel__.Import.int
val equal_float : Core_kernel__.Import.float -> Core_kernel__.Import.float -> Core_kernel__.Import.bool
val hash_fold_float : Ppx_hash_lib.Std.Hash.state -> Core_kernel__.Import.float -> Ppx_hash_lib.Std.Hash.state
val hash_float : Core_kernel__.Import.float -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_float : Core_kernel__.Import.float -> Ppx_sexp_conv_lib.Sexp.t
val float_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Core_kernel__.Import.float
val typerep_of_float : Core_kernel__.Import.float Typerep_lib.Std.Typerep.t
val typename_of_float : Core_kernel__.Import.float Typerep_lib.Std.Typename.t
val bin_shape_int : Bin_prot.Shape.t
val bin_size_int : Core_kernel__.Import.int Bin_prot.Size.sizer
val bin_write_int : Core_kernel__.Import.int Bin_prot.Write.writer
val bin_writer_int : Core_kernel__.Import.int Bin_prot.Type_class.writer
val bin_read_int : Core_kernel__.Import.int Bin_prot.Read.reader
val __bin_read_int__ : (Core_kernel__.Import.int -> Core_kernel__.Import.int) Bin_prot.Read.reader
val bin_reader_int : Core_kernel__.Import.int Bin_prot.Type_class.reader
val bin_int : Core_kernel__.Import.int Bin_prot.Type_class.t
val compare_int : Core_kernel__.Import.int -> Core_kernel__.Import.int -> Core_kernel__.Import.int
val equal_int : Core_kernel__.Import.int -> Core_kernel__.Import.int -> Core_kernel__.Import.bool
val hash_fold_int : Ppx_hash_lib.Std.Hash.state -> Core_kernel__.Import.int -> Ppx_hash_lib.Std.Hash.state
val hash_int : Core_kernel__.Import.int -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_int : Core_kernel__.Import.int -> Ppx_sexp_conv_lib.Sexp.t
val int_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Core_kernel__.Import.int
val typerep_of_int : Core_kernel__.Import.int Typerep_lib.Std.Typerep.t
val typename_of_int : Core_kernel__.Import.int Typerep_lib.Std.Typename.t
val bin_shape_int32 : Bin_prot.Shape.t
val bin_size_int32 : Core_kernel__.Import.int32 Bin_prot.Size.sizer
val bin_write_int32 : Core_kernel__.Import.int32 Bin_prot.Write.writer
val bin_writer_int32 : Core_kernel__.Import.int32 Bin_prot.Type_class.writer
val bin_read_int32 : Core_kernel__.Import.int32 Bin_prot.Read.reader
val __bin_read_int32__ : (Core_kernel__.Import.int -> Core_kernel__.Import.int32) Bin_prot.Read.reader
val bin_reader_int32 : Core_kernel__.Import.int32 Bin_prot.Type_class.reader
val bin_int32 : Core_kernel__.Import.int32 Bin_prot.Type_class.t
val compare_int32 : Core_kernel__.Import.int32 -> Core_kernel__.Import.int32 -> Core_kernel__.Import.int
val equal_int32 : Core_kernel__.Import.int32 -> Core_kernel__.Import.int32 -> Core_kernel__.Import.bool
val hash_fold_int32 : Ppx_hash_lib.Std.Hash.state -> Core_kernel__.Import.int32 -> Ppx_hash_lib.Std.Hash.state
val hash_int32 : Core_kernel__.Import.int32 -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_int32 : Core_kernel__.Import.int32 -> Ppx_sexp_conv_lib.Sexp.t
val int32_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Core_kernel__.Import.int32
val typerep_of_int32 : Core_kernel__.Import.int32 Typerep_lib.Std.Typerep.t
val typename_of_int32 : Core_kernel__.Import.int32 Typerep_lib.Std.Typename.t
val bin_shape_int64 : Bin_prot.Shape.t
val bin_size_int64 : Core_kernel__.Import.int64 Bin_prot.Size.sizer
val bin_write_int64 : Core_kernel__.Import.int64 Bin_prot.Write.writer
val bin_writer_int64 : Core_kernel__.Import.int64 Bin_prot.Type_class.writer
val bin_read_int64 : Core_kernel__.Import.int64 Bin_prot.Read.reader
val __bin_read_int64__ : (Core_kernel__.Import.int -> Core_kernel__.Import.int64) Bin_prot.Read.reader
val bin_reader_int64 : Core_kernel__.Import.int64 Bin_prot.Type_class.reader
val bin_int64 : Core_kernel__.Import.int64 Bin_prot.Type_class.t
val compare_int64 : Core_kernel__.Import.int64 -> Core_kernel__.Import.int64 -> Core_kernel__.Import.int
val equal_int64 : Core_kernel__.Import.int64 -> Core_kernel__.Import.int64 -> Core_kernel__.Import.bool
val hash_fold_int64 : Ppx_hash_lib.Std.Hash.state -> Core_kernel__.Import.int64 -> Ppx_hash_lib.Std.Hash.state
val hash_int64 : Core_kernel__.Import.int64 -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_int64 : Core_kernel__.Import.int64 -> Ppx_sexp_conv_lib.Sexp.t
val int64_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Core_kernel__.Import.int64
val typerep_of_int64 : Core_kernel__.Import.int64 Typerep_lib.Std.Typerep.t
val typename_of_int64 : Core_kernel__.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_kernel__.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_kernel__.Import.int) -> 'a lazy_t -> 'a lazy_t -> Core_kernel__.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 -> Ppx_sexp_conv_lib.Sexp.t) -> 'a lazy_t -> Ppx_sexp_conv_lib.Sexp.t
val lazy_t_of_sexp : (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a lazy_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_kernel__.Import.list Bin_prot.Size.sizer
val bin_write_list : 'a Bin_prot.Write.writer -> 'a Core_kernel__.Import.list Bin_prot.Write.writer
val bin_writer_list : 'a Bin_prot.Type_class.writer -> 'a Core_kernel__.Import.list Bin_prot.Type_class.writer
val bin_read_list : 'a Bin_prot.Read.reader -> 'a Core_kernel__.Import.list Bin_prot.Read.reader
val __bin_read_list__ : 'a Bin_prot.Read.reader -> (Core_kernel__.Import.int -> 'a Core_kernel__.Import.list) Bin_prot.Read.reader
val bin_reader_list : 'a Bin_prot.Type_class.reader -> 'a Core_kernel__.Import.list Bin_prot.Type_class.reader
val bin_list : 'a Bin_prot.Type_class.t -> 'a Core_kernel__.Import.list Bin_prot.Type_class.t
val compare_list : ('a -> 'a -> Core_kernel__.Import.int) -> 'a Core_kernel__.Import.list -> 'a Core_kernel__.Import.list -> Core_kernel__.Import.int
val equal_list : ('a -> 'a -> Core_kernel__.Import.bool) -> 'a Core_kernel__.Import.list -> 'a Core_kernel__.Import.list -> Core_kernel__.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_kernel__.Import.list -> Ppx_hash_lib.Std.Hash.state
val sexp_of_list : ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a Core_kernel__.Import.list -> Ppx_sexp_conv_lib.Sexp.t
val list_of_sexp : (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a Core_kernel__.Import.list
val typerep_of_list : 'a Typerep_lib.Std.Typerep.t -> 'a Core_kernel__.Import.list Typerep_lib.Std.Typerep.t
val typename_of_list : 'a Typerep_lib.Std.Typename.t -> 'a Core_kernel__.Import.list Typerep_lib.Std.Typename.t
val bin_shape_nativeint : Bin_prot.Shape.t
val bin_size_nativeint : Core_kernel__.Import.nativeint Bin_prot.Size.sizer
val bin_write_nativeint : Core_kernel__.Import.nativeint Bin_prot.Write.writer
val bin_writer_nativeint : Core_kernel__.Import.nativeint Bin_prot.Type_class.writer
val bin_read_nativeint : Core_kernel__.Import.nativeint Bin_prot.Read.reader
val __bin_read_nativeint__ : (Core_kernel__.Import.int -> Core_kernel__.Import.nativeint) Bin_prot.Read.reader
val bin_reader_nativeint : Core_kernel__.Import.nativeint Bin_prot.Type_class.reader
val bin_nativeint : Core_kernel__.Import.nativeint Bin_prot.Type_class.t
val compare_nativeint : Core_kernel__.Import.nativeint -> Core_kernel__.Import.nativeint -> Core_kernel__.Import.int
val equal_nativeint : Core_kernel__.Import.nativeint -> Core_kernel__.Import.nativeint -> Core_kernel__.Import.bool
val hash_fold_nativeint : Ppx_hash_lib.Std.Hash.state -> Core_kernel__.Import.nativeint -> Ppx_hash_lib.Std.Hash.state
val hash_nativeint : Core_kernel__.Import.nativeint -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_nativeint : Core_kernel__.Import.nativeint -> Ppx_sexp_conv_lib.Sexp.t
val nativeint_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Core_kernel__.Import.nativeint
val typerep_of_nativeint : Core_kernel__.Import.nativeint Typerep_lib.Std.Typerep.t
val typename_of_nativeint : Core_kernel__.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_kernel__.Import.option Bin_prot.Size.sizer
val bin_write_option : 'a Bin_prot.Write.writer -> 'a Core_kernel__.Import.option Bin_prot.Write.writer
val bin_writer_option : 'a Bin_prot.Type_class.writer -> 'a Core_kernel__.Import.option Bin_prot.Type_class.writer
val bin_read_option : 'a Bin_prot.Read.reader -> 'a Core_kernel__.Import.option Bin_prot.Read.reader
val __bin_read_option__ : 'a Bin_prot.Read.reader -> (Core_kernel__.Import.int -> 'a Core_kernel__.Import.option) Bin_prot.Read.reader
val bin_reader_option : 'a Bin_prot.Type_class.reader -> 'a Core_kernel__.Import.option Bin_prot.Type_class.reader
val bin_option : 'a Bin_prot.Type_class.t -> 'a Core_kernel__.Import.option Bin_prot.Type_class.t
val compare_option : ('a -> 'a -> Core_kernel__.Import.int) -> 'a Core_kernel__.Import.option -> 'a Core_kernel__.Import.option -> Core_kernel__.Import.int
val equal_option : ('a -> 'a -> Core_kernel__.Import.bool) -> 'a Core_kernel__.Import.option -> 'a Core_kernel__.Import.option -> Core_kernel__.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_kernel__.Import.option -> Ppx_hash_lib.Std.Hash.state
val sexp_of_option : ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a Core_kernel__.Import.option -> Ppx_sexp_conv_lib.Sexp.t
val option_of_sexp : (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a Core_kernel__.Import.option
val typerep_of_option : 'a Typerep_lib.Std.Typerep.t -> 'a Core_kernel__.Import.option Typerep_lib.Std.Typerep.t
val typename_of_option : 'a Typerep_lib.Std.Typename.t -> 'a Core_kernel__.Import.option Typerep_lib.Std.Typename.t
val bin_shape_string : Bin_prot.Shape.t
val bin_size_string : Core_kernel__.Import.string Bin_prot.Size.sizer
val bin_write_string : Core_kernel__.Import.string Bin_prot.Write.writer
val bin_writer_string : Core_kernel__.Import.string Bin_prot.Type_class.writer
val bin_read_string : Core_kernel__.Import.string Bin_prot.Read.reader
val __bin_read_string__ : (Core_kernel__.Import.int -> Core_kernel__.Import.string) Bin_prot.Read.reader
val bin_reader_string : Core_kernel__.Import.string Bin_prot.Type_class.reader
val bin_string : Core_kernel__.Import.string Bin_prot.Type_class.t
val compare_string : Core_kernel__.Import.string -> Core_kernel__.Import.string -> Core_kernel__.Import.int
val equal_string : Core_kernel__.Import.string -> Core_kernel__.Import.string -> Core_kernel__.Import.bool
val hash_fold_string : Ppx_hash_lib.Std.Hash.state -> Core_kernel__.Import.string -> Ppx_hash_lib.Std.Hash.state
val hash_string : Core_kernel__.Import.string -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_string : Core_kernel__.Import.string -> Ppx_sexp_conv_lib.Sexp.t
val string_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Core_kernel__.Import.string
val typerep_of_string : Core_kernel__.Import.string Typerep_lib.Std.Typerep.t
val typename_of_string : Core_kernel__.Import.string Typerep_lib.Std.Typename.t
val bin_shape_bytes : Bin_prot.Shape.t
val bin_size_bytes : Core_kernel__.Import.bytes Bin_prot.Size.sizer
val bin_write_bytes : Core_kernel__.Import.bytes Bin_prot.Write.writer
val bin_writer_bytes : Core_kernel__.Import.bytes Bin_prot.Type_class.writer
val bin_read_bytes : Core_kernel__.Import.bytes Bin_prot.Read.reader
val __bin_read_bytes__ : (Core_kernel__.Import.int -> Core_kernel__.Import.bytes) Bin_prot.Read.reader
val bin_reader_bytes : Core_kernel__.Import.bytes Bin_prot.Type_class.reader
val bin_bytes : Core_kernel__.Import.bytes Bin_prot.Type_class.t
val compare_bytes : Core_kernel__.Import.bytes -> Core_kernel__.Import.bytes -> Core_kernel__.Import.int
val equal_bytes : Core_kernel__.Import.bytes -> Core_kernel__.Import.bytes -> Core_kernel__.Import.bool
val sexp_of_bytes : Core_kernel__.Import.bytes -> Ppx_sexp_conv_lib.Sexp.t
val bytes_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Core_kernel__.Import.bytes
val typerep_of_bytes : Core_kernel__.Import.bytes Typerep_lib.Std.Typerep.t
val typename_of_bytes : Core_kernel__.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_kernel__.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_kernel__.Import.int) -> 'a ref -> 'a ref -> Core_kernel__.Import.int
val equal_ref : ('a -> 'a -> Core_kernel__.Import.bool) -> 'a ref -> 'a ref -> Core_kernel__.Import.bool
val sexp_of_ref : ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a ref -> Ppx_sexp_conv_lib.Sexp.t
val ref_of_sexp : (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a ref
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_kernel__.Import.unit Bin_prot.Size.sizer
val bin_write_unit : Core_kernel__.Import.unit Bin_prot.Write.writer
val bin_writer_unit : Core_kernel__.Import.unit Bin_prot.Type_class.writer
val bin_read_unit : Core_kernel__.Import.unit Bin_prot.Read.reader
val __bin_read_unit__ : (Core_kernel__.Import.int -> Core_kernel__.Import.unit) Bin_prot.Read.reader
val bin_reader_unit : Core_kernel__.Import.unit Bin_prot.Type_class.reader
val bin_unit : Core_kernel__.Import.unit Bin_prot.Type_class.t
val compare_unit : Core_kernel__.Import.unit -> Core_kernel__.Import.unit -> Core_kernel__.Import.int
val equal_unit : Core_kernel__.Import.unit -> Core_kernel__.Import.unit -> Core_kernel__.Import.bool
val hash_fold_unit : Ppx_hash_lib.Std.Hash.state -> Core_kernel__.Import.unit -> Ppx_hash_lib.Std.Hash.state
val hash_unit : Core_kernel__.Import.unit -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_unit : Core_kernel__.Import.unit -> Ppx_sexp_conv_lib.Sexp.t
val unit_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Core_kernel__.Import.unit
val typerep_of_unit : Core_kernel__.Import.unit Typerep_lib.Std.Typerep.t
val typename_of_unit : Core_kernel__.Import.unit Typerep_lib.Std.Typename.t
type float_array = Core_kernel__.Import.float Core_kernel__.Import.array
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_kernel__.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_kernel__.Import.int
val sexp_of_float_array : float_array -> Ppx_sexp_conv_lib.Sexp.t
val float_array_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> float_array
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_kernel__.Import.Exn.t -> Base__.Ppx_sexp_conv_lib.Sexp.t
type 'a sexp_array = 'a Core_kernel__.Import.array
val bin_shape_sexp_array : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_sexp_array : 'a Bin_prot.Size.sizer -> 'a sexp_array Bin_prot.Size.sizer
val bin_write_sexp_array : 'a Bin_prot.Write.writer -> 'a sexp_array Bin_prot.Write.writer
val bin_writer_sexp_array : 'a Bin_prot.Type_class.writer -> 'a sexp_array Bin_prot.Type_class.writer
val __bin_read_sexp_array__ : 'a Bin_prot.Read.reader -> (Core_kernel__.Import.int -> 'a sexp_array) Bin_prot.Read.reader
val bin_read_sexp_array : 'a Bin_prot.Read.reader -> 'a sexp_array Bin_prot.Read.reader
val bin_reader_sexp_array : 'a Bin_prot.Type_class.reader -> 'a sexp_array Bin_prot.Type_class.reader
val bin_sexp_array : 'a Bin_prot.Type_class.t -> 'a sexp_array Bin_prot.Type_class.t
val compare_sexp_array : ('a -> 'a -> Core_kernel__.Import.int) -> 'a sexp_array -> 'a sexp_array -> Core_kernel__.Import.int
module Typename_of_sexp_array = Core_kernel__Std_internal.Typename_of_sexp_array
val typename_of_sexp_array : 'a Typerep_lib.Typename.t -> 'a sexp_array Typerep_lib.Typename.t
val typerep_of_sexp_array : 'a Typerep_lib.Std.Typerep.t -> 'a sexp_array Typerep_lib.Std.Typerep.t
type sexp_bool = Core_kernel__.Import.bool
val bin_shape_sexp_bool : Bin_prot.Shape.t
val bin_size_sexp_bool : sexp_bool Bin_prot.Size.sizer
val bin_write_sexp_bool : sexp_bool Bin_prot.Write.writer
val bin_writer_sexp_bool : sexp_bool Bin_prot.Type_class.writer
val __bin_read_sexp_bool__ : (Core_kernel__.Import.int -> sexp_bool) Bin_prot.Read.reader
val bin_read_sexp_bool : sexp_bool Bin_prot.Read.reader
val bin_reader_sexp_bool : sexp_bool Bin_prot.Type_class.reader
val bin_sexp_bool : sexp_bool Bin_prot.Type_class.t
val compare_sexp_bool : sexp_bool -> sexp_bool -> Core_kernel__.Import.int
val hash_fold_sexp_bool : Ppx_hash_lib.Std.Hash.state -> sexp_bool -> Ppx_hash_lib.Std.Hash.state
val hash_sexp_bool : sexp_bool -> Ppx_hash_lib.Std.Hash.hash_value
module Typename_of_sexp_bool = Core_kernel__Std_internal.Typename_of_sexp_bool
val typename_of_sexp_bool : sexp_bool Typerep_lib.Typename.t
val typerep_of_sexp_bool : sexp_bool Typerep_lib.Std.Typerep.t
type 'a sexp_list = 'a Core_kernel__.Import.list
val bin_shape_sexp_list : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_sexp_list : 'a Bin_prot.Size.sizer -> 'a sexp_list Bin_prot.Size.sizer
val bin_write_sexp_list : 'a Bin_prot.Write.writer -> 'a sexp_list Bin_prot.Write.writer
val bin_writer_sexp_list : 'a Bin_prot.Type_class.writer -> 'a sexp_list Bin_prot.Type_class.writer
val __bin_read_sexp_list__ : 'a Bin_prot.Read.reader -> (Core_kernel__.Import.int -> 'a sexp_list) Bin_prot.Read.reader
val bin_read_sexp_list : 'a Bin_prot.Read.reader -> 'a sexp_list Bin_prot.Read.reader
val bin_reader_sexp_list : 'a Bin_prot.Type_class.reader -> 'a sexp_list Bin_prot.Type_class.reader
val bin_sexp_list : 'a Bin_prot.Type_class.t -> 'a sexp_list Bin_prot.Type_class.t
val compare_sexp_list : ('a -> 'a -> Core_kernel__.Import.int) -> 'a sexp_list -> 'a sexp_list -> Core_kernel__.Import.int
val hash_fold_sexp_list : (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state) -> Ppx_hash_lib.Std.Hash.state -> 'a sexp_list -> Ppx_hash_lib.Std.Hash.state
module Typename_of_sexp_list = Core_kernel__Std_internal.Typename_of_sexp_list
val typename_of_sexp_list : 'a Typerep_lib.Typename.t -> 'a sexp_list Typerep_lib.Typename.t
val typerep_of_sexp_list : 'a Typerep_lib.Std.Typerep.t -> 'a sexp_list Typerep_lib.Std.Typerep.t
type 'a sexp_option = 'a Core_kernel__.Import.option
val bin_shape_sexp_option : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_sexp_option : 'a Bin_prot.Size.sizer -> 'a sexp_option Bin_prot.Size.sizer
val bin_write_sexp_option : 'a Bin_prot.Write.writer -> 'a sexp_option Bin_prot.Write.writer
val bin_writer_sexp_option : 'a Bin_prot.Type_class.writer -> 'a sexp_option Bin_prot.Type_class.writer
val __bin_read_sexp_option__ : 'a Bin_prot.Read.reader -> (Core_kernel__.Import.int -> 'a sexp_option) Bin_prot.Read.reader
val bin_read_sexp_option : 'a Bin_prot.Read.reader -> 'a sexp_option Bin_prot.Read.reader
val bin_reader_sexp_option : 'a Bin_prot.Type_class.reader -> 'a sexp_option Bin_prot.Type_class.reader
val bin_sexp_option : 'a Bin_prot.Type_class.t -> 'a sexp_option Bin_prot.Type_class.t
val compare_sexp_option : ('a -> 'a -> Core_kernel__.Import.int) -> 'a sexp_option -> 'a sexp_option -> Core_kernel__.Import.int
val hash_fold_sexp_option : (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state) -> Ppx_hash_lib.Std.Hash.state -> 'a sexp_option -> Ppx_hash_lib.Std.Hash.state
module Typename_of_sexp_option = Core_kernel__Std_internal.Typename_of_sexp_option
val typename_of_sexp_option : 'a Typerep_lib.Typename.t -> 'a sexp_option Typerep_lib.Typename.t
val typerep_of_sexp_option : 'a Typerep_lib.Std.Typerep.t -> 'a sexp_option Typerep_lib.Std.Typerep.t
type 'a sexp_opaque = 'a
val bin_shape_sexp_opaque : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_sexp_opaque : 'a Bin_prot.Size.sizer -> 'a sexp_opaque Bin_prot.Size.sizer
val bin_write_sexp_opaque : 'a Bin_prot.Write.writer -> 'a sexp_opaque Bin_prot.Write.writer
val bin_writer_sexp_opaque : 'a Bin_prot.Type_class.writer -> 'a sexp_opaque Bin_prot.Type_class.writer
val __bin_read_sexp_opaque__ : 'a Bin_prot.Read.reader -> (Core_kernel__.Import.int -> 'a sexp_opaque) Bin_prot.Read.reader
val bin_read_sexp_opaque : 'a Bin_prot.Read.reader -> 'a sexp_opaque Bin_prot.Read.reader
val bin_reader_sexp_opaque : 'a Bin_prot.Type_class.reader -> 'a sexp_opaque Bin_prot.Type_class.reader
val bin_sexp_opaque : 'a Bin_prot.Type_class.t -> 'a sexp_opaque Bin_prot.Type_class.t
val compare_sexp_opaque : ('a -> 'a -> Core_kernel__.Import.int) -> 'a sexp_opaque -> 'a sexp_opaque -> Core_kernel__.Import.int
val hash_fold_sexp_opaque : (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state) -> Ppx_hash_lib.Std.Hash.state -> 'a sexp_opaque -> Ppx_hash_lib.Std.Hash.state
module Typename_of_sexp_opaque = Core_kernel__Std_internal.Typename_of_sexp_opaque
val typename_of_sexp_opaque : 'a Typerep_lib.Typename.t -> 'a sexp_opaque Typerep_lib.Typename.t
val typerep_of_sexp_opaque : 'a Typerep_lib.Std.Typerep.t -> 'a sexp_opaque Typerep_lib.Std.Typerep.t
exception Not_found
exception Not_found_s of Sexplib0.Sexp.t
module Bigstring = Core__.Bigstring
module Caml = Core__.Caml
module Command = Core__.Command
module Condition = Core__.Core_condition
module Core_stable = Core__.Stable
module Date = Core__.Core_date
module Filename = Core__.Core_filename
module Interval = Core__.Interval
module Interval_intf = Core__.Interval_intf
module Iobuf = Core__.Iobuf
module Iobuf_debug = Core__.Iobuf_debug
module Iobuf_intf = Core__.Iobuf_intf
module Linux_ext = Core__.Linux_ext
module Digest = Md5
module Mutex = Core__.Core_mutex
module Signal = Core__.Signal
module Sys = Core__.Core_sys
module Thread = Core__.Core_thread
module Time = Core__.Core_time_float
module Time_common = Core__.Time_common
module Time_ns = Core__.Core_time_ns
module Time_stamp_counter = Core__.Time_stamp_counter
module Unix = Core__.Core_unix
module User_and_group = Core__.User_and_group
module Version_util = Core__.Version_util
val sec : Core_kernel__.Import.float -> Time.Span.t
val (^/) : Core_kernel__.Import.string -> Core_kernel__.Import.string -> Core_kernel__.Import.string
module Core_private = Core.Core_private
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