"Represents an iterable collection of elements of finite 
 size. `Collection` is the abstract supertype of `List`,
 `Map`, and `Set`.
 
 A `Collection` forms a `Category` of its elements.
 
 All `Collection`s are `Cloneable`. If a collection is
 immutable, it is acceptable that `clone` produce a
 reference to the collection itself. If a collection is
 mutable, `clone` should produce an immutable collection
 containing references to the same elements, with the
 same structure as the original collection—that 
 is, it should produce an immutable shallow copy of the
 collection."
see (`interface List`, `interface Map`, `interface Set`)
shared interface Collection<out Element>
        satisfies {Element*} &
                  Cloneable<Collection<Element>> {
    
    "Determine if the collection is empty, that is, if 
     it has no elements."
    shared actual default Boolean empty => size==0;
    
    "Return `true` if the given object is an element of
     this collection. In this default implementation,
     and in most refining implementations, return `false`
     otherwise. An acceptable refining implementation
     may return `true` for objects which are not 
     elements of the collection, but this is not 
     recommended. (For example, the `contains()` method 
     of `String` returns `true` for any substring of the
     string.)"
    shared actual default Boolean contains(Object element) {
        for (elem in this) {
            if (exists elem, elem==element) {
                return true;
            }
        }
        else {
            return false;
        }
    }
        
    "A string of form `\"{ x, y, z }\"` where `x`, `y`, 
     and `z` are the `string` representations of the 
     elements of this collection, as produced by the
     iterator of the collection, or the string `\"{}\"` 
     if this collection is empty. If the collection 
     iterator produces the value `null`, the string
     representation contains the string `\"null\"`."
    shared actual default String string => 
            empty then "{}" else "{ ``commaList(this)`` }";
    
}