    """The abstract supertype of all types representing
       definite values. Any two `Object`s may be compared
       for value equality using the `==` and `!=` operators:

           true==false
           1=="hello world"
           "hello"+" "+"world"=="hello world"
           Singleton("hello world")=={ "hello world" }

       However, since `Null` is not a subtype of `Object`, the
       value `null` cannot be compared to any other value
       using `==`. Thus, value equality is not defined for
       optional types. This neatly voids the problem of
       deciding the value of the expression `null==null`,
       which is simply illegal."""
    see (`class Basic`, `class Null`)
    by ("Gavin")
    shared abstract class Object()
            extends Anything() {

        "Determine if two values are equal. Implementations
         should respect the constraints that:

         - if `x===y` then `x==y` (reflexivity),
         - if `x==y` then `y==x` (symmetry),
         - if `x==y` and `y==z` then `x==z` (transitivity).

         Furthermore it is recommended that implementations
         ensure that if `x==y` then `x` and `y` have the
         same concrete class."
        shared formal Boolean equals(Object that);

        "The hash value of the value, which allows the value
         to be an element of a hash-based set or key of a
         hash-based map. Implementations must respect the
         constraint that if `x==y` then `x.hash==y.hash`."
        shared formal Integer hash;

        "A developer-friendly string representing the
         instance. Concatenates the name of the concrete
         class of the instance with the `hash` of the
         instance. Subclasses are encouraged to refine this
         implementation to produce a more meaningful
         representation."
        shared default String string =>
                className(this) + "@" + hash.string;

    }