anchor.diff:  
   == Benefits to this proposal
   
  -A consistent set of rules for equality, equivalence, comparability and orderability.
  +A consistent set of rules is defined for equality, equivalence, comparability and orderability.
   
   == Caveats to this proposal
   
  
positive.code: There are currently a number of limitations and inconsistencies that this CIP aims to fix.
  
  (1) Cypher already has good semantics for equality within the primitive types (booleans, strings, integers, and floats) and maps.
  Furthermore, Cypher has good semantics for comparability and orderability for integers, floats, and strings, within the types.
  However working with values of different types can be difficult:
  
    * Comparability between values of different types is often undefined, which is something we regard as a problem for certain combinations of values and types.
    * `ORDER BY` will often fail with an error if the values passed to it have different types.
  
  (2) The underlying conceptual model is complex and sometimes inconsistent which leads to an unclear relationship between comparison operators, equality, grouping, and `ORDER BY`:
  
    * Comparability and orderability are not aligned with each other consistently (Some types may be ordered but not compared).
    * There are various inconsistencies around equality (and equivalence) semantics as exposed by `IN`, `=`, `DISTINCT`, and grouping.
    The difference between equality and equivalence in Cypher today is small and subtle, and limited to testing two instances of the value `null` to each other.
  
      ** 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`.
  
  
negative.code: [abstract]
  .Abstract
  --
  This CIP intends to introduce and formalise two new concepts, *comparability* and *orderability*, and defines their relationship to the pre-existing concepts of *equality* and *equivalence*.
  Comparability revolves around the inequality operators (`>`, `<`, `>=`, `<=`), and defines the semantics they need to properly determine how two values compare to each other.
  Orderability revolves around the `ORDER BY` clause, and defines the semantics it needs to be able to properly sort values passed to it.
  Futhermore, the definitions of *equality* and *equivalence* are harmonized and spelled out.
  