Map.Make_tree
module Key : sig ... end
include Map_intf.Make_S_plain_tree(Key).S
type 'a t =
(Key.t, 'a, Key.comparator_witness) Base.Map.Using_comparator.Tree.t
include Map_intf.Creators_and_accessors_generic
with type ('a, 'b, 'c) t := 'b t
with type ('a, 'b, 'c) tree := 'b t
with type 'a key := Key.t
with type 'a cmp := Key.comparator_witness
with type ('a, 'b, 'c) create_options :=
('a, 'b, 'c) Base.Map.Without_comparator.t
with type ('a, 'b, 'c) access_options :=
('a, 'b, 'c) Base.Map.Without_comparator.t
include Map_intf.Creators_generic
with type ('a, 'b, 'c) t := 'b t
with type ('a, 'b, 'c) tree := 'b t
with type 'a key := Key.t
with type 'a cmp := Key.comparator_witness
with type ('a, 'b, 'c) create_options :=
('a, 'b, 'c) Base.Map.Without_comparator.t
with type ('a, 'b, 'c) access_options :=
('a, 'b, 'c) Base.Map.Without_comparator.t
include Base.Map.Creators_generic
with type ('a, 'b, 'c) t := 'b t
with type ('a, 'b, 'c) tree := 'b t
with type 'a key := Key.t
with type 'a cmp := Key.comparator_witness
with type ('a, 'b, 'c) create_options :=
('a, 'b, 'c) Base.Map.Without_comparator.t
with type ('a, 'b, 'c) access_options :=
('a, 'b, 'c) Base.Map.Without_comparator.t
val empty : ('k, 'cmp, _ t) Base.Map.Without_comparator.t
val singleton : ('k, 'cmp, Key.t -> 'v -> 'v t) Base.Map.Without_comparator.t
val map_keys_exn :
('k2, 'cmp2, 'v t -> f:(Key.t -> Key.t) -> 'v t)
Base.Map.Without_comparator.t
val transpose_keys :
('k1, 'cmp1, ('k2, 'cmp2, 'a t t -> 'a t t) Base.Map.Without_comparator.t)
Base.Map.Without_comparator.t
val of_sorted_array :
('k, 'cmp, (Key.t * 'v) array -> 'v t Base.Or_error.t)
Base.Map.Without_comparator.t
val of_sorted_array_unchecked :
('k, 'cmp, (Key.t * 'v) array -> 'v t) Base.Map.Without_comparator.t
val of_increasing_iterator_unchecked :
('k, 'cmp, len:int -> f:(int -> Key.t * 'v) -> 'v t)
Base.Map.Without_comparator.t
val of_alist :
('k, 'cmp, (Key.t * 'v) list -> [ `Ok of 'v t | `Duplicate_key of Key.t ])
Base.Map.Without_comparator.t
val of_alist_or_error :
('k, 'cmp, (Key.t * 'v) list -> 'v t Base.Or_error.t)
Base.Map.Without_comparator.t
val of_alist_exn :
('k, 'cmp, (Key.t * 'v) list -> 'v t) Base.Map.Without_comparator.t
val of_alist_multi :
('k, 'cmp, (Key.t * 'v) list -> 'v list t) Base.Map.Without_comparator.t
val of_alist_fold :
('k, 'cmp, (Key.t * 'v1) list -> init:'v2 -> f:('v2 -> 'v1 -> 'v2) -> 'v2 t)
Base.Map.Without_comparator.t
val of_alist_reduce :
('k, 'cmp, (Key.t * 'v) list -> f:('v -> 'v -> 'v) -> 'v t)
Base.Map.Without_comparator.t
val of_increasing_sequence :
('k, 'cmp, (Key.t * 'v) Base.Sequence.t -> 'v t Base.Or_error.t)
Base.Map.Without_comparator.t
val of_sequence :
('k,
'cmp,
(Key.t * 'v) Base.Sequence.t ->
[ `Ok of 'v t | `Duplicate_key of Key.t ])
Base.Map.Without_comparator.t
val of_sequence_or_error :
('k, 'cmp, (Key.t * 'v) Base.Sequence.t -> 'v t Base.Or_error.t)
Base.Map.Without_comparator.t
val of_sequence_exn :
('k, 'cmp, (Key.t * 'v) Base.Sequence.t -> 'v t)
Base.Map.Without_comparator.t
val of_sequence_multi :
('k, 'cmp, (Key.t * 'v) Base.Sequence.t -> 'v list t)
Base.Map.Without_comparator.t
val of_sequence_fold :
('k,
'cmp,
(Key.t * 'v1) Base.Sequence.t ->
init:'v2 ->
f:('v2 -> 'v1 -> 'v2) ->
'v2 t)
Base.Map.Without_comparator.t
val of_sequence_reduce :
('k, 'cmp, (Key.t * 'v) Base.Sequence.t -> f:('v -> 'v -> 'v) -> 'v t)
Base.Map.Without_comparator.t
val of_list_with_key :
('k,
'cmp,
'v list ->
get_key:('v -> Key.t) ->
[ `Ok of 'v t | `Duplicate_key of Key.t ])
Base.Map.Without_comparator.t
val of_list_with_key_or_error :
('k, 'cmp, 'v list -> get_key:('v -> Key.t) -> 'v t Base.Or_error.t)
Base.Map.Without_comparator.t
val of_list_with_key_exn :
('k, 'cmp, 'v list -> get_key:('v -> Key.t) -> 'v t)
Base.Map.Without_comparator.t
val of_list_with_key_multi :
('k, 'cmp, 'v list -> get_key:('v -> Key.t) -> 'v list t)
Base.Map.Without_comparator.t
val of_list_with_key_fold :
('k,
'cmp,
'v list ->
get_key:('v -> Key.t) ->
init:'acc ->
f:('acc -> 'v -> 'acc) ->
'acc t)
Base.Map.Without_comparator.t
val of_list_with_key_reduce :
('k, 'cmp, 'v list -> get_key:('v -> Key.t) -> f:('v -> 'v -> 'v) -> 'v t)
Base.Map.Without_comparator.t
val of_iteri :
('k,
'cmp,
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Ok of 'v t | `Duplicate_key of Key.t ])
Base.Map.Without_comparator.t
val of_iteri_exn :
('k, 'cmp, iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) -> 'v t)
Base.Map.Without_comparator.t
val of_tree : ('k, 'cmp, 'v t -> 'v t) Base.Map.Without_comparator.t
val of_hashtbl_exn :
('k, 'cmp, (Key.t, 'v) Hashtbl.t -> 'v t) Base.Map.Without_comparator.t
val of_key_set :
(Key.t, Key.comparator_witness) Base.Set.t ->
f:(Key.t -> 'v) ->
'v t
Never requires a comparator because it can get one from the input Set.t
.
val quickcheck_generator :
('k,
'cmp,
Key.t Quickcheck.Generator.t ->
'v Quickcheck.Generator.t ->
'v t Quickcheck.Generator.t)
Base.Map.Without_comparator.t
include Map_intf.Accessors_generic
with type ('a, 'b, 'c) t := 'b t
with type ('a, 'b, 'c) tree := 'b t
with type 'a key := Key.t
with type 'a cmp := Key.comparator_witness
with type ('a, 'b, 'c) access_options :=
('a, 'b, 'c) Base.Map.Without_comparator.t
include Base.Map.Accessors_generic
with type ('a, 'b, 'c) t := 'b t
with type ('a, 'b, 'c) tree := 'b t
with type 'a key := Key.t
with type 'a cmp := Key.comparator_witness
with type ('a, 'b, 'c) access_options :=
('a, 'b, 'c) Base.Map.Without_comparator.t
val invariants : ('k, 'cmp, 'v t -> bool) Base.Map.Without_comparator.t
val is_empty : _ t -> bool
val length : _ t -> int
val add :
('k, 'cmp, 'v t -> key:Key.t -> data:'v -> [ `Ok of 'v t | `Duplicate ])
Base.Map.Without_comparator.t
val add_exn :
('k, 'cmp, 'v t -> key:Key.t -> data:'v -> 'v t)
Base.Map.Without_comparator.t
val set :
('k, 'cmp, 'v t -> key:Key.t -> data:'v -> 'v t)
Base.Map.Without_comparator.t
val add_multi :
('k, 'cmp, 'v list t -> key:Key.t -> data:'v -> 'v list t)
Base.Map.Without_comparator.t
val remove_multi :
('k, 'cmp, 'v list t -> Key.t -> 'v list t) Base.Map.Without_comparator.t
val find_multi :
('k, 'cmp, 'v list t -> Key.t -> 'v list) Base.Map.Without_comparator.t
val change :
('k, 'cmp, 'v t -> Key.t -> f:('v option -> 'v option) -> 'v t)
Base.Map.Without_comparator.t
val update :
('k, 'cmp, 'v t -> Key.t -> f:('v option -> 'v) -> 'v t)
Base.Map.Without_comparator.t
val find : ('k, 'cmp, 'v t -> Key.t -> 'v option) Base.Map.Without_comparator.t
val find_exn : ('k, 'cmp, 'v t -> Key.t -> 'v) Base.Map.Without_comparator.t
val remove : ('k, 'cmp, 'v t -> Key.t -> 'v t) Base.Map.Without_comparator.t
val mem : ('k, 'cmp, _ t -> Key.t -> bool) Base.Map.Without_comparator.t
val iter : 'v t -> f:('v -> unit) -> unit
val iteri_until :
'v t ->
f:(key:Key.t -> data:'v -> Base.Map.Continue_or_stop.t) ->
Base.Map.Finished_or_unfinished.t
val iter2 :
('k,
'cmp,
'v1 t ->
'v2 t ->
f:
(key:Key.t ->
data:[ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ] ->
unit) ->
unit)
Base.Map.Without_comparator.t
val fold_until :
'v t ->
init:'acc ->
f:
(key:Key.t ->
data:'v ->
'acc ->
('acc, 'final) Base.Container.Continue_or_stop.t) ->
finish:('acc -> 'final) ->
'final
val fold2 :
('k,
'cmp,
'v1 t ->
'v2 t ->
init:'acc ->
f:
(key:Key.t ->
data:[ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ] ->
'acc ->
'acc) ->
'acc)
Base.Map.Without_comparator.t
val partition_mapi :
'v1 t ->
f:(key:Key.t -> data:'v1 -> ('v2, 'v3) Base.Either.t) ->
'v2 t * 'v3 t
val partition_map :
'v1 t ->
f:('v1 -> ('v2, 'v3) Base.Either.t) ->
'v2 t * 'v3 t
val combine_errors :
('k, 'cmp, 'v Base.Or_error.t t -> 'v t Base.Or_error.t)
Base.Map.Without_comparator.t
val compare_direct :
('k, 'cmp, ('v -> 'v -> int) -> 'v t -> 'v t -> int)
Base.Map.Without_comparator.t
val equal :
('k, 'cmp, ('v -> 'v -> bool) -> 'v t -> 'v t -> bool)
Base.Map.Without_comparator.t
val data : 'v t -> 'v list
val merge :
('k,
'cmp,
'v1 t ->
'v2 t ->
f:
(key:Key.t ->
[ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ] ->
'v3 option) ->
'v3 t)
Base.Map.Without_comparator.t
val merge_disjoint_exn :
('k, 'cmp, 'v t -> 'v t -> 'v t) Base.Map.Without_comparator.t
val merge_skewed :
('k, 'cmp, 'v t -> 'v t -> combine:(key:Key.t -> 'v -> 'v -> 'v) -> 'v t)
Base.Map.Without_comparator.t
val symmetric_diff :
('k,
'cmp,
'v t ->
'v t ->
data_equal:('v -> 'v -> bool) ->
(Key.t * [ `Left of 'v | `Right of 'v | `Unequal of 'v * 'v ])
Base.Sequence.t)
Base.Map.Without_comparator.t
val fold_symmetric_diff :
('k,
'cmp,
'v t ->
'v t ->
data_equal:('v -> 'v -> bool) ->
init:'acc ->
f:
('acc ->
(Key.t * [ `Left of 'v | `Right of 'v | `Unequal of 'v * 'v ]) ->
'acc) ->
'acc)
Base.Map.Without_comparator.t
val for_all : 'v t -> f:('v -> bool) -> bool
val exists : 'v t -> f:('v -> bool) -> bool
val count : 'v t -> f:('v -> bool) -> int
val sum :
(module Base.Container.Summable with type t = 'a) ->
'v t ->
f:('v -> 'a) ->
'a
val sumi :
(module Base.Container.Summable with type t = 'a) ->
'v t ->
f:(key:Key.t -> data:'v -> 'a) ->
'a
val split_le_gt :
('k, 'cmp, 'v t -> Key.t -> 'v t * 'v t) Base.Map.Without_comparator.t
val split_lt_ge :
('k, 'cmp, 'v t -> Key.t -> 'v t * 'v t) Base.Map.Without_comparator.t
val append :
('k,
'cmp,
lower_part:'v t ->
upper_part:'v t ->
[ `Ok of 'v t | `Overlapping_key_ranges ])
Base.Map.Without_comparator.t
val subrange :
('k,
'cmp,
'v t ->
lower_bound:Key.t Base.Maybe_bound.t ->
upper_bound:Key.t Base.Maybe_bound.t ->
'v t)
Base.Map.Without_comparator.t
val fold_range_inclusive :
('k,
'cmp,
'v t ->
min:Key.t ->
max:Key.t ->
init:'acc ->
f:(key:Key.t -> data:'v -> 'acc -> 'acc) ->
'acc)
Base.Map.Without_comparator.t
val range_to_alist :
('k, 'cmp, 'v t -> min:Key.t -> max:Key.t -> (Key.t * 'v) list)
Base.Map.Without_comparator.t
val closest_key :
('k,
'cmp,
'v t ->
[ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ] ->
Key.t ->
(Key.t * 'v) option)
Base.Map.Without_comparator.t
val rank : ('k, 'cmp, _ t -> Key.t -> int option) Base.Map.Without_comparator.t
val to_sequence :
('k,
'cmp,
?order:[ `Increasing_key | `Decreasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'v t ->
(Key.t * 'v) Base.Sequence.t)
Base.Map.Without_comparator.t
val binary_search :
('k,
'cmp,
'v t ->
compare:(key:Key.t -> data:'v -> 'key -> int) ->
Base.Binary_searchable.Which_target_by_key.t ->
'key ->
(Key.t * 'v) option)
Base.Map.Without_comparator.t
val binary_search_segmented :
('k,
'cmp,
'v t ->
segment_of:(key:Key.t -> data:'v -> [ `Left | `Right ]) ->
Base.Binary_searchable.Which_target_by_segment.t ->
(Key.t * 'v) option)
Base.Map.Without_comparator.t
val binary_search_subrange :
('k,
'cmp,
'v t ->
compare:(key:Key.t -> data:'v -> 'bound -> int) ->
lower_bound:'bound Base.Maybe_bound.t ->
upper_bound:'bound Base.Maybe_bound.t ->
'v t)
Base.Map.Without_comparator.t
module Make_applicative_traversals
(A : Base.Applicative.Lazy_applicative) :
sig ... end
val key_set :
('k, 'cmp, _ t -> (Key.t, Key.comparator_witness) Base.Set.t)
Base.Map.Without_comparator.t
val validate :
name:(Key.t -> Base.String.t) ->
'v Validate.check ->
'v t Validate.check
val validatei :
name:(Key.t -> Base.String.t) ->
(Key.t * 'v) Validate.check ->
'v t Validate.check
val quickcheck_observer :
Key.t Quickcheck.Observer.t ->
'v Quickcheck.Observer.t ->
'v t Quickcheck.Observer.t
val quickcheck_shrinker :
('k,
'cmp,
Key.t Quickcheck.Shrinker.t ->
'v Quickcheck.Shrinker.t ->
'v t Quickcheck.Shrinker.t)
Base.Map.Without_comparator.t
module Provide_of_sexp (K : sig ... end) : sig ... end
include Sexpable.S1 with type 'a t := 'a t
val t_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a t
val sexp_of_t : ('a -> Sexplib0.Sexp.t) -> 'a t -> Sexplib0.Sexp.t