Map.Make

# Functor Map.Make

    module Make: functor (Ord : OrderedType) -> S  with type key = Ord.t

Functor building an implementation of the map structure given a totally ordered type.

Parameters: |
`Ord` | : | `OrderedType`

    type key

The type of the map keys.

    type +'a t

The type of maps from type `key` to type `'a`.

    val empty : 'a t

The empty map.

    val is_empty : 'a t -> bool

Test whether a map is empty or not.

    val add : key -> 'a -> 'a t -> 'a t

`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 : key -> 'a t -> 'a

`find x m` returns the current binding of `x` in `m`, or raises `Not_found` if no such binding exists.

    val remove : key -> 'a t -> 'a t

`remove x m` returns a map containing the same bindings as `m`, except for `x` which is unbound in the returned map.

    val mem : key -> 'a t -> bool

`mem x m` returns `true` if `m` contains a binding for `x`, and `false` otherwise.

    val iter : (key -> 'a -> unit) -> 'a 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 bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys. Only current bindings are presented to `f`: bindings hidden by more recent bindings are not passed to `f`.

    val map : ('a -> 'b) -> 'a t -> 'b t

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

    val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t

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

    val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> '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.

    val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int

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

    val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> 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.