Type Hierarchy:

- Anything
  - Object

Direct Known Subclasses: Array<Element>, Basic, Character, Entry<Key,Item>, Float, Integer, Range<Element>, Singleton<Element>, String, Tuple<Element,First,Rest>, empty, emptyMap, emptySet
All Known Subtypes Hierarchy

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

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.

By: Gavin
See also: Basic, Null

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`.
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.