# Module PMap

    module PMap: sig .. end

Polymorphic Map.

This is a polymorphic map, similar to standard library `Map` module but in a defunctorized style.

    type ('a, 'b) t

    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.

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

    val remove : 'a -> ('a, 'b) t -> ('a, 'b) 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 : '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`.

    val map : ('b -> 'c) -> ('a, 'b) t -> ('a, 'c) 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 order in which the associated values are passed to `f` is unspecified.

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

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.

    val enum : ('a, 'b) t -> ('a * 'b) Enum.t

creates an enumeration for this map.

    val of_enum : ?cmp:('a -> 'a -> int) -> ('a * 'b) Enum.t -> ('a, 'b) t

creates a map from an enumeration, using the specified function for key comparison or `compare` by default.