anchor.diff:  
       /// Builds a new collection from the given enumerable object.
       [<CompiledName("OfSeq")>]
  -    let (*inline*) ofSeq source : TagSet<'Tag> =
  +    let (*inline*) ofSeq (source : seq<int<'Tag>>) : TagSet<'Tag> =
           // Preconditions are checked by the member.
  -        IntSet.OfSeq source
  +        IntSet.OfSeq (retype source)
           |> retype
   
       /// Builds a set that contains the same elements as the given list.
       [<CompiledName("OfList")>]
  -    let (*inline*) ofList source : TagSet<'Tag> =
  +    let (*inline*) ofList (source : int<'Tag> list) : TagSet<'Tag> =
           // Preconditions are checked by the member.
  -        IntSet.OfList source
  +        IntSet.OfList (retype source)
           |> retype
   
       /// Builds a set that contains the same elements as the given array.
       [<CompiledName("OfArray")>]
  -    let (*inline*) ofArray source : TagSet<'Tag> =
  +    let (*inline*) ofArray (source : int<'Tag>[]) : TagSet<'Tag> =
           // Preconditions are checked by the member.
  -        IntSet.OfArray source
  -        |> retype
  -
  -    /// Builds an IntSet that contains the same elements as the given Set.
  +        IntSet.OfArray (retype source)
  +        |> retype
  +
  +    /// Builds an set that contains the same elements as the given Set.
       [<CompiledName("OfSet")>]
  -    let (*inline*) ofSet source : TagSet<'Tag> =
  +    let (*inline*) ofSet (source : Set<int<'Tag>>) : TagSet<'Tag> =
           // Preconditions are checked by the member.
  -        IntSet.OfSet source
  +        IntSet.OfSet (retype source)
           |> retype
   
       /// Returns an ordered view of the collection as an enumerable object.
  
positive.code:         checkNonNull "set" set
  
          set.ToSet ()
  
      /// Applies the given function to each element of the set,
      /// in order according to the comparison function.
  
negative.code:         checkNonNull "set" set
  
          set.ToArray ()
          |> retype
  
      /// Builds a Set that contains the same elements as the given TagSet.
      [<CompiledName("ToSet")>]
      let inline toSet (set : TagSet<'Tag>) : Set<int<'Tag>> =
          // Retype as IntSet
          let set : IntSet = retype set
  
  