Batteries user guide : Batteries.ISet

# Module Batteries.ISet

    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