anchor.diff:  
   ====== New map equality ======
   
  -To rectify this, we propose instead that two maps `m1` and `m2` should be equal if:
  -
  -* `m1` and `m2` have the same keys,
  -** including keys that map to a `null` value (the order of keys as returned by `keys()` does not matter here).
  -* Additionally, for each such key `k`,
  -** `m1.k = m2.k` is `true`.
  -
  -As a consequence of these changes, plain <<equality-def>> is not reflexive for all values (consider: `{a: null} = {a: null}`, `[null] = [null]`). However this was already the case (consider: `null = null` \=> `null`).
  +To rectify this, we propose instead to define the equality of two maps `m1` and `m2` as:
  +
  +* `m1` and `m2` have the same keys, including keys that map to a `null` value (the order of keys as returned by `keys()` does not matter here) `AND`
  +* the <<conjunction>> of `m1.k = m2.k` for each key `k`.
  +
  +As a consequence of these changes, plain <<equality-def>> is not reflexive for all values (consider: `{a: null} = {a: null}`, `[null] = [null]`).
  +However this was already the case (consider: `null = null` \=> `null`).
   
   Note that <<equality-def>> is reflexive for values that do not involve `null` though.
   
  
positive.code:   ** The comparison order for maps is unspecified and left to implementations.
    ** The comparison order for maps must align with the <<equality-def,equality semantics>> outlined below.
    In consequence, any map that contains an entry that maps its key to a `null` value is <<incomparable>>.
    For exampe, `{a: 1} \<= {a: 1, b: null}` evaluates to `null`.
    ** Regular maps are <<incomparable>> to any value that is not also a regular map.
    * Nodes
    ** The comparison order for nodes is based on an implementation specific internal total order of node identities.
  
negative.code: [[equality-def,equality]]
  ==== Equality ====
  
  Given that values are only comparable within their most specific type, and comparability and equality are tied together, equlity of values of different types always evaluates to `null`.
  In order to align equality with <<comparability-def>>, we change equality of lists and maps that contain `null` values to treat those values in the same way as if they would have been compared outside of those lists and maps, as individual, simple values.
  
  ===== List equality =====
  
  Specifically, we propose to redefine how equality works for lists in Cypher.
  The equality of two lists `a` and `b` is defined is the <<conjunction>> of `size(a) = size(b)` and a pairwise comparison of all elements of the list.
  If `a = b` evaluates to `null` these lists are <<incomparable>>.
  
  In the following example `=>` means "evaluates to".
  ----
  [1, 2] = [1]
      => size([1, 2]) = size([1]) AND 1 = 1 AND 2 = null
      => false                    AND true  AND null
      => false
  
  [null] = [1]
      => size([null]) = size[1]) AND null = 1
      => true                    AND null
      => null
  
  ["a"] = [1]
      => size(["a"]) = size[1]) AND "a" = 1
      => true                   AND null
      => null
  ----
  
  The same logic applies recursively when comparing nested lists.
  ----
  [[1]] = [[1], [null]]
      => size([[1]]) = size([[1], [null]]) AND [1] = [1] AND null = [null]
      => false                             AND true      AND null
      => false
  ----
  
  ===== Map equality =====
  
  