anchor.diff:          SetTree.isEmpty s.Tree
   
       member s.Partition f : Set<'T> *  Set<'T> = 
  -        match s.Tree with 
  -        | SetEmpty -> s, s
  -        | _ -> let t1, t2 = SetTree.partition s.Comparer f s.Tree in Set(s.Comparer, t1), Set(s.Comparer, t2)
  +        if SetTree.isEmpty s.Tree then s,s
  +        else
  +            let t1, t2 = SetTree.partition s.Comparer f s.Tree in Set(s.Comparer, t1), Set(s.Comparer, t2)
   
       member s.Filter f : Set<'T> = 
  -        match s.Tree with 
  -        | SetEmpty -> s
  -        | _ -> Set(s.Comparer, SetTree.filter s.Comparer f s.Tree)
  +        if SetTree.isEmpty s.Tree then s
  +        else
  +            Set(s.Comparer, SetTree.filter s.Comparer f s.Tree)
   
       member s.Map f : Set<'U> = 
           let comparer = LanguagePrimitives.FastGenericComparer<'U>
  -        Set(comparer, SetTree.fold (fun acc k -> SetTree.add comparer (f k) acc) (SetTree<_>.SetEmpty) s.Tree)
  +        Set(comparer, SetTree.fold (fun acc k -> SetTree.add comparer (f k) acc) (SetTree.empty) s.Tree)
   
       member s.Exists f =
           SetTree.exists f s.Tree
  
positive.code: 
      let ofSeq comparer (c: IEnumerable<_>) =
          use ie = c.GetEnumerator()
          mkFromEnumerator comparer SetEmpty ie 
  
      let ofArray comparer l =
          Array.fold (fun acc k -> add comparer k acc) SetEmpty l 
  
  [<Sealed>]
  [<CompiledName("FSharpSet`1")>]
  
negative.code: 
  // A functional language implementation of binary trees
  
  [<NoEquality; NoComparison>]
  [<AllowNullLiteral>]
  type internal SetTree<'T>(k: 'T) =
      member _.Key = k
  
  [<NoEquality; NoComparison>]
  [<Sealed>]
  [<AllowNullLiteral>]
  type internal SetTreeNode<'T>(v:'T, left:SetTree<'T>, right: SetTree<'T>, h: int) =
      inherit SetTree<'T>(v)
  
      member _.Left = left
      member _.Right = right
      member _.Height = h
  
  [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  module internal SetTree = 
      
      let empty = null
      
      let inline isEmpty (t:SetTree<'T>) = isNull t
  
      let rec countAux (t:SetTree<'T>) acc = 
          if isEmpty t then
              acc
          else
              match t with 
              | :? SetTreeNode<'T> as tn -> countAux tn.Left (countAux tn.Right (acc+1))
              | _ -> acc+1
  
      let count s = countAux s 0
  
  