module BatMultiMap:sig
..end
Polymorphic Multi-Map.
This is a polymorphic multi-map, i.e. an association from 1 to many.
This implementation uses Pervasives.compare
to compare both keys and
values.
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 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
.
val find : 'a -> ('a, 'b) t -> 'b BatSet.t
find x m
returns the current binding of x
in m
val remove_all : 'a -> ('a, 'b) t -> ('a, 'b) t
remove_all x m
returns a map containing the same bindings as
m
, except for x
which is unbound in the returned map.
val remove : 'a -> 'b -> ('a, 'b) t -> ('a, 'b) t
remove k d m
returns a map containing the same bindings as
m
, except for k
which is not bound to d
anymore in the returned
map. If k
was not bound to d
, nothing is changed. If the operation
removes the last binding of k
, then k
is also removed from the set
of keys.
val mem : 'a -> ('a, 'b) t -> bool
mem x m
returns true
if m
contains at least a binding for x
,
and false
otherwise.
val iter : ('a -> 'b BatSet.t -> 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 BatSet.t -> 'c BatSet.t) ->
('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 BatSet.t -> 'c BatSet.t) ->
('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 BatSet.t -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c
fold f m a
computes (f kN dN ... (f k1 d1 (f k0 d0 a))...)
,
where k0,k1..kN
are the keys of all bindings in m
,
and d0,d1..dN
are the associated data.
The order in which the bindings are presented to f
is
unspecified.
val foldi : ('a -> 'b BatSet.t -> '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 modify : 'a ->
('b BatSet.t -> 'b BatSet.t) ->
('a, 'b) t -> ('a, 'b) t
modify x f m
replaces the binding for x
with f
applied to
these values.
Not_found
is x
is unbound in m
val modify_def : 'b BatSet.t ->
'a ->
('b BatSet.t -> 'b BatSet.t) ->
('a, 'b) t -> ('a, 'b) t
modify_def dfl x f m
performs as modify x f m
but it adds
f dfl
in m
instead of raising Not_found
if x
was unbound.
val modify_opt : 'a ->
('b BatSet.t option -> 'b BatSet.t option) ->
('a, 'b) t -> ('a, 'b) t
modify_opt x f m
allows to modify the bindings for k
in m
or absence thereof.
val enum : ('a, 'b) t -> ('a * 'b) BatEnum.t
creates an enumeration for this map.
val of_enum : ('a * 'b) BatEnum.t -> ('a, 'b) t
creates a map from an enumeration, using the specified function
for key comparison or compare
by default.
module Infix:sig
..end
Infix operators over a BatMultiPMap
val print : ?first:string ->
?last:string ->
?sep:string ->
?kvsep:string ->
('a BatInnerIO.output -> 'b -> unit) ->
('a BatInnerIO.output -> 'c -> unit) ->
'a BatInnerIO.output -> ('b, 'c) t -> unit