# Module Batteries.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 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 is_empty : 'a t -> bool

Test whether a set is empty or not.

    val singleton : '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 sym_diff : 'a t -> 'a t -> 'a t

`sym_diff s t` returns the set of all elements in `s` or `t` but not both, also known as the symmetric difference. This is the same as `diff (union s t) (inter s t)`. The returned set uses `s`'s comparison function.

    val compare : 'a t -> 'a t -> int

Total ordering between sets. Can be used as the ordering function for doing sets of sets.

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

`equal s1 s2` tests whether the sets `s1` and `s2` are equal, that is, contain equal elements.

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

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

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

`disjoint s1 s2` tests whether the sets `s1` and `s2` contain no shared elements. (i.e. `inter s1 s2` is empty.)

    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`

The resulting map uses the polymorphic `compare` function to order elements.

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

The resulting map uses the polymorphic `compare` function to order elements.

    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 elements : 'a t -> 'a list

Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering of the given 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 backwards : 'a t -> 'a BatEnum.t

Return an enumeration of all elements of the given set. The returned enumeration is sorted in decreasing order with respect to the ordering `Pervasives.compare`.

    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 -> 'c -> unit) ->
           'a BatInnerIO.output -> 'c t -> unit

    module PSet: sig .. end