This module defines the Map module for Core. We use "core_map" as the file name rather than "map" to avoid conflicts with OCaml's standard map module. In this documentation, we use Map to mean this module, not the OCaml standard one.
Map is a functional datastructure (balanced binary tree) implementing finite maps over a totally-ordered domain, called a "key". The map types and operations appear in three places:
| Map | polymorphic map operations |
| Map.Poly | maps that use polymorphic comparison to order keys |
| Key.Map | maps with a fixed key type that use [Key.compare] to order keys |Where Key is any module defining values that can be used as keys of a map, like Int, String, etc. To add this functionality to an arbitrary module, use the Comparable.Make functor.
One should use Map for functions that access existing maps, like find, mem, add, fold, iter, and to_alist. For functions that create maps, like empty, singleton, and of_alist, one should strive to use the corresponding Key.Map function, which will use the comparison function specifically for Key. As a last resort, if one does not have easy access to a comparison function for the keys in one's map, use Map.Poly to create the map. This will use OCaml's built-in polymorphic comparison to compare keys, which has all the usual performance and robustness problems that entails.
Parallel to the three kinds of map modules, there are also tree modules Map.Tree, Map.Poly.Tree, and Key.Map.Tree. A tree is a bare representation of a map, without the comparator. Thus tree operations need to obtain the comparator from somewhere. For Map.Poly.Tree and Key.Map.Tree, the comparator is implicit in the module name. For Map.Tree, the comparator must be passed to each operation. The main advantages of trees over maps are slightly improved space usage (there is no outer container holding the comparator) and the ability to marshal trees, because a tree doesn't contain a closure, unlike a map. The main disadvantages of using trees are needing to be more explicit about the comparator, and the possibility of accidental use of polymorphic equality on a tree (for which maps dynamically detect failure due to the presence of a closure in the data structure).
For a detailed explanation of the interface design, read on.
An instance of the map type is determined by the types of the map's keys and values, and the comparison function used to order the keys:
type ('key, 'value, 'cmp) Map.t
'cmp is a phantom type uniquely identifying the comparison function, as generated by Comparator.Make.
Map.Poly supports arbitrary key and value types, but enforces that the comparison function used to order the keys is polymorphic comparison. Key.Map has a fixed key type and comparison function, and supports arbitrary values.
type ('key, 'value) Map.Poly.t = ('key , 'value, Comparator.Poly.t) Map.t
type 'value Key.Map.t = (Key.t, 'value, Key.comparator ) Map.t
The same map operations exist in Map, Map.Poly, and Key.Map, albeit with different types. For example:
val Map.length : (_, _, _) Map.t -> int
val Map.Poly.length : (_, _) Map.Poly.t -> int
val Key.Map.length : _ Key.Map.t -> int
Because Map.Poly.t and Key.Map.t are exposed as instances of the more general Map.t type, one can use Map.length on any map. The same is true for all of the functions that access an existing map, such as add, change, find, fold, iter, map, to_alist, etc.
Depending on the number of type variables N, the type of accessor (resp. creator) functions are defined in the module type AccessorsN (resp. CreatorsN) in Core_map_intf. Also for creators, when the comparison function is not fixed, i.e. the 'cmp variable of Map.t is free, we need to pass a comparator to the function creating the map. The module type is called Creators3_with_comparator. There is also a module type Accessors3_with_comparator in addition to Accessors3 which used for trees since the comparator is not known.
module Tree : sig ... endtype ('key, +'value, 'cmp) t = ('key, 'value, 'cmp) Base.Map.tTest if invariants of internal AVL search tree hold.
val empty : comparator:('a, 'cmp) Comparator.t -> ('a, 'b, 'cmp) tval singleton :
comparator:('a, 'cmp) Comparator.t ->
'a ->
'b ->
('a, 'b, 'cmp) tmap with one key, data pair
val of_alist :
comparator:('a, 'cmp) Comparator.t ->
('a * 'b) Base.List.t ->
[ `Ok of ('a, 'b, 'cmp) t | `Duplicate_key of 'a ]creates map from association list with unique keys
creates map from association list with unique keys. Returns an error if duplicate 'a keys are found.
creates map from association list with unique keys. Raises an exception if duplicate 'a keys are found.
of_hashtbl_exn creates a map from bindings present in a hash table. of_hashtbl_exn raises if there are distinct keys a1 and a2 in the table with comparator.compare a1 a2 = 0, which is only possible if the hash-table comparison function is different than comparator.compare. In the common case, the comparison is the same, in which case of_hashtbl_exn does not raise, regardless of the keys present in the table.
creates map from association list with possibly repeated keys.
val of_alist_fold :
comparator:('a, 'cmp) Comparator.t ->
('a * 'b) Base.List.t ->
init:'c ->
f:('c -> 'b -> 'c) ->
('a, 'c, 'cmp) tcombines an association list into a map, folding together bound values with common keys
val of_alist_reduce :
comparator:('a, 'cmp) Comparator.t ->
('a * 'b) Base.List.t ->
f:('b -> 'b -> 'b) ->
('a, 'b, 'cmp) tcombines an association list into a map, reducing together bound values with common keys
of_iteri ~iteri behaves like of_alist, except that instead of taking a concrete datastruture, it takes an iteration function. For instance, to convert a string table into a map: of_iteri ~comparator ~f:(Hashtbl.iteri table). It is faster than adding the elements one by one.
val to_tree : ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) Tree.tCreates a t from a Tree.t and a Comparator.t. This is an O(n) operation as it must discover the length of the Tree.t.
creates map from sorted array of key-data pairs. The input array must be sorted, as given by the relevant comparator (either in ascending or descending order), and must not contain any duplicate keys. If either of these conditions do not hold, an error is returned.
Like of_sorted_array except it returns a map with broken invariants when an Error would have been returned.
if_increasing_iterator_unchecked ~comparator ~len ~f behaves like of_sorted_array_unchecked ~comparator (Array.init len ~f), with the additional restriction that a decreasing order is not supported. The advantage is not requiring you to allocate an intermediate array. f will be called with 0, 1, ... len - 1, in order.
Test whether a map is empty or not.
val add : ('k, 'v, 'cmp) t -> key:'k -> data:'v -> ('k, 'v, 'cmp) treturns a new map with the specified new binding; if the key was already bound, its previous binding disappears.
if key is not present then add a singleton list, otherwise, cons data on the head of the existing list.
if key is present then remove its head element; if result is empty, remove the key.
change t key ~f returns a new map m that is the same as t on all keys except for key, and whose value for key is defined by f, i.e. find m key = f (find t
key).
val update :
('k, 'v, 'cmp) t ->
'k ->
f:('v Base.Option.t -> 'v) ->
('k, 'v, 'cmp) tupdate t key ~f is change t key ~f:(fun o -> Some (f o)).
returns the value bound to the given key, raising Not_found if none such exists
val find_exn : ('k, 'v, 'cmp) t -> 'k -> 'vval remove : ('k, 'v, 'cmp) t -> 'k -> ('k, 'v, 'cmp) treturns a new map with any binding for the key in question removed
mem map key tests whether map contains a binding for key
val iter2 :
('k, 'v1, 'cmp) t ->
('k, 'v2, 'cmp) t ->
f:
(key:'k ->
data:[ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ] ->
Base.Unit.t) ->
Base.Unit.tIterate two maps side by side. Complexity of this function is O(M+N). If two inputs are (0, a); (1, a) and (1, b); (2, b), f will be called with (0, `Left a); (1,
`Both (a, b)); (2, `Right b)
val map : ('k, 'v1, 'cmp) t -> f:('v1 -> 'v2) -> ('k, 'v2, 'cmp) treturns new map with bound values replaced by f applied to the bound values
val mapi :
('k, 'v1, 'cmp) t ->
f:(key:'k -> data:'v1 -> 'v2) ->
('k, 'v2, 'cmp) tlike map, but function takes both key and data as arguments
val fold : ('k, 'v, _) t -> init:'a -> f:(key:'k -> data:'v -> 'a -> 'a) -> 'afolds over keys and data in map in increasing order of key.
val fold_right :
('k, 'v, _) t ->
init:'a ->
f:(key:'k -> data:'v -> 'a -> 'a) ->
'afolds over keys and data in map in decreasing order of key.
val fold2 :
('k, 'v1, 'cmp) t ->
('k, 'v2, 'cmp) t ->
init:'a ->
f:
(key:'k ->
data:[ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ] ->
'a ->
'a) ->
'afolds over two maps side by side, like iter2.
val filter_keys : ('k, 'v, 'cmp) t -> f:('k -> Base.Bool.t) -> ('k, 'v, 'cmp) tfilter, filteri, filter_keys, filter_map, and filter_mapi run in O(n * lg n) time; they simply accumulate each key & data retained by f into a new map using add.
val filter : ('k, 'v, 'cmp) t -> f:('v -> Base.Bool.t) -> ('k, 'v, 'cmp) tval filteri :
('k, 'v, 'cmp) t ->
f:(key:'k -> data:'v -> Base.Bool.t) ->
('k, 'v, 'cmp) tval filter_map :
('k, 'v1, 'cmp) t ->
f:('v1 -> 'v2 Base.Option.t) ->
('k, 'v2, 'cmp) treturns new map with bound values filtered by f applied to the bound values
val filter_mapi :
('k, 'v1, 'cmp) t ->
f:(key:'k -> data:'v1 -> 'v2 Base.Option.t) ->
('k, 'v2, 'cmp) tlike filter_map, but function takes both key and data as arguments
val partition_mapi :
('k, 'v1, 'cmp) t ->
f:(key:'k -> data:'v1 -> [ `Fst of 'v2 | `Snd of 'v3 ]) ->
('k, 'v2, 'cmp) t * ('k, 'v3, 'cmp) tpartition_mapi t ~f returns two new ts, with each key in t appearing in exactly one of the result maps depending on its mapping in f.
val partition_map :
('k, 'v1, 'cmp) t ->
f:('v1 -> [ `Fst of 'v2 | `Snd of 'v3 ]) ->
('k, 'v2, 'cmp) t * ('k, 'v3, 'cmp) tpartition_map t ~f = partition_mapi t ~f:(fun ~key:_ ~data -> f data)
val partitioni_tf :
('k, 'v, 'cmp) t ->
f:(key:'k -> data:'v -> Base.Bool.t) ->
('k, 'v, 'cmp) t * ('k, 'v, 'cmp) tpartitioni_tf t ~f
=
partition_mapi t ~f:(fun ~key ~data ->
if f ~key ~data
then `Fst data
else `Snd data)
val partition_tf :
('k, 'v, 'cmp) t ->
f:('v -> Base.Bool.t) ->
('k, 'v, 'cmp) t * ('k, 'v, 'cmp) tpartition_tf t ~f = partitioni_tf t ~f:(fun ~key:_ ~data -> f data)
Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
Hash function: a building block to use when hashing data structures containing maps in them. hash_fold_direct hash_fold_key is compatible with compare_direct iff hash_fold_key is compatible with (comparator m).compare of the map m being hashed.
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.
returns list of keys in map
returns list of data in map
val to_alist :
?key_order:[ `Increasing | `Decreasing ] ->
('k, 'v, _) t ->
('k * 'v) Base.List.tcreates association list from map.
Additional operations on maps
val merge :
('k, 'v1, 'cmp) t ->
('k, 'v2, 'cmp) t ->
f:
(key:'k ->
[ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ] ->
'v3 Base.Option.t) ->
('k, 'v3, 'cmp) tsymmetric_diff t1 t2 ~data_equal returns a list of changes between t1 and t2. It is intended to be efficient in the case where t1 and t2 share a large amount of structure. The keys in the output sequence will be in sorted order.
val min_elt_exn : ('k, 'v, _) t -> 'k * 'vval max_elt_exn : ('k, 'v, _) t -> 'k * 'vsame semantics as similar functions in List
val split :
('k, 'v, 'cmp) t ->
'k ->
('k, 'v, 'cmp) t * ('k * 'v) Base.Option.t * ('k, 'v, 'cmp) tsplit t key returns a map of keys strictly less than key, the mapping of key if any, and a map of keys strictly greater than key.
Runtime is O(m + log n) where n is the size of the input map, and m is the size of the smaller of the two output maps. The O(m) term is due to the need to calculate the length of the output maps. *
val append :
lower_part:('k, 'v, 'cmp) t ->
upper_part:('k, 'v, 'cmp) t ->
[ `Ok of ('k, 'v, 'cmp) t | `Overlapping_key_ranges ]append ~lower_part ~upper_part returns `Ok map where map contains all the (key,
value) pairs from the two input maps if all the keys from lower_part are less than all the keys from upper_part. Otherwise it returns `Overlapping_key_ranges.
Runtime is O(log n) where n is the size of the larger input map. This can be significantly faster than Map.merge or repeated Map.add.
assert (match Map.append ~lower_part ~upper_part with
| `Ok whole_map ->
whole_map
= Map.(of_alist_exn (List.append (to_alist lower_part) (to_alist upper_part)))
| `Overlapping_key_ranges -> true);
subrange t ~lower_bound ~upper_bound returns a map containing all the entries from t whose keys lie inside the interval indicated by ~lower_bound and ~upper_bound. If this interval is empty, an empty map is returned.
Runtime is O(m + log n) where n is the size of the input map, and m is the size of the output map. The O(m) term is due to the need to calculate the length of the output map.
val fold_range_inclusive :
('k, 'v, 'cmp) t ->
min:'k ->
max:'k ->
init:'a ->
f:(key:'k -> data:'v -> 'a -> 'a) ->
'afold_range_inclusive t ~min ~max ~init ~f folds f (with initial value ~init) over all keys (and their associated values) that are in the range min, max (inclusive).
val range_to_alist :
('k, 'v, 'cmp) t ->
min:'k ->
max:'k ->
('k * 'v) Base.List.trange_to_alist t ~min ~max returns an associative list of the elements whose keys lie in min, max (inclusive), with the smallest key being at the head of the list.
val closest_key :
('k, 'v, 'cmp) t ->
[ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ] ->
'k ->
('k * 'v) Base.Option.tclosest_key t dir k returns the (key, value) pair in t with key closest to k, which satisfies the given inequality bound.
For example, closest_key t `Less_than k would be the pair with the closest key to k where key < k.
to_sequence can be used to get the same results as closest_key. It is less efficient for individual lookups but more efficient for finding many elements starting at some value.
nth t n finds the (key, value) pair of rank n (i.e. such that there are exactly n keys strictly less than the found key), if one exists. O(log(length t) + n) time.
rank t k if k is in t, returns the number of keys strictly less than k in t, otherwise None
val to_sequence :
?order:[ `Increasing_key | `Decreasing_key ] ->
?keys_greater_or_equal_to:'k ->
?keys_less_or_equal_to:'k ->
('k, 'v, 'cmp) t ->
('k * 'v) Sequence.tto_sequence ?order ?keys_greater_or_equal_to ?keys_less_or_equal_to t gives a sequence of key-value pairs between keys_less_or_equal_to and keys_greater_or_equal_to inclusive, presented in order. If keys_greater_or_equal_to > keys_less_or_equal_to, the sequence is empty. Cost is O(log n) up front and amortized O(1) to produce each element.
This shrinker and the other shrinkers for maps and trees produce a shrunk value by dropping a key-value pair, shrinking a key or shrinking a value. A shrunk key will override an existing key's value.
module Poly : sig ... endThe following functors may be used to define stable modules