## set: sets over ordered types

This module implements the set data structure, given a total ordering function over the set elements. All operations over sets are purely applicative (no side-effects). The implementation uses balanced binary trees, and is therefore reasonably efficient: insertion and membership take time logarithmic in the size of the set, for instance.
```type 'a t
```
The type of sets containing elements of type 'a.
```value empty: ('a -> 'a -> int) -> 'a t
```
The empty set. The argument is a total ordering function over the set elements. This is a two-argument function f such that f e1 e2 is zero if the elements e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Examples: a suitable ordering function for type int is prefix -. You can also use the generic structural comparison function eq__compare.
```value is_empty: 'a t -> bool
```
Test whether a set is empty or not.
```value mem: 'a -> 'a t -> bool
```
mem x s tests whether x belongs to the set s.
```value add: 'a -> 'a t -> 'a t
```
add x s returns a set containing all elements of s, plus x. If x was already in s, s is returned unchanged.
```value remove: 'a -> 'a t -> 'a t
```
remove x s returns a set containing all elements of s, except x. If x was not in s, s is returned unchanged.
```value union: 'a t -> 'a t -> 'a t
value inter: 'a t -> 'a t -> 'a t
value diff: 'a t -> 'a t -> 'a t
```
Union, intersection and set difference.
```value equal: 'a t -> 'a t -> bool
```
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain the same elements.
```value compare: 'a t -> 'a t -> int
```
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
```value elements: 'a t -> 'a list
```
Return the list of all elements of the given set. The elements appear in the list in some non-specified order.
```value iter: ('a -> unit) -> 'a t -> unit
```
iter f s applies f in turn to all elements of s, and discards the results. The elements of s are presented to f in a non-specified order.
```value fold: ('a -> 'b -> 'b) -> 'a t -> 'b -> 'b
```
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 not specified.
```value choose: 'a t -> 'a
```
Return one element of the given set, or raise Not_found if the set is empty. Which element is chosen is not specified, but equal elements will be chosen for equal sets.