Module Core_kernel__.Import

module Applicative = Base.Applicative
module Avltree = Base.Avltree
module Backtrace = Base.Backtrace
module Commutative_group = Base.Commutative_group
module Comparisons = Base.Comparisons
module Equal = Base.Equal
module Exn = Base.Exn
module Floatable = Base.Floatable
module Hash = Base.Hash
module Hasher = Base.Hasher
module Heap_block = Base.Heap_block
module Indexed_container = Base.Indexed_container
module Invariant = Base.Invariant
module Intable = Base.Intable
module Monad = Base.Monad
module Obj_array = Base.Not_exposed_properly.Obj_array
module Poly = Base.Poly
module Polymorphic_compare = Base.Polymorphic_compare
module Popcount = Base.Popcount
module Pretty_printer = Base.Pretty_printer
module Random = Base.Random
module Staged = Base.Staged
module Stringable = Base.Stringable
module Validate = Base.Validate
module With_return = Base.With_return
module Word_size = Base.Word_size
include Base.Export
type 'a array = 'a Base.Array.t
val compare_array : a. ('a ‑> 'a ‑> int) ‑> 'a array ‑> 'a array ‑> int
val array_of_sexp : a. (Base.Sexp.t ‑> 'a) ‑> Base.Sexp.t ‑> 'a array
val sexp_of_array : a. ('a ‑> Base.Sexp.t) ‑> 'a array ‑> Base.Sexp.t
type bool = Base.Bool.t
val compare_bool : bool ‑> bool ‑> int
val hash_fold_bool : Base.Hash.state ‑> bool ‑> Base.Hash.state
val hash_bool : bool ‑> Base.Hash.hash_value
val bool_of_sexp : Base.Sexp.t ‑> bool
val sexp_of_bool : bool ‑> Base.Sexp.t
type char = Base.Char.t
val compare_char : char ‑> char ‑> int
val hash_fold_char : Base.Hash.state ‑> char ‑> Base.Hash.state
val hash_char : char ‑> Base.Hash.hash_value
val char_of_sexp : Base.Sexp.t ‑> char
val sexp_of_char : char ‑> Base.Sexp.t
type exn = Base.Exn.t
val sexp_of_exn : exn ‑> Base.Sexp.t
type float = Base.Float.t
val compare_float : float ‑> float ‑> int
val hash_fold_float : Base.Hash.state ‑> float ‑> Base.Hash.state
val hash_float : float ‑> Base.Hash.hash_value
val float_of_sexp : Base.Sexp.t ‑> float
val sexp_of_float : float ‑> Base.Sexp.t
type int = Base.Int.t
val compare_int : int ‑> int ‑> int
val hash_fold_int : Base.Hash.state ‑> int ‑> Base.Hash.state
val hash_int : int ‑> Base.Hash.hash_value
val int_of_sexp : Base.Sexp.t ‑> int
val sexp_of_int : int ‑> Base.Sexp.t
type int32 = Base.Int32.t
val compare_int32 : int32 ‑> int32 ‑> int
val hash_fold_int32 : Base.Hash.state ‑> int32 ‑> Base.Hash.state
val hash_int32 : int32 ‑> Base.Hash.hash_value
val int32_of_sexp : Base.Sexp.t ‑> int32
val sexp_of_int32 : int32 ‑> Base.Sexp.t
type int64 = Base.Int64.t
val compare_int64 : int64 ‑> int64 ‑> int
val hash_fold_int64 : Base.Hash.state ‑> int64 ‑> Base.Hash.state
val hash_int64 : int64 ‑> Base.Hash.hash_value
val int64_of_sexp : Base.Sexp.t ‑> int64
val sexp_of_int64 : int64 ‑> Base.Sexp.t
type 'a list = 'a Base.List.t
val compare_list : a. ('a ‑> 'a ‑> int) ‑> 'a list ‑> 'a list ‑> int
val hash_fold_list : a. (Base.Hash.state ‑> 'a ‑> Base.Hash.state) ‑> Base.Hash.state ‑> 'a list ‑> Base.Hash.state
val list_of_sexp : a. (Base.Sexp.t ‑> 'a) ‑> Base.Sexp.t ‑> 'a list
val sexp_of_list : a. ('a ‑> Base.Sexp.t) ‑> 'a list ‑> Base.Sexp.t
type nativeint = Base.Nativeint.t
val compare_nativeint : nativeint ‑> nativeint ‑> int
val hash_fold_nativeint : Base.Hash.state ‑> nativeint ‑> Base.Hash.state
val hash_nativeint : nativeint ‑> Base.Hash.hash_value
val nativeint_of_sexp : Base.Sexp.t ‑> nativeint
val sexp_of_nativeint : nativeint ‑> Base.Sexp.t
type 'a option = 'a Base.Option.t
val compare_option : a. ('a ‑> 'a ‑> int) ‑> 'a option ‑> 'a option ‑> int
val hash_fold_option : a. (Base.Hash.state ‑> 'a ‑> Base.Hash.state) ‑> Base.Hash.state ‑> 'a option ‑> Base.Hash.state
val option_of_sexp : a. (Base.Sexp.t ‑> 'a) ‑> Base.Sexp.t ‑> 'a option
val sexp_of_option : a. ('a ‑> Base.Sexp.t) ‑> 'a option ‑> Base.Sexp.t
type 'a ref = 'a Base.Ref.t
val compare_ref : a. ('a ‑> 'a ‑> int) ‑> 'a ref ‑> 'a ref ‑> int
val ref_of_sexp : a. (Base.Sexp.t ‑> 'a) ‑> Base.Sexp.t ‑> 'a ref
val sexp_of_ref : a. ('a ‑> Base.Sexp.t) ‑> 'a ref ‑> Base.Sexp.t
type string = Base.String.t
val compare_string : string ‑> string ‑> int
val hash_fold_string : Base.Hash.state ‑> string ‑> Base.Hash.state
val hash_string : string ‑> Base.Hash.hash_value
val string_of_sexp : Base.Sexp.t ‑> string
val sexp_of_string : string ‑> Base.Sexp.t
type bytes = Base.Bytes.t
val compare_bytes : bytes ‑> bytes ‑> int
val bytes_of_sexp : Base.Sexp.t ‑> bytes
val sexp_of_bytes : bytes ‑> Base.Sexp.t
type unit = Base.Unit.t
val compare_unit : unit ‑> unit ‑> int
val hash_fold_unit : Base.Hash.state ‑> unit ‑> Base.Hash.state
val hash_unit : unit ‑> Base.Hash.hash_value
val unit_of_sexp : Base.Sexp.t ‑> unit
val sexp_of_unit : unit ‑> Base.Sexp.t

Format stuff

type ('a, 'b, 'c) format = ('a, 'b, 'c) Pervasives.format
type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'd) Pervasives.format4
type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) Pervasives.format6

Sexp

Exporting the ad-hoc types that are recognized by ppx_sexp_* converters. sexp_array, sexp_list, and sexp_option allow a record field to be absent when converting from a sexp, and if absent, the field will take a default value of the appropriate type:

        sexp_array   [||]
        sexp_bool    false
        sexp_list    []
        sexp_option  None

sexp_opaque causes the conversion to sexp to produce the atom <opaque>.

For more documentation, see sexplib/README.md.

type 'a sexp_array = 'a array
type 'a sexp_list = 'a list
type 'a sexp_opaque = 'a
type 'a sexp_option = 'a option

List operators

include Base.List.Infix
val (@) : 'a Base__List.t ‑> 'a Base__List.t ‑> 'a Base__List.t

Int operators and comparisons

include Base.Int.O

A sub-module designed to be opened to make working with ints more convenient.

include Base__.Int_intf.Operators_unbounded
type t
val (+) : t ‑> t ‑> t
val (-) : t ‑> t ‑> t
val (*) : t ‑> t ‑> t
val (/) : t ‑> t ‑> t
val (~-) : t ‑> t
val (**) : t ‑> t ‑> t
include Base.Comparisons.Infix with type t := t
type t
val (>=) : t ‑> t ‑> bool
val (<=) : t ‑> t ‑> bool
val (=) : t ‑> t ‑> bool
val (>) : t ‑> t ‑> bool
val (<) : t ‑> t ‑> bool
val (<>) : t ‑> t ‑> bool
val abs : t ‑> t
val neg : t ‑> t
val zero : t
val (%) : t ‑> t ‑> t
val (/%) : t ‑> t ‑> t
val (//) : t ‑> t ‑> float
val (land) : t ‑> t ‑> t
val (lor) : t ‑> t ‑> t
val (lxor) : t ‑> t ‑> t
val (lnot) : t ‑> t
val (lsl) : t ‑> int ‑> t
val (asr) : t ‑> int ‑> t
val (lsr) : t ‑> int ‑> t
include Base__.Import.Int_replace_polymorphic_compare
val (<) : int ‑> int ‑> bool
val (<=) : int ‑> int ‑> bool
val (<>) : int ‑> int ‑> bool
val (=) : int ‑> int ‑> bool
val (>) : int ‑> int ‑> bool
val (>=) : int ‑> int ‑> bool
val ascending : int ‑> int ‑> int
val descending : int ‑> int ‑> int
val compare : int ‑> int ‑> int
val equal : int ‑> int ‑> bool
val max : int ‑> int ‑> int
val min : int ‑> int ‑> int

Float operators

include Base.Float.O_dot

Similar to O, except that operators are suffixed with a dot, allowing one to have both int and float operators in scope simultaneously.

Similar to O, except that operators are suffixed with a dot, allowing one to have both int and float operators in scope simultaneously.

val (**.) : Base.Float.t ‑> Base.Float.t ‑> Base.Float.t
val (~-.) : Base.Float.t ‑> Base.Float.t
external (|>) : 'a ‑> ('a ‑> 'b) ‑> 'b = "%revapply"

Reverse application operator. x |> g |> f is equivalent to f (g (x)).

external (@@) : ('a ‑> 'b) ‑> 'a ‑> 'b = "%apply"

Application operator. g @@ f @@ x is equivalent to g (f (x)).

Boolean operations

external (&&) : bool ‑> bool ‑> bool = "%sequand"
external (||) : bool ‑> bool ‑> bool = "%sequor"
external not : bool ‑> bool = "%boolnot"
external ignore : _ ‑> unit = "%ignore"
val (^) : Base.String.t ‑> Base.String.t ‑> Base.String.t

Common string operations

Reference operations

external (!) : 'a ref ‑> 'a = "%field0"
external ref : 'a ‑> 'a ref = "%makemutable"
external (:=) : 'a ref ‑> 'a ‑> unit = "%setfield0"

Pair operations

val fst : ('a * 'b) ‑> 'a
val snd : ('a * 'b) ‑> 'b

Exceptions stuff

val failwith : string ‑> 'a
val invalid_arg : string ‑> 'a
val raise : exn ‑> 'a
val raise_s : Base.Sexp.t ‑> 'a

Misc

val phys_equal : 'a ‑> 'a ‑> bool
external force : 'a Base.Lazy.t ‑> 'a = "%lazy_force"
include Stdio
module In_channel = Stdio.In_channel
module Out_channel = Stdio.Out_channel
val stdin : In_channel.t

Same as In_channel.stdin

val stdout : Out_channel.t

Same as Out_channel.stdout

val stderr : Out_channel.t

Same as Out_channel.stderr

val printf : ('a, Out_channel.t, Base.unit) Base.format ‑> 'a

Same as Out_channel.printf

val eprintf : ('a, Out_channel.t, Base.unit) Base.format ‑> 'a

Same as Out_channel.eprintf

val print_endline : Base.string ‑> Base.unit

Same as Out_channel.print_endline

val prerr_endline : Base.string ‑> Base.unit

Same as Out_channel.prerr_endline

include Base_for_tests
module Test_binary_searchable = Base_for_tests__Test_binary_searchable
module Test_binary_searchable_intf = Base_for_tests__Test_binary_searchable_intf
module Test_blit = Base_for_tests__Test_blit
module Test_blit_intf = Base_for_tests__Test_blit_intf
include Bin_prot.Std

This module defines default converters for the types defined in the OCaml standard library.

include Bin_prot.Size

Compute size of values in the binary protocol.

type 'a sizer = 'a ‑> int
type ('a, 'b) sizer1 = 'a sizer ‑> 'b sizer
type ('a, 'b, 'c) sizer2 = 'a sizer ‑> ('b, 'c) sizer1
type ('a, 'b, 'c, 'd) sizer3 = 'a sizer ‑> ('b, 'c, 'd) sizer2
val bin_size_unit : unit sizer
val bin_size_bool : bool sizer
val bin_size_string : string sizer
val bin_size_bytes : bytes sizer
val bin_size_char : char sizer
val bin_size_int : int sizer
val bin_size_float : float sizer
val bin_size_int32 : int32 sizer
val bin_size_int64 : int64 sizer
val bin_size_nativeint : nativeint sizer
val bin_size_nat0 : Bin_prot.Nat0.t sizer
val bin_size_ref : ('a, 'a Pervasives.ref) sizer1
val bin_size_lazy_t : ('a, 'a lazy_t) sizer1
val bin_size_lazy : ('a, 'a lazy_t) sizer1
val bin_size_option : ('a, 'a option) sizer1
val bin_size_pair : ('a, 'b, 'a * 'b) sizer2
val bin_size_triple : ('a, 'b, 'c, 'a * 'b * 'c) sizer3
val bin_size_list : ('a, 'a list) sizer1
val bin_size_array : ('a, 'a array) sizer1
val bin_size_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) sizer2
val bin_size_float32_vec : Bin_prot.Common.vec32 sizer
val bin_size_float64_vec : Bin_prot.Common.vec64 sizer
val bin_size_vec : Bin_prot.Common.vec sizer
val bin_size_float32_mat : Bin_prot.Common.mat32 sizer
val bin_size_float64_mat : Bin_prot.Common.mat64 sizer
val bin_size_mat : Bin_prot.Common.mat sizer
val bin_size_bigstring : Bin_prot.Common.buf sizer
val bin_size_float_array : float array sizer
val bin_size_variant_int : int sizer
val bin_size_int_8bit : int sizer
val bin_size_int_16bit : int sizer
val bin_size_int_32bit : int sizer
val bin_size_int_64bit : int sizer
val bin_size_int64_bits : int64 sizer
val bin_size_network16_int : int sizer
val bin_size_network32_int : int sizer
val bin_size_network32_int32 : int32 sizer
val bin_size_network64_int : int sizer
val bin_size_network64_int64 : int64 sizer
val bin_size_array_no_length : ('a, 'a array) sizer1
  • Deprecated [since 2016-03] this function was deprecated as it is misleading and unused
val bin_size_md5 : Md5_lib.t sizer
module Maximum = Bin_prot.Size.Maximum
module Minimum = Bin_prot.Size.Minimum
val bin_unit : unit Bin_prot.Type_class.t
val bin_shape_unit : Bin_prot.Shape.t
val bin_writer_unit : unit Bin_prot.Type_class.writer
val bin_write_unit : unit Bin_prot.Write.writer
val bin_reader_unit : unit Bin_prot.Type_class.reader
val bin_read_unit : unit Bin_prot.Read.reader
val __bin_read_unit__ : 'a ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'b ‑> 'c
val bin_bool : bool Bin_prot.Type_class.t
val bin_shape_bool : Bin_prot.Shape.t
val bin_writer_bool : bool Bin_prot.Type_class.writer
val bin_write_bool : bool Bin_prot.Write.writer
val bin_reader_bool : bool Bin_prot.Type_class.reader
val bin_read_bool : bool Bin_prot.Read.reader
val __bin_read_bool__ : 'a ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'b ‑> 'c
val bin_string : string Bin_prot.Type_class.t
val bin_shape_string : Bin_prot.Shape.t
val bin_writer_string : string Bin_prot.Type_class.writer
val bin_write_string : string Bin_prot.Write.writer
val bin_reader_string : string Bin_prot.Type_class.reader
val bin_read_string : string Bin_prot.Read.reader
val __bin_read_string__ : 'a ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'b ‑> 'c
val bin_bytes : bytes Bin_prot.Type_class.t
val bin_shape_bytes : Bin_prot.Shape.t
val bin_writer_bytes : bytes Bin_prot.Type_class.writer
val bin_write_bytes : bytes Bin_prot.Write.writer
val bin_reader_bytes : bytes Bin_prot.Type_class.reader
val bin_read_bytes : bytes Bin_prot.Read.reader
val __bin_read_bytes__ : 'a ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'b ‑> 'c
val bin_char : char Bin_prot.Type_class.t
val bin_shape_char : Bin_prot.Shape.t
val bin_writer_char : char Bin_prot.Type_class.writer
val bin_write_char : char Bin_prot.Write.writer
val bin_reader_char : char Bin_prot.Type_class.reader
val bin_read_char : char Bin_prot.Read.reader
val __bin_read_char__ : 'a ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'b ‑> 'c
val bin_int : int Bin_prot.Type_class.t
val bin_shape_int : Bin_prot.Shape.t
val bin_writer_int : int Bin_prot.Type_class.writer
val bin_write_int : int Bin_prot.Write.writer
val bin_reader_int : int Bin_prot.Type_class.reader
val bin_read_int : int Bin_prot.Read.reader
val __bin_read_int__ : 'a ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'b ‑> 'c
val bin_float : float Bin_prot.Type_class.t
val bin_shape_float : Bin_prot.Shape.t
val bin_writer_float : float Bin_prot.Type_class.writer
val bin_write_float : float Bin_prot.Write.writer
val bin_reader_float : float Bin_prot.Type_class.reader
val bin_read_float : float Bin_prot.Read.reader
val __bin_read_float__ : 'a ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'b ‑> 'c
type float_array = float array
val bin_shape_float_array : Bin_prot.Shape.t
val bin_write_float_array : float array Bin_prot.Write.writer
val bin_read_float_array : float array Bin_prot.Read.reader
val __bin_read_float_array__ : 'a ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'b ‑> 'c
val bin_int32 : int32 Bin_prot.Type_class.t
val bin_shape_int32 : Bin_prot.Shape.t
val bin_writer_int32 : int32 Bin_prot.Type_class.writer
val bin_write_int32 : int32 Bin_prot.Write.writer
val bin_reader_int32 : int32 Bin_prot.Type_class.reader
val bin_read_int32 : int32 Bin_prot.Read.reader
val __bin_read_int32__ : 'a ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'b ‑> 'c
val bin_int64 : int64 Bin_prot.Type_class.t
val bin_shape_int64 : Bin_prot.Shape.t
val bin_writer_int64 : int64 Bin_prot.Type_class.writer
val bin_write_int64 : int64 Bin_prot.Write.writer
val bin_reader_int64 : int64 Bin_prot.Type_class.reader
val bin_read_int64 : int64 Bin_prot.Read.reader
val __bin_read_int64__ : 'a ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'b ‑> 'c
val bin_nativeint : nativeint Bin_prot.Type_class.t
val bin_shape_nativeint : Bin_prot.Shape.t
val bin_writer_nativeint : nativeint Bin_prot.Type_class.writer
val bin_write_nativeint : nativeint Bin_prot.Write.writer
val bin_reader_nativeint : nativeint Bin_prot.Type_class.reader
val bin_read_nativeint : nativeint Bin_prot.Read.reader
val __bin_read_nativeint__ : 'a ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'b ‑> 'c
val bin_ref : ('a, 'a Pervasives.ref) Bin_prot.Type_class.S1.t
val bin_shape_ref : Bin_prot.Shape.t ‑> Bin_prot.Shape.t
val bin_writer_ref : ('a, 'a Pervasives.ref) Bin_prot.Type_class.S1.writer
val bin_write_ref : ('a, 'a Pervasives.ref) Bin_prot.Write.writer1
val bin_reader_ref : ('a, 'a Pervasives.ref) Bin_prot.Type_class.S1.reader
val bin_read_ref : ('a, 'a Pervasives.ref) Bin_prot.Read.reader1
val __bin_read_ref__ : 'a ‑> 'b ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'c ‑> 'd
val bin_lazy_t : ('a, 'a lazy_t) Bin_prot.Type_class.S1.t
val bin_shape_lazy_t : Bin_prot.Shape.t ‑> Bin_prot.Shape.t
val bin_writer_lazy_t : ('a, 'a lazy_t) Bin_prot.Type_class.S1.writer
val bin_write_lazy_t : ('a, 'a lazy_t) Bin_prot.Write.writer1
val bin_reader_lazy_t : ('a, 'a lazy_t) Bin_prot.Type_class.S1.reader
val bin_read_lazy_t : ('a, 'a lazy_t) Bin_prot.Read.reader1
val __bin_read_lazy_t__ : 'a ‑> 'b ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'c ‑> 'd
val bin_lazy : ('a, 'a lazy_t) Bin_prot.Type_class.S1.t
val bin_shape_lazy : Bin_prot.Shape.t ‑> Bin_prot.Shape.t
val bin_writer_lazy : ('a, 'a lazy_t) Bin_prot.Type_class.S1.writer
val bin_write_lazy : ('a, 'a lazy_t) Bin_prot.Write.writer1
val bin_reader_lazy : ('a, 'a lazy_t) Bin_prot.Type_class.S1.reader
val bin_read_lazy : ('a, 'a lazy_t) Bin_prot.Read.reader1
val __bin_read_lazy__ : 'a ‑> 'b ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'c ‑> 'd
val bin_option : ('a, 'a option) Bin_prot.Type_class.S1.t
val bin_shape_option : Bin_prot.Shape.t ‑> Bin_prot.Shape.t
val bin_writer_option : ('a, 'a option) Bin_prot.Type_class.S1.writer
val bin_write_option : ('a, 'a option) Bin_prot.Write.writer1
val bin_reader_option : ('a, 'a option) Bin_prot.Type_class.S1.reader
val bin_read_option : ('a, 'a option) Bin_prot.Read.reader1
val __bin_read_option__ : 'a ‑> 'b ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'c ‑> 'd
val bin_list : ('a, 'a list) Bin_prot.Type_class.S1.t
val bin_shape_list : Bin_prot.Shape.t ‑> Bin_prot.Shape.t
val bin_writer_list : ('a, 'a list) Bin_prot.Type_class.S1.writer
val bin_write_list : ('a, 'a list) Bin_prot.Write.writer1
val bin_reader_list : ('a, 'a list) Bin_prot.Type_class.S1.reader
val bin_read_list : ('a, 'a list) Bin_prot.Read.reader1
val __bin_read_list__ : 'a ‑> 'b ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'c ‑> 'd
val bin_array : ('a, 'a array) Bin_prot.Type_class.S1.t
val bin_shape_array : Bin_prot.Shape.t ‑> Bin_prot.Shape.t
val bin_writer_array : ('a, 'a array) Bin_prot.Type_class.S1.writer
val bin_write_array : ('a, 'a array) Bin_prot.Write.writer1
val bin_reader_array : ('a, 'a array) Bin_prot.Type_class.S1.reader
val bin_read_array : ('a, 'a array) Bin_prot.Read.reader1
val __bin_read_array__ : 'a ‑> 'b ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'c ‑> 'd
val bin_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) Bin_prot.Type_class.S2.t
val bin_shape_hashtbl : Bin_prot.Shape.t ‑> Bin_prot.Shape.t ‑> Bin_prot.Shape.t
val bin_writer_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) Bin_prot.Type_class.S2.writer
val bin_write_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) Bin_prot.Write.writer2
val bin_reader_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) Bin_prot.Type_class.S2.reader
val bin_read_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) Bin_prot.Read.reader2
val __bin_read_hashtbl__ : 'a ‑> 'b ‑> 'c ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'd ‑> 'e
val bin_shape_bigstring : Bin_prot.Shape.t
val bin_write_bigstring : Bin_prot.Common.buf Bin_prot.Write.writer
val bin_read_bigstring : Bin_prot.Common.buf Bin_prot.Read.reader
val __bin_read_bigstring__ : 'a ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'b ‑> 'c
val bin_shape_mat : Bin_prot.Shape.t
val __bin_read_mat__ : 'a ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'b ‑> 'c
val bin_shape_float32_mat : Bin_prot.Shape.t
val bin_write_float32_mat : Bin_prot.Common.mat32 Bin_prot.Write.writer
val bin_read_float32_mat : Bin_prot.Common.mat32 Bin_prot.Read.reader
val __bin_read_float32_mat__ : 'a ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'b ‑> 'c
val bin_shape_float64_mat : Bin_prot.Shape.t
val bin_write_float64_mat : Bin_prot.Common.mat64 Bin_prot.Write.writer
val bin_read_float64_mat : Bin_prot.Common.mat64 Bin_prot.Read.reader
val __bin_read_float64_mat__ : 'a ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'b ‑> 'c
val bin_shape_vec : Bin_prot.Shape.t
val __bin_read_vec__ : 'a ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'b ‑> 'c
val bin_shape_float32_vec : Bin_prot.Shape.t
val bin_write_float32_vec : Bin_prot.Common.vec32 Bin_prot.Write.writer
val bin_read_float32_vec : Bin_prot.Common.vec32 Bin_prot.Read.reader
val __bin_read_float32_vec__ : 'a ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'b ‑> 'c
val bin_shape_float64_vec : Bin_prot.Shape.t
val bin_write_float64_vec : Bin_prot.Common.vec64 Bin_prot.Write.writer
val bin_read_float64_vec : Bin_prot.Common.vec64 Bin_prot.Read.reader
val __bin_read_float64_vec__ : 'a ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'b ‑> 'c
module Field = Fieldslib.Field
module From_sexplib : sig ... end
include From_sexplib
type bigstring = Sexplib.Conv.bigstring
include sig ... end
val bigstring_of_sexp : Base.Sexp.t ‑> bigstring
val sexp_of_bigstring : bigstring ‑> Base.Sexp.t
type mat = Sexplib.Conv.mat
include sig ... end
val mat_of_sexp : Base.Sexp.t ‑> mat
val sexp_of_mat : mat ‑> Base.Sexp.t
type vec = Sexplib.Conv.vec
include sig ... end
val vec_of_sexp : Base.Sexp.t ‑> vec
val sexp_of_vec : vec ‑> Base.Sexp.t
val sexp_of_opaque : _ ‑> Base.Sexp.t
val opaque_of_sexp : Base.Sexp.t ‑> _
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 exn * Base.Sexp.t
val of_sexp_error : string ‑> Base.Sexp.t ‑> _
val of_sexp_error_exn : exn ‑> Base.Sexp.t ‑> _
include sig ... end with type a sexp_opaque := a sexp_opaque
type 'a sexp_opaque
include sig ... end
val bin_read_sexp_opaque : 'a Bin_prot.Read.reader ‑> 'a sexp_opaque Bin_prot.Read.reader
val __bin_read_sexp_opaque__ : 'a Bin_prot.Read.reader ‑> (int ‑> 'a sexp_opaque) Bin_prot.Read.reader
val bin_reader_sexp_opaque : 'a Bin_prot.Type_class.reader ‑> 'a sexp_opaque Bin_prot.Type_class.reader
val bin_size_sexp_opaque : 'a Bin_prot.Size.sizer ‑> 'a sexp_opaque Bin_prot.Size.sizer
val bin_write_sexp_opaque : 'a Bin_prot.Write.writer ‑> 'a sexp_opaque Bin_prot.Write.writer
val bin_writer_sexp_opaque : 'a Bin_prot.Type_class.writer ‑> 'a sexp_opaque Bin_prot.Type_class.writer
val bin_shape_sexp_opaque : Bin_prot.Shape.t ‑> Bin_prot.Shape.t
val compare_sexp_opaque : ('a ‑> 'a ‑> int) ‑> 'a sexp_opaque ‑> 'a sexp_opaque ‑> int
val hash_fold_sexp_opaque : (Base.Hash.state ‑> 'a ‑> Base.Hash.state) ‑> Base.Hash.state ‑> 'a sexp_opaque ‑> Base.Hash.state
val typerep_of_sexp_opaque : 'a Typerep_lib.Std.Typerep.t ‑> 'a sexp_opaque Typerep_lib.Std.Typerep.t
val typename_of_sexp_opaque : 'a Typerep_lib.Std.Typename.t ‑> 'a sexp_opaque Typerep_lib.Std.Typename.t
include module type of sig ... end with module Type_equal := Typerep_lib.Std.Type_equal
module Type_abstract = Typerep_lib.Type_abstract
module Type_equal = Typerep_lib.Type_equal
module Type_generic = Typerep_lib.Type_generic
module Typename = Typerep_lib.Typename
module Make_typename = Typerep_lib.Make_typename
module Type_named_intf = Typerep_lib.Named_intf
module Typerepable = Typerep_lib.Typerepable
module Typerep_obj = Typerep_lib.Typerep_obj
val typerep_of_int : int Typerep.t
val typerep_of_int32 : int32 Typerep.t
val typerep_of_int64 : int64 Typerep.t
val typerep_of_nativeint : nativeint Typerep.t
val typerep_of_char : char Typerep.t
val typerep_of_float : float Typerep.t
val typerep_of_string : string Typerep.t
val typerep_of_bytes : bytes Typerep.t
val typerep_of_bool : bool Typerep.t
val typerep_of_unit : unit Typerep.t
val value_tuple0 : tuple0
val typerep_of_option : 'a Typerep.t ‑> 'a option Typerep.t
val typerep_of_list : 'a Typerep.t ‑> 'a list Typerep.t
val typerep_of_array : 'a Typerep.t ‑> 'a array Typerep.t
val typerep_of_lazy_t : 'a Typerep.t ‑> 'a lazy_t Typerep.t
val typerep_of_ref : 'a Typerep.t ‑> 'a Pervasives.ref Typerep.t
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_int : int Typerep_lib.Typename.t
val typename_of_int32 : int32 Typerep_lib.Typename.t
val typename_of_int64 : int64 Typerep_lib.Typename.t
val typename_of_nativeint : nativeint Typerep_lib.Typename.t
val typename_of_char : char Typerep_lib.Typename.t
val typename_of_float : float Typerep_lib.Typename.t
val typename_of_string : string Typerep_lib.Typename.t
val typename_of_bytes : bytes Typerep_lib.Typename.t
val typename_of_bool : bool Typerep_lib.Typename.t
val typename_of_unit : unit Typerep_lib.Typename.t
val typename_of_option : 'a Typerep_lib.Typename.t ‑> 'a option Typerep_lib.Typename.t
val typename_of_list : 'a Typerep_lib.Typename.t ‑> 'a list Typerep_lib.Typename.t
val typename_of_array : 'a Typerep_lib.Typename.t ‑> 'a array Typerep_lib.Typename.t
val typename_of_lazy_t : 'a Typerep_lib.Typename.t ‑> 'a lazy_t Typerep_lib.Typename.t
val typename_of_ref : 'a Typerep_lib.Typename.t ‑> 'a Pervasives.ref 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
module Variant = Variantslib.Variant
val with_return : ('a With_return.return ‑> 'a) ‑> 'a
val am_running_inline_test : bool
type 'a identity = 'a
module Not_found : sig ... end
include Not_found
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