`module ISet: ``BatISet`

type`t =`

`(int * int) BatAvlTree.tree`

the underlying representation is a balanced tree of ranges

type`elt =`

`int`

This kind of set only holds ints

`val empty : ``t`

The empty set

`val is_empty : ``t -> bool`

Test whether a set is empty, returns `true`

if the set is empty.

`val mem : ``int -> t -> bool`

test whether a given int is a member of the set

`val add : ``int -> t -> t`

Add the given int to the set, returning a new set

`val add_range : ``int -> int -> t -> t`

`add_range lo hi t`

adds the range of integers `lo, hi`

(including both endpoints) to
the given set, returning a new set

**Raises**`Invalid_argument`

if`lo`

>`hi`

`val singleton : ``int -> t`

Return the singleton set containing only the given element

`val remove : ``int -> t -> t`

Remove an element from the given set, returning a new set

`val remove_range : ``int -> int -> t -> t`

`remove_range lo hi t`

removes a range of elements from the given set, returning a new set

**Raises**`Invalid_argument`

if`lo`

>`hi`

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

Compute the union of two sets. This is the set whose elements are those elements in either input set.

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

Compute the intersection of two sets. This is the set whose elements are those in *both* of the input sets.

`val diff : ``t -> t -> t`

Compute the difference between two sets. This is the set of
elements that are in the first but not in the second. Unlike
`union`

and `inter`

, order matters here.

`val compl : ``t -> t`

Create the complement of the given set - i.e. the set of all values not in the input set.

`val compare : ``t -> t -> int`

Compare two sets. It is not safe to use the polymorphic (<) and related functions to compare these sets, as the tree representation used can balance in multiple ways.

`val equal : ``t -> t -> bool`

Test whether two sets are equal. It is not safe to use the polymorphic (=) on these sets, as the same set can have multiple representations depending on how it was built.

`val ord : ``t -> t -> BatOrd.order`

Same as `compare`

but returns `BatOrd.Lt | BatOrd.Eq | BatOrd.Gt`

instead of an int.

`val subset : ``t -> t -> bool`

`subset t u`

returns `true`

if `t`

is a subset of `u`

`val from : ``int -> t -> t`

`from x t`

returns the portion of `t`

in the range `x, max_int`

`val after : ``int -> t -> t`

`after x t`

returns the portion of `t`

in the range `x+1, max_int`

`val until : ``int -> t -> t`

`until x t`

returns the portion of `t`

in the range `min_int, x`

`val before : ``int -> t -> t`

`before x t`

returns the portion of `t`

in the range `min_int, x-1`

`val iter : ``(int -> unit) -> t -> unit`

`iter f t`

calls `f`

once for each element of `t`

`val iter_range : ``(int -> int -> unit) -> t -> unit`

`iter_range f t`

calls `f`

once for each contiguous range of `t`

.
The contiguous ranges of a set are sequences of adjacent integers
all part of the set.

`val fold : ``(int -> 'a -> 'a) -> t -> 'a -> 'a`

`fold f t x0`

returns the final result of merging each element of
`t`

into `x0`

using merge function `f`

`val fold_range : ``(int -> int -> 'a -> 'a) -> t -> 'a -> 'a`

As fold, but operates on contiguous ranges

`val for_all : ``(int -> bool) -> t -> bool`

Tests whether a predicate applies to all elements of the set

`val exists : ``(int -> bool) -> t -> bool`

Test whether some element of a set satisfies a predicate

`val filter : ``(int -> bool) -> t -> t`

Builds the subset of those elements that satisfy the predicate

`val partition : ``(int -> bool) -> t -> t * t`

partitions the input set into two sets with elements that satisfy the predicate and those that don't

`val cardinal : ``t -> int`

Returns the number of elements in the set

`val elements : ``t -> int list`

Returns a list of all elements in the set

`val ranges : ``t -> (int * int) list`

Returns a list of all contiguous ranges in the set

`val min_elt : ``t -> int`

Returns the minimum element in the set

`val max_elt : ``t -> int`

Returns the maximum element in the set

`val choose : ``t -> int`

Returns some element in the set

`val enum : ``t -> (int * int) BatEnum.t`

Enumerates all contiguous ranges in the set

`val of_enum : ``(int * int) BatEnum.t -> t`

`val of_list : ``(int * int) list -> t`

Build a ISet.t out of a list or enum of ranges

`val print : ``'a BatIO.output -> t -> unit`