Binable (p.core.v0.16.2.doc.core.Core.Binable)

Source

type bigstring =
  (Base.Char.t, Bigarray.int8_unsigned_elt, Bigarray.c_layout)
    Bigarray.Array1.t

We copy the definition of the bigstring type here, because we cannot depend on bigstring.ml

Sourcemodule type S = Bin_prot.Binable.S

New code should use @@deriving bin_io. These module types (S, S1, and S2) are exported only for backwards compatibility.

Sourcemodule type S_only_functions = Bin_prot.Binable.S_only_functions

Sourcemodule type S1 = Bin_prot.Binable.S1

Sourcemodule type S2 = Bin_prot.Binable.S2

Sourcemodule type S3 = Bin_prot.Binable.S3

Sourcemodule Minimal : sig ... end

Sourcemodule type Conv = sig ... end

Sourcemodule type Conv1 = sig ... end

Sourcemodule type Conv2 = sig ... end

Sourcemodule type Conv3 = sig ... end

Sourcemodule type Conv_sexpable = sig ... end

Sourcemodule type Conv_stringable = sig ... end

Sourcemodule type Conv_without_uuid = sig ... end

Sourcemodule type Conv1_without_uuid = sig ... end

Sourcemodule type Conv2_without_uuid = sig ... end

Sourcemodule type Conv3_without_uuid = sig ... end

Of_binable* functors are for when you want the binary representation of one type to be the same as that for some other isomorphic type.

Source

module Of_binable_with_uuid
  (Binable : Minimal.S)
  (M : Conv with type binable := Binable.t) : 
  S with type t := M.t

Source

module Of_binable1_with_uuid
  (Binable : Minimal.S1)
  (M : Conv1 with type 'a binable := 'a Binable.t) : 
  S1 with type 'a t := 'a M.t

Source

module Of_binable2_with_uuid
  (Binable : Minimal.S2)
  (M : Conv2 with type ('a, 'b) binable := ('a, 'b) Binable.t) : 
  S2 with type ('a, 'b) t := ('a, 'b) M.t

Source

module Of_binable3_with_uuid
  (Binable : Minimal.S3)
  (M : Conv3 with type ('a, 'b, 'c) binable := ('a, 'b, 'c) Binable.t) : 
  S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) M.t

Source

module Of_binable_without_uuid
  (Binable : Minimal.S)
  (M : Conv_without_uuid with type binable := Binable.t) : 
  S with type t := M.t

Source

module Of_binable1_without_uuid
  (Binable : Minimal.S1)
  (M : Conv1_without_uuid with type 'a binable := 'a Binable.t) : 
  S1 with type 'a t := 'a M.t

Source

module Of_binable2_without_uuid
  (Binable : Minimal.S2)
  (M : Conv2_without_uuid with type ('a, 'b) binable := ('a, 'b) Binable.t) : 
  S2 with type ('a, 'b) t := ('a, 'b) M.t

Source

module Of_binable3_without_uuid
  (Binable : Minimal.S3)
  (M : 
    Conv3_without_uuid with type ('a, 'b, 'c) binable := ('a, 'b, 'c) Binable.t) : 
  S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) M.t

Of_sexpable_with_uuid serializes a value using the bin-io of the sexp serialization of the value. This is not as efficient as using @@deriving bin_io. However, it is useful when performance isn't important and there are obstacles to using @@deriving bin_io, e.g., some type missing @@deriving bin_io. Of_sexpable_with_uuid is also useful when one wants to be forgiving about format changes, due to the sexp serialization being more robust to changes like adding or removing a constructor.

Sourcemodule Of_sexpable_with_uuid (M : Conv_sexpable) : S with type t := M.t

Sourcemodule Of_stringable_with_uuid (M : Conv_stringable) : S with type t := M.t

Sourcemodule Of_sexpable_without_uuid (M : Sexpable.S) : S with type t := M.t

Source

module Of_stringable_without_uuid
  (M : Base.Stringable.S) : 
  S with type t := M.t

Sourcetype 'a m = (module S with type t = 'a)

Sourceval of_bigstring : 'a m -> bigstring -> 'a

Sourceval to_bigstring : ?prefix_with_length:Base.Bool.t -> 'a m -> 'a -> bigstring

The following functors preserve stability: if applied to stable types with stable (de)serializations, they will produce stable types with stable (de)serializations.

Note: In all cases, stability of the input (and therefore the output) depends on the semantics of all conversion functions (e.g. to_string, to_sexpable) not changing in the future.

Sourcemodule Stable : sig ... end

Sourceval of_string : 'a m -> Base.String.t -> 'a

Sourceval to_string : 'a m -> 'a -> Base.String.t