Batteries_uni.Set

# Module Batteries_uni.Set

    module Set: BatSet

#### Functorized Sets

    module type OrderedType = BatInterfaces.OrderedType

Input signature of the functor `Set.Make`.

    module type S = sig .. end

Output signature of the functor `Set.Make`.

    module StringSet: S  with type elt = String.t

A set of strings.

    module IStringSet: S  with type elt = String.t

A set of strings.

    module NumStringSet: S  with type elt = String.t

A set of strings.

    module RopeSet: S  with type elt = BatRope.t

A set of ropes.

    module IRopeSet: S  with type elt = BatRope.t

A set of ropes.

    module IntSet: S  with type elt = BatInt.t

A set of integers.

    module CharSet: S  with type elt = Char.t

A set of characters.

    module Make: functor (Ord : OrderedType) -> S  with type elt = Ord.t

Functor building an implementation of the set structure given a totally ordered type.

###### Polymorphic sets

The definitions below describe the polymorphic set interface.

They are similar in functionality to the functorized `BatSet.Make` module, but the compiler cannot ensure that sets using different element ordering have different types: the responsibility of not mixing non-sensical comparison functions together is to the programmer. If in doubt, you should rather use the `BatSet.Make` functor for additional safety.

    type 'a t

The type of sets.

    include BatEnum.Enumerable

    include BatInterfaces.Mappable

    val empty : 'a t

The empty set, using `compare` as comparison function

    val create : ('a -> 'a -> int) -> 'a t

Creates a new empty set, using the provided function for key comparison.

    val is_empty : 'a t -> bool

Test whether a set is empty or not.

    val singleton : ?cmp:('a -> 'a -> int) -> 'a -> 'a t

Creates a new set with the single given element in it.

    val mem : 'a -> 'a t -> bool

`mem x s` tests whether `x` belongs to the set `s`.

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

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

    val union : 'a t -> 'a t -> 'a t

`union s t` returns the union of `s` and `t` - the set containing all elements in either `s` and `t`. The returned set uses `t`'s comparison function. The current implementation works better for small `s`.

    val intersect : 'a t -> 'a t -> 'a t

`intersect s t` returns a new set of those elements that are in both `s` and `t`. The returned set uses `s`'s comparison function.

    val diff : 'a t -> 'a t -> 'a t

`diff s t` returns the set of all elements in `s` but not in `t`. The returned set uses `s`'s comparison function.

    val subset : 'a t -> 'a t -> bool

`subset a b` returns true if `a` is a subset of `b`. O(|a|).

    val iter : ('a -> unit) -> 'a t -> unit

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

    val map : ('a -> 'a) -> 'a t -> 'a t

`map f x` creates a new set with elements `f a0`, `f a1`... `f aN`, where `a0`, `a1`, ..., `aN` are the values contained in `x`

    val filter : ('a -> bool) -> 'a t -> 'a t

`filter p s` returns the set of all elements in `s` that satisfy predicate `p`.

    val filter_map : ('a -> 'b option) -> 'a t -> 'b t

`filter_map f m` combines the features of `filter` and `map`. It calls calls `f a0`, `f a1`, `f aN` where `a0,a1..an` are the elements of `m` and returns the set of pairs `bi` such as `f ai = Some bi` (when `f` returns `None`, the corresponding element of `m` is discarded).

    val fold : ('a -> 'b -> 'b) -> 'a t -> 'b -> 'b

`fold f s a` computes `(f xN ... (f x1 (f x0 a))...)`, where `x0,x1..xN` are the elements of `s`, in increasing order.

    val exists : ('a -> bool) -> 'a t -> bool

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

    val for_all : ('a -> bool) -> 'a t -> bool

Returns whether the given predicate applies to all elements in the set

    val partition : ('a -> bool) -> 'a t -> 'a t * 'a t

returns two disjoint subsets, those that satisfy the given predicate and those that don't

    val split : 'a -> 'a t -> 'a t * bool * 'a t

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

    val cardinal : 'a t -> int

Return the number of elements of a set.

    val min_elt : 'a t -> 'a

returns the smallest element of the set. Raises `Invalid_argument` if given an empty set.

    val max_elt : 'a t -> 'a

returns the largest element of the set. Raises `Invalid_argument` if given an empty set.

    val choose : 'a t -> 'a

returns an arbitrary (but deterministic) element of the given set. Raises `Invalid_argument` if given an empty set.

    val pop : 'a t -> 'a * 'a t

returns one element of the set and the set without that element. Raises `Not_found` if given an empty set

    val enum : 'a t -> 'a BatEnum.t

Return an enumeration of all elements of the given set. The returned enumeration is sorted in increasing order with respect to the ordering of this set.

    val of_enum : 'a BatEnum.t -> 'a t

    val of_enum_cmp : cmp:('a -> 'a -> int) -> 'a BatEnum.t -> 'a t

    val of_list : 'a list -> 'a t

builds a set from the given list, using the default comparison function

###### Boilerplate code

Printing

    val print : ?first:string ->
           ?last:string ->
           ?sep:string ->
           ('a BatInnerIO.output -> 'b -> unit) ->
           'a BatInnerIO.output -> 'b t -> unit