anchor.diff:      //            res <- combineHash res (hash x)
       //      abs res
   
  -    override this.GetHashCode() = 0 //this.ComputeHashCode()
  -
  -    override this.Equals(that) = false
  +    override __.GetHashCode() = 0 //this.ComputeHashCode()
  +
  +    override __.Equals(_) = false
       //      match that with
       //      | :? Set<'T> as that ->
       //            use e1 = (this :> seq<_>).GetEnumerator()
  
positive.code: open System.Collections
  open System.Collections.Generic
  
  type GenericComparer<'T>() =
      interface IComparer<'T> with
          member __.Compare(x, y) = 0 // TODO
  
  (* A classic functional language implementation of binary trees *)
  
  
negative.code:     type mkIEnumerator<'a when 'a : comparison>(s) =
          let i = ref (mkIterator s)
          interface IEnumerator<'a> with
              member __.Current = current !i
          interface IEnumerator with
              member __.Current = box (current !i)
              member __.MoveNext() = moveNext !i
              member __.Reset() = i :=  mkIterator s
          interface System.IDisposable with
              member __.Dispose() = ()
  
      let mkIEnumerator s =
          new mkIEnumerator<_>(s) :> IEnumerator<_>
  