"""The abstract supertype of all types representing definite 
   values. Any two values which are assignable to `Object` 
   may be compared for value equality using the `==` and `!=` 
   operators, even if the values are of different concrete 
   type:
   
       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 the `==` operator. Thus, value equality is not 
   defined for optional types. This neatly bypasses the 
   problem of deciding the value of the expression 
   `null==null`, which is simply illegal.
   
   A concrete subclass of `Object` must refine [[equals]] 
   and [[hash]] (or inherit concrete refinements), providing 
   a concrete definition of value equality for the class."""
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.
     
     A class which explicitly refines `equals()` is said to 
     support _value equality_, and the equality operator 
     `==` is considered much more meaningful for such 
     classes than for a class which simply inherits the
     default implementation of _identity equality_ from
     [[Identifiable]]."
    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`.
     
     Therefore, a class which refines [[equals]] must also
     refine `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;
    
}