Determine if two values are equal.

For any two non-null objects `x`

and `y`

, `x.equals(y)`

may be written as:

x == y

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`

.

Note that an implementation of `equals()`

that always
returns `false`

does satisfy the constraints given
above, as long as the class does *not* inherit
`Identifiable`

. Therefore, in very rare cases where
there is no reasonable definition of value equality for
a class, for example, function references (`Callable`

),
it is acceptable for `equals()`

to be defined to return
`false`

for every argument.