module Make:
Parameters: 

type
elt
type
t
val empty : t
val is_empty : t > bool
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
(the result of the function is then physically equal to s
).val singleton : elt > t
singleton x
returns the oneelement 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
(the result of the function is then physically equal to s
).val union : t > t > t
val inter : t > t > t
val diff : t > t > t
val compare : t > t > int
val equal : t > t > bool
equal s1 s2
tests whether the sets s1
and s2
are
equal, that is, contain 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 map : (elt > elt) > t > t
map f s
is the set whose elements are f a0
,f a1
... f
aN
, where a0
,a1
...aN
are the elements of s
.
The elements are passed to f
in increasing order
with respect to the ordering over the type of the elements.
If no element of s
is changed by f
, s
is returned
unchanged. (If each output of f
is physically equal to its
input, the returned set is physically equal to s
.)
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
. If p
satisfies every element in s
,
s
is returned unchanged (the result of the function is then
physically equal to s
).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
val elements : t > elt list
Ord.compare
, where Ord
is the argument
given to Set.Make
.val min_elt : t > elt
Ord.compare
ordering), or raise
Not_found
if the set is empty.val max_elt : t > elt
Set.S.min_elt
, but returns the largest element of the
given set.val choose : t > elt
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 elements 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.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.