Up
# module PMap

: sig

Polymorphic Map.

This is a polymorphic map, similar to standard library `Map`

module
but in a defunctorized style.

#

type ('a, 'b) t

#

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

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

#

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 mem : 'a -> ('a, 'b) t -> bool

`mem x m`

returns `true`

if `m`

contains a binding for `x`

,
and `false`

otherwise.

#

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

end