anchor.diff:          
           set.Partition predicate
   
  +    /// 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
  +
  +    /// 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
  +
  +    /// Searches the set looking for the first element where the given function
  +    /// returns a Some value. If no such element is found, returns None.
  +    [<CompiledName("TryPick")>]
  +    let inline tryPick (picker : 'T -> 'U option) (set : HashSet<'T>) : 'U option =
  +        // Preconditions
  +        checkNonNull "set" set
  +        
  +        set.TryPick picker
  +
  +    /// Searches the set looking for the first element where the given function
  +    /// returns a Some value.
  +    [<CompiledName("Pick")>]
  +    let inline pick (picker : 'T -> 'U option) (set : HashSet<'T>) : 'U =
  +        // Preconditions
  +        checkNonNull "set" set
  +
  +        set.Pick picker
  +
       /// Splits the set into two sets by applying the given partitioning function
       /// to each binding in the set.
       [<CompiledName("MapPartition")>]
  
positive.code:         
          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
  
      /// Splits the set into two sets containing the bindings for which the given
      /// predicate returns true and false, respectively.
  
negative.code: 
      /// Computes the union of two PatriciaHashSets.
      static member Union (s, t) : PatriciaHashSet<'T> =
          match s, t with
          | Br (p, m, s0, s1), Br (q, n, t0, t1) ->
              if m = n then
                  if p = q then
                      // The trees have the same prefix. Merge the subtrees.
                      let left = PatriciaHashSet.Union (s0, t0)
                      let right = PatriciaHashSet.Union (s1, t1)
                      Br (p, m, left, right)
                  else
                      // The prefixes disagree.
                      PatriciaHashSet.Join (p, s, q, t)
  
              #if LITTLE_ENDIAN_TRIES
              elif m < n then
              #else
              elif m > n then
              #endif
                  if matchPrefix (q, p, m) then
                      // q contains p. Merge t with a subtree of s.
                      if zeroBit (q, m) then
                          let left = PatriciaHashSet.Union (s0, t)
                          Br (p, m, left, s1)
                      else
                          let right = PatriciaHashSet.Union (s1, t)
                          Br (p, m, s0, right)
                  else
                      // The prefixes disagree.
                      PatriciaHashSet.Join (p, s, q, t)
  
              else
                  if matchPrefix (p, q, n) then
                      // p contains q. Merge s with a subtree of t.
                      if zeroBit (p, n) then
                          let left = PatriciaHashSet.Union (s, t0)
                          Br (q, n, left, t1)
                      else
                          let right = PatriciaHashSet.Union (s, t1)
                          Br (q, n, t0, right)
                  else
                      // The prefixes disagree.
                      PatriciaHashSet.Join (p, s, q, t)
  
          | Br (p, m, s0, s1), Lf (k, _) ->
              if matchPrefix (k, p, m) then
                  if zeroBit (k, m) then
                      let left = PatriciaHashSet.Union (s0, t)
                      Br (p, m, left, s1)
                  else
                      let right = PatriciaHashSet.Union (s1, t)
                      Br (p, m, s0, right)
              else
                  PatriciaHashSet.Join (k, t, p, s)
  
          | Lf (k, _), Br (q, n, t0, t1) ->
              if matchPrefix (k, q, n) then
                  if zeroBit (k, n) then
                      let left = PatriciaHashSet.Union (s, t0)
                      Br (q, n, left, t1)
                  else
                      let right = PatriciaHashSet.Union (s, t1)
                      Br (q, n, t0, right)
              else
                  PatriciaHashSet.Join (k, s, q, t)
  
          | Lf (j, listSet1), Lf (k, listSet2) ->
              if j = k then
                  // Combine the sets into a single set.
                  let listSet = ListSet.union listSet1 listSet2
                  
                  // OPTIMIZE : Try to figure out how we can implement structure-sharing
                  // here (i.e., how can we modify the ListSet functions so they return one of
                  // the original lists if the result is going to be the same anyway).
                  // Without this, the effectiveness of the structure-sharing optimizations
                  // for this data structure is greatly reduced.
                  Lf (j, listSet)
              else
                  PatriciaHashSet.Join (j, s, k, t)
  
          | _, Empty -> s
          | Empty, _ -> t
  
      /// Compute the intersection of two PatriciaHashSets.
      static member Intersect (s, t) : PatriciaHashSet<'T> =
  