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

- since 2.1

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

- since 2.1

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

- since 2.1

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

## Boilerplate code

### Printing

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