package incr_map

  1. Overview
  2. Docs

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
val t_of_sexp : Sexplib0__.Sexp.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
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__ : (int -> t) Bin_prot.Read.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 Base__Ppx_compare_lib.compare
include Ppx_compare_lib.Equal.S with type t := t
val equal : t Base__Ppx_compare_lib.equal
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 key_range : t -> Key.t Collate.Which_range.t
val rank_range : t -> int Collate.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 to_parts : t -> Intermediate.Part.t Base.Sequence.t
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
OCaml

Innovation. Community. Security.