package bin_prot

You can search for identifiers within the package.

in-package search v0.2.0

package bin_prot

bin_prot
- Bin_prot
bin_prot.shape
- Bin_shape_lib
  - Bin_shape
    
    Canonical
    
    Create
    
    Def
    
    Exp
    
    Digest
    
    For_typerep
    
    Location
    
    Tid
    
    Uuid
    
    Vid
  - Std
bin_prot.xen
- Bin_prot_xen

Legend:
Library
Module
Module type
Parameter
Class
Class type

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

include module type of struct include 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 : Nat0.t sizer

val bin_size_ref : ('a, 'a Stdlib.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) Stdlib.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_floatarray : floatarray sizer

val bin_size_float_array : float array sizer

deprecated [since 2021-09] use ppx_bin_prot with type [float array] or [floatarray] or the 'floatarray' functions

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 = 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 Stdlib.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 Stdlib.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 Stdlib.ref -> 'b -> 'c

val bin_bytes : bytes Type_class.t

val bin_shape_bytes : Shape.t

val bin_writer_bytes : bytes Type_class.writer

val bin_write_bytes : bytes Write.writer

val bin_reader_bytes : bytes Type_class.reader

val bin_read_bytes : bytes Read.reader

val __bin_read_bytes__ : 'a -> pos_ref:Common.pos Stdlib.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 Stdlib.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 Stdlib.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 Stdlib.ref -> 'b -> 'c

val bin_floatarray : floatarray Type_class.t

val bin_shape_floatarray : Shape.t

val bin_writer_floatarray : floatarray Type_class.writer

val bin_write_floatarray : floatarray Write.writer

val bin_reader_floatarray : floatarray Type_class.reader

val bin_read_floatarray : floatarray Read.reader

val __bin_read_floatarray__ : 'a -> pos_ref:Common.pos Stdlib.ref -> 'b -> 'c

include sig ... end

type float_array = float array

deprecated [since 2021-09] Use [float array] or [floatarray] instead

val bin_shape_float_array : Shape.t

val bin_writer_float_array : float array Type_class.writer

val bin_write_float_array : float array Write.writer

val bin_reader_float_array : float array Type_class.reader

val bin_read_float_array : float array Read.reader

val __bin_read_float_array__ : 'a -> pos_ref:Common.pos Stdlib.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 Stdlib.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 Stdlib.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 Stdlib.ref -> 'b -> 'c

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

val bin_shape_ref : Shape.t -> Shape.t

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

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

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

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

val __bin_read_ref__ : 'a -> 'b -> pos_ref:Common.pos Stdlib.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 Stdlib.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 Stdlib.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 Stdlib.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 Stdlib.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 Stdlib.ref -> 'c -> 'd

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

val bin_shape_hashtbl : Shape.t -> Shape.t -> Shape.t

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

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

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

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

val __bin_read_hashtbl__ : 
  'a ->
  'b ->
  'c ->
  pos_ref:Common.pos Stdlib.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 Stdlib.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 Stdlib.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 Stdlib.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 Stdlib.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 Stdlib.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 Stdlib.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 Stdlib.ref -> 'b -> 'c