anchor.diff:          elif otherSet.Trie === trie' then otherSet
           else IntSet (trie')
   
  +    /// Computes the union of a sequence of IntSets.
  +    static member internal UnionMany (sets : seq<IntSet>) : IntSet =
  +        // Preconditions
  +        checkNonNull "sets" sets
  +
  +        let combinedTrie =
  +            (PatriciaSet.Empty, sets)
  +            ||> Seq.fold (fun combinedSetTree set ->
  +                PatriciaSet.Union (combinedSetTree, set.Trie))
  +
  +        IntSet (combinedTrie)
  +
  +    /// Computes the intersection of a sequence of IntSets.
  +    static member internal IntersectMany (sets : seq<IntSet>) : IntSet =
  +        // Preconditions
  +        checkNonNull "sets" sets
  +
  +        Seq.reduce (fun s1 s2 -> s1.Intersect s2) sets
  +
       /// Determines if the given set is a subset of this set.
       member this.IsSubset (otherSet : IntSet) : bool =
           PatriciaSet.IsSubset (otherSet.Trie, trie)
  
positive.code:         checkNonNull "set2" set2
  
          set1.Intersect set2
          |> retype
  
      /// Returns a new set with the elements of the second set removed from the first.
  
negative.code:         set1.Union set2
          |> retype
  
      /// Computes the union of a sequence of sets.
      [<CompiledName("UnionMany")>]
      let unionMany (sets : seq<TagSet<'Tag>>) : TagSet<'Tag> =
          // Retype as seq<IntSet>
          let sets : seq<IntSet> = retype sets
  
          // Preconditions checked by the target method.
          IntSet.UnionMany sets
          |> retype
  
      /// Computes the intersection of the two sets.
      [<CompiledName("Intersect")>]
      let inline intersect (set1 : TagSet<'Tag>) (set2 : TagSet<'Tag>) : TagSet<'Tag> =
  