anchor.diff:  === Orderability
   
   We further propose that orderability be defined between any pair of values, where the result is always `true` or `false`; i.e. always defined.
  -To accomplish this, there must be a pre-determined type order and each value must fall under exactly one type in this order. We propose to use the following ascending global sort order:
  +To accomplish this, there must be a pre-determined type order and each value must fall under exactly one type in this order. We propose to use the following ascending global sort order of types:
   
   * `NODE`
   * `RELATIONSHIP`
  
positive.code: 
  === Equality ===
  
  Finally, we propose that equality and comparability must be aligned, i.e. `l = r <=> l <= r && l >= r`.
  
  To achieve this, we unify the difference between equality and equivalence, by making lists containing `null` values follow the same difference as the `null` values themselves.
  Concretely, we propose to redefine how equality works for lists in Cypher today.
  To determine if two lists `l1` and `l2` are equal, we propose two simple tests, like so
  
  
negative.code: 
  However this type of update map comparison is rare and could be emulated using a more complex predicate. The current rules do however break symmetry with how equality handles `null` in all other cases. This becomes more apparent by considering these two examples
  
  * `expr1 = expr2` => `null` if `expr1 IS null && expr2 IS NULL`
  * `{a: expr1} = {a: expr2}` => `true` (!!) if `expr1 IS null && expr2 IS NULL`
  
  To fix this, we propose that two maps `m1` and `m2` instead should be equal if
  
  * `m1` and `m2` have the same keys (the order of keys as returned by `keys` does not matter)
  * For each such key `k`, `m1.k = m2.k`
  
  As a consequence of these changes, plain equality is not reflexive in a classic sense (Consider: `{a: null} = {a: null}`, `[null] = [null]`). However this was already the case (Consider: `null = null` => `null`).
  
  However, Equality is reflexive for values that do not involve `null`.
  
  === Equivalence ===
  
  Equivalence remains unchanged but now can be defined succinctly as being identical to equality except that:
  * Any two `null` values are treated as equivalent (both directly or inside nested structures).
  * Any two `NaN` values are treated as equivalent (both directly or inside nested structures).
  
  Note that orderability is aligned with equivalence, i.e. equivalent values have the same position under orderability.
  
  Equivalence is reflexive for all values.
  
  === Summary of Conceptual Model
  
  This proposal aims to simplify the conceptual model around equality, comparison, sorting, and grouping:
  
  * Equality: Equality follows natural, literal equality. However, values involving `null` are never equal. Nested structures are first tested for equality by shape (keys, size) and then componentwise. This ensures that equality is compatible with interpreting `null` as "unknown" or "could be any value".
  * Comparability: Comparability is aligned with equality. Two values of the same type in the global sort order are always comparable. Two values of different types are always incomparable and values involving `null` are always incomparable.
  This ensures that `MATCH (n) WHERE n.prop > 42` will never find nodes where `n.prop` is of type `STRING`.
  * Equivalence: Equivalence is a form of equality that treats `null` (and `NaN`) values as identical. Equivalence is used in grouping and `DISTINCT` where `null` commonly is interpreted as a marker that a value was missing instead of as a wildcard for any possible value.
  * Orderability follows comparability but additionally defines a global sort order between values of different types and is aligned with equivalence regarding the handling of `null` and `NaN` values.
  
  === Examples
  
  