val empty : 'a t
The empty map.
val is_empty : 'a t -> bool
Test whether a map is empty or not.
mem x m returns
m contains a binding for
add x y m returns a map containing the same bindings as
m, plus a binding of
x was already bound
m to a value that is physically equal to
m is returned unchanged (the result of the function is
then physically equal to
m). Otherwise, the previous binding
singleton x y returns the one-element map that contains a binding
remove x m returns a map containing the same bindings as
m, except for
x which is unbound in the returned map.
x was not in
m is returned unchanged
(the result of the function is then physically equal to
merge f m1 m2 computes a map whose keys is a subset of keys of
m2. The presence of each such binding, and the corresponding
value, is determined with the function
union f m1 m2 computes a map whose keys is the union of keys
m1 and of
m2. When the same binding is defined in both
arguments, the function
f is used to combine them.
Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.
equal cmp m1 m2 tests whether the maps
equal, that is, contain equal keys and associate them with
cmp is the equality predicate used to compare
the data associated with the keys.
iter f m applies
f to all bindings in map
f receives the key as first argument, and the associated value
as second argument. The bindings are passed to
f in increasing
order with respect to the ordering over the type of the keys.
fold f m a computes
(f kN dN ... (f k1 d1 a)...),
k1 ... kN are the keys of all bindings in
(in increasing order), and
d1 ... dN are the associated data.
for_all p m checks if all the bindings of the map
satisfy the predicate
exists p m checks if at least one binding of the map
satisfy the predicate
filter p m returns the map with all the bindings in
that satisfy predicate
p satisfies every binding in
m is returned unchanged (the result of the function is then
physically equal to
partition p m returns a pair of maps
(m1, m2), where
m1 contains all the bindings of
s that satisfy the
m2 is the map with all the bindings of
s that do not satisfy
val cardinal : 'a t -> int
Return the number of bindings of a map.
Return the list of all bindings of the given map.
The returned list is sorted in increasing order with respect
to the ordering
Ord is the argument
given to Map.Make.
Return the smallest binding of the given map
(with respect to the
Ord.compare ordering), or raise
Not_found if the map is empty.
Same as Map.S.min_binding, but returns the largest binding of the given map.
Return one binding of the given map, or raise
the map is empty. Which binding is chosen is unspecified,
but equal bindings will be chosen for equal maps.
split x m returns a triple
(l, data, r), where
l is the map with all the bindings of
m whose key
is strictly less than
r is the map with all the bindings of
m whose key
is strictly greater than
m contains no binding for
Some v if
find x m returns the current binding of
Not_found if no such binding exists.
map f m returns a map with same domain as
m, where the
a of all bindings of
m has been
replaced by the result of the application of
The bindings are passed to
f in increasing order
with respect to the ordering over the type of the keys.
type 'a t
= 'a map
get_min_binding is like min_binding but
val get_max_binding : 'a map -> string * 'a
get_min_binding is like max_binding but
get_any_binding is like choose but
get k m is like Map.S.find but raises
k is not bound in
of_list bs is
List.fold_left (fun m (k, v) -> add k v m) empty
val pp : ?sep:(Format.formatter -> unit -> unit) -> (Format.formatter -> (path * 'a) -> unit) -> Format.formatter -> 'a map -> unit
pp ~sep pp_binding ppf m formats the bindings of
ppf. Each binding is formatted with
bindings are separated by
sep (defaults to
Format.pp_print_cut). If the map is empty leaves