Module InferStdlib__IStd

include Core
module Std = Core__.Std0
module Applicative = Core_kernel__.Import.Applicative
module Avltree = Core_kernel__.Import.Avltree
module Backtrace = Core_kernel__.Import.Backtrace
module Bin_prot = Core_kernel__.Core_bin_prot
module Commutative_group = Core_kernel__.Import.Commutative_group
module Comparisons = Core_kernel__.Import.Comparisons
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 Hash = Core_kernel__.Import.Hash
module Heap_block = Core_kernel__.Import.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 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 = Core_kernel__.Import.Polymorphic_compare
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 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 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 Bigsubstring = Core_kernel__.Bigsubstring
module Binable = Core_kernel__.Binable
module Binary_packing = Core_kernel__.Binary_packing
module Blang = Core_kernel__.Blang
module Bounded_index = Core_kernel__.Bounded_index
module Bounded_int_table = Core_kernel__.Bounded_int_table
module Bucket = Core_kernel__.Bucket
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 Fheap = Core_kernel__.Fheap
module Flags = Core_kernel__.Flags
module Float_with_finite_only_serialization = Core_kernel__.Float_with_finite_only_serialization
module Force_once = Core_kernel__.Force_once
module Fqueue = Core_kernel__.Fqueue
module Gc = Core_kernel__.Gc
module Hash_heap = Core_kernel__.Hash_heap
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 Int_set = Core_kernel__.Int_set
module Interfaces = Core_kernel__.Interfaces
module Limiter = Core_kernel__.Limiter
module Linked_stack = Core_kernel__.Linked_stack
module Map = Core_kernel__.Map
module Memo = Core_kernel__.Memo
module Month = Core_kernel__.Month
module Moption = Core_kernel__.Moption
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 Pid = Core_kernel__.Pid
module Pool = Core_kernel__.Pool
module Pool_intf = Core_kernel__.Pool_intf
module Pooled_hashtbl = Core_kernel__.Pooled_hashtbl
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 Rope = Core_kernel__.Rope
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 Thread_safe_queue = Core_kernel__.Thread_safe_queue
module Timing_wheel_ns = Core_kernel__.Timing_wheel_ns
module Total_map = Core_kernel__.Total_map
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 Unpack_buffer = Core_kernel__.Unpack_buffer
module Validated = Core_kernel__.Validated
module Weak = Core_kernel__.Weak
module Weak_pointer = Core_kernel__.Weak_pointer
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
type bytes = [
| `This_type_does_not_equal_string_because_we_want_type_errors_to_say_string
]
val am_running_inline_test : bool
external raise : exn ‑> 'a = "%reraise"
external raise_notrace : exn ‑> 'a = "%raise_notrace"
val invalid_arg : string ‑> 'a
val failwith : string ‑> 'a
exception Exit
external (=) : 'a ‑> 'a ‑> bool = "%equal"
external (<>) : 'a ‑> 'a ‑> bool = "%notequal"
external (<) : 'a ‑> 'a ‑> bool = "%lessthan"
external (>) : 'a ‑> 'a ‑> bool = "%greaterthan"
external (<=) : 'a ‑> 'a ‑> bool = "%lessequal"
external (>=) : 'a ‑> 'a ‑> bool = "%greaterequal"
external compare : 'a ‑> 'a ‑> int = "%compare"
val min : 'a ‑> 'a ‑> 'a
val max : 'a ‑> 'a ‑> 'a
external (==) : 'a ‑> 'a ‑> bool = "%eq"
  • Deprecated [since 2014-10] Use [phys_equal]
external (!=) : 'a ‑> 'a ‑> bool = "%noteq"
  • Deprecated [since 2014-10] Use [phys_equal]
external not : bool ‑> bool = "%boolnot"
external (&&) : bool ‑> bool ‑> bool = "%sequand"
external (&) : bool ‑> bool ‑> bool = "%sequand"
  • Deprecated [since 2010-01] {!Pervasives.( && )} should be used instead.
external (||) : bool ‑> bool ‑> bool = "%sequor"
external or : bool ‑> bool ‑> bool = "%sequor"
  • Deprecated [since 2010-01] {!Pervasives.( || )} should be used instead.
external __LOC__ : string = "%loc_LOC"
external __FILE__ : string = "%loc_FILE"
external __LINE__ : int = "%loc_LINE"
external __MODULE__ : string = "%loc_MODULE"
external __POS__ : string * int * int * int = "%loc_POS"
external __LOC_OF__ : 'a ‑> string * 'a = "%loc_LOC"
external __LINE_OF__ : 'a ‑> int * 'a = "%loc_LINE"
external __POS_OF__ : 'a ‑> (string * int * int * int) * 'a = "%loc_POS"
external (|>) : 'a ‑> ('a ‑> 'b) ‑> 'b = "%revapply"
external (@@) : ('a ‑> 'b) ‑> 'a ‑> 'b = "%apply"
external (~-) : int ‑> int = "%negint"
external (~+) : int ‑> int = "%identity"
external succ : int ‑> int = "%succint"
external pred : int ‑> int = "%predint"
external (+) : int ‑> int ‑> int = "%addint"
external (-) : int ‑> int ‑> int = "%subint"
external (*) : int ‑> int ‑> int = "%mulint"
external (/) : int ‑> int ‑> int = "%divint"
external (mod) : int ‑> int ‑> int = "%modint"
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]
external (land) : int ‑> int ‑> int = "%andint"
external (lor) : int ‑> int ‑> int = "%orint"
external (lxor) : int ‑> int ‑> int = "%xorint"
val (lnot) : int ‑> int
external (lsl) : int ‑> int ‑> int = "%lslint"
external (lsr) : int ‑> int ‑> int = "%lsrint"
external (asr) : int ‑> int ‑> int = "%asrint"
external (~-.) : float ‑> float = "%negfloat"
external (~+.) : float ‑> float = "%identity"
external (+.) : float ‑> float ‑> float = "%addfloat"
external (-.) : float ‑> float ‑> float = "%subfloat"
external (*.) : float ‑> float ‑> float = "%mulfloat"
external (/.) : float ‑> float ‑> float = "%divfloat"
external (**) : float ‑> float ‑> float = "caml_power_float" "pow"
external sqrt : float ‑> float = "caml_sqrt_float" "sqrt"
external exp : float ‑> float = "caml_exp_float" "exp"
external log : float ‑> float = "caml_log_float" "log"
external log10 : float ‑> float = "caml_log10_float" "log10"
  • Deprecated [since 2016-07] Use [Float.log10]
external expm1 : float ‑> float = "caml_expm1_float" "caml_expm1"
  • Deprecated [since 2016-07] Use [Float.expm1]
external log1p : float ‑> float = "caml_log1p_float" "caml_log1p"
  • Deprecated [since 2016-07] Use [Float.log1p]
external cos : float ‑> float = "caml_cos_float" "cos"
  • Deprecated [since 2016-07] Use [Float.cos]
external sin : float ‑> float = "caml_sin_float" "sin"
  • Deprecated [since 2016-07] Use [Float.sin]
external tan : float ‑> float = "caml_tan_float" "tan"
  • Deprecated [since 2016-07] Use [Float.tan]
external acos : float ‑> float = "caml_acos_float" "acos"
  • Deprecated [since 2016-07] Use [Float.acos]
external asin : float ‑> float = "caml_asin_float" "asin"
  • Deprecated [since 2016-07] Use [Float.asin]
external atan : float ‑> float = "caml_atan_float" "atan"
  • Deprecated [since 2016-07] Use [Float.atan]
external atan2 : float ‑> float ‑> float = "caml_atan2_float" "atan2"
  • Deprecated [since 2016-07] Use [Float.atan2]
external hypot : float ‑> float ‑> float = "caml_hypot_float" "caml_hypot"
  • Deprecated [since 2016-07] Use [Float.hypot]
external cosh : float ‑> float = "caml_cosh_float" "cosh"
  • Deprecated [since 2016-07] Use [Float.cosh]
external sinh : float ‑> float = "caml_sinh_float" "sinh"
  • Deprecated [since 2016-07] Use [Float.sinh]
external tanh : float ‑> float = "caml_tanh_float" "tanh"
  • Deprecated [since 2016-07] Use [Float.tanh]
external ceil : float ‑> float = "caml_ceil_float" "ceil"
  • Deprecated [since 2014-10] Use [Float.round_up]
external floor : float ‑> float = "caml_floor_float" "floor"
  • Deprecated [since 2014-10] Use [Float.round_down]
external abs_float : float ‑> float = "%absfloat"
  • Deprecated [since 2014-10] Use [Float.abs]
external copysign : float ‑> float ‑> float = "caml_copysign_float" "caml_copysign"
  • Deprecated [since 2016-07] Use [Float.copysign]
external mod_float : float ‑> float ‑> float = "caml_fmod_float" "fmod"
  • Deprecated [since 2014-10] Use [Float.mod_float]
external frexp : float ‑> float * int = "caml_frexp_float"
  • Deprecated [since 2014-10] Use [Float.frexp]
external ldexp : float ‑> int ‑> float = "caml_ldexp_float" "caml_ldexp_float_unboxed"
  • Deprecated [since 2014-10] Use [Float.ldexp]
external modf : float ‑> float * float = "caml_modf_float"
  • Deprecated [since 2014-10] Use [Float.modf]
external float : int ‑> float = "%floatofint"
external float_of_int : int ‑> float = "%floatofint"
external truncate : float ‑> int = "%intoffloat"
  • Deprecated [since 2014-10] Use [Float.iround_towards_zero_exn]
external int_of_float : float ‑> int = "%intoffloat"
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 = Pervasives.fpclass =
| FP_normal
| FP_subnormal
| FP_zero
| FP_infinite
| FP_nan
external classify_float : float ‑> fpclass = "caml_classify_float" "caml_classify_float_unboxed"
  • Deprecated [since 2014-10] Use [Float.classify]
val (^) : string ‑> string ‑> string
external int_of_char : char ‑> int = "%identity"
val char_of_int : int ‑> char
external ignore : 'a ‑> unit = "%ignore"
val string_of_bool : bool ‑> string
val bool_of_string : string ‑> bool
val string_of_int : int ‑> string
external int_of_string : string ‑> int = "caml_int_of_string"
val string_of_float : float ‑> string
external float_of_string : string ‑> float = "caml_float_of_string"
external fst : ('a * 'b) ‑> 'a = "%field0"
external snd : ('a * 'b) ‑> 'b = "%field1"
type in_channel = Pervasives.in_channel
  • Deprecated [since 2016-04] Use [In_channel.t]
type out_channel = Pervasives.out_channel
  • Deprecated [since 2016-04] Use [Out_channel.t]
val stdin : Pervasives.in_channel
  • Deprecated [since 2016-04] Use [In_channel.stdin]
val stdout : Pervasives.out_channel
val stderr : Pervasives.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 = Pervasives.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 ‑> Pervasives.out_channel
  • Deprecated [since 2016-04] Use [Out_channel.create]
val open_out_bin : string ‑> Pervasives.out_channel
  • Deprecated [since 2016-04] Use [Out_channel.create]
val open_out_gen : Pervasives.open_flag list ‑> int ‑> string ‑> Pervasives.out_channel
  • Deprecated [since 2016-04] Use [Out_channel.create]
val flush : Pervasives.out_channel ‑> unit
  • Deprecated [since 2016-04] Use [Out_channel.flush]
val flush_all : unit ‑> unit
  • Deprecated [since 2016-04]
val output_char : Pervasives.out_channel ‑> char ‑> unit
  • Deprecated [since 2016-04] Use [Out_channel.output_char]
val output_string : Pervasives.out_channel ‑> string ‑> unit
  • Deprecated [since 2016-04] Use [Out_channel.output_string]
val output_bytes : Pervasives.out_channel ‑> bytes ‑> unit
  • Deprecated [since 2016-04] Core doesn't yet support bytes.
val output : Pervasives.out_channel ‑> bytes ‑> int ‑> int ‑> unit
  • Deprecated [since 2016-04] Core doesn't yet support bytes.
val output_substring : Pervasives.out_channel ‑> string ‑> int ‑> int ‑> unit
  • Deprecated [since 2016-04] Use [Out_channel.output]
val output_byte : Pervasives.out_channel ‑> int ‑> unit
  • Deprecated [since 2016-04] Use [Out_channel.output_byte]
val output_binary_int : Pervasives.out_channel ‑> int ‑> unit
  • Deprecated [since 2016-04] Use [Out_channel.output_binary_int]
val output_value : Pervasives.out_channel ‑> 'a ‑> unit
  • Deprecated [since 2016-04] Use [Out_channel.output_value]
val seek_out : Pervasives.out_channel ‑> int ‑> unit
  • Deprecated [since 2014-10] Use [Out_channel.seek]
val pos_out : Pervasives.out_channel ‑> int
  • Deprecated [since 2014-10] Use [Out_channel.pos]
val out_channel_length : Pervasives.out_channel ‑> int
  • Deprecated [since 2014-10] Use [Out_channel.length]
val close_out : Pervasives.out_channel ‑> unit
  • Deprecated [since 2014-10] Use [Out_channel.close]
val close_out_noerr : Pervasives.out_channel ‑> unit
  • Deprecated [since 2016-04] Use [Out_channel.close] and catch exceptions
val set_binary_mode_out : Pervasives.out_channel ‑> bool ‑> unit
  • Deprecated [since 2016-04] Use [Out_channel.set_binary_mode]
val open_in : string ‑> Pervasives.in_channel
  • Deprecated [since 2016-04] Use [In_channel.create]
val open_in_bin : string ‑> Pervasives.in_channel
  • Deprecated [since 2016-04] Use [In_channel.create]
val open_in_gen : Pervasives.open_flag list ‑> int ‑> string ‑> Pervasives.in_channel
  • Deprecated [since 2016-04] Use [In_channel.create]
val input_char : Pervasives.in_channel ‑> char
  • Deprecated [since 2016-04] Use [In_channel.input_char]
val input_line : Pervasives.in_channel ‑> string
  • Deprecated [since 2016-04] Use [In_channel.input_line]
val input : Pervasives.in_channel ‑> bytes ‑> int ‑> int ‑> int
  • Deprecated [since 2016-04] Core doesn't yet support bytes.
val really_input : Pervasives.in_channel ‑> bytes ‑> int ‑> int ‑> unit
  • Deprecated [since 2016-04] Core doesn't yet support bytes.
val really_input_string : Pervasives.in_channel ‑> int ‑> string
  • Deprecated [since 2016-04] Use [In_channel.really_input_exn ~pos:0]
val input_byte : Pervasives.in_channel ‑> int
  • Deprecated [since 2016-04] Use [In_channel.input_byte]
val input_binary_int : Pervasives.in_channel ‑> int
  • Deprecated [since 2016-04] Use [In_channel.input_binary_int]
val input_value : Pervasives.in_channel ‑> 'a
  • Deprecated [since 2016-04] Use [In_channel.unsafe_input_value]
val seek_in : Pervasives.in_channel ‑> int ‑> unit
  • Deprecated [since 2014-10] Use [In_channel.seek]
val pos_in : Pervasives.in_channel ‑> int
  • Deprecated [since 2014-10] Use [In_channel.pos]
val in_channel_length : Pervasives.in_channel ‑> int
  • Deprecated [since 2014-10] Use [In_channel.length]
val close_in : Pervasives.in_channel ‑> unit
  • Deprecated [since 2014-10] Use [In_channel.close]
val close_in_noerr : Pervasives.in_channel ‑> unit
  • Deprecated [since 2016-04] Use [In_channel.close] and catch exceptions
val set_binary_mode_in : Pervasives.in_channel ‑> bool ‑> unit
  • Deprecated [since 2016-04] Use [In_channel.set_binary_mode]
module LargeFile = Core_kernel__Core_pervasives.LargeFile
type 'a ref = 'a Pervasives.ref = {
mutable contents : 'a;
}
external ref : 'a ‑> 'a ref = "%makemutable"
external (!) : 'a ref ‑> 'a = "%field0"
external (:=) : 'a ref ‑> 'a ‑> unit = "%setfield0"
external incr : int ref ‑> unit = "%incr"
external decr : int ref ‑> unit = "%decr"
type ('a, 'b) result = ('a, 'b) Pervasives.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
external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 ‑> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity"
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
  • Deprecated [since 2015-11] Do not use.
val unsafe_really_input : Pervasives.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 (|!) : 'a ‑> ('a ‑> 'b) ‑> 'b
  • Deprecated [since 2016-07] Use [ |> ]
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 bigstring_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> bigstring
val sexp_of_bigstring : bigstring ‑> Ppx_sexp_conv_lib.Sexp.t
type mat = Sexplib.Conv.mat
val mat_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> mat
val sexp_of_mat : mat ‑> Ppx_sexp_conv_lib.Sexp.t
type vec = Sexplib.Conv.vec
val vec_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> vec
val sexp_of_vec : vec ‑> Ppx_sexp_conv_lib.Sexp.t
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 = Base__Ordering.t =
| Less
| Equal
| Greater
type read = Core_kernel__Perms.Read.t
val bin_read : read Bin_prot.Type_class.t
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_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_shape_read : Bin_prot.Shape.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 read_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> read
val sexp_of_read : read ‑> Ppx_sexp_conv_lib.Sexp.t
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 write_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> write
val sexp_of_write : write ‑> Ppx_sexp_conv_lib.Sexp.t
type immutable = Core_kernel__Perms.Immutable.t
val bin_immutable : immutable Bin_prot.Type_class.t
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_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_shape_immutable : Bin_prot.Shape.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 immutable_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> immutable
val sexp_of_immutable : immutable ‑> Ppx_sexp_conv_lib.Sexp.t
type read_write = Core_kernel__Perms.Read_write.t
val bin_read_write : read_write Bin_prot.Type_class.t
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_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_shape_read_write : Bin_prot.Shape.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 read_write_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> read_write
val sexp_of_read_write : read_write ‑> Ppx_sexp_conv_lib.Sexp.t
type 'a perms = 'a Core_kernel__Perms.Upper_bound.t
val bin_perms : 'a Bin_prot.Type_class.t ‑> 'a perms Bin_prot.Type_class.t
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_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_shape_perms : Bin_prot.Shape.t ‑> Bin_prot.Shape.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 perms_of_sexp : (Ppx_sexp_conv_lib.Sexp.t ‑> 'a) ‑> Ppx_sexp_conv_lib.Sexp.t ‑> 'a perms
val sexp_of_perms : ('a ‑> Ppx_sexp_conv_lib.Sexp.t) ‑> 'a perms ‑> Ppx_sexp_conv_lib.Sexp.t
type ('ok, 'err) _result = ('ok, 'err) Base__Result.t =
| Ok of 'ok
| Error of 'err
val is_ok : ('a, 'b) Base__Result.t ‑> bool
val is_error : ('a, 'b) Base__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 print_s : ?⁠mach:unit ‑> Core_kernel__.Sexp.t ‑> unit
val bprintf : Base__.Import0.Caml.Buffer.t ‑> ('a, Base__.Import0.Caml.Buffer.t, unit) Pervasives.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) Pervasives.format4 ‑> 'a
val failwithp : ?⁠strict:Core_kernel__.Import.unit ‑> Lexing.position ‑> Core_kernel__.Import.string ‑> 'a ‑> ('a ‑> Base.Sexp.t) ‑> 'b
val failwiths : ?⁠strict:Core_kernel__.Import.unit ‑> ?⁠here: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) Pervasives.format4 ‑> 'a
val ifprintf : 'a ‑> ('b, 'a, 'c, unit) Pervasives.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) Pervasives.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 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 sprintf : ('a, unit, string) Pervasives.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 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_array : 'a Bin_prot.Type_class.t ‑> 'a Core_kernel__.Import.array Bin_prot.Type_class.t
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_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_shape_array : Bin_prot.Shape.t ‑> Bin_prot.Shape.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 array_of_sexp : (Ppx_sexp_conv_lib.Sexp.t ‑> 'a) ‑> Ppx_sexp_conv_lib.Sexp.t ‑> 'a Core_kernel__.Import.array
val sexp_of_array : ('a ‑> Ppx_sexp_conv_lib.Sexp.t) ‑> 'a Core_kernel__.Import.array ‑> Ppx_sexp_conv_lib.Sexp.t
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_bool : Core_kernel__.Import.bool Bin_prot.Type_class.t
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_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_shape_bool : Bin_prot.Shape.t
val compare_bool : Core_kernel__.Import.bool ‑> Core_kernel__.Import.bool ‑> Core_kernel__.Import.int
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 bool_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> Core_kernel__.Import.bool
val sexp_of_bool : Core_kernel__.Import.bool ‑> Ppx_sexp_conv_lib.Sexp.t
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_char : Core_kernel__.Import.char Bin_prot.Type_class.t
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_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_shape_char : Bin_prot.Shape.t
val compare_char : Core_kernel__.Import.char ‑> Core_kernel__.Import.char ‑> Core_kernel__.Import.int
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 char_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> Core_kernel__.Import.char
val sexp_of_char : Core_kernel__.Import.char ‑> Ppx_sexp_conv_lib.Sexp.t
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_float : Core_kernel__.Import.float Bin_prot.Type_class.t
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_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_shape_float : Bin_prot.Shape.t
val compare_float : Core_kernel__.Import.float ‑> Core_kernel__.Import.float ‑> Core_kernel__.Import.int
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 float_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> Core_kernel__.Import.float
val sexp_of_float : Core_kernel__.Import.float ‑> Ppx_sexp_conv_lib.Sexp.t
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_int : Core_kernel__.Import.int Bin_prot.Type_class.t
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_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_shape_int : Bin_prot.Shape.t
val compare_int : Core_kernel__.Import.int ‑> Core_kernel__.Import.int ‑> Core_kernel__.Import.int
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 int_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> Core_kernel__.Import.int
val sexp_of_int : Core_kernel__.Import.int ‑> Ppx_sexp_conv_lib.Sexp.t
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_int32 : Core_kernel__.Import.int32 Bin_prot.Type_class.t
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_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_shape_int32 : Bin_prot.Shape.t
val compare_int32 : Core_kernel__.Import.int32 ‑> Core_kernel__.Import.int32 ‑> Core_kernel__.Import.int
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 int32_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> Core_kernel__.Import.int32
val sexp_of_int32 : Core_kernel__.Import.int32 ‑> Ppx_sexp_conv_lib.Sexp.t
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_int64 : Core_kernel__.Import.int64 Bin_prot.Type_class.t
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_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_shape_int64 : Bin_prot.Shape.t
val compare_int64 : Core_kernel__.Import.int64 ‑> Core_kernel__.Import.int64 ‑> Core_kernel__.Import.int
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 int64_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> Core_kernel__.Import.int64
val sexp_of_int64 : Core_kernel__.Import.int64 ‑> Ppx_sexp_conv_lib.Sexp.t
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_lazy_t : 'a Bin_prot.Type_class.t ‑> 'a lazy_t Bin_prot.Type_class.t
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_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_shape_lazy_t : Bin_prot.Shape.t ‑> Bin_prot.Shape.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 lazy_t_of_sexp : (Ppx_sexp_conv_lib.Sexp.t ‑> 'a) ‑> Ppx_sexp_conv_lib.Sexp.t ‑> 'a lazy_t
val sexp_of_lazy_t : ('a ‑> Ppx_sexp_conv_lib.Sexp.t) ‑> 'a lazy_t ‑> Ppx_sexp_conv_lib.Sexp.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_list : 'a Bin_prot.Type_class.t ‑> 'a Core_kernel__.Import.list Bin_prot.Type_class.t
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_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_shape_list : Bin_prot.Shape.t ‑> Bin_prot.Shape.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 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 list_of_sexp : (Ppx_sexp_conv_lib.Sexp.t ‑> 'a) ‑> Ppx_sexp_conv_lib.Sexp.t ‑> 'a Core_kernel__.Import.list
val sexp_of_list : ('a ‑> Ppx_sexp_conv_lib.Sexp.t) ‑> 'a Core_kernel__.Import.list ‑> Ppx_sexp_conv_lib.Sexp.t
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_nativeint : Core_kernel__.Import.nativeint Bin_prot.Type_class.t
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_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_shape_nativeint : Bin_prot.Shape.t
val compare_nativeint : Core_kernel__.Import.nativeint ‑> Core_kernel__.Import.nativeint ‑> Core_kernel__.Import.int
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 nativeint_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> Core_kernel__.Import.nativeint
val sexp_of_nativeint : Core_kernel__.Import.nativeint ‑> Ppx_sexp_conv_lib.Sexp.t
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_option : 'a Bin_prot.Type_class.t ‑> 'a Core_kernel__.Import.option Bin_prot.Type_class.t
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_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_shape_option : Bin_prot.Shape.t ‑> Bin_prot.Shape.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 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 option_of_sexp : (Ppx_sexp_conv_lib.Sexp.t ‑> 'a) ‑> Ppx_sexp_conv_lib.Sexp.t ‑> 'a Core_kernel__.Import.option
val sexp_of_option : ('a ‑> Ppx_sexp_conv_lib.Sexp.t) ‑> 'a Core_kernel__.Import.option ‑> Ppx_sexp_conv_lib.Sexp.t
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_string : Core_kernel__.Import.string Bin_prot.Type_class.t
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_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_shape_string : Bin_prot.Shape.t
val compare_string : Core_kernel__.Import.string ‑> Core_kernel__.Import.string ‑> Core_kernel__.Import.int
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 string_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> Core_kernel__.Import.string
val sexp_of_string : Core_kernel__.Import.string ‑> Ppx_sexp_conv_lib.Sexp.t
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_bytes : Core_kernel__.Import.bytes Bin_prot.Type_class.t
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_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_shape_bytes : Bin_prot.Shape.t
val compare_bytes : Core_kernel__.Import.bytes ‑> Core_kernel__.Import.bytes ‑> Core_kernel__.Import.int
val bytes_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> Core_kernel__.Import.bytes
val sexp_of_bytes : Core_kernel__.Import.bytes ‑> Ppx_sexp_conv_lib.Sexp.t
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_ref : 'a Bin_prot.Type_class.t ‑> 'a ref Bin_prot.Type_class.t
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_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_shape_ref : Bin_prot.Shape.t ‑> Bin_prot.Shape.t
val compare_ref : ('a ‑> 'a ‑> Core_kernel__.Import.int) ‑> 'a ref ‑> 'a ref ‑> Core_kernel__.Import.int
val ref_of_sexp : (Ppx_sexp_conv_lib.Sexp.t ‑> 'a) ‑> Ppx_sexp_conv_lib.Sexp.t ‑> 'a ref
val sexp_of_ref : ('a ‑> Ppx_sexp_conv_lib.Sexp.t) ‑> 'a ref ‑> Ppx_sexp_conv_lib.Sexp.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_unit : Core_kernel__.Import.unit Bin_prot.Type_class.t
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_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_shape_unit : Bin_prot.Shape.t
val compare_unit : Core_kernel__.Import.unit ‑> Core_kernel__.Import.unit ‑> Core_kernel__.Import.int
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 unit_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> Core_kernel__.Import.unit
val sexp_of_unit : Core_kernel__.Import.unit ‑> Ppx_sexp_conv_lib.Sexp.t
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_float_array : float_array Bin_prot.Type_class.t
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_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_shape_float_array : Bin_prot.Shape.t
val compare_float_array : float_array ‑> float_array ‑> Core_kernel__.Import.int
val float_array_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> float_array
val sexp_of_float_array : float_array ‑> Ppx_sexp_conv_lib.Sexp.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_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 Core_kernel__.Import.array ‑> int
val bin_write_sexp_array : 'a Bin_prot.Write.writer ‑> Bin_prot.Common.buf ‑> pos:Bin_prot.Common.pos ‑> 'a Core_kernel__.Import.array ‑> Bin_prot.Common.pos
val bin_writer_sexp_array : 'a Bin_prot.Type_class.writer ‑> 'a Core_kernel__.Import.array Bin_prot.Type_class.writer
val __bin_read_sexp_array__ : 'a Bin_prot.Read.reader ‑> Bin_prot.Common.buf ‑> pos_ref:Bin_prot.Common.pos_ref ‑> Core_kernel__.Import.int ‑> 'a Core_kernel__.Import.array
val bin_read_sexp_array : 'a Bin_prot.Read.reader ‑> Bin_prot.Common.buf ‑> pos_ref:Bin_prot.Common.pos_ref ‑> 'a Core_kernel__.Import.array
val bin_reader_sexp_array : 'a Bin_prot.Type_class.reader ‑> 'a Core_kernel__.Import.array Bin_prot.Type_class.reader
val bin_sexp_array : 'a Bin_prot.Type_class.t ‑> 'a Core_kernel__.Import.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 : Core_kernel__.Import.bool Bin_prot.Size.sizer
val bin_write_sexp_bool : Core_kernel__.Import.bool Bin_prot.Write.writer
val bin_writer_sexp_bool : Core_kernel__.Import.bool Bin_prot.Type_class.writer
val __bin_read_sexp_bool__ : (Core_kernel__.Import.int ‑> Core_kernel__.Import.bool) Bin_prot.Read.reader
val bin_read_sexp_bool : Core_kernel__.Import.bool Bin_prot.Read.reader
val bin_reader_sexp_bool : Core_kernel__.Import.bool Bin_prot.Type_class.reader
val bin_sexp_bool : Core_kernel__.Import.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 Core_kernel__.Import.list ‑> int
val bin_write_sexp_list : 'a Bin_prot.Write.writer ‑> Bin_prot.Common.buf ‑> pos:Bin_prot.Common.pos ‑> 'a Core_kernel__.Import.list ‑> Bin_prot.Common.pos
val bin_writer_sexp_list : 'a Bin_prot.Type_class.writer ‑> 'a Core_kernel__.Import.list Bin_prot.Type_class.writer
val __bin_read_sexp_list__ : 'a Bin_prot.Read.reader ‑> Bin_prot.Common.buf ‑> pos_ref:Bin_prot.Common.pos_ref ‑> Core_kernel__.Import.int ‑> 'a Core_kernel__.Import.list
val bin_read_sexp_list : 'a Bin_prot.Read.reader ‑> Bin_prot.Common.buf ‑> pos_ref:Bin_prot.Common.pos_ref ‑> 'a Core_kernel__.Import.list
val bin_reader_sexp_list : 'a Bin_prot.Type_class.reader ‑> 'a Core_kernel__.Import.list Bin_prot.Type_class.reader
val bin_sexp_list : 'a Bin_prot.Type_class.t ‑> 'a Core_kernel__.Import.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 Core_kernel__.Import.option ‑> int
val bin_write_sexp_option : 'a Bin_prot.Write.writer ‑> Bin_prot.Common.buf ‑> pos:Bin_prot.Common.pos ‑> 'a Core_kernel__.Import.option ‑> Bin_prot.Common.pos
val bin_writer_sexp_option : 'a Bin_prot.Type_class.writer ‑> 'a Core_kernel__.Import.option Bin_prot.Type_class.writer
val __bin_read_sexp_option__ : 'a Bin_prot.Read.reader ‑> Bin_prot.Common.buf ‑> pos_ref:Bin_prot.Common.pos_ref ‑> Core_kernel__.Import.int ‑> 'a Core_kernel__.Import.option
val bin_read_sexp_option : 'a Bin_prot.Read.reader ‑> Bin_prot.Common.buf ‑> pos_ref:Bin_prot.Common.pos_ref ‑> 'a Core_kernel__.Import.option
val bin_reader_sexp_option : 'a Bin_prot.Type_class.reader ‑> 'a Core_kernel__.Import.option Bin_prot.Type_class.reader
val bin_sexp_option : 'a Bin_prot.Type_class.t ‑> 'a Core_kernel__.Import.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 ‑> 'a
val bin_write_sexp_opaque : 'a ‑> 'a
val bin_writer_sexp_opaque : 'a Bin_prot.Type_class.writer ‑> 'a Bin_prot.Type_class.writer
val __bin_read_sexp_opaque__ : 'a ‑> 'b ‑> pos_ref:Bin_prot.Common.pos ref ‑> 'c ‑> 'd
val bin_read_sexp_opaque : 'a ‑> 'a
val bin_reader_sexp_opaque : 'a Bin_prot.Type_class.reader ‑> 'a Bin_prot.Type_class.reader
val bin_sexp_opaque : 'a Bin_prot.Type_class.t ‑> 'a 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
  • 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
module Bigbuffer = Core__.Bigbuffer
module Bigstring = Core__.Bigstring
module Bigstring_marshal = Core__.Bigstring_marshal
module Caml = Core__.Caml
module Command = Core__.Command
module Condition = Core__.Core_condition
module Core_stable = Core__.Stable
module Crc = Core__.Crc
module Daemon = Core__.Daemon
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 Lock_file = Core__.Lock_file
module Mac_address = Core__.Mac_address
module Md5 = Core__.Md5
module Digest = Md5
module Mutex = Core__.Core_mutex
module Nano_mutex = Core__.Nano_mutex
module Piecewise_linear = Core__.Piecewise_linear
module Process_env = Core__.Process_env
module Schedule_v4_deprecated = Core__.Schedule_v4_deprecated
module Schedule_v5 = Core__.Schedule_v5
module Signal = Core__.Signal
module Squeue = Core__.Squeue
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 Timing_wheel_float = Core__.Timing_wheel_float
module Unix = Core__.Core_unix
module User_and_group = Core__.User_and_group
module Uuid = Core__.Uuid
module Version_util = Core__.Version_util
module Weak_hashtbl = Core__.Weak_hashtbl
val sec : Core_kernel__.Import.float ‑> Time.Span.t
val (^/) : string ‑> string ‑> string
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