Do filter runtime operation based on a term level predicate

Author: EugeneFlesselle

library/src/scala/Tuple.scala

@@ -90,15 +90,10 @@ sealed trait Tuple extends Product:
   inline def reverseOnto[This >: this.type <: Tuple, Acc <: Tuple](acc: Acc): ReverseOnto[This, Acc] =
     (this.reverse ++ acc).asInstanceOf[ReverseOnto[This, Acc]]
 
-  /** A tuple consisting of all elements of this tuple that have types
-   *  for which the given type level predicate `P` reduces to the literal
-   *  constant `true`.
-   */
-  inline def filter[This >: this.type <: Tuple, P[_ <: Union[This]] <: Boolean]: Filter[This, P] =
-    val toInclude = constValueTuple[IndicesWhere[This, P]].toArray
-    val arr = new Array[Object](toInclude.length)
-    for i <- 0 until toInclude.length do
-      arr(i) = this.productElement(toInclude(i).asInstanceOf[Int]).asInstanceOf[Object]
+  /** A tuple consisting of all elements of this tuple that satisfy the predicate `p`. */
+  inline def filter[This >: this.type <: Tuple, P[_ <: Union[This]] <: Boolean]
+                   (p: (x: Union[This]) => P[x.type]): Filter[This, P] =
+    val arr = this.toArray.filter(x => p(x.asInstanceOf[Union[This]]))
     Tuple.fromArray(arr).asInstanceOf[Filter[This, P]]
 
 object Tuple:

tests/pos/named-tuples-strawman-2.scala

@@ -60,7 +60,10 @@ object TupleOps:
     case EmptyTuple => X
 
   inline def concatDistinct[X <: Tuple, Y <: Tuple](xs: X, ys: Y): ConcatDistinct[X, Y] =
-    (xs ++ ys.filter[Y, [Elem] =>> ![Contains[X, Elem]]]).asInstanceOf[ConcatDistinct[X, Y]]
+    // Note the type parameter is needed due to the invariance of compiletime.ops.boolean.!
+    extension [B <: Boolean](self: B) def negated: ![B] = (!self).asInstanceOf
+    val ysDistinct = ys.filter[Y, [y] =>> ![Contains[X, y]]](xs.contains(_).negated)
+    (xs ++ ysDistinct).asInstanceOf[ConcatDistinct[X, Y]]
 
 object NamedTupleDecomposition:
   import NamedTupleOps.*