package bin_prot

You can search for identifiers within the package.

in-package search v0.2.0

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

include module type of struct include Bin_shape_lib.Std.Shape end

type t = Bin_shape_lib.Bin_shape.t

Shape.t are constructed by the bin_shape syntax extension from Ocaml type definitions & expressions.

There is a direct mapping from ocaml type definition syntax to the corresponding Shape.group and from ocaml type expression syntax to the corresponding Shape.t.

val sexp_of_t : t -> Sexplib0.Sexp.t

Tid.t & Vid.t are identifiers for type-constructors & type-vars. i.e. Given type 'a t = ...

module Tid = Bin_shape_lib.Std.Shape.Tid

module Vid = Bin_shape_lib.Std.Shape.Vid

module Location = Bin_shape_lib.Std.Shape.Location

Location.t is required when constructing shapes for which evaluation might fail.

module Uuid = Bin_shape_lib.Std.Shape.Uuid

Uuid.t is used by basetype and annotate.

type group = Bin_shape_lib.Bin_shape.group

group of mutually recursive type definitions

val group : Location.t -> (Tid.t * Vid.t list * t) list -> group

This function is generative; repeated calls create distinct groups

val tuple : t list -> t

val record : (string * t) list -> t

val variant : (string * t list) list -> t

type poly_variant_row = Bin_shape_lib.Bin_shape.poly_variant_row

val constr : string -> t option -> poly_variant_row

val inherit_ : Location.t -> t -> poly_variant_row

val poly_variant : Location.t -> poly_variant_row list -> t

val rec_app : Tid.t -> t list -> t

recursive apps within the current group

val top_app : group -> Tid.t -> t list -> t

apps from outside the group

val var : Location.t -> Vid.t -> t

val basetype : Uuid.t -> t list -> t

Built-in types and types with custom serialization: i.e. int,list,... To avoid accidental protocol compatibility, pass a UUID as the string argument

a = annotate s t creates a shape a distinguished, but dependent on shape t. Very much as record [(s,t)] does. But with annotate the ocaml record type does not exist.

val annotate : Uuid.t -> t -> t

Shape.Canonical.t is the result of evaluating a shape to a canonical form, and represents the shape of Ocaml types w.r.t. bin_io serialization.

The idea is that de-serialization is safe if the canonical-shape for the type produced by de-serialization is equivalent to the canonical-shape of the serialized type.

The representation is canonical, so equivalence is structural equality.

Canonical.t also provides a useful human level description of a type.

A Canonical.t can be `digested' to a Digest.t, and except for nearly impossible hash collisions, equality of the digests implies equality of canonical-shapes and hence equivalence at the Shape.t level.

Canonical.t may also be constructed with various functions: annotate, basetype, tuple, record, variant, poly_variant, fix, recurse, .. which might be used when setting up unit tests or expected shapes.

module Digest = Bin_shape_lib.Std.Shape.Digest

module Canonical = Bin_shape_lib.Std.Shape.Canonical

val eval : t -> Canonical.t

eval t returns the canonical-shape for a shape-expression Shape.t. Type aliases are expanded, so that no Tid.t or Vid.t have significance in the resulting canonical-shape. Type-recursion, including non-regular recursion, is translated to the de-bruijn representation used in canonical-shapes.

val eval_to_digest : t -> Digest.t

eval_to_digest t returns a hash-value direct from the Shape.t, potentially avoiding the intermediate Canonical.t from being constructed. This is important as the size of a canonical-shape might be exponential in terms of the size of the shape expression. The following holds: Digest.(eval_to_digest exp = Canonical.to_digest (eval exp))

val eval_to_digest_string : t -> string

eval_to_digest_string t == Digest.to_hex (eval_to_digest t) Convenience function useful for writing unit tests.

module For_typerep = Bin_shape_lib.Std.Shape.For_typerep

val bin_shape_unit : t

val bin_shape_bool : t

val bin_shape_string : t

val bin_shape_bytes : t

val bin_shape_char : t

val bin_shape_float : t

val bin_shape_int : t

val bin_shape_int32 : t

val bin_shape_int63 : t

val bin_shape_int64 : t

val bin_shape_nativeint : t

val bin_shape_nat0 : t

val bin_shape_digest : t

val bin_shape_float32_vec : t

val bin_shape_float64_vec : t

val bin_shape_vec : t

val bin_shape_float32_mat : t

val bin_shape_float64_mat : t

val bin_shape_mat : t

val bin_shape_bigstring : t

val bin_shape_floatarray : t

val bin_shape_variant_int : t

val bin_shape_int_8bit : t

val bin_shape_int_16bit : t

val bin_shape_int_32bit : t

val bin_shape_int_64bit : t

val bin_shape_int64_bits : t

val bin_shape_network16_int : t

val bin_shape_network32_int : t

val bin_shape_network32_int32 : t

val bin_shape_network64_int : t

val bin_shape_network64_int64 : t

val bin_shape_ref : t -> t

val bin_shape_option : t -> t

val bin_shape_list : t -> t

val bin_shape_array : t -> t

val bin_shape_hashtbl : t -> t -> t

val bin_shape_float_array : t

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

val bin_shape_lazy : 'a -> 'a

val bin_shape_pair : t -> t -> t

val bin_shape_triple : t -> t -> t -> t