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`

- `Anything`
  - `Object`

- `Object`
  - `Anything`

- `Object`
  - `Array`
  - `ArraySequence`
  - `Basic`
    - `AbstractAnnotation`
    - `ActualAnnotation`
    - `AnnotationAnnotation`
    - `AuthorsAnnotation`
    - `Boolean`
      - `false`
      - `true`
    - `Comparison`
      - `equal`
      - `larger`
      - `smaller`
    - `DefaultAnnotation`
    - `DeprecationAnnotation`
    - `DocAnnotation`
    - `FinalAnnotation`
    - `Finished`
      - `finished`
    - `FormalAnnotation`
    - `LateAnnotation`
    - `LicenseAnnotation`
    - `NativeAnnotation`
    - `OptionalImportAnnotation`
    - `SealedAnnotation`
    - `SeeAnnotation`
    - `SharedAnnotation`
    - `StringBuilder`
    - `TagsAnnotation`
    - `Throwable`
      - `AssertionError`
        - `InitializationError`
      - `Exception`
        - `IncompatibleTypeException`
        - `InvocationException`
        - `MutationException`
        - `OverflowException`
        - `TypeApplicationException`
    - `ThrownExceptionAnnotation`
    - `VariableAnnotation`
    - `contravariant`
    - `covariant`
    - `emptyIterator`
    - `invariant`
    - `language`
    - `modules`
    - `nothingType`
    - `nothingType`
    - `operatingSystem`
    - `process`
    - `runtime`
    - `system`
  - `Byte`
  - `Character`
  - `Entry`
  - `Float`
  - `Integer`
  - `Range`
  - `Singleton`
  - `String`
  - `Tuple`
  - `empty`
  - `emptyMap`
  - `emptySet`

Initializer
`Object()`

Attributes
`hash` | Source Code `shared 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`.
`string` | Source Code `shared 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
`equals` | Source Code `shared 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`.