Section Header
    + name := SET[E];
    - comment := "Definition of a mathematical set of objects.";
All common operations on mathematical sets are available.
Well knowned implementations are HASHED_SET and AVL_SET.
Section Inherit
    + parent_traversable:TRAVERSABLE[E] :=
    + parent_safe_equal:SAFE_EQUAL[E] :=
Section Public
Counting:
    - count:INTEGER <-
        Cardinality of the set (i.e. actual `count' of stored elements).
    - is_empty:BOOLEAN <-
        Is the set empty?
Adding and removing:
    - add e:E <-
        Add new item `e' to the set. The mathematical definition of adding
        in a set is followed, i.e. the element `e' is added only and only
        if it is not yet present in the set.
        As this `add' feature is actually using `is_equal', you may consider
        to use `fast_add' for expanded objects as well while trying to get
        the very best performances.
    - fast_add e:E <-
        Same job as `add', but uses basic `=' for comparison.
    - remove e:E <-
        Remove item `e' from the set: the mathematical definition of
        removing from a set is followed.
    - fast_remove e:E <-
        Same job as `remove', but uses basic `=' for comparison.
    - clear <-
    - clear_count <-
        Empty the current set (`is_empty' is True after that call).
        If possible, the actual implementation is supposed to keep
        its internal storage area in order to refill `Current' in
        an efficient way.
       
        See also `clear_count_and_capacity' to select the most appropriate.
    - clear_count_and_capacity <-
        Empty the current set (`is_empty' is True after that call).
        If possible, the actual implementation is supposed to release
        its internal storage area for this memory to be used by other objects.
       
        See also `clear_count' to select the most appropriate.
Looking and searching:
    - has e:E :BOOLEAN <-
        Is element `e' in the set?
        As this query is actually using `is_equal', you may consider to use
        `fast_has' for expanded objects as well while trying to get the very
        best performances.
    - fast_has e:E :BOOLEAN <-
        Is element `e' actually stored in the set?
        Warning: this query is using basic `=' for comparison.
       
        See also `has' when dealing with reference types.
    - reference_at e:E :E <-
        Non Void when `e' is in the set. In such a situation, `Result' is the
        object which is actually stored in the `Current' set (see ensure assertion).
To provide iterating facilities:
    - lower:INTEGER :=
    - upper:INTEGER <-
    - item i:INTEGER :E <-
        Item at the corresponding index `i'.
       
        See also `lower', `upper', `valid_index'.
       
        SETs are intrinsically unordered, so there is no guarantee that
        `item'(i) after performing an `add' or `remove' operation is related
        in any way to `item'(i) before that operation.
    - first:E <-
        The very `first' item.
       
        See also `last', `item'.
       
        SETs are intrinsically unordered, so there is no guarantee that
        `first' after performing an `add' or `remove' operation is related
        in any way to `first' before that operation.
    - last:E <-
        The `last' item.
       
        See also `first', `item'.
       
        SETs are intrinsically unordered, so there is no guarantee that
        `last' after performing an `add' or `remove' operation is related
        in any way to `last' before that operation.
Mathematical operations:
    - union other:SELF <-
        Make the union of the `Current' set with `other'.
    - '+' other:SELF :SELF <-
        Return the union of the `Current' set with `other'.
    - intersection other:SELF <-
        Make the intersection of the `Current' set with `other'.
    - '^' other:SELF :SELF <-
        Return the intersection of the `Current' set with `other'.
    - minus other:SELF <-
        Make the set `Current' - `other'.
    - '-' other:SELF :SELF <-
        Return the set `Current' - `other'.
Comparison:
    - is_subset_of other:SELF :BOOLEAN <-
        Is the `Current' set a subset of `other'?
    - is_disjoint_from other:SELF :BOOLEAN <-
        Is the `Current' set disjoint from `other' ?
    - '==' other:SELF :BOOLEAN <-
        Is the `Current' set equal to `other'?
Duplication.
    - copy other:SELF <-
        Copy 'other' into the current set
    - from_collection model:COLLECTION[E] <-
        Add all items of `model'.
Agents based features:
    - do_all action:BLOCK <-
        Apply `action' to every item of `Self'.
       
        See also `for_all', `exists'.
    - for_all predicate:BLOCK :BOOLEAN <-
        Do all items satisfy `predicate'?
       
        See also `do_all', `exists'.
    - exists predicate:BLOCK :BOOLEAN <-
        Does at least one item satisfy `predicate'?
       
        See also `do_all', `for_all'.
Creation.
    - create:SELF <-
    - make <-
        Creation of an empty SET.