Module V1.Make_concrete

Parameters

module Key : sig ... end
module Value : sig ... end

Signature

module Key : sig ... end
module Value : sig ... end
type ('k, 'v) parametrized = ('k, 'v) t
include Sexplib0.Sexpable.S with type t := t
include Sexplib0.Sexpable.Of_sexp with type t := t
val t_of_sexp : Sexplib0.Sexp.t -> t
include Sexplib0.Sexpable.Sexp_of with type t := t
val sexp_of_t : t -> Sexplib0.Sexp.t
include Core.Bin_prot.Binable.S with type t := t
include Bin_prot.Binable.S_only_functions with type t := t
include sig ... end
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : t Bin_prot.Read.vtag_reader

This function only needs implementation if t exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t afterwards.

val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
include Ppx_compare_lib.Comparable.S with type t := t
val compare : t -> t -> int
include Ppx_compare_lib.Equal.S with type t := t
val equal : t -> t -> bool
val empty : t
val fold : t -> init:'accum -> f:('accum -> (Key.t * Value.t) -> 'accum) -> 'accum
val iter : t -> f:((Key.t * Value.t) -> unit) -> unit
val to_alist : t -> (Key.t * Value.t) list
val to_opaque_map : t -> (Key.t * Value.t) Opaque_map.t
val first : t -> (Key.t * Value.t) option
val last : t -> (Key.t * Value.t) option
val length : t -> int
val num_filtered_rows : t -> int
val num_unfiltered_rows : t -> int
val rank_range : t -> int Collate_params.Which_range.t
include Legacy_diffable.S with type t := t
module Update : sig ... end
val update : t -> Update.t -> t
val diffs : from:t -> to_:t -> Update.t
val to_diffs : t -> Update.t
val of_diffs : Update.t -> t
include Streamable.S with type t := t
module Intermediate : sig ... end
val finalize : Intermediate.t -> t
val this_type_does_not_support_ldiffable : unit

This strange value just encodes the fact that this type does not yet implement Ldiffable.S. When it does, delete this and then the compiler will show you places to update.

val find_by_key : t -> Key.t -> Value.t option
val prev : t -> Key.t -> (Key.t * Value.t) option
val next : t -> Key.t -> (Key.t * Value.t) option
module Private : sig ... end