anchor.diff:  * `STRING`
   * `BOOLEAN`
   * `NUMBER`
  -** `NaN` is treated as the largest number in orderability only (i.e. it is put after positive infinity)
  +** `NaN` values are treated as the largest numbers in orderability only (i.e. they are put after positive infinity)
   * `VOID` (i.e. the type of `null`)
   
   To give a concrete example, under this global sort order all nodes come before all strings.
   
   Between values of the same type in the global sort order, orderability defers to comparability except that equality is overriden by equivalence as described below.
  +For example, `[null, 1]` is ordered before `[null, 2]` under orderability.
  +
  +Furthermore, the values of additional, non-canonical types must not be inserted after `NaN` values in the global sort order.
   
   The accompanying descending global sort order is the same order in reverse (i.e. it runs from `VOID` to `MAP`).
   
   [[equivalence-def,equivalence]]
   ==== Equivalence ====
   
  -Equivalence remains mostly unchanged but now can be defined succinctly as being identical to equality except that:
  +Equivalence now can be defined succinctly as being identical to equality except that:
   
   * Any two `null` values are equivalent (both directly or inside nested structures).
   * Any two `NaN` values are equivalent (both directly or inside nested structures).
   * However, `null` and `NaN` values are not equivalent (both directly or inside nested structures).
  +* Equivalence of lists is identical to equality of lists but uses equivalence for comparing the contained list elements.
  +* Equivalence of regular maps is identical to equality of regular maps but uses equivalence for comparing the contained map entries.
   
   Equivalence is reflexive for all values.
   
   [[aggregation]]
   === Aggregation ===
   
  -Generally, an aggregation function call `aggr(expr)` processes all matching rows for each aggregation key found in an incoming record (keys are compared using equivalence, as noted above).
  +Generally an aggregation `aggr(expr)` processes all matching rows for each aggregation key found in an incoming record (keys are compared using equivalence).
  +
   For a fixed aggregation key and each matching record, `expr` is evaluated to a value.
   This yields a list of candidate values.
  -Generally, the order of candidate values is unspecified.
  -However, if the aggregation happens in a projection with an associated `ORDER BY` subclause, the list of candidate values is ordered in the same way as the underlying records and as specified by the associated `ORDER BY` subclause.
  +Generally the order of candidate values is unspecified.
  +If the aggregation happens in a projection with an associated `ORDER BY` subclause, the list of candidate values is ordered in the same way as the underlying records and as specified by the associated `ORDER BY` subclause.
   
   In a regular aggregation (i.e. of the form `aggr(expr)`), the list of aggregated values is the list of candidate values with all `null` values removed from it.
   
   In a distinct aggregation (i.e. of the form `aggr(DISTINCT expr)`), the list of aggregated values is the list of candidate values with all `null` values removed from it.
  -Futhermore, in a distinct aggregation, only the first of all equivalent candidate values is included in the list of aggregated values, i.e. duplicates under equivalence are removed.
  +Futhermore, in a distinct aggregation, only one of all equivalent candidate values is included in the list of aggregated values, i.e. duplicates under equivalence are removed.
  +However, if the distinct aggregation happens in a projection with an associated `ORDER BY` subclause, always the first from a set of equivalent candidate values is included in the list of aggregated values.
   
   Finally, the remaining aggregated values are processed by the actual aggregation function.
   If the list of aggregated values is empty, the aggregation function returns a default value (`null` unless specified otherwise below).
  
positive.code:   ** Paths are compared as if they were a list of alternating nodes and relationships of the path from the start node to the end node.
    For example, given nodes `n1`, `n2`, `n3`, and relationships `r1` and `r3`, and given that `n1 < n2 < n3` and `r1 < r3`, then the path `p1` from `n1` to `n3` via `r1` would be less than the path `p2` to `n1` from `n2` via `r3`. Expressed in terms of lists:
  
    p1 < p2
    => [n1-r1->n3] < [n1<-r3-n2]
    => n1 < n1 || r1 < r3 || n3 < n2
    => false || true || false
    => true
  
    ** Additionally, paths track the direction in which a relationship is traversed.
    Two paths that traverse the same nodes and relationships in the same order but differ in the direction in which they traverse a single relationship are not equal (this can happen in paths containing self-loops).
    The comparison order for paths is expected to align with this.
    ** Paths are <<incomparable>> to any value that is not also a path.
  - Implementation-specific types
  
negative.code: 
  == Proposal
  
  We propose to redefine <<comparability-def>> and <<equality-def>>, as well as <<orderability-def>> and <<equivalence-def>> as detailed in this section, and additionally rephrase <<aggregation,aggregation>> in terms of these new concepts.
  
  [[concepts]]
  === Concepts
  