# Module type Set.S

`module type S : `sig ... end``
 Types `elt` The type of the set elements. Abstract `t` The type of sets. Abstract

 Simple values `empty` `t` The empty set.

 Functions

 ``` is_empty``` : `t -> bool`
Test whether a set is empty or not.

 ``` mem``` : `elt -> t -> bool`
`mem x s` tests whether `x` belongs to the set `s`.

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

 ``` singleton``` : `elt -> t`
`singleton x` returns the one-element set containing only `x`.

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

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

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

 ``` diff``` : `t -> t -> t`
Union, intersection and set difference.

 ``` compare``` : `t -> t -> int`
Total ordering between sets. Can be used as the ordering function for doing sets of sets.

 ``` equal``` : `t -> t -> bool`
`equal s1 s2` tests whether the sets `s1` and `s2` are equal, that is, contain equal elements.

 ``` subset``` : `t -> t -> bool`
`subset s1 s2` tests whether the set `s1` is a subset of the set `s2`.

 ``` iter``` : `f:(elt -> unit) -> t -> unit`
`iter f s` applies `f` in turn to all elements of `s`. The order in which the elements of `s` are presented to `f` is unspecified.

 ``` fold``` : `f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a`
`fold f s a` computes `(f xN ... (f x2 (f x1 a))...)`, where `x1 ... xN` are the elements of `s`. The order in which elements of `s` are presented to `f` is unspecified.

 ``` for_all``` : `f:(elt -> bool) -> t -> bool`
`for_all p s` checks if all elements of the set satisfy the predicate `p`.

 ``` exists``` : `f:(elt -> bool) -> t -> bool`
`exists p s` checks if at least one element of the set satisfies the predicate `p`.

 ``` filter``` : `f:(elt -> bool) -> t -> t`
`filter p s` returns the set of all elements in `s` that satisfy predicate `p`.

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

 ``` cardinal``` : `t -> int`
Return the number of elements of a set.

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

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

 ``` max_elt``` : `t -> elt`
Same as `min_elt`, but returns the largest element of the given set.

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