module Make:
| Parameters: |
|
type elt
type t
val empty : tval is_empty : t -> boolval mem : elt -> t -> boolmem x s tests whether x belongs to the set s.val add : elt -> t -> tadd 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 -> tsingleton x returns the one-element set containing only x.val remove : elt -> t -> tremove 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 -> tval inter : t -> t -> tval diff : t -> t -> tval compare : t -> t -> intval equal : t -> t -> boolequal s1 s2 tests whether the sets s1 and s2 are
equal, that is, contain equal elements.val subset : t -> t -> boolsubset s1 s2 tests whether the set s1 is a subset of
the set s2.val iter : (elt -> unit) -> t -> unititer 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 -> tmap 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.)
Since 4.04.0
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'afold 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 -> boolfor_all p s checks if all elements of the set
satisfy the predicate p.val exists : (elt -> bool) -> t -> boolexists p s checks if at least one element of
the set satisfies the predicate p.val filter : (elt -> bool) -> t -> tfilter 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 * tpartition 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 -> intval elements : t -> elt listOrd.compare, where Ord is the argument
given to Set.Make.val min_elt : t -> eltOrd.compare ordering), or raise
Not_found if the set is empty.val min_elt_opt : t -> elt optionOrd.compare ordering), or None
if the set is empty.val max_elt : t -> eltSet.S.min_elt, but returns the largest element of the
given set.val max_elt_opt : t -> elt option
val choose : t -> eltNot_found if
the set is empty. Which element is chosen is unspecified,
but equal elements will be chosen for equal sets.val choose_opt : t -> elt optionNone 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 * tsplit 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 -> eltfind x s returns the element of s equal to x (according
to Ord.compare), or raise Not_found if no such element
exists.val find_opt : elt -> t -> elt optionfind_opt x s returns the element of s equal to x (according
to Ord.compare), or None if no such element
exists.val find_first : (elt -> bool) -> t -> eltfind_first f s, where f is a monotonically increasing function,
returns the lowest element e of s such that f e,
or raises Not_found if no such element exists.
For example, find_first (fun e -> Ord.compare e x >= 0) s will return
the first element e of s where Ord.compare e x >= 0 (intuitively:
e >= x), or raise Not_found if x is greater than any element of
s.
Since 4.05
val find_first_opt : (elt -> bool) -> t -> elt optionfind_first_opt f s, where f is a monotonically increasing function,
returns an option containing the lowest element e of s such that
f e, or None if no such element exists.val find_last : (elt -> bool) -> t -> eltfind_last f s, where f is a monotonically decreasing function,
returns the highest element e of s such that f e,
or raises Not_found if no such element exists.val find_last_opt : (elt -> bool) -> t -> elt optionfind_last_opt f s, where f is a monotonically decreasing function,
returns an option containing the highest element e of s such that
f e, or None if no such element exists.val of_list : elt list -> tof_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.