de-duplicate code code

filter and partition is common other than the supplied function

Author: mkeskells

library/src/scala/collection/immutable/RedBlackTree.scala

@@ -975,21 +975,6 @@ private[collection] object NewRedBlackTree {
     blacken(fk(t))
   }
 
-  def filterKeys[A, B](t: Tree[A, B], f: A => Boolean, isFlipped: Boolean): Tree[A, B] = if(t eq null) null else {
-    def fk(t: Tree[A, B]): Tree[A, B] = {
-      val k = t.key
-      val l = t.left
-      val r = t.right
-      val l2 = if(l eq null) null else fk(l)
-      val keep = isFlipped ^ f(k)
-      val r2 = if(r eq null) null else fk(r)
-      if(!keep) join2(l2, r2)
-      else if((l2 eq l) && (r2 eq r)) t
-      else join(l2, k, t.value, r2)
-    }
-    blacken(fk(t))
-  }
-
   def partitionEntries[A, B](t: Tree[A, B], p: (A, B) => Boolean): (Tree[A, B], Tree[A, B]) = if(t eq null) (null, null) else {
     var tmpk, tmpd = null: Tree[A, B] // shared vars to avoid returning tuples from fk
     def fk(t: Tree[A, B]): Unit = {
@@ -1024,40 +1009,6 @@ private[collection] object NewRedBlackTree {
     (blacken(tmpk), blacken(tmpd))
   }
 
-  def partitionKeys[A, B](t: Tree[A, B], p: A => Boolean): (Tree[A, B], Tree[A, B]) = if(t eq null) (null, null) else {
-    var tmpk, tmpd = null: Tree[A, B] // shared vars to avoid returning tuples from fk
-    def fk(t: Tree[A, B]): Unit = {
-      val k = t.key
-      val v = t.value
-      val l = t.left
-      val r = t.right
-      var l2k, l2d, r2k, r2d = null: Tree[A, B]
-      if(l ne null) {
-        fk(l)
-        l2k = tmpk
-        l2d = tmpd
-      }
-      val keep = p(k)
-      if(r ne null) {
-        fk(r)
-        r2k = tmpk
-        r2d = tmpd
-      }
-      val jk =
-        if(!keep) join2(l2k, r2k)
-        else if((l2k eq l) && (r2k eq r)) t
-        else join(l2k, k, v, r2k)
-      val jd =
-        if(keep) join2(l2d, r2d)
-        else if((l2d eq l) && (r2d eq r)) t
-        else join(l2d, k, v, r2d)
-      tmpk = jk
-      tmpd = jd
-    }
-    fk(t)
-    (blacken(tmpk), blacken(tmpd))
-  }
-
 
   // Based on Stefan Kahrs' Haskell version of Okasaki's Red&Black Trees
   // Constructing Red-Black Trees, Ralf Hinze: [[http://www.cs.ox.ac.uk/ralf.hinze/publications/WAAAPL99b.ps.gz]]

library/src/scala/collection/immutable/TreeSet.scala

@@ -292,10 +292,10 @@ final class TreeSet[A] private[immutable] (private[immutable] val tree: RB.Tree[
   }
 
   override private[scala] def filterImpl(f: A => Boolean, isFlipped: Boolean) =
-    newSetOrSelf(RB.filterKeys(tree, f, isFlipped))
+    newSetOrSelf(RB.filterEntries[A, Any](tree, {(k, _) => isFlipped ^ f(k)}))
 
   override def partition(p: A => Boolean): (TreeSet[A], TreeSet[A]) = {
-    val (l, r) = RB.partitionKeys(tree, p)
+    val (l, r) = RB.partitionEntries(tree, {(a:A, _: Any) => p(a)})
     (newSetOrSelf(l), newSetOrSelf(r))
   }