    "The general contract for values whose magnitude can be
     compared. `Comparable` imposes a total ordering upon
     instances of any type that satisfies the interface.
     If a type `T` satisfies `Comparable<T>`, then instances
     of `T` may be compared using the comparison operators
     `<`, `>`, `<=`, `>=`, and `<=>`.

     The total order of a type must be consistent with the
     definition of equality for the type. That is, there
     are three mutually exclusive possibilities:

     - `x<y`,
     - `x>y`, or
     - `x==y`"
    by ("Gavin")
    shared interface Comparable<in Other> of Other
            given Other satisfies Comparable<Other> {

        "Compares this value with the given value.
         Implementations must respect the constraints that:

         - `x==y` if and only if `x<=>y == equal`
            (consistency with `equals()`),
         - if `x>y` then `y<x` (symmetry), and
         - if `x>y` and `y>z` then `x>z` (transitivity)."
        see (`function equals`)
        shared formal Comparison compare(Other other);

        /*"Determines if this value is strictly larger than
         the given value."
        shared Boolean largerThan(Other other) {
            return compare(other)==larger;
        }

        "Determines if this value is strictly smaller than
         the given value."
        shared Boolean smallerThan(Other other) {
            return compare(other)==smaller;
        }

        "Determines if this value is larger than or equal to
         the given value."
        shared Boolean asLargeAs(Other other) {
            return compare(other)!=smaller;
        }

        "Determines if this value is smaller than or equal
         to the given value."
        shared Boolean asSmallAs(Other other) {
            return compare(other)!=larger;
        }*/

    }