include Hardcaml__.Map_intf.Map
include module type of sig ... end
type ('key, 'value, 'cmp) t = ('key, 'value, 'cmp) Base__Map.t
type ('k, 'cmp) comparator = (module Base.Comparator.S with type comparator_witness = 'cmp and type t = 'k)
val invariants : ('a, 'b, 'c) t -> boolval comparator_s : ('a, 'b, 'cmp) t -> ('a, 'cmp) comparatorval comparator : ('a, 'b, 'cmp) t -> ('a, 'cmp) Base.Comparator.tval empty : ('a, 'cmp) comparator -> ('a, 'b, 'cmp) tval singleton : ('a, 'cmp) comparator -> 'a -> 'b -> ('a, 'b, 'cmp) tval of_alist : ('a, 'cmp) comparator -> ('a * 'b) list -> [ `Duplicate_key of 'a | `Ok of ('a, 'b, 'cmp) t ]val of_alist_or_error : ('a, 'cmp) comparator -> ('a * 'b) list -> ('a, 'b, 'cmp) t Base.Or_error.tval of_alist_exn : ('a, 'cmp) comparator -> ('a * 'b) list -> ('a, 'b, 'cmp) tval of_alist_multi : ('a, 'cmp) comparator -> ('a * 'b) list -> ('a, 'b list, 'cmp) tval of_alist_fold : ('a, 'cmp) comparator -> ('a * 'b) list -> init:'c -> f:('c -> 'b -> 'c) -> ('a, 'c, 'cmp) tval of_alist_reduce : ('a, 'cmp) comparator -> ('a * 'b) list -> f:('b -> 'b -> 'b) -> ('a, 'b, 'cmp) tval of_iteri : ('a, 'cmp) comparator -> iteri:(f:(key:'a -> data:'b -> unit) -> unit) -> [ `Duplicate_key of 'a | `Ok of ('a, 'b, 'cmp) t ]val of_sorted_array : ('a, 'cmp) comparator -> ('a * 'b) array -> ('a, 'b, 'cmp) t Base.Or_error.tval of_sorted_array_unchecked : ('a, 'cmp) comparator -> ('a * 'b) array -> ('a, 'b, 'cmp) tval of_increasing_iterator_unchecked : ('a, 'cmp) comparator -> len:int -> f:(int -> 'a * 'b) -> ('a, 'b, 'cmp) tval of_increasing_sequence : ('k, 'cmp) comparator -> ('k * 'v) Base.Sequence.t -> ('k, 'v, 'cmp) t Base.Or_error.tval of_sequence : ('k, 'cmp) comparator -> ('k * 'v) Base.Sequence.t -> [ `Duplicate_key of 'k | `Ok of ('k, 'v, 'cmp) t ]val of_sequence_or_error : ('a, 'cmp) comparator -> ('a * 'b) Base.Sequence.t -> ('a, 'b, 'cmp) t Base.Or_error.tval of_sequence_exn : ('a, 'cmp) comparator -> ('a * 'b) Base.Sequence.t -> ('a, 'b, 'cmp) tval of_sequence_multi : ('a, 'cmp) comparator -> ('a * 'b) Base.Sequence.t -> ('a, 'b list, 'cmp) tval of_sequence_fold : ('a, 'cmp) comparator -> ('a * 'b) Base.Sequence.t -> init:'c -> f:('c -> 'b -> 'c) -> ('a, 'c, 'cmp) tval of_sequence_reduce : ('a, 'cmp) comparator -> ('a * 'b) Base.Sequence.t -> f:('b -> 'b -> 'b) -> ('a, 'b, 'cmp) tval is_empty : ('a, 'b, 'c) t -> boolval length : ('a, 'b, 'c) t -> intval set : ('k, 'v, 'cmp) t -> key:'k -> data:'v -> ('k, 'v, 'cmp) tval add : ('k, 'v, 'cmp) t -> key:'k -> data:'v -> ('k, 'v, 'cmp) t Or_duplicate.tval add_exn : ('k, 'v, 'cmp) t -> key:'k -> data:'v -> ('k, 'v, 'cmp) tval add_multi : ('k, 'v list, 'cmp) t -> key:'k -> data:'v -> ('k, 'v list, 'cmp) tval remove_multi : ('k, 'v list, 'cmp) t -> 'k -> ('k, 'v list, 'cmp) tval find_multi : ('k, 'v list, 'cmp) t -> 'k -> 'v listval change : ('k, 'v, 'cmp) t -> 'k -> f:('v option -> 'v option) -> ('k, 'v, 'cmp) tval update : ('k, 'v, 'cmp) t -> 'k -> f:('v option -> 'v) -> ('k, 'v, 'cmp) tval find : ('k, 'v, 'cmp) t -> 'k -> 'v optionval find_exn : ('k, 'v, 'cmp) t -> 'k -> 'vval remove : ('k, 'v, 'cmp) t -> 'k -> ('k, 'v, 'cmp) tval mem : ('k, 'a, 'cmp) t -> 'k -> boolval iter_keys : ('k, 'a, 'b) t -> f:('k -> unit) -> unitval iter : ('a, 'v, 'b) t -> f:('v -> unit) -> unitval iteri : ('k, 'v, 'a) t -> f:(key:'k -> data:'v -> unit) -> unitval iteri_until : ('k, 'v, 'a) t -> f:(key:'k -> data:'v -> Continue_or_stop.t) -> Finished_or_unfinished.tval iter2 : ('k, 'v1, 'cmp) t -> ('k, 'v2, 'cmp) t -> f:(key:'k -> data:[ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] -> unit) -> unitval map : ('k, 'v1, 'cmp) t -> f:('v1 -> 'v2) -> ('k, 'v2, 'cmp) tval mapi : ('k, 'v1, 'cmp) t -> f:(key:'k -> data:'v1 -> 'v2) -> ('k, 'v2, 'cmp) tval fold : ('k, 'v, 'b) t -> init:'a -> f:(key:'k -> data:'v -> 'a -> 'a) -> 'aval fold_right : ('k, 'v, 'b) t -> init:'a -> f:(key:'k -> data:'v -> 'a -> 'a) -> 'aval fold2 : ('k, 'v1, 'cmp) t -> ('k, 'v2, 'cmp) t -> init:'a -> f:(key:'k -> data:[ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] -> 'a -> 'a) -> 'aval filter_keys : ('k, 'v, 'cmp) t -> f:('k -> bool) -> ('k, 'v, 'cmp) tval filter : ('k, 'v, 'cmp) t -> f:('v -> bool) -> ('k, 'v, 'cmp) tval filteri : ('k, 'v, 'cmp) t -> f:(key:'k -> data:'v -> bool) -> ('k, 'v, 'cmp) tval filter_map : ('k, 'v1, 'cmp) t -> f:('v1 -> 'v2 option) -> ('k, 'v2, 'cmp) tval filter_mapi : ('k, 'v1, 'cmp) t -> f:(key:'k -> data:'v1 -> 'v2 option) -> ('k, 'v2, 'cmp) tval partition_mapi : ('k, 'v1, 'cmp) t -> f:(key:'k -> data:'v1 -> [ `Fst of 'v2 | `Snd of 'v3 ]) -> ('k, 'v2, 'cmp) t * ('k, 'v3, 'cmp) tval partition_map : ('k, 'v1, 'cmp) t -> f:('v1 -> [ `Fst of 'v2 | `Snd of 'v3 ]) -> ('k, 'v2, 'cmp) t * ('k, 'v3, 'cmp) tval partitioni_tf : ('k, 'v, 'cmp) t -> f:(key:'k -> data:'v -> bool) -> ('k, 'v, 'cmp) t * ('k, 'v, 'cmp) tval partition_tf : ('k, 'v, 'cmp) t -> f:('v -> bool) -> ('k, 'v, 'cmp) t * ('k, 'v, 'cmp) tval compare_direct : ('v -> 'v -> int) -> ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) t -> intval hash_fold_direct : 'k Base.Hash.folder -> 'v Base.Hash.folder -> ('k, 'v, 'cmp) t Base.Hash.folderval equal : ('v -> 'v -> bool) -> ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) t -> boolval keys : ('k, 'a, 'b) t -> 'k listval data : ('a, 'v, 'b) t -> 'v listval to_alist : ?key_order:[ `Decreasing | `Increasing ] -> ('k, 'v, 'a) t -> ('k * 'v) listval validate : name:('k -> string) -> 'v Base.Validate.check -> ('k, 'v, 'a) t Base.Validate.checkval merge : ('k, 'v1, 'cmp) t -> ('k, 'v2, 'cmp) t -> f:(key:'k -> [ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] -> 'v3 option) -> ('k, 'v3, 'cmp) tval merge_skewed : ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) t -> combine:(key:'k -> 'v -> 'v -> 'v) -> ('k, 'v, 'cmp) t
val symmetric_diff : ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) t -> data_equal:('v -> 'v -> bool) -> ('k, 'v) Symmetric_diff_element.t Base.Sequence.tval fold_symmetric_diff : ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) t -> data_equal:('v -> 'v -> bool) -> init:'a -> f:('a -> ('k, 'v) Symmetric_diff_element.t -> 'a) -> 'aval min_elt : ('k, 'v, 'a) t -> ('k * 'v) optionval min_elt_exn : ('k, 'v, 'a) t -> 'k * 'vval max_elt : ('k, 'v, 'a) t -> ('k * 'v) optionval max_elt_exn : ('k, 'v, 'a) t -> 'k * 'vval for_all : ('k, 'v, 'a) t -> f:('v -> bool) -> boolval for_alli : ('k, 'v, 'a) t -> f:(key:'k -> data:'v -> bool) -> boolval exists : ('k, 'v, 'a) t -> f:('v -> bool) -> boolval existsi : ('k, 'v, 'a) t -> f:(key:'k -> data:'v -> bool) -> boolval count : ('k, 'v, 'a) t -> f:('v -> bool) -> intval counti : ('k, 'v, 'a) t -> f:(key:'k -> data:'v -> bool) -> intval split : ('k, 'v, 'cmp) t -> 'k -> ('k, 'v, 'cmp) t * ('k * 'v) option * ('k, 'v, 'cmp) tval append : lower_part:('k, 'v, 'cmp) t -> upper_part:('k, 'v, 'cmp) t -> [ `Ok of ('k, 'v, 'cmp) t | `Overlapping_key_ranges ]val subrange : ('k, 'v, 'cmp) t -> lower_bound:'k Base.Maybe_bound.t -> upper_bound:'k Base.Maybe_bound.t -> ('k, 'v, 'cmp) tval fold_range_inclusive : ('k, 'v, 'cmp) t -> min:'k -> max:'k -> init:'a -> f:(key:'k -> data:'v -> 'a -> 'a) -> 'aval range_to_alist : ('k, 'v, 'cmp) t -> min:'k -> max:'k -> ('k * 'v) listval closest_key : ('k, 'v, 'cmp) t -> [ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ] -> 'k -> ('k * 'v) optionval nth : ('k, 'v, 'a) t -> int -> ('k * 'v) optionval nth_exn : ('k, 'v, 'a) t -> int -> 'k * 'vval rank : ('k, 'v, 'cmp) t -> 'k -> int optionval to_sequence : ?order:[ `Decreasing_key | `Increasing_key ] -> ?keys_greater_or_equal_to:'k -> ?keys_less_or_equal_to:'k -> ('k, 'v, 'cmp) t -> ('k * 'v) Base.Sequence.tval binary_search : ('k, 'v, 'cmp) t -> compare:(key:'k -> data:'v -> 'key -> int) -> [ `First_equal_to | `First_greater_than_or_equal_to | `First_strictly_greater_than | `Last_equal_to | `Last_less_than_or_equal_to | `Last_strictly_less_than ] -> 'key -> ('k * 'v) optionval binary_search_segmented : ('k, 'v, 'cmp) t -> segment_of:(key:'k -> data:'v -> [ `Left | `Right ]) -> [ `First_on_right | `Last_on_left ] -> ('k * 'v) option
val sexp_of_m__t : (module Sexp_of_m with type t = 'k) -> ('v -> Base.Sexp.t) -> ('k, 'v, 'cmp) t -> Base.Sexp.tval m__t_of_sexp : (module M_of_sexp with type comparator_witness = 'cmp and type t = 'k) -> (Base.Sexp.t -> 'v) -> Base.Sexp.t -> ('k, 'v, 'cmp) tval compare_m__t : (module Compare_m) -> ('v -> 'v -> int) -> ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) t -> intval equal_m__t : (module Equal_m) -> ('v -> 'v -> bool) -> ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) t -> boolval hash_fold_m__t : (module Hash_fold_m with type t = 'k) -> (Base.Hash.state -> 'v -> Base.Hash.state) -> Base.Hash.state -> ('k, 'v, 'a) t -> Base.Hash.state