The ti(set) class implements a i(sorted collection of values). Before using
tt(set) containers the tthi(set) header file must be included.

    A set contains unique values (of a container-acceptable type). Each value
is stored only once, and the tt(set) sorts its values using their
tt(operator<), where the smallest values appears as first element in the set.

A specific value can be explicitly created: Every tt(set) defines a
ti(value_type) which may be used to create values that can be stored in the
tt(set). For example, a value for a tt(set<string>) can be constructed as
follows:
        verb(    set<string>::value_type setValue{ "Hello" };)

Like the tt(std::map) container, the tt(std::set) also has an additional
parameter declaring the class that is used for comparing values in the set.
For value type tt(ValueType) the set's type definition, therefore, looks like
this:
        verb(    set<ValueType, std::less<ValueType>>)

The tt(value_type) is associated with the tt(set<string>). Anonymous
tt(value_type) objects are also often used. E.g.,
        verb(    set<string>::value_type{ "Hello" };)

Instead of using the line tt(set<string>::value_type(...)) over
and over again, a using declaration is often used to reduce typing and to
improve readability:
        verb(    using StringSetValue = set<string>::value_type;)

Now values for the tt(set<string>) may be constructed as follows:
        verb(    StringSetValue{ "Hello" };)

Alternatively, values of the set's type may be used
immediately. In that case the value of type tt(Type) is implicitly
converted  to a tt(set<Type>::value_type).

    The following constructors, operators, and member functions are available
for the tt(set) container:
    itemization(
    it() Constructors:
        itemization(
        it() The copy and move constructors are available;
        it() A tt(set) may be constructed empty:
        verb(    set<int> object;)

it() A set may be initialized using two iterators. For example:
            verb(    int intarr[] = {1, 2, 3, 4, 5};

    set<int> object{ &intarr[0], &intarr[5] };)

)

    Note that all values in the set must be different: it is not possible to
store the same value repeatedly when the set is constructed. If the same value
occurs repeatedly, only the first instance of the value is entered into the
set; the remaining values are silently ignored.

    Like the link(map)(MAP), the tt(set) receives its own copy of the data it
contains.
    it() The tt(set) container only supports the standard set of operators
that are available for containers.
    it() The tt(set) class has the following member functions:
        itemization(
        ithtq(begin)(set::iterator begin())(returns an iterator pointing to
the first element of the set. If the set is empty tt(end) is returned.)
        ithtq(clear)(void clear())
            (erases all elements from the set.)
        ithtq(count)(size_t count(value))(returns 1 if
the specified value is available in the tt(set), otherwise 0 is returned.)
        ithtq(emplace)(pair<iterator, bool> emplace(Args &&...args))
           (a tt(value_type) object is constructed from the member's
            arguments, and the newly created element is inserted into the
            set. The return value's tt(second) member is tt(true) if the
            element is inserted, and tt(false) if the element was already
            available. The pair's tt(first) element is an iterator referring
            to the set's eement.) 
        ithtq(empty)(bool empty())(returns tt(true) if
the set contains no elements.)
        ithtq(end)(set::iterator end())(returns an iterator pointing beyond
the last element of the set.)
        ithtq(equal_range)
            (pair<set::iterator, set::iterator> equal_range(value))(this
member returns a pair of iterators, being respectively the return values of
the member functions tt(lower_bound) and tt(upper_bound), introduced
below.)
        ithtq(erase)(... erase())(erases a specific element or range of
elements from the set:)
            itemization(
            itt(bool erase(value)) erases the element having the given
tt(value) from the tt(set). tt(True) is returned if the value was removed,
tt(false) if the set did not contain an element `tt(value)'.
            itt(void erase(pos)) erases the element pointed to by the iterator
tt(pos).
            itt(void erase(first, beyond)) erases all elements
indicated by the iterator range rangett(first, beyond).
            )

        ithtq(find)(set::iterator find(value))(returns
an iterator to the element having the given value. If the element isn't
available, tt(end) is returned.)
        ithtq(get_allocator)(allocator_type get_allocator() const)(returns a
copy of the allocator object used by the tt(set) object.)
        ithtq(insert)(... insert())(inserts elements into the tt(set). If the
element already exists, the existing element is left untouched and the element
to be inserted is ignored.  The return value depends on the version of
tt(insert) that is called:)
            itemization(
            itt(pair<set::iterator, bool> insert(value)) inserts
a new tt(set::value_type) into the set. The return value is a
ti(pair<set::iterator, bool>).  If the returned ti(bool) field is tt(true),
tt(value) was inserted into the set. The value tt(false) indicates that the
value that was specified was already available in the set, and
so the provided tt(value) was not inserted into the set.  In both cases the
tt(set::iterator) field points to the data element in the tt(set) having the
specified tt(value).
            itt(set::iterator insert(pos, value)). This way a
tt(set::value_type) may also be inserted into the set. tt(pos) is ignored, and
an iterator to the inserted element is returned.
            itt(void insert(first, beyond)) inserts the (tt(set::value_type))
elements pointed to by the iterator range rangett(first, beyond) into the
set. Values that were already present are not replaced.
            )

    ithtq(key_comp)(key_compare key_comp())
       (returns a copy of the object used by the tt(set) to compare keys. The
        type nl()
        tt(set<ValueType>::key_compare) is defined by the set container
        and tt(key_compare)'s parameters have types tt(ValueType const &). The
        comparison function returns tt(true) if its first argument should
        be ordered before its second argument.)
    ithtq(lower_bound) (set::iterator lower_bound(value))
       (returns an iterator pointing to the first tt(value) element of
        which the tt(value) is at least equal to the specified tt(value).  If no
        such element exists, the function returns tt(end).)
    ithtq(max_size)(size_t max_size())(returns the maximum number of
        elements this tt(set) may contain.)
    ithtq(rbegin)(set::reverse_iterator rbegin())(
        returns a reverse_iterator pointing to the last element of the set.)
    ithtq(rend)(set::reverse_iterator rend)(returns a reverse_iterator
        pointing before the first element of the set.)
    ithtq(size)(size_t size())(returns the number of elements in the set.)
    ithtq(swap)(void swap(argument))(swaps two sets (tt(argument) being
the second set) that use identical data types.)
    ithtq(upper_bound)
            (set::iterator upper_bound(value))
            (returns an iterator pointing to the first
tt(value) element having a tt(value) exceeding the specified tt(value).  If no
such element exists, the function returns tt(end).)
    ithtq(value_comp)(value_compare value_comp())
       (returns a copy of the object used by the tt(set) to compare values. The
        type nl()
       tt(set<ValueType>::value_compare) is defined by the set container and
        tt(value_compare)'s parameters have types tt(ValueType const &). The
        comparison function returns tt(true) if its first argument should be
        ordered before its second argument. Its operation is identical to that
        of a tt(key_compare) object, returned by tt(key_comp).)
    )
  )
