module type S =`sig`

..`end`

Output signature of the functor `Set.Make`

.

`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
(the result of the function is then physically equal to `s`

).

**Before 4.03**Physical equality was not ensured.

`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
(the result of the function is then physically equal to `s`

).

**Before 4.03**Physical equality was not ensured.

`val union : ``t -> t -> t`

Set union.

`val inter : ``t -> t -> t`

Set intersection.

`val disjoint : ``t -> t -> bool`

Test if two sets are disjoint.

**Since**4.08.0

`val diff : ``t -> t -> t`

Set difference: `diff s1 s2`

contains the elements of `s1`

that are not in `s2`

.

`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, 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`

, where

aN`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 -> 'a`

`fold f s init`

computes `(f xN ... (f x2 (f x1 init))...)`

,
where `x1 ... xN`

are the elements of `s`

, in increasing order.

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

`for_all f s`

checks if all elements of the set
satisfy the predicate `f`

.

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

`exists f s`

checks if at least one element of
the set satisfies the predicate `f`

.

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

`filter f s`

returns the set of all elements in `s`

that satisfy predicate `f`

. If `f`

satisfies every element in `s`

,
`s`

is returned unchanged (the result of the function is then
physically equal to `s`

).

**Before 4.03**Physical equality was not ensured.

`val filter_map : ``(elt -> elt option) -> t -> t`

`filter_map f s`

returns the set of all `v`

such that
`f x = Some v`

for some element `x`

of `s`

.

For example,

`filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) s`

is the set of halves of the even elements of `s`

.

If no element of `s`

is changed or dropped by `f`

(if
`f x = Some x`

for each element `x`

), then
`s`

is returned unchanged: the result of the function
is then physically equal to `s`

.

**Since**4.11.0

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

`partition f s`

returns a pair of sets `(s1, s2)`

, where
`s1`

is the set of all the elements of `s`

that satisfy the
predicate `f`

, and `s2`

is the set of all the elements of
`s`

that do not satisfy `f`

.

`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 min_elt_opt : ``t -> elt option`

Return the smallest element of the given set
(with respect to the `Ord.compare`

ordering), or `None`

if the set is empty.

**Since**4.05

`val max_elt : ``t -> elt`

Same as `Set.S.min_elt`

, but returns the largest element of the
given set.

`val max_elt_opt : ``t -> elt option`

Same as `Set.S.min_elt_opt`

, but returns the largest element of the
given set.

**Since**4.05

`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 choose_opt : ``t -> elt option`

Return one element of the given set, or `None`

if
the set is empty. Which element is chosen is unspecified,
but equal elements will be chosen for equal sets.

**Since**4.05

`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.

**Since**4.01.0

`val find_opt : ``elt -> t -> elt option`

`find_opt x s`

returns the element of `s`

equal to `x`

(according
to `Ord.compare`

), or `None`

if no such element
exists.

**Since**4.05

`val find_first : ``(elt -> bool) -> t -> elt`

`find_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 option`

`find_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.

**Since**4.05

`val find_last : ``(elt -> bool) -> t -> elt`

`find_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.

**Since**4.05

`val find_last_opt : ``(elt -> bool) -> t -> elt option`

`find_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.

**Since**4.05

`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

`val to_seq_from : ``elt -> t -> elt Seq.t`

`to_seq_from x s`

iterates on a subset of the elements of `s`

in ascending order, from `x`

or above.

**Since**4.07

`val to_seq : ``t -> elt Seq.t`

Iterate on the whole set, in ascending order

**Since**4.07

`val to_rev_seq : ``t -> elt Seq.t`

Iterate on the whole set, in descending order

**Since**4.12

`val add_seq : ``elt Seq.t -> t -> t`

Add the given elements to the set, in order.

**Since**4.07

`val of_seq : ``elt Seq.t -> t`

Build a set from the given bindings

**Since**4.07