MoreLabels.Set.S(3) OCaml library MoreLabels.Set.S(3)

# [NAME](#NAME)

MoreLabels.Set.S - Output signature of the functor MoreLabels.Set.Make.

# [Module type](#Module_type)

Module type MoreLabels.Set.S

# [Documentation](#Documentation)

Module type **S**  
\= **sig end**

Output signature of the functor **MoreLabels.Set.Make** .

## [Sets](#Sets)

*type elt*

The type of the set elements.

*type t*

The type of sets.

*val empty* : **t**

The empty set.

*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 disjoint* : **t -> t -> bool**

Test if two sets are disjoint.

**Since** 4.08

*val diff* : **t -> t -> t**

Set difference: **diff s1 s2** contains the elements of **s1** that are not in **s2** .

*val cardinal* : **t -> int**

Return the number of elements of a set.

## [Elements](#Elements)

*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 **MoreLabels.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 **MoreLabels.Set.S.min\_elt** , but returns the largest element of the given set.

*val max\_elt\_opt* : **t -> elt option**

Same as **MoreLabels.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

## [Searching](#Searching)

*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

*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* : **f:(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* : **f:(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* : **f:(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* : **f:(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

## [Traversing](#Traversing)

*val iter* : **f:(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* : **f:(elt -> 'acc -> 'acc) ->** **t -> init:'acc -> 'acc**

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

## [Transforming](#Transforming)

*val map* : **f:(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

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

**filter ~f s** returns the set of all elements in **s** that satisfy predicate **f** . If every element in **s** satisfies **f** , **s** is returned unchanged (the result of the function is then physically equal to **s** ).

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

*val filter\_map* : **f:(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

*val partition* : **f:(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 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** .

## [Predicates and comparisons](#Predicates_and_comparisons)

*val is\_empty* : **t -> bool**

Test whether a set is empty or not.

*val is\_singleton* : **t -> bool**

Test whether a set has exactly one element or not.

**Since** 5.5

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

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

*val equal* : **t -> t -> bool**

**equal s1 s2** tests whether the sets **s1** and **s2** are equal, that is, contain equal elements.

*val compare* : **t -> t -> int**

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

*val subset* : **t -> t -> bool**

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

*val for\_all* : **f:(elt -> bool) -> t -> bool**

**for\_all ~f s** checks if all elements of the set satisfy the predicate **f** .

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

**exists ~f s** checks if at least one element of the set satisfies the predicate **f** .

## [Converting](#Converting)

*val to\_list* : **t -> elt list**

**to\_list s** is **MoreLabels.Set.S.elements** **s** .

**Since** 5.1

*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

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

**Since** 4.07

2026-09-04 OCamldoc

---

Document: MoreLabels.Set.S(3o) from ocaml 5.5.1-r0 (Chainguard OS)
Source: https://github.com/ocaml/ocaml