`module type S = sig .. end`

Output signature of the functor

`Map.Make`

.```
type key;
```

The type of the map keys.

```
type t(+'a);
```

The type of maps from type

`key`

to type `'a`

.```
let empty: t('a);
```

The empty map.

```
let is_empty: t('a) => bool;
```

Test whether a map is empty or not.

```
let mem: (key, t('a)) => bool;
```

`mem x m`

returns `true`

if `m`

contains a binding for `x`

,
and `false`

otherwise.```
let add: (key, 'a, t('a)) => t('a);
```

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

, its previous binding disappears.```
let singleton: (key, 'a) => t('a);
```

`singleton x y`

returns the one-element map that contains a binding `y`

for `x`

.```
let remove: (key, t('a)) => t('a);
```

`remove x m`

returns a map containing the same bindings as
`m`

, except for `x`

which is unbound in the returned map.```
let merge:
((key, option('a), option('b)) => option('c), t('a), t('b)) => t('c);
```

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

.```
let compare: (('a, 'a) => int, t('a), t('a)) => int;
```

Total ordering between maps. The first argument is a total ordering
used to compare data associated with equal keys in the two maps.

```
let equal: (('a, 'a) => bool, t('a), t('a)) => bool;
```

`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.```
let iter: ((key, 'a) => unit, t('a)) => unit;
```

`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.```
let fold: ((key, 'a, 'b) => 'b, t('a), 'b) => 'b;
```

`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.```
let for_all: ((key, 'a) => bool, t('a)) => bool;
```

`for_all p m`

checks if all the bindings of the map
satisfy the predicate `p`

.```
let exists: ((key, 'a) => bool, t('a)) => bool;
```

`exists p m`

checks if at least one binding of the map
satisfy the predicate `p`

.```
let filter: ((key, 'a) => bool, t('a)) => t('a);
```

`filter p m`

returns the map with all the bindings in `m`

that satisfy predicate `p`

.```
let partition: ((key, 'a) => bool, t('a)) => (t('a), t('a));
```

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

.```
let cardinal: t('a) => int;
```

Return the number of bindings of a map.

**Since** 3.12.0

```
let bindings: t('a) => list((key, 'a));
```

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

**Since** 3.12.0

`Ord.compare`

, where `Ord`

is the argument
given to `Map.Make`

.```
let min_binding: t('a) => (key, 'a);
```

Return the smallest binding of the given map
(with respect to the

**Since** 3.12.0

`Ord.compare`

ordering), or raise
`Not_found`

if the map is empty.```
let max_binding: t('a) => (key, 'a);
```

```
let choose: t('a) => (key, 'a);
```

Return one binding of the given map, or raise

**Since** 3.12.0

`Not_found`

if
the map is empty. Which binding is chosen is unspecified,
but equal bindings will be chosen for equal maps.```
let split: (key, t('a)) => (t('a), option('a), t('a));
```

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

.```
let find: (key, t('a)) => 'a;
```

`find x m`

returns the current binding of `x`

in `m`

,
or raises `Not_found`

if no such binding exists.```
let map: ('a => 'b, t('a)) => t('b);
```

`map f m`

returns a map with same domain as `m`

, where the
associated value `a`

of all bindings of `m`

has been
replaced by the result of the application of `f`

to `a`

.
The bindings are passed to `f`

in increasing order
with respect to the ordering over the type of the keys.```
let mapi: ((key, 'a) => 'b, t('a)) => t('b);
```

Same as

`Map.S.map`

, but the function receives as arguments both the
key and the associated value for each binding of the map.