anchor.diff:  
   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.
   To determine if two lists `l1` and `l2` are equal, we propose two simple tests, as exemplified by the following:
   
  -* `l1` and `l2` must have the same size, i.e. inversely `size(l1) <> size(l2>) \=> l1 <> l2`
  +* `l1` and `l2` must have the same size, i.e. inversely `size(l1) <> size(l2) \=> l1 <> l2`
   * the pairwise elements of both `l1` and `l2` must be equal, i.e.
   ----
   [a1, a2, ...] = [b1, b2, ...]
  
positive.code:   * `NaN` is <<incomparable>>.
    * Numbers are <<incomparable>> to any value that is not also a number.
  - Booleans
    * Booleans are compared such that `false < true`.
    * Booleans are <<incomparable>> to any value that is not also a boolean.
  - Strings
    * Strings are compared in dictionary order, i.e. characters are compared pairwise in ascending order from the start of the string to the end. Characters missing in a shorter string are considered to be smaller than any other character. For example, `'a' < 'aa'`.
    * Strings are <<incomparable>> to any value that is not also a string.
  - Lists
    * Lists are compared in dictionary order, i.e. list elements are compared pairwise in ascending order from the start of the list to the end. Elements missing in a shorter list are considered to be smaller than any other value. For example, `[1] < [1,0]`.
    * Lists containing `null` values are <<incomparable>>. For example, `[1] >= [1, null]` evaluates to `null`.
    * Lists are <<incomparable>> to any value that is not also a list.
  - Maps
    * [[regular-maps,regular maps]]Regular maps
    ** 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 it's 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 unspecified and left to implementations.
  
negative.code: 
  We propose that <<orderability-def>> and <<equivalence-def>> should be aligned with each other, i.e.
  
  `expr1` is equivalent to `expr2` if and only if they have the same position under orderability (i.e. they would be sorted before (or after resp.) any other non-equivalent value in the same way).
  
  Orderability and equivalence use <<missing-null,"missing" `null` values>>.
  
  