anchor.diff:          
           set.Choose chooser
   
  -    /// Applies the given function to each binding in the set.
  -    [<CompiledName("Iterate")>]
  -    let inline iter (action : 'T -> unit) (set : HashSet<'T>) : unit =
  -        // Preconditions
  -        checkNonNull "set" set
  -        
  -        set.Iterate action
  -
  -    /// Applies the given function to each binding in the set.
  -    [<CompiledName("IterateBack")>]
  -    let inline iterBack (action : 'T -> unit) (set : HashSet<'T>) : unit =
  -        // Preconditions
  -        checkNonNull "set" set
  -
  -        set.IterateBack action
  -
  -    /// Folds over the bindings in the set.
  -    [<CompiledName("Fold")>]
  -    let inline fold (folder : 'State -> 'T -> 'State) (state : 'State) (set : HashSet<'T>) : 'State =
  -        // Preconditions
  -        checkNonNull "set" set
  -        
  -        set.Fold (folder, state)
  -
  -    /// Folds over the bindings in the set.
  -    [<CompiledName("FoldBack")>]
  -    let inline foldBack (folder : 'T -> 'State -> 'State) (set : HashSet<'T>) (state : 'State) : 'State =
  -        // Preconditions
  -        checkNonNull "set" set
  -
  -        set.FoldBack (folder, state)
  -
  -    /// Determines if any binding in the set matches the specified predicate.
  -    [<CompiledName("Exists")>]
  -    let inline exists (predicate : 'T -> bool) (set : HashSet<'T>) : bool =
  -        // Preconditions
  -        checkNonNull "set" set
  -        
  -        set.Exists predicate
  -
  -    /// Determines if all bindings in the set match the specified predicate.
  -    [<CompiledName("Forall")>]
  -    let inline forall (predicate : 'T -> bool) (set : HashSet<'T>) : bool =
  -        // Preconditions
  -        checkNonNull "set" set
  -
  -        set.Forall predicate
  +    /// <summary>
  +    /// Builds a new set containing only the bindings for which the given
  +    /// predicate returns &quot;true&quot;.
  +    /// </summary>
  +    [<CompiledName("Filter")>]
  +    let inline filter (predicate : 'T -> bool) (set : HashSet<'T>) : HashSet<'T> =
  +        // Preconditions
  +        checkNonNull "set" set
  +        
  +        set.Filter predicate
  +
  +    /// Builds a new collection whose elements are the results of applying the given function
  +    /// to each of the elements of the collection. The key passed to the function indicates
  +    /// the key of the element being transformed.
  +    [<CompiledName("Map")>]
  +    let inline map (mapping : 'T -> 'U) (set : HashSet<'T>) : HashSet<'U> =
  +        // Preconditions
  +        checkNonNull "set" set
  +        
  +        set.Map mapping
   
       /// Splits the set into two sets containing the bindings for which the given
       /// predicate returns true and false, respectively.
  
positive.code:     let inline singleton (value : 'T) : HashSet<'T> =
          HashSet.Singleton value
  
      /// Tests if an element is in the domain of the set.
      [<CompiledName("ContainsKey")>]
      let inline contains (value : 'T) (set : HashSet<'T>) : bool =
          // Preconditions
          checkNonNull "set" set
  
          set.Contains value
  
      /// Returns the key of the first element in the collection which satisfies the given
      /// predicate. Returns None if no such element is found.
      [<CompiledName("TryFind")>]
      let inline tryFind (predicate : 'T -> bool) (set : HashSet<'T>) : 'T option =
          // Preconditions
          checkNonNull "set" set
          
          set.TryFind predicate
  
      //
      [<CompiledName("Find")>]
      let inline find (predicate : 'T -> bool) (set : HashSet<'T>) : 'T =
          // Preconditions
          checkNonNull "set" set
  
          set.Find predicate
  
      /// Returns a new set with the binding added to this set.
      [<CompiledName("Add")>]
      let inline add (value : 'T) (set : HashSet<'T>) : HashSet<'T> =
  
negative.code:         checkNonNull "set" set
  
          set.MapPartition partitioner
  