---
name: "Depend.StringSet"
section: "3o"
platform: "linux"
package: "ocaml-compiler-libs"
version: "4.05.0-11"
release: "Debian 10 (Buster)"
platforms: ["linux"]
url: "https://new.carta.tech/Depend.StringSet"
---

# Depend.StringSet(3o)

no description

## NAME

Depend.StringSet - no description

## Module

Module   Depend.StringSet

## Documentation

Module **StringSet**\
  :  **sig end**

*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