Legend:
Library
Module
Module type
Parameter
Class
Class type

## Set

`include Set.S with type elt = t`
`type elt = t`

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

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

• before 4.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 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 option`

`find e s` is the element of `s` equal to `e` (if any).

`val get : elt -> t -> elt`

`get` is like `find` but

• raises Invalid_argument

if `elt` is not in `s`.

`val min_elt : t -> elt option`

`min_elt s` is the smallest element of `s` (if any).

`val get_min_elt : t -> elt`

`get_min_elt` is like `min_elt` but

• raises Invalid_argument

on the empty set.

`val max_elt : t -> elt option`

`max_elt s` is the greatest element of `s` (if any).

`val get_max_elt : t -> elt`

`get_max_elt` is like `max_elt` but

• raises Invalid_argument

on the empty set.

`val choose : t -> elt option`

`choose s` is an element of `s` or `None` is `s` empty. The chosen element is equal for equal sets.

`val get_any_elt : t -> elt`

`get_any_elt` is like `choose` but

• raises Invalid_argument

on the empty set.

## Conversions

`val to_list : t -> elt list`

`to_list s` is the elements of `s` in increasing order.

`val of_list : elt list -> t`

`of_list l` is a set from the elements of `l`

## Pretty-printers

```val pp : ?sep:(Format.formatter -> unit -> unit) -> (Format.formatter -> elt -> unit) -> Format.formatter -> t -> unit```

`pp ~sep pp_elt ppf s` formats the elements of `s` on `ppf`. Each element is formatted with `pp_elt` and elements are separated by `~sep` (defaults to `Format.pp_print_cut`). If the set is empty leaves `ppf` untouched.

`val dump : (Format.formatter -> elt -> unit) -> Format.formatter -> t -> unit`

`dump pp_elt ppf s` prints an unspecified representation of `s` on `ppf` using `pp_elt` to print elements.