Update usages of deprecated CS predicate overloads

koperagen · koperagen · commit 5887f8b31a47 · 2025-05-06T17:10:14.000+03:00
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt b/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)
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt b/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
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt b/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() }
     }
 
 /**
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt b/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
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt b/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() }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/parse.kt b/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() }
     }
 
 /**
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt b/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 }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/xs.kt b/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
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/GroupByImpl.kt b/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
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/join.kt b/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)
                 }
             }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/parse.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/parse.kt
@@ -680,7 +680,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() }
                     }
                 }
             }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/html.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/html.kt
@@ -277,7 +277,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()
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/allExcept.kt b/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") } },
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colsAtAnyDepth.kt b/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
     }
 
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt b/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")
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt b/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>()
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/single.kt b/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" } } },
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/PlaylistJsonTest.kt b/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?>()
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Access.kt b/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() }
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTests.kt b/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
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTreeTests.kt b/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
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/PivotTests.kt b/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 {
diff --git a/examples/idea-examples/titanic/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/titanic/ml/titanic.kt b/examples/idea-examples/titanic/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/titanic/ml/titanic.kt
@@ -83,7 +83,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).toTypedArray()
 

Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,7 @@ public fun <T> DataColumn<T>.describe(): DataFrame<ColumnDescription> = describe`
`120`	`120`	`*/`
`121`	`121`	`public fun <T> DataFrame<T>.describe(): DataFrame<ColumnDescription> =`
`122`	`122`	`describe {`
`123`		`- colsAtAnyDepth { !it.isColumnGroup() }`
	`123`	`+ colsAtAnyDepth().filter { !it.isColumnGroup() }`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -214,7 +214,7 @@ public fun DataColumn<String?>.tryParse(options: ParserOptions? = null): DataCol`
`214`	`214`
`215`	`215`	`public fun <T> DataFrame<T>.parse(options: ParserOptions? = null): DataFrame<T> =`
`216`	`216`	`parse(options) {`
`217`		`- colsAtAnyDepth { !it.isColumnGroup() }`
	`217`	`+ colsAtAnyDepth().filter { !it.isColumnGroup() }`
`218`	`218`	`}`
`219`	`219`
`220`	`220`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,9 @@ internal fun <T, G, R> aggregateGroupBy(`
`107`	`107`
`108`	`108`	`if (!removeColumns) removedNode.data.wasRemoved = false`
`109`	`109`
`110`		`- val columnsToInsert = groupedFrame.getColumnsWithPaths { colsAtAnyDepth { !it.isColumnGroup() } }.map {`
	`110`	`+ val columnsToInsert = groupedFrame.getColumnsWithPaths {`
	`111`	`+ colsAtAnyDepth().filter { !it.isColumnGroup() }`
	`112`	`+ }.map {`
`111`	`113`	`ColumnToInsert(insertPath + it.path, it, removedNode)`
`112`	`114`	`}`
`113`	`115`	`val src = if (removeColumns) removed.df else df`
Original file line number	Diff line number	Diff line change
`@@ -112,7 +112,7 @@ internal fun <A, B> DataFrame<A>.joinImpl(`
`112`	`112`
`113`	`113`	`// group row indices by key from right data frame`
`114`	`114`	`val groupedRight = when (joinType) {`
`115`		`- JoinType.Exclude -> rightJoinKeyToIndex.associate { it.first to emptyList<Int>() }`
	`115`	`+ JoinType.Exclude -> rightJoinKeyToIndex.associate { it.first to emptyList() }`
`116`	`116`	`else -> rightJoinKeyToIndex.groupBy({ it.first }) { it.second }`
`117`	`117`	`}`
`118`	`118`
`@@ -145,14 +145,14 @@ internal fun <A, B> DataFrame<A>.joinImpl(`
`145`	`145`	`outputRowsCount += rightUnmatchedCount`
`146`	`146`	`}`
`147`	`147`
`148`		`- val leftColumns = getColumnsWithPaths { colsAtAnyDepth { !it.isColumnGroup() } }`
	`148`	`+ val leftColumns = getColumnsWithPaths { colsAtAnyDepth().filter { !it.isColumnGroup() } }`
`149`	`149`
`150`	`150`	`val rightJoinColumnPaths = allRightJoinColumns.associate { it.path to it.data }`
`151`	`151`
`152`	`152`	`val newRightColumns =`
`153`	`153`	`if (addNewColumns) {`
`154`	`154`	`other.getColumnsWithPaths {`
`155`		`- colsAtAnyDepth {`
	`155`	`+ colsAtAnyDepth().filter {`
`156`	`156`	`!it.isColumnGroup() && !rightJoinColumnPaths.contains(it.path)`
`157`	`157`	`}`
`158`	`158`	`}`