module Make = functor ...
Functor building an implementation of the map structure given a totally ordered type.
Parameters: |
|
Types | |
key |
The type of the map keys. Abstract |
'b t |
The type of maps from type key to type 'a .Abstract |
Simple values | |
empty |
'c t The empty map. |
Functions |
add
: key:key -> data:'d -> 'd t -> 'd 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.
find
: key -> 'e t -> 'e |
find x m
returns the current binding of x
in m
,
or raises Not_found
if no such binding exists.
remove
: key -> 'f t -> 'f t |
remove x m
returns a map containing the same bindings as
m
, except for x
which is unbound in the returned map.
mem
: key -> 'g t -> bool |
mem x m
returns true
if m
contains a binding for x
,
and false
otherwise.
iter
: f:(key:key -> data:'h -> unit) -> 'h 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:('i -> 'j) -> 'i t -> 'j 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.
mapi
: f:(key -> 'k -> 'l) -> 'k t -> 'l t |
map
, but the function receives as arguments both the
key and the associated value for each binding of the map.
fold
: f:(key:key -> data:'m -> 'n -> 'n) -> 'm t -> init:'n -> 'n |
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.