To focus the search input from anywhere on the page, press the 'S' key.

in-package search v0.1.0

Library

Module

Module type

Parameter

Class

Class type

Signature for sets of values of a totally ordered type.

## Set

`include Set.S`

`val empty : t`

The empty set.

`val is_empty : t -> bool`

Test whether a set is empty or not.

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

).

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

).

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

`equal s1 s2`

tests whether the sets `s1`

and `s2`

are equal, that is, contain equal elements.

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

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

.)

`fold f s a`

computes `(f xN ... (f x2 (f x1 a))...)`

, where `x1 ... xN`

are the elements of `s`

, in increasing order.

`for_all p s`

checks if all elements of the set satisfy the predicate `p`

.

`exists p s`

checks if at least one element of the set satisfies the predicate `p`

.

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

).

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

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`

.

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

.

`choose s`

is an element of `s`

or `None`

is `s`

empty. The chosen element is equal for equal sets.

## Conversions

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