package core

  1. Overview
  2. Docs
package core
Legend:
Library
Module
Module type
Parameter
Class
Class type
  • deprecated [since 2021-05] Use [Core_stable] -- [Core_kernel] was renamed as [Core]
module Unit_test = Stable_unit_test.Make
module type Stable = sig ... end
module type Stable_without_comparator = sig ... end
module type Stable1 = sig ... end
module type Stable2 = sig ... end
module type Stable3 = sig ... end
module type Stable4 = sig ... end
module type Stable_with_witness = sig ... end
module type Stable_int63able_with_witness = sig ... end
module type Stable_without_comparator_with_witness = sig ... end
module type Stable1_with_witness = sig ... end
module type Stable2_with_witness = sig ... end
module type Stable3_with_witness = sig ... end
module type Stable4_with_witness = sig ... end
module Make_stable : sig ... end
include module type of struct include Bin_prot.Std end
include module type of struct include Bin_prot.Size end
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
type 'a sizer_local = 'a -> int
type ('a, 'b) sizer_local1 = 'a sizer_local -> 'b sizer_local
type ('a, 'b, 'c) sizer_local2 = 'a sizer_local -> ('b, 'c) sizer_local1
type ('a, 'b, 'c, 'd) sizer_local3 = 'a sizer_local -> ('b, 'c, 'd) sizer_local2
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 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_floatarray : floatarray 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_md5 : Md5_lib.t sizer
val bin_size_unit__local : unit sizer_local
val bin_size_bool__local : bool sizer_local
val bin_size_string__local : string sizer_local
val bin_size_bytes__local : bytes sizer_local
val bin_size_char__local : char sizer_local
val bin_size_int__local : int sizer_local
val bin_size_float__local : float sizer_local
val bin_size_int32__local : int32 sizer_local
val bin_size_int64__local : int64 sizer_local
val bin_size_nativeint__local : nativeint sizer_local
val bin_size_nat0__local : Bin_prot.Nat0.t sizer_local
val bin_size_ref__local : ('a, 'a ref) sizer_local1
val bin_size_lazy_t__local : ('a, 'a lazy_t) sizer_local1
val bin_size_lazy__local : ('a, 'a lazy_t) sizer_local1
val bin_size_option__local : ('a, 'a option) sizer_local1
val bin_size_pair__local : ('a, 'b, 'a * 'b) sizer_local2
val bin_size_triple__local : ('a, 'b, 'c, 'a * 'b * 'c) sizer_local3
val bin_size_list__local : ('a, 'a list) sizer_local1
val bin_size_array__local : ('a, 'a array) sizer_local1
val bin_size_float32_vec__local : Bin_prot.Common.vec32 sizer_local
val bin_size_float64_vec__local : Bin_prot.Common.vec64 sizer_local
val bin_size_vec__local : Bin_prot.Common.vec sizer_local
val bin_size_float32_mat__local : Bin_prot.Common.mat32 sizer_local
val bin_size_float64_mat__local : Bin_prot.Common.mat64 sizer_local
val bin_size_mat__local : Bin_prot.Common.mat sizer_local
val bin_size_bigstring__local : Bin_prot.Common.buf sizer_local
val bin_size_floatarray__local : floatarray sizer_local
val bin_size_variant_int__local : int sizer_local
val bin_size_int_8bit__local : int sizer_local
val bin_size_int_16bit__local : int sizer_local
val bin_size_int_32bit__local : int sizer_local
val bin_size_int_64bit__local : int sizer_local
val bin_size_int64_bits__local : int64 sizer_local
val bin_size_network16_int__local : int sizer_local
val bin_size_network32_int__local : int sizer_local
val bin_size_network32_int32__local : int32 sizer_local
val bin_size_network64_int__local : int sizer_local
val bin_size_network64_int64__local : int64 sizer_local
val bin_size_md5__local : Md5_lib.t sizer_local
module Maximum = Bin_prot.Std.Maximum
module Minimum = Bin_prot.Std.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_write_unit__local : unit Bin_prot.Write.writer_local
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 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_write_bool__local : bool Bin_prot.Write.writer_local
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 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_write_string__local : string Bin_prot.Write.writer_local
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 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_write_bytes__local : bytes Bin_prot.Write.writer_local
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 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_write_char__local : char Bin_prot.Write.writer_local
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 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_write_int__local : int Bin_prot.Write.writer_local
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 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_write_float__local : float Bin_prot.Write.writer_local
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 ref -> 'b -> 'c
val bin_floatarray : floatarray Bin_prot.Type_class.t
val bin_shape_floatarray : Bin_prot.Shape.t
val bin_writer_floatarray : floatarray Bin_prot.Type_class.writer
val bin_write_floatarray : floatarray Bin_prot.Write.writer
val bin_write_floatarray__local : floatarray Bin_prot.Write.writer_local
val bin_reader_floatarray : floatarray Bin_prot.Type_class.reader
val bin_read_floatarray : floatarray Bin_prot.Read.reader
val __bin_read_floatarray__ : 'a -> pos_ref:Bin_prot.Common.pos 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_write_int32__local : int32 Bin_prot.Write.writer_local
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 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_write_int64__local : int64 Bin_prot.Write.writer_local
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 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_write_nativeint__local : nativeint Bin_prot.Write.writer_local
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 ref -> 'b -> 'c
val bin_ref : ('a, 'a 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 ref) Bin_prot.Type_class.S1.writer
val bin_write_ref : ('a, 'a ref) Bin_prot.Write.writer1
val bin_write_ref__local : ('a, 'a ref) Bin_prot.Write.writer_local1
val bin_reader_ref : ('a, 'a ref) Bin_prot.Type_class.S1.reader
val bin_read_ref : ('a, 'a ref) Bin_prot.Read.reader1
val __bin_read_ref__ : 'a -> 'b -> pos_ref:Bin_prot.Common.pos 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_write_lazy_t__local : ('a, 'a lazy_t) Bin_prot.Write.writer_local1
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 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_write_lazy__local : ('a, 'a lazy_t) Bin_prot.Write.writer_local1
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 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_write_option__local : ('a, 'a option) Bin_prot.Write.writer_local1
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 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_write_list__local : ('a, 'a list) Bin_prot.Write.writer_local1
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 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_write_array__local : ('a, 'a array) Bin_prot.Write.writer_local1
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 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 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_write_bigstring__local : Bin_prot.Common.buf Bin_prot.Write.writer_local
val bin_read_bigstring : Bin_prot.Common.buf Bin_prot.Read.reader
val __bin_read_bigstring__ : 'a -> pos_ref:Bin_prot.Common.pos ref -> 'b -> 'c
val bin_shape_mat : Bin_prot.Shape.t
val bin_write_mat__local : Bin_prot.Common.mat Bin_prot.Write.writer_local
val __bin_read_mat__ : 'a -> pos_ref:Bin_prot.Common.pos 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_write_float32_mat__local : Bin_prot.Common.mat32 Bin_prot.Write.writer_local
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 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_write_float64_mat__local : Bin_prot.Common.mat64 Bin_prot.Write.writer_local
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 ref -> 'b -> 'c
val bin_shape_vec : Bin_prot.Shape.t
val bin_write_vec__local : Bin_prot.Common.vec Bin_prot.Write.writer_local
val __bin_read_vec__ : 'a -> pos_ref:Bin_prot.Common.pos 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_write_float32_vec__local : Bin_prot.Common.vec32 Bin_prot.Write.writer_local
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 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_write_float64_vec__local : Bin_prot.Common.vec64 Bin_prot.Write.writer_local
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 ref -> 'b -> 'c
include module type of struct include Base.Hash.Builtin end
val hash_fold_nativeint : nativeint Base.Hash.folder
val hash_fold_int64 : int64 Base.Hash.folder
val hash_fold_int32 : int32 Base.Hash.folder
val hash_fold_char : char Base.Hash.folder
val hash_fold_int : int Base.Hash.folder
val hash_fold_bool : bool Base.Hash.folder
val hash_fold_string : string Base.Hash.folder
val hash_fold_float : float Base.Hash.folder
val hash_fold_unit : unit Base.Hash.folder
val hash_fold_option : 'a Base.Hash.folder -> 'a option Base.Hash.folder
val hash_fold_list : 'a Base.Hash.folder -> 'a list Base.Hash.folder
val hash_fold_lazy_t : 'a Base.Hash.folder -> 'a lazy_t Base.Hash.folder
val hash_fold_ref_frozen : 'a Base.Hash.folder -> 'a ref Base.Hash.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 Base.Hash.folder -> 'a array Base.Hash.folder
val hash_nativeint : nativeint -> Base.Hash.hash_value
val hash_int64 : int64 -> Base.Hash.hash_value
val hash_int32 : int32 -> Base.Hash.hash_value
val hash_char : char -> Base.Hash.hash_value
val hash_int : int -> Base.Hash.hash_value
val hash_bool : bool -> Base.Hash.hash_value
val hash_string : string -> Base.Hash.hash_value
val hash_float : float -> Base.Hash.hash_value
val hash_unit : unit -> Base.Hash.hash_value
include module type of struct include Stable_witness.Export end
val stable_witness_array : 'a Stable_witness.t -> 'a array Stable_witness.t
val stable_witness_bool : bool Stable_witness.t
val stable_witness_bytes : bytes Stable_witness.t
val stable_witness_char : char Stable_witness.t
val stable_witness_exn : exn Stable_witness.t
val stable_witness_float : float Stable_witness.t
val stable_witness_int : int Stable_witness.t
val stable_witness_int32 : int32 Stable_witness.t
val stable_witness_int64 : int64 Stable_witness.t
val stable_witness_lazy_t : 'a Stable_witness.t -> 'a lazy_t Stable_witness.t
val stable_witness_list : 'a Stable_witness.t -> 'a list Stable_witness.t
val stable_witness_nativeint : nativeint Stable_witness.t
val stable_witness_option : 'a Stable_witness.t -> 'a option Stable_witness.t
val stable_witness_ref : 'a Stable_witness.t -> 'a ref Stable_witness.t
val stable_witness_string : string Stable_witness.t
val stable_witness_unit : unit Stable_witness.t
include sig ... end
val sexp_of_array : ('a -> Sexplib0.Sexp.t) -> 'a Base.Array.t -> Sexplib0.Sexp.t
val array_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a Base.Array.t
val sexp_of_bool : Base.Bool.t -> Sexplib0.Sexp.t
val bool_of_sexp : Sexplib0.Sexp.t -> Base.Bool.t
val bool_sexp_grammar : Base.Bool.t Sexplib0.Sexp_grammar.t
val sexp_of_char : Base.Char.t -> Sexplib0.Sexp.t
val char_of_sexp : Sexplib0.Sexp.t -> Base.Char.t
val char_sexp_grammar : Base.Char.t Sexplib0.Sexp_grammar.t
val sexp_of_exn : Base.Exn.t -> Sexplib0.Sexp.t
val sexp_of_float : Base.Float.t -> Sexplib0.Sexp.t
val float_of_sexp : Sexplib0.Sexp.t -> Base.Float.t
val float_sexp_grammar : Base.Float.t Sexplib0.Sexp_grammar.t
val sexp_of_int : Base.Int.t -> Sexplib0.Sexp.t
val int_of_sexp : Sexplib0.Sexp.t -> Base.Int.t
val int_sexp_grammar : Base.Int.t Sexplib0.Sexp_grammar.t
val sexp_of_int32 : Base.Int32.t -> Sexplib0.Sexp.t
val int32_of_sexp : Sexplib0.Sexp.t -> Base.Int32.t
val int32_sexp_grammar : Base.Int32.t Sexplib0.Sexp_grammar.t
val sexp_of_int64 : Base.Int64.t -> Sexplib0.Sexp.t
val int64_of_sexp : Sexplib0.Sexp.t -> Base.Int64.t
val int64_sexp_grammar : Base.Int64.t Sexplib0.Sexp_grammar.t
val sexp_of_list : ('a -> Sexplib0.Sexp.t) -> 'a Base.List.t -> Sexplib0.Sexp.t
val list_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a Base.List.t
val sexp_of_nativeint : Base.Nativeint.t -> Sexplib0.Sexp.t
val nativeint_of_sexp : Sexplib0.Sexp.t -> Base.Nativeint.t
val nativeint_sexp_grammar : Base.Nativeint.t Sexplib0.Sexp_grammar.t
val sexp_of_option : ('a -> Sexplib0.Sexp.t) -> 'a Base.Option.t -> Sexplib0.Sexp.t
val option_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a Base.Option.t
val sexp_of_ref : ('a -> Sexplib0.Sexp.t) -> 'a Base.Ref.t -> Sexplib0.Sexp.t
val ref_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a Base.Ref.t
val sexp_of_string : Base.String.t -> Sexplib0.Sexp.t
val string_of_sexp : Sexplib0.Sexp.t -> Base.String.t
val string_sexp_grammar : Base.String.t Sexplib0.Sexp_grammar.t
val sexp_of_bytes : Base.Bytes.t -> Sexplib0.Sexp.t
val bytes_of_sexp : Sexplib0.Sexp.t -> Base.Bytes.t
val bytes_sexp_grammar : Base.Bytes.t Sexplib0.Sexp_grammar.t
val sexp_of_unit : Base.Unit.t -> Sexplib0.Sexp.t
val unit_of_sexp : Sexplib0.Sexp.t -> Base.Unit.t
val unit_sexp_grammar : Base.Unit.t Sexplib0.Sexp_grammar.t
module Hashable = Hashable.Stable
module Bigstring = Bigstring.Stable
module Binable = Binable.Stable
module Blang = Blang.Stable
module Bool = Bool.Stable
module Byte_units = Byte_units.Stable
module Bytes = Bytes.Stable
module Char = Char.Stable
module Comparable = Comparable.Stable
module Comparator = Comparator.Stable
module Date = Date.Stable
module Day_of_week = Day_of_week.Stable
module Md5 = Md5.Stable
module Either = Either.Stable
module Error = Error.Stable
module Fdeque = Fdeque.Stable
module Filename = Filename.Stable
module Float = Float.Stable
module Float_with_finite_only_serialization = Float_with_finite_only_serialization.Stable
module Fqueue = Fqueue.Stable
module Gc = Gc.Stable
module Host_and_port = Host_and_port.Stable
module Info = Info.Stable
module Int = Int.Stable
module Int63 = Int63.Stable
module Lazy = Lazy.Stable
module List = List.Stable
module Map = Map.Stable
module Maybe_bound = Maybe_bound.Stable
module Month = Month.Stable
module Nothing = Nothing.Stable
module Option = Option.Stable
module Or_error = Or_error.Stable
module Percent = Percent.Stable
module Perms = Perms.Stable
module Pid = Pid.Stable
module Queue = Queue.Stable
module Result = Result.Stable
module Set = Set.Stable
module Sexp = Sexp.Stable
module Sexpable = Sexpable.Stable
module Source_code_position = Source_code_position.Stable
module String = String.Stable
module String_id = String_id.Stable
module Time_ns = Time_ns.Stable
module Time = Time_float.Stable
module Time_float = Time_float.Stable
module Uchar = Uchar.Stable
module Unit = Unit.Stable
module Unix : sig ... end
include module type of struct include Perms.Export end
type read = 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__ : (Base.Int.t -> read) Bin_prot.Read.reader
val bin_reader_read : read Bin_prot.Type_class.reader
val compare_read : read -> read -> Base.Int.t
val globalize_read : read -> read
val hash_fold_read : Base.Hash.state -> read -> Base.Hash.state
val hash_read : read -> Base.Hash.hash_value
val sexp_of_read : read -> Sexplib0.Sexp.t
val read_of_sexp : Sexplib0.Sexp.t -> read
val equal_read : read -> read -> Base.Bool.t
type write = Perms.Write.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.

val compare_write : write -> write -> Base.Int.t
val equal_write : write -> write -> Base.Bool.t
val hash_fold_write : Base.Hash.state -> write -> Base.Hash.state
val hash_write : write -> Base.Hash.hash_value
val globalize_write : write -> write
val sexp_of_write : write -> Sexplib0.Sexp.t
val write_of_sexp : Sexplib0.Sexp.t -> write
type immutable = 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__ : (Base.Int.t -> 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 -> Base.Int.t
val equal_immutable : immutable -> immutable -> Base.Bool.t
val globalize_immutable : immutable -> immutable
val hash_fold_immutable : Base.Hash.state -> immutable -> Base.Hash.state
val hash_immutable : immutable -> Base.Hash.hash_value
val sexp_of_immutable : immutable -> Sexplib0.Sexp.t
val immutable_of_sexp : Sexplib0.Sexp.t -> immutable
type read_write = 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__ : (Base.Int.t -> 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 -> Base.Int.t
val equal_read_write : read_write -> read_write -> Base.Bool.t
val globalize_read_write : read_write -> read_write
val hash_fold_read_write : Base.Hash.state -> read_write -> Base.Hash.state
val hash_read_write : read_write -> Base.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 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_read_perms : 'a Bin_prot.Read.reader -> 'a perms Bin_prot.Read.reader
val __bin_read_perms__ : 'a Bin_prot.Read.reader -> (Base.Int.t -> 'a perms) Bin_prot.Read.reader
val compare_perms : ('a -> 'a -> Base.Int.t) -> 'a perms -> 'a perms -> Base.Int.t
val equal_perms : ('a -> 'a -> Base.Bool.t) -> 'a perms -> 'a perms -> Base.Bool.t
val globalize_perms : ('a -> 'a) -> 'a perms -> 'a perms
val hash_fold_perms : (Base.Hash.state -> 'a -> Base.Hash.state) -> Base.Hash.state -> 'a perms -> Base.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
include module type of struct include Ppx_compare_lib.Builtin end
val compare_bool : bool -> bool -> int
val compare_char : char -> char -> int
val compare_float : float -> float -> int
val compare_int : int -> int -> int
val compare_int32 : int32 -> int32 -> int
val compare_int64 : int64 -> int64 -> int
val compare_nativeint : nativeint -> nativeint -> int
val compare_string : string -> string -> int
val compare_bytes : bytes -> bytes -> int
val compare_unit : unit -> unit -> int
val compare_array : ('a -> 'a -> int) -> 'a array -> 'a array -> int
val compare_list : ('a -> 'a -> int) -> 'a list -> 'a list -> int
val compare_option : ('a -> 'a -> int) -> 'a option -> 'a option -> int
val compare_ref : ('a -> 'a -> int) -> 'a ref -> 'a ref -> int
val equal_bool : bool -> bool -> bool
val equal_char : char -> char -> bool
val equal_float : float -> float -> bool
val equal_int : int -> int -> bool
val equal_int32 : int32 -> int32 -> bool
val equal_int64 : int64 -> int64 -> bool
val equal_nativeint : nativeint -> nativeint -> bool
val equal_string : string -> string -> bool
val equal_bytes : bytes -> bytes -> bool
val equal_unit : unit -> unit -> bool
val equal_array : ('a -> 'a -> bool) -> 'a array -> 'a array -> bool
val equal_list : ('a -> 'a -> bool) -> 'a list -> 'a list -> bool
val equal_option : ('a -> 'a -> bool) -> 'a option -> 'a option -> bool
val equal_ref : ('a -> 'a -> bool) -> 'a ref -> 'a ref -> bool
val compare_bool__local : bool -> bool -> int
val compare_char__local : char -> char -> int
val compare_float__local : float -> float -> int
val compare_int__local : int -> int -> int
val compare_int32__local : int32 -> int32 -> int
val compare_int64__local : int64 -> int64 -> int
val compare_nativeint__local : nativeint -> nativeint -> int
val compare_string__local : string -> string -> int
val compare_bytes__local : bytes -> bytes -> int
val compare_unit__local : unit -> unit -> int
val compare_array__local : ('a -> 'a -> int) -> 'a array -> 'a array -> int
val compare_list__local : ('a -> 'a -> int) -> 'a list -> 'a list -> int
val compare_option__local : ('a -> 'a -> int) -> 'a option -> 'a option -> int
val compare_ref__local : ('a -> 'a -> int) -> 'a ref -> 'a ref -> int
val equal_bool__local : bool -> bool -> bool
val equal_char__local : char -> char -> bool
val equal_float__local : float -> float -> bool
val equal_int__local : int -> int -> bool
val equal_int32__local : int32 -> int32 -> bool
val equal_int64__local : int64 -> int64 -> bool
val equal_nativeint__local : nativeint -> nativeint -> bool
val equal_string__local : string -> string -> bool
val equal_bytes__local : bytes -> bytes -> bool
val equal_unit__local : unit -> unit -> bool
val equal_array__local : ('a -> 'a -> bool) -> 'a array -> 'a array -> bool
val equal_list__local : ('a -> 'a -> bool) -> 'a list -> 'a list -> bool
val equal_option__local : ('a -> 'a -> bool) -> 'a option -> 'a option -> bool
val equal_ref__local : ('a -> 'a -> bool) -> 'a ref -> 'a ref -> bool
include module type of struct include Base.Exported_for_specific_uses.Globalize end
val globalize_bool : bool -> bool
val globalize_char : char -> char
val globalize_float : float -> float
val globalize_int : int -> int
val globalize_int32 : int32 -> int32
val globalize_int64 : int64 -> int64
val globalize_nativeint : nativeint -> nativeint
val globalize_bytes : bytes -> bytes
val globalize_string : string -> string
val globalize_unit : unit -> unit
val globalize_array : ('a -> 'b) -> 'a array -> 'a array
val globalize_lazy_t : ('a -> 'b) -> 'a lazy_t -> 'a lazy_t
val globalize_list : ('a -> 'b) -> 'a list -> 'b list
val globalize_option : ('a -> 'b) -> 'a option -> 'b option
val globalize_result : ('ok -> 'ok) -> ('err -> 'err) -> ('ok, 'err) result -> ('ok, 'err) result
val globalize_ref : ('a -> 'b) -> 'a ref -> 'a ref
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
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct