Module CLMap.BaseMap

type _ key = key
type (!'a, 'b) value = ('a, 'b value) PatriciaTree.snd
type 'a t = 'a t
val empty : 'map t
val leaf : 'key key -> ('key, 'map) value -> 'map t
val branch : prefix:int -> branching_bit:int -> tree0:'map t -> tree1:'map t -> 'map t
type !'map view = private
  1. | Empty : 'map0 view
  2. | Branch : {
    1. prefix : int;
    2. branching_bit : int;
    3. tree0 : 'map1 t;
    4. tree1 : 'map1 t;
    } -> 'map1 view
  3. | Leaf : {
    1. key : 'key key;
    2. value : ('key, 'map2) value;
    } -> 'map2 view
val is_empty : 'map t -> bool
val view : 'a t -> 'a view
val find : 'key key -> 'map t -> ('key, 'map) value
val find_opt : 'key key -> 'map t -> ('key, 'map) value option
type !'map key_value_pair =
  1. | KeyValue : 'a key * ('a, 'map0) value -> 'map0 key_value_pair
val unsigned_min_binding : 'a t -> 'a key_value_pair
val unsigned_max_binding : 'a t -> 'a key_value_pair
val singleton : 'a key -> ('a, 'b) value -> 'b t
val cardinal : 'a t -> int
val is_singleton : 'a t -> 'a key_value_pair option
val mem : 'key key -> 'map t -> bool
val remove : 'key key -> 'map t -> 'map t
val pop_unsigned_minimum : 'map t -> ('map key_value_pair * 'map t) option
val pop_unsigned_maximum : 'map t -> ('map key_value_pair * 'map t) option
val insert : 'a key -> (('a, 'map) value option -> ('a, 'map) value) -> 'map t -> 'map t
val update : 'a key -> (('a, 'map) value option -> ('a, 'map) value option) -> 'map t -> 'map t
val add : 'key key -> ('key, 'map) value -> 'map t -> 'map t
val split : 'key key -> 'map t -> 'map t * ('key, 'map) value option * 'map t
type !'map polyiter = {
  1. f : 'a. 'a key -> ('a, 'map) value -> unit;
}
val iter : 'map polyiter -> 'map t -> unit
type (!'acc, !'map) polyfold = {
  1. f : 'a. 'a key -> ('a, 'map) value -> 'acc -> 'acc;
}
val fold : ('acc, 'map) polyfold -> 'map t -> 'acc -> 'acc
type (!'acc, !'map) polyfold2 = {
  1. f : 'a. 'a key -> ('a, 'map) value -> ('a, 'map) value -> 'acc -> 'acc;
}
val fold_on_nonequal_inter : ('acc, 'map) polyfold2 -> 'map t -> 'map t -> 'acc -> 'acc
type (!'acc, !'map) polyfold2_union = {
  1. f : 'a. 'a key -> ('a, 'map) value option -> ('a, 'map) value option -> 'acc -> 'acc;
}
val fold_on_nonequal_union : ('acc, 'map) polyfold2_union -> 'map t -> 'map t -> 'acc -> 'acc
type !'map polypredicate = {
  1. f : 'a. 'a key -> ('a, 'map) value -> bool;
}
val filter : 'map polypredicate -> 'map t -> 'map t
val for_all : 'map polypredicate -> 'map t -> bool
type (!'map1, !'map2) polymap = {
  1. f : 'a. ('a, 'map1) value -> ('a, 'map2) value;
}
val map : ('map, 'map) polymap -> 'map t -> 'map t
val map_no_share : ('map1, 'map2) polymap -> 'map1 t -> 'map2 t
type (!'map1, !'map2) polymapi = {
  1. f : 'a. 'a key -> ('a, 'map1) value -> ('a, 'map2) value;
}
val mapi : ('map, 'map) polymapi -> 'map t -> 'map t
val mapi_no_share : ('map1, 'map2) polymapi -> 'map1 t -> 'map2 t
type (!'map1, !'map2) polyfilter_map = {
  1. f : 'a. 'a key -> ('a, 'map1) value -> ('a, 'map2) value option;
}
val filter_map : ('map, 'map) polyfilter_map -> 'map t -> 'map t
val filter_map_no_share : ('map1, 'map2) polyfilter_map -> 'map1 t -> 'map2 t
type !'map polypretty = {
  1. f : 'a. Stdlib.Format.formatter -> 'a key -> ('a, 'map) value -> unit;
}
val pretty : ?pp_sep:(Stdlib.Format.formatter -> unit -> unit) -> 'map polypretty -> Stdlib.Format.formatter -> 'map t -> unit
type (!'map1, !'map2) polysame_domain_for_all2 = {
  1. f : 'a. 'a key -> ('a, 'map1) value -> ('a, 'map2) value -> bool;
}
val reflexive_same_domain_for_all2 : ('map, 'map) polysame_domain_for_all2 -> 'map t -> 'map t -> bool
val nonreflexive_same_domain_for_all2 : ('map1, 'map2) polysame_domain_for_all2 -> 'map1 t -> 'map2 t -> bool
val reflexive_subset_domain_for_all2 : ('map, 'map) polysame_domain_for_all2 -> 'map t -> 'map t -> bool
type !'map polycompare = {
  1. f : 'a. 'a key -> ('a, 'map) value -> ('a, 'map) value -> int;
}
val reflexive_compare : 'a polycompare -> 'a t -> 'a t -> int
val disjoint : 'a t -> 'a t -> bool
type (!'map1, !'map2, !'map3) polyunion = {
  1. f : 'a. 'a key -> ('a, 'map1) value -> ('a, 'map2) value -> ('a, 'map3) value;
}
val idempotent_union : ('a, 'a, 'a) polyunion -> 'a t -> 'a t -> 'a t
type (!'map1, !'map2, !'map3) polyinter = {
  1. f : 'a. 'a key -> ('a, 'map1) value -> ('a, 'map2) value -> ('a, 'map3) value;
}
val idempotent_inter : ('a, 'a, 'a) polyinter -> 'a t -> 'a t -> 'a t
val nonidempotent_inter_no_share : ('a, 'b, 'c) polyinter -> 'a t -> 'b t -> 'c t
type (!'map1, !'map2, !'map3) polyinterfilter = {
  1. f : 'a. 'a key -> ('a, 'map1) value -> ('a, 'map2) value -> ('a, 'map3) value option;
}
val idempotent_inter_filter : ('a, 'a, 'a) polyinterfilter -> 'a t -> 'a t -> 'a t
type (!'map1, !'map2, !'map3) polymerge = {
  1. f : 'a. 'a key -> ('a, 'map1) value option -> ('a, 'map2) value option -> ('a, 'map3) value option;
}
val slow_merge : ('map1, 'map2, 'map3) polymerge -> 'map1 t -> 'map2 t -> 'map3 t
type (!'a, !'b) polydifference = ('a, 'b, 'a) polyinterfilter
val symmetric_difference : ('a, 'a) polydifference -> 'a t -> 'a t -> 'a t
val difference : ('a, 'a) polydifference -> 'a t -> 'a t -> 'a t
type (!'a, !'b) key_value_value =
  1. | KeyValueValue : 'k key * ('k, 'a0) value * ('k, 'b0) value -> ('a0, 'b0) key_value_value
val min_binding_inter : 'a t -> 'b t -> ('a, 'b) key_value_value option
val max_binding_inter : 'a t -> 'b t -> ('a, 'b) key_value_value option
val to_seq : 'a t -> 'a key_value_pair Stdlib.Seq.t
val to_rev_seq : 'a t -> 'a key_value_pair Stdlib.Seq.t
val add_seq : 'a key_value_pair Stdlib.Seq.t -> 'a t -> 'a t
val of_seq : 'a key_value_pair Stdlib.Seq.t -> 'a t
val of_list : 'a key_value_pair list -> 'a t
val to_list : 'a t -> 'a key_value_pair list
module WithForeign (Map2 : sig ... end) : sig ... end