Module IStdlib.IStd

include module type of struct include Core end
module Applicative : sig ... end
module Arg : sig ... end
module Array : sig ... end
module Avltree : sig ... end
module Backtrace : sig ... end
module Bag : sig ... end
module Bigbuffer : sig ... end
module Bigstring : sig ... end
module Bigsubstring : sig ... end
module Bin_prot : sig ... end
module Binable : sig ... end
module Binary_searchable : sig ... end
module Blang : sig ... end
module Blit : sig ... end
module Bool : sig ... end
module Bounded_index : sig ... end
module Buffer = Base.Buffer
module Byte_units : sig ... end
module Bytes : sig ... end
module Caml = Core.Caml
module Char : sig ... end
module Command : sig ... end
module Comparable : sig ... end
module Comparator : sig ... end
module Comparisons : sig ... end
module Container : sig ... end
module Container_intf : sig ... end
module Continue_or_stop : sig ... end
module Core_kernel_stable : sig ... end
module Core_stable : sig ... end
module Date : sig ... end
module Day_of_week : sig ... end
module Debug : sig ... end
module Deque : sig ... end
module Deriving_hash : sig ... end
module Digest : sig ... end
module Doubly_linked : sig ... end
module Either : sig ... end
module Ephemeron : sig ... end
module Equal : sig ... end
module Error : sig ... end
module Exn = Base.Exn
module Expect_test_config = Expect_test_config
module Fdeque : sig ... end
module Field : sig ... end
module Float : sig ... end
module Float_with_finite_only_serialization : sig ... end
module Floatable : sig ... end
module Fn : sig ... end
module Formatter : sig ... end
module Fqueue : sig ... end
module Gc : sig ... end
module Hash : sig ... end
module Hash_queue : sig ... end
module Hash_set : sig ... end
module Hashable : sig ... end
module Hashtbl : sig ... end
module Hashtbl_intf : sig ... end
module Heap_block : sig ... end
module Hexdump : sig ... end
module Hexdump_intf : sig ... end
module Host_and_port : sig ... end
module Identifiable : sig ... end
module Immediate_option : sig ... end
module Immediate_option_intf : sig ... end
module In_channel : sig ... end
module Indexed_container : sig ... end
module Info : sig ... end
module Int : sig ... end
module Int32 : sig ... end
module Int63 : sig ... end
module Int64 : sig ... end
module Int_conversions : sig ... end
module Int_intf : sig ... end
module Int_math : sig ... end
module Intable : sig ... end
module Interfaces : sig ... end
module Invariant : sig ... end
module Lazy : sig ... end
module Linked_queue : sig ... end
module List : sig ... end
module Map : sig ... end
module Map_intf : sig ... end
module Maybe_bound : sig ... end
module Md5 : sig ... end
module Memo : sig ... end
module Monad : sig ... end
module Month : sig ... end
module Mutex = Core.Mutex
module Nativeint : sig ... end
module No_polymorphic_compare : sig ... end
module Nothing : sig ... end
module Only_in_test : sig ... end
module Option : sig ... end
module Option_array : sig ... end
module Optional_syntax : sig ... end
module Optional_syntax_intf : sig ... end
module Or_error : sig ... end
module Ordered_collection_common : sig ... end
module Ordering : sig ... end
module Out_channel : sig ... end
module Percent : sig ... end
module Perms : sig ... end
module Pid : sig ... end
module Poly : sig ... end
module Polymorphic_compare = Poly
module Popcount = Base.Popcount
module Pretty_printer : sig ... end
module Printexc : sig ... end
module Printf : sig ... end
module Queue : sig ... end
module Quickcheck : sig ... end
module Quickcheck_intf : sig ... end
module Quickcheckable : sig ... end
module Random = Base.Random
module Ref : sig ... end
module Result : sig ... end
module Robustly_comparable : sig ... end
module Sequence : sig ... end
module Set : sig ... end
module Set_intf : sig ... end
module Set_once : sig ... end
module Sexp_maybe : sig ... end
module Sexp : sig ... end
module Sexpable : sig ... end
module Sign : sig ... end
module Signal : sig ... end
module Sign_or_nan : sig ... end
module Source_code_position : sig ... end
module Splittable_random = Splittable_random
module Stable_comparable : sig ... end
module Stable_unit_test : sig ... end
module Stack : sig ... end
module Staged = Base.Staged
module String : sig ... end
module String_id : sig ... end
module Stringable : sig ... end
module Substring : sig ... end
module Substring_intf : sig ... end
module Thread = Core.Thread
module Time : sig ... end
module Time_ns : sig ... end
module Tuple : sig ... end
module Tuple2 = Tuple.T2
module Tuple3 = Tuple.T3
module Type_equal : sig ... end
module Type_immediacy : sig ... end
module Uchar : sig ... end
module Uniform_array : sig ... end
module Union_find : sig ... end
module Unique_id : sig ... end
module Unit : sig ... end
module Unit_of_time : sig ... end
module Univ_map : sig ... end
module Validate = Validate
module Validated : sig ... end
module Variant : sig ... end
module Weak = Stdlib.Weak
module With_return : sig ... end
module Word_size : sig ... end
module type Unique_id = Core.Unique_id
module type T = Core.T
module type T1 = Core.T1
module type T2 = Core.T2
module type T3 = Core.T3
module type T_bin = Core.T_bin
val raise : exn -> 'a
val raise_notrace : exn -> 'a
exception Exit
val (==) : 'a -> 'a -> bool
  • deprecated [since 2014-10] Use [phys_equal]
val (!=) : 'a -> 'a -> bool
  • deprecated [since 2014-10] Use [phys_equal]
val not : bool -> bool
val (&&) : bool -> bool -> bool
val (&) : bool -> bool -> bool
  • deprecated [since 2010-01] {!Caml.( && )} should be used instead.
val (||) : bool -> bool -> bool
val or : bool -> bool -> bool
  • deprecated [since 2010-01] {!Caml.( || )} should be used instead.
val __LOC__ : string
val __FILE__ : string
val __LINE__ : int
val __MODULE__ : string
val __POS__ : string * int * int * int
val __FUNCTION__ : string
val __LOC_OF__ : 'a -> string * 'a
val __LINE_OF__ : 'a -> int * 'a
val __POS_OF__ : 'a -> (string * int * int * int) * 'a
val (|>) : 'a -> ('a -> 'b) -> 'b
val (@@) : ('a -> 'b) -> 'a -> 'b
val (~-) : int -> int
val (~+) : int -> int
val succ : int -> int
val pred : int -> int
val (+) : int -> int -> int
val (-) : int -> int -> int
val (*) : int -> int -> int
val (/) : int -> int -> int
val (mod) : int -> int -> int
val abs : int -> int
val max_int : int
  • deprecated [since 2014-10] Use [Int.max_value]
val min_int : int
  • deprecated [since 2014-10] Use [Int.min_value]
val (land) : int -> int -> int
val (lor) : int -> int -> int
val (lxor) : int -> int -> int
val lnot : int -> int
val (lsl) : int -> int -> int
val (lsr) : int -> int -> int
val (asr) : int -> int -> int
val (~-.) : float -> float
val (~+.) : float -> float
val (+.) : float -> float -> float
val (-.) : float -> float -> float
val (*.) : float -> float -> float
val (/.) : float -> float -> float
val (**) : float -> float -> float
val sqrt : float -> float
val exp : float -> float
val log : float -> float
val log10 : float -> float
  • deprecated [since 2016-07] Use [Float.log10]
val expm1 : float -> float
  • deprecated [since 2016-07] Use [Float.expm1]
val log1p : float -> float
  • deprecated [since 2016-07] Use [Float.log1p]
val cos : float -> float
  • deprecated [since 2016-07] Use [Float.cos]
val sin : float -> float
  • deprecated [since 2016-07] Use [Float.sin]
val tan : float -> float
  • deprecated [since 2016-07] Use [Float.tan]
val acos : float -> float
  • deprecated [since 2016-07] Use [Float.acos]
val asin : float -> float
  • deprecated [since 2016-07] Use [Float.asin]
val atan : float -> float
  • deprecated [since 2016-07] Use [Float.atan]
val atan2 : float -> float -> float
  • deprecated [since 2016-07] Use [Float.atan2]
val hypot : float -> float -> float
  • deprecated [since 2016-07] Use [Float.hypot]
val cosh : float -> float
  • deprecated [since 2016-07] Use [Float.cosh]
val sinh : float -> float
  • deprecated [since 2016-07] Use [Float.sinh]
val tanh : float -> float
  • deprecated [since 2016-07] Use [Float.tanh]
val ceil : float -> float
  • deprecated [since 2014-10] Use [Float.round_up]
val floor : float -> float
  • deprecated [since 2014-10] Use [Float.round_down]
val abs_float : float -> float
  • deprecated [since 2014-10] Use [Float.abs]
val copysign : float -> float -> float
  • deprecated [since 2016-07] Use [Float.copysign]
val mod_float : float -> float -> float
  • deprecated [since 2014-10] Use [Float.mod_float]
val frexp : float -> float * int
  • deprecated [since 2014-10] Use [Float.frexp]
val ldexp : float -> int -> float
  • deprecated [since 2014-10] Use [Float.ldexp]
val modf : float -> float * float
  • deprecated [since 2014-10] Use [Float.modf]
val float : int -> float
val float_of_int : int -> float
val truncate : float -> int
  • deprecated [since 2014-10] Use [Float.iround_towards_zero_exn]
val int_of_float : float -> int
val infinity : float
  • deprecated [since 2014-10] Use [Float.infinity]
val neg_infinity : float
  • deprecated [since 2014-10] Use [Float.neg_infinity]
val nan : float
  • deprecated [since 2014-10] Use [Float.nan]
val max_float : float
  • deprecated [since 2014-10] Use [Float.max_value]
val min_float : float
  • deprecated [since 2014-10] Use [Float.min_value]
val epsilon_float : float
  • deprecated [since 2014-10] Use [Float.epsilon_float]
type fpclass = Caml.fpclass =
  1. | FP_normal
  2. | FP_subnormal
  3. | FP_zero
  4. | FP_infinite
  5. | FP_nan
val classify_float : float -> fpclass
  • deprecated [since 2014-10] Use [Float.classify]
val (^) : string -> string -> string
val int_of_char : char -> int
val char_of_int : int -> char
val ignore : 'a -> unit
val string_of_bool : bool -> string
val bool_of_string : string -> bool
val string_of_int : int -> string
val int_of_string : string -> int
val string_of_float : float -> string
val float_of_string : string -> float
val fst : ('a * 'b) -> 'a
val snd : ('a * 'b) -> 'b
type in_channel = Caml.in_channel
  • deprecated [since 2016-04] Use [In_channel.t]
type out_channel = Caml.out_channel
  • deprecated [since 2016-04] Use [Out_channel.t]
val stdin : Caml.in_channel
  • deprecated [since 2016-04] Use [In_channel.stdin]
val stdout : Caml.out_channel
val stderr : Caml.out_channel
val print_char : char -> unit
  • deprecated [since 2016-04] Use [Out_channel.output_char stdout]
val print_string : string -> unit
val print_bytes : bytes -> unit
  • deprecated [since 2016-04] Core doesn't support [bytes] yet.
val print_int : int -> unit
  • deprecated [since 2016-04] Use [Out_channel.output_string stdout]
val print_float : float -> unit
  • deprecated [since 2016-04] Use [Out_channel.output_string stdout]
val print_endline : string -> unit
val print_newline : unit -> unit
  • deprecated [since 2016-04] Use [Out_channel.newline stdout]
val prerr_char : char -> unit
  • deprecated [since 2016-04] Use [Out_channel.output_char stderr]
val prerr_string : string -> unit
  • deprecated [since 2016-04] Use [Out_channel.output_string stderr]
val prerr_bytes : bytes -> unit
  • deprecated [since 2016-04] Core doesn't support [bytes] yet
val prerr_int : int -> unit
  • deprecated [since 2016-04] Use [Out_channel.output_string stderr]
val prerr_float : float -> unit
  • deprecated [since 2016-04] Use [Out_channel.output_string stderr]
val prerr_endline : string -> unit
val prerr_newline : unit -> unit
  • deprecated [since 2016-04] Use [Out_channel.newline stderr]
val read_line : unit -> string
  • deprecated [since 2016-04] Use [Out_channel.(flush stdout); In_channel.(input_line_exn stdin)]
val read_int : unit -> int
  • deprecated [since 2016-04] Use [Out_channel.(flush stdout); Int.of_string In_channel.(input_line_exn stdin)]
val read_float : unit -> float
  • deprecated [since 2016-04] Use [Out_channel.(flush stdout); Float.of_string In_channel.(input_line_exn stdin)]
type open_flag = Caml.open_flag =
  1. | Open_rdonly
  2. | Open_wronly
  3. | Open_append
  4. | Open_creat
  5. | Open_trunc
  6. | Open_excl
  7. | Open_binary
  8. | Open_text
  9. | Open_nonblock
  • deprecated [since 2016-04] Use [In_channel.create] and [Out_channel.create]
val open_out : string -> Caml.out_channel
  • deprecated [since 2016-04] Use [Out_channel.create]
val open_out_bin : string -> Caml.out_channel
  • deprecated [since 2016-04] Use [Out_channel.create]
val open_out_gen : Caml.open_flag list -> int -> string -> Caml.out_channel
  • deprecated [since 2016-04] Use [Out_channel.create]
val flush : Caml.out_channel -> unit
  • deprecated [since 2016-04] Use [Out_channel.flush]
val flush_all : unit -> unit
  • deprecated [since 2016-04]
val output_char : Caml.out_channel -> char -> unit
  • deprecated [since 2016-04] Use [Out_channel.output_char]
val output_string : Caml.out_channel -> string -> unit
  • deprecated [since 2016-04] Use [Out_channel.output_string]
val output_bytes : Caml.out_channel -> bytes -> unit
  • deprecated [since 2016-04] Core doesn't yet support bytes.
val output : Caml.out_channel -> bytes -> int -> int -> unit
  • deprecated [since 2016-04] Core doesn't yet support bytes.
val output_substring : Caml.out_channel -> string -> int -> int -> unit
  • deprecated [since 2016-04] Use [Out_channel.output]
val output_byte : Caml.out_channel -> int -> unit
  • deprecated [since 2016-04] Use [Out_channel.output_byte]
val output_binary_int : Caml.out_channel -> int -> unit
  • deprecated [since 2016-04] Use [Out_channel.output_binary_int]
val output_value : Caml.out_channel -> 'a -> unit
  • deprecated [since 2016-04] Use [Out_channel.output_value]
val seek_out : Caml.out_channel -> int -> unit
  • deprecated [since 2014-10] Use [Out_channel.seek]
val pos_out : Caml.out_channel -> int
  • deprecated [since 2014-10] Use [Out_channel.pos]
val out_channel_length : Caml.out_channel -> int
  • deprecated [since 2014-10] Use [Out_channel.length]
val close_out : Caml.out_channel -> unit
  • deprecated [since 2014-10] Use [Out_channel.close]
val close_out_noerr : Caml.out_channel -> unit
  • deprecated [since 2016-04] Use [Out_channel.close] and catch exceptions
val set_binary_mode_out : Caml.out_channel -> bool -> unit
  • deprecated [since 2016-04] Use [Out_channel.set_binary_mode]
val open_in : string -> Caml.in_channel
  • deprecated [since 2016-04] Use [In_channel.create]
val open_in_bin : string -> Caml.in_channel
  • deprecated [since 2016-04] Use [In_channel.create]
val open_in_gen : Caml.open_flag list -> int -> string -> Caml.in_channel
  • deprecated [since 2016-04] Use [In_channel.create]
val input_char : Caml.in_channel -> char
  • deprecated [since 2016-04] Use [In_channel.input_char]
val input_line : Caml.in_channel -> string
  • deprecated [since 2016-04] Use [In_channel.input_line]
val input : Caml.in_channel -> bytes -> int -> int -> int
  • deprecated [since 2016-04] Core doesn't yet support bytes.
val really_input : Caml.in_channel -> bytes -> int -> int -> unit
  • deprecated [since 2016-04] Core doesn't yet support bytes.
val really_input_string : Caml.in_channel -> int -> string
  • deprecated [since 2016-04] Use [In_channel.really_input_exn ~pos:0]
val input_byte : Caml.in_channel -> int
  • deprecated [since 2016-04] Use [In_channel.input_byte]
val input_binary_int : Caml.in_channel -> int
  • deprecated [since 2016-04] Use [In_channel.input_binary_int]
val input_value : Caml.in_channel -> 'a
  • deprecated [since 2016-04] Use [In_channel.unsafe_input_value]
val seek_in : Caml.in_channel -> int -> unit
  • deprecated [since 2014-10] Use [In_channel.seek]
val pos_in : Caml.in_channel -> int
  • deprecated [since 2014-10] Use [In_channel.pos]
val in_channel_length : Caml.in_channel -> int
  • deprecated [since 2014-10] Use [In_channel.length]
val close_in : Caml.in_channel -> unit
  • deprecated [since 2014-10] Use [In_channel.close]
val close_in_noerr : Caml.in_channel -> unit
  • deprecated [since 2016-04] Use [In_channel.close] and catch exceptions
val set_binary_mode_in : Caml.in_channel -> bool -> unit
  • deprecated [since 2016-04] Use [In_channel.set_binary_mode]
module LargeFile : sig ... end
type !'a ref = 'a Caml.ref = {
  1. 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 =
  1. | Ok of 'a
  2. | Error of 'b
type (!'a, !'b, !'c, !'d, !'e, !'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6
type (!'a, !'b, !'c, !'d) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6
type (!'a, !'b, !'c) format = ('a, 'b, 'c, 'c) format4
val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string
val format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6
val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6
val at_exit : (unit -> unit) -> unit
val valid_float_lexem : string -> string
  • deprecated [since 2015-11] Do not use.
val unsafe_really_input : Caml.in_channel -> bytes -> int -> int -> unit
  • deprecated [since 2015-11] Do not use.
val do_at_exit : unit -> unit
  • deprecated [since 2015-11] Do not use.
val (>=) : Core__Int.t -> Core__Int.t -> bool
val (<=) : Core__Int.t -> Core__Int.t -> bool
val (>) : Core__Int.t -> Core__Int.t -> bool
val (<) : Core__Int.t -> Core__Int.t -> bool
val (<>) : Core__Int.t -> Core__Int.t -> bool
val min : Core__Int.t -> Core__Int.t -> Core__Int.t
val max : Core__Int.t -> Core__Int.t -> Core__Int.t
val quickcheck_generator_unit : Base.unit Base_quickcheck__.Generator.t
val quickcheck_generator_bool : Base.bool Base_quickcheck__.Generator.t
val quickcheck_generator_char : Base.char Base_quickcheck__.Generator.t
val quickcheck_generator_string : Base.string Base_quickcheck__.Generator.t
val quickcheck_generator_bytes : Base.bytes Base_quickcheck__.Generator.t
val quickcheck_generator_int : Base.int Base_quickcheck__.Generator.t
val quickcheck_generator_int32 : Base.int32 Base_quickcheck__.Generator.t
val quickcheck_generator_int64 : Base.int64 Base_quickcheck__.Generator.t
val quickcheck_generator_nativeint : Base.nativeint Base_quickcheck__.Generator.t
val quickcheck_generator_float : Base.float Base_quickcheck__.Generator.t
val quickcheck_observer_unit : Base.unit Base_quickcheck__.Observer.t
val quickcheck_observer_bool : Base.bool Base_quickcheck__.Observer.t
val quickcheck_observer_char : Base.char Base_quickcheck__.Observer.t
val quickcheck_observer_string : Base.string Base_quickcheck__.Observer.t
val quickcheck_observer_bytes : Base.bytes Base_quickcheck__.Observer.t
val quickcheck_observer_int : Base.int Base_quickcheck__.Observer.t
val quickcheck_observer_int32 : Base.int32 Base_quickcheck__.Observer.t
val quickcheck_observer_int64 : Base.int64 Base_quickcheck__.Observer.t
val quickcheck_observer_nativeint : Base.nativeint Base_quickcheck__.Observer.t
val quickcheck_observer_float : Base.float Base_quickcheck__.Observer.t
val quickcheck_shrinker_unit : Base.unit Base_quickcheck__.Shrinker.t
val quickcheck_shrinker_bool : Base.bool Base_quickcheck__.Shrinker.t
val quickcheck_shrinker_char : Base.char Base_quickcheck__.Shrinker.t
val quickcheck_shrinker_string : Base.string Base_quickcheck__.Shrinker.t
val quickcheck_shrinker_bytes : Base.bytes Base_quickcheck__.Shrinker.t
val quickcheck_shrinker_int : Base.int Base_quickcheck__.Shrinker.t
val quickcheck_shrinker_int32 : Base.int32 Base_quickcheck__.Shrinker.t
val quickcheck_shrinker_int64 : Base.int64 Base_quickcheck__.Shrinker.t
val quickcheck_shrinker_nativeint : Base.nativeint Base_quickcheck__.Shrinker.t
val quickcheck_shrinker_float : Base.float Base_quickcheck__.Shrinker.t
val quickcheck_generator_option : 'a Base_quickcheck__.Generator.t -> 'a Base.option Base_quickcheck__.Generator.t
val quickcheck_generator_list : 'a Base_quickcheck__.Generator.t -> 'a Base.list Base_quickcheck__.Generator.t
val quickcheck_generator_array : 'a Base_quickcheck__.Generator.t -> 'a Base.array Base_quickcheck__.Generator.t
val quickcheck_generator_ref : 'a Base_quickcheck__.Generator.t -> 'a Base.ref Base_quickcheck__.Generator.t
val quickcheck_generator_lazy_t : 'a Base_quickcheck__.Generator.t -> 'a Base.Lazy.t Base_quickcheck__.Generator.t
val quickcheck_observer_option : 'a Base_quickcheck__.Observer.t -> 'a Base.option Base_quickcheck__.Observer.t
val quickcheck_observer_list : 'a Base_quickcheck__.Observer.t -> 'a Base.list Base_quickcheck__.Observer.t
val quickcheck_observer_array : 'a Base_quickcheck__.Observer.t -> 'a Base.array Base_quickcheck__.Observer.t
val quickcheck_observer_ref : 'a Base_quickcheck__.Observer.t -> 'a Base.ref Base_quickcheck__.Observer.t
val quickcheck_observer_lazy_t : 'a Base_quickcheck__.Observer.t -> 'a Base.Lazy.t Base_quickcheck__.Observer.t
val quickcheck_shrinker_option : 'a Base_quickcheck__.Shrinker.t -> 'a Base.option Base_quickcheck__.Shrinker.t
val quickcheck_shrinker_list : 'a Base_quickcheck__.Shrinker.t -> 'a Base.list Base_quickcheck__.Shrinker.t
val quickcheck_shrinker_array : 'a Base_quickcheck__.Shrinker.t -> 'a Base.array Base_quickcheck__.Shrinker.t
val quickcheck_shrinker_ref : 'a Base_quickcheck__.Shrinker.t -> 'a Base.ref Base_quickcheck__.Shrinker.t
val quickcheck_shrinker_lazy_t : 'a Base_quickcheck__.Shrinker.t -> 'a Base.Lazy.t Base_quickcheck__.Shrinker.t
val (|!) : 'a -> ('a -> 'b) -> 'b
  • deprecated [since 2016-07] Use [ |> ]
type (!'f, !'s) _either = ('f, 's) Base__Either.t =
  1. | First of 'f
  2. | Second of 's
type bigstring = Sexplib.Conv.bigstring
val sexp_of_bigstring : bigstring -> Sexplib0.Sexp.t
val bigstring_of_sexp : Sexplib0.Sexp.t -> bigstring
type mat = Sexplib.Conv.mat
val sexp_of_mat : mat -> Sexplib0.Sexp.t
val mat_of_sexp : Sexplib0.Sexp.t -> mat
type vec = Sexplib.Conv.vec
val sexp_of_vec : vec -> Sexplib0.Sexp.t
val vec_of_sexp : Sexplib0.Sexp.t -> vec
val sexp_of_opaque : 'a -> Base.Sexp.t
val opaque_of_sexp : Base.Sexp.t -> 'a
val sexp_of_pair : ('a -> Base.Sexp.t) -> ('b -> Base.Sexp.t) -> ('a * 'b) -> Base.Sexp.t
val pair_of_sexp : (Base.Sexp.t -> 'a) -> (Base.Sexp.t -> 'b) -> Base.Sexp.t -> 'a * 'b
exception Of_sexp_error of Core__Import.exn * Base.Sexp.t
val of_sexp_error : Core__Import.string -> Base.Sexp.t -> 'a
val of_sexp_error_exn : Core__Import.exn -> Base.Sexp.t -> 'a
module type Applicative = Core.Applicative
module type Binable = Core.Binable
module type Comparable = Core.Comparable
module type Comparable_binable = Core.Comparable_binable
module type Floatable = Core.Floatable
module type Hashable = Core.Hashable
module type Hashable_binable = Core.Hashable_binable
module type Identifiable = Core.Identifiable
module type Infix_comparators = Core.Infix_comparators
module type Intable = Core.Intable
module type Monad = Core.Monad
module type Quickcheckable = Core.Quickcheckable
module type Robustly_comparable = Core.Robustly_comparable
module type Sexpable = Core.Sexpable
module type Stable = Core.Stable
module type Stable_int63able = Core.Stable_int63able
module type Stable_without_comparator = Core.Stable_without_comparator
module type Stable1 = Core.Stable1
module type Stable2 = Core.Stable2
module type Stable3 = Core.Stable3
module type Stable4 = Core.Stable4
module type Stringable = Core.Stringable
module type Unit = Core.Unit
val (@) : 'a Base__List.t -> 'a Base__List.t -> 'a Base__List.t
type never_returns = Core__.Nothing.t
val sexp_of_never_returns : never_returns -> Sexplib0.Sexp.t
val never_returns : never_returns -> 'a
type _ordering = Core__Ordering.t =
  1. | Less
  2. | Equal
  3. | Greater
type read = Core__Perms.Read.t
val bin_shape_read : Bin_prot.Shape.t
val bin_size_read : read Bin_prot.Size.sizer
val bin_write_read : read Bin_prot.Write.writer
val bin_writer_read : read Bin_prot.Type_class.writer
val bin_read_read : read Bin_prot.Read.reader
val __bin_read_read__ : (Core__.Import.int -> read) Bin_prot.Read.reader
val bin_reader_read : read Bin_prot.Type_class.reader
val bin_read : read Bin_prot.Type_class.t
val compare_read : read -> read -> Core__.Import.int
val hash_fold_read : Ppx_hash_lib.Std.Hash.state -> read -> Ppx_hash_lib.Std.Hash.state
val hash_read : read -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_read : read -> Sexplib0.Sexp.t
val read_of_sexp : Sexplib0.Sexp.t -> read
type write = Core__Perms.Write.t
val compare_write : write -> write -> Core__.Import.int
val hash_fold_write : Ppx_hash_lib.Std.Hash.state -> write -> Ppx_hash_lib.Std.Hash.state
val hash_write : write -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_write : write -> Sexplib0.Sexp.t
val write_of_sexp : Sexplib0.Sexp.t -> write
type immutable = Core__Perms.Immutable.t
val bin_shape_immutable : Bin_prot.Shape.t
val bin_size_immutable : immutable Bin_prot.Size.sizer
val bin_write_immutable : immutable Bin_prot.Write.writer
val bin_writer_immutable : immutable Bin_prot.Type_class.writer
val bin_read_immutable : immutable Bin_prot.Read.reader
val __bin_read_immutable__ : (Core__.Import.int -> immutable) Bin_prot.Read.reader
val bin_reader_immutable : immutable Bin_prot.Type_class.reader
val bin_immutable : immutable Bin_prot.Type_class.t
val compare_immutable : immutable -> immutable -> Core__.Import.int
val hash_fold_immutable : Ppx_hash_lib.Std.Hash.state -> immutable -> Ppx_hash_lib.Std.Hash.state
val hash_immutable : immutable -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_immutable : immutable -> Sexplib0.Sexp.t
val immutable_of_sexp : Sexplib0.Sexp.t -> immutable
type read_write = Core__Perms.Read_write.t
val bin_shape_read_write : Bin_prot.Shape.t
val bin_size_read_write : read_write Bin_prot.Size.sizer
val bin_write_read_write : read_write Bin_prot.Write.writer
val bin_writer_read_write : read_write Bin_prot.Type_class.writer
val bin_read_read_write : read_write Bin_prot.Read.reader
val __bin_read_read_write__ : (Core__.Import.int -> read_write) Bin_prot.Read.reader
val bin_reader_read_write : read_write Bin_prot.Type_class.reader
val bin_read_write : read_write Bin_prot.Type_class.t
val compare_read_write : read_write -> read_write -> Core__.Import.int
val hash_fold_read_write : Ppx_hash_lib.Std.Hash.state -> read_write -> Ppx_hash_lib.Std.Hash.state
val hash_read_write : read_write -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_read_write : read_write -> Sexplib0.Sexp.t
val read_write_of_sexp : Sexplib0.Sexp.t -> read_write
type !'a perms = 'a Core__Perms.Upper_bound.t
val bin_shape_perms : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_perms : 'a Bin_prot.Size.sizer -> 'a perms Bin_prot.Size.sizer
val bin_write_perms : 'a Bin_prot.Write.writer -> 'a perms Bin_prot.Write.writer
val bin_writer_perms : 'a Bin_prot.Type_class.writer -> 'a perms Bin_prot.Type_class.writer
val bin_read_perms : 'a Bin_prot.Read.reader -> 'a perms Bin_prot.Read.reader
val __bin_read_perms__ : 'a Bin_prot.Read.reader -> (Core__.Import.int -> 'a perms) Bin_prot.Read.reader
val bin_reader_perms : 'a Bin_prot.Type_class.reader -> 'a perms Bin_prot.Type_class.reader
val bin_perms : 'a Bin_prot.Type_class.t -> 'a perms Bin_prot.Type_class.t
val compare_perms : ('a -> 'a -> Core__.Import.int) -> 'a perms -> 'a perms -> Core__.Import.int
val hash_fold_perms : (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state) -> Ppx_hash_lib.Std.Hash.state -> 'a perms -> Ppx_hash_lib.Std.Hash.state
val sexp_of_perms : ('a -> Sexplib0.Sexp.t) -> 'a perms -> Sexplib0.Sexp.t
val perms_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a perms
type (!'ok, !'err) _result = ('ok, 'err) Core__Result.t =
  1. | Ok of 'ok
  2. | Error of 'err
val is_ok : ('a, 'b) Core__Result.t -> bool
val is_error : ('a, 'b) Core__Result.t -> bool
type !-'a return = private 'a Core__.Import.With_return.return = {
  1. return : 'b. 'a -> 'b;
}
exception Bug of Core__.Import.string
  • deprecated [since 2020-03] Don't use [Bug]
exception C_malloc_exn of Core__.Import.int * Core__.Import.int
exception Finally of Core__.Import.Exn.t * Core__.Import.Exn.t
val fst3 : ('a * 'b * 'c) -> 'a
val snd3 : ('a * 'b * 'c) -> 'b
val trd3 : ('a * 'b * 'c) -> 'c
val uw : 'a Core__.Import.option -> 'a
  • deprecated [since 2018-12] Use [Option.value_exn]
val (%) : Core__.Int.t -> Core__.Int.t -> Core__.Int.t
val (/%) : Core__.Int.t -> Core__.Int.t -> Core__.Int.t
val (//) : Core__.Int.t -> Core__.Int.t -> float
val (==>) : bool -> bool -> bool
val bprintf : Base__.Import0.Caml.Buffer.t -> ('a, Base__.Import0.Caml.Buffer.t, unit) Stdlib.format -> 'a
val const : 'a -> 'b -> 'a
val eprintf : ('a, Stdlib.out_channel, Core__.Import.unit) Core__.Import.format -> 'a
val error : ?here:Base__.Source_code_position0.t -> ?strict:unit -> string -> 'a -> ('a -> Base__.Sexp.t) -> 'b Core__.Or_error.t
val error_s : Base__.Sexp.t -> 'a Core__.Or_error.t
val failwithp : ?strict:Core__.Import.unit -> Core__.Source_code_position.t -> Core__.Import.string -> 'a -> ('a -> Core__.Sexp.t) -> 'b
  • deprecated [since 2020-03] Use [failwiths] instead.
val failwiths : ?strict:Core__.Import.unit -> here:Stdlib.Lexing.position -> Core__.Import.string -> 'a -> ('a -> Base.Sexp.t) -> 'b
val force : 'a Base.Lazy.t -> 'a
val fprintf : Stdlib.out_channel -> ('a, Stdlib.out_channel, Core__.Import.unit) Core__.Import.format -> 'a
val ident : 'a -> 'a
  • deprecated [since 2021-08] Use [Fn.id] instead.
val ifprintf : 'a -> ('b, 'a, 'c, unit) Stdlib.format4 -> 'b
val is_none : 'a option -> bool
val is_some : 'a option -> bool
val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) Stdlib.format4 -> 'b
val ok_exn : 'a Core__.Or_error.t -> 'a
val phys_equal : 'a -> 'a -> bool
val phys_same : 'a -> 'b -> bool
val print_s : ?mach:Base.unit -> Base.Sexp.t -> Base.unit
val eprint_s : ?mach:Base.unit -> Base.Sexp.t -> Base.unit
val printf : ('a, Stdlib.out_channel, Core__.Import.unit) Core__.Import.format -> 'a
val protect : f:(unit -> 'a) -> finally:(unit -> unit) -> 'a
val protectx : f:('a -> 'b) -> 'a -> finally:('a -> unit) -> 'b
val raise_s : Base__.Sexp.t -> 'a
val round : ?dir:[ `Down | `Nearest | `Up | `Zero ] -> float -> float
val (**.) : Base__Float.t -> Base__Float.t -> Base__Float.t
val (%.) : Base__Float.t -> Base__Float.t -> Base__Float.t
val sprintf : ('a, unit, string) Stdlib.format -> 'a
val stage : 'a -> 'a Core__.Import.Staged.t
val unstage : 'a Core__.Import.Staged.t -> 'a
val with_return : ('a Core__.Import.With_return.return -> 'a) -> 'a
val with_return_option : ('a Core__.Import.With_return.return -> unit) -> 'a option
module Typerep : sig ... end
val typerep_of_int63 : Base.Int63.t Typerep.t
type tuple0 = Typerep_lib__Std_internal.tuple0
val value_tuple0 : tuple0
val typerep_of_function : 'a Typerep.t -> 'b Typerep.t -> ('a -> 'b) Typerep.t
val typerep_of_tuple0 : tuple0 Typerep.t
val typerep_of_tuple2 : 'a Typerep.t -> 'b Typerep.t -> ('a * 'b) Typerep.t
val typerep_of_tuple3 : 'a Typerep.t -> 'b Typerep.t -> 'c Typerep.t -> ('a * 'b * 'c) Typerep.t
val typerep_of_tuple4 : 'a Typerep.t -> 'b Typerep.t -> 'c Typerep.t -> 'd Typerep.t -> ('a * 'b * 'c * 'd) Typerep.t
val typerep_of_tuple5 : 'a Typerep.t -> 'b Typerep.t -> 'c Typerep.t -> 'd Typerep.t -> 'e Typerep.t -> ('a * 'b * 'c * 'd * 'e) Typerep.t
val typename_of_int63 : Base.Int63.t Typerep_lib.Typename.t
val typename_of_function : 'a Typerep_lib.Typename.t -> 'b Typerep_lib.Typename.t -> ('a -> 'b) Typerep_lib.Typename.t
val typename_of_tuple0 : tuple0 Typerep_lib.Typename.t
val typename_of_tuple2 : 'a Typerep_lib.Typename.t -> 'b Typerep_lib.Typename.t -> ('a * 'b) Typerep_lib.Typename.t
val typename_of_tuple3 : 'a Typerep_lib.Typename.t -> 'b Typerep_lib.Typename.t -> 'c Typerep_lib.Typename.t -> ('a * 'b * 'c) Typerep_lib.Typename.t
val typename_of_tuple4 : 'a Typerep_lib.Typename.t -> 'b Typerep_lib.Typename.t -> 'c Typerep_lib.Typename.t -> 'd Typerep_lib.Typename.t -> ('a * 'b * 'c * 'd) Typerep_lib.Typename.t
val typename_of_tuple5 : 'a Typerep_lib.Typename.t -> 'b Typerep_lib.Typename.t -> 'c Typerep_lib.Typename.t -> 'd Typerep_lib.Typename.t -> 'e Typerep_lib.Typename.t -> ('a * 'b * 'c * 'd * 'e) Typerep_lib.Typename.t
val bin_shape_array : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_array : 'a Bin_prot.Size.sizer -> 'a Core__.Import.array Bin_prot.Size.sizer
val bin_write_array : 'a Bin_prot.Write.writer -> 'a Core__.Import.array Bin_prot.Write.writer
val bin_writer_array : 'a Bin_prot.Type_class.writer -> 'a Core__.Import.array Bin_prot.Type_class.writer
val bin_read_array : 'a Bin_prot.Read.reader -> 'a Core__.Import.array Bin_prot.Read.reader
val __bin_read_array__ : 'a Bin_prot.Read.reader -> (Core__.Import.int -> 'a Core__.Import.array) Bin_prot.Read.reader
val bin_reader_array : 'a Bin_prot.Type_class.reader -> 'a Core__.Import.array Bin_prot.Type_class.reader
val bin_array : 'a Bin_prot.Type_class.t -> 'a Core__.Import.array Bin_prot.Type_class.t
val compare_array : ('a -> 'a -> Core__.Import.int) -> 'a Core__.Import.array -> 'a Core__.Import.array -> Core__.Import.int
val equal_array : ('a -> 'a -> Core__.Import.bool) -> 'a Core__.Import.array -> 'a Core__.Import.array -> Core__.Import.bool
val sexp_of_array : ('a -> Sexplib0.Sexp.t) -> 'a Core__.Import.array -> Sexplib0.Sexp.t
val array_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a Core__.Import.array
val array_sexp_grammar : 'a Sexplib0.Sexp_grammar.t -> 'a Core__.Import.array Sexplib0.Sexp_grammar.t
val typerep_of_array : 'a Typerep_lib.Std.Typerep.t -> 'a Core__.Import.array Typerep_lib.Std.Typerep.t
val typename_of_array : 'a Typerep_lib.Std.Typename.t -> 'a Core__.Import.array Typerep_lib.Std.Typename.t
val bin_shape_bool : Bin_prot.Shape.t
val bin_size_bool : Core__.Import.bool Bin_prot.Size.sizer
val bin_write_bool : Core__.Import.bool Bin_prot.Write.writer
val bin_writer_bool : Core__.Import.bool Bin_prot.Type_class.writer
val bin_read_bool : Core__.Import.bool Bin_prot.Read.reader
val __bin_read_bool__ : (Core__.Import.int -> Core__.Import.bool) Bin_prot.Read.reader
val bin_reader_bool : Core__.Import.bool Bin_prot.Type_class.reader
val bin_bool : Core__.Import.bool Bin_prot.Type_class.t
val compare_bool : Core__.Import.bool -> Core__.Import.bool -> Core__.Import.int
val equal_bool : Core__.Import.bool -> Core__.Import.bool -> Core__.Import.bool
val hash_fold_bool : Ppx_hash_lib.Std.Hash.state -> Core__.Import.bool -> Ppx_hash_lib.Std.Hash.state
val hash_bool : Core__.Import.bool -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_bool : Core__.Import.bool -> Sexplib0.Sexp.t
val bool_of_sexp : Sexplib0.Sexp.t -> Core__.Import.bool
val bool_sexp_grammar : Core__.Import.bool Sexplib0.Sexp_grammar.t
val typerep_of_bool : Core__.Import.bool Typerep_lib.Std.Typerep.t
val typename_of_bool : Core__.Import.bool Typerep_lib.Std.Typename.t
val bin_shape_char : Bin_prot.Shape.t
val bin_size_char : Core__.Import.char Bin_prot.Size.sizer
val bin_write_char : Core__.Import.char Bin_prot.Write.writer
val bin_writer_char : Core__.Import.char Bin_prot.Type_class.writer
val bin_read_char : Core__.Import.char Bin_prot.Read.reader
val __bin_read_char__ : (Core__.Import.int -> Core__.Import.char) Bin_prot.Read.reader
val bin_reader_char : Core__.Import.char Bin_prot.Type_class.reader
val bin_char : Core__.Import.char Bin_prot.Type_class.t
val compare_char : Core__.Import.char -> Core__.Import.char -> Core__.Import.int
val equal_char : Core__.Import.char -> Core__.Import.char -> Core__.Import.bool
val hash_fold_char : Ppx_hash_lib.Std.Hash.state -> Core__.Import.char -> Ppx_hash_lib.Std.Hash.state
val hash_char : Core__.Import.char -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_char : Core__.Import.char -> Sexplib0.Sexp.t
val char_of_sexp : Sexplib0.Sexp.t -> Core__.Import.char
val char_sexp_grammar : Core__.Import.char Sexplib0.Sexp_grammar.t
val typerep_of_char : Core__.Import.char Typerep_lib.Std.Typerep.t
val typename_of_char : Core__.Import.char Typerep_lib.Std.Typename.t
val bin_shape_float : Bin_prot.Shape.t
val bin_size_float : Core__.Import.float Bin_prot.Size.sizer
val bin_write_float : Core__.Import.float Bin_prot.Write.writer
val bin_writer_float : Core__.Import.float Bin_prot.Type_class.writer
val bin_read_float : Core__.Import.float Bin_prot.Read.reader
val __bin_read_float__ : (Core__.Import.int -> Core__.Import.float) Bin_prot.Read.reader
val bin_reader_float : Core__.Import.float Bin_prot.Type_class.reader
val bin_float : Core__.Import.float Bin_prot.Type_class.t
val compare_float : Core__.Import.float -> Core__.Import.float -> Core__.Import.int
val equal_float : Core__.Import.float -> Core__.Import.float -> Core__.Import.bool
val hash_fold_float : Ppx_hash_lib.Std.Hash.state -> Core__.Import.float -> Ppx_hash_lib.Std.Hash.state
val hash_float : Core__.Import.float -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_float : Core__.Import.float -> Sexplib0.Sexp.t
val float_of_sexp : Sexplib0.Sexp.t -> Core__.Import.float
val float_sexp_grammar : Core__.Import.float Sexplib0.Sexp_grammar.t
val typerep_of_float : Core__.Import.float Typerep_lib.Std.Typerep.t
val typename_of_float : Core__.Import.float Typerep_lib.Std.Typename.t
val bin_shape_int : Bin_prot.Shape.t
val bin_size_int : Core__.Import.int Bin_prot.Size.sizer
val bin_write_int : Core__.Import.int Bin_prot.Write.writer
val bin_writer_int : Core__.Import.int Bin_prot.Type_class.writer
val bin_read_int : Core__.Import.int Bin_prot.Read.reader
val __bin_read_int__ : (Core__.Import.int -> Core__.Import.int) Bin_prot.Read.reader
val bin_reader_int : Core__.Import.int Bin_prot.Type_class.reader
val bin_int : Core__.Import.int Bin_prot.Type_class.t
val compare_int : Core__.Import.int -> Core__.Import.int -> Core__.Import.int
val equal_int : Core__.Import.int -> Core__.Import.int -> Core__.Import.bool
val hash_fold_int : Ppx_hash_lib.Std.Hash.state -> Core__.Import.int -> Ppx_hash_lib.Std.Hash.state
val hash_int : Core__.Import.int -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_int : Core__.Import.int -> Sexplib0.Sexp.t
val int_of_sexp : Sexplib0.Sexp.t -> Core__.Import.int
val int_sexp_grammar : Core__.Import.int Sexplib0.Sexp_grammar.t
val typerep_of_int : Core__.Import.int Typerep_lib.Std.Typerep.t
val typename_of_int : Core__.Import.int Typerep_lib.Std.Typename.t
val bin_shape_int32 : Bin_prot.Shape.t
val bin_size_int32 : Core__.Import.int32 Bin_prot.Size.sizer
val bin_write_int32 : Core__.Import.int32 Bin_prot.Write.writer
val bin_writer_int32 : Core__.Import.int32 Bin_prot.Type_class.writer
val bin_read_int32 : Core__.Import.int32 Bin_prot.Read.reader
val __bin_read_int32__ : (Core__.Import.int -> Core__.Import.int32) Bin_prot.Read.reader
val bin_reader_int32 : Core__.Import.int32 Bin_prot.Type_class.reader
val bin_int32 : Core__.Import.int32 Bin_prot.Type_class.t
val compare_int32 : Core__.Import.int32 -> Core__.Import.int32 -> Core__.Import.int
val equal_int32 : Core__.Import.int32 -> Core__.Import.int32 -> Core__.Import.bool
val hash_fold_int32 : Ppx_hash_lib.Std.Hash.state -> Core__.Import.int32 -> Ppx_hash_lib.Std.Hash.state
val hash_int32 : Core__.Import.int32 -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_int32 : Core__.Import.int32 -> Sexplib0.Sexp.t
val int32_of_sexp : Sexplib0.Sexp.t -> Core__.Import.int32
val int32_sexp_grammar : Core__.Import.int32 Sexplib0.Sexp_grammar.t
val typerep_of_int32 : Core__.Import.int32 Typerep_lib.Std.Typerep.t
val typename_of_int32 : Core__.Import.int32 Typerep_lib.Std.Typename.t
val bin_shape_int64 : Bin_prot.Shape.t
val bin_size_int64 : Core__.Import.int64 Bin_prot.Size.sizer
val bin_write_int64 : Core__.Import.int64 Bin_prot.Write.writer
val bin_writer_int64 : Core__.Import.int64 Bin_prot.Type_class.writer
val bin_read_int64 : Core__.Import.int64 Bin_prot.Read.reader
val __bin_read_int64__ : (Core__.Import.int -> Core__.Import.int64) Bin_prot.Read.reader
val bin_reader_int64 : Core__.Import.int64 Bin_prot.Type_class.reader
val bin_int64 : Core__.Import.int64 Bin_prot.Type_class.t
val compare_int64 : Core__.Import.int64 -> Core__.Import.int64 -> Core__.Import.int
val equal_int64 : Core__.Import.int64 -> Core__.Import.int64 -> Core__.Import.bool
val hash_fold_int64 : Ppx_hash_lib.Std.Hash.state -> Core__.Import.int64 -> Ppx_hash_lib.Std.Hash.state
val hash_int64 : Core__.Import.int64 -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_int64 : Core__.Import.int64 -> Sexplib0.Sexp.t
val int64_of_sexp : Sexplib0.Sexp.t -> Core__.Import.int64
val int64_sexp_grammar : Core__.Import.int64 Sexplib0.Sexp_grammar.t
val typerep_of_int64 : Core__.Import.int64 Typerep_lib.Std.Typerep.t
val typename_of_int64 : Core__.Import.int64 Typerep_lib.Std.Typename.t
val bin_shape_lazy_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_lazy_t : 'a Bin_prot.Size.sizer -> 'a lazy_t Bin_prot.Size.sizer
val bin_write_lazy_t : 'a Bin_prot.Write.writer -> 'a lazy_t Bin_prot.Write.writer
val bin_writer_lazy_t : 'a Bin_prot.Type_class.writer -> 'a lazy_t Bin_prot.Type_class.writer
val bin_read_lazy_t : 'a Bin_prot.Read.reader -> 'a lazy_t Bin_prot.Read.reader
val __bin_read_lazy_t__ : 'a Bin_prot.Read.reader -> (Core__.Import.int -> 'a lazy_t) Bin_prot.Read.reader
val bin_reader_lazy_t : 'a Bin_prot.Type_class.reader -> 'a lazy_t Bin_prot.Type_class.reader
val bin_lazy_t : 'a Bin_prot.Type_class.t -> 'a lazy_t Bin_prot.Type_class.t
val compare_lazy_t : ('a -> 'a -> Core__.Import.int) -> 'a lazy_t -> 'a lazy_t -> Core__.Import.int
val hash_fold_lazy_t : (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state) -> Ppx_hash_lib.Std.Hash.state -> 'a lazy_t -> Ppx_hash_lib.Std.Hash.state
val sexp_of_lazy_t : ('a -> Sexplib0.Sexp.t) -> 'a lazy_t -> Sexplib0.Sexp.t
val lazy_t_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a lazy_t
val lazy_t_sexp_grammar : 'a Sexplib0.Sexp_grammar.t -> 'a lazy_t Sexplib0.Sexp_grammar.t
val typerep_of_lazy_t : 'a Typerep_lib.Std.Typerep.t -> 'a lazy_t Typerep_lib.Std.Typerep.t
val typename_of_lazy_t : 'a Typerep_lib.Std.Typename.t -> 'a lazy_t Typerep_lib.Std.Typename.t
val bin_shape_list : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_list : 'a Bin_prot.Size.sizer -> 'a Core__.Import.list Bin_prot.Size.sizer
val bin_write_list : 'a Bin_prot.Write.writer -> 'a Core__.Import.list Bin_prot.Write.writer
val bin_writer_list : 'a Bin_prot.Type_class.writer -> 'a Core__.Import.list Bin_prot.Type_class.writer
val bin_read_list : 'a Bin_prot.Read.reader -> 'a Core__.Import.list Bin_prot.Read.reader
val __bin_read_list__ : 'a Bin_prot.Read.reader -> (Core__.Import.int -> 'a Core__.Import.list) Bin_prot.Read.reader
val bin_reader_list : 'a Bin_prot.Type_class.reader -> 'a Core__.Import.list Bin_prot.Type_class.reader
val bin_list : 'a Bin_prot.Type_class.t -> 'a Core__.Import.list Bin_prot.Type_class.t
val compare_list : ('a -> 'a -> Core__.Import.int) -> 'a Core__.Import.list -> 'a Core__.Import.list -> Core__.Import.int
val equal_list : ('a -> 'a -> Core__.Import.bool) -> 'a Core__.Import.list -> 'a Core__.Import.list -> Core__.Import.bool
val hash_fold_list : (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state) -> Ppx_hash_lib.Std.Hash.state -> 'a Core__.Import.list -> Ppx_hash_lib.Std.Hash.state
val sexp_of_list : ('a -> Sexplib0.Sexp.t) -> 'a Core__.Import.list -> Sexplib0.Sexp.t
val list_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a Core__.Import.list
val list_sexp_grammar : 'a Sexplib0.Sexp_grammar.t -> 'a Core__.Import.list Sexplib0.Sexp_grammar.t
val typerep_of_list : 'a Typerep_lib.Std.Typerep.t -> 'a Core__.Import.list Typerep_lib.Std.Typerep.t
val typename_of_list : 'a Typerep_lib.Std.Typename.t -> 'a Core__.Import.list Typerep_lib.Std.Typename.t
val bin_shape_nativeint : Bin_prot.Shape.t
val bin_size_nativeint : Core__.Import.nativeint Bin_prot.Size.sizer
val bin_write_nativeint : Core__.Import.nativeint Bin_prot.Write.writer
val bin_writer_nativeint : Core__.Import.nativeint Bin_prot.Type_class.writer
val bin_read_nativeint : Core__.Import.nativeint Bin_prot.Read.reader
val __bin_read_nativeint__ : (Core__.Import.int -> Core__.Import.nativeint) Bin_prot.Read.reader
val bin_reader_nativeint : Core__.Import.nativeint Bin_prot.Type_class.reader
val bin_nativeint : Core__.Import.nativeint Bin_prot.Type_class.t
val compare_nativeint : Core__.Import.nativeint -> Core__.Import.nativeint -> Core__.Import.int
val equal_nativeint : Core__.Import.nativeint -> Core__.Import.nativeint -> Core__.Import.bool
val hash_fold_nativeint : Ppx_hash_lib.Std.Hash.state -> Core__.Import.nativeint -> Ppx_hash_lib.Std.Hash.state
val hash_nativeint : Core__.Import.nativeint -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_nativeint : Core__.Import.nativeint -> Sexplib0.Sexp.t
val nativeint_of_sexp : Sexplib0.Sexp.t -> Core__.Import.nativeint
val nativeint_sexp_grammar : Core__.Import.nativeint Sexplib0.Sexp_grammar.t
val typerep_of_nativeint : Core__.Import.nativeint Typerep_lib.Std.Typerep.t
val typename_of_nativeint : Core__.Import.nativeint Typerep_lib.Std.Typename.t
val bin_shape_option : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_option : 'a Bin_prot.Size.sizer -> 'a Core__.Import.option Bin_prot.Size.sizer
val bin_write_option : 'a Bin_prot.Write.writer -> 'a Core__.Import.option Bin_prot.Write.writer
val bin_writer_option : 'a Bin_prot.Type_class.writer -> 'a Core__.Import.option Bin_prot.Type_class.writer
val bin_read_option : 'a Bin_prot.Read.reader -> 'a Core__.Import.option Bin_prot.Read.reader
val __bin_read_option__ : 'a Bin_prot.Read.reader -> (Core__.Import.int -> 'a Core__.Import.option) Bin_prot.Read.reader
val bin_reader_option : 'a Bin_prot.Type_class.reader -> 'a Core__.Import.option Bin_prot.Type_class.reader
val bin_option : 'a Bin_prot.Type_class.t -> 'a Core__.Import.option Bin_prot.Type_class.t
val compare_option : ('a -> 'a -> Core__.Import.int) -> 'a Core__.Import.option -> 'a Core__.Import.option -> Core__.Import.int
val equal_option : ('a -> 'a -> Core__.Import.bool) -> 'a Core__.Import.option -> 'a Core__.Import.option -> Core__.Import.bool
val hash_fold_option : (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state) -> Ppx_hash_lib.Std.Hash.state -> 'a Core__.Import.option -> Ppx_hash_lib.Std.Hash.state
val sexp_of_option : ('a -> Sexplib0.Sexp.t) -> 'a Core__.Import.option -> Sexplib0.Sexp.t
val option_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a Core__.Import.option
val option_sexp_grammar : 'a Sexplib0.Sexp_grammar.t -> 'a Core__.Import.option Sexplib0.Sexp_grammar.t
val typerep_of_option : 'a Typerep_lib.Std.Typerep.t -> 'a Core__.Import.option Typerep_lib.Std.Typerep.t
val typename_of_option : 'a Typerep_lib.Std.Typename.t -> 'a Core__.Import.option Typerep_lib.Std.Typename.t
val bin_shape_string : Bin_prot.Shape.t
val bin_size_string : Core__.Import.string Bin_prot.Size.sizer
val bin_write_string : Core__.Import.string Bin_prot.Write.writer
val bin_writer_string : Core__.Import.string Bin_prot.Type_class.writer
val bin_read_string : Core__.Import.string Bin_prot.Read.reader
val __bin_read_string__ : (Core__.Import.int -> Core__.Import.string) Bin_prot.Read.reader
val bin_reader_string : Core__.Import.string Bin_prot.Type_class.reader
val bin_string : Core__.Import.string Bin_prot.Type_class.t
val compare_string : Core__.Import.string -> Core__.Import.string -> Core__.Import.int
val equal_string : Core__.Import.string -> Core__.Import.string -> Core__.Import.bool
val hash_fold_string : Ppx_hash_lib.Std.Hash.state -> Core__.Import.string -> Ppx_hash_lib.Std.Hash.state
val hash_string : Core__.Import.string -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_string : Core__.Import.string -> Sexplib0.Sexp.t
val string_of_sexp : Sexplib0.Sexp.t -> Core__.Import.string
val string_sexp_grammar : Core__.Import.string Sexplib0.Sexp_grammar.t
val typerep_of_string : Core__.Import.string Typerep_lib.Std.Typerep.t
val typename_of_string : Core__.Import.string Typerep_lib.Std.Typename.t
val bin_shape_bytes : Bin_prot.Shape.t
val bin_size_bytes : Core__.Import.bytes Bin_prot.Size.sizer
val bin_write_bytes : Core__.Import.bytes Bin_prot.Write.writer
val bin_writer_bytes : Core__.Import.bytes Bin_prot.Type_class.writer
val bin_read_bytes : Core__.Import.bytes Bin_prot.Read.reader
val __bin_read_bytes__ : (Core__.Import.int -> Core__.Import.bytes) Bin_prot.Read.reader
val bin_reader_bytes : Core__.Import.bytes Bin_prot.Type_class.reader
val bin_bytes : Core__.Import.bytes Bin_prot.Type_class.t
val compare_bytes : Core__.Import.bytes -> Core__.Import.bytes -> Core__.Import.int
val equal_bytes : Core__.Import.bytes -> Core__.Import.bytes -> Core__.Import.bool
val sexp_of_bytes : Core__.Import.bytes -> Sexplib0.Sexp.t
val bytes_of_sexp : Sexplib0.Sexp.t -> Core__.Import.bytes
val bytes_sexp_grammar : Core__.Import.bytes Sexplib0.Sexp_grammar.t
val typerep_of_bytes : Core__.Import.bytes Typerep_lib.Std.Typerep.t
val typename_of_bytes : Core__.Import.bytes Typerep_lib.Std.Typename.t
val bin_shape_ref : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_ref : 'a Bin_prot.Size.sizer -> 'a ref Bin_prot.Size.sizer
val bin_write_ref : 'a Bin_prot.Write.writer -> 'a ref Bin_prot.Write.writer
val bin_writer_ref : 'a Bin_prot.Type_class.writer -> 'a ref Bin_prot.Type_class.writer
val bin_read_ref : 'a Bin_prot.Read.reader -> 'a ref Bin_prot.Read.reader
val __bin_read_ref__ : 'a Bin_prot.Read.reader -> (Core__.Import.int -> 'a ref) Bin_prot.Read.reader
val bin_reader_ref : 'a Bin_prot.Type_class.reader -> 'a ref Bin_prot.Type_class.reader
val bin_ref : 'a Bin_prot.Type_class.t -> 'a ref Bin_prot.Type_class.t
val compare_ref : ('a -> 'a -> Core__.Import.int) -> 'a ref -> 'a ref -> Core__.Import.int
val equal_ref : ('a -> 'a -> Core__.Import.bool) -> 'a ref -> 'a ref -> Core__.Import.bool
val sexp_of_ref : ('a -> Sexplib0.Sexp.t) -> 'a ref -> Sexplib0.Sexp.t
val ref_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a ref
val ref_sexp_grammar : 'a Sexplib0.Sexp_grammar.t -> 'a ref Sexplib0.Sexp_grammar.t
val typerep_of_ref : 'a Typerep_lib.Std.Typerep.t -> 'a ref Typerep_lib.Std.Typerep.t
val typename_of_ref : 'a Typerep_lib.Std.Typename.t -> 'a ref Typerep_lib.Std.Typename.t
val bin_shape_unit : Bin_prot.Shape.t
val bin_size_unit : Core__.Import.unit Bin_prot.Size.sizer
val bin_write_unit : Core__.Import.unit Bin_prot.Write.writer
val bin_writer_unit : Core__.Import.unit Bin_prot.Type_class.writer
val bin_read_unit : Core__.Import.unit Bin_prot.Read.reader
val __bin_read_unit__ : (Core__.Import.int -> Core__.Import.unit) Bin_prot.Read.reader
val bin_reader_unit : Core__.Import.unit Bin_prot.Type_class.reader
val bin_unit : Core__.Import.unit Bin_prot.Type_class.t
val compare_unit : Core__.Import.unit -> Core__.Import.unit -> Core__.Import.int
val equal_unit : Core__.Import.unit -> Core__.Import.unit -> Core__.Import.bool
val hash_fold_unit : Ppx_hash_lib.Std.Hash.state -> Core__.Import.unit -> Ppx_hash_lib.Std.Hash.state
val hash_unit : Core__.Import.unit -> Ppx_hash_lib.Std.Hash.hash_value
val sexp_of_unit : Core__.Import.unit -> Sexplib0.Sexp.t
val unit_of_sexp : Sexplib0.Sexp.t -> Core__.Import.unit
val unit_sexp_grammar : Core__.Import.unit Sexplib0.Sexp_grammar.t
val typerep_of_unit : Core__.Import.unit Typerep_lib.Std.Typerep.t
val typename_of_unit : Core__.Import.unit Typerep_lib.Std.Typename.t
type float_array = Core__.Import.float Core__.Import.array
  • deprecated [since 2021-09] use [float array] or [floatarray] instead
val bin_shape_float_array : Bin_prot.Shape.t
val bin_size_float_array : float_array Bin_prot.Size.sizer
val bin_write_float_array : float_array Bin_prot.Write.writer
val bin_writer_float_array : float_array Bin_prot.Type_class.writer
val bin_read_float_array : float_array Bin_prot.Read.reader
val __bin_read_float_array__ : (Core__.Import.int -> float_array) Bin_prot.Read.reader
val bin_reader_float_array : float_array Bin_prot.Type_class.reader
val bin_float_array : float_array Bin_prot.Type_class.t
val compare_float_array : float_array -> float_array -> Core__.Import.int
val sexp_of_float_array : float_array -> Sexplib0.Sexp.t
val float_array_of_sexp : Sexplib0.Sexp.t -> float_array
val float_array_sexp_grammar : float_array Sexplib0.Sexp_grammar.t
val typerep_of_float_array : float_array Typerep_lib.Std.Typerep.t
val typename_of_float_array : float_array Typerep_lib.Std.Typename.t
val sexp_of_exn : Core__.Import.Exn.t -> Sexplib0.Sexp.t
exception Not_found
  • deprecated [since 2018-02] Instead of raising [Not_found], consider using [raise_s] with an informative error message. If code needs to distinguish [Not_found] from other exceptions, please change it to handle both [Not_found] and [Not_found_s]. Then, instead of raising [Not_found], raise [Not_found_s] with an informative error message.
exception Not_found_s of Sexplib0.Sexp.t
type !'a _maybe_bound = 'a Maybe_bound.t =
  1. | Incl of 'a
  2. | Excl of 'a
  3. | Unbounded
val am_running_inline_test : bool
val am_running_test : bool
val does_raise : (unit -> 'a) -> bool
val sec : Core__.Import.float -> Core__.Time_float.Span.t
val (^/) : Core__.Import.string -> Core__.Import.string -> Core__.Import.string
module Core_private = Core.Core_private
module Core_kernel_private = Core_private
module Unix = Core_unix
module Str = Re.Str
module Filename : sig ... end
module Sys : sig ... end
val compare : No_polymorphic_compare.compare
val equal : No_polymorphic_compare.compare
val (=) : No_polymorphic_compare.compare
val failwith : 'a -> [ `use_Logging_die_instead ]
val failwithf : 'a -> [ `use_Logging_die_instead ]
val invalid_arg : 'a -> [ `use_Logging_die_instead ]
val invalid_argf : 'a -> [ `use_Logging_die_instead ]
val exit : [> `In_general_prefer_using_Logging_exit_over_Pervasives_exit ]
module ANSITerminal : module type of ANSITerminal