Module type(Map.S)

NAME
Map.S - Output signature of the functor Map.Make.

Module type
Module type Map.S

Documentation

Module type S
 = sig end

Output signature of the functor Map.Make

type key

The type of the map keys.

type +'a t

The type of maps from type key to type 'a

val empty : 'a t

The empty map.

val add : key -> 'a -> 'a t -> 'a t

add x y m returns a map containing the same bindings as m , plus a binding of x to y x was already bound in m , its previous binding disappears.

val find : key -> 'a t -> 'a

find x m returns the current binding of x in m , or raises Not_found if no such binding exists.

val remove : key -> 'a t -> 'a 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 : key -> 'a t -> bool

mem x m returns true if m contains a binding for x , and false otherwise.

val iter : (key -> 'a -> unit) -> 'a 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 : ('a -> 'b) -> 'a t -> 'b 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 : (key -> 'a -> 'b) -> 'a t -> 'b t

Same as Map.S.map , but the function receives as arguments both the key and the associated value for each binding of the map.

val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b

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.