PatriciaTree.MakeMap
module Key : HomogeneousKey
type key = Key.t
The type of keys.
Underlying basemap, for cross map/set operations
val empty : 'a t
The empty map.
val is_empty : 'a t -> bool
Test if a map is empty; O(1) complexity.
Returns the (key,value) where Key.to_int key
is minimal (in unsigned representation of integers); O(log n) complexity.
Returns the (key,value) where Key.to_int key
is maximal; O(log n) complexity.
singleton key value
creates a map with a single binding, O(1) complexity.
val cardinal : 'a t -> int
The size of the map
mem map key
returns true
iff key
is bound in map
, O(log(n)) complexity.
pop_minimum m
returns None
if is_empty m
, or Some(key,value,m')
where (key,value) = min_binding m
and m' = remove m key
. O(log(n)) complexity.
pop_maximum m
returns None
if is_empty m
, or Some(key,value,m')
where (key,value) = max_binding m
and m' = remove m key
. O(log(n)) complexity.
insert map key f
Modifies or insert an element of the map; f takes None if the value was not previously bound, and Some old where old is the previously bound value otherwise. The function preserves physical equality when possible. O(log(n)) complexity.
update map key f
Modifies, insert, or remove an element from the map; f takes None if the value was not previously bound, and Some old where old is the previously bound value otherwise. The function preserves physical equality when possible.It returns None if the element should be removed O(log(n)) complexity.
Unconditionally adds a value in the map (independently from whether the old value existed). O(log(n)) complexity.
split key map
splits the map into:
map
whose keys are smaller than key
key
(if present)map
whose keys are bigger than key
Where the order is given by Key.to_int
.Iterate on each (key,value) pair of the map, in increasing order of keys.
Fold on each (key,value) pair of the map, in increasing order of keys.
Returns the submap containing only the key->value pairs satisfying the given predicate. f
is called in increasing number of keys
Returns true if the predicate holds on all map bindings. Short-circuiting
In the following, the *no_share function allows taking arguments of different types (but cannot share subtrees of the map), while the default functions attempt to preserve and benefit from sharing the subtrees (using physical equality to detect sharing).
map m f
returns a map where the value
bound to each key
is replaced by f key value
. The subtrees for which the returned value is physically the same (i.e. f key value == value
for all the keys in the subtree) are guaranteed to be physically equal to the original subtree. O(n) complexity. f
is called in increasing order of keys.
map_no_share m f
returns a map where the value
bound to each key
is replaced by f key value
. O(n) complexity. f
is called in increasing order of keys.
filter_map m f
returns a map where the value
bound to each key
is removed (if f key value
returns None
), or is replaced by v
((if f key value
returns Some v
). The subtrees for which the returned value is physically the same (i.e. f key value = Some v
with value == v
for all the keys in the subtree) are guaranteed to be physically equal to the original subtree. O(n) complexity. f
is called in increasing order of keys.
filter_map m f
returns a map where the value
bound to each key
is removed (if f key value
returns None
), or is replaced by v
((if f key value
returns Some v
). O(n) complexity. f
is called in increasing order of keys.
The following functions combine two maps. It is key for the performance, when we have large maps who share common subtrees, not to visit the nodes in these subtrees. Hence, we have specialized versions of these functions that assume properties of the function parameter (reflexive relation, idempotent operation, etc.)
When we cannot enjoy these properties, our functions explicitly say so (with a nonreflexive or nonidempotent prefix). The names are a bit long, but having these names avoids using an ineffective code by default, by forcing to know and choose between the fast and slow version.
It is also important to not visit a subtree when there merging this subtree with Empty; hence we provide union and inter operations.
reflexive_same_domain_for_all2 map1 map2 f
returns true if map1
and map2
have the same keys, and f key value1 value2
returns true for each mapping pair of keys. We assume that f
is reflexive (i.e. f key value value
returns true) to avoid visiting physically equal subtrees of map1
and map2
. The complexity is O(log(n)*Delta) where Delta is the number of different keys between map1
and map2
.
nonreflexive_same_domain_for_all2 map1 map2 f
returns true if map1 and map2 have the same keys, and f key value1 value2
returns true for each mapping pair of keys. The complexity is O(min(|map1|,|map2|)).
reflexive_subset_domain_for_all2 map1 map2 f
returns true if all the keys of map1
also are in map2
, and f key (find map1
key) (find map2 key)
returns true
when both keys are present in the map. We assume that f
is reflexive (i.e. f key value
value
returns true) to avoid visiting physically equal subtrees of map1
and map2
. The complexity is O(log(n)*Delta) where Delta is the number of different keys between map1
and map2
.
idempotent_union map1 map2 f
returns a map whose keys is the union of the keys of map1
and map2
. f
is used to combine the values a key is mapped in both maps. We assume that f
is idempotent (i.e. f key value value == value
) to avoid visiting physically equal subtrees of map1
and map2
, and also to preserve physical equality of the subtreess in that case. The complexity is O(log(n)*Delta) where Delta is the number of different keys between map1
and map2
. f
is called in increasing order of keys. f
is never called on physically equal values.
idempotent_inter map1 map2 f
returns a map whose keys is the intersection of the keys of map1
and map2
. f
is used to combine the values a key is mapped in both maps. We assume that f
is idempotent (i.e. f key value value == value
) to avoid visiting physically equal subtrees of map1
and map2
, and also to preserve physical equality of the subtrees in that case. The complexity is O(log(n)*Delta) where Delta is the number of different keys between map1
and map2
. f
is called in increasing order of keys. f
is never called on physically equal values.
nonidempotent_inter_no_share map1 map2 f
returns a map whose keys is the intersection of the keys of map1
and map2
. f
is used to combine the values a key is mapped in both maps. f
does not need to be idempotent, which imply that we have to visit physically equal subtrees of map1
and map2
. The complexity is O(log(n)*min(|map1|,|map2|)). f
is called in increasing order of keys. f
is called on every shared binding.
idempotent_inter_filter m1 m2 f
is like idempotent_inter m1
m2 f
(assuming idempotence, using and preserving physically equal subtrees), but it also removes the key->value bindings for which f
returns None
.
slow_merge m1 m2 f
returns a map whose keys are a subset of the keys of m1
and m2
. The f
function is used to combine keys, similarly to the Map.merge
function. This funcion has to traverse all the bindings in m1
and m2
; its complexity is O(|m1|+|m2|). Use one of faster functions above if you can.
module WithForeign (Map2 : BaseMap_S with type _ key = key) : sig ... end
Combination with other kinds of maps.