Module Bin_prot.Std

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

include 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 : 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 : Common.vec32 sizer

val bin_size_float64_vec : Common.vec64 sizer

val bin_size_vec : Common.vec sizer

val bin_size_float32_mat : Common.mat32 sizer

val bin_size_float64_mat : Common.mat64 sizer

val bin_size_mat : Common.mat sizer

val bin_size_bigstring : 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 : Shape.Digest.t sizer

module Maximum = Size.Maximum

module Minimum = Size.Minimum

val bin_unit : unit Type_class.t

val bin_shape_unit : Shape.t

val bin_writer_unit : unit Type_class.writer

val bin_write_unit : unit Write.writer

val bin_reader_unit : unit Type_class.reader

val bin_read_unit : unit Read.reader

val __bin_read_unit__ : 'a ‑> pos_ref:Common.pos Pervasives.ref ‑> 'b ‑> 'c

val bin_bool : bool Type_class.t

val bin_shape_bool : Shape.t

val bin_writer_bool : bool Type_class.writer

val bin_write_bool : bool Write.writer

val bin_reader_bool : bool Type_class.reader

val bin_read_bool : bool Read.reader

val __bin_read_bool__ : 'a ‑> pos_ref:Common.pos Pervasives.ref ‑> 'b ‑> 'c

val bin_string : string Type_class.t

val bin_shape_string : Shape.t

val bin_writer_string : string Type_class.writer

val bin_write_string : string Write.writer

val bin_reader_string : string Type_class.reader

val bin_read_string : string Read.reader

val __bin_read_string__ : 'a ‑> pos_ref:Common.pos Pervasives.ref ‑> 'b ‑> 'c

val bin_char : char Type_class.t

val bin_shape_char : Shape.t

val bin_writer_char : char Type_class.writer

val bin_write_char : char Write.writer

val bin_reader_char : char Type_class.reader

val bin_read_char : char Read.reader

val __bin_read_char__ : 'a ‑> pos_ref:Common.pos Pervasives.ref ‑> 'b ‑> 'c

val bin_int : int Type_class.t

val bin_shape_int : Shape.t

val bin_writer_int : int Type_class.writer

val bin_write_int : int Write.writer

val bin_reader_int : int Type_class.reader

val bin_read_int : int Read.reader

val __bin_read_int__ : 'a ‑> pos_ref:Common.pos Pervasives.ref ‑> 'b ‑> 'c

val bin_float : float Type_class.t

val bin_shape_float : Shape.t

val bin_writer_float : float Type_class.writer

val bin_write_float : float Write.writer

val bin_reader_float : float Type_class.reader

val bin_read_float : float Read.reader

val __bin_read_float__ : 'a ‑> pos_ref:Common.pos Pervasives.ref ‑> 'b ‑> 'c

type float_array = float array

val bin_float_array : Type_class.float_array Type_class.t

val bin_shape_float_array : Shape.t

val bin_writer_float_array : Type_class.float_array Type_class.writer

val bin_write_float_array : float array Write.writer

val bin_reader_float_array : Type_class.float_array Type_class.reader

val bin_read_float_array : float array Read.reader

val __bin_read_float_array__ : 'a ‑> pos_ref:Common.pos Pervasives.ref ‑> 'b ‑> 'c

val bin_int32 : int32 Type_class.t

val bin_shape_int32 : Shape.t

val bin_writer_int32 : int32 Type_class.writer

val bin_write_int32 : int32 Write.writer

val bin_reader_int32 : int32 Type_class.reader

val bin_read_int32 : int32 Read.reader

val __bin_read_int32__ : 'a ‑> pos_ref:Common.pos Pervasives.ref ‑> 'b ‑> 'c

val bin_int64 : int64 Type_class.t

val bin_shape_int64 : Shape.t

val bin_writer_int64 : int64 Type_class.writer

val bin_write_int64 : int64 Write.writer

val bin_reader_int64 : int64 Type_class.reader

val bin_read_int64 : int64 Read.reader

val __bin_read_int64__ : 'a ‑> pos_ref:Common.pos Pervasives.ref ‑> 'b ‑> 'c

val bin_nativeint : nativeint Type_class.t

val bin_shape_nativeint : Shape.t

val bin_writer_nativeint : nativeint Type_class.writer

val bin_write_nativeint : nativeint Write.writer

val bin_reader_nativeint : nativeint Type_class.reader

val bin_read_nativeint : nativeint Read.reader

val __bin_read_nativeint__ : 'a ‑> pos_ref:Common.pos Pervasives.ref ‑> 'b ‑> 'c

val bin_ref : ('a, 'a Pervasives.ref) Type_class.S1.t

val bin_shape_ref : Shape.t ‑> Shape.t

val bin_writer_ref : ('a, 'a Pervasives.ref) Type_class.S1.writer

val bin_write_ref : ('a, 'a Pervasives.ref) Write.writer1

val bin_reader_ref : ('a, 'a Pervasives.ref) Type_class.S1.reader

val bin_read_ref : ('a, 'a Pervasives.ref) Read.reader1

val __bin_read_ref__ : 'a ‑> 'b ‑> pos_ref:Common.pos Pervasives.ref ‑> 'c ‑> 'd

val bin_lazy_t : ('a, 'a lazy_t) Type_class.S1.t

val bin_shape_lazy_t : Shape.t ‑> Shape.t

val bin_writer_lazy_t : ('a, 'a lazy_t) Type_class.S1.writer

val bin_write_lazy_t : ('a, 'a lazy_t) Write.writer1

val bin_reader_lazy_t : ('a, 'a lazy_t) Type_class.S1.reader

val bin_read_lazy_t : ('a, 'a lazy_t) Read.reader1

val __bin_read_lazy_t__ : 'a ‑> 'b ‑> pos_ref:Common.pos Pervasives.ref ‑> 'c ‑> 'd

val bin_lazy : ('a, 'a lazy_t) Type_class.S1.t

val bin_shape_lazy : Shape.t ‑> Shape.t

val bin_writer_lazy : ('a, 'a lazy_t) Type_class.S1.writer

val bin_write_lazy : ('a, 'a lazy_t) Write.writer1

val bin_reader_lazy : ('a, 'a lazy_t) Type_class.S1.reader

val bin_read_lazy : ('a, 'a lazy_t) Read.reader1

val __bin_read_lazy__ : 'a ‑> 'b ‑> pos_ref:Common.pos Pervasives.ref ‑> 'c ‑> 'd

val bin_option : ('a, 'a option) Type_class.S1.t

val bin_shape_option : Shape.t ‑> Shape.t

val bin_writer_option : ('a, 'a option) Type_class.S1.writer

val bin_write_option : ('a, 'a option) Write.writer1

val bin_reader_option : ('a, 'a option) Type_class.S1.reader

val bin_read_option : ('a, 'a option) Read.reader1

val __bin_read_option__ : 'a ‑> 'b ‑> pos_ref:Common.pos Pervasives.ref ‑> 'c ‑> 'd

val bin_list : ('a, 'a list) Type_class.S1.t

val bin_shape_list : Shape.t ‑> Shape.t

val bin_writer_list : ('a, 'a list) Type_class.S1.writer

val bin_write_list : ('a, 'a list) Write.writer1

val bin_reader_list : ('a, 'a list) Type_class.S1.reader

val bin_read_list : ('a, 'a list) Read.reader1

val __bin_read_list__ : 'a ‑> 'b ‑> pos_ref:Common.pos Pervasives.ref ‑> 'c ‑> 'd

val bin_array : ('a, 'a array) Type_class.S1.t

val bin_shape_array : Shape.t ‑> Shape.t

val bin_writer_array : ('a, 'a array) Type_class.S1.writer

val bin_write_array : ('a, 'a array) Write.writer1

val bin_reader_array : ('a, 'a array) Type_class.S1.reader

val bin_read_array : ('a, 'a array) Read.reader1

val __bin_read_array__ : 'a ‑> 'b ‑> pos_ref:Common.pos Pervasives.ref ‑> 'c ‑> 'd

val bin_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) Type_class.S2.t

val bin_shape_hashtbl : Shape.t ‑> Shape.t ‑> Shape.t

val bin_writer_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) Type_class.S2.writer

val bin_write_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) Write.writer2

val bin_reader_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) Type_class.S2.reader

val bin_read_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) Read.reader2

val __bin_read_hashtbl__ : 'a ‑> 'b ‑> 'c ‑> pos_ref:Common.pos Pervasives.ref ‑> 'd ‑> 'e

val bin_bigstring : Common.buf Type_class.t

val bin_shape_bigstring : Shape.t

val bin_writer_bigstring : Common.buf Type_class.writer

val bin_write_bigstring : Common.buf Write.writer

val bin_reader_bigstring : Common.buf Type_class.reader

val bin_read_bigstring : Common.buf Read.reader

val __bin_read_bigstring__ : 'a ‑> pos_ref:Common.pos Pervasives.ref ‑> 'b ‑> 'c

val bin_mat : Common.mat Type_class.t

val bin_shape_mat : Shape.t

val bin_writer_mat : Common.mat Type_class.writer

val bin_write_mat : Common.mat Write.writer

val bin_reader_mat : Common.mat Type_class.reader

val bin_read_mat : Common.mat Read.reader

val __bin_read_mat__ : 'a ‑> pos_ref:Common.pos Pervasives.ref ‑> 'b ‑> 'c

val bin_float32_mat : Common.mat32 Type_class.t

val bin_shape_float32_mat : Shape.t

val bin_writer_float32_mat : Common.mat32 Type_class.writer

val bin_write_float32_mat : Common.mat32 Write.writer

val bin_reader_float32_mat : Common.mat32 Type_class.reader

val bin_read_float32_mat : Common.mat32 Read.reader

val __bin_read_float32_mat__ : 'a ‑> pos_ref:Common.pos Pervasives.ref ‑> 'b ‑> 'c

val bin_float64_mat : Common.mat64 Type_class.t

val bin_shape_float64_mat : Shape.t

val bin_writer_float64_mat : Common.mat64 Type_class.writer

val bin_write_float64_mat : Common.mat64 Write.writer

val bin_reader_float64_mat : Common.mat64 Type_class.reader

val bin_read_float64_mat : Common.mat64 Read.reader

val __bin_read_float64_mat__ : 'a ‑> pos_ref:Common.pos Pervasives.ref ‑> 'b ‑> 'c

val bin_vec : Common.vec Type_class.t

val bin_shape_vec : Shape.t

val bin_writer_vec : Common.vec Type_class.writer

val bin_write_vec : Common.vec Write.writer

val bin_reader_vec : Common.vec Type_class.reader

val bin_read_vec : Common.vec Read.reader

val __bin_read_vec__ : 'a ‑> pos_ref:Common.pos Pervasives.ref ‑> 'b ‑> 'c

val bin_float32_vec : Common.vec32 Type_class.t

val bin_shape_float32_vec : Shape.t

val bin_writer_float32_vec : Common.vec32 Type_class.writer

val bin_write_float32_vec : Common.vec32 Write.writer

val bin_reader_float32_vec : Common.vec32 Type_class.reader

val bin_read_float32_vec : Common.vec32 Read.reader

val __bin_read_float32_vec__ : 'a ‑> pos_ref:Common.pos Pervasives.ref ‑> 'b ‑> 'c

val bin_float64_vec : Common.vec64 Type_class.t

val bin_shape_float64_vec : Shape.t

val bin_writer_float64_vec : Common.vec64 Type_class.writer

val bin_write_float64_vec : Common.vec64 Write.writer

val bin_reader_float64_vec : Common.vec64 Type_class.reader

val bin_read_float64_vec : Common.vec64 Read.reader

val __bin_read_float64_vec__ : 'a ‑> pos_ref:Common.pos Pervasives.ref ‑> 'b ‑> 'c