Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
Map.Make(3)			 OCaml library			   Map.Make(3)

NAME
       Map.Make	 -  Functor  building  an  implementation of the map structure
       given a totally ordered type.

Module
       Module	Map.Make

Documentation
       Module Make
	: functor (Ord : OrderedType) -> sig end

       Functor building	an implementation of the map structure given a totally
       ordered type.

       Parameters:

       "Ord"

       Map.OrderedType

       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 is_empty : 'a t -> bool

       Test whether a map is empty or not.

       val mem : key ->	'a t ->	bool

       mem  x  m returns true if m contains a binding for x , and false	other-
       wise.

       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 . If x was already bound in m	, its previous binding
       disappears.

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

       singleton x y returns the one-element map that contains a binding y for
       x .

       Since 3.12.0

       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 merge : (key	-> 'a option ->	'b option -> 'c	option)	-> 'a t	->  'b
       t -> 'c t

       merge  f	 m1 m2 computes	a map whose keys is a subset of	keys of	m1 and
       of m2 . The presence of each such binding, and the corresponding	value,
       is determined with the function f .

       Since 3.12.0

       val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int

       Total  ordering	between	 maps.	The first argument is a	total ordering
       used to compare data associated with equal keys in the two maps.

       val equal : ('a -> 'a ->	bool) -> 'a t -> 'a t -> bool

       equal cmp m1 m2 tests whether the maps m1 and m2	are  equal,  that  is,
       contain	equal  keys  and  associate  them with equal data.  cmp	is the
       equality	predicate used to compare the data associated with the keys.

       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 bind-
       ings are	passed to f in increasing order	with respect to	 the  ordering
       over the	type of	the keys.

       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 (in increasing order), and	d1 ... dN  are
       the associated data.

       val for_all : (key -> 'a	-> bool) -> 'a t -> bool

       for_all p m checks if all the bindings of the map satisfy the predicate
       p .

       Since 3.12.0

       val exists : (key -> 'a -> bool)	-> 'a t	-> bool

       exists p	m checks if at least one binding of the	map satisfy the	predi-
       cate p .

       Since 3.12.0

       val filter : (key -> 'a -> bool)	-> 'a t	-> 'a t

       filter  p  m  returns  the  map with all	the bindings in	m that satisfy
       predicate p .

       Since 3.12.0

       val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a	t

       partition p m returns a pair of maps (m1, m2) , where m1	 contains  all
       the bindings of s that satisfy the predicate p ,	and m2 is the map with
       all the bindings	of s that do not satisfy p .

       Since 3.12.0

       val cardinal : 'a t -> int

       Return the number of bindings of	a map.

       Since 3.12.0

       val bindings : 'a t -> (key * 'a) list

       Return the list of all bindings of the given map.  The returned list is
       sorted  in  increasing order with respect to the	ordering Ord.compare ,
       where Ord is the	argument given to Map.Make .

       Since 3.12.0

       val min_binding : 'a t -> key * 'a

       Return the smallest binding of the  given  map  (with  respect  to  the
       Ord.compare ordering), or raise Not_found if the	map is empty.

       Since 3.12.0

       val max_binding : 'a t -> key * 'a

       Same  as	 Map.S.min_binding  ,  but  returns the	largest	binding	of the
       given map.

       Since 3.12.0

       val choose : 'a t -> key	* 'a

       Return one binding of the given map, or raise Not_found if the  map  is
       empty.  Which binding is	chosen is unspecified, but equal bindings will
       be chosen for equal maps.

       Since 3.12.0

       val split : key -> 'a t -> 'a t * 'a option * 'a	t

       split x m returns a triple (l, data, r) , where l is the	map  with  all
       the bindings of m whose key is strictly less than x ; r is the map with
       all the bindings	of m whose key is strictly greater than	x  ;  data  is
       None if m contains no binding for x , or	Some v if m binds v to x .

       Since 3.12.0

       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 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 ap-
       plication of f to a .  The bindings are passed to f in increasing order
       with respect to the ordering over the type of the keys.

       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.

OCamldoc			  2017-04-30			   Map.Make(3)

NAME | Module | Documentation

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=Map.Make&sektion=3o&manpath=FreeBSD+12.0-RELEASE+and+Ports>

home | help