diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 1c82c1a55..5b3a57cfb 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -4,6 +4,7 @@ import io.github.devcrocod.korro.KorroTask
 import nl.jolanrensen.docProcessor.defaultProcessors.*
 import nl.jolanrensen.docProcessor.gradle.creatingProcessDocTask
 import org.gradle.jvm.tasks.Jar
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import org.jmailen.gradle.kotlinter.tasks.LintTask
 import xyz.ronella.gradle.plugin.simple.git.task.GitTask
 
@@ -77,7 +78,7 @@ val samplesImplementation by configurations.getting {
     extendsFrom(configurations.testImplementation.get())
 }
 
-val compileSamplesKotlin = tasks.named<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>("compileSamplesKotlin") {
+val compileSamplesKotlin = tasks.named<KotlinCompile>("compileSamplesKotlin") {
     friendPaths.from(sourceSets["main"].output.classesDirs)
     source(sourceSets["test"].kotlin)
     destinationDirectory.set(file("$buildDir/classes/testWithOutputs/kotlin"))
@@ -106,6 +107,7 @@ val samplesTest = tasks.register<Test>("samplesTest") {
 
     dependsOn(compileSamplesKotlin)
     dependsOn(clearTestResults)
+    outputs.upToDateWhen { false }
 
     environment("DATAFRAME_SAVE_OUTPUTS", "")
 
@@ -129,6 +131,12 @@ val clearSamplesOutputs by tasks.creating {
     }
 }
 
+val addSamplesToGit by tasks.creating(GitTask::class) {
+    directory.set(file("."))
+    command.set("add")
+    args.set(listOf("-A", "../docs/StardustDocs/snippets"))
+}
+
 val copySamplesOutputs = tasks.register<JavaExec>("copySamplesOutputs") {
     group = "documentation"
     mainClass.set("org.jetbrains.kotlinx.dataframe.explainer.SampleAggregatorKt")
@@ -136,6 +144,10 @@ val copySamplesOutputs = tasks.register<JavaExec>("copySamplesOutputs") {
     dependsOn(clearSamplesOutputs)
     dependsOn(samplesTest)
     classpath = sourceSets.test.get().runtimeClasspath
+
+    doLast {
+        addSamplesToGit.executeCommand()
+    }
 }
 
 tasks.withType<KorroTask> {
@@ -307,7 +319,7 @@ tasks.withType<JavaCompile> {
     targetCompatibility = JavaVersion.VERSION_1_8.toString()
 }
 
-tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
+tasks.withType<KotlinCompile> {
     kotlinOptions {
         freeCompilerArgs = freeCompilerArgs + listOf("-Xinline-classes", "-Xopt-in=kotlin.RequiresOptIn")
     }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataColumn.kt
index 37d387567..76a752d7f 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataColumn.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataColumn.kt
@@ -1,26 +1,8 @@
 package org.jetbrains.kotlinx.dataframe
 
-import org.jetbrains.kotlinx.dataframe.api.Infer
-import org.jetbrains.kotlinx.dataframe.api.asDataColumn
-import org.jetbrains.kotlinx.dataframe.api.cast
-import org.jetbrains.kotlinx.dataframe.api.concat
-import org.jetbrains.kotlinx.dataframe.api.filter
-import org.jetbrains.kotlinx.dataframe.api.schema
-import org.jetbrains.kotlinx.dataframe.api.take
-import org.jetbrains.kotlinx.dataframe.columns.BaseColumn
-import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
-import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
-import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
-import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
-import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
-import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnGroupImpl
-import org.jetbrains.kotlinx.dataframe.impl.columns.FrameColumnImpl
-import org.jetbrains.kotlinx.dataframe.impl.columns.ValueColumnImpl
-import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
-import org.jetbrains.kotlinx.dataframe.impl.columns.guessColumnType
-import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnKind
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.columns.*
+import org.jetbrains.kotlinx.dataframe.impl.columns.*
 import org.jetbrains.kotlinx.dataframe.impl.getValuesType
 import org.jetbrains.kotlinx.dataframe.impl.splitByIndices
 import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
@@ -54,7 +36,7 @@ public interface DataColumn<out T> : BaseColumn<T> {
             values: List<T>,
             type: KType,
             infer: Infer = Infer.None,
-            defaultValue: T? = null
+            defaultValue: T? = null,
         ): ValueColumn<T> = ValueColumnImpl(values, name, getValuesType(values, type, infer), defaultValue)
 
         /**
@@ -67,7 +49,11 @@ public interface DataColumn<out T> : BaseColumn<T> {
          * @param values list of column values
          * @param infer column type inference mode
          */
-        public inline fun <reified T> createValueColumn(name: String, values: List<T>, infer: Infer = Infer.None): ValueColumn<T> = createValueColumn(
+        public inline fun <reified T> createValueColumn(
+            name: String,
+            values: List<T>,
+            infer: Infer = Infer.None,
+        ): ValueColumn<T> = createValueColumn(
             name, values,
             getValuesType(
                 values,
@@ -81,17 +67,21 @@ public interface DataColumn<out T> : BaseColumn<T> {
         public fun <T> createFrameColumn(
             name: String,
             df: DataFrame<T>,
-            startIndices: Iterable<Int>
+            startIndices: Iterable<Int>,
         ): FrameColumn<T> =
             FrameColumnImpl(name, df.splitByIndices(startIndices.asSequence()).toList(), lazy { df.schema() })
 
         public fun <T> createFrameColumn(
             name: String,
             groups: List<DataFrame<T>>,
-            schema: Lazy<DataFrameSchema>? = null
+            schema: Lazy<DataFrameSchema>? = null,
         ): FrameColumn<T> = FrameColumnImpl(name, groups, schema)
 
-        public fun <T> createWithTypeInference(name: String, values: List<T>, nullable: Boolean? = null): DataColumn<T> = guessColumnType(name, values, nullable = nullable)
+        public fun <T> createWithTypeInference(
+            name: String,
+            values: List<T>,
+            nullable: Boolean? = null,
+        ): DataColumn<T> = guessColumnType(name, values, nullable = nullable)
 
         public fun <T> create(name: String, values: List<T>, type: KType, infer: Infer = Infer.None): DataColumn<T> {
             return when (type.toColumnKind()) {
@@ -101,7 +91,8 @@ public interface DataColumn<out T> : BaseColumn<T> {
             }
         }
 
-        public inline fun <reified T> create(name: String, values: List<T>, infer: Infer = Infer.None): DataColumn<T> = create(name, values, typeOf<T>(), infer)
+        public inline fun <reified T> create(name: String, values: List<T>, infer: Infer = Infer.None): DataColumn<T> =
+            create(name, values, typeOf<T>(), infer)
 
         public fun empty(name: String = ""): AnyCol = createValueColumn(name, emptyList<Unit>(), typeOf<Unit>())
     }
@@ -116,7 +107,8 @@ public interface DataColumn<out T> : BaseColumn<T> {
 
     override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? = this.addPath()
 
-    override operator fun getValue(thisRef: Any?, property: KProperty<*>): DataColumn<T> = super.getValue(thisRef, property) as DataColumn<T>
+    override operator fun getValue(thisRef: Any?, property: KProperty<*>): DataColumn<T> =
+        super.getValue(thisRef, property) as DataColumn<T>
 
     public operator fun iterator(): Iterator<T> = values().iterator()
 
@@ -133,6 +125,8 @@ public val AnyCol.indices: IntRange get() = indices()
 
 public val AnyCol.type: KType get() = type()
 public val AnyCol.kind: ColumnKind get() = kind()
-public val AnyCol.typeClass: KClass<*> get() = type.classifier as? KClass<*> ?: error("Cannot cast ${type.classifier?.javaClass} to a ${KClass::class}. Column $name: $type")
+public val AnyCol.typeClass: KClass<*>
+    get() = type.classifier as? KClass<*>
+        ?: error("Cannot cast ${type.classifier?.javaClass} to a ${KClass::class}. Column $name: $type")
 
 public fun AnyBaseCol.indices(): IntRange = 0 until size()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
index f89e2ff51..e49b08d53 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
@@ -9,39 +9,15 @@ import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
-import org.jetbrains.kotlinx.dataframe.Predicate
-import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
-import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
-import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
-import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
-import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
-import org.jetbrains.kotlinx.dataframe.columns.renamedReference
-import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.*
 import org.jetbrains.kotlinx.dataframe.documentation.AccessApi
 import org.jetbrains.kotlinx.dataframe.documentation.ColumnExpression
 import org.jetbrains.kotlinx.dataframe.documentation.DocumentationUrls
 import org.jetbrains.kotlinx.dataframe.documentation.LineBreak
-import org.jetbrains.kotlinx.dataframe.hasNulls
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.toColumns
 import org.jetbrains.kotlinx.dataframe.impl.columnName
-import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnsList
-import org.jetbrains.kotlinx.dataframe.impl.columns.DistinctColumnSet
-import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
-import org.jetbrains.kotlinx.dataframe.impl.columns.allColumnsExcept
-import org.jetbrains.kotlinx.dataframe.impl.columns.changePath
-import org.jetbrains.kotlinx.dataframe.impl.columns.createColumnSet
-import org.jetbrains.kotlinx.dataframe.impl.columns.getAt
-import org.jetbrains.kotlinx.dataframe.impl.columns.getChildrenAt
-import org.jetbrains.kotlinx.dataframe.impl.columns.singleImpl
-import org.jetbrains.kotlinx.dataframe.impl.columns.top
-import org.jetbrains.kotlinx.dataframe.impl.columns.transform
-import org.jetbrains.kotlinx.dataframe.impl.columns.transformSingle
-import org.jetbrains.kotlinx.dataframe.impl.columns.transformWithContext
-import org.jetbrains.kotlinx.dataframe.impl.columns.tree.dfs
+import org.jetbrains.kotlinx.dataframe.impl.columns.*
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.flattenRecursively
 import org.jetbrains.kotlinx.dataframe.impl.headPlusArray
 import kotlin.reflect.KProperty
 import kotlin.reflect.KType
@@ -290,8 +266,8 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @throws [NoSuchElementException] if no column adheres to the given [condition].
      * @see [last]
      */
-    public fun <C> ColumnSet<C>.first(condition: ColumnFilter<C> = { true }): SingleColumn<C> =
-        transform { listOf(it.first(condition)) }.singleImpl()
+    public fun <C> ColumnSet<C>.first(condition: ColumnFilter<C> = { true }): TransformableSingleColumn<C> =
+        transform { listOf(it.first(condition)) }.singleWithTransformerImpl()
 
     /**
      * ## First
@@ -303,12 +279,14 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][select]` { myColumnGroup.`[first][first]`() }`
      *
+     * `df.`[select][select]` { "pathTo"["myColumnGroup"].`[first][first]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
      * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
      * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the first column that adheres to the given [condition].
      * @throws [NoSuchElementException] if no column adheres to the given [condition].
      * @see [last]
      */
-    public fun SingleColumn<AnyRow>.first(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
+    public fun SingleColumn<*>.first(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
         all().first(condition)
 
     /**
@@ -324,23 +302,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @throws [NoSuchElementException] if no column adheres to the given [condition].
      * @see [last]
      */
-    public fun String.first(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
-        colGroup(this).first(condition)
-
-    /**
-     * ## First
-     * Returns the first column in this [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] or [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] that adheres to the given [condition].
-     *
-     * #### For example:
-     *
-     * `df.`[select][select]` { "pathTo"["myColumnGroup"].`[first][first]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
-     *
-     * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
-     * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the first column that adheres to the given [condition].
-     * @throws [NoSuchElementException] if no column adheres to the given [condition].
-     * @see [last]
-     */
-    public fun ColumnPath.first(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
+    public fun String.first(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
         colGroup(this).first(condition)
 
     /**
@@ -356,7 +318,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @throws [NoSuchElementException] if no column adheres to the given [condition].
      * @see [last]
      */
-    public fun KProperty<*>.first(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
+    public fun KProperty<*>.first(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
         colGroup(this).first(condition)
 
     /**
@@ -393,8 +355,8 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @throws [NoSuchElementException] if no column adheres to the given [condition].
      * @see [first]
      */
-    public fun <C> ColumnSet<C>.last(condition: ColumnFilter<C> = { true }): SingleColumn<C> =
-        transform { listOf(it.last(condition)) }.singleImpl()
+    public fun <C> ColumnSet<C>.last(condition: ColumnFilter<C> = { true }): TransformableSingleColumn<C> =
+        transform { listOf(it.last(condition)) }.singleWithTransformerImpl()
 
     /**
      * ## Last
@@ -406,12 +368,14 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][select]` { myColumnGroup.`[last][last]`() }`
      *
+     * `df.`[select][select]` { "pathTo"["myColumnGroup"].`[last][last]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
      * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
      * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the last column that adheres to the given [condition].
      * @throws [NoSuchElementException] if no column adheres to the given [condition].
      * @see [first]
      */
-    public fun SingleColumn<AnyRow>.last(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
+    public fun SingleColumn<*>.last(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
         all().last(condition)
 
     /**
@@ -427,23 +391,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @throws [NoSuchElementException] if no column adheres to the given [condition].
      * @see [first]
      */
-    public fun String.last(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
-        colGroup(this).last(condition)
-
-    /**
-     * ## Last
-     * Returns the last column in this [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] or [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] that adheres to the given [condition].
-     *
-     * #### For example:
-     *
-     * `df.`[select][select]` { "pathTo"["myColumnGroup"].`[last][last]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
-     *
-     * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
-     * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the last column that adheres to the given [condition].
-     * @throws [NoSuchElementException] if no column adheres to the given [condition].
-     * @see [first]
-     */
-    public fun ColumnPath.last(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
+    public fun String.last(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
         colGroup(this).last(condition)
 
     /**
@@ -459,7 +407,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @throws [NoSuchElementException] if no column adheres to the given [condition].
      * @see [first]
      */
-    public fun KProperty<*>.last(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
+    public fun KProperty<*>.last(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
         colGroup(this).last(condition)
 
     /**
@@ -496,8 +444,8 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @throws [NoSuchElementException] if no column adheres to the given [condition].
      * @throws [IllegalArgumentException] if more than one column adheres to the given [condition].
      */
-    public fun <C> ColumnSet<C>.single(condition: ColumnFilter<C> = { true }): SingleColumn<C> =
-        transform { listOf(it.single(condition)) }.singleImpl()
+    public fun <C> ColumnSet<C>.single(condition: ColumnFilter<C> = { true }): TransformableSingleColumn<C> =
+        transform { listOf(it.single(condition)) }.singleWithTransformerImpl()
 
     /**
      * ## Single
@@ -509,12 +457,14 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][select]` { myColumnGroup.`[single][single]`() }`
      *
+     * `df.`[select][select]` { "pathTo"["myColumnGroup"].`[single][single]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
+     *
      * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
      * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the single column that adheres to the given [condition].
      * @throws [NoSuchElementException] if no column adheres to the given [condition].
      * @throws [IllegalArgumentException] if more than one column adheres to the given [condition].
      */
-    public fun SingleColumn<AnyRow>.single(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
+    public fun SingleColumn<*>.single(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
         all().single(condition)
 
     /**
@@ -530,23 +480,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @throws [NoSuchElementException] if no column adheres to the given [condition].
      * @throws [IllegalArgumentException] if more than one column adheres to the given [condition].
      */
-    public fun String.single(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
-        colGroup(this).single(condition)
-
-    /**
-     * ## Single
-     * Returns the single column in this [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] or [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] that adheres to the given [condition].
-     *
-     * #### For example:
-     *
-     * `df.`[select][select]` { "pathTo"["myColumnGroup"].`[single][single]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
-     *
-     * @param [condition] The optional [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] condition that the column must adhere to.
-     * @return A [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing the single column that adheres to the given [condition].
-     * @throws [NoSuchElementException] if no column adheres to the given [condition].
-     * @throws [IllegalArgumentException] if more than one column adheres to the given [condition].
-     */
-    public fun ColumnPath.single(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
+    public fun String.single(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
         colGroup(this).single(condition)
 
     /**
@@ -562,7 +496,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @throws [NoSuchElementException] if no column adheres to the given [condition].
      * @throws [IllegalArgumentException] if more than one column adheres to the given [condition].
      */
-    public fun KProperty<*>.single(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
+    public fun KProperty<*>.single(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
         colGroup(this).single(condition)
 
     /**
@@ -736,8 +670,9 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      */
     public operator fun AnyColumnReference.rangeTo(endInclusive: AnyColumnReference): ColumnSet<*> =
         object : ColumnSet<Any?> {
-            override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<Any?>> {
-                val startPath = this@rangeTo.resolveSingle(context)!!.path
+
+            private fun process(col: AnyColumnReference, context: ColumnResolutionContext): List<ColumnWithPath<Any?>> {
+                val startPath = col.resolveSingle(context)!!.path
                 val endPath = endInclusive.resolveSingle(context)!!.path
                 val parentPath = startPath.parent()!!
                 require(parentPath == endPath.parent()) { "Start and end columns have different parent column paths" }
@@ -750,6 +685,9 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
                     }
                 }
             }
+
+            override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<Any?>> =
+                process(this@rangeTo, context)
         }
 
     /**
@@ -1066,7 +1004,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      */
     public fun <C> ColumnGroupReference.col(property: KProperty<C>): ColumnAccessor<C> = column(property)
 
-    public fun SingleColumn<AnyRow>.col(index: Int): SingleColumn<Any?> = getChildrenAt(index).singleImpl()
+    public fun SingleColumn<*>.col(index: Int): SingleColumn<Any?> = getChildrenAt(index).singleImpl()
 
     public operator fun <C> ColumnSet<C>.get(index: Int): SingleColumn<C> = getAt(index)
 
@@ -1677,7 +1615,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet]) from a parent [ColumnSet], -[ColumnGroup], or -[DataFrame].
+     * Creates a subset of columns ([ColumnSet]) from the current [ColumnSet].
+     *
+     * If the current [ColumnSet] is a [SingleColumn]
+     * (and thus consists of only one column (or [column group][ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][AccessApi] (+ [ColumnPath]).
      *
@@ -1700,7 +1643,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
         /**
          * ## Cols
-         * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+         * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+         *
+         * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+         * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+         * then `cols` will create a subset of its children.
+         *
          * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
          * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
          *
@@ -1726,7 +1674,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
         /**
          * ## Cols
-         * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+         * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+         *
+         * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+         * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+         * then `cols` will create a subset of its children.
+         *
          * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
          * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
          *
@@ -1762,7 +1715,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -1797,7 +1755,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     private interface ColumnSetColsPredicateDocs
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -1832,15 +1795,15 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     @Suppress("UNCHECKED_CAST")
     public fun <C> ColumnSet<C>.cols(
         predicate: ColumnFilter<C> = { true },
-    ): ColumnSet<C> = transformWithContext {
-        dataFrameOf(it)
-            .asColumnGroup()
-            .cols(predicate as ColumnFilter<*>)
-            .resolve(this)
-    } as ColumnSet<C>
+    ): TransformableColumnSet<C> = colsInternal(predicate as ColumnFilter<*>) as TransformableColumnSet<C>
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -1874,11 +1837,16 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      */
     public operator fun <C> ColumnSet<C>.get(
         predicate: ColumnFilter<C> = { true },
-    ): ColumnSet<C> = cols(predicate)
+    ): TransformableColumnSet<C> = cols(predicate)
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -1900,17 +1868,18 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][select]` { myColumnGroup`.[cols][cols]` { "e" `[in][String.contains]` it.`[name][ColumnPath.name]`() } }`
      *
-     * `// same as `[all][all]
+     * `df.`[select][select]` { `[cols][cols]`() } // same as `[all][all]
      *
-     * `df.`[select][select]` { `[cols][cols]`() }`
+     * `df.`[select][select]` { "pathTo"["myGroupCol"].`[cols][cols]` { "e" `[in][String.contains]` it.`[name][ColumnPath.name]`() } }`
+     *
+     * `df.`[select][select]` { "pathTo"["myGroupCol"]`[`[`][cols]`{ it.`[any][ColumnWithPath.any]` { it == "Alice" } }`[`]`][cols]` }`
+     *
+     * `df.`[select][select]` { "pathTo"["myGroupCol"].`[cols][cols]`() } // identity call, same as `[all][all]
      *
      * `// NOTE: there's a `[DataFrame.get]` overload that prevents this:`
      *
      * `df.`[select][select]` { myColumnGroup`[`[`][cols]`{ ... }`[`]`][cols]` }`
      *
-     * `// use `[cols][cols]` instead`
-     * `df.`[select][select]` { myColumnGroup`.[cols][cols]` { ... } }`
-     *
      * @see [all]
      *
      *
@@ -1920,7 +1889,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     private interface SingleColumnAnyRowColsPredicateDocs
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -1942,30 +1916,36 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { myColumnGroup`.[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "e" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.name]`() } }`
      *
-     * `// same as `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() } // same as `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]
      *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() }`
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["myGroupCol"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "e" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.name]`() } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["myGroupCol"]`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`{ it.`[any][ColumnWithPath.any]` { it == "Alice" } }`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["myGroupCol"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() } // identity call, same as `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]
      *
      * `// NOTE: there's a `[DataFrame.get][org.jetbrains.kotlinx.dataframe.DataFrame.get]` overload that prevents this:`
      *
      * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`{ ... }`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
      *
-     * `// use `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` instead`
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { myColumnGroup`.[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { ... } }`
-     *
      * @see [all]
      *
      *
      * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
      * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
      */
-    public fun SingleColumn<AnyRow>.cols(
+    public fun SingleColumn<*>.cols(
         predicate: ColumnFilter<*> = { true },
-    ): ColumnSet<*> = colsInternal(predicate)
+    ): TransformableColumnSet<*> = colsInternal(predicate)
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -1987,17 +1967,18 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { myColumnGroup`.[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "e" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.name]`() } }`
      *
-     * `// same as `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() } // same as `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]
      *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() }`
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["myGroupCol"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "e" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.name]`() } }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["myGroupCol"]`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`{ it.`[any][ColumnWithPath.any]` { it == "Alice" } }`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["myGroupCol"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() } // identity call, same as `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]
      *
      * `// NOTE: there's a `[DataFrame.get][org.jetbrains.kotlinx.dataframe.DataFrame.get]` overload that prevents this:`
      *
      * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`{ ... }`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
      *
-     * `// use `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` instead`
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { myColumnGroup`.[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { ... } }`
-     *
      * @see [all]
      *
      *
@@ -2005,13 +1986,18 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
      * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
      */
-    public operator fun SingleColumn<AnyRow>.get(
+    public operator fun SingleColumn<*>.get(
         predicate: ColumnFilter<*> = { true },
-    ): ColumnSet<Any?> = cols(predicate)
+    ): TransformableColumnSet<Any?> = cols(predicate)
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2042,7 +2028,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     private interface StringColsPredicateDocs
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2072,10 +2063,15 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      */
     public fun String.cols(
         predicate: ColumnFilter<*> = { true },
-    ): ColumnSet<*> = colGroup(this).cols(predicate)
+    ): TransformableColumnSet<*> = colGroup(this).cols(predicate)
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2105,115 +2101,16 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      */
     public operator fun String.get(
         predicate: ColumnFilter<*> = { true },
-    ): ColumnSet<Any?> = cols(predicate)
+    ): TransformableColumnSet<Any?> = cols(predicate)
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
-     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
-     * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
-     *
-     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] directly, you can also use the [get][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.get] operator in most cases.
-     *
-     * #### For example:
-     * `df.`[remove][org.jetbrains.kotlinx.dataframe.DataFrame.remove]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[hasNulls][org.jetbrains.kotlinx.dataframe.hasNulls]`() } }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[String][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`1, 3, 5] }`
-     *
-     *
-     * #### Examples for this overload:
-     *
-     * `df.`[select][select]` { "pathTo"["myGroupCol"].`[cols][cols]` { "e" `[in][String.contains]` it.`[name][ColumnPath.name]`() } }`
-     *
-     * `df.`[select][select]` { "pathTo"["myGroupCol"]`[`[`][cols]`{ it.`[any][ColumnWithPath.any]` { it == "Alice" } }`[`]`][cols]` }`
-     *
-     * `// identity call, same as `[all][all]
-     *
-     * `df.`[select][select]` { "pathTo"["myGroupCol"].`[cols][cols]`() }`
-     *
-     * @see [all]
-     *
-     *
-     * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
-     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
-     */
-    private interface ColumnPathColsPredicateDocs
-
-    /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
-     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
-     * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
-     *
-     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] directly, you can also use the [get][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.get] operator in most cases.
-     *
-     * #### For example:
-     * `df.`[remove][org.jetbrains.kotlinx.dataframe.DataFrame.remove]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[hasNulls][org.jetbrains.kotlinx.dataframe.hasNulls]`() } }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[String][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`1, 3, 5] }`
-     *
-     *
-     * #### Examples for this overload:
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["myGroupCol"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "e" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.name]`() } }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["myGroupCol"]`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`{ it.`[any][ColumnWithPath.any]` { it == "Alice" } }`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
-     *
-     * `// identity call, same as `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["myGroupCol"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() }`
-     *
-     * @see [all]
-     *
-     *
-     * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
-     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
-     */
-    public fun ColumnPath.cols(
-        predicate: ColumnFilter<*> = { true },
-    ): ColumnSet<*> = colGroup(this).cols(predicate)
-
-    /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
-     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
-     * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
-     *
-     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] directly, you can also use the [get][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.get] operator in most cases.
-     *
-     * #### For example:
-     * `df.`[remove][org.jetbrains.kotlinx.dataframe.DataFrame.remove]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[hasNulls][org.jetbrains.kotlinx.dataframe.hasNulls]`() } }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[String][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`1, 3, 5] }`
-     *
-     *
-     * #### Examples for this overload:
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["myGroupCol"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { "e" `[in][String.contains]` it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnPath.name]`() } }`
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
      *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["myGroupCol"]`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`{ it.`[any][ColumnWithPath.any]` { it == "Alice" } }`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
-     *
-     * `// identity call, same as `[all][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.all]
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["myGroupCol"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`() }`
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
      *
-     * @see [all]
-     *
-     *
-     * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
-     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
-     */
-    public operator fun ColumnPath.get(
-        predicate: ColumnFilter<*> = { true },
-    ): ColumnSet<Any?> = cols(predicate)
-
-    /**
-     * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2246,7 +2143,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     private interface KPropertyColsPredicateDocs
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2278,10 +2180,15 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      */
     public fun KProperty<*>.cols(
         predicate: ColumnFilter<*> = { true },
-    ): ColumnSet<*> = colGroup(this).cols(predicate)
+    ): TransformableColumnSet<*> = colGroup(this).cols(predicate)
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2313,7 +2220,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      */
     public operator fun KProperty<*>.get(
         predicate: ColumnFilter<*> = { true },
-    ): ColumnSet<Any?> = cols(predicate)
+    ): TransformableColumnSet<Any?> = cols(predicate)
 
     // endregion
 
@@ -2321,7 +2228,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2351,7 +2263,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     private interface ColumnSetColsVarargColumnReferenceDocs
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2389,7 +2306,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     }
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2423,7 +2345,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2447,6 +2374,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][select]` { myColumnGroup.`[cols][cols]`(columnA, columnB) }`
      *
+     * `df.`[select][select]` { "pathTo"["columnGroup"].`[cols][cols]`(columnA, columnB) }`
+     *
+     * `df.`[select][select]` { "pathTo"["columnGroup"].`[cols][cols]`("pathTo"["colA"], "pathTo"["colB"]) }`
+     *
+     * `df.`[select][select]` { "pathTo"["columnGroup"]`[`[`][cols]`columnA, columnB`[`]`][cols]` }`
+     *
      * `// NOTE: there's a `[DataFrame.get]` overload that prevents this:`
      *
      * `df.`[select][select]` { myColumnGroup`[`[`][cols]`columnA, columnB`[`]`][cols]` }`
@@ -2459,7 +2392,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     private interface SingleColumnColsVarargColumnReferenceDocs
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2483,6 +2421,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { myColumnGroup.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
      *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`("pathTo"["colA"], "pathTo"["colB"]) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`columnA, columnB`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     *
      * `// NOTE: there's a `[DataFrame.get][org.jetbrains.kotlinx.dataframe.DataFrame.get]` overload that prevents this:`
      *
      * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`columnA, columnB`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
@@ -2492,7 +2436,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @param [otherCols] Optional additional [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s that point to columns.
      * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
      */
-    public fun <C> SingleColumn<AnyRow>.cols(
+    public fun <C> SingleColumn<*>.cols(
         firstCol: ColumnReference<C>,
         vararg otherCols: ColumnReference<C>,
     ): ColumnSet<C> = headPlusArray(firstCol, otherCols).let { refs ->
@@ -2503,7 +2447,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2527,6 +2476,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { myColumnGroup.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
      *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`("pathTo"["colA"], "pathTo"["colB"]) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`columnA, columnB`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     *
      * `// NOTE: there's a `[DataFrame.get][org.jetbrains.kotlinx.dataframe.DataFrame.get]` overload that prevents this:`
      *
      * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`columnA, columnB`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
@@ -2537,14 +2492,19 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @param [otherCols] Optional additional [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s that point to columns.
      * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
      */
-    public operator fun <C> SingleColumn<AnyRow>.get(
+    public operator fun <C> SingleColumn<*>.get(
         firstCol: ColumnReference<C>,
         vararg otherCols: ColumnReference<C>,
     ): ColumnSet<C> = cols(firstCol, *otherCols)
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2574,7 +2534,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     private interface StringColsVarargColumnReferenceDocs
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2607,7 +2572,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     ): ColumnSet<C> = colGroup(this).cols(firstCol, *otherCols)
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2641,7 +2611,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2657,21 +2632,26 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * #### Examples for this overload:
      *
-     * `df.`[select][select]` { "pathTo"["columnGroup"].`[cols][cols]`(columnA, columnB) }`
+     * `df.`[select][select]` { Type::myColumnGroup.`[cols][cols]`(columnA, columnB) }`
      *
-     * `df.`[select][select]` { "pathTo"["columnGroup"].`[cols][cols]`("pathTo"["colA"], "pathTo"["colB"]) }`
+     * `df.`[select][select]` { Type::myColumnGroup.`[cols][cols]`("pathTo"["colA"], "pathTo"["colB"]) }`
      *
-     * `df.`[select][select]` { "pathTo"["columnGroup"]`[`[`][cols]`columnA, columnB`[`]`][cols]` }`
+     * `df.`[select][select]` { Type::myColumnGroup`[`[`][cols]`columnA, columnB`[`]`][cols]` }`
      *
      *
      * @param [firstCol] A [ColumnReference] that points to a column.
      * @param [otherCols] Optional additional [ColumnReference]s that point to columns.
      * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
      */
-    private interface ColumnPathColsVarargColumnReferenceDocs
+    private interface KPropertyColsVarargColumnReferenceDocs
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2687,24 +2667,29 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * #### Examples for this overload:
      *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { Type::myColumnGroup.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
      *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`("pathTo"["colA"], "pathTo"["colB"]) }`
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { Type::myColumnGroup.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`("pathTo"["colA"], "pathTo"["colB"]) }`
      *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`columnA, columnB`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { Type::myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`columnA, columnB`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
      *
      *
      * @param [firstCol] A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] that points to a column.
      * @param [otherCols] Optional additional [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s that point to columns.
      * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
      */
-    public fun <C> ColumnPath.cols(
+    public fun <C> KProperty<*>.cols(
         firstCol: ColumnReference<C>,
         vararg otherCols: ColumnReference<C>,
     ): ColumnSet<C> = colGroup(this).cols(firstCol, *otherCols)
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2720,108 +2705,11 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * #### Examples for this overload:
      *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { Type::myColumnGroup.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
      *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`("pathTo"["colA"], "pathTo"["colB"]) }`
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { Type::myColumnGroup.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`("pathTo"["colA"], "pathTo"["colB"]) }`
      *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`columnA, columnB`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
-     *
-     *
-     * @param [firstCol] A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] that points to a column.
-     * @param [otherCols] Optional additional [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s that point to columns.
-     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
-     */
-    public operator fun <C> ColumnPath.get(
-        firstCol: ColumnReference<C>,
-        vararg otherCols: ColumnReference<C>,
-    ): ColumnSet<C> = cols(firstCol, *otherCols)
-
-    /**
-     * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
-     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
-     * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
-     *
-     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] directly, you can also use the [get][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.get] operator in most cases.
-     *
-     * #### For example:
-     * `df.`[remove][org.jetbrains.kotlinx.dataframe.DataFrame.remove]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[hasNulls][org.jetbrains.kotlinx.dataframe.hasNulls]`() } }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[String][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`1, 3, 5] }`
-     *
-     *
-     * #### Examples for this overload:
-     *
-     * `df.`[select][select]` { Type::myColumnGroup.`[cols][cols]`(columnA, columnB) }`
-     *
-     * `df.`[select][select]` { Type::myColumnGroup.`[cols][cols]`("pathTo"["colA"], "pathTo"["colB"]) }`
-     *
-     * `df.`[select][select]` { Type::myColumnGroup`[`[`][cols]`columnA, columnB`[`]`][cols]` }`
-     *
-     *
-     * @param [firstCol] A [ColumnReference] that points to a column.
-     * @param [otherCols] Optional additional [ColumnReference]s that point to columns.
-     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
-     */
-    private interface KPropertyColsVarargColumnReferenceDocs
-
-    /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
-     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
-     * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
-     *
-     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] directly, you can also use the [get][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.get] operator in most cases.
-     *
-     * #### For example:
-     * `df.`[remove][org.jetbrains.kotlinx.dataframe.DataFrame.remove]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[hasNulls][org.jetbrains.kotlinx.dataframe.hasNulls]`() } }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[String][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`1, 3, 5] }`
-     *
-     *
-     * #### Examples for this overload:
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { Type::myColumnGroup.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { Type::myColumnGroup.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`("pathTo"["colA"], "pathTo"["colB"]) }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { Type::myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`columnA, columnB`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
-     *
-     *
-     * @param [firstCol] A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] that points to a column.
-     * @param [otherCols] Optional additional [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s that point to columns.
-     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
-     */
-    public fun <C> KProperty<*>.cols(
-        firstCol: ColumnReference<C>,
-        vararg otherCols: ColumnReference<C>,
-    ): ColumnSet<C> = colGroup(this).cols(firstCol, *otherCols)
-
-    /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
-     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
-     * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
-     *
-     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] directly, you can also use the [get][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.get] operator in most cases.
-     *
-     * #### For example:
-     * `df.`[remove][org.jetbrains.kotlinx.dataframe.DataFrame.remove]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[hasNulls][org.jetbrains.kotlinx.dataframe.hasNulls]`() } }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[String][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`1, 3, 5] }`
-     *
-     *
-     * #### Examples for this overload:
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { Type::myColumnGroup.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { Type::myColumnGroup.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`("pathTo"["colA"], "pathTo"["colB"]) }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { Type::myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`columnA, columnB`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { Type::myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`columnA, columnB`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
      *
      *
      * @param [firstCol] A [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] that points to a column.
@@ -2839,7 +2727,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2867,7 +2760,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     private interface ColumnSetColsVarargStringDocs
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2892,20 +2790,21 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @param [otherCols] Optional additional [String]s that point to columns.
      * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
      */
-    @Suppress("UNCHECKED_CAST")
     public fun <C> ColumnSet<C>.cols(
         firstCol: String,
         vararg otherCols: String,
-    ): ColumnSet<C> = transformWithContext {
-        dataFrameOf(it)
-            .asColumnGroup()
-            .cols(firstCol, *otherCols)
-            .resolve(this) as List<ColumnWithPath<C>>
+    ): ColumnSet<C> = headPlusArray(firstCol, otherCols).let { names ->
+        filter { it.name in names }
     }
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2937,7 +2836,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2959,6 +2863,10 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][select]` { myColumnGroup.`[cols][cols]`("columnA", "columnB") }`
      *
+     * `df.`[select][select]` { "pathTo"["columnGroup"].`[cols][cols]`("columnA", "columnB") }`
+     *
+     * `df.`[select][select]` { "pathTo"["columnGroup"]`[`[`][cols]`"columnA", "columnB"`[`]`][cols]` }`
+     *
      * `// NOTE: there's a `[DataFrame.get]` overload that prevents this:`
      *
      * `df.`[select][select]` { myColumnGroup`[`[`][cols]`"columnA", "columnB"`[`]`][cols]` }`
@@ -2971,7 +2879,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     private interface SingleColumnColsVarargStringDocs
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -2993,6 +2906,10 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { myColumnGroup.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`("columnA", "columnB") }`
      *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`"columnA", "columnB"`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     *
      * `// NOTE: there's a `[DataFrame.get][org.jetbrains.kotlinx.dataframe.DataFrame.get]` overload that prevents this:`
      *
      * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`"columnA", "columnB"`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
@@ -3002,7 +2919,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @param [otherCols] Optional additional [String]s that point to columns.
      * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
      */
-    public fun SingleColumn<AnyRow>.cols(
+    public fun SingleColumn<*>.cols(
         firstCol: String,
         vararg otherCols: String,
     ): ColumnSet<*> = headPlusArray(firstCol, otherCols).let { names ->
@@ -3011,7 +2928,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -3033,6 +2955,10 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { myColumnGroup.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`("columnA", "columnB") }`
      *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`("columnA", "columnB") }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`"columnA", "columnB"`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     *
      * `// NOTE: there's a `[DataFrame.get][org.jetbrains.kotlinx.dataframe.DataFrame.get]` overload that prevents this:`
      *
      * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`"columnA", "columnB"`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
@@ -3043,14 +2969,19 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @param [otherCols] Optional additional [String]s that point to columns.
      * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
      */
-    public operator fun SingleColumn<AnyRow>.get(
+    public operator fun SingleColumn<*>.get(
         firstCol: String,
         vararg otherCols: String,
     ): ColumnSet<*> = cols(firstCol, *otherCols)
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -3078,7 +3009,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     private interface StringColsVarargStringDocs
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -3109,7 +3045,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     ): ColumnSet<*> = colGroup(this).cols(firstCol, *otherCols)
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -3141,98 +3082,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
-     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
-     * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
-     *
-     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] directly, you can also use the [get][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.get] operator in most cases.
-     *
-     * #### For example:
-     * `df.`[remove][org.jetbrains.kotlinx.dataframe.DataFrame.remove]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[hasNulls][org.jetbrains.kotlinx.dataframe.hasNulls]`() } }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[String][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`1, 3, 5] }`
-     *
-     *
-     * #### Examples for this overload:
-     *
-     * `df.`[select][select]` { "pathTo"["columnGroup"].`[cols][cols]`("columnA", "columnB") }`
-     *
-     * `df.`[select][select]` { "pathTo"["columnGroup"]`[`[`][cols]`"columnA", "columnB"`[`]`][cols]` }`
-     *
-     *
-     * @param [firstCol] A [String] that points to a column.
-     * @param [otherCols] Optional additional [String]s that point to columns.
-     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
-     */
-    private interface ColumnPathColsVarargStringDocs
-
-    /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
-     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
-     * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
-     *
-     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] directly, you can also use the [get][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.get] operator in most cases.
-     *
-     * #### For example:
-     * `df.`[remove][org.jetbrains.kotlinx.dataframe.DataFrame.remove]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[hasNulls][org.jetbrains.kotlinx.dataframe.hasNulls]`() } }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[String][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`1, 3, 5] }`
-     *
-     *
-     * #### Examples for this overload:
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`("columnA", "columnB") }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`"columnA", "columnB"`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
-     *
-     *
-     * @param [firstCol] A [String] that points to a column.
-     * @param [otherCols] Optional additional [String]s that point to columns.
-     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
-     */
-    public fun ColumnPath.cols(
-        firstCol: String,
-        vararg otherCols: String,
-    ): ColumnSet<*> = colGroup(this).cols(firstCol, *otherCols)
-
-    /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
-     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
-     * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
-     *
-     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] directly, you can also use the [get][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.get] operator in most cases.
-     *
-     * #### For example:
-     * `df.`[remove][org.jetbrains.kotlinx.dataframe.DataFrame.remove]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[hasNulls][org.jetbrains.kotlinx.dataframe.hasNulls]`() } }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
      *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[String][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`1, 3, 5] }`
-     *
-     *
-     * #### Examples for this overload:
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`("columnA", "columnB") }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`"columnA", "columnB"`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
      *
-     *
-     * @param [firstCol] A [String] that points to a column.
-     * @param [otherCols] Optional additional [String]s that point to columns.
-     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
-     */
-    public operator fun ColumnPath.get(
-        firstCol: String,
-        vararg otherCols: String,
-    ): ColumnSet<*> = cols(firstCol, *otherCols)
-
-    /**
-     * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -3260,7 +3115,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     private interface KPropertiesColsVarargStringDocs
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -3291,7 +3151,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     ): ColumnSet<*> = colGroup(this).cols(firstCol, *otherCols)
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -3327,7 +3192,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -3355,7 +3225,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     private interface ColumnSetColsVarargKPropertyDocs
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -3383,15 +3258,17 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     public fun <C> ColumnSet<C>.cols(
         firstCol: KProperty<C>,
         vararg otherCols: KProperty<C>,
-    ): ColumnSet<C> = transformWithContext {
-        dataFrameOf(it)
-            .asColumnGroup()
-            .cols(firstCol, *otherCols)
-            .resolve(this)
+    ): ColumnSet<C> = headPlusArray(firstCol, otherCols).map { it.name }.let { names ->
+        filter { it.name in names }
     }
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -3423,7 +3300,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -3447,6 +3329,10 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][select]` { myColumnGroup`[`[`][cols]`Type::colA, Type::colB`[`]`][cols]` }`
      *
+     * `df.`[select][select]` { "pathTo"["columnGroup"].`[cols][cols]`(Type::colA, Type::colB) }`
+     *
+     * `df.`[select][select]` { "pathTo"["columnGroup"]`[`[`][cols]`Type::colA, Type::colB`[`]`][cols]` }`
+     *
      *
      * @param [firstCol] A [KProperty] that points to a column.
      * @param [otherCols] Optional additional [KProperty]s that point to columns.
@@ -3455,7 +3341,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     private interface SingleColumnColsVarargKPropertyDocs
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -3479,12 +3370,16 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`Type::colA, Type::colB`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
      *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(Type::colA, Type::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`Type::colA, Type::colB`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     *
      *
      * @param [firstCol] A [KProperty] that points to a column.
      * @param [otherCols] Optional additional [KProperty]s that point to columns.
      * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
      */
-    public fun <C> SingleColumn<AnyRow>.cols(
+    public fun <C> SingleColumn<*>.cols(
         firstCol: KProperty<C>,
         vararg otherCols: KProperty<C>,
     ): ColumnSet<C> = headPlusArray(firstCol, otherCols).let { props ->
@@ -3492,7 +3387,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     }
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -3516,19 +3416,28 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { myColumnGroup`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`Type::colA, Type::colB`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
      *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(Type::colA, Type::colB) }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`Type::colA, Type::colB`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     *
      *
      * @param [firstCol] A [KProperty] that points to a column.
      * @param [otherCols] Optional additional [KProperty]s that point to columns.
      * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
      */
-    public operator fun <C> SingleColumn<AnyRow>.get(
+    public operator fun <C> SingleColumn<*>.get(
         firstCol: KProperty<C>,
         vararg otherCols: KProperty<C>,
     ): ColumnSet<C> = cols(firstCol, *otherCols)
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -3556,7 +3465,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     private interface StringColsVarargKPropertyDocs
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -3587,7 +3501,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     ): ColumnSet<C> = colGroup(this).cols(firstCol, *otherCols)
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -3619,7 +3538,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -3635,110 +3559,24 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * #### Examples for this overload:
      *
-     * `df.`[select][select]` { "pathTo"["columnGroup"].`[cols][cols]`(Type::colA, Type::colB) }`
+     * `df.`[select][select]` { Type::myColumnGroup.`[cols][cols]`(Type::colA, Type::colB) }`
      *
-     * `df.`[select][select]` { "pathTo"["columnGroup"]`[`[`][cols]`Type::colA, Type::colB`[`]`][cols]` }`
+     * `df.`[select][select]` { Type::myColumnGroup`[`[`][cols]`Type::colA, Type::colB`[`]`][cols]` }`
      *
      *
      * @param [firstCol] A [KProperty] that points to a column.
      * @param [otherCols] Optional additional [KProperty]s that point to columns.
      * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
      */
-    private interface ColumnPathColsVarargKPropertyDocs
-
-    /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
-     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
-     * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
-     *
-     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] directly, you can also use the [get][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.get] operator in most cases.
-     *
-     * #### For example:
-     * `df.`[remove][org.jetbrains.kotlinx.dataframe.DataFrame.remove]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[hasNulls][org.jetbrains.kotlinx.dataframe.hasNulls]`() } }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[String][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`1, 3, 5] }`
-     *
-     *
-     * #### Examples for this overload:
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(Type::colA, Type::colB) }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`Type::colA, Type::colB`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
-     *
-     *
-     * @param [firstCol] A [KProperty] that points to a column.
-     * @param [otherCols] Optional additional [KProperty]s that point to columns.
-     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
-     */
-    public fun <C> ColumnPath.cols(
-        firstCol: KProperty<C>,
-        vararg otherCols: KProperty<C>,
-    ): ColumnSet<C> = colGroup(this).cols(firstCol, *otherCols)
+    private interface KPropertyColsVarargKPropertyDocs
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
-     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
-     * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
-     *
-     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] directly, you can also use the [get][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.get] operator in most cases.
-     *
-     * #### For example:
-     * `df.`[remove][org.jetbrains.kotlinx.dataframe.DataFrame.remove]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[hasNulls][org.jetbrains.kotlinx.dataframe.hasNulls]`() } }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[String][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`1, 3, 5] }`
-     *
-     *
-     * #### Examples for this overload:
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"].`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(Type::colA, Type::colB) }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.select]` { "pathTo"["columnGroup"]`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`Type::colA, Type::colB`[`]`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` }`
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
      *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
      *
-     * @param [firstCol] A [KProperty] that points to a column.
-     * @param [otherCols] Optional additional [KProperty]s that point to columns.
-     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
-     */
-    public operator fun <C> ColumnPath.get(
-        firstCol: KProperty<C>,
-        vararg otherCols: KProperty<C>,
-    ): ColumnSet<C> = cols(firstCol, *otherCols)
-
-    /**
-     * ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
-     * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
-     * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
-     *
-     * Aside from calling [cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols] directly, you can also use the [get][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.get] operator in most cases.
-     *
-     * #### For example:
-     * `df.`[remove][org.jetbrains.kotlinx.dataframe.DataFrame.remove]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]` { it.`[hasNulls][org.jetbrains.kotlinx.dataframe.hasNulls]`() } }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroupCol.`[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(columnA, columnB) }`
-     *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.colsOf]`<`[String][String]`>()`[`[`][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`1, 3, 5] }`
-     *
-     *
-     * #### Examples for this overload:
-     *
-     * `df.`[select][select]` { Type::myColumnGroup.`[cols][cols]`(Type::colA, Type::colB) }`
-     *
-     * `df.`[select][select]` { Type::myColumnGroup`[`[`][cols]`Type::colA, Type::colB`[`]`][cols]` }`
-     *
-     *
-     * @param [firstCol] A [KProperty] that points to a column.
-     * @param [otherCols] Optional additional [KProperty]s that point to columns.
-     * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
-     */
-    private interface KPropertyColsVarargKPropertyDocs
-
-    /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -3769,7 +3607,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     ): ColumnSet<C> = colGroup(this).cols(firstCol, *otherCols)
 
     /** ## Cols
-     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from a parent [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], -[ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], or -[DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+     * Creates a subset of columns ([ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]) from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn]
+     * (and thus consists of only one column (or [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter][org.jetbrains.kotlinx.dataframe.ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][org.jetbrains.kotlinx.dataframe.documentation.AccessApi] (+ [ColumnPath][org.jetbrains.kotlinx.dataframe.columns.ColumnPath]).
      *
@@ -3803,33 +3646,25 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     // region indices
 
-    @Suppress("UNCHECKED_CAST")
     public fun <C> ColumnSet<C>.cols(
         firstIndex: Int,
         vararg otherIndices: Int,
-    ): ColumnSet<C> = transformWithContext {
-        dataFrameOf(it)
-            .asColumnGroup()
-            .cols(firstIndex, *otherIndices)
-            .resolve(this) as List<ColumnWithPath<C>>
-    }
+    ): ColumnSet<C> = colsInternal(headPlusArray(firstIndex, otherIndices)) as ColumnSet<C>
 
     public operator fun <C> ColumnSet<C>.get(
         firstIndex: Int,
         vararg otherIndices: Int,
     ): ColumnSet<C> = cols(firstIndex, *otherIndices)
 
-    public fun SingleColumn<AnyRow>.cols(
+    public fun SingleColumn<*>.cols(
         firstIndex: Int,
         vararg otherIndices: Int,
-    ): ColumnSet<*> = headPlusArray(firstIndex, otherIndices).let { indices ->
-        transform { it.flatMap { it.children().let { children -> indices.map { children[it] } } } }
-    }
+    ): ColumnSet<*> = colsInternal(headPlusArray(firstIndex, otherIndices))
 
     /**
      *
      */
-    public operator fun SingleColumn<AnyRow>.get(
+    public operator fun SingleColumn<*>.get(
         firstIndex: Int,
         vararg otherIndices: Int,
     ): ColumnSet<*> = cols(firstIndex, *otherIndices)
@@ -3844,16 +3679,6 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
         vararg otherIndices: Int,
     ): ColumnSet<*> = cols(firstIndex, *otherIndices)
 
-    public fun ColumnPath.cols(
-        firstIndex: Int,
-        vararg otherIndices: Int,
-    ): ColumnSet<*> = colGroup(this).cols(firstIndex, *otherIndices)
-
-    public operator fun ColumnPath.get(
-        firstIndex: Int,
-        vararg otherIndices: Int,
-    ): ColumnSet<*> = cols(firstIndex, *otherIndices)
-
     public fun KProperty<*>.cols(
         firstIndex: Int,
         vararg otherIndices: Int,
@@ -3868,33 +3693,22 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     // region ranges
 
-    @Suppress("UNCHECKED_CAST")
     public fun <C> ColumnSet<C>.cols(range: IntRange): ColumnSet<C> =
-        transformWithContext {
-            dataFrameOf(it)
-                .asColumnGroup()
-                .cols(range)
-                .resolve(this) as List<ColumnWithPath<C>>
-        }
+        colsInternal(range) as ColumnSet<C>
 
     public operator fun <C> ColumnSet<C>.get(range: IntRange): ColumnSet<C> = cols(range)
 
-    public fun SingleColumn<AnyRow>.cols(range: IntRange): ColumnSet<*> =
-        transform { it.flatMap { it.children().subList(range.first, range.last + 1) } }
+    public fun SingleColumn<*>.cols(range: IntRange): ColumnSet<*> = colsInternal(range)
 
     /**
      *
      */
-    public operator fun SingleColumn<AnyRow>.get(range: IntRange): ColumnSet<*> = cols(range)
+    public operator fun SingleColumn<*>.get(range: IntRange): ColumnSet<*> = cols(range)
 
     public fun String.cols(range: IntRange): ColumnSet<*> = colGroup(this).cols(range)
 
     public operator fun String.get(range: IntRange): ColumnSet<*> = cols(range)
 
-    public fun ColumnPath.cols(range: IntRange): ColumnSet<*> = colGroup(this).cols(range)
-
-    public operator fun ColumnPath.get(range: IntRange): ColumnSet<*> = cols(range)
-
     public fun KProperty<*>.cols(range: IntRange): ColumnSet<*> = colGroup(this).cols(range)
 
     public operator fun KProperty<*>.get(range: IntRange): ColumnSet<*> = cols(range)
@@ -3925,10 +3739,32 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     // region dfs
 
+    @Deprecated(
+        message = "dfs is deprecated, use recursively instead.",
+        replaceWith = ReplaceWith("this.cols(predicate).recursively(includeTopLevel = false)"),
+        level = DeprecationLevel.WARNING,
+    )
     public fun <C> ColumnSet<C>.dfs(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<Any?> = dfsInternal(predicate)
 
+    @Deprecated(
+        message = "dfs is deprecated, use recursively instead.",
+        replaceWith = ReplaceWith("this.cols(predicate).recursively()"),
+        level = DeprecationLevel.WARNING,
+    )
+    public fun SingleColumn<*>.dfs(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<Any?> = dfsInternal(predicate)
+
+    @Deprecated(
+        message = "dfs is deprecated, use recursively instead.",
+        replaceWith = ReplaceWith("this.cols(predicate).recursively()"),
+        level = DeprecationLevel.WARNING,
+    )
     public fun String.dfs(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> = toColumnAccessor().dfs(predicate)
 
+    @Deprecated(
+        message = "dfs is deprecated, use recursively instead.",
+        replaceWith = ReplaceWith("this.cols(predicate).recursively()"),
+        level = DeprecationLevel.WARNING,
+    )
     public fun <C> KProperty<C>.dfs(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> =
         toColumnAccessor().dfs(predicate)
 
@@ -3936,22 +3772,321 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     // region all
 
-    public fun SingleColumn<*>.all(): ColumnSet<*> = transformSingle { it.children() }
+    /**
+     * ## All
+     * Creates a new [ColumnSet] that contains all columns from the current [ColumnSet].
+     *
+     * If the current [ColumnSet] is a [SingleColumn] and consists of only one [column group][ColumnGroup],
+     * then `all` will create a new [ColumnSet] consisting of its children.
+     *
+     * This makes the function equivalent to [cols()][ColumnSet.cols].
+     *
+     * #### For example:
+     * `df.`[move][DataFrame.move]` { `[all][ColumnSet.all]`().`[recursively][recursively]`() }.`[under][MoveClause.under]`("info")`
+     *
+     * `df.`[select][DataFrame.select]` { myGroup.`[all][ColumnSet.all]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * {@includeArg [CommonAllDocs.Examples]}
+     *
+     * @see [cols\]
+     */
+    private interface CommonAllDocs {
 
-    public fun String.all(): ColumnSet<*> = toColumnAccessor().transformSingle { it.children() }
+        /** Example argument */
+        interface Examples
+    }
 
-    public fun KProperty<*>.all(): ColumnSet<*> = toColumnAccessor().transformSingle { it.children() }
+    /**
+     * ## All
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all columns from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] and consists of only one [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup],
+     * then `all` will create a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] consisting of its children.
+     *
+     * This makes the function equivalent to [cols()][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols].
+     *
+     * #### For example:
+     * `df.`[move][org.jetbrains.kotlinx.dataframe.DataFrame.move]` { `[all][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.all]`().`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`() }.`[under][org.jetbrains.kotlinx.dataframe.api.MoveClause.under]`("info")`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroup.`[all][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.all]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][select]` { `[cols][cols]` { "a" in `[name][ColumnWithPath.name]` }.`[all][all]`() }`
+     * ## ‎
+     * NOTE: This is an identity call and can be omitted in most cases. However, it can still prove useful
+     * for readability or in combination with [recursively].
+     *
+     * @see [cols]
+     */
+    public fun <C> ColumnSet<C>.all(): TransformableColumnSet<C> = allInternal()
+
+    /**
+     * ## All
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all columns from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] and consists of only one [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup],
+     * then `all` will create a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] consisting of its children.
+     *
+     * This makes the function equivalent to [cols()][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols].
+     *
+     * #### For example:
+     * `df.`[move][org.jetbrains.kotlinx.dataframe.DataFrame.move]` { `[all][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.all]`().`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`() }.`[under][org.jetbrains.kotlinx.dataframe.api.MoveClause.under]`("info")`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroup.`[all][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.all]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][select]` { `[all][all]`() }`
+     *
+     * `df.`[select][select]` { myGroup.`[all][all]`() }`
+     *
+     * `df.`[select][select]` { "pathTo"["myGroup"].`[all][all]`() }`
+     *
+     * @see [cols]
+     */
+    public fun SingleColumn<*>.all(): TransformableColumnSet<*> = allInternal()
+
+    /**
+     * ## All
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all columns from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] and consists of only one [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup],
+     * then `all` will create a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] consisting of its children.
+     *
+     * This makes the function equivalent to [cols()][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols].
+     *
+     * #### For example:
+     * `df.`[move][org.jetbrains.kotlinx.dataframe.DataFrame.move]` { `[all][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.all]`().`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`() }.`[under][org.jetbrains.kotlinx.dataframe.api.MoveClause.under]`("info")`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroup.`[all][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.all]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][select]` { "myGroupCol".`[all][all]`() }`
+     *
+     * @see [cols]
+     */
+    public fun String.all(): TransformableColumnSet<*> = toColumnAccessor().all()
+
+    /**
+     * ## All
+     * Creates a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] that contains all columns from the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet].
+     *
+     * If the current [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] and consists of only one [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup],
+     * then `all` will create a new [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] consisting of its children.
+     *
+     * This makes the function equivalent to [cols()][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols].
+     *
+     * #### For example:
+     * `df.`[move][org.jetbrains.kotlinx.dataframe.DataFrame.move]` { `[all][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.all]`().`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`() }.`[under][org.jetbrains.kotlinx.dataframe.api.MoveClause.under]`("info")`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myGroup.`[all][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.all]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][select]` { Type::columnGroup.`[all][all]`() }`
+     *
+     * @see [cols]
+     */
+    public fun KProperty<*>.all(): TransformableColumnSet<*> = toColumnAccessor().all()
 
     // region allDfs
 
+    @Deprecated(
+        message = "allDfs is deprecated, use recursively instead.",
+        replaceWith = ReplaceWith("this.cols { includeGroups || !it.isColumnGroup() }.recursively()"),
+        level = DeprecationLevel.WARNING,
+    )
     public fun ColumnSet<*>.allDfs(includeGroups: Boolean = false): ColumnSet<Any?> =
         if (includeGroups) dfs { true } else dfs { !it.isColumnGroup() }
 
+    @Deprecated(
+        message = "allDfs is deprecated, use recursively instead.",
+        replaceWith = ReplaceWith("this.cols { includeGroups || !it.isColumnGroup() }.recursively()"),
+        level = DeprecationLevel.WARNING,
+    )
+    public fun SingleColumn<*>.allDfs(includeGroups: Boolean = false): ColumnSet<Any?> =
+        if (includeGroups) dfs { true } else dfs { !it.isColumnGroup() }
+
+    @Deprecated(
+        message = "allDfs is deprecated, use recursively instead.",
+        replaceWith = ReplaceWith("this.cols { includeGroups || !it.isColumnGroup() }.recursively()"),
+        level = DeprecationLevel.WARNING,
+    )
     public fun String.allDfs(includeGroups: Boolean = false): ColumnSet<Any?> = toColumnAccessor().allDfs(includeGroups)
 
+    @Deprecated(
+        message = "allDfs is deprecated, use recursively instead.",
+        replaceWith = ReplaceWith("this.cols { includeGroups || !it.isColumnGroup() }.recursively()"),
+        level = DeprecationLevel.WARNING,
+    )
     public fun KProperty<*>.allDfs(includeGroups: Boolean = false): ColumnSet<Any?> =
         toColumnAccessor().allDfs(includeGroups)
 
+    /**
+     * ## Recursively / Rec
+     *
+     * Modifies the previous call to run not only on the current column set,
+     * but also on all columns inside [column groups][ColumnGroup].
+     *
+     * `df.`[select][DataFrame.select]` { `[colsOf][ColumnSet.colsOf]`<`[String][String]`>() }`
+     *
+     * returns all columns of type [String] in the top-level, as expected. However, what if you want ALL
+     * columns of type [String] even if they are inside a nested [column group][ColumnGroup]? Then you can use [recursively]:
+     *
+     * `df.`[select][DataFrame.select]` { `[colsOf][ColumnSet.colsOf]`<`[String][String]`>().`[recursively][recursively]`() }`
+     *
+     * This will return the columns of type [String] in all levels.
+     *
+     * More examples:
+     *
+     * `df.`[select][DataFrame.select]` { `[first][ColumnSet.first]` { col -> col.`[any][DataColumn.any]` { it == "Alice" } }.`[recursively][recursively]`() }`
+     *
+     * `df.`[select][DataFrame.select]` { `[cols][ColumnSet.cols]` { "name" in it.`[name][ColumnReference.name]` }.`[recursively][recursively]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * {@includeArg [CommonRecursivelyDocs.Examples]}
+     *
+     * @param [includeTopLevel\] Whether to include the top-level columns in the result. `true` by default.
+     */
+    private interface CommonRecursivelyDocs {
+
+        /** Example argument */
+        interface Examples
+    }
+
+    /**
+     * ## Recursively / Rec
+     *
+     * Modifies the previous call to run not only on the current column set,
+     * but also on all columns inside [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsOf]`<`[String][String]`>() }`
+     *
+     * returns all columns of type [String] in the top-level, as expected. However, what if you want ALL
+     * columns of type [String] even if they are inside a nested [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]? Then you can use [recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsOf]`<`[String][String]`>().`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`() }`
+     *
+     * This will return the columns of type [String] in all levels.
+     *
+     * More examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[first][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.first]` { col -> col.`[any][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } }.`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` { "name" in it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]` }.`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { `[colsOf][ColumnSet.colsOf]`<`[String][String]`>().`[recursively][recursively]`() }`
+     *
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[all][ColumnSet.all]`().`[rec][rec]`() }`
+     *
+     * `df.`[select][DataFrame.select]` { `[groups][ColumnSet.groups]`().`[recursively][recursively]`() }`
+     *
+     * @param [includeTopLevel] Whether to include the top-level columns in the result. `true` by default.
+     */
+    public fun <C> TransformableColumnSet<C>.recursively(): ColumnSet<C> =
+        recursivelyImpl(includeTopLevel = true, includeGroups = true)
+
+    /** ## Recursively / Rec
+     *
+     * Modifies the previous call to run not only on the current column set,
+     * but also on all columns inside [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsOf]`<`[String][String]`>() }`
+     *
+     * returns all columns of type [String] in the top-level, as expected. However, what if you want ALL
+     * columns of type [String] even if they are inside a nested [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]? Then you can use [recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsOf]`<`[String][String]`>().`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`() }`
+     *
+     * This will return the columns of type [String] in all levels.
+     *
+     * More examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[first][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.first]` { col -> col.`[any][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } }.`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` { "name" in it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]` }.`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsOf]`<`[String][String]`>().`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[all][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.all]`().`[rec][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.rec]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[groups][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.groups]`().`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`() }`
+     *
+     * @param [includeTopLevel] Whether to include the top-level columns in the result. `true` by default.
+     */
+    public fun <C> TransformableColumnSet<C>.rec(): ColumnSet<C> = recursively()
+
+    /**
+     * ## Recursively / Rec
+     *
+     * Modifies the previous call to run not only on the current column set,
+     * but also on all columns inside [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsOf]`<`[String][String]`>() }`
+     *
+     * returns all columns of type [String] in the top-level, as expected. However, what if you want ALL
+     * columns of type [String] even if they are inside a nested [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]? Then you can use [recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsOf]`<`[String][String]`>().`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`() }`
+     *
+     * This will return the columns of type [String] in all levels.
+     *
+     * More examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[first][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.first]` { col -> col.`[any][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } }.`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` { "name" in it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]` }.`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][DataFrame.select]` { `[first][ColumnSet.first]` { col -> col.`[any][DataColumn.any]` { it == "Alice" } }.`[recursively][recursively]`() }`
+     *
+     * `df.`[select][DataFrame.select]` { `[single][ColumnSet.single]` { it.name == "myCol" }.`[rec][rec]`() }`
+     *
+     * @param [includeTopLevel] Whether to include the top-level columns in the result. `true` by default.
+     */
+    public fun TransformableSingleColumn<*>.recursively(): SingleColumn<*> =
+        recursivelyImpl(includeTopLevel = true, includeGroups = true)
+
+    /** ## Recursively / Rec
+     *
+     * Modifies the previous call to run not only on the current column set,
+     * but also on all columns inside [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup].
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsOf]`<`[String][String]`>() }`
+     *
+     * returns all columns of type [String] in the top-level, as expected. However, what if you want ALL
+     * columns of type [String] even if they are inside a nested [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]? Then you can use [recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsOf]`<`[String][String]`>().`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`() }`
+     *
+     * This will return the columns of type [String] in all levels.
+     *
+     * More examples:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[first][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.first]` { col -> col.`[any][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } }.`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[cols][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.cols]` { "name" in it.`[name][org.jetbrains.kotlinx.dataframe.columns.ColumnReference.name]` }.`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[first][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.first]` { col -> col.`[any][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } }.`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`() }`
+     *
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[single][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.single]` { it.name == "myCol" }.`[rec][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.rec]`() }`
+     *
+     * @param [includeTopLevel] Whether to include the top-level columns in the result. `true` by default.
+     */
+    public fun TransformableSingleColumn<*>.rec(): SingleColumn<*> = recursively()
+
     // endregion
 
     // region allAfter
@@ -4085,68 +4220,129 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     // endregion
 
     // region groups
+    public fun ColumnSet<*>.groups(filter: (ColumnGroup<*>) -> Boolean = { true }): TransformableColumnSet<AnyRow> =
+        groupsInternal(filter)
 
-    public fun SingleColumn<*>.groups(filter: (ColumnGroup<*>) -> Boolean = { true }): ColumnSet<AnyRow> =
-        children { it.isColumnGroup() && filter(it.asColumnGroup()) } as ColumnSet<AnyRow>
+    public fun SingleColumn<*>.groups(filter: (ColumnGroup<*>) -> Boolean = { true }): TransformableColumnSet<AnyRow> =
+        groupsInternal(filter)
 
-    public fun String.groups(filter: (ColumnGroup<*>) -> Boolean = { true }): ColumnSet<AnyRow> =
+    public fun String.groups(filter: (ColumnGroup<*>) -> Boolean = { true }): TransformableColumnSet<AnyRow> =
         toColumnAccessor().groups(filter)
 
-    public fun KProperty<*>.groups(filter: (ColumnGroup<*>) -> Boolean = { true }): ColumnSet<AnyRow> =
+    public fun KProperty<*>.groups(filter: (ColumnGroup<*>) -> Boolean = { true }): TransformableColumnSet<AnyRow> =
         toColumnAccessor().groups(filter)
 
     // endregion
 
     // region children
 
-    public fun ColumnSet<*>.children(predicate: (ColumnWithPath<Any?>) -> Boolean = { true }): ColumnSet<Any?> =
+    // takes children of all columns in the column set
+    public fun ColumnSet<*>.children(predicate: ColumnFilter<Any?> = { true }): TransformableColumnSet<Any?> =
         transform { it.flatMap { it.children().filter { predicate(it) } } }
 
-    public fun ColumnGroupReference.children(): ColumnSet<Any?> = transformSingle { it.children() }
+    // same as cols
+    public fun SingleColumn<*>.children(predicate: ColumnFilter<Any?> = { true }): TransformableColumnSet<Any?> =
+        (this as ColumnSet<*>).children(predicate)
 
     // endregion
 
     public operator fun <C> List<DataColumn<C>>.get(range: IntRange): ColumnSet<C> =
         ColumnsList(subList(range.first, range.last + 1))
 
-    public fun SingleColumn<AnyRow>.take(n: Int): ColumnSet<*> = transformSingle { it.children().take(n) }
-    public fun SingleColumn<AnyRow>.takeLast(n: Int): ColumnSet<*> = transformSingle { it.children().takeLast(n) }
-    public fun SingleColumn<AnyRow>.drop(n: Int): ColumnSet<*> = transformSingle { it.children().drop(n) }
-    public fun SingleColumn<AnyRow>.dropLast(n: Int = 1): ColumnSet<*> = transformSingle { it.children().dropLast(n) }
+    public fun SingleColumn<*>.take(n: Int): ColumnSet<*> = transformSingle { it.children().take(n) }
+    public fun SingleColumn<*>.takeLast(n: Int): ColumnSet<*> = transformSingle { it.children().takeLast(n) }
+    public fun SingleColumn<*>.drop(n: Int): ColumnSet<*> = transformSingle { it.children().drop(n) }
+    public fun SingleColumn<*>.dropLast(n: Int = 1): ColumnSet<*> = transformSingle { it.children().dropLast(n) }
 
     public fun <C> ColumnSet<C>.drop(n: Int): ColumnSet<C> = transform { it.drop(n) }
     public fun <C> ColumnSet<C>.take(n: Int): ColumnSet<C> = transform { it.take(n) }
     public fun <C> ColumnSet<C>.dropLast(n: Int = 1): ColumnSet<C> = transform { it.dropLast(n) }
     public fun <C> ColumnSet<C>.takeLast(n: Int): ColumnSet<C> = transform { it.takeLast(n) }
-    public fun <C> ColumnSet<C>.top(): ColumnSet<C> = transform { it.top() }
-    public fun <C> ColumnSet<C>.takeWhile(predicate: Predicate<ColumnWithPath<C>>): ColumnSet<C> =
+
+    @Deprecated("Use roots() instead", ReplaceWith("roots()"))
+    public fun <C> ColumnSet<C>.top(): ColumnSet<C> = roots()
+
+    /**
+     * ## Roots
+     *
+     * Returns a sub-set of columns that are roots of the trees of columns.
+     *
+     * In practice, this means that if a column in [this] is a child of another column in [this],
+     * it will not be included in the result.
+     *
+     * If [this] is a [SingleColumn] containing a single [ColumnGroup] it will run on the children of that group,
+     * else it simply runs on the columns in the [ColumnSet] itself.
+     */
+    public fun <C> ColumnSet<C>.roots(): ColumnSet<C> = rootsInternal() as ColumnSet<C>
+
+    /**
+     * ## Roots
+     *
+     * Returns a sub-set of columns that are roots of the trees of columns.
+     *
+     * In practice, this means that if a column in [this] is a child of another column in [this],
+     * it will not be included in the result.
+     *
+     * If [this] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing a single [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] it will run on the children of that group,
+     * else it simply runs on the columns in the [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] itself.
+     */
+    public fun SingleColumn<*>.roots(): ColumnSet<*> = rootsInternal()
+
+    public fun <C> ColumnSet<C>.takeWhile(predicate: ColumnFilter<C>): ColumnSet<C> =
         transform { it.takeWhile(predicate) }
 
-    public fun <C> ColumnSet<C>.takeLastWhile(predicate: Predicate<ColumnWithPath<C>>): ColumnSet<C> =
+    public fun <C> ColumnSet<C>.takeLastWhile(predicate: ColumnFilter<C>): ColumnSet<C> =
         transform { it.takeLastWhile(predicate) }
 
-    public fun <C> ColumnSet<C>.filter(predicate: Predicate<ColumnWithPath<C>>): ColumnSet<C> =
-        transform { it.filter(predicate) }
+    public fun <C> ColumnSet<C>.filter(predicate: ColumnFilter<C>): TransformableColumnSet<C> =
+        colsInternal(predicate as ColumnFilter<*>) as TransformableColumnSet<C>
+
+    public fun SingleColumn<*>.nameContains(text: CharSequence): TransformableColumnSet<*> =
+        cols { it.name.contains(text) }
+
+    public fun <C> ColumnSet<C>.nameContains(text: CharSequence): TransformableColumnSet<C> =
+        cols { it.name.contains(text) }
 
-    public fun SingleColumn<AnyRow>.nameContains(text: CharSequence): ColumnSet<*> = cols { it.name.contains(text) }
-    public fun <C> ColumnSet<C>.nameContains(text: CharSequence): ColumnSet<C> = cols { it.name.contains(text) }
-    public fun SingleColumn<AnyRow>.nameContains(regex: Regex): ColumnSet<*> = cols { it.name.contains(regex) }
-    public fun <C> ColumnSet<C>.nameContains(regex: Regex): ColumnSet<C> = cols { it.name.contains(regex) }
-    public fun SingleColumn<AnyRow>.startsWith(prefix: CharSequence): ColumnSet<*> = cols { it.name.startsWith(prefix) }
-    public fun <C> ColumnSet<C>.startsWith(prefix: CharSequence): ColumnSet<C> = cols { it.name.startsWith(prefix) }
-    public fun SingleColumn<AnyRow>.endsWith(suffix: CharSequence): ColumnSet<*> = cols { it.name.endsWith(suffix) }
-    public fun <C> ColumnSet<C>.endsWith(suffix: CharSequence): ColumnSet<C> = cols { it.name.endsWith(suffix) }
+    public fun SingleColumn<*>.nameContains(regex: Regex): TransformableColumnSet<*> = cols { it.name.contains(regex) }
 
-    public fun <C> ColumnSet<C>.except(vararg other: ColumnSet<*>): ColumnSet<*> = except(other.toColumnSet())
-    public fun <C> ColumnSet<C>.except(vararg other: String): ColumnSet<*> = except(other.toColumnSet())
+    public fun <C> ColumnSet<C>.nameContains(regex: Regex): TransformableColumnSet<C> = cols { it.name.contains(regex) }
 
-    public fun <C> ColumnSet<C?>.withoutNulls(): ColumnSet<C> = transform { it.filter { !it.hasNulls } } as ColumnSet<C>
+    public fun SingleColumn<*>.startsWith(prefix: CharSequence): TransformableColumnSet<*> =
+        cols { it.name.startsWith(prefix) }
 
-    public infix fun <C> ColumnSet<C>.except(other: ColumnSet<*>): ColumnSet<*> =
-        createColumnSet { resolve(it).allColumnsExcept(other.resolve(it)) }
+    public fun <C> ColumnSet<C>.startsWith(prefix: CharSequence): TransformableColumnSet<C> =
+        cols { it.name.startsWith(prefix) }
 
-    public infix fun <C> ColumnSet<C>.except(selector: ColumnsSelector<T, *>): ColumnSet<C> =
-        except(selector.toColumns()) as ColumnSet<C>
+    public fun SingleColumn<*>.endsWith(suffix: CharSequence): TransformableColumnSet<*> =
+        cols { it.name.endsWith(suffix) }
+
+    public fun <C> ColumnSet<C>.endsWith(suffix: CharSequence): TransformableColumnSet<C> =
+        cols { it.name.endsWith(suffix) }
+
+    public fun <C> ColumnSet<C>.except(vararg other: ColumnSet<*>): TransformableColumnSet<*> =
+        except(other.toColumnSet())
+
+    public fun <C> ColumnSet<C>.except(vararg other: String): TransformableColumnSet<*> = except(other.toColumnSet())
+
+    public fun <C> ColumnSet<C?>.withoutNulls(): TransformableColumnSet<C> =
+        transform { it.filter { !it.hasNulls() } } as TransformableColumnSet<C>
+
+    public infix fun <C> ColumnSet<C>.except(other: ColumnSet<*>): TransformableColumnSet<*> =
+        createTransformableColumnSet(
+            resolver = { context ->
+                this@except
+                    .resolve(context)
+                    .allColumnsExcept(other.resolve(context))
+            },
+            transformResolve = { context, transformer ->
+                transformer.transform(this@except)
+                    .resolve(context)
+                    .allColumnsExcept(other.resolve(context))
+            },
+        )
+
+    public infix fun <C> ColumnSet<C>.except(selector: ColumnsSelector<T, *>): TransformableColumnSet<C> =
+        except(selector.toColumns()) as TransformableColumnSet<C>
 
     public operator fun <C> ColumnsSelector<T, C>.invoke(): ColumnSet<C> =
         this(this@ColumnsSelectionDsl, this@ColumnsSelectionDsl)
@@ -4224,9 +4420,25 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     public fun <C> ColumnSet<C>.distinct(): ColumnSet<C> = DistinctColumnSet(this)
 
+    @Deprecated(
+        message = "Use recursively() instead",
+        replaceWith = ReplaceWith(
+            "this.colsOf(type, predicate).recursively()",
+            "org.jetbrains.kotlinx.dataframe.columns.recursively",
+            "org.jetbrains.kotlinx.dataframe.api.colsOf",
+        ),
+    )
     public fun <C> String.dfsOf(type: KType, predicate: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<*> =
         toColumnAccessor().dfsOf(type, predicate)
 
+    @Deprecated(
+        message = "Use recursively() instead",
+        replaceWith = ReplaceWith(
+            "this.colsOf(type, predicate).recursively()",
+            "org.jetbrains.kotlinx.dataframe.columns.recursively",
+            "org.jetbrains.kotlinx.dataframe.api.colsOf",
+        ),
+    )
     public fun <C> KProperty<*>.dfsOf(type: KType, predicate: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<*> =
         toColumnAccessor().dfsOf(type, predicate)
 
@@ -4335,18 +4547,101 @@ public inline fun <T, reified R> ColumnsSelectionDsl<T>.expr(
 internal fun <T, C> ColumnsSelector<T, C>.filter(predicate: (ColumnWithPath<C>) -> Boolean): ColumnsSelector<T, C> =
     { this@filter(it, it).filter(predicate) }
 
-internal fun ColumnSet<*>.colsInternal(predicate: ColumnFilter<*>) =
-    transform { it.flatMap { it.children().filter { predicate(it) } } }
+/**
+ * If this [ColumnSet] is a [SingleColumn], it
+ * returns a new [ColumnSet] containing the children of this [SingleColumn] that
+ * match the given [predicate].
+ *
+ * Else, it returns a new [ColumnSet] containing all columns in this [ColumnSet] that
+ * match the given [predicate].
+ */
+internal fun ColumnSet<*>.colsInternal(predicate: ColumnFilter<*>): TransformableColumnSet<*> =
+    allInternal().transform { it.filter(predicate) }
 
-internal fun ColumnSet<*>.dfsInternal(predicate: (ColumnWithPath<*>) -> Boolean) =
-    transform { it.filter { it.isColumnGroup() }.flatMap { it.children().dfs().filter(predicate) } }
+internal fun ColumnSet<*>.colsInternal(indices: IntArray): TransformableColumnSet<*> =
+    allInternal().transform { cols ->
+        indices.map { cols[it] }
+    }
 
+internal fun ColumnSet<*>.colsInternal(range: IntRange): TransformableColumnSet<*> =
+    allInternal().transform {
+        it.subList(range.first, range.last + 1)
+    }
+
+internal fun ColumnSet<*>.rootsInternal(): ColumnSet<*> =
+    allInternal().transform { it.roots() }
+
+internal fun ColumnSet<*>.groupsInternal(filter: (ColumnGroup<*>) -> Boolean): TransformableColumnSet<AnyRow> =
+    colsInternal { it.isColumnGroup() && filter(it.asColumnGroup()) } as TransformableColumnSet<AnyRow>
+
+/**
+ * If [this] is a [SingleColumn] containing a single [ColumnGroup], it
+ * returns a [(transformable) ColumnSet][TransformableColumnSet] containing the children of this [ColumnGroup],
+ * else it simply returns a [(transformable) ColumnSet][TransformableColumnSet] from [this].
+ */
+internal fun <C> ColumnSet<C>.allInternal(): TransformableColumnSet<C> =
+    transform {
+        if (this.isSingleColumnWithGroup(it)) {
+            it.single().children()
+        } else {
+            it
+        }
+    }.cast()
+
+/** If [this] is a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] containing a single [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup], it
+ * returns a [(transformable) ColumnSet][org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet] containing the children of this [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup],
+ * else it simply returns a [(transformable) ColumnSet][org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet] from [this]. */
+internal fun SingleColumn<*>.allInternal(): TransformableColumnSet<*> =
+    (this as ColumnSet<*>).allInternal()
+
+@Deprecated("Replaced with recursively()")
+internal fun ColumnSet<*>.dfsInternal(predicate: (ColumnWithPath<*>) -> Boolean) =
+    transform { it.filter { it.isColumnGroup() }.flatMap { it.children().flattenRecursively().filter(predicate) } }
+
+@Deprecated(
+    message = "Use recursively() instead",
+    replaceWith = ReplaceWith(
+        "this.colsOf(type, predicate).recursively()",
+        "org.jetbrains.kotlinx.dataframe.columns.recursively",
+        "org.jetbrains.kotlinx.dataframe.api.colsOf",
+    ),
+)
 public fun <C> ColumnSet<*>.dfsOf(type: KType, predicate: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<*> =
     dfsInternal { it.isSubtypeOf(type) && predicate(it.cast()) }
 
+@Deprecated(
+    message = "Use recursively() instead",
+    replaceWith = ReplaceWith(
+        "this.colsOf(type, predicate).recursively()",
+        "org.jetbrains.kotlinx.dataframe.columns.recursively",
+        "org.jetbrains.kotlinx.dataframe.api.colsOf",
+    ),
+)
+public fun <C> SingleColumn<*>.dfsOf(type: KType, predicate: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<*> =
+    dfsInternal { it.isSubtypeOf(type) && predicate(it.cast()) }
+
+@Deprecated(
+    message = "Use recursively() instead",
+    replaceWith = ReplaceWith(
+        "this.colsOf<C>(filter).recursively(includeTopLevel = false)",
+        "org.jetbrains.kotlinx.dataframe.columns.recursively",
+        "org.jetbrains.kotlinx.dataframe.api.colsOf",
+    ),
+)
 public inline fun <reified C> ColumnSet<*>.dfsOf(noinline filter: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<C> =
     dfsOf(typeOf<C>(), filter) as ColumnSet<C>
 
+@Deprecated(
+    message = "Use recursively() instead",
+    replaceWith = ReplaceWith(
+        "this.colsOf<C>(filter).recursively()",
+        "org.jetbrains.kotlinx.dataframe.columns.recursively",
+        "org.jetbrains.kotlinx.dataframe.api.colsOf",
+    ),
+)
+public inline fun <reified C> SingleColumn<*>.dfsOf(noinline filter: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<C> =
+    dfsOf(typeOf<C>(), filter) as ColumnSet<C>
+
 /**
  * ## Cols Of
  * Get columns by a given type and an optional filter.
@@ -4449,8 +4744,96 @@ private interface CommonColsOfDocs {
  * @param [filter] an optional filter function that takes a column of type [C] and returns `true` if the column should be included.
  * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns of given type that were included by [filter].
  */
-public fun <C> ColumnSet<*>.colsOf(type: KType, filter: (DataColumn<C>) -> Boolean = { true }): ColumnSet<C> =
-    colsInternal { it.isSubtypeOf(type) && filter(it.cast()) } as ColumnSet<C>
+public fun <C> ColumnSet<*>.colsOf(
+    type: KType,
+    filter: (DataColumn<C>) -> Boolean = { true },
+): TransformableColumnSet<C> =
+    colsInternal { it.isSubtypeOf(type) && filter(it.cast()) } as TransformableColumnSet<C>
+
+/**
+ * ## Cols Of
+ * Get columns by a given type and an optional filter.
+ *
+ * #### For example:
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ * ## ‎
+ * Alternatively, [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf] can also be called on existing columns:
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup"<Type>().`[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { (Type::myColumnGroup)().`[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
+ * ## ‎
+ * Finally, [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf] can also take a [KType] argument instead of a reified type.
+ * This is useful when the type is not known at compile time or when the API function cannot be inlined.
+ *
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][org.jetbrains.kotlinx.dataframe.DataColumn]`<`[Int][Int]`> -> it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ * ## This Cols Of Overload
+ * Get (sub-)columns by a given type with or without [filter].
+ * #### For example:
+ *
+ * `df.`[select][DataFrame.select]` { `[colsOf][colsOf]`<`[Int][Int]`>() }`
+ *
+ * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][colsOf]`<`[Int][Int]`> { it.`[size][DataColumn.size]` > 10 } }`
+ *
+ * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][colsOf]`<`[Int][Int]`>() }`
+ *
+ * @param [filter] an optional filter function that takes a column of type [C] and returns `true` if the column should be included.
+ * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns of given type that were included by [filter].
+ */
+public inline fun <reified C> ColumnSet<*>.colsOf(noinline filter: (DataColumn<C>) -> Boolean = { true }): TransformableColumnSet<C> =
+    colsOf(typeOf<C>(), filter)
+
+/**
+ * ## Cols Of
+ * Get columns by a given type and an optional filter.
+ *
+ * #### For example:
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ * ## ‎
+ * Alternatively, [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf] can also be called on existing columns:
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`>() }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup"<Type>().`[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Int][Int]`> { it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { (Type::myColumnGroup)().`[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
+ * ## ‎
+ * Finally, [colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf] can also take a [KType] argument instead of a reified type.
+ * This is useful when the type is not known at compile time or when the API function cannot be inlined.
+ *
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+ *
+ * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { "myColumnGroup".`[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][org.jetbrains.kotlinx.dataframe.DataColumn]`<`[Int][Int]`> -> it.`[size][org.jetbrains.kotlinx.dataframe.DataColumn.size]` > 10 } }`
+ * ## This Cols Of Overload
+ * Get (sub-)columns by [type] with or without [filter].
+ * #### For example:
+ *
+ * `df.`[select][DataFrame.select]` { `[colsOf][colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+ *
+ * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }`
+ *
+ * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+ *
+ * @param [filter] an optional filter function that takes a column of type [C] and returns `true` if the column should be included.
+ * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns of given type that were included by [filter].
+ */
+public fun <C> SingleColumn<*>.colsOf(
+    type: KType,
+    filter: (DataColumn<C>) -> Boolean = { true },
+): TransformableColumnSet<C> =
+    colsInternal { it.isSubtypeOf(type) && filter(it.cast()) } as TransformableColumnSet<C>
 
 /**
  * ## Cols Of
@@ -4490,7 +4873,7 @@ public fun <C> ColumnSet<*>.colsOf(type: KType, filter: (DataColumn<C>) -> Boole
  * @param [filter] an optional filter function that takes a column of type [C] and returns `true` if the column should be included.
  * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns of given type that were included by [filter].
  */
-public inline fun <reified C> ColumnSet<*>.colsOf(noinline filter: (DataColumn<C>) -> Boolean = { true }): ColumnSet<C> =
+public inline fun <reified C> SingleColumn<*>.colsOf(noinline filter: (DataColumn<C>) -> Boolean = { true }): TransformableColumnSet<C> =
     colsOf(typeOf<C>(), filter)
 
 /* TODO: [Issue: #325, context receiver support](https://github.com/Kotlin/dataframe/issues/325)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt
index 921fdd412..a77aa4c62 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt
@@ -1,3 +1,5 @@
+@file:Suppress("UNCHECKED_CAST")
+
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyCol
@@ -15,6 +17,8 @@ import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
 import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
 import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
 import org.jetbrains.kotlinx.dataframe.impl.api.convertToImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableSingleColumn
 import kotlin.reflect.typeOf
 
 public fun <T> AnyFrame.cast(): DataFrame<T> = this as DataFrame<T>
@@ -44,6 +48,10 @@ public fun <T> ColumnAccessor<*>.cast(): ColumnAccessor<T> = this as ColumnAcces
 
 public fun <C> ColumnSet<*>.cast(): ColumnSet<C> = this as ColumnSet<C>
 
+public fun <C> TransformableColumnSet<*>.cast(): TransformableColumnSet<C> = this as TransformableColumnSet<C>
+
 public fun <C> ColumnReference<*>.cast(): ColumnReference<C> = this as ColumnReference<C>
 
 public fun <C> SingleColumn<*>.cast(): SingleColumn<C> = this as SingleColumn<C>
+
+public fun <C> TransformableSingleColumn<*>.cast(): TransformableSingleColumn<C> = this as TransformableSingleColumn<C>
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt
index 0e9cb3198..3212310ad 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt
@@ -18,7 +18,7 @@ public data class Corr<T, C>(
     internal val columns: ColumnsSelector<T, C>,
 )
 
-public fun <T> DataFrame<T>.corr(): DataFrame<T> = corr { dfs { it.isSuitableForCorr() } }.withItself()
+public fun <T> DataFrame<T>.corr(): DataFrame<T> = corr { cols { it.isSuitableForCorr() }.rec() }.withItself()
 
 public fun <T, C> DataFrame<T>.corr(columns: ColumnsSelector<T, C>): Corr<T, C> = Corr(this, columns)
 public fun <T> DataFrame<T>.corr(vararg columns: String): Corr<T, Any?> = corr { columns.toColumnSet() }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt
index ec2d861a7..40d929b4f 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt
@@ -52,7 +52,9 @@ public fun <T> DataFrame<T>.cumSum(
 public fun <T> DataFrame<T>.cumSum(vararg columns: KProperty<*>, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> =
     cumSum(skipNA) { columns.toColumnSet() }
 
-public fun <T> DataFrame<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) { allDfs() }
+public fun <T> DataFrame<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) {
+    cols { !it.isColumnGroup() }.recursively()
+}
 
 // endregion
 
@@ -77,7 +79,8 @@ public fun <T, G> GroupBy<T, G>.cumSum(
     skipNA: Boolean = defaultCumSumSkipNA,
 ): GroupBy<T, G> = cumSum(skipNA) { columns.toColumnSet() }
 
-public fun <T, G> GroupBy<T, G>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> =
-    cumSum(skipNA) { allDfs() }
+public fun <T, G> GroupBy<T, G>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> = cumSum(skipNA) {
+    cols { !it.isColumnGroup() }.recursively()
+}
 
 // endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt
index 793dc2f87..11615b113 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt
@@ -39,7 +39,7 @@ public fun <T> DataColumn<T>.describe(): DataFrame<ColumnDescription> = describe
 
 // region DataFrame
 
-public fun <T> DataFrame<T>.describe(): DataFrame<ColumnDescription> = describe { allDfs() }
+public fun <T> DataFrame<T>.describe(): DataFrame<ColumnDescription> = describe { cols { !it.isColumnGroup() }.recursively() }
 
 public fun <T> DataFrame<T>.describe(columns: ColumnsSelector<T, *>): DataFrame<ColumnDescription> =
     describeImpl(getColumnsWithPaths(columns))
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt
index a816fde4b..43214008f 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt
@@ -10,7 +10,7 @@ import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.api.explodeImpl
 import kotlin.reflect.KProperty
 
-private val defaultExplodeColumns: ColumnsSelector<*, *> = { dfs { it.isList() || it.isFrameColumn() } }
+private val defaultExplodeColumns: ColumnsSelector<*, *> = { cols { it.isList() || it.isFrameColumn() }.rec() }
 
 // region explode DataFrame
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt
index 8453af76f..3e28c405c 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt
@@ -14,7 +14,7 @@ public fun AnyCol.inferType(): DataColumn<*> = guessColumnType(name, toList(), t
 
 // region DataFrame
 
-public fun <T> DataFrame<T>.inferType(): DataFrame<T> = inferType { allDfs() }
+public fun <T> DataFrame<T>.inferType(): DataFrame<T> = inferType { cols { !it.isColumnGroup() }.recursively() }
 
 public fun <T> DataFrame<T>.inferType(columns: ColumnsSelector<T, *>): DataFrame<T> =
     replace(columns).with { it.inferType() }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt
index 25fb9147a..6fd14236b 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt
@@ -2,11 +2,7 @@ package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.ColumnsContainer
 import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
-import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.*
 import org.jetbrains.kotlinx.dataframe.impl.api.joinImpl
 import kotlin.reflect.KProperty
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/parse.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/parse.kt
index e4d086f18..a60747a77 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/parse.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/parse.kt
@@ -55,7 +55,9 @@ public data class ParserOptions(
 
 public fun DataColumn<String?>.tryParse(options: ParserOptions? = null): DataColumn<*> = tryParseImpl(options)
 
-public fun <T> DataFrame<T>.parse(options: ParserOptions? = null): DataFrame<T> = parse(options) { allDfs() }
+public fun <T> DataFrame<T>.parse(options: ParserOptions? = null): DataFrame<T> = parse(options) {
+    cols { !it.isColumnGroup() }.recursively()
+}
 
 public fun DataColumn<String?>.parse(options: ParserOptions? = null): DataColumn<*> =
     tryParse(options).also { if (it.typeClass == String::class) error("Can't guess column type") }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt
index 2b8c88cb2..1c06afae9 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt
@@ -42,28 +42,29 @@ public fun <T, C> DataFrame<T>.rename(cols: Iterable<ColumnReference<C>>): Renam
 
 public data class RenameClause<T, C>(val df: DataFrame<T>, val columns: ColumnsSelector<T, C>)
 
-public fun <T> DataFrame<T>.renameToCamelCase(): DataFrame<T> {
+public fun <T> DataFrame<T>.renameToCamelCase(): DataFrame<T> = this
     // recursively rename all column groups to camel case
-    return rename {
-        dfs { it.isColumnGroup() && it.name() matches DELIMITED_STRING_REGEX }
+    .rename {
+        groups { it.name() matches DELIMITED_STRING_REGEX }.recursively()
     }.toCamelCase()
-        // recursively rename all other columns to camel case
-        .rename {
-            dfs { !it.isColumnGroup() && it.name() matches DELIMITED_STRING_REGEX }
-        }.toCamelCase()
-
-        // take all frame columns recursively and call renameToCamelCase() on all dataframes inside
-        .update {
-            dfsOf<AnyFrame>()
-        }.with { it.renameToCamelCase() }
-
-        // convert all first chars of all columns to the lowercase
-        .rename {
-            allDfs()
-        }.into {
-            it.name.replaceFirstChar { it.lowercaseChar() }
-        }
-}
+
+    // recursively rename all other columns to camel case
+    .rename {
+        cols { !it.isColumnGroup() && it.name() matches DELIMITED_STRING_REGEX }.recursively()
+    }.toCamelCase()
+
+    // take all frame columns recursively and call renameToCamelCase() on all dataframes inside
+    .update {
+        colsOf<AnyFrame>().recursively()
+    }.with { it.renameToCamelCase() }
+
+    // convert all first chars of all columns to the lowercase
+    .rename {
+        cols { !it.isColumnGroup() }.recursively()
+    }.into {
+        it.name.replaceFirstChar { it.lowercaseChar() }
+    }
+
 
 public fun <T, C> RenameClause<T, C>.into(vararg newColumns: ColumnReference<*>): DataFrame<T> =
     into(*newColumns.map { it.name() }.toTypedArray())
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
index ca32ebd92..0f6672e17 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
@@ -39,12 +39,17 @@ public fun <T, C, V : Comparable<V>> Reorder<T, C>.byDesc(expression: ColumnExpr
     reorderImpl(true, expression)
 
 public fun <T, V : Comparable<V>> DataFrame<T>.reorderColumnsBy(
-    dfs: Boolean = true,
+    recursively: Boolean = true,
     desc: Boolean = false,
     expression: Selector<AnyCol, V>,
-): DataFrame<T> = Reorder(this, { if (dfs) allDfs(true) else all() }, dfs).reorderImpl(desc, expression)
-
-public fun <T> DataFrame<T>.reorderColumnsByName(dfs: Boolean = true, desc: Boolean = false): DataFrame<T> =
-    reorderColumnsBy(dfs, desc) { name() }
+): DataFrame<T> =
+    Reorder(
+        df = this,
+        columns = { if (recursively) all().recursively() else all() },
+        inFrameColumns = recursively,
+    ).reorderImpl(desc, expression)
+
+public fun <T> DataFrame<T>.reorderColumnsByName(recursively: Boolean = true, desc: Boolean = false): DataFrame<T> =
+    reorderColumnsBy(recursively, desc) { name() }
 
 // endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt
index 0905c0f18..4e2d27e99 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt
@@ -38,7 +38,7 @@ public fun <T, C> DataFrame<T>.replace(columns: Iterable<ColumnReference<C>>): R
 
 public fun <T> DataFrame<T>.replaceAll(
     vararg valuePairs: Pair<Any?, Any?>,
-    columns: ColumnsSelector<T, *> = { allDfs() },
+    columns: ColumnsSelector<T, *> = { cols { !it.isColumnGroup() }.recursively() },
 ): DataFrame<T> {
     val map = valuePairs.toMap()
     return update(columns).with { map[it] ?: it }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
index c03c68178..0cd779e58 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
@@ -131,12 +131,12 @@ public fun Iterable<Pair<String, Iterable<Any?>>>.toDataFrameFromPairs(): AnyFra
 public interface TraversePropertiesDsl {
 
     /**
-     * Skip given [classes] during dfs traversal
+     * Skip given [classes] during recursive (dfs) traversal
      */
     public fun exclude(vararg classes: KClass<*>)
 
     /**
-     * Skip given [properties] during dfs traversal
+     * Skip given [properties] during recursive (dfs) traversal
      */
     public fun exclude(vararg properties: KProperty<*>)
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/xs.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/xs.kt
index 3706590e7..75c843770 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/xs.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/xs.kt
@@ -6,16 +6,22 @@ import org.jetbrains.kotlinx.dataframe.impl.api.xsImpl
 
 // region DataFrame
 
-public fun <T> DataFrame<T>.xs(vararg keyValues: Any?): DataFrame<T> = xs(*keyValues) { allDfs().take(keyValues.size) }
+public fun <T> DataFrame<T>.xs(vararg keyValues: Any?): DataFrame<T> = xs(*keyValues) {
+    cols { !it.isColumnGroup() }.recursively().take(keyValues.size)
+}
 
-public fun <T, C> DataFrame<T>.xs(vararg keyValues: C, keyColumns: ColumnsSelector<T, C>): DataFrame<T> = xsImpl(keyColumns, false, *keyValues)
+public fun <T, C> DataFrame<T>.xs(vararg keyValues: C, keyColumns: ColumnsSelector<T, C>): DataFrame<T> =
+    xsImpl(keyColumns, false, *keyValues)
 
 // endregion
 
 // region GroupBy
 
-public fun <T, G> GroupBy<T, G>.xs(vararg keyValues: Any?): GroupBy<T, G> = xs(*keyValues) { allDfs().take(keyValues.size) }
+public fun <T, G> GroupBy<T, G>.xs(vararg keyValues: Any?): GroupBy<T, G> = xs(*keyValues) {
+    cols { !it.isColumnGroup() }.recursively().take(keyValues.size)
+}
 
-public fun <T, G, C> GroupBy<T, G>.xs(vararg keyValues: C, keyColumns: ColumnsSelector<T, C>): GroupBy<T, G> = xsImpl(*keyValues, keyColumns = keyColumns)
+public fun <T, G, C> GroupBy<T, G>.xs(vararg keyValues: C, keyColumns: ColumnsSelector<T, C>): GroupBy<T, G> =
+    xsImpl(*keyValues, keyColumns = keyColumns)
 
 // endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnReference.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnReference.kt
index e65d38476..8ed0f7840 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnReference.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnReference.kt
@@ -1,10 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.columns
 
-import org.jetbrains.kotlinx.dataframe.AnyFrame
-import org.jetbrains.kotlinx.dataframe.AnyRow
-import org.jetbrains.kotlinx.dataframe.DataColumn
-import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.*
 import org.jetbrains.kotlinx.dataframe.api.name
 import org.jetbrains.kotlinx.dataframe.impl.columnName
 import org.jetbrains.kotlinx.dataframe.impl.columns.RenamedColumnReference
@@ -20,7 +16,8 @@ import kotlin.reflect.KProperty
  */
 public interface ColumnReference<out C> : SingleColumn<C> {
 
-    public operator fun getValue(thisRef: Any?, property: KProperty<*>): ColumnReference<C> = renamedReference(property.columnName)
+    public operator fun getValue(thisRef: Any?, property: KProperty<*>): ColumnReference<C> =
+        renamedReference(property.columnName)
 
     public fun name(): String
 
@@ -32,13 +29,16 @@ public interface ColumnReference<out C> : SingleColumn<C> {
 
     public fun getValueOrNull(row: AnyRow): C? = resolveFor(row.df())?.get(row.index())
 
-    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>? {
-        return context.df.getColumn<C>(path(), context.unresolvedColumnsPolicy)?.addPath(path())
-    }
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>? =
+        context.df
+            .getColumn<C>(path(), context.unresolvedColumnsPolicy)
+            ?.addPath(path())
 }
 
-internal fun <C> ColumnReference<C>.renamedReference(newName: String): ColumnReference<C> = RenamedColumnReference(this, newName)
+internal fun <C> ColumnReference<C>.renamedReference(newName: String): ColumnReference<C> =
+    RenamedColumnReference(this, newName)
 
 internal fun ColumnReference<*>.shortPath() = ColumnPath(name)
 
-internal fun <C> ColumnReference<C>.resolveFor(df: AnyFrame): ColumnWithPath<C>? = resolveSingle(ColumnResolutionContext(df, UnresolvedColumnsPolicy.Skip))
+internal fun <C> ColumnReference<C>.resolveFor(df: AnyFrame): ColumnWithPath<C>? =
+    resolveSingle(ColumnResolutionContext(df, UnresolvedColumnsPolicy.Skip))
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnSet.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnSet.kt
index 794f94aab..b534a61c1 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnSet.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnSet.kt
@@ -3,21 +3,31 @@ package org.jetbrains.kotlinx.dataframe.columns
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.impl.columns.*
 
 /**
+ * ## ColumnSet
  * Entity that can be resolved into a list of [columns][DataColumn].
  *
  * Used as a return type of [ColumnsSelector].
  * @param C common type of resolved columns
+ * @see [SingleColumn]
+ * @see [TransformableColumnSet]
+ * @see [TransformableSingleColumn]
  */
 public interface ColumnSet<out C> {
 
+    /**
+     * Resolves this [ColumnSet] as a [List]<[ColumnWithPath]<[C]>>.
+     * In many cases this function [transforms][ColumnSet.transform] a parent [ColumnSet] to reach
+     * the current [ColumnSet] result.
+     */
     public fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>>
 }
 
-public class ColumnResolutionContext internal constructor (
+public class ColumnResolutionContext internal constructor(
     internal val df: DataFrame<*>,
-    internal val unresolvedColumnsPolicy: UnresolvedColumnsPolicy
+    internal val unresolvedColumnsPolicy: UnresolvedColumnsPolicy,
 ) {
 
     public val allowMissingColumns: Boolean = unresolvedColumnsPolicy != UnresolvedColumnsPolicy.Fail
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnWithPath.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnWithPath.kt
index 4ef6b1f21..45d841dc5 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnWithPath.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnWithPath.kt
@@ -19,15 +19,24 @@ public interface ColumnWithPath<out T> : DataColumn<T> {
 
     public fun depth(): Int = path.depth()
 
-    public fun <C> getChild(accessor: ColumnReference<C>): ColumnWithPath<C>? = asColumnGroup().getColumnOrNull(accessor)?.addPath(path + accessor.path())
+    public fun <C> getChild(accessor: ColumnReference<C>): ColumnWithPath<C>? =
+        asColumnGroup().getColumnOrNull(accessor)?.addPath(path + accessor.path())
 
-    public fun getChild(name: String): ColumnWithPath<Any?>? = asColumnGroup().getColumnOrNull(name)?.addParentPath(path)
+    public fun getChild(name: String): ColumnWithPath<Any?>? =
+        asColumnGroup().getColumnOrNull(name)?.addParentPath(path)
 
-    public fun getChild(index: Int): ColumnWithPath<Any?>? = asColumnGroup().getColumnOrNull(index)?.addParentPath(path)
+    public fun getChild(index: Int): ColumnWithPath<Any?>? =
+        asColumnGroup().getColumnOrNull(index)?.addParentPath(path)
 
-    public fun <C> getChild(accessor: KProperty<C>): ColumnWithPath<C>? = asColumnGroup().getColumnOrNull(accessor)?.addParentPath(path)
+    public fun <C> getChild(accessor: KProperty<C>): ColumnWithPath<C>? =
+        asColumnGroup().getColumnOrNull(accessor)?.addParentPath(path)
 
-    public fun children(): List<ColumnWithPath<Any?>> = if (isColumnGroup()) data.asColumnGroup().columns().map { it.addParentPath(path) } else emptyList()
+    public fun children(): List<ColumnWithPath<Any?>> =
+        if (isColumnGroup()) {
+            data.asColumnGroup().columns().map { it.addParentPath(path) }
+        } else {
+            emptyList()
+        }
 
     override fun path(): ColumnPath = path
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/SingleColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/SingleColumn.kt
index f822f9774..68a0615d9 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/SingleColumn.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/SingleColumn.kt
@@ -1,15 +1,30 @@
 package org.jetbrains.kotlinx.dataframe.columns
 
 import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.impl.columns.*
 
 /**
  * Entity that can be [resolved][resolveSingle] into [DataColumn].
  *
  * @param C Column [type][BaseColumn.type] of resolved column.
+ * @see [ColumnSet]
+ * @see [TransformableColumnSet]
+ * @see [TransformableSingleColumn]
  */
 public interface SingleColumn<out C> : ColumnSet<C> {
 
-    override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> = resolveSingle(context)?.let { listOf(it) } ?: emptyList()
+    override fun resolve(
+        context: ColumnResolutionContext,
+    ): List<ColumnWithPath<C>> = resolveSingle(context)?.let { listOf(it) } ?: emptyList()
 
     public fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>?
 }
+
+public fun ColumnSet<*>.isSingleColumn(): Boolean = this is SingleColumn<*>
+
+/**
+ * Returns true if [this] is a [SingleColumn] and [cols] consists of a single column group.
+ */
+public fun ColumnSet<*>.isSingleColumnWithGroup(cols: List<ColumnWithPath<*>>): Boolean =
+    isSingleColumn() && cols.singleOrNull()?.isColumnGroup() == true
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameReceiver.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameReceiver.kt
index 3345f87fe..25e877c02 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameReceiver.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameReceiver.kt
@@ -1,27 +1,13 @@
 package org.jetbrains.kotlinx.dataframe.impl
 
-import org.jetbrains.kotlinx.dataframe.ColumnSelector
-import org.jetbrains.kotlinx.dataframe.DataColumn
-import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.DataRow
-import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.asDataColumn
-import org.jetbrains.kotlinx.dataframe.api.cast
-import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.pathOf
-import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
-import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
-import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
-import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.columns.*
 import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnGroupWithParent
 import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnGroupWithPathImpl
 import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
 import org.jetbrains.kotlinx.dataframe.impl.columns.missing.MissingColumnGroup
 import org.jetbrains.kotlinx.dataframe.impl.columns.missing.MissingDataColumn
-import org.jetbrains.kotlinx.dataframe.nrow
 
 private fun <T> DataFrame<T>.unbox(): DataFrame<T> = when (this) {
     is ColumnGroupWithParent -> source.unbox()
@@ -29,11 +15,12 @@ private fun <T> DataFrame<T>.unbox(): DataFrame<T> = when (this) {
     else -> this
 }
 
-internal abstract class DataFrameReceiverBase<T>(protected val df: DataFrame<T>) : DataFrameImpl<T>(df.columns(), df.nrow)
+internal abstract class DataFrameReceiverBase<T>(protected val df: DataFrame<T>) :
+    DataFrameImpl<T>(df.columns(), df.nrow)
 
 internal open class DataFrameReceiver<T>(
     source: DataFrame<T>,
-    private val unresolvedColumnsPolicy: UnresolvedColumnsPolicy
+    private val unresolvedColumnsPolicy: UnresolvedColumnsPolicy,
 ) : DataFrameReceiverBase<T>(source.unbox()), SingleColumn<DataRow<T>> {
 
     private fun <R> DataColumn<R>?.check(path: ColumnPath): DataColumn<R> =
@@ -61,11 +48,14 @@ internal open class DataFrameReceiver<T>(
     }
 
     override fun getColumnOrNull(path: ColumnPath) = super.getColumnOrNull(path).check(path)
-    override fun <R> getColumnOrNull(column: ColumnSelector<T, R>) = getColumnsImpl(unresolvedColumnsPolicy, column).singleOrNull()
+    override fun <R> getColumnOrNull(column: ColumnSelector<T, R>) =
+        getColumnsImpl(unresolvedColumnsPolicy, column).singleOrNull()
 
-    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<DataRow<T>>? = DataColumn.createColumnGroup("", df).addPath(emptyPath())
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<DataRow<T>>? =
+        DataColumn.createColumnGroup("", df).addPath(emptyPath())
 
-    override fun columns() = df.columns().map { if (it.isColumnGroup()) ColumnGroupWithParent(null, it.asColumnGroup()) else it }
+    override fun columns() =
+        df.columns().map { if (it.isColumnGroup()) ColumnGroupWithParent(null, it.asColumnGroup()) else it }
 
     override fun columnNames() = df.columnNames()
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/GroupByImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/GroupByImpl.kt
index 6675dcc0c..585dc87fa 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/GroupByImpl.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/GroupByImpl.kt
@@ -6,18 +6,7 @@ import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.Selector
 import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedBody
 import org.jetbrains.kotlinx.dataframe.aggregation.NamedValue
-import org.jetbrains.kotlinx.dataframe.api.GroupBy
-import org.jetbrains.kotlinx.dataframe.api.GroupedRowFilter
-import org.jetbrains.kotlinx.dataframe.api.asGroupBy
-import org.jetbrains.kotlinx.dataframe.api.cast
-import org.jetbrains.kotlinx.dataframe.api.concat
-import org.jetbrains.kotlinx.dataframe.api.convert
-import org.jetbrains.kotlinx.dataframe.api.getColumn
-import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
-import org.jetbrains.kotlinx.dataframe.api.into
-import org.jetbrains.kotlinx.dataframe.api.minus
-import org.jetbrains.kotlinx.dataframe.api.pathOf
-import org.jetbrains.kotlinx.dataframe.api.rename
+import org.jetbrains.kotlinx.dataframe.api.*
 import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.AggregatableInternal
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.GroupByReceiverImpl
@@ -95,7 +84,7 @@ internal fun <T, G, R> aggregateGroupBy(
 
     if (!removeColumns) removedNode.data.wasRemoved = false
 
-    val columnsToInsert = groupedFrame.getColumnsWithPaths { allDfs() }.map {
+    val columnsToInsert = groupedFrame.getColumnsWithPaths { cols { !it.isColumnGroup() }.rec() }.map {
         ColumnToInsert(insertPath + it.path, it, removedNode)
     }
     val src = if (removeColumns) removed.df else df
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ConfiguredAggregateColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ConfiguredAggregateColumn.kt
index daae75d99..6a0f6ea05 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ConfiguredAggregateColumn.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ConfiguredAggregateColumn.kt
@@ -1,11 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.impl.aggregation
 
-import org.jetbrains.kotlinx.dataframe.api.name
-import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
-import org.jetbrains.kotlinx.dataframe.columns.shortPath
+import org.jetbrains.kotlinx.dataframe.columns.*
 
 internal class ConfiguredAggregateColumn<C> private constructor(
     val columns: ColumnSet<C>,
@@ -22,7 +17,7 @@ internal class ConfiguredAggregateColumn<C> private constructor(
         else -> AggregateColumnDescriptor(col, default, if (keepName) newPath?.plus(col.name) else newPath)
     }
 
-    override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> {
+    private fun resolve(context: ColumnResolutionContext, columns: ColumnSet<C>): List<ColumnWithPath<C>> {
         val resolved = columns.resolve(context)
         if (resolved.size == 1) return listOf(resolved[0].toDescriptor(false))
         else return resolved.map {
@@ -30,6 +25,9 @@ internal class ConfiguredAggregateColumn<C> private constructor(
         }
     }
 
+    override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> =
+        resolve(context, columns)
+
     companion object {
 
         fun <C> withDefault(src: ColumnSet<C>, default: C?): ColumnSet<C> = when (src) {
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/corr.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/corr.kt
index 2a3143be9..cac43096d 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/corr.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/corr.kt
@@ -2,16 +2,7 @@ package org.jetbrains.kotlinx.dataframe.impl.api
 
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.api.Corr
-import org.jetbrains.kotlinx.dataframe.api.cast
-import org.jetbrains.kotlinx.dataframe.api.castToNotNullable
-import org.jetbrains.kotlinx.dataframe.api.convertToDouble
-import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
-import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
-import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.isSuitableForCorr
-import org.jetbrains.kotlinx.dataframe.api.name
-import org.jetbrains.kotlinx.dataframe.api.toValueColumn
+import org.jetbrains.kotlinx.dataframe.api.*
 import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
 import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
 import org.jetbrains.kotlinx.dataframe.math.varianceAndMean
@@ -25,7 +16,7 @@ internal fun <T, C, R> Corr<T, C>.corrImpl(otherColumns: ColumnsSelector<T, R>):
         // extract nested number columns from ColumnGroups
         if (it.isColumnGroup()) {
             val groupPath = it.path
-            df.getColumnsWithPaths { groupPath.dfs { it.isSuitableForCorr() } }.map { it.cast() }
+            df.getColumnsWithPaths { groupPath.cols { it.isSuitableForCorr() }.rec() }.map { it.cast() }
         } else listOf(it)
     }
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/describe.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/describe.kt
index 671480716..74b0567b2 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/describe.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/describe.kt
@@ -31,12 +31,25 @@ import org.jetbrains.kotlinx.dataframe.type
 import kotlin.reflect.jvm.jvmErasure
 
 internal fun describeImpl(cols: List<AnyCol>): DataFrame<ColumnDescription> {
-    fun List<AnyCol>.collectAll(dfs: Boolean): List<AnyCol> = flatMap { col ->
+    fun List<AnyCol>.collectAll(recursively: Boolean): List<AnyCol> = flatMap { col ->
         when (col.kind) {
-            ColumnKind.Frame -> col.asAnyFrameColumn().concat().columns().map {
-                it.addPath(col.path() + it.name)
-            }.collectAll(true)
-            ColumnKind.Group -> if (dfs) col.asColumnGroup().columns().map { it.addPath(col.path() + it.name) }.collectAll(true) else listOf(col)
+            ColumnKind.Frame ->
+                col.asAnyFrameColumn()
+                    .concat()
+                    .columns()
+                    .map { it.addPath(col.path() + it.name) }
+                    .collectAll(true)
+
+            ColumnKind.Group ->
+                if (recursively) {
+                    col.asColumnGroup()
+                        .columns()
+                        .map { it.addPath(col.path() + it.name) }
+                        .collectAll(true)
+                } else {
+                    listOf(col)
+                }
+
             ColumnKind.Value -> listOf(col)
         }
     }
@@ -55,14 +68,18 @@ internal fun describeImpl(cols: List<AnyCol>): DataFrame<ColumnDescription> {
         ColumnDescription::count from { it.size }
         ColumnDescription::unique from { it.countDistinct() }
         ColumnDescription::nulls from { it.values.count { it == null } }
-        ColumnDescription::top from inferType { it.values.filterNotNull().groupBy { it }.maxByOrNull { it.value.size }?.key }
+        ColumnDescription::top from inferType {
+            it.values.filterNotNull().groupBy { it }.maxByOrNull { it.value.size }?.key
+        }
         if (hasNumeric) {
             ColumnDescription::mean from { if (it.isNumber()) it.asNumbers().mean() else null }
             ColumnDescription::std from { if (it.isNumber()) it.asNumbers().std() else null }
         }
         if (hasComparable) {
             ColumnDescription::min from inferType { if (it.isComparable()) it.asComparable().minOrNull() else null }
-            ColumnDescription::median from inferType { if (it.isComparable()) it.asComparable().medianOrNull() else null }
+            ColumnDescription::median from inferType {
+                if (it.isComparable()) it.asComparable().medianOrNull() else null
+            }
             ColumnDescription::max from inferType { if (it.isComparable()) it.asComparable().maxOrNull() else null }
         }
     }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/flatten.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/flatten.kt
index 5ed842f65..d410fb525 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/flatten.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/flatten.kt
@@ -16,17 +16,19 @@ internal fun <T, C> DataFrame<T>.flattenImpl(
     columns: ColumnsSelector<T, C>,
     keepParentNameForColumns: Boolean = false
 ): DataFrame<T> {
-    val rootColumns = getColumnsWithPaths { columns.toColumnSet().filter { it.isColumnGroup() }.top() }
+    val rootColumns = getColumnsWithPaths {
+        columns.toColumnSet().filter { it.isColumnGroup() }.roots()
+    }
     val rootPrefixes = rootColumns.map { it.path }.toSet()
-    val nameGenerators = rootPrefixes.map { it.dropLast() }.distinct().associate { path ->
+    val nameGenerators = rootPrefixes.map { it.dropLast() }.distinct().associateWith { path ->
         val usedNames = get(path).asColumnGroup().columns().filter { path + it.name() !in rootPrefixes }.map { it.name() }
-        path to ColumnNameGenerator(usedNames)
+        ColumnNameGenerator(usedNames)
     }
 
     fun getRootPrefix(path: ColumnPath) =
         (1 until path.size).asSequence().map { path.take(it) }.first { rootPrefixes.contains(it) }
 
-    val result = move { rootPrefixes.toColumnSet().allDfs() }
+    val result = move { rootPrefixes.toColumnSet().cols { !it.isColumnGroup() }.recursively() }
         .into {
             val targetPath = getRootPrefix(it.path).dropLast(1)
             val nameGen = nameGenerators[targetPath]!!
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/join.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/join.kt
index 4624fa6de..daad1cde2 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/join.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/join.kt
@@ -74,8 +74,8 @@ internal fun <A, B> DataFrame<A>.joinImpl(
         val leftCol = leftJoinColumns[i]
         val rightCol = rightJoinColumns[i]
         if (leftCol.isColumnGroup() && rightCol.isColumnGroup()) {
-            val leftColumns = getColumnsWithPaths { leftCol.allDfs() }
-            val rightColumns = other.getColumnsWithPaths { rightCol.allDfs() }
+            val leftColumns = getColumnsWithPaths { leftCol.cols { !it.isColumnGroup() }.recursively()}
+            val rightColumns = other.getColumnsWithPaths { rightCol.cols { !it.isColumnGroup() }.recursively() }
 
             val leftPrefixLength = leftCol.path.size
             val rightPrefixLength = rightCol.path.size
@@ -147,12 +147,13 @@ internal fun <A, B> DataFrame<A>.joinImpl(
         outputRowsCount += rightUnmatchedCount
     }
 
-    val leftColumns = getColumnsWithPaths { allDfs() }
+    val leftColumns = getColumnsWithPaths { cols { !it.isColumnGroup() }.recursively() }
 
-    val rightJoinColumnPaths = allRightJoinColumns.map { it.path to it.data }.toMap()
+    val rightJoinColumnPaths = allRightJoinColumns.associate { it.path to it.data }
 
     val newRightColumns =
-        if (addNewColumns) other.getColumnsWithPaths { dfs { !it.isColumnGroup() && !rightJoinColumnPaths.contains(it.path) } } else emptyList()
+        if (addNewColumns) other.getColumnsWithPaths { cols { !it.isColumnGroup() && !rightJoinColumnPaths.contains(it.path) }.rec() }
+        else emptyList()
 
     // for every column index from the left dataframe store matching column from the right dataframe
     val leftToRightColumns = leftColumns.map { rightJoinColumnPaths[pathMapping[it.path()]] }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/pivot.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/pivot.kt
index a29c3aa41..292320ce1 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/pivot.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/pivot.kt
@@ -8,12 +8,8 @@ import org.jetbrains.kotlinx.dataframe.api.PivotColumnsSelector
 import org.jetbrains.kotlinx.dataframe.api.forEach
 import org.jetbrains.kotlinx.dataframe.api.groupBy
 import org.jetbrains.kotlinx.dataframe.api.toPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.*
 import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
-import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.GroupByReceiverImpl
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.AggregateInternalDsl
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.AggregatePivotDslImpl
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/sort.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/sort.kt
index fac8e3967..a83d14824 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/sort.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/sort.kt
@@ -9,11 +9,8 @@ import org.jetbrains.kotlinx.dataframe.api.castFrameColumn
 import org.jetbrains.kotlinx.dataframe.api.getFrameColumn
 import org.jetbrains.kotlinx.dataframe.api.update
 import org.jetbrains.kotlinx.dataframe.api.with
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.*
 import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
-import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
 import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
 import org.jetbrains.kotlinx.dataframe.impl.columns.assertIsComparable
 import org.jetbrains.kotlinx.dataframe.impl.columns.missing.MissingColumnGroup
@@ -106,7 +103,8 @@ internal fun <C> ColumnWithPath<C>.addFlag(flag: SortFlag): ColumnWithPath<C> {
 }
 
 internal class ColumnsWithSortFlag<C>(val column: ColumnSet<C>, val flag: SortFlag) : ColumnSet<C> {
-    override fun resolve(context: ColumnResolutionContext) = column.resolve(context).map { it.addFlag(flag) }
+    override fun resolve(context: ColumnResolutionContext) =
+        column.resolve(context).map { it.addFlag(flag) }
 }
 
 internal class SortColumnDescriptor<C>(
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnAccessorImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnAccessorImpl.kt
index 3f6e14e82..dbc7d0944 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnAccessorImpl.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnAccessorImpl.kt
@@ -6,11 +6,7 @@ import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
 import org.jetbrains.kotlinx.dataframe.api.cast
 import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
 import org.jetbrains.kotlinx.dataframe.api.toPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
-import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.*
 
 internal class ColumnAccessorImpl<T>(val path: ColumnPath) : ColumnAccessor<T> {
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnsList.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnsList.kt
index 4fe7c9885..35d15fc7c 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnsList.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnsList.kt
@@ -6,5 +6,6 @@ import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
 internal class ColumnsList<C>(val columns: List<ColumnSet<C>>) : ColumnSet<C> {
     constructor(vararg columns: ColumnSet<C>) : this(columns.toList())
 
-    override fun resolve(context: ColumnResolutionContext) = columns.flatMap { it.resolve(context) }
+    override fun resolve(context: ColumnResolutionContext) =
+        columns.flatMap { it.resolve(context) }
 }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/Recursively.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/Recursively.kt
new file mode 100644
index 000000000..5f6b1de32
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/Recursively.kt
@@ -0,0 +1,92 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.api.allInternal
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.*
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.flattenRecursively
+
+/**
+ * Recursively implementation for [TransformableColumnSet].
+ * This converts a [TransformableColumnSet] into a [ColumnSet] by redirecting [ColumnSet.resolve]
+ * to [TransformableColumnSet.transformResolve] with a correctly configured [RecursivelyTransformer].
+ */
+internal fun <C> TransformableColumnSet<C>.recursivelyImpl(
+    includeGroups: Boolean = true,
+    includeTopLevel: Boolean = true,
+): ColumnSet<C> = object : ColumnSet<C> {
+
+    override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> =
+        this@recursivelyImpl.transformResolve(
+            context = context,
+            transformer = RecursivelyTransformer(
+                includeGroups = includeGroups,
+                includeTopLevel = includeTopLevel,
+            ),
+        )
+}
+
+/**
+ * Recursively implementation for [TransformableSingleColumn].
+ * This converts a [TransformableSingleColumn] into a [SingleColumn] by redirecting [SingleColumn.resolveSingle]
+ * to [TransformableSingleColumn.transformResolveSingle] with a correctly configured [RecursivelyTransformer].
+ */
+internal fun <C> TransformableSingleColumn<C>.recursivelyImpl(
+    includeGroups: Boolean = true,
+    includeTopLevel: Boolean = true,
+): SingleColumn<C> = object : SingleColumn<C> {
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>? =
+        this@recursivelyImpl.transformResolveSingle(
+            context = context,
+            transformer = RecursivelyTransformer(
+                includeGroups = includeGroups,
+                includeTopLevel = includeTopLevel,
+            ),
+        )
+}
+
+/**
+ * ## Recursively transformer.
+ * A [ColumnSetTransformer] implementation around the [ColumnSet.flattenRecursively] function.
+ * Created only using [recursivelyImpl].
+ */
+private class RecursivelyTransformer(
+    val includeGroups: Boolean = true,
+    val includeTopLevel: Boolean = true,
+) : ColumnSetTransformer {
+
+    override fun transform(columnSet: ColumnSet<*>): ColumnSet<*> =
+        columnSet.flattenRecursively(
+            includeGroups = includeGroups,
+            includeTopLevel = includeTopLevel,
+        )
+
+    override fun transformSingle(singleColumn: SingleColumn<*>): ColumnSet<*> =
+        singleColumn.flattenRecursively(
+            includeGroups = includeGroups,
+            includeTopLevel = includeTopLevel,
+        )
+}
+
+/**
+ * Flattens a [ColumnSet]/[SingleColumn] recursively.
+ *
+ * If [this] is a [SingleColumn] containing a single [ColumnGroup], the "top-level" is
+ * considered to be the [ColumnGroup]'s children, otherwise, if this is a [ColumnSet],
+ * the "top-level" is considered to be the columns in the [ColumnSet].
+ *
+ * @param includeGroups Whether to include [ColumnGroup]s in the result.
+ * @param includeTopLevel Whether to include the "top-level" columns in the result.
+ */
+internal fun ColumnSet<*>.flattenRecursively(
+    includeGroups: Boolean = true,
+    includeTopLevel: Boolean = true,
+): ColumnSet<*> = allInternal().transform { cols ->
+    if (includeTopLevel) {
+        cols.flattenRecursively()
+    } else {
+        cols
+            .filter { it.isColumnGroup() }
+            .flatMap { it.children().flattenRecursively() }
+    }.filter { includeGroups || !it.isColumnGroup() }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/TransformableColumnSet.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/TransformableColumnSet.kt
new file mode 100644
index 000000000..37b6e02e3
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/TransformableColumnSet.kt
@@ -0,0 +1,58 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+
+/**
+ * ## Transformable ColumnSet
+ * This type of [ColumnSet] can be [transformed][transformResolve] before being resolved.
+ *
+ * This is especially useful for calls like
+ * [cols { }][ColumnsSelectionDsl.cols].[recursively()][ColumnsSelectionDsl.recursively],
+ * where [recursively][ColumnsSelectionDsl.recursively] modifies the [ColumnSet][ColumnSet]
+ * that [cols { }][ColumnsSelectionDsl.cols] operates on before it's evaluated.
+ *
+ * @see [ColumnSet]
+ * @see [TransformableSingleColumn]
+ * @see [SingleColumn]
+ */
+public interface TransformableColumnSet<out C> : ColumnSet<C> {
+    public fun transformResolve(
+        context: ColumnResolutionContext,
+        transformer: ColumnSetTransformer,
+    ): List<ColumnWithPath<C>>
+}
+
+/**
+ * ## Transformable SingleColumn
+ * This type of [SingleColumn] can be [transformed][transformResolveSingle] before being resolved.
+ *
+ * This is especially useful for calls like
+ * [first { }][ColumnsSelectionDsl.first].[recursively()][ColumnsSelectionDsl.recursively],
+ * where [recursively][ColumnsSelectionDsl.recursively] modifies the [ColumnSet][ColumnSet]
+ * that [first { }][ColumnsSelectionDsl.first] operates on before it's evaluated.
+ *
+ * @see [SingleColumn]
+ * @see [TransformableColumnSet]
+ * @see [ColumnSet]
+ */
+public interface TransformableSingleColumn<out C> : SingleColumn<C> {
+    public fun transformResolveSingle(
+        context: ColumnResolutionContext,
+        transformer: ColumnSetTransformer,
+    ): ColumnWithPath<C>?
+}
+
+/**
+ * ## Column set transformer.
+ * This contains implementations for both [transform][ColumnSet.transform] and
+ * [transformSingle][SingleColumn.transformSingle] and can be passed around.
+ */
+public interface ColumnSetTransformer {
+    public fun transform(columnSet: ColumnSet<*>): ColumnSet<*>
+
+    public fun transformSingle(singleColumn: SingleColumn<*>): ColumnSet<*>
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/Utils.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/Utils.kt
index e30b80ac9..197e9092d 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/Utils.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/Utils.kt
@@ -9,27 +9,12 @@ import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.api.cast
 import org.jetbrains.kotlinx.dataframe.api.name
 import org.jetbrains.kotlinx.dataframe.api.pathOf
-import org.jetbrains.kotlinx.dataframe.columns.BaseColumn
-import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
-import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
-import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
-import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
-import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
-import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
-import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.columns.*
 import org.jetbrains.kotlinx.dataframe.columns.values
 import org.jetbrains.kotlinx.dataframe.impl.DataFrameImpl
 import org.jetbrains.kotlinx.dataframe.impl.asNullable
 import org.jetbrains.kotlinx.dataframe.impl.columns.missing.MissingDataColumn
-import org.jetbrains.kotlinx.dataframe.impl.columns.tree.ColumnPosition
-import org.jetbrains.kotlinx.dataframe.impl.columns.tree.TreeNode
-import org.jetbrains.kotlinx.dataframe.impl.columns.tree.collectTree
-import org.jetbrains.kotlinx.dataframe.impl.columns.tree.getOrPut
-import org.jetbrains.kotlinx.dataframe.impl.columns.tree.put
-import org.jetbrains.kotlinx.dataframe.impl.columns.tree.topDfs
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.*
 import org.jetbrains.kotlinx.dataframe.impl.equalsByElement
 import org.jetbrains.kotlinx.dataframe.impl.rollingHash
 import org.jetbrains.kotlinx.dataframe.nrow
@@ -93,34 +78,108 @@ internal fun <T> DataColumn<T>.assertIsComparable(): DataColumn<T> {
     return this
 }
 
-internal fun <A, B> SingleColumn<A>.transformSingle(converter: (ColumnWithPath<A>) -> List<ColumnWithPath<B>>): ColumnSet<B> =
-    object : ColumnSet<B> {
-        override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<B>> =
-            this@transformSingle.resolveSingle(context)?.let { converter(it) } ?: emptyList()
-    }
+/**
+ * Applies a transformation on [this] [SingleColumn] by converting its
+ * single [ColumnWithPath]<[A]> to [List]<[ColumnWithPath]<[B]>] using [converter].
+ * Since [converter] allows you to return multiple columns, the result is turned into a [ColumnSet]<[B]>.
+ */
+internal fun <A, B> SingleColumn<A>.transformSingle(
+    converter: (ColumnWithPath<A>) -> List<ColumnWithPath<B>>,
+): ColumnSet<B> = object : ColumnSet<B> {
+    override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<B>> =
+        this@transformSingle
+            .resolveSingle(context)
+            ?.let(converter)
+            ?: emptyList()
+}
 
-internal fun <A, B> ColumnSet<A>.transform(converter: (List<ColumnWithPath<A>>) -> List<ColumnWithPath<B>>): ColumnSet<B> =
-    object : ColumnSet<B> {
-        override fun resolve(context: ColumnResolutionContext) = converter(this@transform.resolve(context))
-    }
+/**
+ * Applies a transformation on [this] by converting its [List]<[ColumnWithPath]<[A]>] to [List]<[ColumnWithPath]<[B]>]
+ * using [converter].
+ *
+ * The result can either be used as a normal [ColumnSet]<[B]>,
+ * which resolves [this] and then applies [converter] on the result,
+ *
+ * or it can be used as a [TransformableColumnSet]<[B]>, where a [ColumnSetTransformer] can be injected before
+ * the [converter] is applied.
+ */
+internal fun <A, B> ColumnSet<A>.transform(
+    converter: (List<ColumnWithPath<A>>) -> List<ColumnWithPath<B>>,
+): TransformableColumnSet<B> = object : TransformableColumnSet<B> {
+    override fun resolve(context: ColumnResolutionContext) =
+        this@transform
+            .resolve(context)
+            .let(converter)
+
+    override fun transformResolve(
+        context: ColumnResolutionContext,
+        transformer: ColumnSetTransformer,
+    ): List<ColumnWithPath<B>> =
+        transformer.transform(this@transform)
+            .resolve(context)
+            .let { converter(it as List<ColumnWithPath<A>>) }
+}
 
+/**
+ * Applies a transformation on [this] by converting its [List]<[ColumnWithPath]<[A]>] to [List]<[ColumnWithPath]<[B]>]
+ * using [converter], but also providing the [ColumnResolutionContext] to the converter.
+ *
+ * The result can either be used as a normal [ColumnSet]<[B]>,
+ * which resolves [this] and then applies [converter] on the result,
+ *
+ * or it can be used as a [TransformableColumnSet]<[B]>, where a [ColumnSetTransformer] can be injected before
+ * the [converter] is applied.
+ */
 internal fun <A, B> ColumnSet<A>.transformWithContext(
     converter: ColumnResolutionContext.(List<ColumnWithPath<A>>) -> List<ColumnWithPath<B>>,
-): ColumnSet<B> = object : ColumnSet<B> {
+): TransformableColumnSet<B> = object : TransformableColumnSet<B> {
     override fun resolve(context: ColumnResolutionContext) =
-        converter(context, this@transformWithContext.resolve(context))
+        this@transformWithContext
+            .resolve(context)
+            .let { converter(context, it) }
+
+    override fun transformResolve(
+        context: ColumnResolutionContext,
+        transformer: ColumnSetTransformer,
+    ): List<ColumnWithPath<B>> =
+        transformer.transform(this@transformWithContext)
+            .resolve(context)
+            .let { converter(context, it as List<ColumnWithPath<A>>) }
 }
 
-internal fun <T> ColumnSet<T>.singleImpl() = object : SingleColumn<T> {
-    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? {
-        return this@singleImpl.resolve(context).singleOrNull()
-    }
+/**
+ * Converts [this] [ColumnSet] to a [SingleColumn].
+ * [resolveSingle] will return the single column of [this] if there is only one, else it will return `null`.
+ * If the result used as a [ColumnSet], `null` will be converted to an empty list.
+ */
+internal fun <T> ColumnSet<T>.singleImpl(): SingleColumn<T> = object : SingleColumn<T> {
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? =
+        this@singleImpl.resolve(context).singleOrNull()
 }
 
-internal fun <T> ColumnSet<T>.getAt(index: Int) = object : SingleColumn<T> {
-    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? {
-        return this@getAt.resolve(context).getOrNull(index)
+/**
+ * Same as [singleImpl], however, it passes any [ColumnSetTransformer] back to [this] if it is supplied.
+ */
+internal fun <T> TransformableColumnSet<T>.singleWithTransformerImpl(): TransformableSingleColumn<T> =
+    object : TransformableSingleColumn<T> {
+        override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? =
+            this@singleWithTransformerImpl.resolve(context).singleOrNull()
+
+        override fun transformResolveSingle(
+            context: ColumnResolutionContext,
+            transformer: ColumnSetTransformer,
+        ): ColumnWithPath<T>? =
+            this@singleWithTransformerImpl.transformResolve(
+                context = context,
+                transformer = transformer,
+            ).singleOrNull()
     }
+
+internal fun <T> ColumnSet<T>.getAt(index: Int): SingleColumn<T> = object : SingleColumn<T> {
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? =
+        this@getAt
+            .resolve(context)
+            .getOrNull(index)
 }
 
 internal fun <T> ColumnSet<T>.getChildrenAt(index: Int): ColumnSet<Any?> =
@@ -146,10 +205,16 @@ internal fun <C> ColumnsContainer<*>.getColumn(path: ColumnPath, policy: Unresol
             UnresolvedColumnsPolicy.Create -> DataColumn.empty().cast<C>()
         }
 
-internal fun <T> List<ColumnWithPath<T>>.top(): List<ColumnWithPath<T>> {
-    val root = TreeNode.createRoot<ColumnWithPath<T>?>(null)
-    forEach { root.put(it.path, it) }
-    return root.topDfs { it.data != null }.map { it.data!! }
+/**
+ * Returns a sub-list of columns that are roots of the trees of columns.
+ *
+ * In practice, this means that if a column in [this] is a child of another column in [this],
+ * it will not be included in the result.
+ */
+internal fun <T> List<ColumnWithPath<T>>.roots(): List<ColumnWithPath<T>> {
+    val emptyRoot = TreeNode.createRoot<ColumnWithPath<T>?>(data = null)
+    this.forEach { emptyRoot.put(it.path, it) }
+    return emptyRoot.topmostChildren { it.data != null }.map { it.data!! }
 }
 
 internal fun List<ColumnWithPath<*>>.allColumnsExcept(columns: Iterable<ColumnWithPath<*>>): List<ColumnWithPath<*>> {
@@ -157,14 +222,14 @@ internal fun List<ColumnWithPath<*>>.allColumnsExcept(columns: Iterable<ColumnWi
     val fullTree = collectTree()
     columns.forEach {
         var node = fullTree.getOrPut(it.path).asNullable()
-        node?.dfs()?.forEach { it.data = null }
+        node?.allChildren()?.forEach { it.data = null }
         while (node != null) {
             node.data = null
             node = node.parent
         }
     }
-    val dfs = fullTree.topDfs { it.data != null }
-    return dfs.map { it.data!!.addPath(it.pathFromRoot()) }
+    val subtrees = fullTree.topmostChildren { it.data != null }
+    return subtrees.map { it.data!!.addPath(it.pathFromRoot()) }
 }
 
 internal fun KType.toColumnKind(): ColumnKind = jvmErasure.let {
@@ -177,13 +242,13 @@ internal fun KType.toColumnKind(): ColumnKind = jvmErasure.let {
 
 internal fun <C> ColumnSet<C>.resolve(
     df: DataFrame<*>,
-    unresolvedColumnsPolicy: UnresolvedColumnsPolicy = UnresolvedColumnsPolicy.Fail
+    unresolvedColumnsPolicy: UnresolvedColumnsPolicy = UnresolvedColumnsPolicy.Fail,
 ) =
     resolve(ColumnResolutionContext(df, unresolvedColumnsPolicy))
 
 internal fun <C> SingleColumn<C>.resolveSingle(
     df: DataFrame<*>,
-    unresolvedColumnsPolicy: UnresolvedColumnsPolicy = UnresolvedColumnsPolicy.Fail
+    unresolvedColumnsPolicy: UnresolvedColumnsPolicy = UnresolvedColumnsPolicy.Fail,
 ): ColumnWithPath<C>? =
     resolveSingle(ColumnResolutionContext(df, unresolvedColumnsPolicy))
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnImpl.kt
index b21d8f6f6..49253bf0b 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnImpl.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnImpl.kt
@@ -2,9 +2,7 @@ package org.jetbrains.kotlinx.dataframe.impl.columns
 
 import org.jetbrains.kotlinx.dataframe.AnyRow
 import org.jetbrains.kotlinx.dataframe.DataColumn
-import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.columns.*
 import kotlin.reflect.KType
 import kotlin.reflect.full.withNullability
 
@@ -13,9 +11,8 @@ internal open class ValueColumnImpl<T>(
     name: String,
     type: KType,
     val defaultValue: T? = null,
-    distinct: Lazy<Set<T>>? = null
-) :
-    DataColumnImpl<T>(values, name, type, distinct), ValueColumn<T> {
+    distinct: Lazy<Set<T>>? = null,
+) : DataColumnImpl<T>(values, name, type, distinct), ValueColumn<T> {
 
     override fun distinct() = ValueColumnImpl(toSet().toList(), name, type, defaultValue, distinct)
 
@@ -40,7 +37,8 @@ internal open class ValueColumnImpl<T>(
         return createWithValues(newValues, nullable)
     }
 
-    override fun get(columnName: String) = throw UnsupportedOperationException("Can not get nested column '$columnName' from ValueColumn '$name'")
+    override fun get(columnName: String) =
+        throw UnsupportedOperationException("Can not get nested column '$columnName' from ValueColumn '$name'")
 
     override operator fun get(range: IntRange): ValueColumn<T> = super<DataColumnImpl>.get(range) as ValueColumn<T>
 
@@ -50,12 +48,13 @@ internal open class ValueColumnImpl<T>(
 }
 
 internal class ResolvingValueColumn<T>(
-    override val source: ValueColumn<T>
+    override val source: ValueColumn<T>,
 ) : ValueColumn<T> by source, ForceResolvedColumn<T> {
 
     override fun resolve(context: ColumnResolutionContext) = super<ValueColumn>.resolve(context)
 
-    override fun resolveSingle(context: ColumnResolutionContext) = context.df.getColumn<T>(source.name(), context.unresolvedColumnsPolicy)?.addPath()
+    override fun resolveSingle(context: ColumnResolutionContext) =
+        context.df.getColumn<T>(source.name(), context.unresolvedColumnsPolicy)?.addPath()
 
     override fun getValue(row: AnyRow) = super<ValueColumn>.getValue(row)
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt
index 01790f3b8..1cf7d097e 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt
@@ -144,10 +144,23 @@ internal fun <T> createColumn(values: Iterable<T>, suggestedType: KType, guessTy
 
 // region create Columns
 
-internal fun <C> createColumnSet(resolver: (ColumnResolutionContext) -> List<ColumnWithPath<C>>): ColumnSet<C> =
-    object : ColumnSet<C> {
-        override fun resolve(context: ColumnResolutionContext) = resolver(context)
-    }
+internal fun <C> createColumnSet(
+    resolver: (context: ColumnResolutionContext) -> List<ColumnWithPath<C>>,
+): ColumnSet<C> = object : ColumnSet<C> {
+    override fun resolve(context: ColumnResolutionContext) = resolver(context)
+}
+
+internal fun <C> createTransformableColumnSet(
+    resolver: (context: ColumnResolutionContext) -> List<ColumnWithPath<C>>,
+    transformResolve: (context: ColumnResolutionContext, transformer: ColumnSetTransformer) -> List<ColumnWithPath<C>>,
+): TransformableColumnSet<C> = object : TransformableColumnSet<C> {
+    override fun resolve(context: ColumnResolutionContext) = resolver(context)
+
+    override fun transformResolve(
+        context: ColumnResolutionContext,
+        transformer: ColumnSetTransformer,
+    ): List<ColumnWithPath<C>> = transformResolve(context, transformer)
+}
 
 // region toColumnSet
 
@@ -155,12 +168,11 @@ internal fun <C> createColumnSet(resolver: (ColumnResolutionContext) -> List<Col
 
 internal fun <TD, T : DataFrame<TD>, C> Selector<T, ColumnSet<C>>.toColumnSet(
     createReceiver: (ColumnResolutionContext) -> T,
-): ColumnSet<C> =
-    createColumnSet {
-        val receiver = createReceiver(it)
-        val columnSet = this(receiver, receiver)
-        columnSet.resolve(receiver, it.unresolvedColumnsPolicy)
-    }
+): ColumnSet<C> = createColumnSet {
+    val receiver = createReceiver(it)
+    val columnSet = this(receiver, receiver)
+    columnSet.resolve(receiver, it.unresolvedColumnsPolicy)
+}
 
 @JvmName("toColumnSetForPivot")
 internal fun <T, C> PivotColumnsSelector<T, C>.toColumnSet(): ColumnSet<C> = toColumnSet {
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingColumnGroup.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingColumnGroup.kt
index 62518ab0c..a3abdcedd 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingColumnGroup.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingColumnGroup.kt
@@ -8,10 +8,7 @@ import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedBody
 import org.jetbrains.kotlinx.dataframe.api.asDataColumn
 import org.jetbrains.kotlinx.dataframe.api.cast
 import org.jetbrains.kotlinx.dataframe.api.name
-import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.*
 import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
 import org.jetbrains.kotlinx.dataframe.impl.columns.DataColumnGroup
 import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/TreeNode.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/TreeNode.kt
index 2f35bca69..bf9d27646 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/TreeNode.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/TreeNode.kt
@@ -6,7 +6,7 @@ internal class TreeNode<T>(
     override val name: String,
     override val depth: Int,
     override var data: T,
-    override val parent: TreeNode<T>? = null
+    override val parent: TreeNode<T>? = null,
 ) : ReadonlyTreeNode<T> {
 
     companion object {
@@ -28,7 +28,7 @@ internal class TreeNode<T>(
     fun pathFromRoot(): ColumnPath {
         val path = mutableListOf<String>()
         var node: TreeNode<T>? = this
-        while (node != null && node.parent != null) {
+        while (node?.parent != null) {
             path.add(node.name)
             node = node.parent
         }
@@ -48,19 +48,34 @@ internal class TreeNode<T>(
         return addChild(childName, createData())
     }
 
-    fun dfs(enterCondition: (TreeNode<T>) -> Boolean = { true }, yieldCondition: (TreeNode<T>) -> Boolean = { true }): List<TreeNode<T>> {
+    @Deprecated("Use allChildren instead", ReplaceWith("allChildren(enterCondition, yieldCondition)"))
+    fun dfs(
+        enterCondition: (TreeNode<T>) -> Boolean = { true },
+        yieldCondition: (TreeNode<T>) -> Boolean = { true },
+    ): List<TreeNode<T>> = allChildren(enterCondition, yieldCondition)
+
+    /**
+     * Traverses the tree in depth-first order and returns all nodes that satisfy [yieldCondition].
+     * If [enterCondition] returns false for a node, its children are not traversed.
+     * By default, all nodes are traversed and all nodes are returned.
+     */
+    fun allChildren(
+        enterCondition: (TreeNode<T>) -> Boolean = { true },
+        yieldCondition: (TreeNode<T>) -> Boolean = { true },
+    ): List<TreeNode<T>> {
         val result = mutableListOf<TreeNode<T>>()
-        fun doDfs(node: TreeNode<T>) {
+
+        fun traverse(node: TreeNode<T>) {
             if (yieldCondition(node)) {
                 result.add(node)
             }
             if (enterCondition(node)) {
                 node.children.forEach {
-                    doDfs(it)
+                    traverse(it)
                 }
             }
         }
-        doDfs(this)
+        traverse(this)
         return result
     }
 }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/Utils.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/Utils.kt
index e74bc75c8..97f16582b 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/Utils.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/Utils.kt
@@ -29,9 +29,22 @@ internal fun <T> TreeNode<T>.getOrPut(path: ColumnPath, createData: (ColumnPath)
     return node
 }
 
-internal fun <T> TreeNode<T>.topDfs(yieldCondition: (TreeNode<T>) -> Boolean): List<TreeNode<T>> = dfs(enterCondition = { !yieldCondition(it) }, yieldCondition = yieldCondition)
+/**
+ * Traverses all children in the tree in depth-first order and returns the top-most nodes that satisfy
+ * [yieldCondition]. This means that if a node satisfies [yieldCondition], its children are not traversed, regardless of
+ * whether they satisfy [yieldCondition] or not.
+ */
+internal fun <T> TreeNode<T>.topmostChildren(yieldCondition: (TreeNode<T>) -> Boolean): List<TreeNode<T>> =
+    allChildren(
+        enterCondition = { !yieldCondition(it) },
+        yieldCondition = yieldCondition,
+    )
 
-internal fun <T> TreeNode<T>.topDfsExcluding(excludeRoot: TreeNode<*>): List<TreeNode<T>> {
+@Deprecated("Use topmostChildren instead", ReplaceWith("topmostChildren(yieldCondition)"))
+internal fun <T> TreeNode<T>.topDfs(yieldCondition: (TreeNode<T>) -> Boolean): List<TreeNode<T>> =
+    topmostChildren(yieldCondition)
+
+internal fun <T> TreeNode<T>.topmostChildrenExcluding(excludeRoot: TreeNode<*>): List<TreeNode<T>> {
     val result = mutableListOf<TreeNode<T>>()
     fun doDfs(node: TreeNode<T>, exclude: TreeNode<*>) {
         if (exclude.children.isNotEmpty()) {
@@ -48,23 +61,35 @@ internal fun <T> TreeNode<T>.topDfsExcluding(excludeRoot: TreeNode<*>): List<Tre
     return result
 }
 
-internal fun <T> TreeNode<T?>.dfsNotNull() = dfs { it.data != null }.map { it as TreeNode<T> }
-internal fun <T> TreeNode<T?>.dfsTopNotNull() = dfs(enterCondition = { it.data == null }, yieldCondition = { it.data != null }).map { it as TreeNode<T> }
+internal fun <T> TreeNode<T?>.allChildrenNotNull(): List<TreeNode<T>> =
+    allChildren { it.data != null } as List<TreeNode<T>>
+
+internal fun <T> TreeNode<T?>.topmostChildrenNotNull() =
+    topmostChildren { it.data != null } as List<TreeNode<T>>
 
-internal fun TreeNode<ColumnPosition>.allRemovedColumns() = dfs { it.data.wasRemoved && it.data.column != null }
-internal fun TreeNode<ColumnPosition>.allWithColumns() = dfs { it.data.column != null }
-internal fun Iterable<ColumnWithPath<*>>.dfs(): List<ColumnWithPath<*>> {
+internal fun TreeNode<ColumnPosition>.allRemovedColumns() =
+    allChildren { it.data.wasRemoved && it.data.column != null }
+
+internal fun TreeNode<ColumnPosition>.allWithColumns() =
+    allChildren { it.data.column != null }
+
+internal fun Iterable<ColumnWithPath<*>>.flattenRecursively(): List<ColumnWithPath<*>> {
     val result = mutableListOf<ColumnWithPath<*>>()
-    fun dfs(cols: Iterable<ColumnWithPath<*>>) {
+
+    fun flattenRecursively(cols: Iterable<ColumnWithPath<*>>) {
         cols.forEach {
             result.add(it)
             val path = it.path
             if (it.data.isColumnGroup()) {
-                dfs(it.data.asColumnGroup().columns().map { it.addPath(path + it.name()) })
+                flattenRecursively(
+                    it.data.asColumnGroup()
+                        .columns()
+                        .map { it.addPath(path + it.name()) }
+                )
             }
         }
     }
-    dfs(this)
+    flattenRecursively(this)
     return result
 }
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/html.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/html.kt
index aa69386c4..229c13d0d 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/html.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/html.kt
@@ -74,8 +74,8 @@ internal fun tableJs(columns: List<ColumnDataForJs>, id: Int, rootId: Int, nrow:
     var index = 0
     val data = buildString {
         append("[")
-        fun dfs(col: ColumnDataForJs): Int {
-            val children = col.nested.map { dfs(it) }
+        fun appendColWithChildren(col: ColumnDataForJs): Int {
+            val children = col.nested.map { appendColWithChildren(it) }
             val colIndex = index++
             val values = col.values.joinToString(",", prefix = "[", postfix = "]") {
                 when (it) {
@@ -100,7 +100,7 @@ internal fun tableJs(columns: List<ColumnDataForJs>, id: Int, rootId: Int, nrow:
 
             return colIndex
         }
-        columns.forEach { dfs(it) }
+        columns.forEach { appendColWithChildren(it) }
         append("]")
     }
     val js = getResourceText(
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
index dd5d16685..d14a0a5ef 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
@@ -3,181 +3,159 @@ package org.jetbrains.kotlinx.dataframe.api
 import io.kotest.matchers.shouldBe
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
-import org.jetbrains.kotlinx.dataframe.impl.columns.asValueColumn
-import org.jetbrains.kotlinx.dataframe.samples.api.TestBase
-import org.jetbrains.kotlinx.dataframe.samples.api.age
-import org.jetbrains.kotlinx.dataframe.samples.api.firstName
-import org.jetbrains.kotlinx.dataframe.samples.api.isHappy
-import org.jetbrains.kotlinx.dataframe.samples.api.lastName
-import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.jetbrains.kotlinx.dataframe.samples.api.*
 import org.junit.Test
+import kotlin.reflect.typeOf
 
-class ColumnsSelectionDslTests : TestBase() {
+open class ColumnsSelectionDslTests : TestBase() {
 
     @Test
     fun first() {
-        df.select { all().first() } shouldBe df.select { first() }
-        df.select { all().first() } shouldBe df.select { name }
-        df.select { first() } shouldBe df.select { name }
-        df.select { first { it.name().startsWith("a") } } shouldBe df.select { age }
-
-        df.select {
-            name.first { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select {
-            name.colsOf<String>().first { col ->
-                col.any { it == "Alice" }
-            }
-        }
+        listOf(
+            df.select { name },
+            df.select { first() },
+            df.select { all().first() },
+            df.select { first { it.name().startsWith("n") } },
+        ).shouldAllBeEqual()
 
-        df.select {
-            "name".first { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select { name.firstName }
+        listOf(
+            df.select { name.firstName },
 
-        df.select {
-            Person::name.first { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select { name.firstName }
+            df.select { name.first { col -> col.any { it == "Alice" } } },
+            df.select { name.colsOf<String>().first { col -> col.any { it == "Alice" } } },
 
-        df.select {
-            pathOf("name").first { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select { name.firstName }
+            df.select { "name".first { col -> col.any { it == "Alice" } } },
+            df.select { "name".colsOf<String>(typeOf<String>()).first { col -> col.any { it == "Alice" } } },
+
+            df.select { Person::name.first { col -> col.any { it == "Alice" } } },
+            df.select { Person::name.colsOf<String>(typeOf<String>()).first { col -> col.any { it == "Alice" } } },
+
+            df.select { pathOf("name").first { col -> col.any { it == "Alice" } } },
+            df.select { pathOf("name").colsOf<String>(typeOf<String>()).first { col -> col.any { it == "Alice" } } },
+
+            df.select { it["name"].first { col -> col.any { it == "Alice" } } },
+            df.select { it["name"].colsOf<String>(typeOf<String>()).first { col -> col.any { it == "Alice" } } },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun last() {
-        df.select { all().last() } shouldBe df.select { last() }
-        df.select { all().last() } shouldBe df.select { isHappy }
-        df.select { last() } shouldBe df.select { isHappy }
-        df.select { last { it.name().startsWith("a") } } shouldBe df.select { age }
-        df.select {
-            name.last { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select {
-            name.colsOf<String>().last { col ->
-                col.any { it == "Alice" }
-            }
-        }
+        listOf(
+            df.select { isHappy },
+            df.select { last() },
+            df.select { all().last() },
+            df.select { last { it.name().startsWith("is") } },
+        ).shouldAllBeEqual()
 
-        df.select {
-            "name".last { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select { name.firstName }
+        listOf(
+            df.select { name.firstName },
 
-        df.select {
-            Person::name.last { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select { name.firstName }
+            df.select { name.last { col -> col.any { it == "Alice" } } },
+            df.select { name.colsOf<String>().last { col -> col.any { it == "Alice" } } },
 
-        df.select {
-            pathOf("name").last { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select { name.firstName }
+            df.select { "name".last { col -> col.any { it == "Alice" } } },
+            df.select { "name".colsOf<String>(typeOf<String>()).last { col -> col.any { it == "Alice" } } },
+
+            df.select { Person::name.last { col -> col.any { it == "Alice" } } },
+            df.select { Person::name.colsOf<String>(typeOf<String>()).last { col -> col.any { it == "Alice" } } },
+
+            df.select { pathOf("name").last { col -> col.any { it == "Alice" } } },
+            df.select { pathOf("name").colsOf<String>(typeOf<String>()).last { col -> col.any { it == "Alice" } } },
+
+            df.select { it["name"].last { col -> col.any { it == "Alice" } } },
+            df.select { it["name"].colsOf<String>(typeOf<String>()).last { col -> col.any { it == "Alice" } } },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun single() {
         val singleDf = df.select { take(1) }
-        singleDf.select { all().single() } shouldBe singleDf.select { single() }
-        singleDf.select { all().single() } shouldBe singleDf.select { name }
-        singleDf.select { single() } shouldBe singleDf.select { name }
-        df.select { single { it.name().startsWith("a") } } shouldBe df.select { age }
-
-        df.select {
-            name.single { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select {
-            name.colsOf<String>().single { col ->
-                col.any { it == "Alice" }
-            }
-        }
 
-        df.select {
-            "name".single { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select { name.firstName }
+        listOf(
+            df.select { name },
+            singleDf.select { name },
+            singleDf.select { single() },
+            singleDf.select { all().single() },
+            df.select { single { it.name().startsWith("n") } },
+        ).shouldAllBeEqual()
 
-        df.select {
-            Person::name.single { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select { name.firstName }
+        listOf(
+            df.select { name.firstName },
 
-        df.select {
-            pathOf("name").single { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select { name.firstName }
+            df.select { name.single { col -> col.any { it == "Alice" } } },
+            df.select { name.colsOf<String>().single { col -> col.any { it == "Alice" } } },
+
+            df.select { "name".single { col -> col.any { it == "Alice" } } },
+            df.select { "name".colsOf<String>(typeOf<String>()).single { col -> col.any { it == "Alice" } } },
+
+            df.select { Person::name.single { col -> col.any { it == "Alice" } } },
+            df.select { Person::name.colsOf<String>(typeOf<String>()).single { col -> col.any { it == "Alice" } } },
+
+            df.select { pathOf("name").single { col -> col.any { it == "Alice" } } },
+            df.select { pathOf("name").colsOf<String>(typeOf<String>()).single { col -> col.any { it == "Alice" } } },
+
+            df.select { it["name"].single { col -> col.any { it == "Alice" } } },
+            df.select { it["name"].colsOf<String>(typeOf<String>()).single { col -> col.any { it == "Alice" } } },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun col() {
-        df.select { col("age") } shouldBe df.select { age }
-        df.select { col<Int>("age") } shouldBe df.select { age }
-        df.select { col(pathOf("age")) } shouldBe df.select { age }
-        df.select { col<Int>(pathOf("age")) } shouldBe df.select { age }
-        df.select { col(Person::age) } shouldBe df.select { age }
-
-        df.select { colGroup("name").col("firstName") } shouldBe df.select { name.firstName }
-        df.select { colGroup("name").col<String>("firstName") } shouldBe df.select { name.firstName }
-        df.select { colGroup("name").col(pathOf("firstName")) } shouldBe df.select { name.firstName }
-        df.select { colGroup("name").col<String>(pathOf("firstName")) } shouldBe df.select { name.firstName }
-        df.select { colGroup("name").col(Name::firstName) } shouldBe df.select { name.firstName }
-    }
+        listOf(
+            df.select { age },
 
-    @DataSchema
-    interface FirstNames {
-        val firstName: String
-        val secondName: String?
-        val thirdName: String?
-    }
+            df.select { col("age") },
+            df.select { col<Int>("age") },
 
-    @DataSchema
-    interface MyName : Name {
-        val firstNames: FirstNames
+            df.select { col(pathOf("age")) },
+            df.select { col<Int>(pathOf("age")) },
+
+            df.select { col(Person::age) },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.firstName },
+
+            df.select { colGroup("name").col("firstName") },
+            df.select { colGroup("name").col<String>("firstName") },
+
+            df.select { colGroup("name").col(pathOf("firstName")) },
+            df.select { colGroup("name").col<String>(pathOf("firstName")) },
+
+            df.select { colGroup("name").col(Name::firstName) },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun colGroup() {
-        val firstNames by columnGroup<FirstNames>()
-        val dfGroup = df.convert { name.firstName }.to {
-            val firstName by it
-            val secondName by it.map<_, String?> { null }.asValueColumn()
-            val thirdName by it.map<_, String?> { null }.asValueColumn()
-
-            dataFrameOf(firstName, secondName, thirdName)
-                .cast<FirstNames>(verify = true)
-                .asColumnGroup(firstNames)
-        }
+        listOf(
+            dfGroup.select { name },
+
+            dfGroup.select { colGroup("name") },
+            dfGroup.select { colGroup<Name>("name") },
+
+            dfGroup.select { colGroup(pathOf("name")) },
+            dfGroup.select { colGroup<Name>(pathOf("name")) },
+
+            dfGroup.select { colGroup(Person::name) },
+        ).shouldAllBeEqual()
 
-        dfGroup.select { colGroup("name") } shouldBe dfGroup.select { name }
-        dfGroup.select { colGroup<Name>("name") } shouldBe dfGroup.select { name }
-        dfGroup.select { colGroup(pathOf("name")) } shouldBe dfGroup.select { name }
-        dfGroup.select { colGroup<Name>(pathOf("name")) } shouldBe dfGroup.select { name }
-        dfGroup.select { colGroup(Person::name) } shouldBe dfGroup.select { name }
+        listOf(
+            dfGroup.select { name.firstName },
+
+            dfGroup.select { colGroup("name").colGroup("firstName") },
+            dfGroup.select { colGroup("name").colGroup<FirstNames>("firstName") },
+
+            dfGroup.select { colGroup("name").colGroup(pathOf("firstName")) },
+            dfGroup.select { colGroup("name").colGroup<FirstNames>(pathOf("firstName")) },
 
-        dfGroup.select { colGroup("name").colGroup("firstNames") } shouldBe dfGroup.select { name[firstNames] }
-        dfGroup.select { colGroup("name").colGroup<String>("firstNames") } shouldBe dfGroup.select { name[firstNames] }
-        dfGroup.select { colGroup("name").colGroup(pathOf("firstNames")) } shouldBe dfGroup.select { name[firstNames] }
-        dfGroup.select { colGroup("name").colGroup<String>(pathOf("firstNames")) } shouldBe dfGroup.select { name[firstNames] }
-        dfGroup.select { colGroup("name").colGroup(MyName::firstNames) } shouldBe dfGroup.select { name[firstNames] }
+            dfGroup.select { colGroup("name").colGroup(Name2::firstName) },
+        ).shouldAllBeEqual()
 
         dfGroup.select {
-            "name"["firstNames"]["firstName", "secondName"]
+            "name"["firstName"]["firstName", "secondName"]
         } shouldBe dfGroup.select {
-            name[firstNames]["firstName"] and name[firstNames]["secondName"]
+            name.firstName["firstName"] and name.firstName["secondName"]
         }
     }
 
@@ -204,321 +182,322 @@ class ColumnsSelectionDslTests : TestBase() {
                 dataFrameOf(firstName, lastName, frameCol).asColumnGroup("name")
             }
 
-        dfWithFrames.select { frameCol("frameCol") } shouldBe dfWithFrames.select { frameCol }
-        dfWithFrames.select { frameCol<Person>("frameCol") } shouldBe dfWithFrames.select { frameCol }
-        dfWithFrames.select { frameCol(pathOf("frameCol")) } shouldBe dfWithFrames.select { frameCol }
-        dfWithFrames.select { frameCol<Person>(pathOf("frameCol")) } shouldBe dfWithFrames.select { frameCol }
-        dfWithFrames.select { frameCol(PersonWithFrame::frameCol) } shouldBe dfWithFrames.select { frameCol }
-
-        dfWithFrames.select { colGroup("name").frameCol("frameCol") } shouldBe dfWithFrames.select { name[frameCol] }
-        dfWithFrames.select { colGroup("name").frameCol<Person>("frameCol") } shouldBe dfWithFrames.select { name[frameCol] }
-        dfWithFrames.select { colGroup("name").frameCol(pathOf("frameCol")) } shouldBe dfWithFrames.select { name[frameCol] }
-        dfWithFrames.select { colGroup("name").frameCol<Person>(pathOf("frameCol")) } shouldBe dfWithFrames.select { name[frameCol] }
-        dfWithFrames.select { colGroup("name").frameCol(PersonWithFrame::frameCol) } shouldBe dfWithFrames.select { name[frameCol] }
+        listOf(
+            dfWithFrames.select { frameCol },
+
+            dfWithFrames.select { frameCol("frameCol") },
+            dfWithFrames.select { frameCol<Person>("frameCol") },
+
+            dfWithFrames.select { frameCol(pathOf("frameCol")) },
+            dfWithFrames.select { frameCol<Person>(pathOf("frameCol")) },
+
+            dfWithFrames.select { frameCol(PersonWithFrame::frameCol) },
+        ).shouldAllBeEqual()
+
+        listOf(
+            dfWithFrames.select { name[frameCol] },
+
+            dfWithFrames.select { colGroup("name").frameCol("frameCol") },
+            dfWithFrames.select { colGroup("name").frameCol<Person>("frameCol") },
+
+            dfWithFrames.select { colGroup("name").frameCol(pathOf("frameCol")) },
+            dfWithFrames.select { colGroup("name").frameCol<Person>(pathOf("frameCol")) },
+
+            dfWithFrames.select { colGroup("name").frameCol(PersonWithFrame::frameCol) },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun `cols and get with predicate`() {
-        df.select { all().cols() } shouldBe df.select { cols() }
-        df.select { all().cols { "e" in it.name() } } shouldBe df.select {
-            cols { "e" in it.name() }
-        }
-        df.select { all()[{ "e" in it.name() }] } shouldBe df.select {
-//            this[{ "e" in it.name() }]
-            cols { "e" in it.name() }
-        }
+        listOf(
+            df.select { cols(name, age, city, weight, isHappy) },
+            df.select { all().cols() },
+            df.select { cols() },
+            df.select { all() },
+        ).shouldAllBeEqual()
 
-        df.select {
-            name.cols {
-                "Name" in it.name()
-            }
-        } shouldBe df.select {
-            name.colsOf<String>().cols {
-                "Name" in it.name()
-            }
-        }
+        listOf(
+            df.select { name },
+            df.select { name }.select { all() },
+            df.select { name }.select { cols() },
+            df.select { name }.select { cols().all() },
+            df.select { name }.select { all().cols() },
+        ).shouldAllBeEqual()
 
-        df.select {
-//            name[{ "Name" in it.name() }]
-            name.cols { "Name" in it.name() }
-        } shouldBe df.select {
-            name.colsOf<String>()[{ "Name" in it.name() }]
-        }
+        listOf(
+            df.select { cols(name, age, weight) },
 
-        df.select {
-            "name".cols { "Name" in it.name() }
-        } shouldBe df.select {
-            Person::name.cols { "Name" in it.name() }
-        }
+            df.select { cols { "e" in it.name() } },
+//            df.select { this[{ "e" in it.name() }] },
 
-        df.select {
-            "name"[{ "Name" in it.name() }]
-        } shouldBe df.select {
-            Person::name[{ "Name" in it.name() }]
-        }
+            df.select { all().cols { "e" in it.name() } },
+            df.select { all()[{ "e" in it.name() }] },
+        ).shouldAllBeEqual()
 
-        df.select {
-            pathOf("name").cols { "Name" in it.name() }
-        } shouldBe df.select {
-            "name"[{ "Name" in it.name() }]
-        }
+        listOf(
+            df.select { name.firstName and name.lastName },
 
-        df.select {
-            pathOf("name").cols { "Name" in it.name() }
-        } shouldBe df.select {
-            pathOf("name")[{ "Name" in it.name() }]
-        }
+            df.select { name.cols { "Name" in it.name() } },
+//            df.select { name[{ "Name" in it.name() }] },
+
+            df.select { name.colsOf<String>().cols { "Name" in it.name() } },
+            df.select { name.colsOf<String>()[{ "Name" in it.name() }] },
+
+            df.select { "name".cols { "Name" in it.name() } },
+            df.select { "name"[{ "Name" in it.name() }] },
+
+            df.select { Person::name.cols { "Name" in it.name() } },
+            df.select { Person::name[{ "Name" in it.name() }] },
+
+            df.select { pathOf("name").cols { "Name" in it.name() } },
+            df.select { pathOf("name")[{ "Name" in it.name() }] },
+
+            df.select { it["name"].cols { "Name" in it.name() } },
+            df.select { it["name"][{ "Name" in it.name() }] },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun `cols and get with column references`() {
-        df.select { all().cols(name, age) } shouldBe df.select { cols(name, age) }
-        df.select { all()[name, age] } shouldBe df.select { this[name, age] }
+        listOf(
+            df.select { name and age },
+
+            df.select { cols(name, age) },
+            df.select { this[name, age] },
+            df.select { it[name, age] },
+
+            df.select { all().cols(name, age) },
+            df.select { all()[name, age] },
+        ).shouldAllBeEqual()
 
         val firstName by column<String>()
         val lastName by column<String>()
-        df.select {
-            name.cols(firstName, lastName)
-        } shouldBe df.select {
-            name.colsOf<String>().cols(firstName, lastName)
-        }
 
-        df.select {
-            name.cols(name.firstName, name.lastName)
-        } shouldBe df.select {
-            name.colsOf<String>().cols(name.firstName, name.lastName)
-        }.also { it.print() }
-
-        df.select {
-//            name[name.firstName, name.lastName]
-            name.cols(name.firstName, name.lastName)
-        } shouldBe df.select {
-            name.colsOf<String>()[name.firstName, name.lastName]
-        }
+        listOf(
+            df.select { name.firstName and name.lastName },
 
-        df.select {
-            "name".cols(name.firstName, name.lastName)
-        } shouldBe df.select {
-            Person::name.cols(name.firstName, name.lastName)
-        }
+            df.select { name.cols(firstName, lastName) },
+//            df.select { name[name.firstName, name.lastName] },
 
-        df.select {
-            "name"[name.firstName, name.lastName]
-        } shouldBe df.select {
-            Person::name[name.firstName, name.lastName]
-        }
+            df.select { name.colsOf<String>().cols(firstName, lastName) },
+            df.select { name.colsOf<String>()[firstName, lastName] },
 
-        df.select {
-            pathOf("name").cols(name.firstName, name.lastName)
-        } shouldBe df.select {
-            pathOf("name")[name.firstName, name.lastName]
-        }
+            df.select { name.select { cols(this@select.firstName, this@select.lastName) } },
+
+            df.select { "name".cols(firstName, lastName) },
+            df.select { "name"[firstName, lastName] },
+
+            df.select { Person::name.cols(firstName, lastName) },
+            df.select { Person::name[firstName, lastName] },
+
+            df.select { pathOf("name").cols(firstName, lastName) },
+            df.select { pathOf("name")[firstName, lastName] },
+
+            df.select { it["name"].cols(firstName, lastName) },
+            df.select { it["name"][firstName, lastName] },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun `cols and get with column names`() {
-        df.select { all().cols("name", "age") } shouldBe df.select { cols("name", "age") }
-        df.select { all()["name", "age"] } shouldBe df.select { this["name", "age"] }
+        listOf(
+            df.select { name and age },
 
-        df.select {
-            name.cols("firstName", "lastName")
-        } shouldBe df.select {
-            name.colsOf<String>().cols("firstName", "lastName")
-        }
+            df.select { cols("name", "age") },
+            df.select { this["name", "age"] },
+            df.select { it["name", "age"] },
 
-        df.select {
-//            name["firstName", "lastName"]
-            name.cols("firstName", "lastName")
-        } shouldBe df.select {
-            name.colsOf<String>()["firstName", "lastName"]
-        }
+            df.select { all().cols("name", "age") },
+            df.select { all()["name", "age"] },
+        ).shouldAllBeEqual()
 
-        df.select {
-            "name".cols("firstName", "lastName")
-        } shouldBe df.select {
-            Person::name.cols("firstName", "lastName")
-        }
+        listOf(
+            df.select { name.firstName and name.lastName },
 
-        df.select {
-            "name"["firstName", "lastName"]
-        } shouldBe df.select {
-            Person::name["firstName", "lastName"]
-        }
+            df.select { name.cols("firstName", "lastName") },
+//            df.select { name["firstName", "lastName"] },
 
-        df.select {
-            pathOf("name").cols("firstName", "lastName")
-        } shouldBe df.select {
-            pathOf("name")["firstName", "lastName"]
-        }
+            df.select { name.colsOf<String>().cols("firstName", "lastName") },
+            df.select { name.colsOf<String>()["firstName", "lastName"] },
+
+            df.select { "name".cols("firstName", "lastName") },
+            df.select { "name"["firstName", "lastName"] },
+            df.select { "name"["firstName"] and "name"["lastName"] },
+
+            df.select { Person::name.cols("firstName", "lastName") },
+            df.select { Person::name["firstName", "lastName"] },
+
+            df.select { pathOf("name").cols("firstName", "lastName") },
+            df.select { pathOf("name")["firstName", "lastName"] },
+
+            df.select { it["name"].cols("firstName", "lastName") },
+            df.select { it["name"]["firstName", "lastName"] },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun `cols and get with column paths`() {
         listOf(
-            df.select {
-                all().cols(pathOf("name", "firstName"))
-            },
-            df.select {
-                cols(pathOf("name", "firstName"))
-            },
-            df.select {
-                pathOf("name", "firstName")
-            },
-            df.select {
-                name.firstName
-            },
-        ).reduce { acc, dataFrame ->
-            acc shouldBe dataFrame
-            dataFrame
-        }
+            df.select { name.firstName },
 
-        df.select { all().cols(pathOf("name"), pathOf("age")) } shouldBe df.select {
-            cols(
-                pathOf("name"),
-                pathOf("age")
-            )
-        }
-        df.select { all()[pathOf("name"), pathOf("age")] } shouldBe df.select { this[pathOf("name"), pathOf("age")] }
+            df.select { cols(pathOf("name", "firstName")) },
+            df.select { this[pathOf("name", "firstName")] },
+            df.select { it[pathOf("name", "firstName")] },
 
-        df.select {
-            name.cols(pathOf("firstName"), pathOf("lastName"))
-        } shouldBe df.select {
-            name.colsOf<String>().cols(pathOf("firstName"), pathOf("lastName"))
-        }
+            df.select { all().cols(pathOf("name", "firstName")) },
+            df.select { all()[pathOf("name", "firstName")] },
 
-        df.select {
-//            name[pathOf("firstName"), pathOf("lastName")]
-            name.cols(pathOf("firstName"), pathOf("lastName"))
-        } shouldBe df.select {
-            name.colsOf<String>()[pathOf("firstName"), pathOf("lastName")]
-        }
+            df.select { pathOf("name", "firstName") },
+        ).shouldAllBeEqual()
 
-        df.select {
-            "name".cols(pathOf("firstName"), pathOf("lastName"))
-        } shouldBe df.select {
-            Person::name.cols(pathOf("firstName"), pathOf("lastName"))
-        }
+        listOf(
+            df.select { name and age },
 
-        df.select {
-            "name"[pathOf("firstName"), pathOf("lastName")]
-        } shouldBe df.select {
-            Person::name[pathOf("firstName"), pathOf("lastName")]
-        }
+            df.select { cols(pathOf("name"), pathOf("age")) },
+            df.select { this[pathOf("name"), pathOf("age")] },
+            df.select { it[pathOf("name"), pathOf("age")] },
 
-        df.select {
-            pathOf("name").cols(pathOf("firstName"), pathOf("lastName"))
-        } shouldBe df.select {
-            pathOf("name")[pathOf("firstName"), pathOf("lastName")]
-        }
+            df.select { all().cols(pathOf("name"), pathOf("age")) },
+            df.select { all()[pathOf("name"), pathOf("age")] },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.firstName and name.lastName },
+
+            df.select { name.cols(pathOf("firstName"), pathOf("lastName")) },
+//            df.select { name[pathOf("firstName"), pathOf("lastName")] },
+
+            df.select { name.colsOf<String>().cols(pathOf("firstName"), pathOf("lastName")) },
+            df.select { name.colsOf<String>()[pathOf("firstName"), pathOf("lastName")] },
+
+            df.select { "name".cols(pathOf("firstName"), pathOf("lastName")) },
+            df.select { "name"[pathOf("firstName"), pathOf("lastName")] },
+
+            df.select { Person::name.cols(pathOf("firstName"), pathOf("lastName")) },
+            df.select { Person::name[pathOf("firstName"), pathOf("lastName")] },
+
+            df.select { pathOf("name").cols(pathOf("firstName"), pathOf("lastName")) },
+            df.select { pathOf("name")[pathOf("firstName"), pathOf("lastName")] },
+
+            df.select { it["name"].cols(pathOf("firstName"), pathOf("lastName")) },
+            df.select { it["name"][pathOf("firstName"), pathOf("lastName")] },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun `cols and get with KProperties`() {
-        df.select { all().cols(Person::name, Person::age) } shouldBe df.select { cols(Person::name, Person::age) }
-        df.select { all()[Person::name, Person::age] } shouldBe df.select { this[Person::name, Person::age] }
+        listOf(
+            df.select { name and age },
 
-        df.select {
-            name.cols(Name::firstName, Name::lastName)
-        } shouldBe df.select {
-            name.colsOf<String>().cols(Name::firstName, Name::lastName)
-        }
+            df.select { cols(Person::name, Person::age) },
+            df.select { this[Person::name, Person::age] },
+            df.select { it[Person::name, Person::age] },
 
-        df.select {
-            name[Name::firstName, Name::lastName]
-        } shouldBe df.select {
-            name.colsOf<String>()[Name::firstName, Name::lastName]
-        }
+            df.select { all().cols(Person::name, Person::age) },
+            df.select { all()[Person::name, Person::age] },
+        ).shouldAllBeEqual()
 
-        df.select {
-            "name".cols(Name::firstName, Name::lastName)
-        } shouldBe df.select {
-            Person::name.cols(Name::firstName, Name::lastName)
-        }
+        listOf(
+            df.select { name.firstName and name.lastName },
 
-        df.select {
-            "name"[Name::firstName, Name::lastName]
-        } shouldBe df.select {
-            Person::name[Name::firstName, Name::lastName]
-        }
+            df.select { name.cols(Name::firstName, Name::lastName) },
+            df.select { name[Name::firstName, Name::lastName] },
 
-        df.select {
-            pathOf("name").cols(Name::firstName, Name::lastName)
-        } shouldBe df.select {
-            pathOf("name")[Name::firstName, Name::lastName]
-        }
+            df.select { name.colsOf<String>().cols(Name::firstName, Name::lastName) },
+            df.select { name.colsOf<String>()[Name::firstName, Name::lastName] },
+
+            df.select { "name".cols(Name::firstName, Name::lastName) },
+            df.select { "name"[Name::firstName, Name::lastName] },
+
+            df.select { Person::name.cols(Name::firstName, Name::lastName) },
+            df.select { Person::name[Name::firstName, Name::lastName] },
+
+            df.select { pathOf("name").cols(Name::firstName, Name::lastName) },
+            df.select { pathOf("name")[Name::firstName, Name::lastName] },
+
+            df.select { it["name"].cols(Name::firstName, Name::lastName) },
+            df.select { it["name"][Name::firstName, Name::lastName] },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun `cols and get with indices`() {
-        df.select { all().cols(0, 1) } shouldBe df.select { cols(0, 1) }
-        df.select { all()[0, 1] } shouldBe df.select { this[0, 1] }
+        listOf(
+            df.select { name and age },
 
-        df.select {
-            name.cols(0, 1)
-        } shouldBe df.select {
-            name.colsOf<String>().cols(0, 1)
-        }
+            df.select { cols(0, 1) },
+            df.select { this[0, 1] },
+            df.select { it[0, 1] },
 
-        df.select {
-//            name[0, 1]
-            name.cols(0, 1)
-        } shouldBe df.select {
-            name.colsOf<String>()[0, 1]
-        }
+            df.select { all().cols(0, 1) },
+            df.select { all()[0, 1] },
+        ).shouldAllBeEqual()
 
-        df.select {
-            "name".cols(0, 1)
-        } shouldBe df.select {
-            Person::name.cols(0, 1)
-        }
+        listOf(
+            df.select { name.firstName and name.lastName },
 
-        df.select {
-            "name"[0, 1]
-        } shouldBe df.select {
-            Person::name[0, 1]
-        }
+            df.select { name.cols(0, 1) },
+//            df.select { name[0, 1] },
 
-        df.select {
-            pathOf("name").cols(0, 1)
-        } shouldBe df.select {
-            pathOf("name")[0, 1]
-        }
+            df.select { name.colsOf<String>().cols(0, 1) },
+            df.select { name.colsOf<String>()[0, 1] },
+
+            df.select { "name".cols(0, 1) },
+            df.select { "name"[0, 1] },
+
+            df.select { Person::name.cols(0, 1) },
+            df.select { Person::name[0, 1] },
+
+            df.select { pathOf("name").cols(0, 1) },
+            df.select { pathOf("name")[0, 1] },
+
+            df.select { it["name"].cols(0, 1) },
+//            df.select { it["name"][0, 1] },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun `cols and get with range`() {
-        df.select { all().cols(0..1) } shouldBe df.select { cols(0..1) }
-        df.select { all()[0..1] } shouldBe df.select { this[0..1] }
+        listOf(
+            df.select { name and age },
 
-        df.select {
-            name.cols(0..1)
-        } shouldBe df.select {
-            name.colsOf<String>().cols(0..1)
-        }
+            df.select { cols(0..1) },
+            df.select { this[0..1] },
+            df.select { it[0..1] },
 
-        df.select {
-//            name[0..1]
-            name.cols(0..1)
-        } shouldBe df.select {
-            name.colsOf<String>()[0..1]
-        }
+            df.select { all().cols(0..1) },
+            df.select { all()[0..1] },
+        ).shouldAllBeEqual()
 
-        df.select {
-            "name".cols(0..1)
-        } shouldBe df.select {
-            Person::name.cols(0..1)
-        }
+        listOf(
+            df.select { name.firstName and name.lastName },
 
-        df.select {
-            "name"[0..1]
-        } shouldBe df.select {
-            Person::name[0..1]
-        }
+            df.select { name.cols(0..1) },
+//            df.select { name[0..1] },
 
-        df.select {
-            pathOf("name").cols(0..1)
-        } shouldBe df.select {
-            pathOf("name")[0..1]
-        }
+            df.select { name.colsOf<String>().cols(0..1) },
+            df.select { name.colsOf<String>()[0..1] },
+
+            df.select { "name".cols(0..1) },
+            df.select { "name"[0..1] },
+
+            df.select { Person::name.cols(0..1) },
+            df.select { Person::name[0..1] },
+
+            df.select { pathOf("name").cols(0..1) },
+            df.select { pathOf("name")[0..1] },
+
+            df.select { it["name"].cols(0..1) },
+//            df.select { it["name"][0..1] },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun roots() {
+        df.select { cols(name.firstName, name.lastName, age).roots() } shouldBe
+            df.select { cols(name.firstName, name.lastName, age) }
+
+        df.select { cols(name.firstName, name.lastName, age, name).roots() } shouldBe
+            df.select { cols(name, age) }
     }
 }
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
index f585e6b22..5c7357b1c 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
@@ -27,14 +27,18 @@ class MoveTests {
     }
 
     @Test
-    fun `select all dfs`() {
-        val selected = grouped.getColumnsWithPaths { all().allDfs() }.map { it.path.joinToString(".") }
+    fun `select all allRecursively`() {
+        val selected = grouped
+            .getColumnsWithPaths { children { !it.isColumnGroup() }.recursively() }
+            .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 { dfs { it.depth() > 0 && !it.isColumnGroup() } }.into { pathOf(it.path.joinToString(".")) }
+        val ungrouped = grouped.move {
+            cols { it.depth() > 0 && !it.isColumnGroup() }.rec()
+        }.into { pathOf(it.path.joinToString(".")) }
         ungrouped.columnNames() shouldBe listOf("q", "a.b", "a.c.d", "b.c", "b.d", "w", "e.f", "r")
     }
 
@@ -64,15 +68,19 @@ class MoveTests {
     }
 
     @Test
-    fun `select Dfs`() {
-        val selected = grouped.select { it["a"].dfs { !it.isColumnGroup() } }
+    fun `select recursively`() {
+        val selected = grouped.select {
+            it["a"].cols { !it.isColumnGroup() }.recursively()
+        }
         selected.columnNames() shouldBe listOf("b", "d")
     }
 
     @Test
     fun `columnsWithPath in selector`() {
         val selected = grouped.getColumnsWithPaths { it["a"] }
-        val actual = grouped.getColumnsWithPaths { selected.map { it.allDfs() }.toColumnSet() }
+        val actual = grouped.getColumnsWithPaths {
+            selected.map { it.cols { !it.isColumnGroup() }.recursively() }.toColumnSet()
+        }
         actual.map { it.path.joinToString(".") } shouldBe listOf("a.b", "a.c.d")
     }
 
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
index 727165729..36cc299a4 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
@@ -41,7 +41,7 @@ class PivotTests {
         }
         pivoted.columnsCount() shouldBe 3
         pivoted.rowsCount() shouldBe 2
-        val cols = pivoted.getColumns { except(a).allDfs() }
+        val cols = pivoted.getColumns { except(a).cols { !it.isColumnGroup() }.rec() }
         cols.size shouldBe 4
         cols.forEach {
             it.type() shouldBe typeOf<Char>()
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/recursively.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/recursively.kt
new file mode 100644
index 000000000..38e89fce0
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/recursively.kt
@@ -0,0 +1,108 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.shouldNotBe
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.samples.api.TestBase
+import org.jetbrains.kotlinx.dataframe.samples.api.city
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.junit.Test
+
+class Recursively : TestBase() {
+
+    fun List<ColumnWithPath<*>>.print() {
+        forEach {
+            if (it.isValueColumn()) println("${it.name}: ${it.type()}")
+            else it.print()
+        }
+        println()
+    }
+
+    infix fun List<ColumnWithPath<*>>.shouldBe(other: List<ColumnWithPath<*>>) {
+        this.map { it.name to it.path } shouldBe other.map { it.name to it.path }
+    }
+
+    infix fun List<ColumnWithPath<*>>.shouldNotBe(other: List<ColumnWithPath<*>>) {
+        this.map { it.name to it.path } shouldNotBe other.map { it.name to it.path }
+    }
+
+    private val recursivelyGoal = dfGroup.getColumnsWithPaths { dfs { true } }
+        .sortedBy { it.name }
+
+    private val recursivelyNoGroups = dfGroup.getColumnsWithPaths { allDfs(false) }
+        .sortedBy { it.name }
+
+    private val recursivelyString = dfGroup.getColumnsWithPaths { dfsOf<String?>() }
+        .sortedBy { it.name }
+
+    @Test
+    fun `first, last, and single`() {
+        listOf(
+            dfGroup.select { name.firstName.firstName },
+
+            dfGroup.select { first { col -> col.any { it == "Alice" } }.recursively() },
+            dfGroup.select { last { col -> col.any { it == "Alice" } }.recursively() },
+            dfGroup.select { single { col -> col.any { it == "Alice" } }.recursively() },
+        ).shouldAllBeEqual()
+
+        listOf(
+            dfGroup.select { city },
+
+            dfGroup.select { first { col -> col.any { it == "London" } }.recursively() },
+            dfGroup.select { last { col -> col.any { it == "London" } }.recursively() },
+            dfGroup.select { single { col -> col.any { it == "London" } }.recursively() },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `children`() {
+        dfGroup.getColumnsWithPaths { children().recursively() }.print()
+        dfGroup.getColumnsWithPaths { name.children() }.print()
+    }
+
+    @Test
+    fun `groups`() {
+        listOf(
+            df.select { name },
+            df.select { groups().recursively() },
+            df.select { groups() },
+            df.select { all().groups() },
+            df.select { all().groups().rec() },
+        ).shouldAllBeEqual()
+
+        dfGroup.select { groups() } shouldBe dfGroup.select { name }
+        dfGroup.select { groups().rec() } shouldBe dfGroup.select { name and name.firstName }
+    }
+
+    @Test
+    fun `all recursively`() {
+        dfGroup.getColumnsWithPaths { all().recursively() }.sortedBy { it.name } shouldBe recursivelyGoal
+        dfGroup.getColumnsWithPaths { all().cols { !it.isColumnGroup() }.rec() }
+            .sortedBy { it.name } shouldBe recursivelyNoGroups
+    }
+
+    @Test
+    fun `cols recursively`() {
+        dfGroup.getColumnsWithPaths { cols().recursively() }.sortedBy { it.name } shouldBe recursivelyGoal
+    }
+
+    @Test
+    fun `colsOf recursively`() {
+        dfGroup.getColumnsWithPaths { colsOf<String?>().recursively() }.sortedBy { it.name } shouldBe recursivelyString
+    }
+
+    @Test
+    fun `all allRecursively`() {
+        dfGroup.getColumnsWithPaths { all().all().recursively() }.sortedBy { it.name } shouldBe recursivelyGoal
+        dfGroup.getColumnsWithPaths { all().cols { !it.isColumnGroup() }.recursively() }
+            .sortedBy { it.name } shouldBe recursivelyNoGroups
+    }
+
+    @Test
+    fun `cols allRecursively`() {
+        dfGroup.getColumnsWithPaths { cols().all().recursively() }.sortedBy { it.name } shouldBe recursivelyGoal
+        dfGroup.getColumnsWithPaths { cols().cols { !it.isColumnGroup() }.recursively() }
+            .sortedBy { it.name } shouldBe recursivelyNoGroups
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
index 87e28271c..94e64ed3c 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
@@ -24,7 +24,7 @@ class ReorderTests {
         sorted1.columnNames() shouldBe listOf("b", "a")
         sorted1["a"].asColumnGroup().columnNames() shouldBe listOf("a", "c")
 
-        val sorted2 = df.reorder { allDfs(true) }.byName()
+        val sorted2 = df.reorder { all().recursively() }.byName()
         sorted2.columnNames() shouldBe listOf("a", "b")
         sorted2["a"].asColumnGroup().columnNames() shouldBe listOf("a", "c")
     }
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/PlaylistJsonTest.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/PlaylistJsonTest.kt
index 02cdc6642..4366dd86a 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/PlaylistJsonTest.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/PlaylistJsonTest.kt
@@ -136,7 +136,9 @@ class PlaylistJsonTest {
 
     @Test
     fun `deep batch update all`() {
-        val updated = item.convert { dfs { it.name() == "url" } }.with { (it as? String)?.let { IMG(it) } }
+        val updated = item
+            .convert { cols { it.name() == "url" }.rec() }
+            .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?>()
         updated.snippet.thumbnails.standard.url.type() shouldBe typeOf<IMG?>()
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Access.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Access.kt
index 438c3bbf8..f44ce9fd2 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Access.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Access.kt
@@ -701,7 +701,7 @@ class Access : TestBase() {
     fun columnSelectorsUsages() {
         // SampleStart
         df.select { age and name }
-        df.fillNaNs { dfsOf<Double>() }.withZero()
+        df.fillNaNs { colsOf<Double>().recursively() }.withZero()
         df.remove { cols { it.hasNulls() } }
         df.group { cols { it.data != name } }.into { "nameless" }
         df.update { city }.notNull { it.lowercase() }
@@ -739,8 +739,8 @@ class Access : TestBase() {
         // all children of ColumnGroup
         df.select { name.all() }
 
-        // depth-first-search traversal of all children columns
-        df.select { name.allDfs() }
+        // recursive traversal of all children columns excluding ColumnGroups
+        df.select { name.cols { !it.isColumnGroup() }.recursively() }
 
         // SampleEnd
     }
@@ -777,8 +777,8 @@ class Access : TestBase() {
         // all children of ColumnGroup
         df.select { name.all() }
 
-        // depth-first-search traversal of all children columns
-        df.select { name.allDfs() }
+        // recursive traversal of all children columns excluding ColumnGroups
+        df.select { name.cols { !it.isColumnGroup() }.recursively() }
         // SampleEnd
     }
 
@@ -812,8 +812,8 @@ class Access : TestBase() {
         // all children of ColumnGroup
         df.select { Person::name.all() }
 
-        // depth-first-search traversal of all children columns
-        df.select { Person::name.allDfs() }
+        // recursive traversal of all children columns excluding groups
+        df.select { Person::name.cols { !it.isColumnGroup() }.recursively() }
         // SampleEnd
     }
 
@@ -846,8 +846,8 @@ class Access : TestBase() {
         // all children of ColumnGroup
         df.select { "name".all() }
 
-        // depth-first-search traversal of all children columns
-        df.select { "name".allDfs() }
+        // recursive traversal of all children columns excluding groups
+        df.select { "name".cols { !it.isColumnGroup() }.recursively() }
         // SampleEnd
     }
 
@@ -905,17 +905,17 @@ class Access : TestBase() {
             Person::name.single { it.name().startsWith("first") }
         }
 
-        // depth-first-search traversal of all columns, excluding ColumnGroups from result
-        df.select { allDfs() }
+        // recursive traversal of all columns, excluding ColumnGroups from result
+        df.select { cols { !it.isColumnGroup() }.recursively() }
 
         // depth-first-search traversal of all columns, including ColumnGroups in result
-        df.select { allDfs(includeGroups = true) }
+        df.select { all().recursively() }
 
-        // depth-first-search traversal with condition
-        df.select { dfs { it.name().contains(":") } }
+        // recursive traversal with condition
+        df.select { cols { it.name().contains(":") }.recursively() }
 
-        // depth-first-search traversal of columns of given type
-        df.select { dfsOf<String>() }
+        // recursive traversal of columns of given type
+        df.select { colsOf<String>().rec() }
 
         // all columns except given column set
         df.select { except { colsOf<String>() } }
@@ -929,19 +929,19 @@ class Access : TestBase() {
     @TransformDataFrameExpressions
     fun columnSelectorsModifySet() {
         // SampleStart
-        // first/last n columns in column set
-        df.select { allDfs().take(3) }
-        df.select { allDfs().takeLast(3) }
+        // first/last n value- and frame columns in column set
+        df.select { cols { !it.isColumnGroup() }.recursively().take(3) }
+        df.select { cols { !it.isColumnGroup() }.recursively().takeLast(3) }
 
-        // all except first/last n columns in column set
-        df.select { allDfs().drop(3) }
-        df.select { allDfs().dropLast(3) }
+        // all except first/last n value- and frame columns in column set
+        df.select { cols { !it.isColumnGroup() }.recursively().drop(3) }
+        df.select { cols { !it.isColumnGroup() }.recursively().dropLast(3) }
 
         // filter column set by condition
-        df.select { allDfs().filter { it.name().startsWith("year") } }
+        df.select { cols { !it.isColumnGroup() }.rec().filter { it.name().startsWith("year") } }
 
         // exclude columns from column set
-        df.select { allDfs().except { age } }
+        df.select { cols { !it.isColumnGroup() }.rec().except { age } }
 
         // keep only unique columns
         df.select { (colsOf<Int>() and age).distinct() }
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Modify.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Modify.kt
index b71f65655..aceb0156e 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Modify.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Modify.kt
@@ -23,7 +23,6 @@ import org.jetbrains.kotlinx.dataframe.api.convert
 import org.jetbrains.kotlinx.dataframe.api.convertTo
 import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
 import org.jetbrains.kotlinx.dataframe.api.default
-import org.jetbrains.kotlinx.dataframe.api.dfsOf
 import org.jetbrains.kotlinx.dataframe.api.dropNulls
 import org.jetbrains.kotlinx.dataframe.api.explode
 import org.jetbrains.kotlinx.dataframe.api.fill
@@ -120,7 +119,7 @@ class Modify : TestBase() {
     fun update() {
         // SampleStart
         df.update { age }.with { it * 2 }
-        df.update { dfsOf<String>() }.with { it.uppercase() }
+        df.update { colsOf<String>().recursively() }.with { it.uppercase() }
         df.update { weight }.at(1..4).notNull { it / 2 }
         df.update { name.lastName and age }.at(1, 3, 4).withNull()
         // SampleEnd
@@ -181,7 +180,7 @@ class Modify : TestBase() {
     fun convert() {
         // SampleStart
         df.convert { age }.with { it.toDouble() }
-        df.convert { dfsOf<String>() }.with { it.toCharArray().toList() }
+        df.convert { colsOf<String>().recursively() }.with { it.toCharArray().toList() }
         // SampleEnd
     }
 
@@ -338,7 +337,7 @@ class Modify : TestBase() {
 
         // a.b.e -> be
         // c.d.e -> de
-        df.move { dfs { it.name() == "e" } }.toTop { it.parentName + it.name() }
+        df.move { cols { it.name() == "e" }.recursively() }.toTop { it.parentName + it.name() }
         // SampleEnd
     }
 
@@ -779,7 +778,7 @@ class Modify : TestBase() {
 
     @Test
     @TransformDataFrameExpressions
-    fun concatDfs() {
+    fun concatDataFrames() {
         val df1 = df
         val df2 = df
         // SampleStart
@@ -906,7 +905,7 @@ class Modify : TestBase() {
 
     @Test
     @TransformDataFrameExpressions
-    fun addDfs() {
+    fun addDataFrames() {
         val df1 = df.select { name named "name2" }
         val df2 = df.select { age named "age2" }
         // SampleStart
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/TestBase.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/TestBase.kt
index 4f738e1fe..4e4d2ce04 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/TestBase.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/TestBase.kt
@@ -1,13 +1,12 @@
 package org.jetbrains.kotlinx.dataframe.samples.api
 
+import io.kotest.matchers.should
 import io.kotest.matchers.shouldBe
 import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
-import org.jetbrains.kotlinx.dataframe.api.cast
-import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
-import org.jetbrains.kotlinx.dataframe.api.group
-import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.*
 import org.jetbrains.kotlinx.dataframe.explainer.PluginCallbackProxy
+import org.jetbrains.kotlinx.dataframe.impl.columns.asValueColumn
 import org.junit.After
 import org.junit.Before
 
@@ -41,6 +40,16 @@ public open class TestBase {
         "Charlie", "Byrd", 30, "Moscow", 90, true
     ).group("firstName", "lastName").into("name").cast<Person>()
 
+    val dfGroup = df.convert { name.firstName }.to {
+        val firstName by it
+        val secondName by it.map<_, String?> { null }.asValueColumn()
+        val thirdName by it.map<_, String?> { null }.asValueColumn()
+
+        dataFrameOf(firstName, secondName, thirdName)
+            .cast<FirstNames>(verify = true)
+            .asColumnGroup("firstName")
+    }.cast<Person2>(verify = true)
+
     @DataSchema
     interface Name {
         val firstName: String
@@ -56,5 +65,34 @@ public open class TestBase {
         val isHappy: Boolean
     }
 
+    @DataSchema
+    interface FirstNames {
+        val firstName: String
+        val secondName: String?
+        val thirdName: String?
+    }
+
+    @DataSchema
+    interface Name2 {
+        val firstName: DataRow<FirstNames>
+        val lastName: String
+    }
+
+    @DataSchema
+    interface Person2 {
+        val age: Int
+        val city: String?
+        val name: DataRow<Name2>
+        val weight: Int?
+        val isHappy: Boolean
+    }
+
     infix fun <T, U : T> T.willBe(expected: U?) = shouldBe(expected)
+
+    fun <T> Iterable<T>.shouldAllBeEqual(): Iterable<T> {
+        this should {
+            it.reduce { a, b -> a shouldBe b; b }
+        }
+        return this
+    }
 }
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTests.kt
index c33a44cc6..4bd50bad7 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTests.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTests.kt
@@ -5,181 +5,20 @@ import io.kotest.matchers.doubles.ToleranceMatcher
 import io.kotest.matchers.should
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
-import org.jetbrains.kotlinx.dataframe.AnyFrame
-import org.jetbrains.kotlinx.dataframe.AnyRow
-import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.DataRow
-import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.*
 import org.jetbrains.kotlinx.dataframe.annotations.ColumnName
 import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
-import org.jetbrains.kotlinx.dataframe.api.ExcessiveColumns
-import org.jetbrains.kotlinx.dataframe.api.GroupBy
-import org.jetbrains.kotlinx.dataframe.api.ParserOptions
-import org.jetbrains.kotlinx.dataframe.api.add
-import org.jetbrains.kotlinx.dataframe.api.addAll
-import org.jetbrains.kotlinx.dataframe.api.addId
-import org.jetbrains.kotlinx.dataframe.api.all
-import org.jetbrains.kotlinx.dataframe.api.allNulls
-import org.jetbrains.kotlinx.dataframe.api.append
-import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.asDataFrame
-import org.jetbrains.kotlinx.dataframe.api.asGroupBy
-import org.jetbrains.kotlinx.dataframe.api.asIterable
-import org.jetbrains.kotlinx.dataframe.api.at
-import org.jetbrains.kotlinx.dataframe.api.between
-import org.jetbrains.kotlinx.dataframe.api.by
-import org.jetbrains.kotlinx.dataframe.api.cast
-import org.jetbrains.kotlinx.dataframe.api.chunked
-import org.jetbrains.kotlinx.dataframe.api.colsOf
-import org.jetbrains.kotlinx.dataframe.api.column
-import org.jetbrains.kotlinx.dataframe.api.columnGroup
-import org.jetbrains.kotlinx.dataframe.api.columnOf
-import org.jetbrains.kotlinx.dataframe.api.concat
-import org.jetbrains.kotlinx.dataframe.api.convert
-import org.jetbrains.kotlinx.dataframe.api.convertTo
-import org.jetbrains.kotlinx.dataframe.api.corr
-import org.jetbrains.kotlinx.dataframe.api.count
-import org.jetbrains.kotlinx.dataframe.api.countDistinct
-import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
-import org.jetbrains.kotlinx.dataframe.api.default
-import org.jetbrains.kotlinx.dataframe.api.describe
-import org.jetbrains.kotlinx.dataframe.api.dfsOf
-import org.jetbrains.kotlinx.dataframe.api.digitize
-import org.jetbrains.kotlinx.dataframe.api.distinct
-import org.jetbrains.kotlinx.dataframe.api.distinctBy
-import org.jetbrains.kotlinx.dataframe.api.div
-import org.jetbrains.kotlinx.dataframe.api.drop
-import org.jetbrains.kotlinx.dataframe.api.dropLast
-import org.jetbrains.kotlinx.dataframe.api.dropNA
-import org.jetbrains.kotlinx.dataframe.api.dropNulls
-import org.jetbrains.kotlinx.dataframe.api.dropWhile
-import org.jetbrains.kotlinx.dataframe.api.explode
-import org.jetbrains.kotlinx.dataframe.api.expr
-import org.jetbrains.kotlinx.dataframe.api.fill
-import org.jetbrains.kotlinx.dataframe.api.fillNulls
-import org.jetbrains.kotlinx.dataframe.api.filter
-import org.jetbrains.kotlinx.dataframe.api.first
-import org.jetbrains.kotlinx.dataframe.api.forEach
-import org.jetbrains.kotlinx.dataframe.api.forEachIndexed
-import org.jetbrains.kotlinx.dataframe.api.frameColumn
-import org.jetbrains.kotlinx.dataframe.api.gather
-import org.jetbrains.kotlinx.dataframe.api.getColumn
-import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.getColumns
-import org.jetbrains.kotlinx.dataframe.api.getFrameColumn
-import org.jetbrains.kotlinx.dataframe.api.getValue
-import org.jetbrains.kotlinx.dataframe.api.group
-import org.jetbrains.kotlinx.dataframe.api.groupBy
-import org.jetbrains.kotlinx.dataframe.api.implode
-import org.jetbrains.kotlinx.dataframe.api.indices
-import org.jetbrains.kotlinx.dataframe.api.inplace
-import org.jetbrains.kotlinx.dataframe.api.into
-import org.jetbrains.kotlinx.dataframe.api.intoColumns
-import org.jetbrains.kotlinx.dataframe.api.intoList
-import org.jetbrains.kotlinx.dataframe.api.intoRows
-import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.isFrameColumn
-import org.jetbrains.kotlinx.dataframe.api.isNA
-import org.jetbrains.kotlinx.dataframe.api.isNumber
-import org.jetbrains.kotlinx.dataframe.api.keysInto
-import org.jetbrains.kotlinx.dataframe.api.last
-import org.jetbrains.kotlinx.dataframe.api.leftJoin
-import org.jetbrains.kotlinx.dataframe.api.lowercase
-import org.jetbrains.kotlinx.dataframe.api.map
-import org.jetbrains.kotlinx.dataframe.api.mapToFrame
-import org.jetbrains.kotlinx.dataframe.api.match
-import org.jetbrains.kotlinx.dataframe.api.matches
-import org.jetbrains.kotlinx.dataframe.api.max
-import org.jetbrains.kotlinx.dataframe.api.maxBy
-import org.jetbrains.kotlinx.dataframe.api.mean
-import org.jetbrains.kotlinx.dataframe.api.meanFor
-import org.jetbrains.kotlinx.dataframe.api.meanOf
-import org.jetbrains.kotlinx.dataframe.api.median
-import org.jetbrains.kotlinx.dataframe.api.merge
-import org.jetbrains.kotlinx.dataframe.api.min
-import org.jetbrains.kotlinx.dataframe.api.minBy
-import org.jetbrains.kotlinx.dataframe.api.minOf
-import org.jetbrains.kotlinx.dataframe.api.minus
-import org.jetbrains.kotlinx.dataframe.api.move
-import org.jetbrains.kotlinx.dataframe.api.moveTo
-import org.jetbrains.kotlinx.dataframe.api.moveToLeft
-import org.jetbrains.kotlinx.dataframe.api.moveToRight
+import org.jetbrains.kotlinx.dataframe.api.*
 import org.jetbrains.kotlinx.dataframe.api.name
-import org.jetbrains.kotlinx.dataframe.api.named
-import org.jetbrains.kotlinx.dataframe.api.notNull
-import org.jetbrains.kotlinx.dataframe.api.nullable
-import org.jetbrains.kotlinx.dataframe.api.parse
-import org.jetbrains.kotlinx.dataframe.api.pathOf
-import org.jetbrains.kotlinx.dataframe.api.pivot
-import org.jetbrains.kotlinx.dataframe.api.print
-import org.jetbrains.kotlinx.dataframe.api.remove
-import org.jetbrains.kotlinx.dataframe.api.rename
-import org.jetbrains.kotlinx.dataframe.api.reorderColumnsByName
-import org.jetbrains.kotlinx.dataframe.api.replace
-import org.jetbrains.kotlinx.dataframe.api.rows
-import org.jetbrains.kotlinx.dataframe.api.select
-import org.jetbrains.kotlinx.dataframe.api.single
-import org.jetbrains.kotlinx.dataframe.api.sortBy
-import org.jetbrains.kotlinx.dataframe.api.sortByCount
-import org.jetbrains.kotlinx.dataframe.api.sortByDesc
-import org.jetbrains.kotlinx.dataframe.api.sortByKey
-import org.jetbrains.kotlinx.dataframe.api.sortWith
-import org.jetbrains.kotlinx.dataframe.api.split
-import org.jetbrains.kotlinx.dataframe.api.sum
-import org.jetbrains.kotlinx.dataframe.api.sumOf
-import org.jetbrains.kotlinx.dataframe.api.take
-import org.jetbrains.kotlinx.dataframe.api.takeLast
-import org.jetbrains.kotlinx.dataframe.api.takeWhile
-import org.jetbrains.kotlinx.dataframe.api.times
-import org.jetbrains.kotlinx.dataframe.api.to
-import org.jetbrains.kotlinx.dataframe.api.toColumn
-import org.jetbrains.kotlinx.dataframe.api.toColumnAccessor
-import org.jetbrains.kotlinx.dataframe.api.toColumnOf
-import org.jetbrains.kotlinx.dataframe.api.toDataFrame
-import org.jetbrains.kotlinx.dataframe.api.toDouble
-import org.jetbrains.kotlinx.dataframe.api.toInt
-import org.jetbrains.kotlinx.dataframe.api.toList
-import org.jetbrains.kotlinx.dataframe.api.toListOf
-import org.jetbrains.kotlinx.dataframe.api.toMap
-import org.jetbrains.kotlinx.dataframe.api.toRight
-import org.jetbrains.kotlinx.dataframe.api.toStr
-import org.jetbrains.kotlinx.dataframe.api.toValueColumn
-import org.jetbrains.kotlinx.dataframe.api.transpose
-import org.jetbrains.kotlinx.dataframe.api.under
-import org.jetbrains.kotlinx.dataframe.api.ungroup
-import org.jetbrains.kotlinx.dataframe.api.update
-import org.jetbrains.kotlinx.dataframe.api.value
-import org.jetbrains.kotlinx.dataframe.api.values
-import org.jetbrains.kotlinx.dataframe.api.valuesNotNull
-import org.jetbrains.kotlinx.dataframe.api.where
-import org.jetbrains.kotlinx.dataframe.api.with
-import org.jetbrains.kotlinx.dataframe.api.withNull
-import org.jetbrains.kotlinx.dataframe.api.withValue
-import org.jetbrains.kotlinx.dataframe.api.withValues
-import org.jetbrains.kotlinx.dataframe.api.withZero
-import org.jetbrains.kotlinx.dataframe.api.xs
 import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
 import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
 import org.jetbrains.kotlinx.dataframe.exceptions.ExcessiveColumnsException
 import org.jetbrains.kotlinx.dataframe.exceptions.TypeConversionException
-import org.jetbrains.kotlinx.dataframe.hasNulls
-import org.jetbrains.kotlinx.dataframe.impl.DataFrameSize
+import org.jetbrains.kotlinx.dataframe.impl.*
 import org.jetbrains.kotlinx.dataframe.impl.api.convertToImpl
-import org.jetbrains.kotlinx.dataframe.impl.between
 import org.jetbrains.kotlinx.dataframe.impl.columns.isMissingColumn
-import org.jetbrains.kotlinx.dataframe.impl.emptyPath
-import org.jetbrains.kotlinx.dataframe.impl.getColumnsImpl
-import org.jetbrains.kotlinx.dataframe.impl.nothingType
-import org.jetbrains.kotlinx.dataframe.impl.trackColumnAccess
-import org.jetbrains.kotlinx.dataframe.index
 import org.jetbrains.kotlinx.dataframe.io.renderValueForStdout
-import org.jetbrains.kotlinx.dataframe.kind
 import org.jetbrains.kotlinx.dataframe.math.mean
-import org.jetbrains.kotlinx.dataframe.ncol
-import org.jetbrains.kotlinx.dataframe.nrow
-import org.jetbrains.kotlinx.dataframe.size
-import org.jetbrains.kotlinx.dataframe.type
-import org.jetbrains.kotlinx.dataframe.typeClass
 import org.junit.Test
 import java.math.BigDecimal
 import java.time.LocalDate
@@ -911,7 +750,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 { allDfs() }
+        val cols = df.getColumns { cols { !it.isColumnGroup() }.recursively() }
         cols.size shouldBe 5
         cols.forEach {
             it.toList() shouldBe expected
@@ -1165,7 +1004,7 @@ class DataFrameTests : BaseTest() {
     @Test
     fun `gather bool`() {
         val pivoted = typed.pivot { city }.groupBy { name }.matches()
-        val res = pivoted.gather { dfsOf<Boolean>() }.where { it }.keysInto("city")
+        val res = pivoted.gather { colsOf<Boolean>().recursively() }.where { it }.keysInto("city")
         val sorted = res.sortBy { name and city }
         sorted shouldBe typed.select { name and city.map { it.toString() } }.distinct().sortBy { name and city }
     }
@@ -1553,10 +1392,10 @@ class DataFrameTests : BaseTest() {
     @Test
     fun `union table columns`() {
         val grouped = typed.addId("id").groupBy { name }.toDataFrame()
-        val dfs = (0 until grouped.nrow).map {
+        val flattened = (0 until grouped.nrow).map {
             grouped[it..it]
         }
-        val dst = dfs.concat().asGroupBy().concat().sortBy("id").remove("id")
+        val dst = flattened.concat().asGroupBy().concat().sortBy("id").remove("id")
         dst shouldBe typed
     }
 
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTreeTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTreeTests.kt
index d76ad386c..a96b20382 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTreeTests.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTreeTests.kt
@@ -9,84 +9,7 @@ import org.jetbrains.dataframe.impl.codeGen.InterfaceGenerationMode
 import org.jetbrains.dataframe.impl.codeGen.generate
 import org.jetbrains.kotlinx.dataframe.*
 import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
-import org.jetbrains.kotlinx.dataframe.api.GroupBy
-import org.jetbrains.kotlinx.dataframe.api.GroupWithKey
-import org.jetbrains.kotlinx.dataframe.api.add
-import org.jetbrains.kotlinx.dataframe.api.addId
-import org.jetbrains.kotlinx.dataframe.api.after
-import org.jetbrains.kotlinx.dataframe.api.append
-import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.asDataFrame
-import org.jetbrains.kotlinx.dataframe.api.asGroupBy
-import org.jetbrains.kotlinx.dataframe.api.at
-import org.jetbrains.kotlinx.dataframe.api.by
-import org.jetbrains.kotlinx.dataframe.api.cast
-import org.jetbrains.kotlinx.dataframe.api.column
-import org.jetbrains.kotlinx.dataframe.api.columnGroup
-import org.jetbrains.kotlinx.dataframe.api.columnOf
-import org.jetbrains.kotlinx.dataframe.api.columnsCount
-import org.jetbrains.kotlinx.dataframe.api.concat
-import org.jetbrains.kotlinx.dataframe.api.convert
-import org.jetbrains.kotlinx.dataframe.api.count
-import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
-import org.jetbrains.kotlinx.dataframe.api.dfsOf
-import org.jetbrains.kotlinx.dataframe.api.distinct
-import org.jetbrains.kotlinx.dataframe.api.dropNulls
-import org.jetbrains.kotlinx.dataframe.api.duplicate
-import org.jetbrains.kotlinx.dataframe.api.duplicateRows
-import org.jetbrains.kotlinx.dataframe.api.emptyDataFrame
-import org.jetbrains.kotlinx.dataframe.api.explode
-import org.jetbrains.kotlinx.dataframe.api.expr
-import org.jetbrains.kotlinx.dataframe.api.filter
-import org.jetbrains.kotlinx.dataframe.api.forEach
-import org.jetbrains.kotlinx.dataframe.api.frameColumn
-import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.getColumnPath
-import org.jetbrains.kotlinx.dataframe.api.getColumnWithPath
-import org.jetbrains.kotlinx.dataframe.api.getColumns
-import org.jetbrains.kotlinx.dataframe.api.getValue
-import org.jetbrains.kotlinx.dataframe.api.group
-import org.jetbrains.kotlinx.dataframe.api.groupBy
-import org.jetbrains.kotlinx.dataframe.api.implode
-import org.jetbrains.kotlinx.dataframe.api.indices
-import org.jetbrains.kotlinx.dataframe.api.insert
-import org.jetbrains.kotlinx.dataframe.api.into
-import org.jetbrains.kotlinx.dataframe.api.intoRows
-import org.jetbrains.kotlinx.dataframe.api.inward
-import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.isEmpty
-import org.jetbrains.kotlinx.dataframe.api.isFrameColumn
-import org.jetbrains.kotlinx.dataframe.api.join
-import org.jetbrains.kotlinx.dataframe.api.last
-import org.jetbrains.kotlinx.dataframe.api.map
-import org.jetbrains.kotlinx.dataframe.api.max
-import org.jetbrains.kotlinx.dataframe.api.maxBy
-import org.jetbrains.kotlinx.dataframe.api.median
-import org.jetbrains.kotlinx.dataframe.api.minus
-import org.jetbrains.kotlinx.dataframe.api.move
-import org.jetbrains.kotlinx.dataframe.api.moveTo
-import org.jetbrains.kotlinx.dataframe.api.moveToLeft
-import org.jetbrains.kotlinx.dataframe.api.moveToRight
-import org.jetbrains.kotlinx.dataframe.api.pathOf
-import org.jetbrains.kotlinx.dataframe.api.perRowCol
-import org.jetbrains.kotlinx.dataframe.api.pivot
-import org.jetbrains.kotlinx.dataframe.api.remove
-import org.jetbrains.kotlinx.dataframe.api.rename
-import org.jetbrains.kotlinx.dataframe.api.rows
-import org.jetbrains.kotlinx.dataframe.api.select
-import org.jetbrains.kotlinx.dataframe.api.single
-import org.jetbrains.kotlinx.dataframe.api.sortBy
-import org.jetbrains.kotlinx.dataframe.api.split
-import org.jetbrains.kotlinx.dataframe.api.sumOf
-import org.jetbrains.kotlinx.dataframe.api.toColumnAccessor
-import org.jetbrains.kotlinx.dataframe.api.toTop
-import org.jetbrains.kotlinx.dataframe.api.under
-import org.jetbrains.kotlinx.dataframe.api.ungroup
-import org.jetbrains.kotlinx.dataframe.api.update
-import org.jetbrains.kotlinx.dataframe.api.values
-import org.jetbrains.kotlinx.dataframe.api.with
-import org.jetbrains.kotlinx.dataframe.api.withNull
-import org.jetbrains.kotlinx.dataframe.api.xs
+import org.jetbrains.kotlinx.dataframe.api.*
 import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
 import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
 import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
@@ -143,9 +66,9 @@ class DataFrameTreeTests : BaseTest() {
     }
 
     @Test
-    fun `select dfs under group`() {
-        df2.select { nameAndCity.dfsOf<String>() } shouldBe typed2.select { nameAndCity.name }
-        df2.select { nameAndCity.dfsOf<String?>() } shouldBe typed2.select { nameAndCity.name and nameAndCity.city }
+    fun `select recursively under group`() {
+        df2.select { nameAndCity.colsOf<String>().recursively() } shouldBe typed2.select { nameAndCity.name }
+        df2.select { nameAndCity.colsOf<String?>().recursively() } shouldBe typed2.select { nameAndCity.name and nameAndCity.city }
     }
 
     @Test
@@ -249,8 +172,8 @@ class DataFrameTreeTests : BaseTest() {
     }
 
     @Test
-    fun selectDfs() {
-        val cols = typed2.select { dfs { it.hasNulls } }
+    fun `select recursively`() {
+        val cols = typed2.select { cols { it.hasNulls }.rec() }
         cols shouldBe typed2.select { nameAndCity.city and weight }
     }
 
@@ -457,14 +380,14 @@ class DataFrameTreeTests : BaseTest() {
 
     @Test
     fun parentColumnTest() {
-        val res = typed2.move { dfs { it.depth > 0 } }.toTop { it.parentName + "-" + it.name }
+        val res = typed2.move { cols { it.depth > 0 }.rec() }.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 { allDfs() }.into { pathOf(it.path.joinToString(".")) }
+        val joined = typed2.move { cols { !it.isColumnGroup() }.rec() }.into { pathOf(it.path.joinToString(".")) }
         val grouped = joined.group { nameContains(".") }.into { it.name().substringBefore(".") }
         val expected = typed2.rename { nameAndCity.all() }.into { it.path.joinToString(".") }
         grouped shouldBe expected
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/PivotTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/PivotTests.kt
index 5dea9d318..3af47eb35 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/PivotTests.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/PivotTests.kt
@@ -3,56 +3,7 @@ package org.jetbrains.kotlinx.dataframe.testSets.person
 import io.kotest.matchers.shouldBe
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
-import org.jetbrains.kotlinx.dataframe.api.Infer
-import org.jetbrains.kotlinx.dataframe.api.add
-import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.associate
-import org.jetbrains.kotlinx.dataframe.api.cast
-import org.jetbrains.kotlinx.dataframe.api.column
-import org.jetbrains.kotlinx.dataframe.api.columnNames
-import org.jetbrains.kotlinx.dataframe.api.columnOf
-import org.jetbrains.kotlinx.dataframe.api.columnsCount
-import org.jetbrains.kotlinx.dataframe.api.convert
-import org.jetbrains.kotlinx.dataframe.api.count
-import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
-import org.jetbrains.kotlinx.dataframe.api.drop
-import org.jetbrains.kotlinx.dataframe.api.dropNulls
-import org.jetbrains.kotlinx.dataframe.api.explodeLists
-import org.jetbrains.kotlinx.dataframe.api.expr
-import org.jetbrains.kotlinx.dataframe.api.filter
-import org.jetbrains.kotlinx.dataframe.api.first
-import org.jetbrains.kotlinx.dataframe.api.frames
-import org.jetbrains.kotlinx.dataframe.api.gather
-import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.getColumns
-import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
-import org.jetbrains.kotlinx.dataframe.api.group
-import org.jetbrains.kotlinx.dataframe.api.groupBy
-import org.jetbrains.kotlinx.dataframe.api.groupByOther
-import org.jetbrains.kotlinx.dataframe.api.implode
-import org.jetbrains.kotlinx.dataframe.api.into
-import org.jetbrains.kotlinx.dataframe.api.isList
-import org.jetbrains.kotlinx.dataframe.api.join
-import org.jetbrains.kotlinx.dataframe.api.last
-import org.jetbrains.kotlinx.dataframe.api.map
-import org.jetbrains.kotlinx.dataframe.api.mapKeys
-import org.jetbrains.kotlinx.dataframe.api.mapValues
-import org.jetbrains.kotlinx.dataframe.api.matches
-import org.jetbrains.kotlinx.dataframe.api.named
-import org.jetbrains.kotlinx.dataframe.api.notNull
-import org.jetbrains.kotlinx.dataframe.api.pivot
-import org.jetbrains.kotlinx.dataframe.api.print
-import org.jetbrains.kotlinx.dataframe.api.remove
-import org.jetbrains.kotlinx.dataframe.api.replace
-import org.jetbrains.kotlinx.dataframe.api.rows
-import org.jetbrains.kotlinx.dataframe.api.sortBy
-import org.jetbrains.kotlinx.dataframe.api.sumOf
-import org.jetbrains.kotlinx.dataframe.api.toInt
-import org.jetbrains.kotlinx.dataframe.api.ungroup
-import org.jetbrains.kotlinx.dataframe.api.update
-import org.jetbrains.kotlinx.dataframe.api.values
-import org.jetbrains.kotlinx.dataframe.api.where
-import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.api.*
 import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
 import org.jetbrains.kotlinx.dataframe.impl.asList
 import org.jetbrains.kotlinx.dataframe.impl.nothingType
@@ -229,7 +180,11 @@ class PivotTests {
             group.columnNames() shouldBe if (it.name() == "Bob") keys - "city" else keys
         }
 
-        val leafColumns = pivoted.getColumnsWithPaths { all().drop(1).allDfs() }
+        val leafColumns = pivoted.getColumnsWithPaths {
+            all()
+                .drop(1)
+                .cols { !it.isColumnGroup() }.recursively()
+        }
         leafColumns.size shouldBe typed.name.countDistinct() * typed.key.countDistinct() - 1
         leafColumns.forEach { it.path.size shouldBe 2 }
 
@@ -284,7 +239,7 @@ class PivotTests {
 //        nullGroup.columnTypes() shouldBe listOf(typeOf<Comparable<*>?>(), typeOf<KClass<Any>?>())
         nullGroup.columnTypes() shouldBe listOf(nothingType(true), nothingType(true))
 
-        val cols = pivotedDf.getColumnsWithPaths { all().allDfs() }
+        val cols = pivotedDf.getColumnsWithPaths { cols { !it.isColumnGroup() }.recursively() }
         cols.size shouldBe 2 * typed.name.countDistinct() * typed.key.countDistinct() - 2
 
         cols.forEach {
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataColumn.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataColumn.kt
index 37d387567..76a752d7f 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataColumn.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataColumn.kt
@@ -1,26 +1,8 @@
 package org.jetbrains.kotlinx.dataframe
 
-import org.jetbrains.kotlinx.dataframe.api.Infer
-import org.jetbrains.kotlinx.dataframe.api.asDataColumn
-import org.jetbrains.kotlinx.dataframe.api.cast
-import org.jetbrains.kotlinx.dataframe.api.concat
-import org.jetbrains.kotlinx.dataframe.api.filter
-import org.jetbrains.kotlinx.dataframe.api.schema
-import org.jetbrains.kotlinx.dataframe.api.take
-import org.jetbrains.kotlinx.dataframe.columns.BaseColumn
-import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
-import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
-import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
-import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
-import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
-import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnGroupImpl
-import org.jetbrains.kotlinx.dataframe.impl.columns.FrameColumnImpl
-import org.jetbrains.kotlinx.dataframe.impl.columns.ValueColumnImpl
-import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
-import org.jetbrains.kotlinx.dataframe.impl.columns.guessColumnType
-import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnKind
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.columns.*
+import org.jetbrains.kotlinx.dataframe.impl.columns.*
 import org.jetbrains.kotlinx.dataframe.impl.getValuesType
 import org.jetbrains.kotlinx.dataframe.impl.splitByIndices
 import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
@@ -54,7 +36,7 @@ public interface DataColumn<out T> : BaseColumn<T> {
             values: List<T>,
             type: KType,
             infer: Infer = Infer.None,
-            defaultValue: T? = null
+            defaultValue: T? = null,
         ): ValueColumn<T> = ValueColumnImpl(values, name, getValuesType(values, type, infer), defaultValue)
 
         /**
@@ -67,7 +49,11 @@ public interface DataColumn<out T> : BaseColumn<T> {
          * @param values list of column values
          * @param infer column type inference mode
          */
-        public inline fun <reified T> createValueColumn(name: String, values: List<T>, infer: Infer = Infer.None): ValueColumn<T> = createValueColumn(
+        public inline fun <reified T> createValueColumn(
+            name: String,
+            values: List<T>,
+            infer: Infer = Infer.None,
+        ): ValueColumn<T> = createValueColumn(
             name, values,
             getValuesType(
                 values,
@@ -81,17 +67,21 @@ public interface DataColumn<out T> : BaseColumn<T> {
         public fun <T> createFrameColumn(
             name: String,
             df: DataFrame<T>,
-            startIndices: Iterable<Int>
+            startIndices: Iterable<Int>,
         ): FrameColumn<T> =
             FrameColumnImpl(name, df.splitByIndices(startIndices.asSequence()).toList(), lazy { df.schema() })
 
         public fun <T> createFrameColumn(
             name: String,
             groups: List<DataFrame<T>>,
-            schema: Lazy<DataFrameSchema>? = null
+            schema: Lazy<DataFrameSchema>? = null,
         ): FrameColumn<T> = FrameColumnImpl(name, groups, schema)
 
-        public fun <T> createWithTypeInference(name: String, values: List<T>, nullable: Boolean? = null): DataColumn<T> = guessColumnType(name, values, nullable = nullable)
+        public fun <T> createWithTypeInference(
+            name: String,
+            values: List<T>,
+            nullable: Boolean? = null,
+        ): DataColumn<T> = guessColumnType(name, values, nullable = nullable)
 
         public fun <T> create(name: String, values: List<T>, type: KType, infer: Infer = Infer.None): DataColumn<T> {
             return when (type.toColumnKind()) {
@@ -101,7 +91,8 @@ public interface DataColumn<out T> : BaseColumn<T> {
             }
         }
 
-        public inline fun <reified T> create(name: String, values: List<T>, infer: Infer = Infer.None): DataColumn<T> = create(name, values, typeOf<T>(), infer)
+        public inline fun <reified T> create(name: String, values: List<T>, infer: Infer = Infer.None): DataColumn<T> =
+            create(name, values, typeOf<T>(), infer)
 
         public fun empty(name: String = ""): AnyCol = createValueColumn(name, emptyList<Unit>(), typeOf<Unit>())
     }
@@ -116,7 +107,8 @@ public interface DataColumn<out T> : BaseColumn<T> {
 
     override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? = this.addPath()
 
-    override operator fun getValue(thisRef: Any?, property: KProperty<*>): DataColumn<T> = super.getValue(thisRef, property) as DataColumn<T>
+    override operator fun getValue(thisRef: Any?, property: KProperty<*>): DataColumn<T> =
+        super.getValue(thisRef, property) as DataColumn<T>
 
     public operator fun iterator(): Iterator<T> = values().iterator()
 
@@ -133,6 +125,8 @@ public val AnyCol.indices: IntRange get() = indices()
 
 public val AnyCol.type: KType get() = type()
 public val AnyCol.kind: ColumnKind get() = kind()
-public val AnyCol.typeClass: KClass<*> get() = type.classifier as? KClass<*> ?: error("Cannot cast ${type.classifier?.javaClass} to a ${KClass::class}. Column $name: $type")
+public val AnyCol.typeClass: KClass<*>
+    get() = type.classifier as? KClass<*>
+        ?: error("Cannot cast ${type.classifier?.javaClass} to a ${KClass::class}. Column $name: $type")
 
 public fun AnyBaseCol.indices(): IntRange = 0 until size()
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
index 522207fb9..221d249c6 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
@@ -9,39 +9,15 @@ import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
-import org.jetbrains.kotlinx.dataframe.Predicate
-import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
-import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
-import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
-import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
-import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
-import org.jetbrains.kotlinx.dataframe.columns.renamedReference
-import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.*
 import org.jetbrains.kotlinx.dataframe.documentation.AccessApi
 import org.jetbrains.kotlinx.dataframe.documentation.ColumnExpression
 import org.jetbrains.kotlinx.dataframe.documentation.DocumentationUrls
 import org.jetbrains.kotlinx.dataframe.documentation.LineBreak
-import org.jetbrains.kotlinx.dataframe.hasNulls
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.toColumns
 import org.jetbrains.kotlinx.dataframe.impl.columnName
-import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnsList
-import org.jetbrains.kotlinx.dataframe.impl.columns.DistinctColumnSet
-import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
-import org.jetbrains.kotlinx.dataframe.impl.columns.allColumnsExcept
-import org.jetbrains.kotlinx.dataframe.impl.columns.changePath
-import org.jetbrains.kotlinx.dataframe.impl.columns.createColumnSet
-import org.jetbrains.kotlinx.dataframe.impl.columns.getAt
-import org.jetbrains.kotlinx.dataframe.impl.columns.getChildrenAt
-import org.jetbrains.kotlinx.dataframe.impl.columns.singleImpl
-import org.jetbrains.kotlinx.dataframe.impl.columns.top
-import org.jetbrains.kotlinx.dataframe.impl.columns.transform
-import org.jetbrains.kotlinx.dataframe.impl.columns.transformSingle
-import org.jetbrains.kotlinx.dataframe.impl.columns.transformWithContext
-import org.jetbrains.kotlinx.dataframe.impl.columns.tree.dfs
+import org.jetbrains.kotlinx.dataframe.impl.columns.*
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.flattenRecursively
 import org.jetbrains.kotlinx.dataframe.impl.headPlusArray
 import kotlin.reflect.KProperty
 import kotlin.reflect.KType
@@ -223,8 +199,8 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][select]` { `[colsOf][colsOf]`<`[Int][Int]`>().`[first][first]`() }`
      */
-    public fun <C> ColumnSet<C>.first(condition: ColumnFilter<C> = { true }): SingleColumn<C> =
-        transform { listOf(it.first(condition)) }.singleImpl()
+    public fun <C> ColumnSet<C>.first(condition: ColumnFilter<C> = { true }): TransformableSingleColumn<C> =
+        transform { listOf(it.first(condition)) }.singleWithTransformerImpl()
 
     /**
      * @include [CommonFirstDocs]
@@ -232,8 +208,10 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * `df.`[select][select]` { `[first][first]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
      *
      * `df.`[select][select]` { myColumnGroup.`[first][first]`() }`
+     *
+     * `df.`[select][select]` { "pathTo"["myColumnGroup"].`[first][first]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
      */
-    public fun SingleColumn<AnyRow>.first(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
+    public fun SingleColumn<*>.first(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
         all().first(condition)
 
     /**
@@ -241,15 +219,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @arg [CommonFirstDocs.Examples]
      * `df.`[select][select]` { "myColumnGroup".`[first][first]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
      */
-    public fun String.first(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
-        colGroup(this).first(condition)
-
-    /**
-     * @include [CommonFirstDocs]
-     * @arg [CommonFirstDocs.Examples]
-     * `df.`[select][select]` { "pathTo"["myColumnGroup"].`[first][first]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
-     */
-    public fun ColumnPath.first(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
+    public fun String.first(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
         colGroup(this).first(condition)
 
     /**
@@ -257,7 +227,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @arg [CommonFirstDocs.Examples]
      * `df.`[select][select]` { Type::myColumnGroup.`[first][first]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
      */
-    public fun KProperty<*>.first(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
+    public fun KProperty<*>.first(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
         colGroup(this).first(condition)
 
     /**
@@ -286,8 +256,8 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][select]` { `[colsOf][colsOf]`<`[Int][Int]`>().`[first][last]`() }`
      */
-    public fun <C> ColumnSet<C>.last(condition: ColumnFilter<C> = { true }): SingleColumn<C> =
-        transform { listOf(it.last(condition)) }.singleImpl()
+    public fun <C> ColumnSet<C>.last(condition: ColumnFilter<C> = { true }): TransformableSingleColumn<C> =
+        transform { listOf(it.last(condition)) }.singleWithTransformerImpl()
 
     /**
      * @include [CommonLastDocs]
@@ -295,8 +265,10 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * `df.`[select][select]` { `[last][last]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
      *
      * `df.`[select][select]` { myColumnGroup.`[last][last]`() }`
+     *
+     * `df.`[select][select]` { "pathTo"["myColumnGroup"].`[last][last]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
      */
-    public fun SingleColumn<AnyRow>.last(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
+    public fun SingleColumn<*>.last(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
         all().last(condition)
 
     /**
@@ -304,15 +276,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @arg [CommonLastDocs.Examples]
      * `df.`[select][select]` { "myColumnGroup".`[last][last]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
      */
-    public fun String.last(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
-        colGroup(this).last(condition)
-
-    /**
-     * @include [CommonLastDocs]
-     * @arg [CommonLastDocs.Examples]
-     * `df.`[select][select]` { "pathTo"["myColumnGroup"].`[last][last]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
-     */
-    public fun ColumnPath.last(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
+    public fun String.last(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
         colGroup(this).last(condition)
 
     /**
@@ -320,7 +284,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @arg [CommonLastDocs.Examples]
      * `df.`[select][select]` { Type::myColumnGroup.`[last][last]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
      */
-    public fun KProperty<*>.last(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
+    public fun KProperty<*>.last(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
         colGroup(this).last(condition)
 
     /**
@@ -349,8 +313,8 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][select]` { `[colsOf][colsOf]`<`[Int][Int]`>().`[single][single]`() }`
      */
-    public fun <C> ColumnSet<C>.single(condition: ColumnFilter<C> = { true }): SingleColumn<C> =
-        transform { listOf(it.single(condition)) }.singleImpl()
+    public fun <C> ColumnSet<C>.single(condition: ColumnFilter<C> = { true }): TransformableSingleColumn<C> =
+        transform { listOf(it.single(condition)) }.singleWithTransformerImpl()
 
     /**
      * @include [CommonSingleDocs]
@@ -358,8 +322,10 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * `df.`[select][select]` { `[single][single]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
      *
      * `df.`[select][select]` { myColumnGroup.`[single][single]`() }`
+     *
+     * `df.`[select][select]` { "pathTo"["myColumnGroup"].`[single][single]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
      */
-    public fun SingleColumn<AnyRow>.single(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
+    public fun SingleColumn<*>.single(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
         all().single(condition)
 
     /**
@@ -367,15 +333,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @arg [CommonSingleDocs.Examples]
      * `df.`[select][select]` { "myColumnGroup".`[single][single]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
      */
-    public fun String.single(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
-        colGroup(this).single(condition)
-
-    /**
-     * @include [CommonSingleDocs]
-     * @arg [CommonSingleDocs.Examples]
-     * `df.`[select][select]` { "pathTo"["myColumnGroup"].`[single][single]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
-     */
-    public fun ColumnPath.single(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
+    public fun String.single(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
         colGroup(this).single(condition)
 
     /**
@@ -383,7 +341,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @arg [CommonSingleDocs.Examples]
      * `df.`[select][select]` { Type::myColumnGroup.`[single][single]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
      */
-    public fun KProperty<*>.single(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
+    public fun KProperty<*>.single(condition: ColumnFilter<*> = { true }): TransformableSingleColumn<*> =
         colGroup(this).single(condition)
 
     /**
@@ -467,8 +425,9 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      */
     public operator fun AnyColumnReference.rangeTo(endInclusive: AnyColumnReference): ColumnSet<*> =
         object : ColumnSet<Any?> {
-            override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<Any?>> {
-                val startPath = this@rangeTo.resolveSingle(context)!!.path
+
+            private fun process(col: AnyColumnReference, context: ColumnResolutionContext): List<ColumnWithPath<Any?>> {
+                val startPath = col.resolveSingle(context)!!.path
                 val endPath = endInclusive.resolveSingle(context)!!.path
                 val parentPath = startPath.parent()!!
                 require(parentPath == endPath.parent()) { "Start and end columns have different parent column paths" }
@@ -481,6 +440,9 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
                     }
                 }
             }
+
+            override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<Any?>> =
+                process(this@rangeTo, context)
         }
 
     /**
@@ -608,7 +570,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     public fun <C> ColumnGroupReference.col(property: KProperty<C>): ColumnAccessor<C> = column(property)
 
     /** {@comment TODO} */
-    public fun SingleColumn<AnyRow>.col(index: Int): SingleColumn<Any?> = getChildrenAt(index).singleImpl()
+    public fun SingleColumn<*>.col(index: Int): SingleColumn<Any?> = getChildrenAt(index).singleImpl()
 
     /** {@comment TODO} */
     public operator fun <C> ColumnSet<C>.get(index: Int): SingleColumn<C> = getAt(index)
@@ -872,7 +834,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     /**
      * ## Cols
-     * Creates a subset of columns ([ColumnSet]) from a parent [ColumnSet], -[ColumnGroup], or -[DataFrame].
+     * Creates a subset of columns ([ColumnSet]) from the current [ColumnSet].
+     *
+     * If the current [ColumnSet] is a [SingleColumn]
+     * (and thus consists of only one column (or [column group][ColumnGroup])),
+     * then `cols` will create a subset of its children.
+     *
      * You can use either a [ColumnFilter] or any of the `vararg` overloads for all
      * [APIs][AccessApi] (+ [ColumnPath]).
      *
@@ -941,17 +908,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     @Suppress("UNCHECKED_CAST")
     public fun <C> ColumnSet<C>.cols(
         predicate: ColumnFilter<C> = { true },
-    ): ColumnSet<C> = transformWithContext {
-        dataFrameOf(it)
-            .asColumnGroup()
-            .cols(predicate as ColumnFilter<*>)
-            .resolve(this)
-    } as ColumnSet<C>
+    ): TransformableColumnSet<C> = colsInternal(predicate as ColumnFilter<*>) as TransformableColumnSet<C>
 
     /** @include [ColumnSetColsPredicateDocs] */
     public operator fun <C> ColumnSet<C>.get(
         predicate: ColumnFilter<C> = { true },
-    ): ColumnSet<C> = cols(predicate)
+    ): TransformableColumnSet<C> = cols(predicate)
 
     /**
      * @include [CommonColsDocs.Predicate]
@@ -963,33 +925,34 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][select]` { myColumnGroup`.[cols][cols]` { "e" `[in\][String.contains\]` it.`[name][ColumnPath.name]`() } }`
      *
-     * `// same as `[all][all]
+     * `df.`[select][select]` { `[cols][cols]`() } // same as `[all][all]
      *
-     * `df.`[select][select]` { `[cols][cols]`() }`
+     * `df.`[select][select]` { "pathTo"["myGroupCol"].`[cols][cols]` { "e" `[in\][String.contains\]` it.`[name][ColumnPath.name]`() } }`
+     *
+     * `df.`[select][select]` { "pathTo"["myGroupCol"]`[`[`][cols]`{ it.`[any\][ColumnWithPath.any\]` { it == "Alice" } }`[`]`][cols]` }`
+     *
+     * `df.`[select][select]` { "pathTo"["myGroupCol"].`[cols][cols]`() } // identity call, same as `[all][all]
      *
      * `// NOTE: there's a `[DataFrame.get]` overload that prevents this:`
      *
      * `df.`[select][select]` { myColumnGroup`[`[`][cols]`{ ... }`[`]`][cols]` }`
      *
-     * `// use `[cols][cols]` instead`
-     * `df.`[select][select]` { myColumnGroup`.[cols][cols]` { ... } }`
-     *
      * @see [all\]
      */
     private interface SingleColumnAnyRowColsPredicateDocs
 
     /** @include [SingleColumnAnyRowColsPredicateDocs] */
-    public fun SingleColumn<AnyRow>.cols(
+    public fun SingleColumn<*>.cols(
         predicate: ColumnFilter<*> = { true },
-    ): ColumnSet<*> = colsInternal(predicate)
+    ): TransformableColumnSet<*> = colsInternal(predicate)
 
     /**
      * @include [SingleColumnAnyRowColsPredicateDocs]
      * {@comment this function is shadowed by [DataFrame.get]}
      */
-    public operator fun SingleColumn<AnyRow>.get(
+    public operator fun SingleColumn<*>.get(
         predicate: ColumnFilter<*> = { true },
-    ): ColumnSet<Any?> = cols(predicate)
+    ): TransformableColumnSet<Any?> = cols(predicate)
 
     /**
      * @include [CommonColsDocs.Predicate]
@@ -1008,38 +971,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     /** @include [StringColsPredicateDocs] */
     public fun String.cols(
         predicate: ColumnFilter<*> = { true },
-    ): ColumnSet<*> = colGroup(this).cols(predicate)
+    ): TransformableColumnSet<*> = colGroup(this).cols(predicate)
 
     /** @include [StringColsPredicateDocs] */
     public operator fun String.get(
         predicate: ColumnFilter<*> = { true },
-    ): ColumnSet<Any?> = cols(predicate)
-
-    /**
-     * @include [CommonColsDocs.Predicate]
-     * @arg [CommonColsDocs.Examples]
-     *
-     * `df.`[select][select]` { "pathTo"["myGroupCol"].`[cols][cols]` { "e" `[in\][String.contains\]` it.`[name][ColumnPath.name]`() } }`
-     *
-     * `df.`[select][select]` { "pathTo"["myGroupCol"]`[`[`][cols]`{ it.`[any\][ColumnWithPath.any\]` { it == "Alice" } }`[`]`][cols]` }`
-     *
-     * `// identity call, same as `[all][all]
-     *
-     * `df.`[select][select]` { "pathTo"["myGroupCol"].`[cols][cols]`() }`
-     *
-     * @see [all\]
-     */
-    private interface ColumnPathColsPredicateDocs
-
-    /** @include [ColumnPathColsPredicateDocs] */
-    public fun ColumnPath.cols(
-        predicate: ColumnFilter<*> = { true },
-    ): ColumnSet<*> = colGroup(this).cols(predicate)
-
-    /** @include [ColumnPathColsPredicateDocs] */
-    public operator fun ColumnPath.get(
-        predicate: ColumnFilter<*> = { true },
-    ): ColumnSet<Any?> = cols(predicate)
+    ): TransformableColumnSet<Any?> = cols(predicate)
 
     /**
      * @include [CommonColsDocs.Predicate]
@@ -1060,12 +997,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     /** @include [KPropertyColsPredicateDocs] */
     public fun KProperty<*>.cols(
         predicate: ColumnFilter<*> = { true },
-    ): ColumnSet<*> = colGroup(this).cols(predicate)
+    ): TransformableColumnSet<*> = colGroup(this).cols(predicate)
 
     /** @include [KPropertyColsPredicateDocs] */
     public operator fun KProperty<*>.get(
         predicate: ColumnFilter<*> = { true },
-    ): ColumnSet<Any?> = cols(predicate)
+    ): TransformableColumnSet<Any?> = cols(predicate)
 
     // endregion
 
@@ -1112,6 +1049,12 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][select]` { myColumnGroup.`[cols][cols]`(columnA, columnB) }`
      *
+     * `df.`[select][select]` { "pathTo"["columnGroup"].`[cols][cols]`(columnA, columnB) }`
+     *
+     * `df.`[select][select]` { "pathTo"["columnGroup"].`[cols][cols]`("pathTo"["colA"], "pathTo"["colB"]) }`
+     *
+     * `df.`[select][select]` { "pathTo"["columnGroup"]`[`[`][cols]`columnA, columnB`[`]`][cols]` }`
+     *
      * `// NOTE: there's a `[DataFrame.get]` overload that prevents this:`
      *
      * `df.`[select][select]` { myColumnGroup`[`[`][cols]`columnA, columnB`[`]`][cols]` }`
@@ -1119,7 +1062,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     private interface SingleColumnColsVarargColumnReferenceDocs
 
     /** @include [SingleColumnColsVarargColumnReferenceDocs] */
-    public fun <C> SingleColumn<AnyRow>.cols(
+    public fun <C> SingleColumn<*>.cols(
         firstCol: ColumnReference<C>,
         vararg otherCols: ColumnReference<C>,
     ): ColumnSet<C> = headPlusArray(firstCol, otherCols).let { refs ->
@@ -1132,7 +1075,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @include [SingleColumnColsVarargColumnReferenceDocs]
      * {@comment this function is shadowed by [DataFrame.get] for accessors}
      */
-    public operator fun <C> SingleColumn<AnyRow>.get(
+    public operator fun <C> SingleColumn<*>.get(
         firstCol: ColumnReference<C>,
         vararg otherCols: ColumnReference<C>,
     ): ColumnSet<C> = cols(firstCol, *otherCols)
@@ -1161,30 +1104,6 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
         vararg otherCols: ColumnReference<C>,
     ): ColumnSet<C> = cols(firstCol, *otherCols)
 
-    /**
-     * @include [CommonColsDocs.Vararg] {@arg [CommonColsDocs.Vararg.AccessorType] [ColumnReference]}
-     * @arg [CommonColsDocs.Examples]
-     *
-     * `df.`[select][select]` { "pathTo"["columnGroup"].`[cols][cols]`(columnA, columnB) }`
-     *
-     * `df.`[select][select]` { "pathTo"["columnGroup"].`[cols][cols]`("pathTo"["colA"], "pathTo"["colB"]) }`
-     *
-     * `df.`[select][select]` { "pathTo"["columnGroup"]`[`[`][cols]`columnA, columnB`[`]`][cols]` }`
-     */
-    private interface ColumnPathColsVarargColumnReferenceDocs
-
-    /** @include [ColumnPathColsVarargColumnReferenceDocs] */
-    public fun <C> ColumnPath.cols(
-        firstCol: ColumnReference<C>,
-        vararg otherCols: ColumnReference<C>,
-    ): ColumnSet<C> = colGroup(this).cols(firstCol, *otherCols)
-
-    /** @include [ColumnPathColsVarargColumnReferenceDocs] */
-    public operator fun <C> ColumnPath.get(
-        firstCol: ColumnReference<C>,
-        vararg otherCols: ColumnReference<C>,
-    ): ColumnSet<C> = cols(firstCol, *otherCols)
-
     /**
      * @include [CommonColsDocs.Vararg] {@arg [CommonColsDocs.Vararg.AccessorType] [ColumnReference]}
      * @arg [CommonColsDocs.Examples]
@@ -1224,15 +1143,11 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     private interface ColumnSetColsVarargStringDocs
 
     /** @include [ColumnSetColsVarargStringDocs] */
-    @Suppress("UNCHECKED_CAST")
     public fun <C> ColumnSet<C>.cols(
         firstCol: String,
         vararg otherCols: String,
-    ): ColumnSet<C> = transformWithContext {
-        dataFrameOf(it)
-            .asColumnGroup()
-            .cols(firstCol, *otherCols)
-            .resolve(this) as List<ColumnWithPath<C>>
+    ): ColumnSet<C> = headPlusArray(firstCol, otherCols).let { names ->
+        filter { it.name in names }
     }
 
     /**
@@ -1253,6 +1168,10 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][select]` { myColumnGroup.`[cols][cols]`("columnA", "columnB") }`
      *
+     * `df.`[select][select]` { "pathTo"["columnGroup"].`[cols][cols]`("columnA", "columnB") }`
+     *
+     * `df.`[select][select]` { "pathTo"["columnGroup"]`[`[`][cols]`"columnA", "columnB"`[`]`][cols]` }`
+     *
      * `// NOTE: there's a `[DataFrame.get]` overload that prevents this:`
      *
      * `df.`[select][select]` { myColumnGroup`[`[`][cols]`"columnA", "columnB"`[`]`][cols]` }`
@@ -1260,7 +1179,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     private interface SingleColumnColsVarargStringDocs
 
     /** @include [SingleColumnColsVarargStringDocs] */
-    public fun SingleColumn<AnyRow>.cols(
+    public fun SingleColumn<*>.cols(
         firstCol: String,
         vararg otherCols: String,
     ): ColumnSet<*> = headPlusArray(firstCol, otherCols).let { names ->
@@ -1271,7 +1190,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * @include [SingleColumnColsVarargStringDocs]
      * {@comment this function is shadowed by [DataFrame.get] for accessors}
      */
-    public operator fun SingleColumn<AnyRow>.get(
+    public operator fun SingleColumn<*>.get(
         firstCol: String,
         vararg otherCols: String,
     ): ColumnSet<*> = cols(firstCol, *otherCols)
@@ -1298,28 +1217,6 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
         vararg otherCols: String,
     ): ColumnSet<*> = cols(firstCol, *otherCols)
 
-    /**
-     * @include [CommonColsDocs.Vararg] {@arg [CommonColsDocs.Vararg.AccessorType] [String]}
-     * @arg [CommonColsDocs.Examples]
-     *
-     * `df.`[select][select]` { "pathTo"["columnGroup"].`[cols][cols]`("columnA", "columnB") }`
-     *
-     * `df.`[select][select]` { "pathTo"["columnGroup"]`[`[`][cols]`"columnA", "columnB"`[`]`][cols]` }`
-     */
-    private interface ColumnPathColsVarargStringDocs
-
-    /** @include [ColumnPathColsVarargStringDocs] */
-    public fun ColumnPath.cols(
-        firstCol: String,
-        vararg otherCols: String,
-    ): ColumnSet<*> = colGroup(this).cols(firstCol, *otherCols)
-
-    /** @include [ColumnPathColsVarargStringDocs] */
-    public operator fun ColumnPath.get(
-        firstCol: String,
-        vararg otherCols: String,
-    ): ColumnSet<*> = cols(firstCol, *otherCols)
-
     /**
      * @include [CommonColsDocs.Vararg] {@arg [CommonColsDocs.Vararg.AccessorType] [String]}
      * @arg [CommonColsDocs.Examples]
@@ -1360,11 +1257,8 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     public fun <C> ColumnSet<C>.cols(
         firstCol: KProperty<C>,
         vararg otherCols: KProperty<C>,
-    ): ColumnSet<C> = transformWithContext {
-        dataFrameOf(it)
-            .asColumnGroup()
-            .cols(firstCol, *otherCols)
-            .resolve(this)
+    ): ColumnSet<C> = headPlusArray(firstCol, otherCols).map { it.name }.let { names ->
+        filter { it.name in names }
     }
 
     /** @include [ColumnSetColsVarargKPropertyDocs] */
@@ -1384,11 +1278,15 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      * `df.`[select][select]` { myColumnGroup.`[cols][cols]`(Type::colA, Type::colB) }`
      *
      * `df.`[select][select]` { myColumnGroup`[`[`][cols]`Type::colA, Type::colB`[`]`][cols]` }`
+     *
+     * `df.`[select][select]` { "pathTo"["columnGroup"].`[cols][cols]`(Type::colA, Type::colB) }`
+     *
+     * `df.`[select][select]` { "pathTo"["columnGroup"]`[`[`][cols]`Type::colA, Type::colB`[`]`][cols]` }`
      */
     private interface SingleColumnColsVarargKPropertyDocs
 
     /** @include [SingleColumnColsVarargKPropertyDocs] */
-    public fun <C> SingleColumn<AnyRow>.cols(
+    public fun <C> SingleColumn<*>.cols(
         firstCol: KProperty<C>,
         vararg otherCols: KProperty<C>,
     ): ColumnSet<C> = headPlusArray(firstCol, otherCols).let { props ->
@@ -1396,7 +1294,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     }
 
     /** @include [SingleColumnColsVarargKPropertyDocs] */
-    public operator fun <C> SingleColumn<AnyRow>.get(
+    public operator fun <C> SingleColumn<*>.get(
         firstCol: KProperty<C>,
         vararg otherCols: KProperty<C>,
     ): ColumnSet<C> = cols(firstCol, *otherCols)
@@ -1423,28 +1321,6 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
         vararg otherCols: KProperty<C>,
     ): ColumnSet<C> = cols(firstCol, *otherCols)
 
-    /**
-     * @include [CommonColsDocs.Vararg] {@arg [CommonColsDocs.Vararg.AccessorType] [KProperty]}
-     * @arg [CommonColsDocs.Examples]
-     *
-     * `df.`[select][select]` { "pathTo"["columnGroup"].`[cols][cols]`(Type::colA, Type::colB) }`
-     *
-     * `df.`[select][select]` { "pathTo"["columnGroup"]`[`[`][cols]`Type::colA, Type::colB`[`]`][cols]` }`
-     */
-    private interface ColumnPathColsVarargKPropertyDocs
-
-    /** @include [ColumnPathColsVarargKPropertyDocs] */
-    public fun <C> ColumnPath.cols(
-        firstCol: KProperty<C>,
-        vararg otherCols: KProperty<C>,
-    ): ColumnSet<C> = colGroup(this).cols(firstCol, *otherCols)
-
-    /** @include [ColumnPathColsVarargKPropertyDocs] */
-    public operator fun <C> ColumnPath.get(
-        firstCol: KProperty<C>,
-        vararg otherCols: KProperty<C>,
-    ): ColumnSet<C> = cols(firstCol, *otherCols)
-
     /**
      * @include [CommonColsDocs.Vararg] {@arg [CommonColsDocs.Vararg.AccessorType] [KProperty]}
      * @arg [CommonColsDocs.Examples]
@@ -1471,33 +1347,25 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     // region indices
 
-    @Suppress("UNCHECKED_CAST")
     public fun <C> ColumnSet<C>.cols(
         firstIndex: Int,
         vararg otherIndices: Int,
-    ): ColumnSet<C> = transformWithContext {
-        dataFrameOf(it)
-            .asColumnGroup()
-            .cols(firstIndex, *otherIndices)
-            .resolve(this) as List<ColumnWithPath<C>>
-    }
+    ): ColumnSet<C> = colsInternal(headPlusArray(firstIndex, otherIndices)) as ColumnSet<C>
 
     public operator fun <C> ColumnSet<C>.get(
         firstIndex: Int,
         vararg otherIndices: Int,
     ): ColumnSet<C> = cols(firstIndex, *otherIndices)
 
-    public fun SingleColumn<AnyRow>.cols(
+    public fun SingleColumn<*>.cols(
         firstIndex: Int,
         vararg otherIndices: Int,
-    ): ColumnSet<*> = headPlusArray(firstIndex, otherIndices).let { indices ->
-        transform { it.flatMap { it.children().let { children -> indices.map { children[it] } } } }
-    }
+    ): ColumnSet<*> = colsInternal(headPlusArray(firstIndex, otherIndices))
 
     /**
      * {@comment this function is shadowed by [ColumnGroup.get] for accessors}
      */
-    public operator fun SingleColumn<AnyRow>.get(
+    public operator fun SingleColumn<*>.get(
         firstIndex: Int,
         vararg otherIndices: Int,
     ): ColumnSet<*> = cols(firstIndex, *otherIndices)
@@ -1512,16 +1380,6 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
         vararg otherIndices: Int,
     ): ColumnSet<*> = cols(firstIndex, *otherIndices)
 
-    public fun ColumnPath.cols(
-        firstIndex: Int,
-        vararg otherIndices: Int,
-    ): ColumnSet<*> = colGroup(this).cols(firstIndex, *otherIndices)
-
-    public operator fun ColumnPath.get(
-        firstIndex: Int,
-        vararg otherIndices: Int,
-    ): ColumnSet<*> = cols(firstIndex, *otherIndices)
-
     public fun KProperty<*>.cols(
         firstIndex: Int,
         vararg otherIndices: Int,
@@ -1536,33 +1394,22 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     // region ranges
 
-    @Suppress("UNCHECKED_CAST")
     public fun <C> ColumnSet<C>.cols(range: IntRange): ColumnSet<C> =
-        transformWithContext {
-            dataFrameOf(it)
-                .asColumnGroup()
-                .cols(range)
-                .resolve(this) as List<ColumnWithPath<C>>
-        }
+        colsInternal(range) as ColumnSet<C>
 
     public operator fun <C> ColumnSet<C>.get(range: IntRange): ColumnSet<C> = cols(range)
 
-    public fun SingleColumn<AnyRow>.cols(range: IntRange): ColumnSet<*> =
-        transform { it.flatMap { it.children().subList(range.first, range.last + 1) } }
+    public fun SingleColumn<*>.cols(range: IntRange): ColumnSet<*> = colsInternal(range)
 
     /**
      * {@comment this function is shadowed by [ColumnGroup.get] for accessors}
      */
-    public operator fun SingleColumn<AnyRow>.get(range: IntRange): ColumnSet<*> = cols(range)
+    public operator fun SingleColumn<*>.get(range: IntRange): ColumnSet<*> = cols(range)
 
     public fun String.cols(range: IntRange): ColumnSet<*> = colGroup(this).cols(range)
 
     public operator fun String.get(range: IntRange): ColumnSet<*> = cols(range)
 
-    public fun ColumnPath.cols(range: IntRange): ColumnSet<*> = colGroup(this).cols(range)
-
-    public operator fun ColumnPath.get(range: IntRange): ColumnSet<*> = cols(range)
-
     public fun KProperty<*>.cols(range: IntRange): ColumnSet<*> = colGroup(this).cols(range)
 
     public operator fun KProperty<*>.get(range: IntRange): ColumnSet<*> = cols(range)
@@ -1593,10 +1440,32 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     // region dfs
 
+    @Deprecated(
+        message = "dfs is deprecated, use recursively instead.",
+        replaceWith = ReplaceWith("this.cols(predicate).recursively(includeTopLevel = false)"),
+        level = DeprecationLevel.WARNING,
+    )
     public fun <C> ColumnSet<C>.dfs(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<Any?> = dfsInternal(predicate)
 
+    @Deprecated(
+        message = "dfs is deprecated, use recursively instead.",
+        replaceWith = ReplaceWith("this.cols(predicate).recursively()"),
+        level = DeprecationLevel.WARNING,
+    )
+    public fun SingleColumn<*>.dfs(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<Any?> = dfsInternal(predicate)
+
+    @Deprecated(
+        message = "dfs is deprecated, use recursively instead.",
+        replaceWith = ReplaceWith("this.cols(predicate).recursively()"),
+        level = DeprecationLevel.WARNING,
+    )
     public fun String.dfs(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> = toColumnAccessor().dfs(predicate)
 
+    @Deprecated(
+        message = "dfs is deprecated, use recursively instead.",
+        replaceWith = ReplaceWith("this.cols(predicate).recursively()"),
+        level = DeprecationLevel.WARNING,
+    )
     public fun <C> KProperty<C>.dfs(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> =
         toColumnAccessor().dfs(predicate)
 
@@ -1604,22 +1473,167 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     // region all
 
-    public fun SingleColumn<*>.all(): ColumnSet<*> = transformSingle { it.children() }
+    /**
+     * ## All
+     * Creates a new [ColumnSet] that contains all columns from the current [ColumnSet].
+     *
+     * If the current [ColumnSet] is a [SingleColumn] and consists of only one [column group][ColumnGroup],
+     * then `all` will create a new [ColumnSet] consisting of its children.
+     *
+     * This makes the function equivalent to [cols()][ColumnSet.cols].
+     *
+     * #### For example:
+     * `df.`[move][DataFrame.move]` { `[all][ColumnSet.all]`().`[recursively][recursively]`() }.`[under][MoveClause.under]`("info")`
+     *
+     * `df.`[select][DataFrame.select]` { myGroup.`[all][ColumnSet.all]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * {@includeArg [CommonAllDocs.Examples]}
+     *
+     * @see [cols\]
+     */
+    private interface CommonAllDocs {
+
+        /** Example argument */
+        interface Examples
+    }
+
+    /**
+     * @include [CommonAllDocs]
+     * @arg [CommonAllDocs.Examples]
+     *
+     * `df.`[select][select]` { `[cols][cols]` { "a" in `[name][ColumnWithPath.name]` }.`[all][all]`() }`
+     * {@include [LineBreak]}
+     * NOTE: This is an identity call and can be omitted in most cases. However, it can still prove useful
+     * for readability or in combination with [recursively].
+     */
+    public fun <C> ColumnSet<C>.all(): TransformableColumnSet<C> = allInternal()
+
+    /**
+     * @include [CommonAllDocs]
+     * @arg [CommonAllDocs.Examples]
+     *
+     * `df.`[select][select]` { `[all][all]`() }`
+     *
+     * `df.`[select][select]` { myGroup.`[all][all]`() }`
+     *
+     * `df.`[select][select]` { "pathTo"["myGroup"].`[all][all]`() }`
+     */
+    public fun SingleColumn<*>.all(): TransformableColumnSet<*> = allInternal()
 
-    public fun String.all(): ColumnSet<*> = toColumnAccessor().transformSingle { it.children() }
+    /**
+     * @include [CommonAllDocs]
+     * @arg [CommonAllDocs.Examples]
+     *
+     * `df.`[select][select]` { "myGroupCol".`[all][all]`() }`
+     */
+    public fun String.all(): TransformableColumnSet<*> = toColumnAccessor().all()
 
-    public fun KProperty<*>.all(): ColumnSet<*> = toColumnAccessor().transformSingle { it.children() }
+    /**
+     * @include [CommonAllDocs]
+     * @arg [CommonAllDocs.Examples]
+     *
+     * `df.`[select][select]` { Type::columnGroup.`[all][all]`() }`
+     */
+    public fun KProperty<*>.all(): TransformableColumnSet<*> = toColumnAccessor().all()
 
     // region allDfs
 
+    @Deprecated(
+        message = "allDfs is deprecated, use recursively instead.",
+        replaceWith = ReplaceWith("this.cols { includeGroups || !it.isColumnGroup() }.recursively()"),
+        level = DeprecationLevel.WARNING,
+    )
     public fun ColumnSet<*>.allDfs(includeGroups: Boolean = false): ColumnSet<Any?> =
         if (includeGroups) dfs { true } else dfs { !it.isColumnGroup() }
 
+    @Deprecated(
+        message = "allDfs is deprecated, use recursively instead.",
+        replaceWith = ReplaceWith("this.cols { includeGroups || !it.isColumnGroup() }.recursively()"),
+        level = DeprecationLevel.WARNING,
+    )
+    public fun SingleColumn<*>.allDfs(includeGroups: Boolean = false): ColumnSet<Any?> =
+        if (includeGroups) dfs { true } else dfs { !it.isColumnGroup() }
+
+    @Deprecated(
+        message = "allDfs is deprecated, use recursively instead.",
+        replaceWith = ReplaceWith("this.cols { includeGroups || !it.isColumnGroup() }.recursively()"),
+        level = DeprecationLevel.WARNING,
+    )
     public fun String.allDfs(includeGroups: Boolean = false): ColumnSet<Any?> = toColumnAccessor().allDfs(includeGroups)
 
+    @Deprecated(
+        message = "allDfs is deprecated, use recursively instead.",
+        replaceWith = ReplaceWith("this.cols { includeGroups || !it.isColumnGroup() }.recursively()"),
+        level = DeprecationLevel.WARNING,
+    )
     public fun KProperty<*>.allDfs(includeGroups: Boolean = false): ColumnSet<Any?> =
         toColumnAccessor().allDfs(includeGroups)
 
+    /**
+     * ## Recursively / Rec
+     *
+     * Modifies the previous call to run not only on the current column set,
+     * but also on all columns inside [column groups][ColumnGroup].
+     *
+     * `df.`[select][DataFrame.select]` { `[colsOf][ColumnSet.colsOf]`<`[String][String]`>() }`
+     *
+     * returns all columns of type [String] in the top-level, as expected. However, what if you want ALL
+     * columns of type [String] even if they are inside a nested [column group][ColumnGroup]? Then you can use [recursively]:
+     *
+     * `df.`[select][DataFrame.select]` { `[colsOf][ColumnSet.colsOf]`<`[String][String]`>().`[recursively][recursively]`() }`
+     *
+     * This will return the columns of type [String] in all levels.
+     *
+     * More examples:
+     *
+     * `df.`[select][DataFrame.select]` { `[first][ColumnSet.first]` { col -> col.`[any][DataColumn.any]` { it == "Alice" } }.`[recursively][recursively]`() }`
+     *
+     * `df.`[select][DataFrame.select]` { `[cols][ColumnSet.cols]` { "name" in it.`[name][ColumnReference.name]` }.`[recursively][recursively]`() }`
+     *
+     * #### Examples for this overload:
+     *
+     * {@includeArg [CommonRecursivelyDocs.Examples]}
+     *
+     * @param [includeTopLevel\] Whether to include the top-level columns in the result. `true` by default.
+     */
+    private interface CommonRecursivelyDocs {
+
+        /** Example argument */
+        interface Examples
+    }
+
+    /**
+     * @include [CommonRecursivelyDocs]
+     * @arg [CommonRecursivelyDocs.Examples]
+     *
+     * `df.`[select][DataFrame.select]` { `[colsOf][ColumnSet.colsOf]`<`[String][String]`>().`[recursively][recursively]`() }`
+     *
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[all][ColumnSet.all]`().`[rec][rec]`() }`
+     *
+     * `df.`[select][DataFrame.select]` { `[groups][ColumnSet.groups]`().`[recursively][recursively]`() }`
+     */
+    public fun <C> TransformableColumnSet<C>.recursively(): ColumnSet<C> =
+        recursivelyImpl(includeTopLevel = true, includeGroups = true)
+
+    /** @include [TransformableColumnSet.recursively] */
+    public fun <C> TransformableColumnSet<C>.rec(): ColumnSet<C> = recursively()
+
+    /**
+     * @include [CommonRecursivelyDocs]
+     * @arg [CommonRecursivelyDocs.Examples]
+     *
+     * `df.`[select][DataFrame.select]` { `[first][ColumnSet.first]` { col -> col.`[any][DataColumn.any]` { it == "Alice" } }.`[recursively][recursively]`() }`
+     *
+     * `df.`[select][DataFrame.select]` { `[single][ColumnSet.single]` { it.name == "myCol" }.`[rec][rec]`() }`
+     */
+    public fun TransformableSingleColumn<*>.recursively(): SingleColumn<*> =
+        recursivelyImpl(includeTopLevel = true, includeGroups = true)
+
+    /** @include [TransformableSingleColumn.recursively] */
+    public fun TransformableSingleColumn<*>.rec(): SingleColumn<*> = recursively()
+
     // endregion
 
     // region allAfter
@@ -1753,68 +1767,121 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     // endregion
 
     // region groups
+    public fun ColumnSet<*>.groups(filter: (ColumnGroup<*>) -> Boolean = { true }): TransformableColumnSet<AnyRow> =
+        groupsInternal(filter)
 
-    public fun SingleColumn<*>.groups(filter: (ColumnGroup<*>) -> Boolean = { true }): ColumnSet<AnyRow> =
-        children { it.isColumnGroup() && filter(it.asColumnGroup()) } as ColumnSet<AnyRow>
+    public fun SingleColumn<*>.groups(filter: (ColumnGroup<*>) -> Boolean = { true }): TransformableColumnSet<AnyRow> =
+        groupsInternal(filter)
 
-    public fun String.groups(filter: (ColumnGroup<*>) -> Boolean = { true }): ColumnSet<AnyRow> =
+    public fun String.groups(filter: (ColumnGroup<*>) -> Boolean = { true }): TransformableColumnSet<AnyRow> =
         toColumnAccessor().groups(filter)
 
-    public fun KProperty<*>.groups(filter: (ColumnGroup<*>) -> Boolean = { true }): ColumnSet<AnyRow> =
+    public fun KProperty<*>.groups(filter: (ColumnGroup<*>) -> Boolean = { true }): TransformableColumnSet<AnyRow> =
         toColumnAccessor().groups(filter)
 
     // endregion
 
     // region children
 
-    public fun ColumnSet<*>.children(predicate: (ColumnWithPath<Any?>) -> Boolean = { true }): ColumnSet<Any?> =
+    // takes children of all columns in the column set
+    public fun ColumnSet<*>.children(predicate: ColumnFilter<Any?> = { true }): TransformableColumnSet<Any?> =
         transform { it.flatMap { it.children().filter { predicate(it) } } }
 
-    public fun ColumnGroupReference.children(): ColumnSet<Any?> = transformSingle { it.children() }
+    // same as cols
+    public fun SingleColumn<*>.children(predicate: ColumnFilter<Any?> = { true }): TransformableColumnSet<Any?> =
+        (this as ColumnSet<*>).children(predicate)
 
     // endregion
 
     public operator fun <C> List<DataColumn<C>>.get(range: IntRange): ColumnSet<C> =
         ColumnsList(subList(range.first, range.last + 1))
 
-    public fun SingleColumn<AnyRow>.take(n: Int): ColumnSet<*> = transformSingle { it.children().take(n) }
-    public fun SingleColumn<AnyRow>.takeLast(n: Int): ColumnSet<*> = transformSingle { it.children().takeLast(n) }
-    public fun SingleColumn<AnyRow>.drop(n: Int): ColumnSet<*> = transformSingle { it.children().drop(n) }
-    public fun SingleColumn<AnyRow>.dropLast(n: Int = 1): ColumnSet<*> = transformSingle { it.children().dropLast(n) }
+    public fun SingleColumn<*>.take(n: Int): ColumnSet<*> = transformSingle { it.children().take(n) }
+    public fun SingleColumn<*>.takeLast(n: Int): ColumnSet<*> = transformSingle { it.children().takeLast(n) }
+    public fun SingleColumn<*>.drop(n: Int): ColumnSet<*> = transformSingle { it.children().drop(n) }
+    public fun SingleColumn<*>.dropLast(n: Int = 1): ColumnSet<*> = transformSingle { it.children().dropLast(n) }
 
     public fun <C> ColumnSet<C>.drop(n: Int): ColumnSet<C> = transform { it.drop(n) }
     public fun <C> ColumnSet<C>.take(n: Int): ColumnSet<C> = transform { it.take(n) }
     public fun <C> ColumnSet<C>.dropLast(n: Int = 1): ColumnSet<C> = transform { it.dropLast(n) }
     public fun <C> ColumnSet<C>.takeLast(n: Int): ColumnSet<C> = transform { it.takeLast(n) }
-    public fun <C> ColumnSet<C>.top(): ColumnSet<C> = transform { it.top() }
-    public fun <C> ColumnSet<C>.takeWhile(predicate: Predicate<ColumnWithPath<C>>): ColumnSet<C> =
+
+    @Deprecated("Use roots() instead", ReplaceWith("roots()"))
+    public fun <C> ColumnSet<C>.top(): ColumnSet<C> = roots()
+
+    /**
+     * ## Roots
+     *
+     * Returns a sub-set of columns that are roots of the trees of columns.
+     *
+     * In practice, this means that if a column in [this] is a child of another column in [this],
+     * it will not be included in the result.
+     *
+     * If [this] is a [SingleColumn] containing a single [ColumnGroup] it will run on the children of that group,
+     * else it simply runs on the columns in the [ColumnSet] itself.
+     */
+    public fun <C> ColumnSet<C>.roots(): ColumnSet<C> = rootsInternal() as ColumnSet<C>
+
+    /**
+     * @include [roots]
+     */
+    public fun SingleColumn<*>.roots(): ColumnSet<*> = rootsInternal()
+
+    public fun <C> ColumnSet<C>.takeWhile(predicate: ColumnFilter<C>): ColumnSet<C> =
         transform { it.takeWhile(predicate) }
 
-    public fun <C> ColumnSet<C>.takeLastWhile(predicate: Predicate<ColumnWithPath<C>>): ColumnSet<C> =
+    public fun <C> ColumnSet<C>.takeLastWhile(predicate: ColumnFilter<C>): ColumnSet<C> =
         transform { it.takeLastWhile(predicate) }
 
-    public fun <C> ColumnSet<C>.filter(predicate: Predicate<ColumnWithPath<C>>): ColumnSet<C> =
-        transform { it.filter(predicate) }
+    public fun <C> ColumnSet<C>.filter(predicate: ColumnFilter<C>): TransformableColumnSet<C> =
+        colsInternal(predicate as ColumnFilter<*>) as TransformableColumnSet<C>
+
+    public fun SingleColumn<*>.nameContains(text: CharSequence): TransformableColumnSet<*> =
+        cols { it.name.contains(text) }
+
+    public fun <C> ColumnSet<C>.nameContains(text: CharSequence): TransformableColumnSet<C> =
+        cols { it.name.contains(text) }
+
+    public fun SingleColumn<*>.nameContains(regex: Regex): TransformableColumnSet<*> = cols { it.name.contains(regex) }
+
+    public fun <C> ColumnSet<C>.nameContains(regex: Regex): TransformableColumnSet<C> = cols { it.name.contains(regex) }
 
-    public fun SingleColumn<AnyRow>.nameContains(text: CharSequence): ColumnSet<*> = cols { it.name.contains(text) }
-    public fun <C> ColumnSet<C>.nameContains(text: CharSequence): ColumnSet<C> = cols { it.name.contains(text) }
-    public fun SingleColumn<AnyRow>.nameContains(regex: Regex): ColumnSet<*> = cols { it.name.contains(regex) }
-    public fun <C> ColumnSet<C>.nameContains(regex: Regex): ColumnSet<C> = cols { it.name.contains(regex) }
-    public fun SingleColumn<AnyRow>.startsWith(prefix: CharSequence): ColumnSet<*> = cols { it.name.startsWith(prefix) }
-    public fun <C> ColumnSet<C>.startsWith(prefix: CharSequence): ColumnSet<C> = cols { it.name.startsWith(prefix) }
-    public fun SingleColumn<AnyRow>.endsWith(suffix: CharSequence): ColumnSet<*> = cols { it.name.endsWith(suffix) }
-    public fun <C> ColumnSet<C>.endsWith(suffix: CharSequence): ColumnSet<C> = cols { it.name.endsWith(suffix) }
+    public fun SingleColumn<*>.startsWith(prefix: CharSequence): TransformableColumnSet<*> =
+        cols { it.name.startsWith(prefix) }
 
-    public fun <C> ColumnSet<C>.except(vararg other: ColumnSet<*>): ColumnSet<*> = except(other.toColumnSet())
-    public fun <C> ColumnSet<C>.except(vararg other: String): ColumnSet<*> = except(other.toColumnSet())
+    public fun <C> ColumnSet<C>.startsWith(prefix: CharSequence): TransformableColumnSet<C> =
+        cols { it.name.startsWith(prefix) }
 
-    public fun <C> ColumnSet<C?>.withoutNulls(): ColumnSet<C> = transform { it.filter { !it.hasNulls } } as ColumnSet<C>
+    public fun SingleColumn<*>.endsWith(suffix: CharSequence): TransformableColumnSet<*> =
+        cols { it.name.endsWith(suffix) }
 
-    public infix fun <C> ColumnSet<C>.except(other: ColumnSet<*>): ColumnSet<*> =
-        createColumnSet { resolve(it).allColumnsExcept(other.resolve(it)) }
+    public fun <C> ColumnSet<C>.endsWith(suffix: CharSequence): TransformableColumnSet<C> =
+        cols { it.name.endsWith(suffix) }
 
-    public infix fun <C> ColumnSet<C>.except(selector: ColumnsSelector<T, *>): ColumnSet<C> =
-        except(selector.toColumns()) as ColumnSet<C>
+    public fun <C> ColumnSet<C>.except(vararg other: ColumnSet<*>): TransformableColumnSet<*> =
+        except(other.toColumnSet())
+
+    public fun <C> ColumnSet<C>.except(vararg other: String): TransformableColumnSet<*> = except(other.toColumnSet())
+
+    public fun <C> ColumnSet<C?>.withoutNulls(): TransformableColumnSet<C> =
+        transform { it.filter { !it.hasNulls() } } as TransformableColumnSet<C>
+
+    public infix fun <C> ColumnSet<C>.except(other: ColumnSet<*>): TransformableColumnSet<*> =
+        createTransformableColumnSet(
+            resolver = { context ->
+                this@except
+                    .resolve(context)
+                    .allColumnsExcept(other.resolve(context))
+            },
+            transformResolve = { context, transformer ->
+                transformer.transform(this@except)
+                    .resolve(context)
+                    .allColumnsExcept(other.resolve(context))
+            },
+        )
+
+    public infix fun <C> ColumnSet<C>.except(selector: ColumnsSelector<T, *>): TransformableColumnSet<C> =
+        except(selector.toColumns()) as TransformableColumnSet<C>
 
     public operator fun <C> ColumnsSelector<T, C>.invoke(): ColumnSet<C> =
         this(this@ColumnsSelectionDsl, this@ColumnsSelectionDsl)
@@ -1892,9 +1959,25 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     public fun <C> ColumnSet<C>.distinct(): ColumnSet<C> = DistinctColumnSet(this)
 
+    @Deprecated(
+        message = "Use recursively() instead",
+        replaceWith = ReplaceWith(
+            "this.colsOf(type, predicate).recursively()",
+            "org.jetbrains.kotlinx.dataframe.columns.recursively",
+            "org.jetbrains.kotlinx.dataframe.api.colsOf",
+        ),
+    )
     public fun <C> String.dfsOf(type: KType, predicate: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<*> =
         toColumnAccessor().dfsOf(type, predicate)
 
+    @Deprecated(
+        message = "Use recursively() instead",
+        replaceWith = ReplaceWith(
+            "this.colsOf(type, predicate).recursively()",
+            "org.jetbrains.kotlinx.dataframe.columns.recursively",
+            "org.jetbrains.kotlinx.dataframe.api.colsOf",
+        ),
+    )
     public fun <C> KProperty<*>.dfsOf(type: KType, predicate: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<*> =
         toColumnAccessor().dfsOf(type, predicate)
 
@@ -1951,18 +2034,99 @@ public inline fun <T, reified R> ColumnsSelectionDsl<T>.expr(
 internal fun <T, C> ColumnsSelector<T, C>.filter(predicate: (ColumnWithPath<C>) -> Boolean): ColumnsSelector<T, C> =
     { this@filter(it, it).filter(predicate) }
 
-internal fun ColumnSet<*>.colsInternal(predicate: ColumnFilter<*>) =
-    transform { it.flatMap { it.children().filter { predicate(it) } } }
+/**
+ * If this [ColumnSet] is a [SingleColumn], it
+ * returns a new [ColumnSet] containing the children of this [SingleColumn] that
+ * match the given [predicate].
+ *
+ * Else, it returns a new [ColumnSet] containing all columns in this [ColumnSet] that
+ * match the given [predicate].
+ */
+internal fun ColumnSet<*>.colsInternal(predicate: ColumnFilter<*>): TransformableColumnSet<*> =
+    allInternal().transform { it.filter(predicate) }
 
-internal fun ColumnSet<*>.dfsInternal(predicate: (ColumnWithPath<*>) -> Boolean) =
-    transform { it.filter { it.isColumnGroup() }.flatMap { it.children().dfs().filter(predicate) } }
+internal fun ColumnSet<*>.colsInternal(indices: IntArray): TransformableColumnSet<*> =
+    allInternal().transform { cols ->
+        indices.map { cols[it] }
+    }
+
+internal fun ColumnSet<*>.colsInternal(range: IntRange): TransformableColumnSet<*> =
+    allInternal().transform {
+        it.subList(range.first, range.last + 1)
+    }
+
+internal fun ColumnSet<*>.rootsInternal(): ColumnSet<*> =
+    allInternal().transform { it.roots() }
+
+internal fun ColumnSet<*>.groupsInternal(filter: (ColumnGroup<*>) -> Boolean): TransformableColumnSet<AnyRow> =
+    colsInternal { it.isColumnGroup() && filter(it.asColumnGroup()) } as TransformableColumnSet<AnyRow>
+
+/**
+ * If [this] is a [SingleColumn] containing a single [ColumnGroup], it
+ * returns a [(transformable) ColumnSet][TransformableColumnSet] containing the children of this [ColumnGroup],
+ * else it simply returns a [(transformable) ColumnSet][TransformableColumnSet] from [this].
+ */
+internal fun <C> ColumnSet<C>.allInternal(): TransformableColumnSet<C> =
+    transform {
+        if (this.isSingleColumnWithGroup(it)) {
+            it.single().children()
+        } else {
+            it
+        }
+    }.cast()
+
+/** @include [allInternal] */
+internal fun SingleColumn<*>.allInternal(): TransformableColumnSet<*> =
+    (this as ColumnSet<*>).allInternal()
 
+@Deprecated("Replaced with recursively()")
+internal fun ColumnSet<*>.dfsInternal(predicate: (ColumnWithPath<*>) -> Boolean) =
+    transform { it.filter { it.isColumnGroup() }.flatMap { it.children().flattenRecursively().filter(predicate) } }
+
+@Deprecated(
+    message = "Use recursively() instead",
+    replaceWith = ReplaceWith(
+        "this.colsOf(type, predicate).recursively()",
+        "org.jetbrains.kotlinx.dataframe.columns.recursively",
+        "org.jetbrains.kotlinx.dataframe.api.colsOf",
+    ),
+)
 public fun <C> ColumnSet<*>.dfsOf(type: KType, predicate: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<*> =
     dfsInternal { it.isSubtypeOf(type) && predicate(it.cast()) }
 
+@Deprecated(
+    message = "Use recursively() instead",
+    replaceWith = ReplaceWith(
+        "this.colsOf(type, predicate).recursively()",
+        "org.jetbrains.kotlinx.dataframe.columns.recursively",
+        "org.jetbrains.kotlinx.dataframe.api.colsOf",
+    ),
+)
+public fun <C> SingleColumn<*>.dfsOf(type: KType, predicate: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<*> =
+    dfsInternal { it.isSubtypeOf(type) && predicate(it.cast()) }
+
+@Deprecated(
+    message = "Use recursively() instead",
+    replaceWith = ReplaceWith(
+        "this.colsOf<C>(filter).recursively(includeTopLevel = false)",
+        "org.jetbrains.kotlinx.dataframe.columns.recursively",
+        "org.jetbrains.kotlinx.dataframe.api.colsOf",
+    ),
+)
 public inline fun <reified C> ColumnSet<*>.dfsOf(noinline filter: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<C> =
     dfsOf(typeOf<C>(), filter) as ColumnSet<C>
 
+@Deprecated(
+    message = "Use recursively() instead",
+    replaceWith = ReplaceWith(
+        "this.colsOf<C>(filter).recursively()",
+        "org.jetbrains.kotlinx.dataframe.columns.recursively",
+        "org.jetbrains.kotlinx.dataframe.api.colsOf",
+    ),
+)
+public inline fun <reified C> SingleColumn<*>.dfsOf(noinline filter: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<C> =
+    dfsOf(typeOf<C>(), filter) as ColumnSet<C>
+
 /**
  * ## Cols Of
  * Get columns by a given type and an optional filter.
@@ -2018,8 +2182,48 @@ private interface CommonColsOfDocs {
  * @include [CommonColsOfDocs.FilterParam]
  * @include [CommonColsOfDocs.Return]
  */
-public fun <C> ColumnSet<*>.colsOf(type: KType, filter: (DataColumn<C>) -> Boolean = { true }): ColumnSet<C> =
-    colsInternal { it.isSubtypeOf(type) && filter(it.cast()) } as ColumnSet<C>
+public fun <C> ColumnSet<*>.colsOf(
+    type: KType,
+    filter: (DataColumn<C>) -> Boolean = { true },
+): TransformableColumnSet<C> =
+    colsInternal { it.isSubtypeOf(type) && filter(it.cast()) } as TransformableColumnSet<C>
+
+/**
+ * @include [CommonColsOfDocs]
+ * Get (sub-)columns by a given type with or without [filter].
+ * #### For example:
+ *
+ * `df.`[select][DataFrame.select]` { `[colsOf][colsOf]`<`[Int][Int]`>() }`
+ *
+ * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][colsOf]`<`[Int][Int]`> { it.`[size][DataColumn.size]` > 10 } }`
+ *
+ * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][colsOf]`<`[Int][Int]`>() }`
+ *
+ * @include [CommonColsOfDocs.FilterParam]
+ * @include [CommonColsOfDocs.Return]
+ */
+public inline fun <reified C> ColumnSet<*>.colsOf(noinline filter: (DataColumn<C>) -> Boolean = { true }): TransformableColumnSet<C> =
+    colsOf(typeOf<C>(), filter)
+
+/**
+ * @include [CommonColsOfDocs]
+ * Get (sub-)columns by [type] with or without [filter].
+ * #### For example:
+ *
+ * `df.`[select][DataFrame.select]` { `[colsOf][colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+ *
+ * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }`
+ *
+ * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }`
+ *
+ * @include [CommonColsOfDocs.FilterParam]
+ * @include [CommonColsOfDocs.Return]
+ */
+public fun <C> SingleColumn<*>.colsOf(
+    type: KType,
+    filter: (DataColumn<C>) -> Boolean = { true },
+): TransformableColumnSet<C> =
+    colsInternal { it.isSubtypeOf(type) && filter(it.cast()) } as TransformableColumnSet<C>
 
 /**
  * @include [CommonColsOfDocs]
@@ -2035,7 +2239,7 @@ public fun <C> ColumnSet<*>.colsOf(type: KType, filter: (DataColumn<C>) -> Boole
  * @include [CommonColsOfDocs.FilterParam]
  * @include [CommonColsOfDocs.Return]
  */
-public inline fun <reified C> ColumnSet<*>.colsOf(noinline filter: (DataColumn<C>) -> Boolean = { true }): ColumnSet<C> =
+public inline fun <reified C> SingleColumn<*>.colsOf(noinline filter: (DataColumn<C>) -> Boolean = { true }): TransformableColumnSet<C> =
     colsOf(typeOf<C>(), filter)
 
 /* TODO: [Issue: #325, context receiver support](https://github.com/Kotlin/dataframe/issues/325)
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt
index 921fdd412..a77aa4c62 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt
@@ -1,3 +1,5 @@
+@file:Suppress("UNCHECKED_CAST")
+
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyCol
@@ -15,6 +17,8 @@ import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
 import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
 import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
 import org.jetbrains.kotlinx.dataframe.impl.api.convertToImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableSingleColumn
 import kotlin.reflect.typeOf
 
 public fun <T> AnyFrame.cast(): DataFrame<T> = this as DataFrame<T>
@@ -44,6 +48,10 @@ public fun <T> ColumnAccessor<*>.cast(): ColumnAccessor<T> = this as ColumnAcces
 
 public fun <C> ColumnSet<*>.cast(): ColumnSet<C> = this as ColumnSet<C>
 
+public fun <C> TransformableColumnSet<*>.cast(): TransformableColumnSet<C> = this as TransformableColumnSet<C>
+
 public fun <C> ColumnReference<*>.cast(): ColumnReference<C> = this as ColumnReference<C>
 
 public fun <C> SingleColumn<*>.cast(): SingleColumn<C> = this as SingleColumn<C>
+
+public fun <C> TransformableSingleColumn<*>.cast(): TransformableSingleColumn<C> = this as TransformableSingleColumn<C>
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
index 0e9cb3198..3212310ad 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt
@@ -18,7 +18,7 @@ public data class Corr<T, C>(
     internal val columns: ColumnsSelector<T, C>,
 )
 
-public fun <T> DataFrame<T>.corr(): DataFrame<T> = corr { dfs { it.isSuitableForCorr() } }.withItself()
+public fun <T> DataFrame<T>.corr(): DataFrame<T> = corr { cols { it.isSuitableForCorr() }.rec() }.withItself()
 
 public fun <T, C> DataFrame<T>.corr(columns: ColumnsSelector<T, C>): Corr<T, C> = Corr(this, columns)
 public fun <T> DataFrame<T>.corr(vararg columns: String): Corr<T, Any?> = corr { columns.toColumnSet() }
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
index ec2d861a7..40d929b4f 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt
@@ -52,7 +52,9 @@ public fun <T> DataFrame<T>.cumSum(
 public fun <T> DataFrame<T>.cumSum(vararg columns: KProperty<*>, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> =
     cumSum(skipNA) { columns.toColumnSet() }
 
-public fun <T> DataFrame<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) { allDfs() }
+public fun <T> DataFrame<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) {
+    cols { !it.isColumnGroup() }.recursively()
+}
 
 // endregion
 
@@ -77,7 +79,8 @@ public fun <T, G> GroupBy<T, G>.cumSum(
     skipNA: Boolean = defaultCumSumSkipNA,
 ): GroupBy<T, G> = cumSum(skipNA) { columns.toColumnSet() }
 
-public fun <T, G> GroupBy<T, G>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> =
-    cumSum(skipNA) { allDfs() }
+public fun <T, G> GroupBy<T, G>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> = cumSum(skipNA) {
+    cols { !it.isColumnGroup() }.recursively()
+}
 
 // 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
index 793dc2f87..11615b113 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt
@@ -39,7 +39,7 @@ public fun <T> DataColumn<T>.describe(): DataFrame<ColumnDescription> = describe
 
 // region DataFrame
 
-public fun <T> DataFrame<T>.describe(): DataFrame<ColumnDescription> = describe { allDfs() }
+public fun <T> DataFrame<T>.describe(): DataFrame<ColumnDescription> = describe { cols { !it.isColumnGroup() }.recursively() }
 
 public fun <T> DataFrame<T>.describe(columns: ColumnsSelector<T, *>): DataFrame<ColumnDescription> =
     describeImpl(getColumnsWithPaths(columns))
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
index a816fde4b..43214008f 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt
@@ -10,7 +10,7 @@ import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.api.explodeImpl
 import kotlin.reflect.KProperty
 
-private val defaultExplodeColumns: ColumnsSelector<*, *> = { dfs { it.isList() || it.isFrameColumn() } }
+private val defaultExplodeColumns: ColumnsSelector<*, *> = { cols { it.isList() || it.isFrameColumn() }.rec() }
 
 // region explode DataFrame
 
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
index 8453af76f..3e28c405c 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt
@@ -14,7 +14,7 @@ public fun AnyCol.inferType(): DataColumn<*> = guessColumnType(name, toList(), t
 
 // region DataFrame
 
-public fun <T> DataFrame<T>.inferType(): DataFrame<T> = inferType { allDfs() }
+public fun <T> DataFrame<T>.inferType(): DataFrame<T> = inferType { cols { !it.isColumnGroup() }.recursively() }
 
 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/join.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt
index 25fb9147a..6fd14236b 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt
@@ -2,11 +2,7 @@ package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.ColumnsContainer
 import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
-import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.*
 import org.jetbrains.kotlinx.dataframe.impl.api.joinImpl
 import kotlin.reflect.KProperty
 
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
index e4d086f18..a60747a77 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/parse.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/parse.kt
@@ -55,7 +55,9 @@ public data class ParserOptions(
 
 public fun DataColumn<String?>.tryParse(options: ParserOptions? = null): DataColumn<*> = tryParseImpl(options)
 
-public fun <T> DataFrame<T>.parse(options: ParserOptions? = null): DataFrame<T> = parse(options) { allDfs() }
+public fun <T> DataFrame<T>.parse(options: ParserOptions? = null): DataFrame<T> = parse(options) {
+    cols { !it.isColumnGroup() }.recursively()
+}
 
 public fun DataColumn<String?>.parse(options: ParserOptions? = null): DataColumn<*> =
     tryParse(options).also { if (it.typeClass == String::class) error("Can't guess column type") }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt
index 2b8c88cb2..1c06afae9 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt
@@ -42,28 +42,29 @@ public fun <T, C> DataFrame<T>.rename(cols: Iterable<ColumnReference<C>>): Renam
 
 public data class RenameClause<T, C>(val df: DataFrame<T>, val columns: ColumnsSelector<T, C>)
 
-public fun <T> DataFrame<T>.renameToCamelCase(): DataFrame<T> {
+public fun <T> DataFrame<T>.renameToCamelCase(): DataFrame<T> = this
     // recursively rename all column groups to camel case
-    return rename {
-        dfs { it.isColumnGroup() && it.name() matches DELIMITED_STRING_REGEX }
+    .rename {
+        groups { it.name() matches DELIMITED_STRING_REGEX }.recursively()
     }.toCamelCase()
-        // recursively rename all other columns to camel case
-        .rename {
-            dfs { !it.isColumnGroup() && it.name() matches DELIMITED_STRING_REGEX }
-        }.toCamelCase()
-
-        // take all frame columns recursively and call renameToCamelCase() on all dataframes inside
-        .update {
-            dfsOf<AnyFrame>()
-        }.with { it.renameToCamelCase() }
-
-        // convert all first chars of all columns to the lowercase
-        .rename {
-            allDfs()
-        }.into {
-            it.name.replaceFirstChar { it.lowercaseChar() }
-        }
-}
+
+    // recursively rename all other columns to camel case
+    .rename {
+        cols { !it.isColumnGroup() && it.name() matches DELIMITED_STRING_REGEX }.recursively()
+    }.toCamelCase()
+
+    // take all frame columns recursively and call renameToCamelCase() on all dataframes inside
+    .update {
+        colsOf<AnyFrame>().recursively()
+    }.with { it.renameToCamelCase() }
+
+    // convert all first chars of all columns to the lowercase
+    .rename {
+        cols { !it.isColumnGroup() }.recursively()
+    }.into {
+        it.name.replaceFirstChar { it.lowercaseChar() }
+    }
+
 
 public fun <T, C> RenameClause<T, C>.into(vararg newColumns: ColumnReference<*>): DataFrame<T> =
     into(*newColumns.map { it.name() }.toTypedArray())
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
index ca32ebd92..0f6672e17 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
@@ -39,12 +39,17 @@ public fun <T, C, V : Comparable<V>> Reorder<T, C>.byDesc(expression: ColumnExpr
     reorderImpl(true, expression)
 
 public fun <T, V : Comparable<V>> DataFrame<T>.reorderColumnsBy(
-    dfs: Boolean = true,
+    recursively: Boolean = true,
     desc: Boolean = false,
     expression: Selector<AnyCol, V>,
-): DataFrame<T> = Reorder(this, { if (dfs) allDfs(true) else all() }, dfs).reorderImpl(desc, expression)
-
-public fun <T> DataFrame<T>.reorderColumnsByName(dfs: Boolean = true, desc: Boolean = false): DataFrame<T> =
-    reorderColumnsBy(dfs, desc) { name() }
+): DataFrame<T> =
+    Reorder(
+        df = this,
+        columns = { if (recursively) all().recursively() else all() },
+        inFrameColumns = recursively,
+    ).reorderImpl(desc, expression)
+
+public fun <T> DataFrame<T>.reorderColumnsByName(recursively: Boolean = true, desc: Boolean = false): DataFrame<T> =
+    reorderColumnsBy(recursively, desc) { name() }
 
 // endregion
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
index 0905c0f18..4e2d27e99 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt
@@ -38,7 +38,7 @@ public fun <T, C> DataFrame<T>.replace(columns: Iterable<ColumnReference<C>>): R
 
 public fun <T> DataFrame<T>.replaceAll(
     vararg valuePairs: Pair<Any?, Any?>,
-    columns: ColumnsSelector<T, *> = { allDfs() },
+    columns: ColumnsSelector<T, *> = { cols { !it.isColumnGroup() }.recursively() },
 ): 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/toDataFrame.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
index c03c68178..0cd779e58 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
@@ -131,12 +131,12 @@ public fun Iterable<Pair<String, Iterable<Any?>>>.toDataFrameFromPairs(): AnyFra
 public interface TraversePropertiesDsl {
 
     /**
-     * Skip given [classes] during dfs traversal
+     * Skip given [classes] during recursive (dfs) traversal
      */
     public fun exclude(vararg classes: KClass<*>)
 
     /**
-     * Skip given [properties] during dfs traversal
+     * Skip given [properties] during recursive (dfs) traversal
      */
     public fun exclude(vararg properties: KProperty<*>)
 
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
index 3706590e7..75c843770 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/xs.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/xs.kt
@@ -6,16 +6,22 @@ import org.jetbrains.kotlinx.dataframe.impl.api.xsImpl
 
 // region DataFrame
 
-public fun <T> DataFrame<T>.xs(vararg keyValues: Any?): DataFrame<T> = xs(*keyValues) { allDfs().take(keyValues.size) }
+public fun <T> DataFrame<T>.xs(vararg keyValues: Any?): DataFrame<T> = xs(*keyValues) {
+    cols { !it.isColumnGroup() }.recursively().take(keyValues.size)
+}
 
-public fun <T, C> DataFrame<T>.xs(vararg keyValues: C, keyColumns: ColumnsSelector<T, C>): DataFrame<T> = xsImpl(keyColumns, false, *keyValues)
+public fun <T, C> DataFrame<T>.xs(vararg keyValues: C, keyColumns: ColumnsSelector<T, C>): DataFrame<T> =
+    xsImpl(keyColumns, false, *keyValues)
 
 // endregion
 
 // region GroupBy
 
-public fun <T, G> GroupBy<T, G>.xs(vararg keyValues: Any?): GroupBy<T, G> = xs(*keyValues) { allDfs().take(keyValues.size) }
+public fun <T, G> GroupBy<T, G>.xs(vararg keyValues: Any?): GroupBy<T, G> = xs(*keyValues) {
+    cols { !it.isColumnGroup() }.recursively().take(keyValues.size)
+}
 
-public fun <T, G, C> GroupBy<T, G>.xs(vararg keyValues: C, keyColumns: ColumnsSelector<T, C>): GroupBy<T, G> = xsImpl(*keyValues, keyColumns = keyColumns)
+public fun <T, G, C> GroupBy<T, G>.xs(vararg keyValues: C, keyColumns: ColumnsSelector<T, C>): GroupBy<T, G> =
+    xsImpl(*keyValues, keyColumns = keyColumns)
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnReference.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnReference.kt
index e65d38476..8ed0f7840 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnReference.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnReference.kt
@@ -1,10 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.columns
 
-import org.jetbrains.kotlinx.dataframe.AnyFrame
-import org.jetbrains.kotlinx.dataframe.AnyRow
-import org.jetbrains.kotlinx.dataframe.DataColumn
-import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.*
 import org.jetbrains.kotlinx.dataframe.api.name
 import org.jetbrains.kotlinx.dataframe.impl.columnName
 import org.jetbrains.kotlinx.dataframe.impl.columns.RenamedColumnReference
@@ -20,7 +16,8 @@ import kotlin.reflect.KProperty
  */
 public interface ColumnReference<out C> : SingleColumn<C> {
 
-    public operator fun getValue(thisRef: Any?, property: KProperty<*>): ColumnReference<C> = renamedReference(property.columnName)
+    public operator fun getValue(thisRef: Any?, property: KProperty<*>): ColumnReference<C> =
+        renamedReference(property.columnName)
 
     public fun name(): String
 
@@ -32,13 +29,16 @@ public interface ColumnReference<out C> : SingleColumn<C> {
 
     public fun getValueOrNull(row: AnyRow): C? = resolveFor(row.df())?.get(row.index())
 
-    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>? {
-        return context.df.getColumn<C>(path(), context.unresolvedColumnsPolicy)?.addPath(path())
-    }
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>? =
+        context.df
+            .getColumn<C>(path(), context.unresolvedColumnsPolicy)
+            ?.addPath(path())
 }
 
-internal fun <C> ColumnReference<C>.renamedReference(newName: String): ColumnReference<C> = RenamedColumnReference(this, newName)
+internal fun <C> ColumnReference<C>.renamedReference(newName: String): ColumnReference<C> =
+    RenamedColumnReference(this, newName)
 
 internal fun ColumnReference<*>.shortPath() = ColumnPath(name)
 
-internal fun <C> ColumnReference<C>.resolveFor(df: AnyFrame): ColumnWithPath<C>? = resolveSingle(ColumnResolutionContext(df, UnresolvedColumnsPolicy.Skip))
+internal fun <C> ColumnReference<C>.resolveFor(df: AnyFrame): ColumnWithPath<C>? =
+    resolveSingle(ColumnResolutionContext(df, UnresolvedColumnsPolicy.Skip))
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnSet.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnSet.kt
index 794f94aab..b534a61c1 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnSet.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnSet.kt
@@ -3,21 +3,31 @@ package org.jetbrains.kotlinx.dataframe.columns
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.impl.columns.*
 
 /**
+ * ## ColumnSet
  * Entity that can be resolved into a list of [columns][DataColumn].
  *
  * Used as a return type of [ColumnsSelector].
  * @param C common type of resolved columns
+ * @see [SingleColumn]
+ * @see [TransformableColumnSet]
+ * @see [TransformableSingleColumn]
  */
 public interface ColumnSet<out C> {
 
+    /**
+     * Resolves this [ColumnSet] as a [List]<[ColumnWithPath]<[C]>>.
+     * In many cases this function [transforms][ColumnSet.transform] a parent [ColumnSet] to reach
+     * the current [ColumnSet] result.
+     */
     public fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>>
 }
 
-public class ColumnResolutionContext internal constructor (
+public class ColumnResolutionContext internal constructor(
     internal val df: DataFrame<*>,
-    internal val unresolvedColumnsPolicy: UnresolvedColumnsPolicy
+    internal val unresolvedColumnsPolicy: UnresolvedColumnsPolicy,
 ) {
 
     public val allowMissingColumns: Boolean = unresolvedColumnsPolicy != UnresolvedColumnsPolicy.Fail
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnWithPath.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnWithPath.kt
index 4ef6b1f21..45d841dc5 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnWithPath.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnWithPath.kt
@@ -19,15 +19,24 @@ public interface ColumnWithPath<out T> : DataColumn<T> {
 
     public fun depth(): Int = path.depth()
 
-    public fun <C> getChild(accessor: ColumnReference<C>): ColumnWithPath<C>? = asColumnGroup().getColumnOrNull(accessor)?.addPath(path + accessor.path())
+    public fun <C> getChild(accessor: ColumnReference<C>): ColumnWithPath<C>? =
+        asColumnGroup().getColumnOrNull(accessor)?.addPath(path + accessor.path())
 
-    public fun getChild(name: String): ColumnWithPath<Any?>? = asColumnGroup().getColumnOrNull(name)?.addParentPath(path)
+    public fun getChild(name: String): ColumnWithPath<Any?>? =
+        asColumnGroup().getColumnOrNull(name)?.addParentPath(path)
 
-    public fun getChild(index: Int): ColumnWithPath<Any?>? = asColumnGroup().getColumnOrNull(index)?.addParentPath(path)
+    public fun getChild(index: Int): ColumnWithPath<Any?>? =
+        asColumnGroup().getColumnOrNull(index)?.addParentPath(path)
 
-    public fun <C> getChild(accessor: KProperty<C>): ColumnWithPath<C>? = asColumnGroup().getColumnOrNull(accessor)?.addParentPath(path)
+    public fun <C> getChild(accessor: KProperty<C>): ColumnWithPath<C>? =
+        asColumnGroup().getColumnOrNull(accessor)?.addParentPath(path)
 
-    public fun children(): List<ColumnWithPath<Any?>> = if (isColumnGroup()) data.asColumnGroup().columns().map { it.addParentPath(path) } else emptyList()
+    public fun children(): List<ColumnWithPath<Any?>> =
+        if (isColumnGroup()) {
+            data.asColumnGroup().columns().map { it.addParentPath(path) }
+        } else {
+            emptyList()
+        }
 
     override fun path(): ColumnPath = path
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/SingleColumn.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/SingleColumn.kt
index f822f9774..68a0615d9 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/SingleColumn.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/SingleColumn.kt
@@ -1,15 +1,30 @@
 package org.jetbrains.kotlinx.dataframe.columns
 
 import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.impl.columns.*
 
 /**
  * Entity that can be [resolved][resolveSingle] into [DataColumn].
  *
  * @param C Column [type][BaseColumn.type] of resolved column.
+ * @see [ColumnSet]
+ * @see [TransformableColumnSet]
+ * @see [TransformableSingleColumn]
  */
 public interface SingleColumn<out C> : ColumnSet<C> {
 
-    override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> = resolveSingle(context)?.let { listOf(it) } ?: emptyList()
+    override fun resolve(
+        context: ColumnResolutionContext,
+    ): List<ColumnWithPath<C>> = resolveSingle(context)?.let { listOf(it) } ?: emptyList()
 
     public fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>?
 }
+
+public fun ColumnSet<*>.isSingleColumn(): Boolean = this is SingleColumn<*>
+
+/**
+ * Returns true if [this] is a [SingleColumn] and [cols] consists of a single column group.
+ */
+public fun ColumnSet<*>.isSingleColumnWithGroup(cols: List<ColumnWithPath<*>>): Boolean =
+    isSingleColumn() && cols.singleOrNull()?.isColumnGroup() == true
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameReceiver.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameReceiver.kt
index 3345f87fe..25e877c02 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameReceiver.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameReceiver.kt
@@ -1,27 +1,13 @@
 package org.jetbrains.kotlinx.dataframe.impl
 
-import org.jetbrains.kotlinx.dataframe.ColumnSelector
-import org.jetbrains.kotlinx.dataframe.DataColumn
-import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.DataRow
-import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.asDataColumn
-import org.jetbrains.kotlinx.dataframe.api.cast
-import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.pathOf
-import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
-import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
-import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
-import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.columns.*
 import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnGroupWithParent
 import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnGroupWithPathImpl
 import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
 import org.jetbrains.kotlinx.dataframe.impl.columns.missing.MissingColumnGroup
 import org.jetbrains.kotlinx.dataframe.impl.columns.missing.MissingDataColumn
-import org.jetbrains.kotlinx.dataframe.nrow
 
 private fun <T> DataFrame<T>.unbox(): DataFrame<T> = when (this) {
     is ColumnGroupWithParent -> source.unbox()
@@ -29,11 +15,12 @@ private fun <T> DataFrame<T>.unbox(): DataFrame<T> = when (this) {
     else -> this
 }
 
-internal abstract class DataFrameReceiverBase<T>(protected val df: DataFrame<T>) : DataFrameImpl<T>(df.columns(), df.nrow)
+internal abstract class DataFrameReceiverBase<T>(protected val df: DataFrame<T>) :
+    DataFrameImpl<T>(df.columns(), df.nrow)
 
 internal open class DataFrameReceiver<T>(
     source: DataFrame<T>,
-    private val unresolvedColumnsPolicy: UnresolvedColumnsPolicy
+    private val unresolvedColumnsPolicy: UnresolvedColumnsPolicy,
 ) : DataFrameReceiverBase<T>(source.unbox()), SingleColumn<DataRow<T>> {
 
     private fun <R> DataColumn<R>?.check(path: ColumnPath): DataColumn<R> =
@@ -61,11 +48,14 @@ internal open class DataFrameReceiver<T>(
     }
 
     override fun getColumnOrNull(path: ColumnPath) = super.getColumnOrNull(path).check(path)
-    override fun <R> getColumnOrNull(column: ColumnSelector<T, R>) = getColumnsImpl(unresolvedColumnsPolicy, column).singleOrNull()
+    override fun <R> getColumnOrNull(column: ColumnSelector<T, R>) =
+        getColumnsImpl(unresolvedColumnsPolicy, column).singleOrNull()
 
-    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<DataRow<T>>? = DataColumn.createColumnGroup("", df).addPath(emptyPath())
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<DataRow<T>>? =
+        DataColumn.createColumnGroup("", df).addPath(emptyPath())
 
-    override fun columns() = df.columns().map { if (it.isColumnGroup()) ColumnGroupWithParent(null, it.asColumnGroup()) else it }
+    override fun columns() =
+        df.columns().map { if (it.isColumnGroup()) ColumnGroupWithParent(null, it.asColumnGroup()) else it }
 
     override fun columnNames() = df.columnNames()
 
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
index 6675dcc0c..585dc87fa 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/GroupByImpl.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/GroupByImpl.kt
@@ -6,18 +6,7 @@ import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.Selector
 import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedBody
 import org.jetbrains.kotlinx.dataframe.aggregation.NamedValue
-import org.jetbrains.kotlinx.dataframe.api.GroupBy
-import org.jetbrains.kotlinx.dataframe.api.GroupedRowFilter
-import org.jetbrains.kotlinx.dataframe.api.asGroupBy
-import org.jetbrains.kotlinx.dataframe.api.cast
-import org.jetbrains.kotlinx.dataframe.api.concat
-import org.jetbrains.kotlinx.dataframe.api.convert
-import org.jetbrains.kotlinx.dataframe.api.getColumn
-import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
-import org.jetbrains.kotlinx.dataframe.api.into
-import org.jetbrains.kotlinx.dataframe.api.minus
-import org.jetbrains.kotlinx.dataframe.api.pathOf
-import org.jetbrains.kotlinx.dataframe.api.rename
+import org.jetbrains.kotlinx.dataframe.api.*
 import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.AggregatableInternal
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.GroupByReceiverImpl
@@ -95,7 +84,7 @@ internal fun <T, G, R> aggregateGroupBy(
 
     if (!removeColumns) removedNode.data.wasRemoved = false
 
-    val columnsToInsert = groupedFrame.getColumnsWithPaths { allDfs() }.map {
+    val columnsToInsert = groupedFrame.getColumnsWithPaths { cols { !it.isColumnGroup() }.rec() }.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/aggregation/ConfiguredAggregateColumn.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ConfiguredAggregateColumn.kt
index daae75d99..6a0f6ea05 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ConfiguredAggregateColumn.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ConfiguredAggregateColumn.kt
@@ -1,11 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.impl.aggregation
 
-import org.jetbrains.kotlinx.dataframe.api.name
-import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
-import org.jetbrains.kotlinx.dataframe.columns.shortPath
+import org.jetbrains.kotlinx.dataframe.columns.*
 
 internal class ConfiguredAggregateColumn<C> private constructor(
     val columns: ColumnSet<C>,
@@ -22,7 +17,7 @@ internal class ConfiguredAggregateColumn<C> private constructor(
         else -> AggregateColumnDescriptor(col, default, if (keepName) newPath?.plus(col.name) else newPath)
     }
 
-    override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> {
+    private fun resolve(context: ColumnResolutionContext, columns: ColumnSet<C>): List<ColumnWithPath<C>> {
         val resolved = columns.resolve(context)
         if (resolved.size == 1) return listOf(resolved[0].toDescriptor(false))
         else return resolved.map {
@@ -30,6 +25,9 @@ internal class ConfiguredAggregateColumn<C> private constructor(
         }
     }
 
+    override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> =
+        resolve(context, columns)
+
     companion object {
 
         fun <C> withDefault(src: ColumnSet<C>, default: C?): ColumnSet<C> = when (src) {
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/corr.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/corr.kt
index 2a3143be9..cac43096d 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/corr.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/corr.kt
@@ -2,16 +2,7 @@ package org.jetbrains.kotlinx.dataframe.impl.api
 
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.api.Corr
-import org.jetbrains.kotlinx.dataframe.api.cast
-import org.jetbrains.kotlinx.dataframe.api.castToNotNullable
-import org.jetbrains.kotlinx.dataframe.api.convertToDouble
-import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
-import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
-import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.isSuitableForCorr
-import org.jetbrains.kotlinx.dataframe.api.name
-import org.jetbrains.kotlinx.dataframe.api.toValueColumn
+import org.jetbrains.kotlinx.dataframe.api.*
 import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
 import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
 import org.jetbrains.kotlinx.dataframe.math.varianceAndMean
@@ -25,7 +16,7 @@ internal fun <T, C, R> Corr<T, C>.corrImpl(otherColumns: ColumnsSelector<T, R>):
         // extract nested number columns from ColumnGroups
         if (it.isColumnGroup()) {
             val groupPath = it.path
-            df.getColumnsWithPaths { groupPath.dfs { it.isSuitableForCorr() } }.map { it.cast() }
+            df.getColumnsWithPaths { groupPath.cols { it.isSuitableForCorr() }.rec() }.map { it.cast() }
         } else listOf(it)
     }
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/describe.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/describe.kt
index 671480716..74b0567b2 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/describe.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/describe.kt
@@ -31,12 +31,25 @@ import org.jetbrains.kotlinx.dataframe.type
 import kotlin.reflect.jvm.jvmErasure
 
 internal fun describeImpl(cols: List<AnyCol>): DataFrame<ColumnDescription> {
-    fun List<AnyCol>.collectAll(dfs: Boolean): List<AnyCol> = flatMap { col ->
+    fun List<AnyCol>.collectAll(recursively: Boolean): List<AnyCol> = flatMap { col ->
         when (col.kind) {
-            ColumnKind.Frame -> col.asAnyFrameColumn().concat().columns().map {
-                it.addPath(col.path() + it.name)
-            }.collectAll(true)
-            ColumnKind.Group -> if (dfs) col.asColumnGroup().columns().map { it.addPath(col.path() + it.name) }.collectAll(true) else listOf(col)
+            ColumnKind.Frame ->
+                col.asAnyFrameColumn()
+                    .concat()
+                    .columns()
+                    .map { it.addPath(col.path() + it.name) }
+                    .collectAll(true)
+
+            ColumnKind.Group ->
+                if (recursively) {
+                    col.asColumnGroup()
+                        .columns()
+                        .map { it.addPath(col.path() + it.name) }
+                        .collectAll(true)
+                } else {
+                    listOf(col)
+                }
+
             ColumnKind.Value -> listOf(col)
         }
     }
@@ -55,14 +68,18 @@ internal fun describeImpl(cols: List<AnyCol>): DataFrame<ColumnDescription> {
         ColumnDescription::count from { it.size }
         ColumnDescription::unique from { it.countDistinct() }
         ColumnDescription::nulls from { it.values.count { it == null } }
-        ColumnDescription::top from inferType { it.values.filterNotNull().groupBy { it }.maxByOrNull { it.value.size }?.key }
+        ColumnDescription::top from inferType {
+            it.values.filterNotNull().groupBy { it }.maxByOrNull { it.value.size }?.key
+        }
         if (hasNumeric) {
             ColumnDescription::mean from { if (it.isNumber()) it.asNumbers().mean() else null }
             ColumnDescription::std from { if (it.isNumber()) it.asNumbers().std() else null }
         }
         if (hasComparable) {
             ColumnDescription::min from inferType { if (it.isComparable()) it.asComparable().minOrNull() else null }
-            ColumnDescription::median from inferType { if (it.isComparable()) it.asComparable().medianOrNull() else null }
+            ColumnDescription::median from inferType {
+                if (it.isComparable()) it.asComparable().medianOrNull() else null
+            }
             ColumnDescription::max from inferType { if (it.isComparable()) it.asComparable().maxOrNull() else null }
         }
     }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/flatten.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/flatten.kt
index 5ed842f65..d410fb525 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/flatten.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/flatten.kt
@@ -16,17 +16,19 @@ internal fun <T, C> DataFrame<T>.flattenImpl(
     columns: ColumnsSelector<T, C>,
     keepParentNameForColumns: Boolean = false
 ): DataFrame<T> {
-    val rootColumns = getColumnsWithPaths { columns.toColumnSet().filter { it.isColumnGroup() }.top() }
+    val rootColumns = getColumnsWithPaths {
+        columns.toColumnSet().filter { it.isColumnGroup() }.roots()
+    }
     val rootPrefixes = rootColumns.map { it.path }.toSet()
-    val nameGenerators = rootPrefixes.map { it.dropLast() }.distinct().associate { path ->
+    val nameGenerators = rootPrefixes.map { it.dropLast() }.distinct().associateWith { path ->
         val usedNames = get(path).asColumnGroup().columns().filter { path + it.name() !in rootPrefixes }.map { it.name() }
-        path to ColumnNameGenerator(usedNames)
+        ColumnNameGenerator(usedNames)
     }
 
     fun getRootPrefix(path: ColumnPath) =
         (1 until path.size).asSequence().map { path.take(it) }.first { rootPrefixes.contains(it) }
 
-    val result = move { rootPrefixes.toColumnSet().allDfs() }
+    val result = move { rootPrefixes.toColumnSet().cols { !it.isColumnGroup() }.recursively() }
         .into {
             val targetPath = getRootPrefix(it.path).dropLast(1)
             val nameGen = nameGenerators[targetPath]!!
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
index 4624fa6de..daad1cde2 100644
--- 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
@@ -74,8 +74,8 @@ internal fun <A, B> DataFrame<A>.joinImpl(
         val leftCol = leftJoinColumns[i]
         val rightCol = rightJoinColumns[i]
         if (leftCol.isColumnGroup() && rightCol.isColumnGroup()) {
-            val leftColumns = getColumnsWithPaths { leftCol.allDfs() }
-            val rightColumns = other.getColumnsWithPaths { rightCol.allDfs() }
+            val leftColumns = getColumnsWithPaths { leftCol.cols { !it.isColumnGroup() }.recursively()}
+            val rightColumns = other.getColumnsWithPaths { rightCol.cols { !it.isColumnGroup() }.recursively() }
 
             val leftPrefixLength = leftCol.path.size
             val rightPrefixLength = rightCol.path.size
@@ -147,12 +147,13 @@ internal fun <A, B> DataFrame<A>.joinImpl(
         outputRowsCount += rightUnmatchedCount
     }
 
-    val leftColumns = getColumnsWithPaths { allDfs() }
+    val leftColumns = getColumnsWithPaths { cols { !it.isColumnGroup() }.recursively() }
 
-    val rightJoinColumnPaths = allRightJoinColumns.map { it.path to it.data }.toMap()
+    val rightJoinColumnPaths = allRightJoinColumns.associate { it.path to it.data }
 
     val newRightColumns =
-        if (addNewColumns) other.getColumnsWithPaths { dfs { !it.isColumnGroup() && !rightJoinColumnPaths.contains(it.path) } } else emptyList()
+        if (addNewColumns) other.getColumnsWithPaths { cols { !it.isColumnGroup() && !rightJoinColumnPaths.contains(it.path) }.rec() }
+        else emptyList()
 
     // for every column index from the left dataframe store matching column from the right dataframe
     val leftToRightColumns = leftColumns.map { rightJoinColumnPaths[pathMapping[it.path()]] }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/pivot.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/pivot.kt
index a29c3aa41..292320ce1 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/pivot.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/pivot.kt
@@ -8,12 +8,8 @@ import org.jetbrains.kotlinx.dataframe.api.PivotColumnsSelector
 import org.jetbrains.kotlinx.dataframe.api.forEach
 import org.jetbrains.kotlinx.dataframe.api.groupBy
 import org.jetbrains.kotlinx.dataframe.api.toPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.*
 import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
-import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.GroupByReceiverImpl
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.AggregateInternalDsl
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.AggregatePivotDslImpl
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/sort.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/sort.kt
index fac8e3967..a83d14824 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/sort.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/sort.kt
@@ -9,11 +9,8 @@ import org.jetbrains.kotlinx.dataframe.api.castFrameColumn
 import org.jetbrains.kotlinx.dataframe.api.getFrameColumn
 import org.jetbrains.kotlinx.dataframe.api.update
 import org.jetbrains.kotlinx.dataframe.api.with
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.*
 import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
-import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
 import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
 import org.jetbrains.kotlinx.dataframe.impl.columns.assertIsComparable
 import org.jetbrains.kotlinx.dataframe.impl.columns.missing.MissingColumnGroup
@@ -106,7 +103,8 @@ internal fun <C> ColumnWithPath<C>.addFlag(flag: SortFlag): ColumnWithPath<C> {
 }
 
 internal class ColumnsWithSortFlag<C>(val column: ColumnSet<C>, val flag: SortFlag) : ColumnSet<C> {
-    override fun resolve(context: ColumnResolutionContext) = column.resolve(context).map { it.addFlag(flag) }
+    override fun resolve(context: ColumnResolutionContext) =
+        column.resolve(context).map { it.addFlag(flag) }
 }
 
 internal class SortColumnDescriptor<C>(
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnAccessorImpl.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnAccessorImpl.kt
index 3f6e14e82..dbc7d0944 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnAccessorImpl.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnAccessorImpl.kt
@@ -6,11 +6,7 @@ import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
 import org.jetbrains.kotlinx.dataframe.api.cast
 import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
 import org.jetbrains.kotlinx.dataframe.api.toPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
-import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.*
 
 internal class ColumnAccessorImpl<T>(val path: ColumnPath) : ColumnAccessor<T> {
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnsList.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnsList.kt
index 4fe7c9885..35d15fc7c 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnsList.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnsList.kt
@@ -6,5 +6,6 @@ import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
 internal class ColumnsList<C>(val columns: List<ColumnSet<C>>) : ColumnSet<C> {
     constructor(vararg columns: ColumnSet<C>) : this(columns.toList())
 
-    override fun resolve(context: ColumnResolutionContext) = columns.flatMap { it.resolve(context) }
+    override fun resolve(context: ColumnResolutionContext) =
+        columns.flatMap { it.resolve(context) }
 }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/Recursively.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/Recursively.kt
new file mode 100644
index 000000000..5f6b1de32
--- /dev/null
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/Recursively.kt
@@ -0,0 +1,92 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.api.allInternal
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.*
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.flattenRecursively
+
+/**
+ * Recursively implementation for [TransformableColumnSet].
+ * This converts a [TransformableColumnSet] into a [ColumnSet] by redirecting [ColumnSet.resolve]
+ * to [TransformableColumnSet.transformResolve] with a correctly configured [RecursivelyTransformer].
+ */
+internal fun <C> TransformableColumnSet<C>.recursivelyImpl(
+    includeGroups: Boolean = true,
+    includeTopLevel: Boolean = true,
+): ColumnSet<C> = object : ColumnSet<C> {
+
+    override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> =
+        this@recursivelyImpl.transformResolve(
+            context = context,
+            transformer = RecursivelyTransformer(
+                includeGroups = includeGroups,
+                includeTopLevel = includeTopLevel,
+            ),
+        )
+}
+
+/**
+ * Recursively implementation for [TransformableSingleColumn].
+ * This converts a [TransformableSingleColumn] into a [SingleColumn] by redirecting [SingleColumn.resolveSingle]
+ * to [TransformableSingleColumn.transformResolveSingle] with a correctly configured [RecursivelyTransformer].
+ */
+internal fun <C> TransformableSingleColumn<C>.recursivelyImpl(
+    includeGroups: Boolean = true,
+    includeTopLevel: Boolean = true,
+): SingleColumn<C> = object : SingleColumn<C> {
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>? =
+        this@recursivelyImpl.transformResolveSingle(
+            context = context,
+            transformer = RecursivelyTransformer(
+                includeGroups = includeGroups,
+                includeTopLevel = includeTopLevel,
+            ),
+        )
+}
+
+/**
+ * ## Recursively transformer.
+ * A [ColumnSetTransformer] implementation around the [ColumnSet.flattenRecursively] function.
+ * Created only using [recursivelyImpl].
+ */
+private class RecursivelyTransformer(
+    val includeGroups: Boolean = true,
+    val includeTopLevel: Boolean = true,
+) : ColumnSetTransformer {
+
+    override fun transform(columnSet: ColumnSet<*>): ColumnSet<*> =
+        columnSet.flattenRecursively(
+            includeGroups = includeGroups,
+            includeTopLevel = includeTopLevel,
+        )
+
+    override fun transformSingle(singleColumn: SingleColumn<*>): ColumnSet<*> =
+        singleColumn.flattenRecursively(
+            includeGroups = includeGroups,
+            includeTopLevel = includeTopLevel,
+        )
+}
+
+/**
+ * Flattens a [ColumnSet]/[SingleColumn] recursively.
+ *
+ * If [this] is a [SingleColumn] containing a single [ColumnGroup], the "top-level" is
+ * considered to be the [ColumnGroup]'s children, otherwise, if this is a [ColumnSet],
+ * the "top-level" is considered to be the columns in the [ColumnSet].
+ *
+ * @param includeGroups Whether to include [ColumnGroup]s in the result.
+ * @param includeTopLevel Whether to include the "top-level" columns in the result.
+ */
+internal fun ColumnSet<*>.flattenRecursively(
+    includeGroups: Boolean = true,
+    includeTopLevel: Boolean = true,
+): ColumnSet<*> = allInternal().transform { cols ->
+    if (includeTopLevel) {
+        cols.flattenRecursively()
+    } else {
+        cols
+            .filter { it.isColumnGroup() }
+            .flatMap { it.children().flattenRecursively() }
+    }.filter { includeGroups || !it.isColumnGroup() }
+}
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/TransformableColumnSet.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/TransformableColumnSet.kt
new file mode 100644
index 000000000..37b6e02e3
--- /dev/null
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/TransformableColumnSet.kt
@@ -0,0 +1,58 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+
+/**
+ * ## Transformable ColumnSet
+ * This type of [ColumnSet] can be [transformed][transformResolve] before being resolved.
+ *
+ * This is especially useful for calls like
+ * [cols { }][ColumnsSelectionDsl.cols].[recursively()][ColumnsSelectionDsl.recursively],
+ * where [recursively][ColumnsSelectionDsl.recursively] modifies the [ColumnSet][ColumnSet]
+ * that [cols { }][ColumnsSelectionDsl.cols] operates on before it's evaluated.
+ *
+ * @see [ColumnSet]
+ * @see [TransformableSingleColumn]
+ * @see [SingleColumn]
+ */
+public interface TransformableColumnSet<out C> : ColumnSet<C> {
+    public fun transformResolve(
+        context: ColumnResolutionContext,
+        transformer: ColumnSetTransformer,
+    ): List<ColumnWithPath<C>>
+}
+
+/**
+ * ## Transformable SingleColumn
+ * This type of [SingleColumn] can be [transformed][transformResolveSingle] before being resolved.
+ *
+ * This is especially useful for calls like
+ * [first { }][ColumnsSelectionDsl.first].[recursively()][ColumnsSelectionDsl.recursively],
+ * where [recursively][ColumnsSelectionDsl.recursively] modifies the [ColumnSet][ColumnSet]
+ * that [first { }][ColumnsSelectionDsl.first] operates on before it's evaluated.
+ *
+ * @see [SingleColumn]
+ * @see [TransformableColumnSet]
+ * @see [ColumnSet]
+ */
+public interface TransformableSingleColumn<out C> : SingleColumn<C> {
+    public fun transformResolveSingle(
+        context: ColumnResolutionContext,
+        transformer: ColumnSetTransformer,
+    ): ColumnWithPath<C>?
+}
+
+/**
+ * ## Column set transformer.
+ * This contains implementations for both [transform][ColumnSet.transform] and
+ * [transformSingle][SingleColumn.transformSingle] and can be passed around.
+ */
+public interface ColumnSetTransformer {
+    public fun transform(columnSet: ColumnSet<*>): ColumnSet<*>
+
+    public fun transformSingle(singleColumn: SingleColumn<*>): ColumnSet<*>
+}
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/Utils.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/Utils.kt
index e30b80ac9..197e9092d 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/Utils.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/Utils.kt
@@ -9,27 +9,12 @@ import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.api.cast
 import org.jetbrains.kotlinx.dataframe.api.name
 import org.jetbrains.kotlinx.dataframe.api.pathOf
-import org.jetbrains.kotlinx.dataframe.columns.BaseColumn
-import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
-import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
-import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
-import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
-import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
-import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
-import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.columns.*
 import org.jetbrains.kotlinx.dataframe.columns.values
 import org.jetbrains.kotlinx.dataframe.impl.DataFrameImpl
 import org.jetbrains.kotlinx.dataframe.impl.asNullable
 import org.jetbrains.kotlinx.dataframe.impl.columns.missing.MissingDataColumn
-import org.jetbrains.kotlinx.dataframe.impl.columns.tree.ColumnPosition
-import org.jetbrains.kotlinx.dataframe.impl.columns.tree.TreeNode
-import org.jetbrains.kotlinx.dataframe.impl.columns.tree.collectTree
-import org.jetbrains.kotlinx.dataframe.impl.columns.tree.getOrPut
-import org.jetbrains.kotlinx.dataframe.impl.columns.tree.put
-import org.jetbrains.kotlinx.dataframe.impl.columns.tree.topDfs
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.*
 import org.jetbrains.kotlinx.dataframe.impl.equalsByElement
 import org.jetbrains.kotlinx.dataframe.impl.rollingHash
 import org.jetbrains.kotlinx.dataframe.nrow
@@ -93,34 +78,108 @@ internal fun <T> DataColumn<T>.assertIsComparable(): DataColumn<T> {
     return this
 }
 
-internal fun <A, B> SingleColumn<A>.transformSingle(converter: (ColumnWithPath<A>) -> List<ColumnWithPath<B>>): ColumnSet<B> =
-    object : ColumnSet<B> {
-        override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<B>> =
-            this@transformSingle.resolveSingle(context)?.let { converter(it) } ?: emptyList()
-    }
+/**
+ * Applies a transformation on [this] [SingleColumn] by converting its
+ * single [ColumnWithPath]<[A]> to [List]<[ColumnWithPath]<[B]>] using [converter].
+ * Since [converter] allows you to return multiple columns, the result is turned into a [ColumnSet]<[B]>.
+ */
+internal fun <A, B> SingleColumn<A>.transformSingle(
+    converter: (ColumnWithPath<A>) -> List<ColumnWithPath<B>>,
+): ColumnSet<B> = object : ColumnSet<B> {
+    override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<B>> =
+        this@transformSingle
+            .resolveSingle(context)
+            ?.let(converter)
+            ?: emptyList()
+}
 
-internal fun <A, B> ColumnSet<A>.transform(converter: (List<ColumnWithPath<A>>) -> List<ColumnWithPath<B>>): ColumnSet<B> =
-    object : ColumnSet<B> {
-        override fun resolve(context: ColumnResolutionContext) = converter(this@transform.resolve(context))
-    }
+/**
+ * Applies a transformation on [this] by converting its [List]<[ColumnWithPath]<[A]>] to [List]<[ColumnWithPath]<[B]>]
+ * using [converter].
+ *
+ * The result can either be used as a normal [ColumnSet]<[B]>,
+ * which resolves [this] and then applies [converter] on the result,
+ *
+ * or it can be used as a [TransformableColumnSet]<[B]>, where a [ColumnSetTransformer] can be injected before
+ * the [converter] is applied.
+ */
+internal fun <A, B> ColumnSet<A>.transform(
+    converter: (List<ColumnWithPath<A>>) -> List<ColumnWithPath<B>>,
+): TransformableColumnSet<B> = object : TransformableColumnSet<B> {
+    override fun resolve(context: ColumnResolutionContext) =
+        this@transform
+            .resolve(context)
+            .let(converter)
+
+    override fun transformResolve(
+        context: ColumnResolutionContext,
+        transformer: ColumnSetTransformer,
+    ): List<ColumnWithPath<B>> =
+        transformer.transform(this@transform)
+            .resolve(context)
+            .let { converter(it as List<ColumnWithPath<A>>) }
+}
 
+/**
+ * Applies a transformation on [this] by converting its [List]<[ColumnWithPath]<[A]>] to [List]<[ColumnWithPath]<[B]>]
+ * using [converter], but also providing the [ColumnResolutionContext] to the converter.
+ *
+ * The result can either be used as a normal [ColumnSet]<[B]>,
+ * which resolves [this] and then applies [converter] on the result,
+ *
+ * or it can be used as a [TransformableColumnSet]<[B]>, where a [ColumnSetTransformer] can be injected before
+ * the [converter] is applied.
+ */
 internal fun <A, B> ColumnSet<A>.transformWithContext(
     converter: ColumnResolutionContext.(List<ColumnWithPath<A>>) -> List<ColumnWithPath<B>>,
-): ColumnSet<B> = object : ColumnSet<B> {
+): TransformableColumnSet<B> = object : TransformableColumnSet<B> {
     override fun resolve(context: ColumnResolutionContext) =
-        converter(context, this@transformWithContext.resolve(context))
+        this@transformWithContext
+            .resolve(context)
+            .let { converter(context, it) }
+
+    override fun transformResolve(
+        context: ColumnResolutionContext,
+        transformer: ColumnSetTransformer,
+    ): List<ColumnWithPath<B>> =
+        transformer.transform(this@transformWithContext)
+            .resolve(context)
+            .let { converter(context, it as List<ColumnWithPath<A>>) }
 }
 
-internal fun <T> ColumnSet<T>.singleImpl() = object : SingleColumn<T> {
-    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? {
-        return this@singleImpl.resolve(context).singleOrNull()
-    }
+/**
+ * Converts [this] [ColumnSet] to a [SingleColumn].
+ * [resolveSingle] will return the single column of [this] if there is only one, else it will return `null`.
+ * If the result used as a [ColumnSet], `null` will be converted to an empty list.
+ */
+internal fun <T> ColumnSet<T>.singleImpl(): SingleColumn<T> = object : SingleColumn<T> {
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? =
+        this@singleImpl.resolve(context).singleOrNull()
 }
 
-internal fun <T> ColumnSet<T>.getAt(index: Int) = object : SingleColumn<T> {
-    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? {
-        return this@getAt.resolve(context).getOrNull(index)
+/**
+ * Same as [singleImpl], however, it passes any [ColumnSetTransformer] back to [this] if it is supplied.
+ */
+internal fun <T> TransformableColumnSet<T>.singleWithTransformerImpl(): TransformableSingleColumn<T> =
+    object : TransformableSingleColumn<T> {
+        override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? =
+            this@singleWithTransformerImpl.resolve(context).singleOrNull()
+
+        override fun transformResolveSingle(
+            context: ColumnResolutionContext,
+            transformer: ColumnSetTransformer,
+        ): ColumnWithPath<T>? =
+            this@singleWithTransformerImpl.transformResolve(
+                context = context,
+                transformer = transformer,
+            ).singleOrNull()
     }
+
+internal fun <T> ColumnSet<T>.getAt(index: Int): SingleColumn<T> = object : SingleColumn<T> {
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? =
+        this@getAt
+            .resolve(context)
+            .getOrNull(index)
 }
 
 internal fun <T> ColumnSet<T>.getChildrenAt(index: Int): ColumnSet<Any?> =
@@ -146,10 +205,16 @@ internal fun <C> ColumnsContainer<*>.getColumn(path: ColumnPath, policy: Unresol
             UnresolvedColumnsPolicy.Create -> DataColumn.empty().cast<C>()
         }
 
-internal fun <T> List<ColumnWithPath<T>>.top(): List<ColumnWithPath<T>> {
-    val root = TreeNode.createRoot<ColumnWithPath<T>?>(null)
-    forEach { root.put(it.path, it) }
-    return root.topDfs { it.data != null }.map { it.data!! }
+/**
+ * Returns a sub-list of columns that are roots of the trees of columns.
+ *
+ * In practice, this means that if a column in [this] is a child of another column in [this],
+ * it will not be included in the result.
+ */
+internal fun <T> List<ColumnWithPath<T>>.roots(): List<ColumnWithPath<T>> {
+    val emptyRoot = TreeNode.createRoot<ColumnWithPath<T>?>(data = null)
+    this.forEach { emptyRoot.put(it.path, it) }
+    return emptyRoot.topmostChildren { it.data != null }.map { it.data!! }
 }
 
 internal fun List<ColumnWithPath<*>>.allColumnsExcept(columns: Iterable<ColumnWithPath<*>>): List<ColumnWithPath<*>> {
@@ -157,14 +222,14 @@ internal fun List<ColumnWithPath<*>>.allColumnsExcept(columns: Iterable<ColumnWi
     val fullTree = collectTree()
     columns.forEach {
         var node = fullTree.getOrPut(it.path).asNullable()
-        node?.dfs()?.forEach { it.data = null }
+        node?.allChildren()?.forEach { it.data = null }
         while (node != null) {
             node.data = null
             node = node.parent
         }
     }
-    val dfs = fullTree.topDfs { it.data != null }
-    return dfs.map { it.data!!.addPath(it.pathFromRoot()) }
+    val subtrees = fullTree.topmostChildren { it.data != null }
+    return subtrees.map { it.data!!.addPath(it.pathFromRoot()) }
 }
 
 internal fun KType.toColumnKind(): ColumnKind = jvmErasure.let {
@@ -177,13 +242,13 @@ internal fun KType.toColumnKind(): ColumnKind = jvmErasure.let {
 
 internal fun <C> ColumnSet<C>.resolve(
     df: DataFrame<*>,
-    unresolvedColumnsPolicy: UnresolvedColumnsPolicy = UnresolvedColumnsPolicy.Fail
+    unresolvedColumnsPolicy: UnresolvedColumnsPolicy = UnresolvedColumnsPolicy.Fail,
 ) =
     resolve(ColumnResolutionContext(df, unresolvedColumnsPolicy))
 
 internal fun <C> SingleColumn<C>.resolveSingle(
     df: DataFrame<*>,
-    unresolvedColumnsPolicy: UnresolvedColumnsPolicy = UnresolvedColumnsPolicy.Fail
+    unresolvedColumnsPolicy: UnresolvedColumnsPolicy = UnresolvedColumnsPolicy.Fail,
 ): ColumnWithPath<C>? =
     resolveSingle(ColumnResolutionContext(df, unresolvedColumnsPolicy))
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnImpl.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnImpl.kt
index b21d8f6f6..49253bf0b 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnImpl.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnImpl.kt
@@ -2,9 +2,7 @@ package org.jetbrains.kotlinx.dataframe.impl.columns
 
 import org.jetbrains.kotlinx.dataframe.AnyRow
 import org.jetbrains.kotlinx.dataframe.DataColumn
-import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.columns.*
 import kotlin.reflect.KType
 import kotlin.reflect.full.withNullability
 
@@ -13,9 +11,8 @@ internal open class ValueColumnImpl<T>(
     name: String,
     type: KType,
     val defaultValue: T? = null,
-    distinct: Lazy<Set<T>>? = null
-) :
-    DataColumnImpl<T>(values, name, type, distinct), ValueColumn<T> {
+    distinct: Lazy<Set<T>>? = null,
+) : DataColumnImpl<T>(values, name, type, distinct), ValueColumn<T> {
 
     override fun distinct() = ValueColumnImpl(toSet().toList(), name, type, defaultValue, distinct)
 
@@ -40,7 +37,8 @@ internal open class ValueColumnImpl<T>(
         return createWithValues(newValues, nullable)
     }
 
-    override fun get(columnName: String) = throw UnsupportedOperationException("Can not get nested column '$columnName' from ValueColumn '$name'")
+    override fun get(columnName: String) =
+        throw UnsupportedOperationException("Can not get nested column '$columnName' from ValueColumn '$name'")
 
     override operator fun get(range: IntRange): ValueColumn<T> = super<DataColumnImpl>.get(range) as ValueColumn<T>
 
@@ -50,12 +48,13 @@ internal open class ValueColumnImpl<T>(
 }
 
 internal class ResolvingValueColumn<T>(
-    override val source: ValueColumn<T>
+    override val source: ValueColumn<T>,
 ) : ValueColumn<T> by source, ForceResolvedColumn<T> {
 
     override fun resolve(context: ColumnResolutionContext) = super<ValueColumn>.resolve(context)
 
-    override fun resolveSingle(context: ColumnResolutionContext) = context.df.getColumn<T>(source.name(), context.unresolvedColumnsPolicy)?.addPath()
+    override fun resolveSingle(context: ColumnResolutionContext) =
+        context.df.getColumn<T>(source.name(), context.unresolvedColumnsPolicy)?.addPath()
 
     override fun getValue(row: AnyRow) = super<ValueColumn>.getValue(row)
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt
index 01790f3b8..1cf7d097e 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt
@@ -144,10 +144,23 @@ internal fun <T> createColumn(values: Iterable<T>, suggestedType: KType, guessTy
 
 // region create Columns
 
-internal fun <C> createColumnSet(resolver: (ColumnResolutionContext) -> List<ColumnWithPath<C>>): ColumnSet<C> =
-    object : ColumnSet<C> {
-        override fun resolve(context: ColumnResolutionContext) = resolver(context)
-    }
+internal fun <C> createColumnSet(
+    resolver: (context: ColumnResolutionContext) -> List<ColumnWithPath<C>>,
+): ColumnSet<C> = object : ColumnSet<C> {
+    override fun resolve(context: ColumnResolutionContext) = resolver(context)
+}
+
+internal fun <C> createTransformableColumnSet(
+    resolver: (context: ColumnResolutionContext) -> List<ColumnWithPath<C>>,
+    transformResolve: (context: ColumnResolutionContext, transformer: ColumnSetTransformer) -> List<ColumnWithPath<C>>,
+): TransformableColumnSet<C> = object : TransformableColumnSet<C> {
+    override fun resolve(context: ColumnResolutionContext) = resolver(context)
+
+    override fun transformResolve(
+        context: ColumnResolutionContext,
+        transformer: ColumnSetTransformer,
+    ): List<ColumnWithPath<C>> = transformResolve(context, transformer)
+}
 
 // region toColumnSet
 
@@ -155,12 +168,11 @@ internal fun <C> createColumnSet(resolver: (ColumnResolutionContext) -> List<Col
 
 internal fun <TD, T : DataFrame<TD>, C> Selector<T, ColumnSet<C>>.toColumnSet(
     createReceiver: (ColumnResolutionContext) -> T,
-): ColumnSet<C> =
-    createColumnSet {
-        val receiver = createReceiver(it)
-        val columnSet = this(receiver, receiver)
-        columnSet.resolve(receiver, it.unresolvedColumnsPolicy)
-    }
+): ColumnSet<C> = createColumnSet {
+    val receiver = createReceiver(it)
+    val columnSet = this(receiver, receiver)
+    columnSet.resolve(receiver, it.unresolvedColumnsPolicy)
+}
 
 @JvmName("toColumnSetForPivot")
 internal fun <T, C> PivotColumnsSelector<T, C>.toColumnSet(): ColumnSet<C> = toColumnSet {
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingColumnGroup.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingColumnGroup.kt
index 62518ab0c..a3abdcedd 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingColumnGroup.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingColumnGroup.kt
@@ -8,10 +8,7 @@ import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedBody
 import org.jetbrains.kotlinx.dataframe.api.asDataColumn
 import org.jetbrains.kotlinx.dataframe.api.cast
 import org.jetbrains.kotlinx.dataframe.api.name
-import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.*
 import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
 import org.jetbrains.kotlinx.dataframe.impl.columns.DataColumnGroup
 import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/TreeNode.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/TreeNode.kt
index 2f35bca69..bf9d27646 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/TreeNode.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/TreeNode.kt
@@ -6,7 +6,7 @@ internal class TreeNode<T>(
     override val name: String,
     override val depth: Int,
     override var data: T,
-    override val parent: TreeNode<T>? = null
+    override val parent: TreeNode<T>? = null,
 ) : ReadonlyTreeNode<T> {
 
     companion object {
@@ -28,7 +28,7 @@ internal class TreeNode<T>(
     fun pathFromRoot(): ColumnPath {
         val path = mutableListOf<String>()
         var node: TreeNode<T>? = this
-        while (node != null && node.parent != null) {
+        while (node?.parent != null) {
             path.add(node.name)
             node = node.parent
         }
@@ -48,19 +48,34 @@ internal class TreeNode<T>(
         return addChild(childName, createData())
     }
 
-    fun dfs(enterCondition: (TreeNode<T>) -> Boolean = { true }, yieldCondition: (TreeNode<T>) -> Boolean = { true }): List<TreeNode<T>> {
+    @Deprecated("Use allChildren instead", ReplaceWith("allChildren(enterCondition, yieldCondition)"))
+    fun dfs(
+        enterCondition: (TreeNode<T>) -> Boolean = { true },
+        yieldCondition: (TreeNode<T>) -> Boolean = { true },
+    ): List<TreeNode<T>> = allChildren(enterCondition, yieldCondition)
+
+    /**
+     * Traverses the tree in depth-first order and returns all nodes that satisfy [yieldCondition].
+     * If [enterCondition] returns false for a node, its children are not traversed.
+     * By default, all nodes are traversed and all nodes are returned.
+     */
+    fun allChildren(
+        enterCondition: (TreeNode<T>) -> Boolean = { true },
+        yieldCondition: (TreeNode<T>) -> Boolean = { true },
+    ): List<TreeNode<T>> {
         val result = mutableListOf<TreeNode<T>>()
-        fun doDfs(node: TreeNode<T>) {
+
+        fun traverse(node: TreeNode<T>) {
             if (yieldCondition(node)) {
                 result.add(node)
             }
             if (enterCondition(node)) {
                 node.children.forEach {
-                    doDfs(it)
+                    traverse(it)
                 }
             }
         }
-        doDfs(this)
+        traverse(this)
         return result
     }
 }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/Utils.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/Utils.kt
index e74bc75c8..97f16582b 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/Utils.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/Utils.kt
@@ -29,9 +29,22 @@ internal fun <T> TreeNode<T>.getOrPut(path: ColumnPath, createData: (ColumnPath)
     return node
 }
 
-internal fun <T> TreeNode<T>.topDfs(yieldCondition: (TreeNode<T>) -> Boolean): List<TreeNode<T>> = dfs(enterCondition = { !yieldCondition(it) }, yieldCondition = yieldCondition)
+/**
+ * Traverses all children in the tree in depth-first order and returns the top-most nodes that satisfy
+ * [yieldCondition]. This means that if a node satisfies [yieldCondition], its children are not traversed, regardless of
+ * whether they satisfy [yieldCondition] or not.
+ */
+internal fun <T> TreeNode<T>.topmostChildren(yieldCondition: (TreeNode<T>) -> Boolean): List<TreeNode<T>> =
+    allChildren(
+        enterCondition = { !yieldCondition(it) },
+        yieldCondition = yieldCondition,
+    )
 
-internal fun <T> TreeNode<T>.topDfsExcluding(excludeRoot: TreeNode<*>): List<TreeNode<T>> {
+@Deprecated("Use topmostChildren instead", ReplaceWith("topmostChildren(yieldCondition)"))
+internal fun <T> TreeNode<T>.topDfs(yieldCondition: (TreeNode<T>) -> Boolean): List<TreeNode<T>> =
+    topmostChildren(yieldCondition)
+
+internal fun <T> TreeNode<T>.topmostChildrenExcluding(excludeRoot: TreeNode<*>): List<TreeNode<T>> {
     val result = mutableListOf<TreeNode<T>>()
     fun doDfs(node: TreeNode<T>, exclude: TreeNode<*>) {
         if (exclude.children.isNotEmpty()) {
@@ -48,23 +61,35 @@ internal fun <T> TreeNode<T>.topDfsExcluding(excludeRoot: TreeNode<*>): List<Tre
     return result
 }
 
-internal fun <T> TreeNode<T?>.dfsNotNull() = dfs { it.data != null }.map { it as TreeNode<T> }
-internal fun <T> TreeNode<T?>.dfsTopNotNull() = dfs(enterCondition = { it.data == null }, yieldCondition = { it.data != null }).map { it as TreeNode<T> }
+internal fun <T> TreeNode<T?>.allChildrenNotNull(): List<TreeNode<T>> =
+    allChildren { it.data != null } as List<TreeNode<T>>
+
+internal fun <T> TreeNode<T?>.topmostChildrenNotNull() =
+    topmostChildren { it.data != null } as List<TreeNode<T>>
 
-internal fun TreeNode<ColumnPosition>.allRemovedColumns() = dfs { it.data.wasRemoved && it.data.column != null }
-internal fun TreeNode<ColumnPosition>.allWithColumns() = dfs { it.data.column != null }
-internal fun Iterable<ColumnWithPath<*>>.dfs(): List<ColumnWithPath<*>> {
+internal fun TreeNode<ColumnPosition>.allRemovedColumns() =
+    allChildren { it.data.wasRemoved && it.data.column != null }
+
+internal fun TreeNode<ColumnPosition>.allWithColumns() =
+    allChildren { it.data.column != null }
+
+internal fun Iterable<ColumnWithPath<*>>.flattenRecursively(): List<ColumnWithPath<*>> {
     val result = mutableListOf<ColumnWithPath<*>>()
-    fun dfs(cols: Iterable<ColumnWithPath<*>>) {
+
+    fun flattenRecursively(cols: Iterable<ColumnWithPath<*>>) {
         cols.forEach {
             result.add(it)
             val path = it.path
             if (it.data.isColumnGroup()) {
-                dfs(it.data.asColumnGroup().columns().map { it.addPath(path + it.name()) })
+                flattenRecursively(
+                    it.data.asColumnGroup()
+                        .columns()
+                        .map { it.addPath(path + it.name()) }
+                )
             }
         }
     }
-    dfs(this)
+    flattenRecursively(this)
     return result
 }
 
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
index aa69386c4..229c13d0d 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/html.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/html.kt
@@ -74,8 +74,8 @@ internal fun tableJs(columns: List<ColumnDataForJs>, id: Int, rootId: Int, nrow:
     var index = 0
     val data = buildString {
         append("[")
-        fun dfs(col: ColumnDataForJs): Int {
-            val children = col.nested.map { dfs(it) }
+        fun appendColWithChildren(col: ColumnDataForJs): Int {
+            val children = col.nested.map { appendColWithChildren(it) }
             val colIndex = index++
             val values = col.values.joinToString(",", prefix = "[", postfix = "]") {
                 when (it) {
@@ -100,7 +100,7 @@ internal fun tableJs(columns: List<ColumnDataForJs>, id: Int, rootId: Int, nrow:
 
             return colIndex
         }
-        columns.forEach { dfs(it) }
+        columns.forEach { appendColWithChildren(it) }
         append("]")
     }
     val js = getResourceText(
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
index dd5d16685..d14a0a5ef 100644
--- a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
+++ b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
@@ -3,181 +3,159 @@ package org.jetbrains.kotlinx.dataframe.api
 import io.kotest.matchers.shouldBe
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
-import org.jetbrains.kotlinx.dataframe.impl.columns.asValueColumn
-import org.jetbrains.kotlinx.dataframe.samples.api.TestBase
-import org.jetbrains.kotlinx.dataframe.samples.api.age
-import org.jetbrains.kotlinx.dataframe.samples.api.firstName
-import org.jetbrains.kotlinx.dataframe.samples.api.isHappy
-import org.jetbrains.kotlinx.dataframe.samples.api.lastName
-import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.jetbrains.kotlinx.dataframe.samples.api.*
 import org.junit.Test
+import kotlin.reflect.typeOf
 
-class ColumnsSelectionDslTests : TestBase() {
+open class ColumnsSelectionDslTests : TestBase() {
 
     @Test
     fun first() {
-        df.select { all().first() } shouldBe df.select { first() }
-        df.select { all().first() } shouldBe df.select { name }
-        df.select { first() } shouldBe df.select { name }
-        df.select { first { it.name().startsWith("a") } } shouldBe df.select { age }
-
-        df.select {
-            name.first { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select {
-            name.colsOf<String>().first { col ->
-                col.any { it == "Alice" }
-            }
-        }
+        listOf(
+            df.select { name },
+            df.select { first() },
+            df.select { all().first() },
+            df.select { first { it.name().startsWith("n") } },
+        ).shouldAllBeEqual()
 
-        df.select {
-            "name".first { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select { name.firstName }
+        listOf(
+            df.select { name.firstName },
 
-        df.select {
-            Person::name.first { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select { name.firstName }
+            df.select { name.first { col -> col.any { it == "Alice" } } },
+            df.select { name.colsOf<String>().first { col -> col.any { it == "Alice" } } },
 
-        df.select {
-            pathOf("name").first { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select { name.firstName }
+            df.select { "name".first { col -> col.any { it == "Alice" } } },
+            df.select { "name".colsOf<String>(typeOf<String>()).first { col -> col.any { it == "Alice" } } },
+
+            df.select { Person::name.first { col -> col.any { it == "Alice" } } },
+            df.select { Person::name.colsOf<String>(typeOf<String>()).first { col -> col.any { it == "Alice" } } },
+
+            df.select { pathOf("name").first { col -> col.any { it == "Alice" } } },
+            df.select { pathOf("name").colsOf<String>(typeOf<String>()).first { col -> col.any { it == "Alice" } } },
+
+            df.select { it["name"].first { col -> col.any { it == "Alice" } } },
+            df.select { it["name"].colsOf<String>(typeOf<String>()).first { col -> col.any { it == "Alice" } } },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun last() {
-        df.select { all().last() } shouldBe df.select { last() }
-        df.select { all().last() } shouldBe df.select { isHappy }
-        df.select { last() } shouldBe df.select { isHappy }
-        df.select { last { it.name().startsWith("a") } } shouldBe df.select { age }
-        df.select {
-            name.last { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select {
-            name.colsOf<String>().last { col ->
-                col.any { it == "Alice" }
-            }
-        }
+        listOf(
+            df.select { isHappy },
+            df.select { last() },
+            df.select { all().last() },
+            df.select { last { it.name().startsWith("is") } },
+        ).shouldAllBeEqual()
 
-        df.select {
-            "name".last { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select { name.firstName }
+        listOf(
+            df.select { name.firstName },
 
-        df.select {
-            Person::name.last { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select { name.firstName }
+            df.select { name.last { col -> col.any { it == "Alice" } } },
+            df.select { name.colsOf<String>().last { col -> col.any { it == "Alice" } } },
 
-        df.select {
-            pathOf("name").last { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select { name.firstName }
+            df.select { "name".last { col -> col.any { it == "Alice" } } },
+            df.select { "name".colsOf<String>(typeOf<String>()).last { col -> col.any { it == "Alice" } } },
+
+            df.select { Person::name.last { col -> col.any { it == "Alice" } } },
+            df.select { Person::name.colsOf<String>(typeOf<String>()).last { col -> col.any { it == "Alice" } } },
+
+            df.select { pathOf("name").last { col -> col.any { it == "Alice" } } },
+            df.select { pathOf("name").colsOf<String>(typeOf<String>()).last { col -> col.any { it == "Alice" } } },
+
+            df.select { it["name"].last { col -> col.any { it == "Alice" } } },
+            df.select { it["name"].colsOf<String>(typeOf<String>()).last { col -> col.any { it == "Alice" } } },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun single() {
         val singleDf = df.select { take(1) }
-        singleDf.select { all().single() } shouldBe singleDf.select { single() }
-        singleDf.select { all().single() } shouldBe singleDf.select { name }
-        singleDf.select { single() } shouldBe singleDf.select { name }
-        df.select { single { it.name().startsWith("a") } } shouldBe df.select { age }
-
-        df.select {
-            name.single { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select {
-            name.colsOf<String>().single { col ->
-                col.any { it == "Alice" }
-            }
-        }
 
-        df.select {
-            "name".single { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select { name.firstName }
+        listOf(
+            df.select { name },
+            singleDf.select { name },
+            singleDf.select { single() },
+            singleDf.select { all().single() },
+            df.select { single { it.name().startsWith("n") } },
+        ).shouldAllBeEqual()
 
-        df.select {
-            Person::name.single { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select { name.firstName }
+        listOf(
+            df.select { name.firstName },
 
-        df.select {
-            pathOf("name").single { col ->
-                col.any { it == "Alice" }
-            }
-        } shouldBe df.select { name.firstName }
+            df.select { name.single { col -> col.any { it == "Alice" } } },
+            df.select { name.colsOf<String>().single { col -> col.any { it == "Alice" } } },
+
+            df.select { "name".single { col -> col.any { it == "Alice" } } },
+            df.select { "name".colsOf<String>(typeOf<String>()).single { col -> col.any { it == "Alice" } } },
+
+            df.select { Person::name.single { col -> col.any { it == "Alice" } } },
+            df.select { Person::name.colsOf<String>(typeOf<String>()).single { col -> col.any { it == "Alice" } } },
+
+            df.select { pathOf("name").single { col -> col.any { it == "Alice" } } },
+            df.select { pathOf("name").colsOf<String>(typeOf<String>()).single { col -> col.any { it == "Alice" } } },
+
+            df.select { it["name"].single { col -> col.any { it == "Alice" } } },
+            df.select { it["name"].colsOf<String>(typeOf<String>()).single { col -> col.any { it == "Alice" } } },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun col() {
-        df.select { col("age") } shouldBe df.select { age }
-        df.select { col<Int>("age") } shouldBe df.select { age }
-        df.select { col(pathOf("age")) } shouldBe df.select { age }
-        df.select { col<Int>(pathOf("age")) } shouldBe df.select { age }
-        df.select { col(Person::age) } shouldBe df.select { age }
-
-        df.select { colGroup("name").col("firstName") } shouldBe df.select { name.firstName }
-        df.select { colGroup("name").col<String>("firstName") } shouldBe df.select { name.firstName }
-        df.select { colGroup("name").col(pathOf("firstName")) } shouldBe df.select { name.firstName }
-        df.select { colGroup("name").col<String>(pathOf("firstName")) } shouldBe df.select { name.firstName }
-        df.select { colGroup("name").col(Name::firstName) } shouldBe df.select { name.firstName }
-    }
+        listOf(
+            df.select { age },
 
-    @DataSchema
-    interface FirstNames {
-        val firstName: String
-        val secondName: String?
-        val thirdName: String?
-    }
+            df.select { col("age") },
+            df.select { col<Int>("age") },
 
-    @DataSchema
-    interface MyName : Name {
-        val firstNames: FirstNames
+            df.select { col(pathOf("age")) },
+            df.select { col<Int>(pathOf("age")) },
+
+            df.select { col(Person::age) },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.firstName },
+
+            df.select { colGroup("name").col("firstName") },
+            df.select { colGroup("name").col<String>("firstName") },
+
+            df.select { colGroup("name").col(pathOf("firstName")) },
+            df.select { colGroup("name").col<String>(pathOf("firstName")) },
+
+            df.select { colGroup("name").col(Name::firstName) },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun colGroup() {
-        val firstNames by columnGroup<FirstNames>()
-        val dfGroup = df.convert { name.firstName }.to {
-            val firstName by it
-            val secondName by it.map<_, String?> { null }.asValueColumn()
-            val thirdName by it.map<_, String?> { null }.asValueColumn()
-
-            dataFrameOf(firstName, secondName, thirdName)
-                .cast<FirstNames>(verify = true)
-                .asColumnGroup(firstNames)
-        }
+        listOf(
+            dfGroup.select { name },
+
+            dfGroup.select { colGroup("name") },
+            dfGroup.select { colGroup<Name>("name") },
+
+            dfGroup.select { colGroup(pathOf("name")) },
+            dfGroup.select { colGroup<Name>(pathOf("name")) },
+
+            dfGroup.select { colGroup(Person::name) },
+        ).shouldAllBeEqual()
 
-        dfGroup.select { colGroup("name") } shouldBe dfGroup.select { name }
-        dfGroup.select { colGroup<Name>("name") } shouldBe dfGroup.select { name }
-        dfGroup.select { colGroup(pathOf("name")) } shouldBe dfGroup.select { name }
-        dfGroup.select { colGroup<Name>(pathOf("name")) } shouldBe dfGroup.select { name }
-        dfGroup.select { colGroup(Person::name) } shouldBe dfGroup.select { name }
+        listOf(
+            dfGroup.select { name.firstName },
+
+            dfGroup.select { colGroup("name").colGroup("firstName") },
+            dfGroup.select { colGroup("name").colGroup<FirstNames>("firstName") },
+
+            dfGroup.select { colGroup("name").colGroup(pathOf("firstName")) },
+            dfGroup.select { colGroup("name").colGroup<FirstNames>(pathOf("firstName")) },
 
-        dfGroup.select { colGroup("name").colGroup("firstNames") } shouldBe dfGroup.select { name[firstNames] }
-        dfGroup.select { colGroup("name").colGroup<String>("firstNames") } shouldBe dfGroup.select { name[firstNames] }
-        dfGroup.select { colGroup("name").colGroup(pathOf("firstNames")) } shouldBe dfGroup.select { name[firstNames] }
-        dfGroup.select { colGroup("name").colGroup<String>(pathOf("firstNames")) } shouldBe dfGroup.select { name[firstNames] }
-        dfGroup.select { colGroup("name").colGroup(MyName::firstNames) } shouldBe dfGroup.select { name[firstNames] }
+            dfGroup.select { colGroup("name").colGroup(Name2::firstName) },
+        ).shouldAllBeEqual()
 
         dfGroup.select {
-            "name"["firstNames"]["firstName", "secondName"]
+            "name"["firstName"]["firstName", "secondName"]
         } shouldBe dfGroup.select {
-            name[firstNames]["firstName"] and name[firstNames]["secondName"]
+            name.firstName["firstName"] and name.firstName["secondName"]
         }
     }
 
@@ -204,321 +182,322 @@ class ColumnsSelectionDslTests : TestBase() {
                 dataFrameOf(firstName, lastName, frameCol).asColumnGroup("name")
             }
 
-        dfWithFrames.select { frameCol("frameCol") } shouldBe dfWithFrames.select { frameCol }
-        dfWithFrames.select { frameCol<Person>("frameCol") } shouldBe dfWithFrames.select { frameCol }
-        dfWithFrames.select { frameCol(pathOf("frameCol")) } shouldBe dfWithFrames.select { frameCol }
-        dfWithFrames.select { frameCol<Person>(pathOf("frameCol")) } shouldBe dfWithFrames.select { frameCol }
-        dfWithFrames.select { frameCol(PersonWithFrame::frameCol) } shouldBe dfWithFrames.select { frameCol }
-
-        dfWithFrames.select { colGroup("name").frameCol("frameCol") } shouldBe dfWithFrames.select { name[frameCol] }
-        dfWithFrames.select { colGroup("name").frameCol<Person>("frameCol") } shouldBe dfWithFrames.select { name[frameCol] }
-        dfWithFrames.select { colGroup("name").frameCol(pathOf("frameCol")) } shouldBe dfWithFrames.select { name[frameCol] }
-        dfWithFrames.select { colGroup("name").frameCol<Person>(pathOf("frameCol")) } shouldBe dfWithFrames.select { name[frameCol] }
-        dfWithFrames.select { colGroup("name").frameCol(PersonWithFrame::frameCol) } shouldBe dfWithFrames.select { name[frameCol] }
+        listOf(
+            dfWithFrames.select { frameCol },
+
+            dfWithFrames.select { frameCol("frameCol") },
+            dfWithFrames.select { frameCol<Person>("frameCol") },
+
+            dfWithFrames.select { frameCol(pathOf("frameCol")) },
+            dfWithFrames.select { frameCol<Person>(pathOf("frameCol")) },
+
+            dfWithFrames.select { frameCol(PersonWithFrame::frameCol) },
+        ).shouldAllBeEqual()
+
+        listOf(
+            dfWithFrames.select { name[frameCol] },
+
+            dfWithFrames.select { colGroup("name").frameCol("frameCol") },
+            dfWithFrames.select { colGroup("name").frameCol<Person>("frameCol") },
+
+            dfWithFrames.select { colGroup("name").frameCol(pathOf("frameCol")) },
+            dfWithFrames.select { colGroup("name").frameCol<Person>(pathOf("frameCol")) },
+
+            dfWithFrames.select { colGroup("name").frameCol(PersonWithFrame::frameCol) },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun `cols and get with predicate`() {
-        df.select { all().cols() } shouldBe df.select { cols() }
-        df.select { all().cols { "e" in it.name() } } shouldBe df.select {
-            cols { "e" in it.name() }
-        }
-        df.select { all()[{ "e" in it.name() }] } shouldBe df.select {
-//            this[{ "e" in it.name() }]
-            cols { "e" in it.name() }
-        }
+        listOf(
+            df.select { cols(name, age, city, weight, isHappy) },
+            df.select { all().cols() },
+            df.select { cols() },
+            df.select { all() },
+        ).shouldAllBeEqual()
 
-        df.select {
-            name.cols {
-                "Name" in it.name()
-            }
-        } shouldBe df.select {
-            name.colsOf<String>().cols {
-                "Name" in it.name()
-            }
-        }
+        listOf(
+            df.select { name },
+            df.select { name }.select { all() },
+            df.select { name }.select { cols() },
+            df.select { name }.select { cols().all() },
+            df.select { name }.select { all().cols() },
+        ).shouldAllBeEqual()
 
-        df.select {
-//            name[{ "Name" in it.name() }]
-            name.cols { "Name" in it.name() }
-        } shouldBe df.select {
-            name.colsOf<String>()[{ "Name" in it.name() }]
-        }
+        listOf(
+            df.select { cols(name, age, weight) },
 
-        df.select {
-            "name".cols { "Name" in it.name() }
-        } shouldBe df.select {
-            Person::name.cols { "Name" in it.name() }
-        }
+            df.select { cols { "e" in it.name() } },
+//            df.select { this[{ "e" in it.name() }] },
 
-        df.select {
-            "name"[{ "Name" in it.name() }]
-        } shouldBe df.select {
-            Person::name[{ "Name" in it.name() }]
-        }
+            df.select { all().cols { "e" in it.name() } },
+            df.select { all()[{ "e" in it.name() }] },
+        ).shouldAllBeEqual()
 
-        df.select {
-            pathOf("name").cols { "Name" in it.name() }
-        } shouldBe df.select {
-            "name"[{ "Name" in it.name() }]
-        }
+        listOf(
+            df.select { name.firstName and name.lastName },
 
-        df.select {
-            pathOf("name").cols { "Name" in it.name() }
-        } shouldBe df.select {
-            pathOf("name")[{ "Name" in it.name() }]
-        }
+            df.select { name.cols { "Name" in it.name() } },
+//            df.select { name[{ "Name" in it.name() }] },
+
+            df.select { name.colsOf<String>().cols { "Name" in it.name() } },
+            df.select { name.colsOf<String>()[{ "Name" in it.name() }] },
+
+            df.select { "name".cols { "Name" in it.name() } },
+            df.select { "name"[{ "Name" in it.name() }] },
+
+            df.select { Person::name.cols { "Name" in it.name() } },
+            df.select { Person::name[{ "Name" in it.name() }] },
+
+            df.select { pathOf("name").cols { "Name" in it.name() } },
+            df.select { pathOf("name")[{ "Name" in it.name() }] },
+
+            df.select { it["name"].cols { "Name" in it.name() } },
+            df.select { it["name"][{ "Name" in it.name() }] },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun `cols and get with column references`() {
-        df.select { all().cols(name, age) } shouldBe df.select { cols(name, age) }
-        df.select { all()[name, age] } shouldBe df.select { this[name, age] }
+        listOf(
+            df.select { name and age },
+
+            df.select { cols(name, age) },
+            df.select { this[name, age] },
+            df.select { it[name, age] },
+
+            df.select { all().cols(name, age) },
+            df.select { all()[name, age] },
+        ).shouldAllBeEqual()
 
         val firstName by column<String>()
         val lastName by column<String>()
-        df.select {
-            name.cols(firstName, lastName)
-        } shouldBe df.select {
-            name.colsOf<String>().cols(firstName, lastName)
-        }
 
-        df.select {
-            name.cols(name.firstName, name.lastName)
-        } shouldBe df.select {
-            name.colsOf<String>().cols(name.firstName, name.lastName)
-        }.also { it.print() }
-
-        df.select {
-//            name[name.firstName, name.lastName]
-            name.cols(name.firstName, name.lastName)
-        } shouldBe df.select {
-            name.colsOf<String>()[name.firstName, name.lastName]
-        }
+        listOf(
+            df.select { name.firstName and name.lastName },
 
-        df.select {
-            "name".cols(name.firstName, name.lastName)
-        } shouldBe df.select {
-            Person::name.cols(name.firstName, name.lastName)
-        }
+            df.select { name.cols(firstName, lastName) },
+//            df.select { name[name.firstName, name.lastName] },
 
-        df.select {
-            "name"[name.firstName, name.lastName]
-        } shouldBe df.select {
-            Person::name[name.firstName, name.lastName]
-        }
+            df.select { name.colsOf<String>().cols(firstName, lastName) },
+            df.select { name.colsOf<String>()[firstName, lastName] },
 
-        df.select {
-            pathOf("name").cols(name.firstName, name.lastName)
-        } shouldBe df.select {
-            pathOf("name")[name.firstName, name.lastName]
-        }
+            df.select { name.select { cols(this@select.firstName, this@select.lastName) } },
+
+            df.select { "name".cols(firstName, lastName) },
+            df.select { "name"[firstName, lastName] },
+
+            df.select { Person::name.cols(firstName, lastName) },
+            df.select { Person::name[firstName, lastName] },
+
+            df.select { pathOf("name").cols(firstName, lastName) },
+            df.select { pathOf("name")[firstName, lastName] },
+
+            df.select { it["name"].cols(firstName, lastName) },
+            df.select { it["name"][firstName, lastName] },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun `cols and get with column names`() {
-        df.select { all().cols("name", "age") } shouldBe df.select { cols("name", "age") }
-        df.select { all()["name", "age"] } shouldBe df.select { this["name", "age"] }
+        listOf(
+            df.select { name and age },
 
-        df.select {
-            name.cols("firstName", "lastName")
-        } shouldBe df.select {
-            name.colsOf<String>().cols("firstName", "lastName")
-        }
+            df.select { cols("name", "age") },
+            df.select { this["name", "age"] },
+            df.select { it["name", "age"] },
 
-        df.select {
-//            name["firstName", "lastName"]
-            name.cols("firstName", "lastName")
-        } shouldBe df.select {
-            name.colsOf<String>()["firstName", "lastName"]
-        }
+            df.select { all().cols("name", "age") },
+            df.select { all()["name", "age"] },
+        ).shouldAllBeEqual()
 
-        df.select {
-            "name".cols("firstName", "lastName")
-        } shouldBe df.select {
-            Person::name.cols("firstName", "lastName")
-        }
+        listOf(
+            df.select { name.firstName and name.lastName },
 
-        df.select {
-            "name"["firstName", "lastName"]
-        } shouldBe df.select {
-            Person::name["firstName", "lastName"]
-        }
+            df.select { name.cols("firstName", "lastName") },
+//            df.select { name["firstName", "lastName"] },
 
-        df.select {
-            pathOf("name").cols("firstName", "lastName")
-        } shouldBe df.select {
-            pathOf("name")["firstName", "lastName"]
-        }
+            df.select { name.colsOf<String>().cols("firstName", "lastName") },
+            df.select { name.colsOf<String>()["firstName", "lastName"] },
+
+            df.select { "name".cols("firstName", "lastName") },
+            df.select { "name"["firstName", "lastName"] },
+            df.select { "name"["firstName"] and "name"["lastName"] },
+
+            df.select { Person::name.cols("firstName", "lastName") },
+            df.select { Person::name["firstName", "lastName"] },
+
+            df.select { pathOf("name").cols("firstName", "lastName") },
+            df.select { pathOf("name")["firstName", "lastName"] },
+
+            df.select { it["name"].cols("firstName", "lastName") },
+            df.select { it["name"]["firstName", "lastName"] },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun `cols and get with column paths`() {
         listOf(
-            df.select {
-                all().cols(pathOf("name", "firstName"))
-            },
-            df.select {
-                cols(pathOf("name", "firstName"))
-            },
-            df.select {
-                pathOf("name", "firstName")
-            },
-            df.select {
-                name.firstName
-            },
-        ).reduce { acc, dataFrame ->
-            acc shouldBe dataFrame
-            dataFrame
-        }
+            df.select { name.firstName },
 
-        df.select { all().cols(pathOf("name"), pathOf("age")) } shouldBe df.select {
-            cols(
-                pathOf("name"),
-                pathOf("age")
-            )
-        }
-        df.select { all()[pathOf("name"), pathOf("age")] } shouldBe df.select { this[pathOf("name"), pathOf("age")] }
+            df.select { cols(pathOf("name", "firstName")) },
+            df.select { this[pathOf("name", "firstName")] },
+            df.select { it[pathOf("name", "firstName")] },
 
-        df.select {
-            name.cols(pathOf("firstName"), pathOf("lastName"))
-        } shouldBe df.select {
-            name.colsOf<String>().cols(pathOf("firstName"), pathOf("lastName"))
-        }
+            df.select { all().cols(pathOf("name", "firstName")) },
+            df.select { all()[pathOf("name", "firstName")] },
 
-        df.select {
-//            name[pathOf("firstName"), pathOf("lastName")]
-            name.cols(pathOf("firstName"), pathOf("lastName"))
-        } shouldBe df.select {
-            name.colsOf<String>()[pathOf("firstName"), pathOf("lastName")]
-        }
+            df.select { pathOf("name", "firstName") },
+        ).shouldAllBeEqual()
 
-        df.select {
-            "name".cols(pathOf("firstName"), pathOf("lastName"))
-        } shouldBe df.select {
-            Person::name.cols(pathOf("firstName"), pathOf("lastName"))
-        }
+        listOf(
+            df.select { name and age },
 
-        df.select {
-            "name"[pathOf("firstName"), pathOf("lastName")]
-        } shouldBe df.select {
-            Person::name[pathOf("firstName"), pathOf("lastName")]
-        }
+            df.select { cols(pathOf("name"), pathOf("age")) },
+            df.select { this[pathOf("name"), pathOf("age")] },
+            df.select { it[pathOf("name"), pathOf("age")] },
 
-        df.select {
-            pathOf("name").cols(pathOf("firstName"), pathOf("lastName"))
-        } shouldBe df.select {
-            pathOf("name")[pathOf("firstName"), pathOf("lastName")]
-        }
+            df.select { all().cols(pathOf("name"), pathOf("age")) },
+            df.select { all()[pathOf("name"), pathOf("age")] },
+        ).shouldAllBeEqual()
+
+        listOf(
+            df.select { name.firstName and name.lastName },
+
+            df.select { name.cols(pathOf("firstName"), pathOf("lastName")) },
+//            df.select { name[pathOf("firstName"), pathOf("lastName")] },
+
+            df.select { name.colsOf<String>().cols(pathOf("firstName"), pathOf("lastName")) },
+            df.select { name.colsOf<String>()[pathOf("firstName"), pathOf("lastName")] },
+
+            df.select { "name".cols(pathOf("firstName"), pathOf("lastName")) },
+            df.select { "name"[pathOf("firstName"), pathOf("lastName")] },
+
+            df.select { Person::name.cols(pathOf("firstName"), pathOf("lastName")) },
+            df.select { Person::name[pathOf("firstName"), pathOf("lastName")] },
+
+            df.select { pathOf("name").cols(pathOf("firstName"), pathOf("lastName")) },
+            df.select { pathOf("name")[pathOf("firstName"), pathOf("lastName")] },
+
+            df.select { it["name"].cols(pathOf("firstName"), pathOf("lastName")) },
+            df.select { it["name"][pathOf("firstName"), pathOf("lastName")] },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun `cols and get with KProperties`() {
-        df.select { all().cols(Person::name, Person::age) } shouldBe df.select { cols(Person::name, Person::age) }
-        df.select { all()[Person::name, Person::age] } shouldBe df.select { this[Person::name, Person::age] }
+        listOf(
+            df.select { name and age },
 
-        df.select {
-            name.cols(Name::firstName, Name::lastName)
-        } shouldBe df.select {
-            name.colsOf<String>().cols(Name::firstName, Name::lastName)
-        }
+            df.select { cols(Person::name, Person::age) },
+            df.select { this[Person::name, Person::age] },
+            df.select { it[Person::name, Person::age] },
 
-        df.select {
-            name[Name::firstName, Name::lastName]
-        } shouldBe df.select {
-            name.colsOf<String>()[Name::firstName, Name::lastName]
-        }
+            df.select { all().cols(Person::name, Person::age) },
+            df.select { all()[Person::name, Person::age] },
+        ).shouldAllBeEqual()
 
-        df.select {
-            "name".cols(Name::firstName, Name::lastName)
-        } shouldBe df.select {
-            Person::name.cols(Name::firstName, Name::lastName)
-        }
+        listOf(
+            df.select { name.firstName and name.lastName },
 
-        df.select {
-            "name"[Name::firstName, Name::lastName]
-        } shouldBe df.select {
-            Person::name[Name::firstName, Name::lastName]
-        }
+            df.select { name.cols(Name::firstName, Name::lastName) },
+            df.select { name[Name::firstName, Name::lastName] },
 
-        df.select {
-            pathOf("name").cols(Name::firstName, Name::lastName)
-        } shouldBe df.select {
-            pathOf("name")[Name::firstName, Name::lastName]
-        }
+            df.select { name.colsOf<String>().cols(Name::firstName, Name::lastName) },
+            df.select { name.colsOf<String>()[Name::firstName, Name::lastName] },
+
+            df.select { "name".cols(Name::firstName, Name::lastName) },
+            df.select { "name"[Name::firstName, Name::lastName] },
+
+            df.select { Person::name.cols(Name::firstName, Name::lastName) },
+            df.select { Person::name[Name::firstName, Name::lastName] },
+
+            df.select { pathOf("name").cols(Name::firstName, Name::lastName) },
+            df.select { pathOf("name")[Name::firstName, Name::lastName] },
+
+            df.select { it["name"].cols(Name::firstName, Name::lastName) },
+            df.select { it["name"][Name::firstName, Name::lastName] },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun `cols and get with indices`() {
-        df.select { all().cols(0, 1) } shouldBe df.select { cols(0, 1) }
-        df.select { all()[0, 1] } shouldBe df.select { this[0, 1] }
+        listOf(
+            df.select { name and age },
 
-        df.select {
-            name.cols(0, 1)
-        } shouldBe df.select {
-            name.colsOf<String>().cols(0, 1)
-        }
+            df.select { cols(0, 1) },
+            df.select { this[0, 1] },
+            df.select { it[0, 1] },
 
-        df.select {
-//            name[0, 1]
-            name.cols(0, 1)
-        } shouldBe df.select {
-            name.colsOf<String>()[0, 1]
-        }
+            df.select { all().cols(0, 1) },
+            df.select { all()[0, 1] },
+        ).shouldAllBeEqual()
 
-        df.select {
-            "name".cols(0, 1)
-        } shouldBe df.select {
-            Person::name.cols(0, 1)
-        }
+        listOf(
+            df.select { name.firstName and name.lastName },
 
-        df.select {
-            "name"[0, 1]
-        } shouldBe df.select {
-            Person::name[0, 1]
-        }
+            df.select { name.cols(0, 1) },
+//            df.select { name[0, 1] },
 
-        df.select {
-            pathOf("name").cols(0, 1)
-        } shouldBe df.select {
-            pathOf("name")[0, 1]
-        }
+            df.select { name.colsOf<String>().cols(0, 1) },
+            df.select { name.colsOf<String>()[0, 1] },
+
+            df.select { "name".cols(0, 1) },
+            df.select { "name"[0, 1] },
+
+            df.select { Person::name.cols(0, 1) },
+            df.select { Person::name[0, 1] },
+
+            df.select { pathOf("name").cols(0, 1) },
+            df.select { pathOf("name")[0, 1] },
+
+            df.select { it["name"].cols(0, 1) },
+//            df.select { it["name"][0, 1] },
+        ).shouldAllBeEqual()
     }
 
     @Test
     fun `cols and get with range`() {
-        df.select { all().cols(0..1) } shouldBe df.select { cols(0..1) }
-        df.select { all()[0..1] } shouldBe df.select { this[0..1] }
+        listOf(
+            df.select { name and age },
 
-        df.select {
-            name.cols(0..1)
-        } shouldBe df.select {
-            name.colsOf<String>().cols(0..1)
-        }
+            df.select { cols(0..1) },
+            df.select { this[0..1] },
+            df.select { it[0..1] },
 
-        df.select {
-//            name[0..1]
-            name.cols(0..1)
-        } shouldBe df.select {
-            name.colsOf<String>()[0..1]
-        }
+            df.select { all().cols(0..1) },
+            df.select { all()[0..1] },
+        ).shouldAllBeEqual()
 
-        df.select {
-            "name".cols(0..1)
-        } shouldBe df.select {
-            Person::name.cols(0..1)
-        }
+        listOf(
+            df.select { name.firstName and name.lastName },
 
-        df.select {
-            "name"[0..1]
-        } shouldBe df.select {
-            Person::name[0..1]
-        }
+            df.select { name.cols(0..1) },
+//            df.select { name[0..1] },
 
-        df.select {
-            pathOf("name").cols(0..1)
-        } shouldBe df.select {
-            pathOf("name")[0..1]
-        }
+            df.select { name.colsOf<String>().cols(0..1) },
+            df.select { name.colsOf<String>()[0..1] },
+
+            df.select { "name".cols(0..1) },
+            df.select { "name"[0..1] },
+
+            df.select { Person::name.cols(0..1) },
+            df.select { Person::name[0..1] },
+
+            df.select { pathOf("name").cols(0..1) },
+            df.select { pathOf("name")[0..1] },
+
+            df.select { it["name"].cols(0..1) },
+//            df.select { it["name"][0..1] },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun roots() {
+        df.select { cols(name.firstName, name.lastName, age).roots() } shouldBe
+            df.select { cols(name.firstName, name.lastName, age) }
+
+        df.select { cols(name.firstName, name.lastName, age, name).roots() } shouldBe
+            df.select { cols(name, age) }
     }
 }
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
index f585e6b22..5c7357b1c 100644
--- a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
+++ b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
@@ -27,14 +27,18 @@ class MoveTests {
     }
 
     @Test
-    fun `select all dfs`() {
-        val selected = grouped.getColumnsWithPaths { all().allDfs() }.map { it.path.joinToString(".") }
+    fun `select all allRecursively`() {
+        val selected = grouped
+            .getColumnsWithPaths { children { !it.isColumnGroup() }.recursively() }
+            .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 { dfs { it.depth() > 0 && !it.isColumnGroup() } }.into { pathOf(it.path.joinToString(".")) }
+        val ungrouped = grouped.move {
+            cols { it.depth() > 0 && !it.isColumnGroup() }.rec()
+        }.into { pathOf(it.path.joinToString(".")) }
         ungrouped.columnNames() shouldBe listOf("q", "a.b", "a.c.d", "b.c", "b.d", "w", "e.f", "r")
     }
 
@@ -64,15 +68,19 @@ class MoveTests {
     }
 
     @Test
-    fun `select Dfs`() {
-        val selected = grouped.select { it["a"].dfs { !it.isColumnGroup() } }
+    fun `select recursively`() {
+        val selected = grouped.select {
+            it["a"].cols { !it.isColumnGroup() }.recursively()
+        }
         selected.columnNames() shouldBe listOf("b", "d")
     }
 
     @Test
     fun `columnsWithPath in selector`() {
         val selected = grouped.getColumnsWithPaths { it["a"] }
-        val actual = grouped.getColumnsWithPaths { selected.map { it.allDfs() }.toColumnSet() }
+        val actual = grouped.getColumnsWithPaths {
+            selected.map { it.cols { !it.isColumnGroup() }.recursively() }.toColumnSet()
+        }
         actual.map { it.path.joinToString(".") } shouldBe listOf("a.b", "a.c.d")
     }
 
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
index 727165729..36cc299a4 100644
--- a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
+++ b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
@@ -41,7 +41,7 @@ class PivotTests {
         }
         pivoted.columnsCount() shouldBe 3
         pivoted.rowsCount() shouldBe 2
-        val cols = pivoted.getColumns { except(a).allDfs() }
+        val cols = pivoted.getColumns { except(a).cols { !it.isColumnGroup() }.rec() }
         cols.size shouldBe 4
         cols.forEach {
             it.type() shouldBe typeOf<Char>()
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/recursively.kt b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/recursively.kt
new file mode 100644
index 000000000..38e89fce0
--- /dev/null
+++ b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/recursively.kt
@@ -0,0 +1,108 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.shouldNotBe
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.samples.api.TestBase
+import org.jetbrains.kotlinx.dataframe.samples.api.city
+import org.jetbrains.kotlinx.dataframe.samples.api.firstName
+import org.jetbrains.kotlinx.dataframe.samples.api.name
+import org.junit.Test
+
+class Recursively : TestBase() {
+
+    fun List<ColumnWithPath<*>>.print() {
+        forEach {
+            if (it.isValueColumn()) println("${it.name}: ${it.type()}")
+            else it.print()
+        }
+        println()
+    }
+
+    infix fun List<ColumnWithPath<*>>.shouldBe(other: List<ColumnWithPath<*>>) {
+        this.map { it.name to it.path } shouldBe other.map { it.name to it.path }
+    }
+
+    infix fun List<ColumnWithPath<*>>.shouldNotBe(other: List<ColumnWithPath<*>>) {
+        this.map { it.name to it.path } shouldNotBe other.map { it.name to it.path }
+    }
+
+    private val recursivelyGoal = dfGroup.getColumnsWithPaths { dfs { true } }
+        .sortedBy { it.name }
+
+    private val recursivelyNoGroups = dfGroup.getColumnsWithPaths { allDfs(false) }
+        .sortedBy { it.name }
+
+    private val recursivelyString = dfGroup.getColumnsWithPaths { dfsOf<String?>() }
+        .sortedBy { it.name }
+
+    @Test
+    fun `first, last, and single`() {
+        listOf(
+            dfGroup.select { name.firstName.firstName },
+
+            dfGroup.select { first { col -> col.any { it == "Alice" } }.recursively() },
+            dfGroup.select { last { col -> col.any { it == "Alice" } }.recursively() },
+            dfGroup.select { single { col -> col.any { it == "Alice" } }.recursively() },
+        ).shouldAllBeEqual()
+
+        listOf(
+            dfGroup.select { city },
+
+            dfGroup.select { first { col -> col.any { it == "London" } }.recursively() },
+            dfGroup.select { last { col -> col.any { it == "London" } }.recursively() },
+            dfGroup.select { single { col -> col.any { it == "London" } }.recursively() },
+        ).shouldAllBeEqual()
+    }
+
+    @Test
+    fun `children`() {
+        dfGroup.getColumnsWithPaths { children().recursively() }.print()
+        dfGroup.getColumnsWithPaths { name.children() }.print()
+    }
+
+    @Test
+    fun `groups`() {
+        listOf(
+            df.select { name },
+            df.select { groups().recursively() },
+            df.select { groups() },
+            df.select { all().groups() },
+            df.select { all().groups().rec() },
+        ).shouldAllBeEqual()
+
+        dfGroup.select { groups() } shouldBe dfGroup.select { name }
+        dfGroup.select { groups().rec() } shouldBe dfGroup.select { name and name.firstName }
+    }
+
+    @Test
+    fun `all recursively`() {
+        dfGroup.getColumnsWithPaths { all().recursively() }.sortedBy { it.name } shouldBe recursivelyGoal
+        dfGroup.getColumnsWithPaths { all().cols { !it.isColumnGroup() }.rec() }
+            .sortedBy { it.name } shouldBe recursivelyNoGroups
+    }
+
+    @Test
+    fun `cols recursively`() {
+        dfGroup.getColumnsWithPaths { cols().recursively() }.sortedBy { it.name } shouldBe recursivelyGoal
+    }
+
+    @Test
+    fun `colsOf recursively`() {
+        dfGroup.getColumnsWithPaths { colsOf<String?>().recursively() }.sortedBy { it.name } shouldBe recursivelyString
+    }
+
+    @Test
+    fun `all allRecursively`() {
+        dfGroup.getColumnsWithPaths { all().all().recursively() }.sortedBy { it.name } shouldBe recursivelyGoal
+        dfGroup.getColumnsWithPaths { all().cols { !it.isColumnGroup() }.recursively() }
+            .sortedBy { it.name } shouldBe recursivelyNoGroups
+    }
+
+    @Test
+    fun `cols allRecursively`() {
+        dfGroup.getColumnsWithPaths { cols().all().recursively() }.sortedBy { it.name } shouldBe recursivelyGoal
+        dfGroup.getColumnsWithPaths { cols().cols { !it.isColumnGroup() }.recursively() }
+            .sortedBy { it.name } shouldBe recursivelyNoGroups
+    }
+}
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
index 87e28271c..94e64ed3c 100644
--- a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
+++ b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
@@ -24,7 +24,7 @@ class ReorderTests {
         sorted1.columnNames() shouldBe listOf("b", "a")
         sorted1["a"].asColumnGroup().columnNames() shouldBe listOf("a", "c")
 
-        val sorted2 = df.reorder { allDfs(true) }.byName()
+        val sorted2 = df.reorder { all().recursively() }.byName()
         sorted2.columnNames() shouldBe listOf("a", "b")
         sorted2["a"].asColumnGroup().columnNames() shouldBe listOf("a", "c")
     }
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
index 02cdc6642..4366dd86a 100644
--- a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/PlaylistJsonTest.kt
+++ b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/PlaylistJsonTest.kt
@@ -136,7 +136,9 @@ class PlaylistJsonTest {
 
     @Test
     fun `deep batch update all`() {
-        val updated = item.convert { dfs { it.name() == "url" } }.with { (it as? String)?.let { IMG(it) } }
+        val updated = item
+            .convert { cols { it.name() == "url" }.rec() }
+            .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?>()
         updated.snippet.thumbnails.standard.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
index 438c3bbf8..f44ce9fd2 100644
--- 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
@@ -701,7 +701,7 @@ class Access : TestBase() {
     fun columnSelectorsUsages() {
         // SampleStart
         df.select { age and name }
-        df.fillNaNs { dfsOf<Double>() }.withZero()
+        df.fillNaNs { colsOf<Double>().recursively() }.withZero()
         df.remove { cols { it.hasNulls() } }
         df.group { cols { it.data != name } }.into { "nameless" }
         df.update { city }.notNull { it.lowercase() }
@@ -739,8 +739,8 @@ class Access : TestBase() {
         // all children of ColumnGroup
         df.select { name.all() }
 
-        // depth-first-search traversal of all children columns
-        df.select { name.allDfs() }
+        // recursive traversal of all children columns excluding ColumnGroups
+        df.select { name.cols { !it.isColumnGroup() }.recursively() }
 
         // SampleEnd
     }
@@ -777,8 +777,8 @@ class Access : TestBase() {
         // all children of ColumnGroup
         df.select { name.all() }
 
-        // depth-first-search traversal of all children columns
-        df.select { name.allDfs() }
+        // recursive traversal of all children columns excluding ColumnGroups
+        df.select { name.cols { !it.isColumnGroup() }.recursively() }
         // SampleEnd
     }
 
@@ -812,8 +812,8 @@ class Access : TestBase() {
         // all children of ColumnGroup
         df.select { Person::name.all() }
 
-        // depth-first-search traversal of all children columns
-        df.select { Person::name.allDfs() }
+        // recursive traversal of all children columns excluding groups
+        df.select { Person::name.cols { !it.isColumnGroup() }.recursively() }
         // SampleEnd
     }
 
@@ -846,8 +846,8 @@ class Access : TestBase() {
         // all children of ColumnGroup
         df.select { "name".all() }
 
-        // depth-first-search traversal of all children columns
-        df.select { "name".allDfs() }
+        // recursive traversal of all children columns excluding groups
+        df.select { "name".cols { !it.isColumnGroup() }.recursively() }
         // SampleEnd
     }
 
@@ -905,17 +905,17 @@ class Access : TestBase() {
             Person::name.single { it.name().startsWith("first") }
         }
 
-        // depth-first-search traversal of all columns, excluding ColumnGroups from result
-        df.select { allDfs() }
+        // recursive traversal of all columns, excluding ColumnGroups from result
+        df.select { cols { !it.isColumnGroup() }.recursively() }
 
         // depth-first-search traversal of all columns, including ColumnGroups in result
-        df.select { allDfs(includeGroups = true) }
+        df.select { all().recursively() }
 
-        // depth-first-search traversal with condition
-        df.select { dfs { it.name().contains(":") } }
+        // recursive traversal with condition
+        df.select { cols { it.name().contains(":") }.recursively() }
 
-        // depth-first-search traversal of columns of given type
-        df.select { dfsOf<String>() }
+        // recursive traversal of columns of given type
+        df.select { colsOf<String>().rec() }
 
         // all columns except given column set
         df.select { except { colsOf<String>() } }
@@ -929,19 +929,19 @@ class Access : TestBase() {
     @TransformDataFrameExpressions
     fun columnSelectorsModifySet() {
         // SampleStart
-        // first/last n columns in column set
-        df.select { allDfs().take(3) }
-        df.select { allDfs().takeLast(3) }
+        // first/last n value- and frame columns in column set
+        df.select { cols { !it.isColumnGroup() }.recursively().take(3) }
+        df.select { cols { !it.isColumnGroup() }.recursively().takeLast(3) }
 
-        // all except first/last n columns in column set
-        df.select { allDfs().drop(3) }
-        df.select { allDfs().dropLast(3) }
+        // all except first/last n value- and frame columns in column set
+        df.select { cols { !it.isColumnGroup() }.recursively().drop(3) }
+        df.select { cols { !it.isColumnGroup() }.recursively().dropLast(3) }
 
         // filter column set by condition
-        df.select { allDfs().filter { it.name().startsWith("year") } }
+        df.select { cols { !it.isColumnGroup() }.rec().filter { it.name().startsWith("year") } }
 
         // exclude columns from column set
-        df.select { allDfs().except { age } }
+        df.select { cols { !it.isColumnGroup() }.rec().except { age } }
 
         // keep only unique columns
         df.select { (colsOf<Int>() and age).distinct() }
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Modify.kt b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Modify.kt
index b71f65655..aceb0156e 100644
--- a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Modify.kt
+++ b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Modify.kt
@@ -23,7 +23,6 @@ import org.jetbrains.kotlinx.dataframe.api.convert
 import org.jetbrains.kotlinx.dataframe.api.convertTo
 import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
 import org.jetbrains.kotlinx.dataframe.api.default
-import org.jetbrains.kotlinx.dataframe.api.dfsOf
 import org.jetbrains.kotlinx.dataframe.api.dropNulls
 import org.jetbrains.kotlinx.dataframe.api.explode
 import org.jetbrains.kotlinx.dataframe.api.fill
@@ -120,7 +119,7 @@ class Modify : TestBase() {
     fun update() {
         // SampleStart
         df.update { age }.with { it * 2 }
-        df.update { dfsOf<String>() }.with { it.uppercase() }
+        df.update { colsOf<String>().recursively() }.with { it.uppercase() }
         df.update { weight }.at(1..4).notNull { it / 2 }
         df.update { name.lastName and age }.at(1, 3, 4).withNull()
         // SampleEnd
@@ -181,7 +180,7 @@ class Modify : TestBase() {
     fun convert() {
         // SampleStart
         df.convert { age }.with { it.toDouble() }
-        df.convert { dfsOf<String>() }.with { it.toCharArray().toList() }
+        df.convert { colsOf<String>().recursively() }.with { it.toCharArray().toList() }
         // SampleEnd
     }
 
@@ -338,7 +337,7 @@ class Modify : TestBase() {
 
         // a.b.e -> be
         // c.d.e -> de
-        df.move { dfs { it.name() == "e" } }.toTop { it.parentName + it.name() }
+        df.move { cols { it.name() == "e" }.recursively() }.toTop { it.parentName + it.name() }
         // SampleEnd
     }
 
@@ -779,7 +778,7 @@ class Modify : TestBase() {
 
     @Test
     @TransformDataFrameExpressions
-    fun concatDfs() {
+    fun concatDataFrames() {
         val df1 = df
         val df2 = df
         // SampleStart
@@ -906,7 +905,7 @@ class Modify : TestBase() {
 
     @Test
     @TransformDataFrameExpressions
-    fun addDfs() {
+    fun addDataFrames() {
         val df1 = df.select { name named "name2" }
         val df2 = df.select { age named "age2" }
         // SampleStart
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/TestBase.kt b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/TestBase.kt
index 4f738e1fe..4e4d2ce04 100644
--- a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/TestBase.kt
+++ b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/TestBase.kt
@@ -1,13 +1,12 @@
 package org.jetbrains.kotlinx.dataframe.samples.api
 
+import io.kotest.matchers.should
 import io.kotest.matchers.shouldBe
 import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
-import org.jetbrains.kotlinx.dataframe.api.cast
-import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
-import org.jetbrains.kotlinx.dataframe.api.group
-import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.*
 import org.jetbrains.kotlinx.dataframe.explainer.PluginCallbackProxy
+import org.jetbrains.kotlinx.dataframe.impl.columns.asValueColumn
 import org.junit.After
 import org.junit.Before
 
@@ -41,6 +40,16 @@ public open class TestBase {
         "Charlie", "Byrd", 30, "Moscow", 90, true
     ).group("firstName", "lastName").into("name").cast<Person>()
 
+    val dfGroup = df.convert { name.firstName }.to {
+        val firstName by it
+        val secondName by it.map<_, String?> { null }.asValueColumn()
+        val thirdName by it.map<_, String?> { null }.asValueColumn()
+
+        dataFrameOf(firstName, secondName, thirdName)
+            .cast<FirstNames>(verify = true)
+            .asColumnGroup("firstName")
+    }.cast<Person2>(verify = true)
+
     @DataSchema
     interface Name {
         val firstName: String
@@ -56,5 +65,34 @@ public open class TestBase {
         val isHappy: Boolean
     }
 
+    @DataSchema
+    interface FirstNames {
+        val firstName: String
+        val secondName: String?
+        val thirdName: String?
+    }
+
+    @DataSchema
+    interface Name2 {
+        val firstName: DataRow<FirstNames>
+        val lastName: String
+    }
+
+    @DataSchema
+    interface Person2 {
+        val age: Int
+        val city: String?
+        val name: DataRow<Name2>
+        val weight: Int?
+        val isHappy: Boolean
+    }
+
     infix fun <T, U : T> T.willBe(expected: U?) = shouldBe(expected)
+
+    fun <T> Iterable<T>.shouldAllBeEqual(): Iterable<T> {
+        this should {
+            it.reduce { a, b -> a shouldBe b; b }
+        }
+        return this
+    }
 }
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
index c33a44cc6..4bd50bad7 100644
--- 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
@@ -5,181 +5,20 @@ import io.kotest.matchers.doubles.ToleranceMatcher
 import io.kotest.matchers.should
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
-import org.jetbrains.kotlinx.dataframe.AnyFrame
-import org.jetbrains.kotlinx.dataframe.AnyRow
-import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.DataRow
-import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.*
 import org.jetbrains.kotlinx.dataframe.annotations.ColumnName
 import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
-import org.jetbrains.kotlinx.dataframe.api.ExcessiveColumns
-import org.jetbrains.kotlinx.dataframe.api.GroupBy
-import org.jetbrains.kotlinx.dataframe.api.ParserOptions
-import org.jetbrains.kotlinx.dataframe.api.add
-import org.jetbrains.kotlinx.dataframe.api.addAll
-import org.jetbrains.kotlinx.dataframe.api.addId
-import org.jetbrains.kotlinx.dataframe.api.all
-import org.jetbrains.kotlinx.dataframe.api.allNulls
-import org.jetbrains.kotlinx.dataframe.api.append
-import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.asDataFrame
-import org.jetbrains.kotlinx.dataframe.api.asGroupBy
-import org.jetbrains.kotlinx.dataframe.api.asIterable
-import org.jetbrains.kotlinx.dataframe.api.at
-import org.jetbrains.kotlinx.dataframe.api.between
-import org.jetbrains.kotlinx.dataframe.api.by
-import org.jetbrains.kotlinx.dataframe.api.cast
-import org.jetbrains.kotlinx.dataframe.api.chunked
-import org.jetbrains.kotlinx.dataframe.api.colsOf
-import org.jetbrains.kotlinx.dataframe.api.column
-import org.jetbrains.kotlinx.dataframe.api.columnGroup
-import org.jetbrains.kotlinx.dataframe.api.columnOf
-import org.jetbrains.kotlinx.dataframe.api.concat
-import org.jetbrains.kotlinx.dataframe.api.convert
-import org.jetbrains.kotlinx.dataframe.api.convertTo
-import org.jetbrains.kotlinx.dataframe.api.corr
-import org.jetbrains.kotlinx.dataframe.api.count
-import org.jetbrains.kotlinx.dataframe.api.countDistinct
-import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
-import org.jetbrains.kotlinx.dataframe.api.default
-import org.jetbrains.kotlinx.dataframe.api.describe
-import org.jetbrains.kotlinx.dataframe.api.dfsOf
-import org.jetbrains.kotlinx.dataframe.api.digitize
-import org.jetbrains.kotlinx.dataframe.api.distinct
-import org.jetbrains.kotlinx.dataframe.api.distinctBy
-import org.jetbrains.kotlinx.dataframe.api.div
-import org.jetbrains.kotlinx.dataframe.api.drop
-import org.jetbrains.kotlinx.dataframe.api.dropLast
-import org.jetbrains.kotlinx.dataframe.api.dropNA
-import org.jetbrains.kotlinx.dataframe.api.dropNulls
-import org.jetbrains.kotlinx.dataframe.api.dropWhile
-import org.jetbrains.kotlinx.dataframe.api.explode
-import org.jetbrains.kotlinx.dataframe.api.expr
-import org.jetbrains.kotlinx.dataframe.api.fill
-import org.jetbrains.kotlinx.dataframe.api.fillNulls
-import org.jetbrains.kotlinx.dataframe.api.filter
-import org.jetbrains.kotlinx.dataframe.api.first
-import org.jetbrains.kotlinx.dataframe.api.forEach
-import org.jetbrains.kotlinx.dataframe.api.forEachIndexed
-import org.jetbrains.kotlinx.dataframe.api.frameColumn
-import org.jetbrains.kotlinx.dataframe.api.gather
-import org.jetbrains.kotlinx.dataframe.api.getColumn
-import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.getColumns
-import org.jetbrains.kotlinx.dataframe.api.getFrameColumn
-import org.jetbrains.kotlinx.dataframe.api.getValue
-import org.jetbrains.kotlinx.dataframe.api.group
-import org.jetbrains.kotlinx.dataframe.api.groupBy
-import org.jetbrains.kotlinx.dataframe.api.implode
-import org.jetbrains.kotlinx.dataframe.api.indices
-import org.jetbrains.kotlinx.dataframe.api.inplace
-import org.jetbrains.kotlinx.dataframe.api.into
-import org.jetbrains.kotlinx.dataframe.api.intoColumns
-import org.jetbrains.kotlinx.dataframe.api.intoList
-import org.jetbrains.kotlinx.dataframe.api.intoRows
-import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.isFrameColumn
-import org.jetbrains.kotlinx.dataframe.api.isNA
-import org.jetbrains.kotlinx.dataframe.api.isNumber
-import org.jetbrains.kotlinx.dataframe.api.keysInto
-import org.jetbrains.kotlinx.dataframe.api.last
-import org.jetbrains.kotlinx.dataframe.api.leftJoin
-import org.jetbrains.kotlinx.dataframe.api.lowercase
-import org.jetbrains.kotlinx.dataframe.api.map
-import org.jetbrains.kotlinx.dataframe.api.mapToFrame
-import org.jetbrains.kotlinx.dataframe.api.match
-import org.jetbrains.kotlinx.dataframe.api.matches
-import org.jetbrains.kotlinx.dataframe.api.max
-import org.jetbrains.kotlinx.dataframe.api.maxBy
-import org.jetbrains.kotlinx.dataframe.api.mean
-import org.jetbrains.kotlinx.dataframe.api.meanFor
-import org.jetbrains.kotlinx.dataframe.api.meanOf
-import org.jetbrains.kotlinx.dataframe.api.median
-import org.jetbrains.kotlinx.dataframe.api.merge
-import org.jetbrains.kotlinx.dataframe.api.min
-import org.jetbrains.kotlinx.dataframe.api.minBy
-import org.jetbrains.kotlinx.dataframe.api.minOf
-import org.jetbrains.kotlinx.dataframe.api.minus
-import org.jetbrains.kotlinx.dataframe.api.move
-import org.jetbrains.kotlinx.dataframe.api.moveTo
-import org.jetbrains.kotlinx.dataframe.api.moveToLeft
-import org.jetbrains.kotlinx.dataframe.api.moveToRight
+import org.jetbrains.kotlinx.dataframe.api.*
 import org.jetbrains.kotlinx.dataframe.api.name
-import org.jetbrains.kotlinx.dataframe.api.named
-import org.jetbrains.kotlinx.dataframe.api.notNull
-import org.jetbrains.kotlinx.dataframe.api.nullable
-import org.jetbrains.kotlinx.dataframe.api.parse
-import org.jetbrains.kotlinx.dataframe.api.pathOf
-import org.jetbrains.kotlinx.dataframe.api.pivot
-import org.jetbrains.kotlinx.dataframe.api.print
-import org.jetbrains.kotlinx.dataframe.api.remove
-import org.jetbrains.kotlinx.dataframe.api.rename
-import org.jetbrains.kotlinx.dataframe.api.reorderColumnsByName
-import org.jetbrains.kotlinx.dataframe.api.replace
-import org.jetbrains.kotlinx.dataframe.api.rows
-import org.jetbrains.kotlinx.dataframe.api.select
-import org.jetbrains.kotlinx.dataframe.api.single
-import org.jetbrains.kotlinx.dataframe.api.sortBy
-import org.jetbrains.kotlinx.dataframe.api.sortByCount
-import org.jetbrains.kotlinx.dataframe.api.sortByDesc
-import org.jetbrains.kotlinx.dataframe.api.sortByKey
-import org.jetbrains.kotlinx.dataframe.api.sortWith
-import org.jetbrains.kotlinx.dataframe.api.split
-import org.jetbrains.kotlinx.dataframe.api.sum
-import org.jetbrains.kotlinx.dataframe.api.sumOf
-import org.jetbrains.kotlinx.dataframe.api.take
-import org.jetbrains.kotlinx.dataframe.api.takeLast
-import org.jetbrains.kotlinx.dataframe.api.takeWhile
-import org.jetbrains.kotlinx.dataframe.api.times
-import org.jetbrains.kotlinx.dataframe.api.to
-import org.jetbrains.kotlinx.dataframe.api.toColumn
-import org.jetbrains.kotlinx.dataframe.api.toColumnAccessor
-import org.jetbrains.kotlinx.dataframe.api.toColumnOf
-import org.jetbrains.kotlinx.dataframe.api.toDataFrame
-import org.jetbrains.kotlinx.dataframe.api.toDouble
-import org.jetbrains.kotlinx.dataframe.api.toInt
-import org.jetbrains.kotlinx.dataframe.api.toList
-import org.jetbrains.kotlinx.dataframe.api.toListOf
-import org.jetbrains.kotlinx.dataframe.api.toMap
-import org.jetbrains.kotlinx.dataframe.api.toRight
-import org.jetbrains.kotlinx.dataframe.api.toStr
-import org.jetbrains.kotlinx.dataframe.api.toValueColumn
-import org.jetbrains.kotlinx.dataframe.api.transpose
-import org.jetbrains.kotlinx.dataframe.api.under
-import org.jetbrains.kotlinx.dataframe.api.ungroup
-import org.jetbrains.kotlinx.dataframe.api.update
-import org.jetbrains.kotlinx.dataframe.api.value
-import org.jetbrains.kotlinx.dataframe.api.values
-import org.jetbrains.kotlinx.dataframe.api.valuesNotNull
-import org.jetbrains.kotlinx.dataframe.api.where
-import org.jetbrains.kotlinx.dataframe.api.with
-import org.jetbrains.kotlinx.dataframe.api.withNull
-import org.jetbrains.kotlinx.dataframe.api.withValue
-import org.jetbrains.kotlinx.dataframe.api.withValues
-import org.jetbrains.kotlinx.dataframe.api.withZero
-import org.jetbrains.kotlinx.dataframe.api.xs
 import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
 import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
 import org.jetbrains.kotlinx.dataframe.exceptions.ExcessiveColumnsException
 import org.jetbrains.kotlinx.dataframe.exceptions.TypeConversionException
-import org.jetbrains.kotlinx.dataframe.hasNulls
-import org.jetbrains.kotlinx.dataframe.impl.DataFrameSize
+import org.jetbrains.kotlinx.dataframe.impl.*
 import org.jetbrains.kotlinx.dataframe.impl.api.convertToImpl
-import org.jetbrains.kotlinx.dataframe.impl.between
 import org.jetbrains.kotlinx.dataframe.impl.columns.isMissingColumn
-import org.jetbrains.kotlinx.dataframe.impl.emptyPath
-import org.jetbrains.kotlinx.dataframe.impl.getColumnsImpl
-import org.jetbrains.kotlinx.dataframe.impl.nothingType
-import org.jetbrains.kotlinx.dataframe.impl.trackColumnAccess
-import org.jetbrains.kotlinx.dataframe.index
 import org.jetbrains.kotlinx.dataframe.io.renderValueForStdout
-import org.jetbrains.kotlinx.dataframe.kind
 import org.jetbrains.kotlinx.dataframe.math.mean
-import org.jetbrains.kotlinx.dataframe.ncol
-import org.jetbrains.kotlinx.dataframe.nrow
-import org.jetbrains.kotlinx.dataframe.size
-import org.jetbrains.kotlinx.dataframe.type
-import org.jetbrains.kotlinx.dataframe.typeClass
 import org.junit.Test
 import java.math.BigDecimal
 import java.time.LocalDate
@@ -911,7 +750,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 { allDfs() }
+        val cols = df.getColumns { cols { !it.isColumnGroup() }.recursively() }
         cols.size shouldBe 5
         cols.forEach {
             it.toList() shouldBe expected
@@ -1165,7 +1004,7 @@ class DataFrameTests : BaseTest() {
     @Test
     fun `gather bool`() {
         val pivoted = typed.pivot { city }.groupBy { name }.matches()
-        val res = pivoted.gather { dfsOf<Boolean>() }.where { it }.keysInto("city")
+        val res = pivoted.gather { colsOf<Boolean>().recursively() }.where { it }.keysInto("city")
         val sorted = res.sortBy { name and city }
         sorted shouldBe typed.select { name and city.map { it.toString() } }.distinct().sortBy { name and city }
     }
@@ -1553,10 +1392,10 @@ class DataFrameTests : BaseTest() {
     @Test
     fun `union table columns`() {
         val grouped = typed.addId("id").groupBy { name }.toDataFrame()
-        val dfs = (0 until grouped.nrow).map {
+        val flattened = (0 until grouped.nrow).map {
             grouped[it..it]
         }
-        val dst = dfs.concat().asGroupBy().concat().sortBy("id").remove("id")
+        val dst = flattened.concat().asGroupBy().concat().sortBy("id").remove("id")
         dst shouldBe typed
     }
 
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
index d76ad386c..a96b20382 100644
--- 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
@@ -9,84 +9,7 @@ import org.jetbrains.dataframe.impl.codeGen.InterfaceGenerationMode
 import org.jetbrains.dataframe.impl.codeGen.generate
 import org.jetbrains.kotlinx.dataframe.*
 import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
-import org.jetbrains.kotlinx.dataframe.api.GroupBy
-import org.jetbrains.kotlinx.dataframe.api.GroupWithKey
-import org.jetbrains.kotlinx.dataframe.api.add
-import org.jetbrains.kotlinx.dataframe.api.addId
-import org.jetbrains.kotlinx.dataframe.api.after
-import org.jetbrains.kotlinx.dataframe.api.append
-import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.asDataFrame
-import org.jetbrains.kotlinx.dataframe.api.asGroupBy
-import org.jetbrains.kotlinx.dataframe.api.at
-import org.jetbrains.kotlinx.dataframe.api.by
-import org.jetbrains.kotlinx.dataframe.api.cast
-import org.jetbrains.kotlinx.dataframe.api.column
-import org.jetbrains.kotlinx.dataframe.api.columnGroup
-import org.jetbrains.kotlinx.dataframe.api.columnOf
-import org.jetbrains.kotlinx.dataframe.api.columnsCount
-import org.jetbrains.kotlinx.dataframe.api.concat
-import org.jetbrains.kotlinx.dataframe.api.convert
-import org.jetbrains.kotlinx.dataframe.api.count
-import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
-import org.jetbrains.kotlinx.dataframe.api.dfsOf
-import org.jetbrains.kotlinx.dataframe.api.distinct
-import org.jetbrains.kotlinx.dataframe.api.dropNulls
-import org.jetbrains.kotlinx.dataframe.api.duplicate
-import org.jetbrains.kotlinx.dataframe.api.duplicateRows
-import org.jetbrains.kotlinx.dataframe.api.emptyDataFrame
-import org.jetbrains.kotlinx.dataframe.api.explode
-import org.jetbrains.kotlinx.dataframe.api.expr
-import org.jetbrains.kotlinx.dataframe.api.filter
-import org.jetbrains.kotlinx.dataframe.api.forEach
-import org.jetbrains.kotlinx.dataframe.api.frameColumn
-import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.getColumnPath
-import org.jetbrains.kotlinx.dataframe.api.getColumnWithPath
-import org.jetbrains.kotlinx.dataframe.api.getColumns
-import org.jetbrains.kotlinx.dataframe.api.getValue
-import org.jetbrains.kotlinx.dataframe.api.group
-import org.jetbrains.kotlinx.dataframe.api.groupBy
-import org.jetbrains.kotlinx.dataframe.api.implode
-import org.jetbrains.kotlinx.dataframe.api.indices
-import org.jetbrains.kotlinx.dataframe.api.insert
-import org.jetbrains.kotlinx.dataframe.api.into
-import org.jetbrains.kotlinx.dataframe.api.intoRows
-import org.jetbrains.kotlinx.dataframe.api.inward
-import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.isEmpty
-import org.jetbrains.kotlinx.dataframe.api.isFrameColumn
-import org.jetbrains.kotlinx.dataframe.api.join
-import org.jetbrains.kotlinx.dataframe.api.last
-import org.jetbrains.kotlinx.dataframe.api.map
-import org.jetbrains.kotlinx.dataframe.api.max
-import org.jetbrains.kotlinx.dataframe.api.maxBy
-import org.jetbrains.kotlinx.dataframe.api.median
-import org.jetbrains.kotlinx.dataframe.api.minus
-import org.jetbrains.kotlinx.dataframe.api.move
-import org.jetbrains.kotlinx.dataframe.api.moveTo
-import org.jetbrains.kotlinx.dataframe.api.moveToLeft
-import org.jetbrains.kotlinx.dataframe.api.moveToRight
-import org.jetbrains.kotlinx.dataframe.api.pathOf
-import org.jetbrains.kotlinx.dataframe.api.perRowCol
-import org.jetbrains.kotlinx.dataframe.api.pivot
-import org.jetbrains.kotlinx.dataframe.api.remove
-import org.jetbrains.kotlinx.dataframe.api.rename
-import org.jetbrains.kotlinx.dataframe.api.rows
-import org.jetbrains.kotlinx.dataframe.api.select
-import org.jetbrains.kotlinx.dataframe.api.single
-import org.jetbrains.kotlinx.dataframe.api.sortBy
-import org.jetbrains.kotlinx.dataframe.api.split
-import org.jetbrains.kotlinx.dataframe.api.sumOf
-import org.jetbrains.kotlinx.dataframe.api.toColumnAccessor
-import org.jetbrains.kotlinx.dataframe.api.toTop
-import org.jetbrains.kotlinx.dataframe.api.under
-import org.jetbrains.kotlinx.dataframe.api.ungroup
-import org.jetbrains.kotlinx.dataframe.api.update
-import org.jetbrains.kotlinx.dataframe.api.values
-import org.jetbrains.kotlinx.dataframe.api.with
-import org.jetbrains.kotlinx.dataframe.api.withNull
-import org.jetbrains.kotlinx.dataframe.api.xs
+import org.jetbrains.kotlinx.dataframe.api.*
 import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
 import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
 import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
@@ -143,9 +66,9 @@ class DataFrameTreeTests : BaseTest() {
     }
 
     @Test
-    fun `select dfs under group`() {
-        df2.select { nameAndCity.dfsOf<String>() } shouldBe typed2.select { nameAndCity.name }
-        df2.select { nameAndCity.dfsOf<String?>() } shouldBe typed2.select { nameAndCity.name and nameAndCity.city }
+    fun `select recursively under group`() {
+        df2.select { nameAndCity.colsOf<String>().recursively() } shouldBe typed2.select { nameAndCity.name }
+        df2.select { nameAndCity.colsOf<String?>().recursively() } shouldBe typed2.select { nameAndCity.name and nameAndCity.city }
     }
 
     @Test
@@ -249,8 +172,8 @@ class DataFrameTreeTests : BaseTest() {
     }
 
     @Test
-    fun selectDfs() {
-        val cols = typed2.select { dfs { it.hasNulls } }
+    fun `select recursively`() {
+        val cols = typed2.select { cols { it.hasNulls }.rec() }
         cols shouldBe typed2.select { nameAndCity.city and weight }
     }
 
@@ -457,14 +380,14 @@ class DataFrameTreeTests : BaseTest() {
 
     @Test
     fun parentColumnTest() {
-        val res = typed2.move { dfs { it.depth > 0 } }.toTop { it.parentName + "-" + it.name }
+        val res = typed2.move { cols { it.depth > 0 }.rec() }.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 { allDfs() }.into { pathOf(it.path.joinToString(".")) }
+        val joined = typed2.move { cols { !it.isColumnGroup() }.rec() }.into { pathOf(it.path.joinToString(".")) }
         val grouped = joined.group { nameContains(".") }.into { it.name().substringBefore(".") }
         val expected = typed2.rename { nameAndCity.all() }.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
index 5dea9d318..3af47eb35 100644
--- 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
@@ -3,56 +3,7 @@ package org.jetbrains.kotlinx.dataframe.testSets.person
 import io.kotest.matchers.shouldBe
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
-import org.jetbrains.kotlinx.dataframe.api.Infer
-import org.jetbrains.kotlinx.dataframe.api.add
-import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.associate
-import org.jetbrains.kotlinx.dataframe.api.cast
-import org.jetbrains.kotlinx.dataframe.api.column
-import org.jetbrains.kotlinx.dataframe.api.columnNames
-import org.jetbrains.kotlinx.dataframe.api.columnOf
-import org.jetbrains.kotlinx.dataframe.api.columnsCount
-import org.jetbrains.kotlinx.dataframe.api.convert
-import org.jetbrains.kotlinx.dataframe.api.count
-import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
-import org.jetbrains.kotlinx.dataframe.api.drop
-import org.jetbrains.kotlinx.dataframe.api.dropNulls
-import org.jetbrains.kotlinx.dataframe.api.explodeLists
-import org.jetbrains.kotlinx.dataframe.api.expr
-import org.jetbrains.kotlinx.dataframe.api.filter
-import org.jetbrains.kotlinx.dataframe.api.first
-import org.jetbrains.kotlinx.dataframe.api.frames
-import org.jetbrains.kotlinx.dataframe.api.gather
-import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.getColumns
-import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
-import org.jetbrains.kotlinx.dataframe.api.group
-import org.jetbrains.kotlinx.dataframe.api.groupBy
-import org.jetbrains.kotlinx.dataframe.api.groupByOther
-import org.jetbrains.kotlinx.dataframe.api.implode
-import org.jetbrains.kotlinx.dataframe.api.into
-import org.jetbrains.kotlinx.dataframe.api.isList
-import org.jetbrains.kotlinx.dataframe.api.join
-import org.jetbrains.kotlinx.dataframe.api.last
-import org.jetbrains.kotlinx.dataframe.api.map
-import org.jetbrains.kotlinx.dataframe.api.mapKeys
-import org.jetbrains.kotlinx.dataframe.api.mapValues
-import org.jetbrains.kotlinx.dataframe.api.matches
-import org.jetbrains.kotlinx.dataframe.api.named
-import org.jetbrains.kotlinx.dataframe.api.notNull
-import org.jetbrains.kotlinx.dataframe.api.pivot
-import org.jetbrains.kotlinx.dataframe.api.print
-import org.jetbrains.kotlinx.dataframe.api.remove
-import org.jetbrains.kotlinx.dataframe.api.replace
-import org.jetbrains.kotlinx.dataframe.api.rows
-import org.jetbrains.kotlinx.dataframe.api.sortBy
-import org.jetbrains.kotlinx.dataframe.api.sumOf
-import org.jetbrains.kotlinx.dataframe.api.toInt
-import org.jetbrains.kotlinx.dataframe.api.ungroup
-import org.jetbrains.kotlinx.dataframe.api.update
-import org.jetbrains.kotlinx.dataframe.api.values
-import org.jetbrains.kotlinx.dataframe.api.where
-import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.api.*
 import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
 import org.jetbrains.kotlinx.dataframe.impl.asList
 import org.jetbrains.kotlinx.dataframe.impl.nothingType
@@ -229,7 +180,11 @@ class PivotTests {
             group.columnNames() shouldBe if (it.name() == "Bob") keys - "city" else keys
         }
 
-        val leafColumns = pivoted.getColumnsWithPaths { all().drop(1).allDfs() }
+        val leafColumns = pivoted.getColumnsWithPaths {
+            all()
+                .drop(1)
+                .cols { !it.isColumnGroup() }.recursively()
+        }
         leafColumns.size shouldBe typed.name.countDistinct() * typed.key.countDistinct() - 1
         leafColumns.forEach { it.path.size shouldBe 2 }
 
@@ -284,7 +239,7 @@ class PivotTests {
 //        nullGroup.columnTypes() shouldBe listOf(typeOf<Comparable<*>?>(), typeOf<KClass<Any>?>())
         nullGroup.columnTypes() shouldBe listOf(nothingType(true), nothingType(true))
 
-        val cols = pivotedDf.getColumnsWithPaths { all().allDfs() }
+        val cols = pivotedDf.getColumnsWithPaths { cols { !it.isColumnGroup() }.recursively() }
         cols.size shouldBe 2 * typed.name.countDistinct() * typed.key.countDistinct() - 2
 
         cols.forEach {
diff --git a/dataframe-arrow/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/arrowReadingImpl.kt b/dataframe-arrow/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/arrowReadingImpl.kt
index 860b7c507..a9aacee7e 100644
--- a/dataframe-arrow/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/arrowReadingImpl.kt
+++ b/dataframe-arrow/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/arrowReadingImpl.kt
@@ -222,7 +222,7 @@ internal fun DataFrame.Companion.readArrowIPCImpl(
     nullability: NullabilityOptions = NullabilityOptions.Infer,
 ): AnyFrame {
     ArrowStreamReader(channel, allocator).use { reader ->
-        val dfs = buildList {
+        val flattened = buildList {
             val root = reader.vectorSchemaRoot
             val schema = root.schema
             while (reader.loadNextBatch()) {
@@ -230,7 +230,7 @@ internal fun DataFrame.Companion.readArrowIPCImpl(
                 add(df)
             }
         }
-        return dfs.concatKeepingSchema()
+        return flattened.concatKeepingSchema()
     }
 }
 
@@ -243,7 +243,7 @@ internal fun DataFrame.Companion.readArrowFeatherImpl(
     nullability: NullabilityOptions = NullabilityOptions.Infer,
 ): AnyFrame {
     ArrowFileReader(channel, allocator).use { reader ->
-        val dfs = buildList {
+        val flattened = buildList {
             reader.recordBlocks.forEach { block ->
                 reader.loadRecordBatch(block)
                 val root = reader.vectorSchemaRoot
@@ -252,6 +252,6 @@ internal fun DataFrame.Companion.readArrowFeatherImpl(
                 add(df)
             }
         }
-        return dfs.concatKeepingSchema()
+        return flattened.concatKeepingSchema()
     }
 }
diff --git a/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Access.columnSelectors.html b/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Access.columnSelectors.html
index 1ca191eec..2d5d9a5ee 100644
--- a/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Access.columnSelectors.html
+++ b/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Access.columnSelectors.html
@@ -382,7 +382,7 @@
                         </details>
                         <br>
                         <details>
-                        <summary>df.select { name.allDfs() }</summary>
+                        <summary>df.select { name.cols { !it.isColumnGroup() }.recursively() }</summary>
                         
                                     <details>
                                     <summary>Input DataFrame: rowsCount = 7, columnsCount = 5</summary>
diff --git a/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Access.columnSelectorsMisc.html b/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Access.columnSelectorsMisc.html
index 489c6317a..3841486ae 100644
--- a/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Access.columnSelectorsMisc.html
+++ b/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Access.columnSelectorsMisc.html
@@ -499,7 +499,7 @@
                         </details>
                         <br>
                         <details>
-                        <summary>df.select { allDfs() }</summary>
+                        <summary>df.select { cols { !it.isColumnGroup() }.recursively() }</summary>
                         
                                     <details>
                                     <summary>Input DataFrame: rowsCount = 7, columnsCount = 6</summary>
@@ -516,7 +516,7 @@
                         </details>
                         <br>
                         <details>
-                        <summary>df.select { allDfs(includeGroups = true) }</summary>
+                        <summary>df.select { all().recursively() }</summary>
                         
                                     <details>
                                     <summary>Input DataFrame: rowsCount = 7, columnsCount = 6</summary>
@@ -533,7 +533,7 @@
                         </details>
                         <br>
                         <details>
-                        <summary>df.select { dfs { it.name().contains(&quot;:&quot;) } }</summary>
+                        <summary>df.select { cols { it.name().contains(&quot;:&quot;) }.recursively() }</summary>
                         
                                     <details>
                                     <summary>Input DataFrame: rowsCount = 7, columnsCount = 6</summary>
@@ -550,7 +550,7 @@
                         </details>
                         <br>
                         <details>
-                        <summary>df.select { dfsOf&amp;lt;String&amp;gt;() }</summary>
+                        <summary>df.select { colsOf&amp;lt;String&amp;gt;().rec() }</summary>
                         
                                     <details>
                                     <summary>Input DataFrame: rowsCount = 7, columnsCount = 6</summary>
diff --git a/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Access.columnSelectorsModifySet.html b/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Access.columnSelectorsModifySet.html
index 54a701263..017e49c2e 100644
--- a/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Access.columnSelectorsModifySet.html
+++ b/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Access.columnSelectorsModifySet.html
@@ -214,7 +214,7 @@
             
 
                         <details>
-                        <summary>df.select { allDfs().take(3) }</summary>
+                        <summary>df.select { cols { !it.isColumnGroup() }.recursively().take(3) }</summary>
                         
                                     <details>
                                     <summary>Input DataFrame: rowsCount = 7, columnsCount = 5</summary>
@@ -231,7 +231,7 @@
                         </details>
                         <br>
                         <details>
-                        <summary>df.select { allDfs().takeLast(3) }</summary>
+                        <summary>df.select { cols { !it.isColumnGroup() }.recursively().takeLast(3) }</summary>
                         
                                     <details>
                                     <summary>Input DataFrame: rowsCount = 7, columnsCount = 5</summary>
@@ -248,7 +248,7 @@
                         </details>
                         <br>
                         <details>
-                        <summary>df.select { allDfs().drop(3) }</summary>
+                        <summary>df.select { cols { !it.isColumnGroup() }.recursively().drop(3) }</summary>
                         
                                     <details>
                                     <summary>Input DataFrame: rowsCount = 7, columnsCount = 5</summary>
@@ -265,7 +265,7 @@
                         </details>
                         <br>
                         <details>
-                        <summary>df.select { allDfs().dropLast(3) }</summary>
+                        <summary>df.select { cols { !it.isColumnGroup() }.recursively().dropLast(3) }</summary>
                         
                                     <details>
                                     <summary>Input DataFrame: rowsCount = 7, columnsCount = 5</summary>
@@ -282,7 +282,7 @@
                         </details>
                         <br>
                         <details>
-                        <summary>df.select { allDfs().filter { it.name().startsWith(&quot;year&quot;) } }</summary>
+                        <summary>df.select { cols { !it.isColumnGroup() }.rec().filter { it.name().startsWith(&quot;year&quot;) } }</summary>
                         
                                     <details>
                                     <summary>Input DataFrame: rowsCount = 7, columnsCount = 5</summary>
@@ -299,7 +299,7 @@
                         </details>
                         <br>
                         <details>
-                        <summary>df.select { allDfs().except { age } }</summary>
+                        <summary>df.select { cols { !it.isColumnGroup() }.rec().except { age } }</summary>
                         
                                     <details>
                                     <summary>Input DataFrame: rowsCount = 7, columnsCount = 5</summary>
diff --git a/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Access.columnSelectorsUsages.html b/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Access.columnSelectorsUsages.html
index 8405d62d7..e0eb533cd 100644
--- a/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Access.columnSelectorsUsages.html
+++ b/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Access.columnSelectorsUsages.html
@@ -237,7 +237,7 @@
                         </details>
                         <br>
                         <details>
-                        <summary>df.fillNaNs { dfsOf&amp;lt;Double&amp;gt;() }.withZero()</summary>
+                        <summary>df.fillNaNs { colsOf&amp;lt;Double&amp;gt;().recursively() }.withZero()</summary>
                         
                                     <details>
                                     <summary>Input DataFrame: rowsCount = 7, columnsCount = 5</summary>
diff --git a/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Modify.addDfs.html b/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Modify.addDataFrames.html
similarity index 100%
rename from docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Modify.addDfs.html
rename to docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Modify.addDataFrames.html
diff --git a/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Modify.convert.html b/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Modify.convert.html
index 8b3f4bd68..546253124 100644
--- a/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Modify.convert.html
+++ b/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Modify.convert.html
@@ -212,7 +212,7 @@
                         </details>
                         <br>
                         <details>
-                        <summary>df.convert { dfsOf&amp;lt;String&amp;gt;() }.with { it.toCharArray().toList() }</summary>
+                        <summary>df.convert { colsOf&amp;lt;String&amp;gt;().recursively() }.with { it.toCharArray().toList() }</summary>
                         
                                     <details>
                                     <summary>Input DataFrame: rowsCount = 7, columnsCount = 5</summary>
diff --git a/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Modify.update.html b/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Modify.update.html
index 43309259d..df38de7ad 100644
--- a/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Modify.update.html
+++ b/docs/StardustDocs/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Modify.update.html
@@ -234,7 +234,7 @@
                         </details>
                         <br>
                         <details>
-                        <summary>df.update { dfsOf&amp;lt;String&amp;gt;() }.with { it.uppercase() }</summary>
+                        <summary>df.update { colsOf&amp;lt;String&amp;gt;().recursively() }.with { it.uppercase() }</summary>
                         
                                     <details>
                                     <summary>Input DataFrame: rowsCount = 7, columnsCount = 5</summary>
diff --git a/docs/StardustDocs/topics/ColumnSelectors.md b/docs/StardustDocs/topics/ColumnSelectors.md
index fb4ae353f..1964d9c7c 100644
--- a/docs/StardustDocs/topics/ColumnSelectors.md
+++ b/docs/StardustDocs/topics/ColumnSelectors.md
@@ -10,7 +10,7 @@ Column selectors are used in many operations:
 
 ```kotlin
 df.select { age and name }
-df.fillNaNs { dfsOf<Double>() }.withZero()
+df.fillNaNs { colsOf<Double>().recursively() }.withZero()
 df.remove { cols { it.hasNulls() } }
 df.group { cols { it.data != name } }.into { "nameless" }
 df.update { city }.notNull { it.lowercase() }
@@ -53,8 +53,8 @@ df.select { name..age }
 // all children of ColumnGroup
 df.select { name.all() }
 
-// depth-first-search traversal of all children columns
-df.select { name.allDfs() }
+// recursive traversal of all children columns excluding ColumnGroups
+df.select { name.cols { !it.isColumnGroup() }.recursively() }
 ```
 
 </tab>
@@ -89,8 +89,8 @@ df.select { name..age }
 // all children of ColumnGroup
 df.select { name.all() }
 
-// depth-first-search traversal of all children columns
-df.select { name.allDfs() }
+// recursive traversal of all children columns excluding ColumnGroups
+df.select { name.cols { !it.isColumnGroup() }.recursively() }
 ```
 
 </tab>
@@ -122,8 +122,8 @@ df.select { "name".."age" }
 // all children of ColumnGroup
 df.select { "name".all() }
 
-// depth-first-search traversal of all children columns
-df.select { "name".allDfs() }
+// recursive traversal of all children columns excluding groups
+df.select { "name".cols { !it.isColumnGroup() }.recursively() }
 ```
 
 </tab></tabs>
@@ -187,17 +187,17 @@ df.select {
     Person::name.single { it.name().startsWith("first") }
 }
 
-// depth-first-search traversal of all columns, excluding ColumnGroups from result
-df.select { allDfs() }
+// recursive traversal of all columns, excluding ColumnGroups from result
+df.select { cols { !it.isColumnGroup() }.recursively() }
 
 // depth-first-search traversal of all columns, including ColumnGroups in result
-df.select { allDfs(includeGroups = true) }
+df.select { all().recursively() }
 
-// depth-first-search traversal with condition
-df.select { dfs { it.name().contains(":") } }
+// recursive traversal with condition
+df.select { cols { it.name().contains(":") }.recursively() }
 
-// depth-first-search traversal of columns of given type
-df.select { dfsOf<String>() }
+// recursive traversal of columns of given type
+df.select { colsOf<String>().rec() }
 
 // all columns except given column set
 df.select { except { colsOf<String>() } }
@@ -214,19 +214,19 @@ df.select { take(2) and col(3) }
 <!---FUN columnSelectorsModifySet-->
 
 ```kotlin
-// first/last n columns in column set
-df.select { allDfs().take(3) }
-df.select { allDfs().takeLast(3) }
+// first/last n value- and frame columns in column set
+df.select { cols { !it.isColumnGroup() }.recursively().take(3) }
+df.select { cols { !it.isColumnGroup() }.recursively().takeLast(3) }
 
-// all except first/last n columns in column set
-df.select { allDfs().drop(3) }
-df.select { allDfs().dropLast(3) }
+// all except first/last n value- and frame columns in column set
+df.select { cols { !it.isColumnGroup() }.recursively().drop(3) }
+df.select { cols { !it.isColumnGroup() }.recursively().dropLast(3) }
 
 // filter column set by condition
-df.select { allDfs().filter { it.name().startsWith("year") } }
+df.select { cols { !it.isColumnGroup() }.rec().filter { it.name().startsWith("year") } }
 
 // exclude columns from column set
-df.select { allDfs().except { age } }
+df.select { cols { !it.isColumnGroup() }.rec().except { age } }
 
 // keep only unique columns
 df.select { (colsOf<Int>() and age).distinct() }
diff --git a/docs/StardustDocs/topics/add.md b/docs/StardustDocs/topics/add.md
index 047141e95..b9f9bc995 100644
--- a/docs/StardustDocs/topics/add.md
+++ b/docs/StardustDocs/topics/add.md
@@ -212,13 +212,13 @@ df + score
 
 ## Add all columns from another [`DataFrame`](DataFrame.md)
 
-<!---FUN addDfs-->
+<!---FUN addDataFrames-->
 
 ```kotlin
 df.add(df1, df2)
 ```
 
-<dataFrame src="org.jetbrains.kotlinx.dataframe.samples.api.Modify.addDfs.html"/>
+<dataFrame src="org.jetbrains.kotlinx.dataframe.samples.api.Modify.addDataFrames.html"/>
 <!---END-->
 
 ## addId
diff --git a/docs/StardustDocs/topics/addDf.md b/docs/StardustDocs/topics/addDf.md
index 31a1a4965..03889c6fc 100644
--- a/docs/StardustDocs/topics/addDf.md
+++ b/docs/StardustDocs/topics/addDf.md
@@ -4,13 +4,13 @@
 
 Returns [`DataFrame`](DataFrame.md) with union of columns from several given [`DataFrames`](DataFrame.md).
 
-<!---FUN addDfs-->
+<!---FUN addDataFrames-->
 
 ```kotlin
 df.add(df1, df2)
 ```
 
-<dataFrame src="org.jetbrains.kotlinx.dataframe.samples.api.Modify.addDfs.html"/>
+<dataFrame src="org.jetbrains.kotlinx.dataframe.samples.api.Modify.addDataFrames.html"/>
 <!---END-->
 
 See [all use cases of 'add' operation](add.md).
diff --git a/docs/StardustDocs/topics/concat.md b/docs/StardustDocs/topics/concat.md
index 172ec56ef..b826a9bb8 100644
--- a/docs/StardustDocs/topics/concat.md
+++ b/docs/StardustDocs/topics/concat.md
@@ -8,7 +8,7 @@ Returns [`DataFrame`](DataFrame.md) with the union of rows from several given [`
 
 [`DataFrame`](DataFrame.md):
 
-<!---FUN concatDfs-->
+<!---FUN concatDataFrames-->
 
 ```kotlin
 df.concat(df1, df2)
diff --git a/docs/StardustDocs/topics/concatDf.md b/docs/StardustDocs/topics/concatDf.md
index 5b30ccd43..7f93e31bb 100644
--- a/docs/StardustDocs/topics/concatDf.md
+++ b/docs/StardustDocs/topics/concatDf.md
@@ -4,7 +4,7 @@
 
 Returns [`DataFrame`](DataFrame.md) with the union of rows from several given [`DataFrames`](DataFrame.md).
 
-<!---FUN concatDfs-->
+<!---FUN concatDataFrames-->
 
 ```kotlin
 df.concat(df1, df2)
diff --git a/docs/StardustDocs/topics/convert.md b/docs/StardustDocs/topics/convert.md
index 8adf878aa..15f594404 100644
--- a/docs/StardustDocs/topics/convert.md
+++ b/docs/StardustDocs/topics/convert.md
@@ -18,7 +18,7 @@ See [column selectors](ColumnSelectors.md) and [row expressions](DataRow.md#row-
 
 ```kotlin
 df.convert { age }.with { it.toDouble() }
-df.convert { dfsOf<String>() }.with { it.toCharArray().toList() }
+df.convert { colsOf<String>().recursively() }.with { it.toCharArray().toList() }
 ```
 
 <dataFrame src="org.jetbrains.kotlinx.dataframe.samples.api.Modify.convert.html"/>
diff --git a/docs/StardustDocs/topics/move.md b/docs/StardustDocs/topics/move.md
index 70f9f9100..b5504ef90 100644
--- a/docs/StardustDocs/topics/move.md
+++ b/docs/StardustDocs/topics/move.md
@@ -43,7 +43,7 @@ df.move { name.cols() }.toTop()
 
 // a.b.e -> be
 // c.d.e -> de
-df.move { dfs { it.name() == "e" } }.toTop { it.parentName + it.name() }
+df.move { cols { it.name() == "e" }.recursively() }.toTop { it.parentName + it.name() }
 ```
 
 <dataFrame src="org.jetbrains.kotlinx.dataframe.samples.api.Modify.move.html"/>
diff --git a/docs/StardustDocs/topics/update.md b/docs/StardustDocs/topics/update.md
index d761790bf..860f15aef 100644
--- a/docs/StardustDocs/topics/update.md
+++ b/docs/StardustDocs/topics/update.md
@@ -23,7 +23,7 @@ See [column selectors](ColumnSelectors.md) and [row expressions](DataRow.md#row-
 
 ```kotlin
 df.update { age }.with { it * 2 }
-df.update { dfsOf<String>() }.with { it.uppercase() }
+df.update { colsOf<String>().recursively() }.with { it.uppercase() }
 df.update { weight }.at(1..4).notNull { it / 2 }
 df.update { name.lastName and age }.at(1, 3, 4).withNull()
 ```
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
index 810c6b955..6786230c8 100644
--- 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
@@ -2,24 +2,7 @@ package org.jetbrains.kotlinx.dataframe.examples.titanic.ml
 
 import org.jetbrains.kotlinx.dataframe.ColumnSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.api.by
-import org.jetbrains.kotlinx.dataframe.api.column
-import org.jetbrains.kotlinx.dataframe.api.convert
-import org.jetbrains.kotlinx.dataframe.api.dfsOf
-import org.jetbrains.kotlinx.dataframe.api.fillNulls
-import org.jetbrains.kotlinx.dataframe.api.getColumn
-import org.jetbrains.kotlinx.dataframe.api.into
-import org.jetbrains.kotlinx.dataframe.api.mean
-import org.jetbrains.kotlinx.dataframe.api.merge
-import org.jetbrains.kotlinx.dataframe.api.perCol
-import org.jetbrains.kotlinx.dataframe.api.pivotMatches
-import org.jetbrains.kotlinx.dataframe.api.remove
-import org.jetbrains.kotlinx.dataframe.api.select
-import org.jetbrains.kotlinx.dataframe.api.shuffle
-import org.jetbrains.kotlinx.dataframe.api.toFloat
-import org.jetbrains.kotlinx.dataframe.api.toFloatArray
-import org.jetbrains.kotlinx.dataframe.api.toTypedArray
-import org.jetbrains.kotlinx.dataframe.api.withValue
+import org.jetbrains.kotlinx.dataframe.api.*
 import org.jetbrains.kotlinx.dl.api.core.Sequential
 import org.jetbrains.kotlinx.dl.api.core.activation.Activations
 import org.jetbrains.kotlinx.dl.api.core.initializer.HeNormal
@@ -100,8 +83,8 @@ private fun <T> OnHeapDataset.Companion.create(
 
     fun extractX(): Array<FloatArray> =
         dataframe.remove(yColumn)
-            .convert { allDfs() }.toFloat()
-            .merge { dfsOf<Float>() }.by { it.toFloatArray() }.into(x)
+            .convert { cols { !it.isColumnGroup() }.rec() }.toFloat()
+            .merge { colsOf<Float>().recursively() }.by { it.toFloatArray() }.into(x)
             .getColumn(x).toTypedArray()
 
     fun extractY(): FloatArray = dataframe[yColumn].toFloatArray()
diff --git a/examples/idea-examples/youtube/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/youtube/youtube.kt b/examples/idea-examples/youtube/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/youtube/youtube.kt
index 8fb697b2c..911d75216 100644
--- a/examples/idea-examples/youtube/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/youtube/youtube.kt
+++ b/examples/idea-examples/youtube/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/youtube/youtube.kt
@@ -53,7 +53,7 @@ fun main() {
         .select { id.videoId into videoId and snippet }
         .distinct()
         .parse()
-        .convert { dfsOf<URL>() }.with {
+        .convert { colsOf<URL>().recursively() }.with {
             IMG(it, maxHeight = 150)
         }.add("video") {
             val id = videoId()
diff --git a/examples/notebooks/youtube/Youtube.ipynb b/examples/notebooks/youtube/Youtube.ipynb
index ee4512154..557518acd 100644
--- a/examples/notebooks/youtube/Youtube.ipynb
+++ b/examples/notebooks/youtube/Youtube.ipynb
@@ -607,7 +607,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "val loaded = parsed.convert { dfsOf<URL>() }.with { IMG(it, maxHeight = 150) }\n",
+    "val loaded = parsed.convert { colsOf<URL>().recursively() }.with { IMG(it, maxHeight = 150) }\n",
     "    .add(\"video\") { IFRAME(\"http://www.youtube.com/embed/$id\") }"
    ]
   },