package core

  1. Overview
  2. Docs
Legend:
Library
Module
Module type
Parameter
Class
Class type
include module type of Core_kernel.Core_kernel_stable with module Time_ns := Core_kernel.Core_kernel_stable.Time_ns with module Time := Core_kernel.Core_kernel_stable.Time
module Unit_tests : sig ... end
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 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
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.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_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
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 Base__.Import0.ref Base__Hash.folder
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 sig ... end
include sig ... end
val array_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a Base.Array.t
val sexp_of_array : ('a -> Sexplib.Sexp.t) -> 'a Base.Array.t -> Sexplib.Sexp.t
include sig ... end
val bool_of_sexp : Sexplib.Sexp.t -> Base.Bool.t
val sexp_of_bool : Base.Bool.t -> Sexplib.Sexp.t
include sig ... end
val char_of_sexp : Sexplib.Sexp.t -> Base.Char.t
val sexp_of_char : Base.Char.t -> Sexplib.Sexp.t
include sig ... end
val sexp_of_exn : Base.Exn.t -> Sexplib.Sexp.t
include sig ... end
val float_of_sexp : Sexplib.Sexp.t -> Base.Float.t
val sexp_of_float : Base.Float.t -> Sexplib.Sexp.t
include sig ... end
val int_of_sexp : Sexplib.Sexp.t -> Base.Int.t
val sexp_of_int : Base.Int.t -> Sexplib.Sexp.t
include sig ... end
val int32_of_sexp : Sexplib.Sexp.t -> Base.Int32.t
val sexp_of_int32 : Base.Int32.t -> Sexplib.Sexp.t
include sig ... end
val int64_of_sexp : Sexplib.Sexp.t -> Base.Int64.t
val sexp_of_int64 : Base.Int64.t -> Sexplib.Sexp.t
include sig ... end
val list_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a Base.List.t
val sexp_of_list : ('a -> Sexplib.Sexp.t) -> 'a Base.List.t -> Sexplib.Sexp.t
include sig ... end
val nativeint_of_sexp : Sexplib.Sexp.t -> Base.Nativeint.t
val sexp_of_nativeint : Base.Nativeint.t -> Sexplib.Sexp.t
include sig ... end
val option_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a Base.Option.t
val sexp_of_option : ('a -> Sexplib.Sexp.t) -> 'a Base.Option.t -> Sexplib.Sexp.t
include sig ... end
val ref_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a Base.Ref.t
val sexp_of_ref : ('a -> Sexplib.Sexp.t) -> 'a Base.Ref.t -> Sexplib.Sexp.t
include sig ... end
val string_of_sexp : Sexplib.Sexp.t -> Base.String.t
val sexp_of_string : Base.String.t -> Sexplib.Sexp.t
include sig ... end
val bytes_of_sexp : Sexplib.Sexp.t -> Base.Bytes.t
val sexp_of_bytes : Base.Bytes.t -> Sexplib.Sexp.t
include sig ... end
val unit_of_sexp : Sexplib.Sexp.t -> Base.Unit.t
val sexp_of_unit : Base.Unit.t -> Sexplib.Sexp.t
type 'a sexp_option = 'a Base.Option.t
val bin_shape_sexp_option : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_sexp_option : 'a Bin_prot.Size.sizer -> 'a Base.Option.t -> int
val bin_write_sexp_option : 'a Bin_prot.Write.writer -> Bin_prot.Common.buf -> pos:Bin_prot.Common.pos -> 'a Base.Option.t -> Bin_prot.Common.pos
val bin_writer_sexp_option : 'a Bin_prot.Type_class.writer -> 'a Base.Option.t Bin_prot.Type_class.writer
val __bin_read_sexp_option__ : 'a Bin_prot.Read.reader -> Bin_prot.Common.buf -> pos_ref:Bin_prot.Common.pos_ref -> Base.Int.t -> 'a Base.Option.t
val bin_read_sexp_option : 'a Bin_prot.Read.reader -> Bin_prot.Common.buf -> pos_ref:Bin_prot.Common.pos_ref -> 'a Base.Option.t
val bin_reader_sexp_option : 'a Bin_prot.Type_class.reader -> 'a Base.Option.t Bin_prot.Type_class.reader
val bin_sexp_option : 'a Bin_prot.Type_class.t -> 'a Base.Option.t Bin_prot.Type_class.t
val compare_sexp_option : 'a. ('a -> 'a -> Base.Int.t) -> 'a sexp_option -> 'a sexp_option -> Base.Int.t
val hash_fold_sexp_option : 'a. (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state) -> Ppx_hash_lib.Std.Hash.state -> 'a sexp_option -> Ppx_hash_lib.Std.Hash.state
type 'a sexp_list = 'a Base.List.t
val bin_shape_sexp_list : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_sexp_list : 'a Bin_prot.Size.sizer -> 'a Base.List.t -> int
val bin_write_sexp_list : 'a Bin_prot.Write.writer -> Bin_prot.Common.buf -> pos:Bin_prot.Common.pos -> 'a Base.List.t -> Bin_prot.Common.pos
val bin_writer_sexp_list : 'a Bin_prot.Type_class.writer -> 'a Base.List.t Bin_prot.Type_class.writer
val __bin_read_sexp_list__ : 'a Bin_prot.Read.reader -> Bin_prot.Common.buf -> pos_ref:Bin_prot.Common.pos_ref -> Base.Int.t -> 'a Base.List.t
val bin_read_sexp_list : 'a Bin_prot.Read.reader -> Bin_prot.Common.buf -> pos_ref:Bin_prot.Common.pos_ref -> 'a Base.List.t
val bin_reader_sexp_list : 'a Bin_prot.Type_class.reader -> 'a Base.List.t Bin_prot.Type_class.reader
val bin_sexp_list : 'a Bin_prot.Type_class.t -> 'a Base.List.t Bin_prot.Type_class.t
val compare_sexp_list : 'a. ('a -> 'a -> Base.Int.t) -> 'a sexp_list -> 'a sexp_list -> Base.Int.t
val hash_fold_sexp_list : 'a. (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state) -> Ppx_hash_lib.Std.Hash.state -> 'a sexp_list -> Ppx_hash_lib.Std.Hash.state
module Sexp : sig ... end
module Hashable : sig ... end
module Byte_units = Core_kernel.Byte_units.Stable
module Comparable = Core_kernel.Comparable.Stable
module Comparator = Core_kernel.Comparator.Stable
module Day_of_week = Core_kernel.Day_of_week.Stable
module Float_with_finite_only_serialization = Core_kernel.Float_with_finite_only_serialization.Stable
module Host_and_port = Core_kernel.Host_and_port.Stable
module Or_error = Core_kernel.Or_error.Stable
module Sexpable = Core_kernel.Sexpable.Stable
module Source_code_position = Core_kernel.Source_code_position.Stable
module String_id = Core_kernel.String_id.Stable
include module type of struct include Perms.Export end

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 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 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
val compare_read : read -> read -> Base.Int.t
val hash_fold_read : Ppx_hash_lib.Std.Hash.state -> read -> Ppx_hash_lib.Std.Hash.state
val hash_read : read -> Ppx_hash_lib.Std.Hash.hash_value
val read_of_sexp : Sexplib.Sexp.t -> read
val sexp_of_read : read -> Sexplib.Sexp.t
include sig ... end
val compare_write : write -> write -> Base.Int.t
val hash_fold_write : Ppx_hash_lib.Std.Hash.state -> write -> Ppx_hash_lib.Std.Hash.state
val hash_write : write -> Ppx_hash_lib.Std.Hash.hash_value
val write_of_sexp : Sexplib.Sexp.t -> write
val sexp_of_write : write -> Sexplib.Sexp.t
include sig ... end
val bin_immutable : immutable Bin_prot.Type_class.t
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_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
val compare_immutable : immutable -> immutable -> Base.Int.t
val hash_fold_immutable : Ppx_hash_lib.Std.Hash.state -> immutable -> Ppx_hash_lib.Std.Hash.state
val hash_immutable : immutable -> Ppx_hash_lib.Std.Hash.hash_value
val immutable_of_sexp : Sexplib.Sexp.t -> immutable
val sexp_of_immutable : immutable -> Sexplib.Sexp.t
include sig ... end
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__ : (Base.Int.t -> 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
val compare_read_write : read_write -> read_write -> Base.Int.t
val hash_fold_read_write : Ppx_hash_lib.Std.Hash.state -> read_write -> Ppx_hash_lib.Std.Hash.state
val hash_read_write : read_write -> Ppx_hash_lib.Std.Hash.hash_value
val read_write_of_sexp : Sexplib.Sexp.t -> read_write
val sexp_of_read_write : read_write -> Sexplib.Sexp.t
include sig ... end
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 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
val compare_perms : ('a -> 'a -> Base.Int.t) -> 'a perms -> 'a perms -> Base.Int.t
val hash_fold_perms : (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state) -> Ppx_hash_lib.Std.Hash.state -> 'a perms -> Ppx_hash_lib.Std.Hash.state
val 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
include module type of struct include Ppx_compare_lib.Builtin end
val compare_bool : bool Base__Ppx_compare_lib.compare
val compare_char : char Base__Ppx_compare_lib.compare
val compare_float : float Base__Ppx_compare_lib.compare
val compare_int : int Base__Ppx_compare_lib.compare
val compare_int32 : int32 Base__Ppx_compare_lib.compare
val compare_int64 : int64 Base__Ppx_compare_lib.compare
val compare_nativeint : nativeint Base__Ppx_compare_lib.compare
val compare_string : string Base__Ppx_compare_lib.compare
val compare_unit : unit Base__Ppx_compare_lib.compare
val compare_array : 'a Base__Ppx_compare_lib.compare -> 'a array Base__Ppx_compare_lib.compare
val compare_list : 'a Base__Ppx_compare_lib.compare -> 'a list Base__Ppx_compare_lib.compare
val compare_option : 'a Base__Ppx_compare_lib.compare -> 'a option Base__Ppx_compare_lib.compare
val compare_ref : 'a Base__Ppx_compare_lib.compare -> 'a Pervasives.ref Base__Ppx_compare_lib.compare
module Interval = Interval.Stable
module Mac_address = Mac_address.Stable
module Schedule_v4_deprecated = Schedule_v4_deprecated.Stable
module Schedule_v5 = Schedule_v5.Stable
module Time : sig ... end
module Time_ns : sig ... end
module Unix : sig ... end
module User_and_group = User_and_group.Stable
module Uuid = Uuid.Stable
OCaml

Innovation. Community. Security.