package core

  1. Overview
  2. Docs
package core
Legend:
Library
Module
Module type
Parameter
Class
Class type
include module type of struct include Bin_shape_lib.Std.Shape end

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 = ...

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

Uuid.t is used by basetype and annotate.

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
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.

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.

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
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct