# Module BatteriesPrint.StringSet

    module StringSet: BatSet.Make(String)

    type elt

The type of the set elements.

    type t

The type of sets.

    val empty : t

The empty set.

    val is_empty : t -> bool

Test whether a set is empty or not.

    val singleton : elt -> t

`singleton x` returns the one-element set containing only `x`.

    val mem : elt -> t -> bool

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

    val find : elt -> t -> elt

`find x s` returns the element in s that tests equal to `x` under its comparison function.
Raises `Not_found` if no element is equal

    val add : elt -> t -> 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 : elt -> t -> 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 : t -> t -> t

Set union.

    val inter : t -> t -> t

Set intersection.

    val diff : t -> t -> t

Set difference.

    val sym_diff : t -> t -> t

`sym_diff s t` returns the set of all elements in `s` or `t` but not both. This is the same as `diff (union s t) (inter s t)`.

    val compare : t -> t -> int

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

    val equal : t -> t -> bool

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

    val subset : t -> t -> bool

`subset s1 s2` tests whether the set `s1` is a subset of the set `s2`.

    val disjoint : t -> t -> bool

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

    val compare_subset : t -> t -> int

Partial ordering between sets as generated by `subset`

    val iter : (elt -> unit) -> 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 : (elt -> elt) -> t -> 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 : (elt -> bool) -> t -> t

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

    val filter_map : (elt -> elt option) -> t -> 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 : (elt -> 'a -> 'a) -> t -> 'a -> 'a

`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 for_all : (elt -> bool) -> t -> bool

`for_all p s` checks if all elements of the set satisfy the predicate `p`.

    val exists : (elt -> bool) -> t -> bool

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

    val partition : (elt -> bool) -> t -> t * t

`partition p s` returns a pair of sets `(s1, s2)`, where `s1` is the set of all the elements of `s` that satisfy the predicate `p`, and `s2` is the set of all the elements of `s` that do not satisfy `p`.

    val split : elt -> t -> t * bool * 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 split_opt : elt -> t -> t * elt option * t

`split_opt x s` returns a triple `(l, maybe_v, 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`; `maybe_v` is `None` if `s` contains no element equal to `x`, or `Some v` if `s` contains an element `v` that compares equal to `x`.
Since 2.2.0

    val split_lt : elt -> t -> t * t

`split_lt x s` returns a pair of sets `(l, r)`, such that `l` is the subset of `s` with elements < `x`; `r` is the subset of `s` with elements >= `x`.
Since 2.2.0

    val split_le : elt -> t -> t * t

`split_le x s` returns a pair of sets `(l, r)`, such that `l` is the subset of `s` with elements <= `x`; `r` is the subset of `s` with elements > `x`.
Since 2.2.0

    val cardinal : t -> int

Return the number of elements of a set.

    val elements : t -> elt list

Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering `Ord.compare`, where `Ord` is the argument given to `Set.Make`.

    val to_list : t -> elt list

Alias for `elements`.
Since 2.2.0

    val min_elt : t -> elt

Return the smallest element of the given set (with respect to the `Ord.compare` ordering).
Raises `Not_found` if the set is empty.

    val max_elt : t -> elt

Same as `Set.S.min_elt`, but returns the largest element of the given set.

    val choose : t -> elt

Return one element of the given set, or raise `Not_found` if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.

    val pop : t -> elt * t

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

    val enum : t -> elt 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 `Ord.compare`, where `Ord` is the argument given to `Set.Make`.

    val backwards : t -> elt 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 `Ord.compare`, where `Ord` is the argument given to `Set.Make`.

    val of_enum : elt BatEnum.t -> t

###### Boilerplate code

Printing

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

###### Override modules

The following modules replace functions defined in `Set` with functions behaving slightly differently but having the same name. This is by design: the functions meant to override the corresponding functions of `Set`.

    module Exceptionless: sig .. end

Operations on `Set` without exceptions.

    module Labels: sig .. end

Operations on `Set` with labels.