Type_class

#

type 'a writer = {

# size	: 'a Size.sizer	;
# write	: 'a Write.writer	;

}

#

type 'a reader = {

# read	: 'a Read.reader	;
# vtag_read	: (int -> 'a) Read.reader	;

}

#

type 'a t = {

# writer	: 'a writer	;
# reader	: 'a reader	;

}

#

type 'a writer0 = 'a writer

#

type 'a reader0 = 'a reader

#

type 'a t0 = 'a t

#

module S1 : sig

#

type ('a, 'b) writer = 'a writer0 -> 'b writer0

#

type ('a, 'b) reader = 'a reader0 -> 'b reader0

#

type ('a, 'b) t = 'a t0 -> 'b t0

end

#

module S2 : sig

#

type ('a, 'b, 'c) writer = 'a writer0 -> ('b, 'c) S1.writer

#

type ('a, 'b, 'c) reader = 'a reader0 -> ('b, 'c) S1.reader

#

type ('a, 'b, 'c) t = 'a t0 -> ('b, 'c) S1.t

end

#

module S3 : sig

#

type ('a, 'b, 'c, 'd) writer = 'a writer0 -> ('b, 'c, 'd) S2.writer

#

type ('a, 'b, 'c, 'd) reader = 'a reader0 -> ('b, 'c, 'd) S2.reader

#

type ('a, 'b, 'c, 'd) t = 'a t0 -> ('b, 'c, 'd) S2.t

end

#

val bin_writer_unit : unit writer

#

val bin_reader_unit : unit reader

#

val bin_unit : unit t

#

val bin_writer_bool : bool writer

#

val bin_reader_bool : bool reader

#

val bin_bool : bool t

#

val bin_writer_string : string writer

#

val bin_reader_string : string reader

#

val bin_string : string t

#

val bin_writer_char : char writer

#

val bin_reader_char : char reader

#

val bin_char : char t

#

val bin_writer_int : int writer

#

val bin_reader_int : int reader

#

val bin_int : int t

#

val bin_writer_float : float writer

#

val bin_reader_float : float reader

#

val bin_float : float t

#

val bin_writer_int32 : int32 writer

#

val bin_reader_int32 : int32 reader

#

val bin_int32 : int32 t

#

val bin_writer_int64 : int64 writer

#

val bin_reader_int64 : int64 reader

#

val bin_int64 : int64 t

#

val bin_writer_nativeint : nativeint writer

#

val bin_reader_nativeint : nativeint reader

#

val bin_nativeint : nativeint t

#

val bin_writer_nat0 : Nat0.t writer

#

val bin_reader_nat0 : Nat0.t reader

#

val bin_nat0 : Nat0.t t

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

val bin_writer_pair : ('a, 'b, 'a * 'b) S2.writer

#

val bin_reader_pair : ('a, 'b, 'a * 'b) S2.reader

#

val bin_pair : ('a, 'b, 'a * 'b) S2.t

#

val bin_writer_triple : ('a, 'b, 'c, 'a * 'b * 'c) S3.writer

#

val bin_reader_triple : ('a, 'b, 'c, 'a * 'b * 'c) S3.reader

#

val bin_triple : ('a, 'b, 'c, 'a * 'b * 'c) S3.t

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

val bin_writer_float32_vec : Common.vec32 writer

#

val bin_reader_float32_vec : Common.vec32 reader

#

val bin_float32_vec : Common.vec32 t

#

val bin_writer_float64_vec : Common.vec64 writer

#

val bin_reader_float64_vec : Common.vec64 reader

#

val bin_float64_vec : Common.vec64 t

#

val bin_writer_vec : Common.vec writer

#

val bin_reader_vec : Common.vec reader

#

val bin_vec : Common.vec t

#

val bin_writer_float32_mat : Common.mat32 writer

#

val bin_reader_float32_mat : Common.mat32 reader

#

val bin_float32_mat : Common.mat32 t

#

val bin_writer_float64_mat : Common.mat64 writer

#

val bin_reader_float64_mat : Common.mat64 reader

#

val bin_float64_mat : Common.mat64 t

#

val bin_writer_mat : Common.mat writer

#

val bin_reader_mat : Common.mat reader

#

val bin_mat : Common.mat t

#

val bin_writer_bigstring : Common.buf writer

#

val bin_reader_bigstring : Common.buf reader

#

val bin_bigstring : Common.buf t

#

val bin_writer_float_array : float array writer

#

val bin_reader_float_array : float array reader

#

val bin_float_array : float array t

#

val bin_writer_variant_int : int writer

#

val bin_reader_variant_int : int reader

#

val bin_variant_int : int t

#

val bin_writer_int_8bit : int writer

#

val bin_reader_int_8bit : int reader

#

val bin_int_8bit : int t

#

val bin_writer_int_16bit : int writer

#

val bin_reader_int_16bit : int reader

#

val bin_int_16bit : int t

#

val bin_writer_int_32bit : int writer

#

val bin_reader_int_32bit : int reader

#

val bin_int_32bit : int t

#

val bin_writer_int_64bit : int writer

#

val bin_reader_int_64bit : int reader

#

val bin_int_64bit : int t

#

val bin_writer_int64_bits : int64 writer

#

val bin_reader_int64_bits : int64 reader

#

val bin_int64_bits : int64 t

#

val bin_writer_network16_int : int writer

#

val bin_reader_network16_int : int reader

#

val bin_network16_int : int t

#

val bin_writer_network32_int : int writer

#

val bin_reader_network32_int : int reader

#

val bin_network32_int : int t

#

val bin_writer_network32_int32 : int32 writer

#

val bin_reader_network32_int32 : int32 reader

#

val bin_network32_int32 : int32 t

#

val bin_writer_network64_int : int writer

#

val bin_reader_network64_int : int reader

#

val bin_network64_int : int t

#

val bin_writer_network64_int64 : int64 writer

#

val bin_reader_network64_int64 : int64 reader

#

val bin_network64_int64 : int64 t

#

val bin_writer_array_no_length : ('a, 'a array) S1.writer

#

val cnv_writer : ('a -> 'b) -> 'b writer -> 'a writer

#

val cnv_reader : ('b -> 'a) -> 'b reader -> 'a reader

#

val cnv : ('a -> 'b) -> ('b -> 'a) -> 'b t -> 'a t

module Type_class