module ISet: BatISet
typet =
(int * int) BatAvlTree.tree
the underlying representation is a balanced tree of ranges
typeelt =
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
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
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