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

FreeBSD Manual Pages

  
 
  

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

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

Module
       Module	Set.Make

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

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

       Parameters:

       "Ord"

       Set.OrderedType

       type elt

       The type	of the set elements.

       type t

       The type	of sets.

       val empty : t

       The empty set.

       val is_empty : t	-> bool

       Test whether a set is empty or not.

       val mem : elt ->	t -> bool

       mem x s tests whether x belongs to the set s .

       val add : elt ->	t -> t

       add  x s	returns	a set containing all elements of s , plus x . If x was
       already in s , s	is returned unchanged.

       val singleton : elt -> t

       singleton x returns the one-element set containing only x .

       val remove : elt	-> t ->	t

       remove x	s returns a set	containing all elements	of s , except x	. If x
       was not in s , s	is returned unchanged.

       val union : t ->	t -> t

       Set union.

       val inter : t ->	t -> t

       Set intersection.

       val diff	: t -> t -> t

       Set difference.

       val compare : t -> t -> int

       Total  ordering	between	sets. Can be used as the ordering function for
       doing sets of sets.

       val equal : t ->	t -> bool

       equal s1	s2 tests whether the sets s1 and s2 are	equal, that  is,  con-
       tain equal elements.

       val subset : t -> t -> bool

       subset s1 s2 tests whether the set s1 is	a subset of the	set s2 .

       val iter	: (elt -> unit)	-> t ->	unit

       iter  f	s  applies f in	turn to	all elements of	s .  The elements of s
       are presented to	f in increasing	order with  respect  to	 the  ordering
       over the	type of	the elements.

       val fold	: (elt -> 'a ->	'a) -> t -> 'a -> 'a

       fold  f	s  a computes (f xN ...	(f x2 (f x1 a))...)  , where x1	... xN
       are the elements	of s , in increasing order.

       val for_all : (elt -> bool) -> t	-> bool

       for_all p s checks if all elements of the set satisfy the predicate p .

       val exists : (elt -> bool) -> t -> bool

       exists p	s checks if at least one element  of  the  set	satisfies  the
       predicate p .

       val filter : (elt -> bool) -> t -> t

       filter  p s returns the set of all elements in s	that satisfy predicate
       p .

       val partition : (elt -> bool) ->	t -> t * t

       partition p s returns a pair of sets (s1, s2) , where s1	is the set  of
       all  the	elements of s that satisfy the predicate p , and s2 is the set
       of all the elements of s	that do	not satisfy p .

       val cardinal : t	-> int

       Return the number of elements of	a set.

       val elements : t	-> elt list

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

       val min_elt : t -> elt

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

       val max_elt : t -> elt

       Same  as	 Set.S.min_elt	, but returns the largest element of the given
       set.

       val choose : t -> elt

       Return one element of the given set, or raise Not_found if the  set  is
       empty.  Which element is	chosen is unspecified, but equal elements will
       be chosen for equal sets.

       val split : elt -> t -> t * bool	* t

       split x s returns a triple (l, present, r) , where l is the set of ele-
       ments  of s that	are strictly less than x ; r is	the set	of elements of
       s that are strictly greater than	x ; present is false if	s contains  no
       element equal to	x , or true if s contains an element equal to x	.

       val find	: elt -> t -> elt

       find  x s returns the element of	s equal	to x (according	to Ord.compare
       ), or raise Not_found if	no such	element	exists.

       Since 4.01.0

       val of_list : elt list -> t

       of_list l creates a set from a list of elements.	 This is usually  more
       efficient than folding add over the list, except	perhaps	for lists with
       many duplicated elements.

       Since 4.02.0

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

NAME | Module | Documentation

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

home | help