anchor.diff:  class guaranteeing that all keywords with the same namespace and name
   will return the same keyword object.
   
  +[[numbers]]
   == Numbers
   
   Java `equals` is only true for two numbers if the types and numeric
  
positive.code: * When comparing collections with `=`, numbers within the collections
    are also compared with `=`, so the three numeric categories above
    are significant.
  * 'Not a Number' values `Float/NaN` and `Double/NaN` are not `=` or
    `==` to anything, not even themselves.
    _Recommendation:_ Avoid including `NaN` inside of Clojure data
    structures where you want to compare them to each other using `=`,
    and sometimes get `true` as the result.
  * 0.0 is `=` to -0.0
  
negative.code: 
  There is no Java method to determine whether an arbitrary collection
  is mutable or immutable, so it is not possible in Clojure to implement
  the intended behavior of `EGAL`, although one might consider `=` "closer"
  to `EGAL` if it always returned `false` when one of the arguments was
  a non-Clojure collection.
  
  === Lazy and pending values
  
  Baker recommends that `EGAL` force lazy values when comparing them
  (see Section 3. J. "Lazy Values" in the "Equal Rights for Functional Objects" paper).  When comparing a lazy sequence to
  another sequential thing, Clojure's `=` does force the evaluation of
  the lazy sequence, stopping if it reaches a non-`=` sequence element.
  Chunked sequences, e.g. as produced by `range`, can cause evaluation
  