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