## table of contents

- buster 4.05.0-11

Set.S(3o) | OCamldoc | Set.S(3o) |

# NAME¶

Set.S - Output signature of the functor Set.Make.# Module type¶

Module type Set.S# Documentation¶

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**
).

**Before4.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** ).

**Before4.03** Physical equality was not ensured.

*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, 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** .)

**Since** 4.04.0

*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** ).

**Before4.03** Physical equality was not ensured.

*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 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

source: | 2019-01-25 |