Module Opaque_map

module Key : sig ... end
type 'a t = 'a Key.Map.t
include Sexplib0.Sexpable.S1 with type 'a t := 'a t
val t_of_sexp : 'a. (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a t
val sexp_of_t : 'a. ('a -> Sexplib0.Sexp.t) -> 'a t -> Sexplib0.Sexp.t
include Ppx_compare_lib.Comparable.S1 with type 'a t := 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
include Ppx_compare_lib.Equal.S1 with type 'a t := 'a t
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
include Core.Bin_prot.Binable.S1 with type 'a t := 'a t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
include sig ... end
val bin_size_t : 'a. ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : 'a. ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : 'a. ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : 'a. ('a, 'a t) Bin_prot.Read.vtag_reader1
val bin_writer_t : 'a. ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : 'a. ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : 'a. ('a, 'a t) Bin_prot.Type_class.S1.t
include Diffable.S1 with type 'a t := 'a t
module Diff : sig ... end
val erase_key_incrementally : ?data_equal:('data -> 'data -> bool) -> (('key, 'data, _) Core.Map.t, 'w) Incremental.t -> get:(key:'key -> data:'data -> 'a) -> ('a t, 'w) Incremental.t @@ portable

When Opaque_maps are created incrementally we can be smart about insertion and get good performance around insertion and rebalancing.

empty, of_list, and of_array won't give you nice incrementality like erase_key_incrementally, but they are still fine if the primary goal is using the type itself outside of an incremental context.

But if possible, consider erase_key_incrementally.

val empty : _ t @@ portable
val of_list : 'a list -> 'a t @@ portable
val of_array : 'a array -> 'a t @@ portable
val append : 'a t -> 'a -> 'a t @@ portable

append map elem adds elem to the end of the map.

val prepend : 'a t -> 'a -> 'a t @@ portable

prepend map elem adds elem to the beginning of the map.

val insert_before : 'a t -> key:Key.t -> 'a -> 'a t @@ portable

insert_before map ~key elem inserts elem at a position immediately before key in the ordering.

Note: this will never force rebalancing, so avoid using it as the primary method for constructing a t.

val insert_after : 'a t -> key:Key.t -> 'a -> 'a t @@ portable

insert_after map ~key elem inserts elem at a position immediately after key in the ordering.

Note: this will never force rebalancing, so avoid using it as the primary method for constructing a t.

module Stable : sig ... end