Module Std

module Std: sig .. end

include Size

val bin_unit : unit Type_class.t

val bin_writer_unit : unit Type_class.writer

val bin_write_unit_ : unit Unsafe_write_c.writer

val bin_write_unit : unit Write_ml.writer

val bin_reader_unit : unit Type_class.reader

val bin_read_unit : unit Read_ml.reader

val bin_read_unit_ : unit Unsafe_read_c.reader

val bin_read_unit__ : 'a -> 'b -> 'c -> 'd

val bin_bool : bool Type_class.t

val bin_writer_bool : bool Type_class.writer

val bin_write_bool_ : bool Unsafe_write_c.writer

val bin_write_bool : bool Write_ml.writer

val bin_reader_bool : bool Type_class.reader

val bin_read_bool : bool Read_ml.reader

val bin_read_bool_ : bool Unsafe_read_c.reader

val bin_read_bool__ : 'a -> 'b -> 'c -> 'd

val bin_string : string Type_class.t

val bin_writer_string : string Type_class.writer

val bin_write_string_ : string Unsafe_write_c.writer

val bin_write_string : string Write_ml.writer

val bin_reader_string : string Type_class.reader

val bin_read_string : string Read_ml.reader

val bin_read_string_ : string Unsafe_read_c.reader

val bin_read_string__ : 'a -> 'b -> 'c -> 'd

val bin_char : char Type_class.t

val bin_writer_char : char Type_class.writer

val bin_write_char_ : char Unsafe_write_c.writer

val bin_write_char : char Write_ml.writer

val bin_reader_char : char Type_class.reader

val bin_read_char : char Read_ml.reader

val bin_read_char_ : char Unsafe_read_c.reader

val bin_read_char__ : 'a -> 'b -> 'c -> 'd

val bin_int : int Type_class.t

val bin_writer_int : int Type_class.writer

val bin_write_int_ : int Unsafe_write_c.writer

val bin_write_int : int Write_ml.writer

val bin_reader_int : int Type_class.reader

val bin_read_int : int Read_ml.reader

val bin_read_int_ : int Unsafe_read_c.reader

val bin_read_int__ : 'a -> 'b -> 'c -> 'd

val bin_float : float Type_class.t

val bin_writer_float : float Type_class.writer

val bin_write_float_ : float Unsafe_write_c.writer

val bin_write_float : float Write_ml.writer

val bin_reader_float : float Type_class.reader

val bin_read_float : float Read_ml.reader

val bin_read_float_ : float Unsafe_read_c.reader

val bin_read_float__ : 'a -> 'b -> 'c -> 'd

val bin_int32 : int32 Type_class.t

val bin_writer_int32 : int32 Type_class.writer

val bin_write_int32_ : int32 Unsafe_write_c.writer

val bin_write_int32 : int32 Write_ml.writer

val bin_reader_int32 : int32 Type_class.reader

val bin_read_int32 : int32 Read_ml.reader

val bin_read_int32_ : int32 Unsafe_read_c.reader

val bin_read_int32__ : 'a -> 'b -> 'c -> 'd

val bin_int64 : int64 Type_class.t

val bin_writer_int64 : int64 Type_class.writer

val bin_write_int64_ : int64 Unsafe_write_c.writer

val bin_write_int64 : int64 Write_ml.writer

val bin_reader_int64 : int64 Type_class.reader

val bin_read_int64 : int64 Read_ml.reader

val bin_read_int64_ : int64 Unsafe_read_c.reader

val bin_read_int64__ : 'a -> 'b -> 'c -> 'd

val bin_nativeint : nativeint Type_class.t

val bin_writer_nativeint : nativeint Type_class.writer

val bin_write_nativeint_ : nativeint Unsafe_write_c.writer

val bin_write_nativeint : nativeint Write_ml.writer

val bin_reader_nativeint : nativeint Type_class.reader

val bin_read_nativeint : nativeint Read_ml.reader

val bin_read_nativeint_ : nativeint Unsafe_read_c.reader

val bin_read_nativeint__ : 'a -> 'b -> 'c -> 'd

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

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

val bin_write_ref_ : ('a, 'a Pervasives.ref) Unsafe_write_c.writer1

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

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

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

val bin_read_ref_ : ('a, 'a Pervasives.ref) Unsafe_read_c.reader1

val bin_read_ref__ : 'a -> 'b -> 'c -> 'd -> 'e

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

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

val bin_write_lazy_t_ : ('a, 'a lazy_t) Unsafe_write_c.writer1

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

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

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

val bin_read_lazy_t_ : ('a, 'a lazy_t) Unsafe_read_c.reader1

val bin_read_lazy_t__ : 'a -> 'b -> 'c -> 'd -> 'e

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

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

val bin_write_lazy_ : ('a, 'a lazy_t) Unsafe_write_c.writer1

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

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

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

val bin_read_lazy_ : ('a, 'a lazy_t) Unsafe_read_c.reader1

val bin_read_lazy__ : 'a -> 'b -> 'c -> 'd -> 'e

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

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

val bin_write_option_ : ('a, 'a option) Unsafe_write_c.writer1

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

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

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

val bin_read_option_ : ('a, 'a option) Unsafe_read_c.reader1

val bin_read_option__ : 'a -> 'b -> 'c -> 'd -> 'e

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

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

val bin_write_list_ : ('a, 'a list) Unsafe_write_c.writer1

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

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

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

val bin_read_list_ : ('a, 'a list) Unsafe_read_c.reader1

val bin_read_list__ : 'a -> 'b -> 'c -> 'd -> 'e

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

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

val bin_write_array_ : ('a, 'a array) Unsafe_write_c.writer1

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

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

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

val bin_read_array_ : ('a, 'a array) Unsafe_read_c.reader1

val bin_read_array__ : 'a -> 'b -> 'c -> 'd -> 'e

val bin_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) Type_class.S2.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) Unsafe_write_c.writer2

val bin_write_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) Write_ml.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_ml.reader2

val bin_read_hashtbl_ : ('a, 'b, ('a, 'b) Hashtbl.t) Unsafe_read_c.reader2

val bin_read_hashtbl__ : 'a -> 'b -> 'c -> 'd -> 'e -> 'f

val bin_bigstring : Common.buf Type_class.t

val bin_writer_bigstring : Common.buf Type_class.writer

val bin_write_bigstring_ : Common.buf Unsafe_write_c.writer

val bin_write_bigstring : Common.buf Write_ml.writer

val bin_reader_bigstring : Common.buf Type_class.reader

val bin_read_bigstring : Common.buf Read_ml.reader

val bin_read_bigstring_ : Common.buf Unsafe_read_c.reader

val bin_read_bigstring__ : 'a -> 'b -> 'c -> 'd

val bin_mat : Common.mat Type_class.t

val bin_writer_mat : Common.mat Type_class.writer

val bin_write_mat_ : Common.mat Unsafe_write_c.writer

val bin_write_mat : Common.mat Write_ml.writer

val bin_reader_mat : Common.mat Type_class.reader

val bin_read_mat : Common.mat Read_ml.reader

val bin_read_mat_ : Common.mat Unsafe_read_c.reader

val bin_read_mat__ : 'a -> 'b -> 'c -> 'd

val bin_float32_mat : Common.mat32 Type_class.t

val bin_writer_float32_mat : Common.mat32 Type_class.writer

val bin_write_float32_mat_ : Common.mat32 Unsafe_write_c.writer

val bin_write_float32_mat : Common.mat32 Write_ml.writer

val bin_reader_float32_mat : Common.mat32 Type_class.reader

val bin_read_float32_mat : Common.mat32 Read_ml.reader

val bin_read_float32_mat_ : Common.mat32 Unsafe_read_c.reader

val bin_read_float32_mat__ : 'a -> 'b -> 'c -> 'd

val bin_float64_mat : Common.mat64 Type_class.t

val bin_writer_float64_mat : Common.mat64 Type_class.writer

val bin_write_float64_mat_ : Common.mat64 Unsafe_write_c.writer

val bin_write_float64_mat : Common.mat64 Write_ml.writer

val bin_reader_float64_mat : Common.mat64 Type_class.reader

val bin_read_float64_mat : Common.mat64 Read_ml.reader

val bin_read_float64_mat_ : Common.mat64 Unsafe_read_c.reader

val bin_read_float64_mat__ : 'a -> 'b -> 'c -> 'd

val bin_vec : Common.vec Type_class.t

val bin_writer_vec : Common.vec Type_class.writer

val bin_write_vec_ : Common.vec Unsafe_write_c.writer

val bin_write_vec : Common.vec Write_ml.writer

val bin_reader_vec : Common.vec Type_class.reader

val bin_read_vec : Common.vec Read_ml.reader

val bin_read_vec_ : Common.vec Unsafe_read_c.reader

val bin_read_vec__ : 'a -> 'b -> 'c -> 'd

val bin_float32_vec : Common.vec32 Type_class.t

val bin_writer_float32_vec : Common.vec32 Type_class.writer

val bin_write_float32_vec_ : Common.vec32 Unsafe_write_c.writer

val bin_write_float32_vec : Common.vec32 Write_ml.writer

val bin_reader_float32_vec : Common.vec32 Type_class.reader

val bin_read_float32_vec : Common.vec32 Read_ml.reader

val bin_read_float32_vec_ : Common.vec32 Unsafe_read_c.reader

val bin_read_float32_vec__ : 'a -> 'b -> 'c -> 'd

val bin_float64_vec : Common.vec64 Type_class.t

val bin_writer_float64_vec : Common.vec64 Type_class.writer

val bin_write_float64_vec_ : Common.vec64 Unsafe_write_c.writer

val bin_write_float64_vec : Common.vec64 Write_ml.writer

val bin_reader_float64_vec : Common.vec64 Type_class.reader

val bin_read_float64_vec : Common.vec64 Read_ml.reader

val bin_read_float64_vec_ : Common.vec64 Unsafe_read_c.reader

val bin_read_float64_vec__ : 'a -> 'b -> 'c -> 'd