Module Core_kernel__.Stable

module Unit_test = Core_kernel.Stable_unit_test.Make
module Unit_tests : sig ... end
module type Stable = Core_kernel__.Stable_module_types.S0
module type Stable_without_comparator = Core_kernel__.Stable_module_types.S0_without_comparator
module type Stable1 = Core_kernel__.Stable_module_types.S1
module type Stable2 = Core_kernel__.Stable_module_types.S2
module type Stable3 = Core_kernel__.Stable_module_types.S3
module type Stable4 = Core_kernel__.Stable_module_types.S4
module Make_stable = Core_kernel__.Make_stable
include Core_kernel__.Stable_internal
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_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
val bin_size_digest : Bin_prot.Shape.Digest.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_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
include Core_kernel__.Import.Hash.Builtin
type state
type 'a folder = state ‑> 'a ‑> state
val hash_fold_nativeint : nativeint folder
val hash_fold_int64 : int64 folder
val hash_fold_int32 : int32 folder
val hash_fold_char : char folder
val hash_fold_int : int folder
val hash_fold_bool : bool folder
val hash_fold_string : string folder
val hash_fold_float : float folder
val hash_fold_unit : unit folder
val hash_fold_option : 'a folder ‑> 'a option folder
val hash_fold_list : 'a folder ‑> 'a list folder
val hash_fold_lazy_t : 'a folder ‑> 'a lazy_t folder
val hash_fold_ref_frozen : 'a folder ‑> 'a Base__.Import0.ref folder

Hash support for array and ref is provided, but is potentially DANGEROUS, since it incorporates the current contents of the array/ref into the hash value. Because of this we add a _frozen suffix to the function name.

Hash support for string is also potentially DANGEROUS, but strings are mutated less often, so we don't append _frozen to it.

Also note that we don't support bytes.

val hash_fold_array_frozen : 'a folder ‑> 'a array folder
include sig ... end with type a array := a Core_kernel__.Import.array with type bool := Core_kernel__.Import.bool with type char := Core_kernel__.Import.char with type exn := Core_kernel__.Import.exn with type float := Core_kernel__.Import.float with type int := Core_kernel__.Import.int with type int32 := Core_kernel__.Import.int32 with type int64 := Core_kernel__.Import.int64 with type a list := a Core_kernel__.Import.list with type nativeint := Core_kernel__.Import.nativeint with type a option := a Core_kernel__.Import.option with type a ref := a Core_kernel__.Import.ref with type string := Core_kernel__.Import.string with type unit := Core_kernel__.Import.unit
type 'a array = 'a Core_kernel__.Import.array
include sig ... end
val array_of_sexp : (Sexplib.Sexp.t ‑> 'a) ‑> Sexplib.Sexp.t ‑> 'a array
val sexp_of_array : ('a ‑> Sexplib.Sexp.t) ‑> 'a array ‑> Sexplib.Sexp.t
include sig ... end
val bool_of_sexp : Sexplib.Sexp.t ‑> bool
val sexp_of_bool : bool ‑> Sexplib.Sexp.t
include sig ... end
val char_of_sexp : Sexplib.Sexp.t ‑> char
val sexp_of_char : char ‑> Sexplib.Sexp.t
include sig ... end
val sexp_of_exn : exn ‑> Sexplib.Sexp.t
include sig ... end
val float_of_sexp : Sexplib.Sexp.t ‑> float
val sexp_of_float : float ‑> Sexplib.Sexp.t
include sig ... end
val int_of_sexp : Sexplib.Sexp.t ‑> int
val sexp_of_int : int ‑> Sexplib.Sexp.t
include sig ... end
val int32_of_sexp : Sexplib.Sexp.t ‑> int32
val sexp_of_int32 : int32 ‑> Sexplib.Sexp.t
include sig ... end
val int64_of_sexp : Sexplib.Sexp.t ‑> int64
val sexp_of_int64 : int64 ‑> Sexplib.Sexp.t
type 'a list = 'a Core_kernel__.Import.list
include sig ... end
val list_of_sexp : (Sexplib.Sexp.t ‑> 'a) ‑> Sexplib.Sexp.t ‑> 'a list
val sexp_of_list : ('a ‑> Sexplib.Sexp.t) ‑> 'a list ‑> Sexplib.Sexp.t
include sig ... end
val nativeint_of_sexp : Sexplib.Sexp.t ‑> nativeint
val sexp_of_nativeint : nativeint ‑> Sexplib.Sexp.t
type 'a option = 'a Core_kernel__.Import.option
include sig ... end
val option_of_sexp : (Sexplib.Sexp.t ‑> 'a) ‑> Sexplib.Sexp.t ‑> 'a option
val sexp_of_option : ('a ‑> Sexplib.Sexp.t) ‑> 'a option ‑> Sexplib.Sexp.t
type 'a ref = 'a Core_kernel__.Import.ref
include sig ... end
val ref_of_sexp : (Sexplib.Sexp.t ‑> 'a) ‑> Sexplib.Sexp.t ‑> 'a ref
val sexp_of_ref : ('a ‑> Sexplib.Sexp.t) ‑> 'a ref ‑> Sexplib.Sexp.t
include sig ... end
val string_of_sexp : Sexplib.Sexp.t ‑> string
val sexp_of_string : string ‑> Sexplib.Sexp.t
include sig ... end
val unit_of_sexp : Sexplib.Sexp.t ‑> unit
val sexp_of_unit : unit ‑> Sexplib.Sexp.t
val compare_sexp_option : a. ('a ‑> 'a ‑> Core_kernel__.Import.int) ‑> 'a sexp_option ‑> 'a sexp_option ‑> Core_kernel__.Import.int
val bin_shape_sexp_option : Bin_prot.Shape.t ‑> Bin_prot.Shape.t
val bin_size_sexp_option : 'a Bin_prot.Size.sizer ‑> 'a Core_kernel__.Import.option ‑> int
val __bin_read_sexp_option__ : 'a Bin_prot.Read.reader ‑> Bin_prot.Common.buf ‑> pos_ref:Bin_prot.Common.pos_ref ‑> Core_kernel__.Import.int ‑> 'a Core_kernel__.Import.option
val compare_sexp_list : a. ('a ‑> 'a ‑> Core_kernel__.Import.int) ‑> 'a sexp_list ‑> 'a sexp_list ‑> Core_kernel__.Import.int
val bin_shape_sexp_list : Bin_prot.Shape.t ‑> Bin_prot.Shape.t
val bin_size_sexp_list : 'a Bin_prot.Size.sizer ‑> 'a Core_kernel__.Import.list ‑> int
val __bin_read_sexp_list__ : 'a Bin_prot.Read.reader ‑> Bin_prot.Common.buf ‑> pos_ref:Bin_prot.Common.pos_ref ‑> Core_kernel__.Import.int ‑> 'a Core_kernel__.Import.list
include Core_kernel__.Stable_containers

The Stable versions of Hashtbl, Hash_set, Map, and Set are defined here rather than in their respective modules because:

1. We guarantee their serializations independent of the implementation of those modules 2. Given 1. it is cleaner (and still okay) to separate the code into a separate file

module Binable = Core_kernel.Binable.Stable
module Blang = Core_kernel.Blang.Stable
module Byte_units = Core_kernel.Byte_units.Stable
module Comparable = Core_kernel.Comparable.Stable
module Comparator = Core_kernel.Comparator.Stable
module Date = Core_kernel.Date.Stable
module Day_of_week = Core_kernel.Day_of_week.Stable
module Either = Core_kernel.Either.Stable
module Error = Core_kernel.Error.Stable
module Fdeque = Core_kernel.Fdeque.Stable
module Float_with_finite_only_serialization = Core_kernel.Float_with_finite_only_serialization.Stable
module Fqueue = Core_kernel.Fqueue.Stable
module Host_and_port = Core_kernel.Host_and_port.Stable
module Info = Core_kernel.Info.Stable
module Int = Core_kernel__.Core_int.Stable
module Int63 = Core_kernel__.Core_int63.Stable
module Lazy = Core_kernel__.Core_lazy.Stable
module Map = Core_kernel__.Core_map.Stable
module Month = Core_kernel.Month.Stable
module Nothing = Core_kernel.Nothing.Stable
module Or_error = Core_kernel.Or_error.Stable
module Percent = Core_kernel.Percent.Stable
module Perms = Core_kernel.Perms.Stable
module Pid = Core_kernel.Pid.Stable
module Result = Core_kernel.Result.Stable
module Set = Core_kernel__.Core_set.Stable
module Sexpable = Core_kernel.Sexpable.Stable
module Source_code_position = Core_kernel.Source_code_position.Stable
module String = Core_kernel__.Core_string.Stable
module String_id = Core_kernel.String_id.Stable
module Time_ns = Core_kernel.Time_ns.Stable
include Perms.Export
type read = Core_kernel.Perms.Read.t

We don't expose bin_io for write due to a naming conflict with the functions exported by bin_io for read_write. If you want bin_io for write, use Write.t.

include sig ... end
val read_of_sexp : Sexplib.Sexp.t ‑> read
val sexp_of_read : read ‑> Sexplib.Sexp.t
val compare_read : read ‑> read ‑> Core_kernel__.Import.int
val bin_read_read : read Bin_prot.Read.reader
val __bin_read_read__ : (Core_kernel__.Import.int ‑> read) Bin_prot.Read.reader
val bin_reader_read : read Bin_prot.Type_class.reader
val bin_size_read : read Bin_prot.Size.sizer
val bin_write_read : read Bin_prot.Write.writer
val bin_writer_read : read Bin_prot.Type_class.writer
val bin_shape_read : Bin_prot.Shape.t
include sig ... end
val write_of_sexp : Sexplib.Sexp.t ‑> write
val sexp_of_write : write ‑> Sexplib.Sexp.t
val compare_write : write ‑> write ‑> Core_kernel__.Import.int
include sig ... end
val immutable_of_sexp : Sexplib.Sexp.t ‑> immutable
val sexp_of_immutable : immutable ‑> Sexplib.Sexp.t
val compare_immutable : immutable ‑> immutable ‑> Core_kernel__.Import.int
val bin_immutable : immutable Bin_prot.Type_class.t
val bin_read_immutable : immutable Bin_prot.Read.reader
val __bin_read_immutable__ : (Core_kernel__.Import.int ‑> immutable) Bin_prot.Read.reader
val bin_reader_immutable : immutable Bin_prot.Type_class.reader
val bin_size_immutable : immutable Bin_prot.Size.sizer
val bin_write_immutable : immutable Bin_prot.Write.writer
val bin_writer_immutable : immutable Bin_prot.Type_class.writer
val bin_shape_immutable : Bin_prot.Shape.t
include sig ... end
val read_write_of_sexp : Sexplib.Sexp.t ‑> read_write
val sexp_of_read_write : read_write ‑> Sexplib.Sexp.t
val hash_read_write : read_write ‑> Ppx_hash_lib.Std.Hash.hash_value
val compare_read_write : read_write ‑> read_write ‑> Core_kernel__.Import.int
val bin_read_write : read_write Bin_prot.Type_class.t
val bin_read_read_write : read_write Bin_prot.Read.reader
val __bin_read_read_write__ : (Core_kernel__.Import.int ‑> read_write) Bin_prot.Read.reader
val bin_reader_read_write : read_write Bin_prot.Type_class.reader
val bin_size_read_write : read_write Bin_prot.Size.sizer
val bin_write_read_write : read_write Bin_prot.Write.writer
val bin_writer_read_write : read_write Bin_prot.Type_class.writer
val bin_shape_read_write : Bin_prot.Shape.t
include sig ... end
val perms_of_sexp : (Sexplib.Sexp.t ‑> 'a) ‑> Sexplib.Sexp.t ‑> 'a perms
val sexp_of_perms : ('a ‑> Sexplib.Sexp.t) ‑> 'a perms ‑> Sexplib.Sexp.t
val compare_perms : ('a ‑> 'a ‑> Core_kernel__.Import.int) ‑> 'a perms ‑> 'a perms ‑> Core_kernel__.Import.int
val bin_read_perms : 'a Bin_prot.Read.reader ‑> 'a perms Bin_prot.Read.reader
val __bin_read_perms__ : 'a Bin_prot.Read.reader ‑> (Core_kernel__.Import.int ‑> 'a perms) Bin_prot.Read.reader
val bin_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_shape_perms : Bin_prot.Shape.t ‑> Bin_prot.Shape.t
include Ppx_compare_lib.Builtin
type 'a t = 'a ‑> 'a ‑> int
val compare_bool : bool t
val compare_char : char t
val compare_float : float t
val compare_int : int t
val compare_int32 : int32 t
val compare_int64 : int64 t
val compare_nativeint : nativeint t
val compare_string : string t
val compare_unit : unit t
val compare_array : 'a t ‑> 'a array t
val compare_list : 'a t ‑> 'a list t
val compare_option : 'a t ‑> 'a option t
val compare_ref : 'a t ‑> 'a Pervasives.ref t