Module Core_kernel__.Import

module Applicative = Base.Applicative
module Avltree = Base.Avltree
module Backtrace = Base.Backtrace
module Comparisons = Base.Comparisons
module Continue_or_stop = Base.Continue_or_stop
module Equal = Base.Equal
module Exn = Base.Exn
module Floatable = Base.Floatable
module Formatter = Base.Formatter
module Hash = Base.Hash
module Hasher = Base.Hasher
module Indexed_container = Base.Indexed_container
module Intable = Base.Intable
module Int_conversions = Base.Int_conversions
module Int_math = Base.Int_math
module Invariant = Base.Invariant
module Monad = Base.Monad
module Poly = Base.Poly
module Popcount = Base.Popcount
module Pretty_printer = Base.Pretty_printer
module Random = Base.Random
module Staged = Base.Staged
module Stringable = Base.Stringable
module Uchar = Base.Uchar
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 equal_array : a. ('a -> 'a -> bool) -> 'a array -> 'a array -> bool
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 equal_bool : bool -> bool -> bool
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 equal_char : char -> char -> bool
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 equal_float : float -> float -> bool
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 equal_int : int -> int -> bool
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 equal_int32 : int32 -> int32 -> bool
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 equal_int64 : int64 -> int64 -> bool
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 equal_list : a. ('a -> 'a -> bool) -> 'a list -> 'a list -> bool
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 equal_nativeint : nativeint -> nativeint -> bool
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 equal_option : a. ('a -> 'a -> bool) -> 'a option -> 'a option -> bool
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 equal_ref : a. ('a -> 'a -> bool) -> 'a ref -> 'a ref -> bool
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 equal_string : string -> string -> bool
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 equal_bytes : bytes -> bytes -> bool
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 equal_unit : unit -> unit -> bool
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
type nonrec ('a, 'b, 'c) format = ('a, 'b, 'c) Stdlib.format
type nonrec ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'd) Stdlib.format4
type nonrec ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.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
include Base.List.Infix
val (@) : 'a Base__List.t -> 'a Base__List.t -> 'a Base__List.t
include Base.Int.O
val (+) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (-) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (*) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (/) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (~-) : Base__Int.t -> Base__Int.t
val (**) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (>=) : Base__Int.t -> Base__Int.t -> bool
val (<=) : Base__Int.t -> Base__Int.t -> bool
val (=) : Base__Int.t -> Base__Int.t -> bool
val (>) : Base__Int.t -> Base__Int.t -> bool
val (<) : Base__Int.t -> Base__Int.t -> bool
val (<>) : Base__Int.t -> Base__Int.t -> bool
val abs : Base__Int.t -> Base__Int.t
val neg : Base__Int.t -> Base__Int.t
val zero : Base__Int.t
val (%) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (/%) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (//) : Base__Int.t -> Base__Int.t -> float
val (land) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (lor) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (lxor) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (lnot) : Base__Int.t -> Base__Int.t
val (lsl) : Base__Int.t -> int -> Base__Int.t
val (asr) : Base__Int.t -> int -> Base__Int.t
val (lsr) : Base__Int.t -> int -> Base__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 compare : int -> int -> int
val ascending : int -> int -> int
val descending : int -> int -> int
val equal : int -> int -> bool
val max : int -> int -> int
val min : int -> int -> int
val (|>) : 'a -> ('a -> 'b) -> 'b

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

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

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

val (&&) : bool -> bool -> bool
val (||) : bool -> bool -> bool
val not : bool -> bool
val ignore : _ -> unit
val (^) : Base.String.t -> Base.String.t -> Base.String.t

Common string operations

val (!) : 'a ref -> 'a
val ref : 'a -> 'a ref
val (:=) : 'a ref -> 'a -> unit
val fst : ('a * 'b) -> 'a
val snd : ('a * 'b) -> 'b
val raise : exn -> _
val failwith : string -> 'a
val invalid_arg : string -> 'a
val raise_s : Base.Sexp.t -> 'a
val phys_equal : 'a -> 'a -> bool
val force : 'a Base.Lazy.t -> 'a
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 print_s : ?⁠mach:Base.unit -> Base.Sexp.t -> Base.unit

Same as Out_channel.print_s

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

Same as Out_channel.eprint_s

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

Same as Out_channel.eprintf

val print_string : Base.string -> Base.unit

Same as Out_channel.print_string

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
include Bin_prot.Size
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 Stdlib.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) Stdlib.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
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 Stdlib.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 Stdlib.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 Stdlib.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 Stdlib.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 Stdlib.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 Stdlib.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 Stdlib.ref -> 'b -> 'c
type float_array = float array
val bin_float_array : Bin_prot.Type_class.float_array Bin_prot.Type_class.t
val bin_shape_float_array : Bin_prot.Shape.t
val bin_writer_float_array : Bin_prot.Type_class.float_array Bin_prot.Type_class.writer
val bin_write_float_array : float array Bin_prot.Write.writer
val bin_reader_float_array : Bin_prot.Type_class.float_array Bin_prot.Type_class.reader
val bin_read_float_array : float array Bin_prot.Read.reader
val __bin_read_float_array__ : 'a -> pos_ref:Bin_prot.Common.pos Stdlib.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 Stdlib.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 Stdlib.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 Stdlib.ref -> 'b -> 'c
val bin_ref : ('a, 'a Stdlib.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 Stdlib.ref) Bin_prot.Type_class.S1.writer
val bin_write_ref : ('a, 'a Stdlib.ref) Bin_prot.Write.writer1
val bin_reader_ref : ('a, 'a Stdlib.ref) Bin_prot.Type_class.S1.reader
val bin_read_ref : ('a, 'a Stdlib.ref) Bin_prot.Read.reader1
val __bin_read_ref__ : 'a -> 'b -> pos_ref:Bin_prot.Common.pos Stdlib.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 Stdlib.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 Stdlib.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 Stdlib.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 Stdlib.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 Stdlib.ref -> 'c -> 'd
val bin_hashtbl : ('a, 'b, ('a, 'b) Stdlib.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) Stdlib.Hashtbl.t) Bin_prot.Type_class.S2.writer
val bin_write_hashtbl : ('a, 'b, ('a, 'b) Stdlib.Hashtbl.t) Bin_prot.Write.writer2
val bin_reader_hashtbl : ('a, 'b, ('a, 'b) Stdlib.Hashtbl.t) Bin_prot.Type_class.S2.reader
val bin_read_hashtbl : ('a, 'b, ('a, 'b) Stdlib.Hashtbl.t) Bin_prot.Read.reader2
val __bin_read_hashtbl__ : 'a -> 'b -> 'c -> pos_ref:Bin_prot.Common.pos Stdlib.ref -> 'd -> 'e
val bin_bigstring : Bin_prot.Common.buf Bin_prot.Type_class.t
val bin_shape_bigstring : Bin_prot.Shape.t
val bin_writer_bigstring : Bin_prot.Common.buf Bin_prot.Type_class.writer
val bin_write_bigstring : Bin_prot.Common.buf Bin_prot.Write.writer
val bin_reader_bigstring : Bin_prot.Common.buf Bin_prot.Type_class.reader
val bin_read_bigstring : Bin_prot.Common.buf Bin_prot.Read.reader
val __bin_read_bigstring__ : 'a -> pos_ref:Bin_prot.Common.pos Stdlib.ref -> 'b -> 'c
val bin_mat : Bin_prot.Common.mat Bin_prot.Type_class.t
val bin_shape_mat : Bin_prot.Shape.t
val bin_writer_mat : Bin_prot.Common.mat Bin_prot.Type_class.writer
val bin_write_mat : Bin_prot.Common.mat Bin_prot.Write.writer
val bin_reader_mat : Bin_prot.Common.mat Bin_prot.Type_class.reader
val bin_read_mat : Bin_prot.Common.mat Bin_prot.Read.reader
val __bin_read_mat__ : 'a -> pos_ref:Bin_prot.Common.pos Stdlib.ref -> 'b -> 'c
val bin_float32_mat : Bin_prot.Common.mat32 Bin_prot.Type_class.t
val bin_shape_float32_mat : Bin_prot.Shape.t
val bin_writer_float32_mat : Bin_prot.Common.mat32 Bin_prot.Type_class.writer
val bin_write_float32_mat : Bin_prot.Common.mat32 Bin_prot.Write.writer
val bin_reader_float32_mat : Bin_prot.Common.mat32 Bin_prot.Type_class.reader
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 Stdlib.ref -> 'b -> 'c
val bin_float64_mat : Bin_prot.Common.mat64 Bin_prot.Type_class.t
val bin_shape_float64_mat : Bin_prot.Shape.t
val bin_writer_float64_mat : Bin_prot.Common.mat64 Bin_prot.Type_class.writer
val bin_write_float64_mat : Bin_prot.Common.mat64 Bin_prot.Write.writer
val bin_reader_float64_mat : Bin_prot.Common.mat64 Bin_prot.Type_class.reader
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 Stdlib.ref -> 'b -> 'c
val bin_vec : Bin_prot.Common.vec Bin_prot.Type_class.t
val bin_shape_vec : Bin_prot.Shape.t
val bin_writer_vec : Bin_prot.Common.vec Bin_prot.Type_class.writer
val bin_write_vec : Bin_prot.Common.vec Bin_prot.Write.writer
val bin_reader_vec : Bin_prot.Common.vec Bin_prot.Type_class.reader
val bin_read_vec : Bin_prot.Common.vec Bin_prot.Read.reader
val __bin_read_vec__ : 'a -> pos_ref:Bin_prot.Common.pos Stdlib.ref -> 'b -> 'c
val bin_float32_vec : Bin_prot.Common.vec32 Bin_prot.Type_class.t
val bin_shape_float32_vec : Bin_prot.Shape.t
val bin_writer_float32_vec : Bin_prot.Common.vec32 Bin_prot.Type_class.writer
val bin_write_float32_vec : Bin_prot.Common.vec32 Bin_prot.Write.writer
val bin_reader_float32_vec : Bin_prot.Common.vec32 Bin_prot.Type_class.reader
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 Stdlib.ref -> 'b -> 'c
val bin_float64_vec : Bin_prot.Common.vec64 Bin_prot.Type_class.t
val bin_shape_float64_vec : Bin_prot.Shape.t
val bin_writer_float64_vec : Bin_prot.Common.vec64 Bin_prot.Type_class.writer
val bin_write_float64_vec : Bin_prot.Common.vec64 Bin_prot.Write.writer
val bin_reader_float64_vec : Bin_prot.Common.vec64 Bin_prot.Type_class.reader
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 Stdlib.ref -> 'b -> 'c
module Field = Fieldslib.Field
module From_sexplib : sig ... end
include From_sexplib
type bigstring = Sexplib.Conv.bigstring
val sexp_of_bigstring : bigstring -> Ppx_sexp_conv_lib.Sexp.t
val bigstring_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> bigstring
type mat = Sexplib.Conv.mat
val sexp_of_mat : mat -> Ppx_sexp_conv_lib.Sexp.t
val mat_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> mat
type vec = Sexplib.Conv.vec
val sexp_of_vec : vec -> Ppx_sexp_conv_lib.Sexp.t
val vec_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> vec
val sexp_of_opaque : _ -> 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
type 'a sexp_opaque
val bin_shape_sexp_opaque : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_sexp_opaque : 'a Bin_prot.Size.sizer -> 'a sexp_opaque Bin_prot.Size.sizer
val bin_write_sexp_opaque : 'a Bin_prot.Write.writer -> 'a sexp_opaque Bin_prot.Write.writer
val bin_writer_sexp_opaque : 'a Bin_prot.Type_class.writer -> 'a sexp_opaque Bin_prot.Type_class.writer
val bin_read_sexp_opaque : 'a Bin_prot.Read.reader -> '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_sexp_opaque : 'a Bin_prot.Type_class.t -> 'a sexp_opaque Bin_prot.Type_class.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_int63 : Base.Int63.t 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
type tuple0 = Typerep_lib__Std_internal.tuple0
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 Stdlib.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_int63 : Base.Int63.t 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 Stdlib.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
val am_running_test : bool
type 'a identity = 'a
module Not_found : sig ... end
include Not_found
exception Not_found
exception Not_found_s of Sexplib0.Sexp.t