    """Abstract supertype of objects that contain other
       values, called *elements*, where it is possible to
       efficiently determine if a given value is an element.
       `Category` does not satisfy `Container`, because it is
       conceptually possible to have a `Category` whose
       emptiness cannot be computed.

       The `in` operator may be used to determine if a value
       belongs to a `Category`:

           if ("hello" in "hello world") { ... }
           if (69 in 0..100) { ... }
           if (key->value in { for (n in 0..100) n.string->n**2 }) { ... }

       Ordinarily, `x==y` implies that `x in cat == y in cat`.
       But this contract is not required since it is possible
       to form a meaningful `Category` using a different
       equivalence relation. For example, an `IdentitySet` is
       a meaningful `Category`."""
    by ("Gavin")
    shared interface Category {

        "Determines if the given value belongs to this
         `Category`, that is, if it is an element of this
         `Category`.

         For most `Category`s, if `x==y`, then
         `category.contains(x)` evaluates to the same
         value as `category.contains(y)`. However, it is
         possible to form a `Category` consistent with some
         other equivalence relation, for example `===`.
         Therefore implementations of `contains()` which do
         not satisfy this relationship are tolerated."
        see (`function containsEvery`, `function containsAny`)
        shared formal Boolean contains(Object element);

        "Determines if every one of the given values belongs
         to this `Category`."
        see (`function contains`)
        shared default Boolean containsEvery({Object*} elements) {
            for (element in elements) {
                if (!contains(element)) {
                    return false;
                }
            }
            else {
                return true;
            }
        }

        "Determines if any one of the given values belongs
         to this `Category`"
        see (`function contains`)
        shared default Boolean containsAny({Object*} elements) {
            for (element in elements) {
                if (contains(element)) {
                    return true;
                }
            }
            else {
                return false;
            }
        }

    }