Library

Module

Module type

Parameter

Class

Class type

`val empty : ( 'a, 'b ) t`

The empty map, using `compare`

as key comparison function.

`val is_empty : ( 'a, 'b ) t -> bool`

returns true if the map is empty.

`val create : ( 'a -> 'a -> int ) -> ( 'a, 'b ) t`

creates a new empty map, using the provided function for key comparison.

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

`val find : 'a -> ( 'a, 'b ) t -> 'b`

`find x m`

returns the current binding of `x`

in `m`

, or raises `Not_found`

if no such binding exists.

`remove x m`

returns a map containing the same bindings as `m`

, except for `x`

which is unbound in the returned map.

`val mem : 'a -> ( 'a, 'b ) t -> bool`

`mem x m`

returns `true`

if `m`

contains a binding for `x`

, and `false`

otherwise.

`val exists : 'a -> ( 'a, 'b ) t -> bool`

same as `mem`

.

`val iter : ( 'a -> 'b -> unit ) -> ( 'a, 'b ) t -> 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 order in which the bindings are passed to `f`

is unspecified. Only current bindings are presented to `f`

: bindings hidden by more recent bindings are not passed to `f`

.

`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 order in which the associated values are passed to `f`

is unspecified.

Same as `map`

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

`val fold : ( 'b -> 'c -> 'c ) -> ( 'a, 'b ) t -> 'c -> 'c`

`fold f m a`

computes `(f kN dN ... (f k1 d1 a)...)`

, where `k1 ... kN`

are the keys of all bindings in `m`

, and `d1 ... dN`

are the associated data. The order in which the bindings are presented to `f`

is unspecified.

`val foldi : ( 'a -> 'b -> 'c -> 'c ) -> ( 'a, 'b ) t -> 'c -> 'c`

Same as `fold`

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