anchor.diff:  
   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
   
  -* `n.prop = m.prop` => `null` if `n.prop IS null && m.prop IS NULL`
  -* `{a: n.prop} = {a: m.prop}` => `true` (!!) if `n.prop IS null && m.prop IS NULL`
  +* `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
  +* `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`).
   
  -Equality is reflexive regarding values that do not involve `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).
  -
  -Equivalence is reflexive regarding any values.
  +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:
   
  -* Two values of the same type in the global sort order are always comparable. Two values of different types are always incomparable.
  +* 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`.
  -* Orderability follows comparability but additionally defines a global sort order between values of different types.
  -* Equality is aligned with comparability.
  -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").
  -* `DISTINCT` and grouping use equivalence which is the same as equality except that two `null` values are considered to be equivalent.
  +* 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
   
  
positive.code: * Booleans are compared such that `false < true`.
  * Strings are compared in dictionary order, i.e. characters are compared pairwise in order and characters missing in a shorter string are considered to be smaller than any other character. For example, `'a' < 'aa'`.
  * Lists are compared in dictionary order, i.e. list elements are compared pairwise in order and elements missing in a shorter list are considered to be smaller than any other value. For example, `[1] < [1,0]`.
  * Maps are compared as if they where lists of lists, where the inner lists are the key-value pairs of the maps, ordered in ascending sort order for the keys and omitting map entries where the value is `null`. Comparing a map to a value that is not a map always yields `null`.
  * The comparison order for nodes (and relationships resp.) is undefined, and an implementation may choose an order for these freely, e.g. by using some kind of id. This order must not change during the execution of the query (i.e. it must be stable in the presence of updates). Comparing a node to a relationship always yields `null`.
  * Paths are compared as if they where a list of alternating nodes and relationships of the path from the start node to the end node. Comparing a path to a value that is not a path always yields `null`.
  * Implementations may choose to define suitable comparability rules for values of additional, non-canonical types. However comparing a value of an additional, non-canonical type to any of the canonical types always yields `null`.
  
negative.code:     ** In equality, `null = null` is `null`.
      ** In equivalence, used by grouping and `DISTINCT`, instances of `null` are always treated as being the same value.
      ** However, equality treats `null` values differently if they are an element of a list or a map value.
      ** Similar rules apply for `NaN`.
  
  == Proposal
  
  === Comparability
  
  We propose that comparability be defined between any pair of values, as specified below (Please note that `null` is interpreted as meaning "unknown" or "could be any value" in the context of comparability):
  
  * Integers are compared numerically.
  * Floats (excluding `NaN` and the Infinities) are compared numerically.
  