Module `Core_kernel.Binable`

include Core_kernel__.Binable_intf.Binable

type bigstring = (Core_kernel__.Import.char, Stdlib.Bigarray.int8_unsigned_elt, Stdlib.Bigarray.c_layout) Stdlib.Bigarray.Array1.t: We copy the definition of the bigstring type here, because we cannot depend on bigstring.ml

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

module type S_only_functions = Bin_prot.Binable.S_only_functions

module type S1 = Bin_prot.Binable.S1

module type S2 = Bin_prot.Binable.S2

module type S3 = Bin_prot.Binable.S3

module Minimal : sig ... end

module type Conv = Core_kernel__.Binable_intf.Conv

module type Conv1 = Core_kernel__.Binable_intf.Conv1

module type Conv2 = Core_kernel__.Binable_intf.Conv2

module type Conv3 = Core_kernel__.Binable_intf.Conv3

module type Conv_sexpable = Core_kernel__.Binable_intf.Conv_sexpable

module type Conv_stringable = Core_kernel__.Binable_intf.Conv_stringable

module type Conv_without_uuid = Core_kernel__.Binable_intf.Conv_without_uuid

module type Conv1_without_uuid = Core_kernel__.Binable_intf.Conv1_without_uuid

module type Conv2_without_uuid = Core_kernel__.Binable_intf.Conv2_without_uuid

module type Conv3_without_uuid = Core_kernel__.Binable_intf.Conv3_without_uuid

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

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

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

module Of_binable3_with_uuid : functor (Binable : Minimal.S3) -> functor (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

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

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

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

module Of_binable3_without_uuid : functor (Binable : Minimal.S3) -> functor (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

module Of_binable = Of_binable_without_uuid

module Of_binable1 = Of_binable1_without_uuid

module Of_binable2 = Of_binable2_without_uuid

module Of_binable3 = Of_binable3_without_uuid

module Of_sexpable_with_uuid : functor (M : Conv_sexpable) -> S with type t := M.t

module Of_stringable_with_uuid : functor (M : Conv_stringable) -> S with type t := M.t

module Of_sexpable_without_uuid : functor (M : Sexpable.S) -> S with type t := M.t

module Of_stringable_without_uuid : functor (M : Core_kernel__.Import.Stringable.S) -> S with type t := M.t

module Of_sexpable = Of_sexpable_without_uuid

module Of_stringable = Of_stringable_without_uuid

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

val of_bigstring : 'a m -> bigstring -> 'a
val to_bigstring : ?⁠prefix_with_length:Core_kernel__.Import.bool -> 'a m -> 'a -> bigstring
val of_string : 'a m -> Core_kernel__.Import.string -> 'a
val to_string : 'a m -> 'a -> Core_kernel__.Import.string

module Stable : sig ... end