anchor.diff:              if trie === trie' then this
               elif otherSet.Trie === trie' then otherSet
               else HashSet (trie')
  -(*
  -    /// Returns true if 'other' is a subset of this set.
  -    member this.IsSubsetOfBy (predicate, other : HashSet<'T>) : bool =
  -        PatriciaHashSet.IsSubsetOfBy predicate other.Trie 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
  
positive.code:         | 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
                      | Empty -> s1
                      | left ->
                          Br (p, m, left, s1)
                  else
                      match PatriciaHashSet.Remove (k, s1) with
                      | Empty -> s0
                      | right ->
                          Br (p, m, s0, right)
  
negative.code:             | Empty -> true
              | _ -> false
  
      /// The first element in the set.
      /// If the element type has suitable hash and comparison functions for the set
      /// to be ordered, then this will be the minimum element of the set.
      [<DebuggerBrowsable(DebuggerBrowsableState.Never)>]
      member __.First
          with get () =
              PatriciaHashSet.First trie
  
      /// The last element in the set.
      /// If the element type has suitable hash and comparison functions for the set
      /// to be ordered, then this will be the maximum element of the set.
      [<DebuggerBrowsable(DebuggerBrowsableState.Never)>]
      member __.Last
          with get () =
              PatriciaHashSet.Last trie
  
      /// Tests if an element is in the domain of the HashSet.
      member __.Contains (value : 'T) : bool =
          let valueHash = uint32 <| hash value
  