anchor.diff:  a1 = b1 && a2 = b2 && ...
   ----
   
  +===== Map equality =====
  +
  +====== Current map equality ======
   For clarity, we also repeat the *current* equality semantics of maps here. Under these current semantics, two maps `m1` and `m2` are considered 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).
  +** 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`,
   ** either `m1.k = m2.k` is `true`,
   ** or both `m1.k IS NULL` and `m2.k IS NULL`
  
positive.code: A string compared to a boolean
  [source, cypher]
  ----
  RETURN 'string' \<= true // should be null
  ----
  
  Ordering values of different types
  
negative.code: 
  This proposal could be extended with an operator for making equivalence accessible beyond use in grouping and `DISTINCT`. This seems desirable due to the equality operator (`=`) not being reflexive for all values.
  
  This CIP introduces the distinction between "unknown" and "missing" `null` values. A future proposal could investigate making this explicit through the introduction of different kinds of `null` values. If such a change would be adopted and <<unknown-null,unknown `null` values>> would track their source, equality could become reflexive again as it would become possible to know if two `null` values represent the same "unknown" value. However, this would not remove the need to distinguish between equality and equivalence as grouping would still require `missing = unknown => true` while in general `missing = unknown => missing`.
  
  == Benefits to this proposal
  
  