anchor.diff:          | Br (p, m, s0, s1), Lf (k, y) ->
               if matchPrefix (k, p, m) then
                   if zeroBit (k, m) then
  -                    match PatriciaHashSet.Remove (k, s0) with
  +                    match PatriciaHashSet.RemoveSet (k, s0) with
                       | Empty -> s1
                       | left ->
                           Br (p, m, left, s1)
                   else
  -                    match PatriciaHashSet.Remove (k, s1) with
  +                    match PatriciaHashSet.RemoveSet (k, s1) with
                       | Empty -> s0
                       | right ->
                           Br (p, m, s0, right)
  
positive.code:         | Empty, _ -> -1
  *)
  
      //
      static member OfSeq (source : seq<'T>) : PatriciaHashSet<'T> =
          (Empty, source)
  
negative.code:             if trie === trie' then this
              elif otherSet.Trie === trie' then otherSet
              else HashSet (trie')
  
      /// Computes the union of a sequence of IntSets.
      static member internal UnionMany (sets : seq<HashSet<'T>>) : HashSet<'T> =
          // Preconditions
          checkNonNull "sets" sets
  
          let combinedTrie =
              (PatriciaHashSet.Empty, sets)
              ||> Seq.fold (fun combinedSetTree set ->
                  PatriciaHashSet.Union (combinedSetTree, set.Trie))
  
          HashSet (combinedTrie)
  
      /// Computes the intersection of a sequence of IntSets.
      static member internal IntersectMany (sets : seq<HashSet<'T>>) : HashSet<'T> =
          // Preconditions
          checkNonNull "sets" sets
  
          // If the sequence is empty, return an empty set;
          // this also avoids Seq.reduce raising an exception.
          if Seq.isEmpty sets then
              HashSet.Empty
          else
              Seq.reduce (fun s1 s2 -> s1.Intersect s2) sets
  
      /// Determines if set1 is a subset of set2.
      // IsSubsetOf (set1, set2) returns true if all keys in set1 are in set2.
      static member IsSubset (set1 : HashSet<'T>, set2 : HashSet<'T>) : bool =
          PatriciaHashSet.IsSubset (set1.Trie, set2.Trie)
  
      /// Determines if set1 is a proper subset of set2.
      static member IsProperSubset (set1 : HashSet<'T>, set2 : HashSet<'T>) : bool =
          PatriciaHashSet.IsProperSubset (set1.Trie, set2.Trie)
  
      /// The HashSet containing the given binding.
      static member Singleton (value : 'T) : HashSet<'T> =
          let valueHash = uint32 <| hash value
  