Path maps.

`include Map.S with type key := t and type a t := a map`

`add x y m`

returns a map containing the same bindings as
`m`

, plus a binding of `x`

to `y`

. If `x`

was already bound
in `m`

to a value that is physically equal to `y`

,
`m`

is returned unchanged (the result of the function is
then physically equal to `m`

). Otherwise, the previous binding
of `x`

in `m`

disappears.

- Before 4.03.Physical equality was not ensured.

`remove x m`

returns a map containing the same bindings as
`m`

, except for `x`

which is unbound in the returned map.
If `x`

was not in `m`

, `m`

is returned unchanged
(the result of the function is then physically equal to `m`

).

- Before 4.03.Physical equality was not ensured.

`merge f m1 m2`

computes a map whose keys is a subset of keys of `m1`

and of `m2`

. The presence of each such binding, and the corresponding
value, is determined with the function `f`

.

- Since: 3.12.0

`union f m1 m2`

computes a map whose keys is the union of keys
of `m1`

and of `m2`

. When the same binding is defined in both
arguments, the function `f`

is used to combine them.

- Since: 4.03.0

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 `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.

`iter f m`

applies `f`

to all bindings in map `m`

.
`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)...)`

,
where `k1 ... kN`

are the keys of all bindings in `m`

(in increasing order), and `d1 ... dN`

are the associated data.

`filter p m`

returns the map with all the bindings in `m`

that satisfy predicate `p`

. If `p`

satisfies every binding in `m`

,
`m`

is returned unchanged (the result of the function is then
physically equal to `m`

)

- Since: 3.12.0
- Before 4.03.Physical equality was not ensured.

`partition p m`

returns a pair of maps `(m1, m2)`

, where
`m1`

contains all the bindings of `s`

that satisfy the
predicate `p`

, and `m2`

is the map with all the bindings of
`s`

that do not satisfy `p`

.

- Since: 3.12.0

Return the list of all bindings of the given map.
The returned list is sorted in increasing order with respect
to the ordering `Ord.compare`

, where `Ord`

is the argument
given to Map.Make.

- Since: 3.12.0

Return the smallest binding of the given map
(with respect to the `Ord.compare`

ordering), or raise
`Not_found`

if the map is empty.

- Since: 3.12.0

Same as Map.S.min_binding, but returns the largest binding of the given map.

- Since: 3.12.0

Return one binding of the given map, or raise `Not_found`

if
the map is empty. Which binding is chosen is unspecified,
but equal bindings will be chosen for equal maps.

- Since: 3.12.0

`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 `x`

;
`r`

is the map with all the bindings of `m`

whose key
is strictly greater than `x`

;
`data`

is `None`

if `m`

contains no binding for `x`

,
or `Some v`

if `m`

binds `v`

to `x`

.

- Since: 3.12.0

`get_min_binding`

is like min_binding but

- Raises Invalid_argument: on the empty map.

`val get_max_binding : 'a map -> string * 'a`

`get_min_binding`

is like max_binding but

- Raises Invalid_argument: on the empty map.

`get_any_binding`

is like choose but

- Raises Invalid_argument: on the empty map.

`get k m`

is like Map.S.find but raises `Invalid_argument`

if
`k`

is not bound in `m`

.

`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 `m`

on
`ppf`

. Each binding is formatted with `pp_binding`

and
bindings are separated by `sep`

(defaults to
Format.pp_print_cut). If the map is empty leaves `ppf`

untouched.

`val dump : (Format.formatter -> 'a -> unit) -> Format.formatter -> 'a map -> unit`

`dump pp_v ppf m`

prints an unspecified representation of `m`

on
`ppf`

using `pp_v`

to print the map codomain elements.