Update usages of deprecated CS predicate overloads

Author: koperagen

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt

@@ -16,7 +16,10 @@ internal fun AnyCol.isSuitableForCorr() = isSubtypeOf<Number>() || type() == typ
 
 public data class Corr<T, C>(internal val df: DataFrame<T>, internal val columns: ColumnsSelector<T, C>)
 
-public fun <T> DataFrame<T>.corr(): DataFrame<T> = corr { colsAtAnyDepth { it.isSuitableForCorr() } }.withItself()
+public fun <T> DataFrame<T>.corr(): DataFrame<T> =
+    corr {
+        colsAtAnyDepth().filter { it.isSuitableForCorr() }
+    }.withItself()
 
 public fun <T, C> DataFrame<T>.corr(columns: ColumnsSelector<T, C>): Corr<T, C> = Corr(this, columns)
 

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt

@@ -159,7 +159,7 @@ public fun <T> DataFrame<T>.cumSum(
 public fun <T> DataFrame<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> =
     cumSum(skipNA) {
         // TODO keep at any depth?
-        colsAtAnyDepth { it.isNumber() }.cast()
+        colsAtAnyDepth().filter { it.isNumber() }.cast()
     }
 
 // endregion
@@ -216,7 +216,7 @@ public fun <T, G> GroupBy<T, G>.cumSum(
 public fun <T, G> GroupBy<T, G>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> =
     cumSum(skipNA) {
         // TODO keep at any depth?
-        colsAtAnyDepth { it.isNumber() }.cast()
+        colsAtAnyDepth().filter { it.isNumber() }.cast()
     }
 
 // endregion

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt

@@ -120,7 +120,7 @@ public fun <T> DataColumn<T>.describe(): DataFrame<ColumnDescription> = describe
  */
 public fun <T> DataFrame<T>.describe(): DataFrame<ColumnDescription> =
     describe {
-        colsAtAnyDepth { !it.isColumnGroup() }
+        colsAtAnyDepth().filter { !it.isColumnGroup() }
     }
 
 /**

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt

@@ -13,7 +13,9 @@ import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.api.explodeImpl
 import kotlin.reflect.KProperty
 
-private val defaultExplodeColumns: ColumnsSelector<*, *> = { colsAtAnyDepth { it.isList() || it.isFrameColumn() } }
+private val defaultExplodeColumns: ColumnsSelector<*, *> = {
+    colsAtAnyDepth().filter { it.isList() || it.isFrameColumn() }
+}
 
 // region explode DataFrame
 @Refine

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt

@@ -21,7 +21,10 @@ public fun AnyCol.inferType(): DataColumn<*> =
 
 // region DataFrame
 
-public fun <T> DataFrame<T>.inferType(): DataFrame<T> = inferType { colsAtAnyDepth { !it.isColumnGroup() } }
+public fun <T> DataFrame<T>.inferType(): DataFrame<T> =
+    inferType {
+        colsAtAnyDepth().filter { !it.isColumnGroup() }
+    }
 
 public fun <T> DataFrame<T>.inferType(columns: ColumnsSelector<T, *>): DataFrame<T> =
     replace(columns).with { it.inferType() }

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/parse.kt

@@ -214,7 +214,7 @@ public fun DataColumn<String?>.tryParse(options: ParserOptions? = null): DataCol
 
 public fun <T> DataFrame<T>.parse(options: ParserOptions? = null): DataFrame<T> =
     parse(options) {
-        colsAtAnyDepth { !it.isColumnGroup() }
+        colsAtAnyDepth().filter { !it.isColumnGroup() }
     }
 
 /**

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt

@@ -36,7 +36,7 @@ public fun <T, C> DataFrame<T>.replace(vararg columns: KProperty<C>): ReplaceCla
 
 public fun <T> DataFrame<T>.replaceAll(
     vararg valuePairs: Pair<Any?, Any?>,
-    columns: ColumnsSelector<T, *> = { colsAtAnyDepth { !it.isColumnGroup() } },
+    columns: ColumnsSelector<T, *> = { colsAtAnyDepth().filter { !it.isColumnGroup() } },
 ): DataFrame<T> {
     val map = valuePairs.toMap()
     return update(columns).with { map[it] ?: it }

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/xs.kt

@@ -12,7 +12,7 @@ import org.jetbrains.kotlinx.dataframe.impl.api.xsImpl
 @Interpretable("DataFrameXs")
 public fun <T> DataFrame<T>.xs(vararg keyValues: Any?): DataFrame<T> =
     xs(*keyValues) {
-        colsAtAnyDepth { !it.isColumnGroup() }.take(keyValues.size)
+        colsAtAnyDepth().filter { !it.isColumnGroup() }.take(keyValues.size)
     }
 
 @Refine
@@ -28,7 +28,7 @@ public fun <T, C> DataFrame<T>.xs(vararg keyValues: C, keyColumns: ColumnsSelect
 @Interpretable("GroupByXs")
 public fun <T, G> GroupBy<T, G>.xs(vararg keyValues: Any?): GroupBy<T, G> =
     xs(*keyValues) {
-        colsAtAnyDepth { !it.isColumnGroup() }.take(keyValues.size)
+        colsAtAnyDepth().filter { !it.isColumnGroup() }.take(keyValues.size)
     }
 
 @Refine

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/GroupByImpl.kt

@@ -107,7 +107,9 @@ internal fun <T, G, R> aggregateGroupBy(
 
     if (!removeColumns) removedNode.data.wasRemoved = false
 
-    val columnsToInsert = groupedFrame.getColumnsWithPaths { colsAtAnyDepth { !it.isColumnGroup() } }.map {
+    val columnsToInsert = groupedFrame.getColumnsWithPaths {
+        colsAtAnyDepth().filter { !it.isColumnGroup() }
+    }.map {
         ColumnToInsert(insertPath + it.path, it, removedNode)
     }
     val src = if (removeColumns) removed.df else df

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/join.kt

@@ -112,7 +112,7 @@ internal fun <A, B> DataFrame<A>.joinImpl(
 
     // group row indices by key from right data frame
     val groupedRight = when (joinType) {
-        JoinType.Exclude -> rightJoinKeyToIndex.associate { it.first to emptyList<Int>() }
+        JoinType.Exclude -> rightJoinKeyToIndex.associate { it.first to emptyList() }
         else -> rightJoinKeyToIndex.groupBy({ it.first }) { it.second }
     }
 
@@ -145,14 +145,14 @@ internal fun <A, B> DataFrame<A>.joinImpl(
         outputRowsCount += rightUnmatchedCount
     }
 
-    val leftColumns = getColumnsWithPaths { colsAtAnyDepth { !it.isColumnGroup() } }
+    val leftColumns = getColumnsWithPaths { colsAtAnyDepth().filter { !it.isColumnGroup() } }
 
     val rightJoinColumnPaths = allRightJoinColumns.associate { it.path to it.data }
 
     val newRightColumns =
         if (addNewColumns) {
             other.getColumnsWithPaths {
-                colsAtAnyDepth {
+                colsAtAnyDepth().filter {
                     !it.isColumnGroup() && !rightJoinColumnPaths.contains(it.path)
                 }
             }

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/parse.kt

@@ -681,7 +681,7 @@ internal fun <T> DataFrame<T>.parseImpl(options: ParserOptions?, columns: Column
             col.isFrameColumn() -> {
                 col.map {
                     it.parseImpl(options) {
-                        colsAtAnyDepth { !it.isColumnGroup() }
+                        colsAtAnyDepth().filter { !it.isColumnGroup() }
                     }
                 }
             }

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/html.kt

@@ -283,7 +283,7 @@ public fun AnyFrame.toStaticHtml(
     val id = "static_df_${nextTableId()}"
 
     // Retrieve all columns, including nested ones
-    val flattenedCols = getColumnsWithPaths { colsAtAnyDepth { !it.isColumnGroup() } }
+    val flattenedCols = getColumnsWithPaths { colsAtAnyDepth().filter { !it.isColumnGroup() } }
 
     // Get a grid of columns for the header, as well as the side borders for each cell
     val colGrid = getColumnsHeaderGrid()

core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/allExcept.kt

@@ -149,8 +149,8 @@ class AllExceptTests : ColumnsSelectionDslTests() {
 
         listOf(
             df.select { name.firstName },
-            df.select { name.allCols() except { colsAtAnyDepth { "last" in it.name } } },
-            df.select { name.allCols() except colsAtAnyDepth { "last" in it.name } },
+            df.select { name.allCols() except { colsAtAnyDepth().filter { "last" in it.name } } },
+            df.select { name.allCols() except colsAtAnyDepth().filter { "last" in it.name } },
             df.select { name.allCols() except { name.lastName } },
             df.select { name.allCols() except name.lastName },
             df.select { name.allCols() except { colGroup("name").col("lastName") } },

core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colsAtAnyDepth.kt

@@ -55,21 +55,21 @@ class AtAnyDepth : TestBase() {
             dfGroup.select { name.firstName.firstName },
             dfGroup.select { first { col -> col.any { it == "Alice" } }.atAnyDepthImpl() },
             dfGroup.select { colsAtAnyDepth().first { col -> col.any { it == "Alice" } } },
-            dfGroup.select { colsAtAnyDepth { col -> col.any { it == "Alice" } }.first() },
+            dfGroup.select { colsAtAnyDepth().filter { col -> col.any { it == "Alice" } }.first() },
             dfGroup.select { colsAtAnyDepth().last { col -> col.any { it == "Alice" } } },
-            dfGroup.select { colsAtAnyDepth { col -> col.any { it == "Alice" } }.last() },
-            dfGroup.select { colsAtAnyDepth().single { col -> col.any { it == "Alice" } } },
-            dfGroup.select { colsAtAnyDepth { col -> col.any { it == "Alice" } }.single() },
+            dfGroup.select { colsAtAnyDepth().filter { col -> col.any { it == "Alice" } }.last() },
+            dfGroup.select { colsAtAnyDepth().filter { col -> col.any { it == "Alice" } }.single() },
+            dfGroup.select { colsAtAnyDepth().filter { col -> col.any { it == "Alice" } }.single() },
         ).shouldAllBeEqual()
 
         listOf(
             dfGroup.select { city },
             dfGroup.select { colsAtAnyDepth().first { col -> col.any { it == "London" } } },
-            dfGroup.select { colsAtAnyDepth { col -> col.any { it == "London" } }.first() },
+            dfGroup.select { colsAtAnyDepth().filter { col -> col.any { it == "London" } }.first() },
             dfGroup.select { colsAtAnyDepth().last { col -> col.any { it == "London" } } },
-            dfGroup.select { colsAtAnyDepth { col -> col.any { it == "London" } }.last() },
-            dfGroup.select { colsAtAnyDepth().single { col -> col.any { it == "London" } } },
-            dfGroup.select { colsAtAnyDepth { col -> col.any { it == "London" } }.single() },
+            dfGroup.select { colsAtAnyDepth().filter { col -> col.any { it == "London" } }.last() },
+            dfGroup.select { colsAtAnyDepth().filter { col -> col.any { it == "London" } }.single() },
+            dfGroup.select { colsAtAnyDepth().filter { col -> col.any { it == "London" } }.single() },
         ).shouldAllBeEqual()
     }
 
@@ -78,7 +78,7 @@ class AtAnyDepth : TestBase() {
         listOf(
             df.select { name },
             df.select { colsAtAnyDepth().colGroups() },
-            df.select { colsAtAnyDepth { it.kind == Group } },
+            df.select { colsAtAnyDepth().filter { it.kind == Group } },
             df.select { colGroups() },
             df.select { all().colGroups() },
             df.select { all().colsAtAnyDepth().colGroups() },
@@ -111,15 +111,15 @@ class AtAnyDepth : TestBase() {
     fun `all allAtAnyDepth`() {
         dfGroup.getColumnsWithPaths { all().colsAtAnyDepth().all() }.sortedBy { it.name } shouldBe atAnyDepthGoal
         dfGroup
-            .getColumnsWithPaths { all().colsAtAnyDepth { !it.isColumnGroup() } }
+            .getColumnsWithPaths { all().colsAtAnyDepth().filter { !it.isColumnGroup() } }
             .sortedBy { it.name } shouldBe atAnyDepthNoGroups
     }
 
     @Test
     fun `cols allAtAnyDepth`() {
         dfGroup.getColumnsWithPaths { cols().colsAtAnyDepth().all() }.sortedBy { it.name } shouldBe atAnyDepthGoal
         dfGroup
-            .getColumnsWithPaths { cols().colsAtAnyDepth { !it.isColumnGroup() } }
+            .getColumnsWithPaths { cols().colsAtAnyDepth().filter { !it.isColumnGroup() } }
             .sortedBy { it.name } shouldBe atAnyDepthNoGroups
     }
 

core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt

@@ -30,15 +30,15 @@ class MoveTests {
     @Test
     fun `select all atAnyDepth`() {
         val selected = grouped
-            .getColumnsWithPaths { colGroups().colsAtAnyDepth { !it.isColumnGroup() } }
+            .getColumnsWithPaths { colGroups().colsAtAnyDepth().filter { !it.isColumnGroup() } }
             .map { it.path.joinToString(".") }
         selected shouldBe listOf("a.b", "a.c.d", "b.c", "b.d", "e.f")
     }
 
     @Test
     fun `batch ungrouping`() {
         val ungrouped = grouped.move {
-            colsAtAnyDepth { it.depth() > 0 && !it.isColumnGroup() }
+            colsAtAnyDepth().filter { it.depth() > 0 && !it.isColumnGroup() }
         }.into { pathOf(it.path.joinToString(".")) }
         ungrouped.columnNames() shouldBe listOf("q", "a.b", "a.c.d", "b.c", "b.d", "w", "e.f", "r")
     }
@@ -114,7 +114,7 @@ class MoveTests {
 
     @Test
     fun `move after with column selector`() {
-        val df = grouped.move { colsAtAnyDepth { it.name == "r" || it.name == "w" } }
+        val df = grouped.move { colsAtAnyDepth().filter { it.name == "r" || it.name == "w" } }
             .after { "a"["c"]["d"] }
         df.columnNames() shouldBe listOf("q", "a", "b", "e")
         df["a"]["c"].asColumnGroup().columnNames() shouldBe listOf("d", "w", "r")

core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt

@@ -43,7 +43,7 @@ class PivotTests {
         }
         pivoted.columnsCount() shouldBe 3
         pivoted.rowsCount() shouldBe 2
-        val cols = pivoted.getColumns { allExcept(a).colsAtAnyDepth { !it.isColumnGroup() } }
+        val cols = pivoted.getColumns { allExcept(a).colsAtAnyDepth().filter { !it.isColumnGroup() } }
         cols.size shouldBe 4
         cols.forEach {
             it.type() shouldBe typeOf<Char>()

core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/single.kt

@@ -19,10 +19,10 @@ class SingleTests : ColumnsSelectionDslTests() {
             df.select { Person::age.singleCol() }
         }
         shouldThrow<NoSuchElementException> {
-            df.select { single { false } }
+            df.select { cols().filter { false }.single() }
         }
         shouldThrow<IllegalArgumentException> {
-            df.select { single { true } }
+            df.select { cols().filter { true }.single() }
         }
 
         val singleDf = df.select { take(1) }
@@ -32,12 +32,12 @@ class SingleTests : ColumnsSelectionDslTests() {
             singleDf.select { name },
             singleDf.select { single() },
             singleDf.select { all().single() },
-            df.select { single { it.name().startsWith("n") } },
+            df.select { cols().filter { it.name().startsWith("n") }.single() },
         ).shouldAllBeEqual()
 
         listOf(
             df.select { name.firstName },
-            df.select { name.colsOf<String>().single { col -> col.any { it == "Alice" } } },
+            df.select { name.colsOf<String>().filter { col -> col.any { it == "Alice" } }.single() },
             df.select { name.singleCol { col -> col.any { it == "Alice" } } },
             df.select { "name".singleCol { col -> col.any { it == "Alice" } } },
             df.select { Person::name.singleCol { col -> col.any { it == "Alice" } } },

core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/PlaylistJsonTest.kt

@@ -138,7 +138,7 @@ class PlaylistJsonTest {
     @Test
     fun `deep batch update all`() {
         val updated = item
-            .convert { colsAtAnyDepth { it.name() == "url" } }
+            .convert { colsAtAnyDepth().filter { it.name() == "url" } }
             .with { (it as? String)?.let { IMG(it) } }
         updated.snippet.thumbnails.default.url.type() shouldBe typeOf<IMG>()
         updated.snippet.thumbnails.maxres.url.type() shouldBe typeOf<IMG?>()

core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Access.kt

@@ -959,13 +959,13 @@ class Access : TestBase() {
         }
 
         // traversal of columns at any depth from here excluding ColumnGroups
-        df.select { colsAtAnyDepth { !it.isColumnGroup() } }
+        df.select { colsAtAnyDepth().filter { !it.isColumnGroup() } }
 
         // traversal of columns at any depth from here including ColumnGroups
         df.select { colsAtAnyDepth() }
 
         // traversal of columns at any depth with condition
-        df.select { colsAtAnyDepth { it.name().contains(":") } }
+        df.select { colsAtAnyDepth().filter { it.name().contains(":") } }
 
         // traversal of columns at any depth to find columns of given type
         df.select { colsAtAnyDepth().colsOf<String>() }
@@ -983,18 +983,18 @@ class Access : TestBase() {
     fun columnSelectorsModifySet() {
         // SampleStart
         // first/last n value- and frame columns in column set
-        df.select { colsAtAnyDepth { !it.isColumnGroup() }.take(3) }
-        df.select { colsAtAnyDepth { !it.isColumnGroup() }.takeLast(3) }
+        df.select { colsAtAnyDepth().filter { !it.isColumnGroup() }.take(3) }
+        df.select { colsAtAnyDepth().filter { !it.isColumnGroup() }.takeLast(3) }
 
         // all except first/last n value- and frame columns in column set
-        df.select { colsAtAnyDepth { !it.isColumnGroup() }.drop(3) }
-        df.select { colsAtAnyDepth { !it.isColumnGroup() }.dropLast(3) }
+        df.select { colsAtAnyDepth().filter { !it.isColumnGroup() }.drop(3) }
+        df.select { colsAtAnyDepth().filter { !it.isColumnGroup() }.dropLast(3) }
 
         // filter column set by condition
-        df.select { colsAtAnyDepth { !it.isColumnGroup() }.filter { it.name().startsWith("year") } }
+        df.select { colsAtAnyDepth().filter { !it.isColumnGroup() }.filter { it.name().startsWith("year") } }
 
         // exclude columns from column set
-        df.select { colsAtAnyDepth { !it.isColumnGroup() }.except { age } }
+        df.select { colsAtAnyDepth().filter { !it.isColumnGroup() }.except { age } }
 
         // keep only unique columns
         df.select { (colsOf<Int>() and age).distinct() }

core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTests.kt

@@ -932,7 +932,7 @@ class DataFrameTests : BaseTest() {
         df["e"].kind() shouldBe ColumnKind.Group
         df.getColumnGroup("d").columnNames() shouldBe listOf("f")
         df.getColumnGroup("e").getColumnGroup("g").columnNames() shouldBe listOf("h")
-        val cols = df.getColumns { colsAtAnyDepth { !it.isColumnGroup() } }
+        val cols = df.getColumns { colsAtAnyDepth().filter { !it.isColumnGroup() } }
         cols.size shouldBe 5
         cols.forEach {
             it.toList() shouldBe expected

core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTreeTests.kt

@@ -288,7 +288,7 @@ class DataFrameTreeTests : BaseTest() {
 
     @Test
     fun `select atAnyDepth`() {
-        val cols = typed2.select { colsAtAnyDepth { it.hasNulls } }
+        val cols = typed2.select { colsAtAnyDepth().filter { it.hasNulls } }
         cols shouldBe typed2.select { nameAndCity.city and weight }
     }
 
@@ -535,14 +535,16 @@ class DataFrameTreeTests : BaseTest() {
 
     @Test
     fun parentColumnTest() {
-        val res = typed2.move { colsAtAnyDepth { it.depth > 0 } }.toTop { it.parentName + "-" + it.name }
+        val res = typed2.move { colsAtAnyDepth().filter { it.depth > 0 } }.toTop { it.parentName + "-" + it.name }
         res.columnsCount() shouldBe 4
         res.columnNames() shouldBe listOf("nameAndCity-name", "nameAndCity-city", "age", "weight")
     }
 
     @Test
     fun `group cols`() {
-        val joined = typed2.move { colsAtAnyDepth { !it.isColumnGroup() } }.into { pathOf(it.path.joinToString(".")) }
+        val joined = typed2.move {
+            colsAtAnyDepth().filter { !it.isColumnGroup() }
+        }.into { pathOf(it.path.joinToString(".")) }
         val grouped = joined.group { nameContains(".") }.into { it.name().substringBefore(".") }
         val expected = typed2.rename { nameAndCity.allCols() }.into { it.path.joinToString(".") }
         grouped shouldBe expected

core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/PivotTests.kt

@@ -283,7 +283,7 @@ class PivotTests {
         val leafColumns = pivoted.getColumnsWithPaths {
             all()
                 .drop(1)
-                .colsAtAnyDepth { !it.isColumnGroup() }
+                .colsAtAnyDepth().filter { !it.isColumnGroup() }
         }
         leafColumns.size shouldBe typed.name.countDistinct() * typed.key.countDistinct() - 1
         leafColumns.forEach { it.path.size shouldBe 2 }
@@ -344,7 +344,7 @@ class PivotTests {
 //        nullGroup.columnTypes() shouldBe listOf(typeOf<Comparable<*>?>(), typeOf<KClass<Any>?>())
         nullGroup.columnTypes() shouldBe listOf(nothingType(true), nothingType(true))
 
-        val cols = pivotedDf.getColumnsWithPaths { colsAtAnyDepth { !it.isColumnGroup() } }
+        val cols = pivotedDf.getColumnsWithPaths { colsAtAnyDepth().filter { !it.isColumnGroup() } }
         cols.size shouldBe 2 * typed.name.countDistinct() * typed.key.countDistinct() - 2
 
         cols.forEach {

examples/idea-examples/titanic/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/titanic/ml/titanic.kt

@@ -82,7 +82,7 @@ private fun <T> OnHeapDataset.Companion.create(
 
     fun extractX(): Array<FloatArray> =
         dataframe.remove(yColumn)
-            .convert { colsAtAnyDepth { !it.isColumnGroup() } }.toFloat()
+            .convert { colsAtAnyDepth().filter { !it.isColumnGroup() } }.toFloat()
             .merge { colsAtAnyDepth().colsOf<Float>() }.by { it.toFloatArray() }.into("X")
             .getColumn("X").cast<FloatArray>().toTypedArray()