19.26 | Module `Set`: sets over ordered types

> This module implements the set data structure, given a total ordering function over the set elements. All operations over sets are purely applicative (no side-effects). The implementation uses balanced binary trees, and is therefore reasonably efficient: insertion and membership take time logarithmic in the size of the set, for instance.

    module type OrderedType =
      sig
        type t
        val compare: t -> t -> int
      end

> The input signature of the functor `Set.Make`. `t` is the type of the set elements. `compare` is a total ordering function over the set elements. This is a two-argument function `f` such that `f e1 e2` is zero if the elements `e1` and `e2` are equal, `f e1 e2` is strictly negative if `e1` is smaller than `e2`, and `f e1 e2` is strictly positive if `e1` is greater than `e2`. Example: a suitable ordering function is the generic structural comparison function `compare`.

    module type S =
      sig
        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 mem: elt -> t -> bool

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

        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 singleton: elt -> t

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

        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
        val inter: t -> t -> t
        val diff: t -> t -> t

> Union, intersection and set difference.

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

> `iter f s` applies `f` in turn to all elements of `s`. The order in which the elements of `s` are presented to `f` is unspecified.

        val fold: f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a

> `fold f s a` computes `(f xN ... (f x2 (f x1 a))...)`, where `x1 ... xN` are the elements of `s`. The order in which elements of `s` are presented to `f` is unspecified.

        val for_all: f:(elt -> bool) -> t -> bool

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

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

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

        val filter: f:(elt -> bool) -> t -> t

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

        val partition: f:(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 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 min_elt: t -> elt

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

        val max_elt: t -> elt

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

      end
    module Make(Ord: OrderedType): (S with type elt = Ord.t)

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