anchor.diff: -= CIP2016-06-14 - Redefine Comparability and Equality, as well as Orderability and Equivalence
  += CIP2016-06-14 - Define Comparability and Equality, as well as Orderability and Equivalence
   :numbered:
   :toc:
   :toc-placement: macro
  
positive.code: ** either `m1.k = m2.k` is `true`,
  ** or both `m1.k IS NULL` and `m2.k IS NULL`
  
  This is at odds with the decision to use <<unknown-null,"unknown" `null` values>> in <<comparability-equality>>.
  
  However, this definition is aligned with the most common use case for maps with `null` entries: updating multiple properties through the use of a single `SET` clause, e.g. `SET n += { size: 12, remove_this_key: null }`. In this case, there is no need to differentiate between different `null` values, as `null` merely serves as a marker for keys to be removed (i.e. is a <<missing-null,"missing" `null` value>>). Current equality semantics make it easy to check if two maps would correspond to the same property update in this scenario. We note though that 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:
  
  * `expr1 = expr2` evaluates to `null` if `expr1 IS null && expr2 IS NULL`
  * `{a: expr1} = {a: expr2}` evaluates to `true` if `expr1 IS null && expr2 IS NULL`
  
  ====== New map equality ======
  
  
negative.code:   * Integers are compared numerically in ascending order.
    * Floats (excluding `NaN` and the Infinities) are compared numerically in ascending order.
    * Numbers of different types (excluding `NaN` and the Infinities) are compared to each other as if both numbers would have been coerced to arbitrary precision big decimals (currently outside the Cypher type system) before comparing them with each other numerically in ascending order.
    * Positive infinity is of type `FLOAT`, equal to itself and greater than any other number (excluding `NaN`).
    * Negative infinity is of type `FLOAT`, equal to itself and less than any other number (excluding `NaN`).
    * `NaN` is <<incomparable>>.
    * Numbers are <<incomparable>> to any value that is not also a number.
  - Booleans
  