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.

By: Gavin
See also Basic, Null
Initializer
Object()
Attributes
hashSource Codeshared formal Integer hash

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.

stringSource Codeshared default String string

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.

Methods
equalsSource Codeshared formal Boolean equals(Object that)

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.