3rd attempt, now with different return-type, similar to the first dfs-rename branch.

Author: Jolanrensen

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt

@@ -108,13 +108,6 @@ public class ColumnMatch<C>(public val left: ColumnReference<C>, public val righ
     override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> {
         throw UnsupportedOperationException()
     }
-
-    override fun resolveAfterTransform(
-        context: ColumnResolutionContext,
-        transformer: ColumnSetTransformer,
-    ): List<ColumnWithPath<C>> {
-        throw UnsupportedOperationException()
-    }
 }
 
 public typealias JoinColumnsSelector<A, B> = JoinDsl<A, B>.(ColumnsContainer<A>) -> ColumnSet<*>

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt

@@ -19,17 +19,31 @@ public interface ColumnSet<out C> {
      * the current [ColumnSet] result.
      */
     public fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>>
+}
 
-    /**
-     * Resolves this [ColumnSet] as a [List]<[ColumnWithPath]<[C]>> after applying [transformer] to the parent
-     * [ColumnSet]. This essentially injects a call right before the current in the [ColumnSet.resolve] chain.
-     */
-    public fun resolveAfterTransform(
+public interface ColumnSetWithRecursively<out C> : ColumnSet<C> {
+
+    public fun resolveRecursively(
         context: ColumnResolutionContext,
-        transformer: ColumnSetTransformer,
+        includeGroups: Boolean = true,
+        includeTopLevel: Boolean = true,
     ): List<ColumnWithPath<C>>
 }
 
+internal fun <C> ColumnSetWithRecursively<C>.recursivelyImpl(
+    includeGroups: Boolean = true,
+    includeTopLevel: Boolean = true,
+): ColumnSet<C> = object : ColumnSet<C> {
+
+    override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> =
+        this@recursivelyImpl.resolveRecursively(
+            context = context,
+            includeGroups = includeGroups,
+            includeTopLevel = includeTopLevel,
+        )
+}
+
+
 public fun interface ColumnSetTransformer {
 
     public fun transform(columnSet: ColumnSet<*>): ColumnSet<*>

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnSet.kt

@@ -16,16 +16,31 @@ public interface SingleColumn<out C> : ColumnSet<C> {
         context: ColumnResolutionContext,
     ): List<ColumnWithPath<C>> = resolveSingle(context)?.let { listOf(it) } ?: emptyList()
 
-    /** By default, we transform the current SingleColumn using the transformer and then resolve it */
-    override fun resolveAfterTransform(
-        context: ColumnResolutionContext,
-        transformer: ColumnSetTransformer,
-    ): List<ColumnWithPath<C>> =
-        transformer(this).resolve(context) as List<ColumnWithPath<C>>
-
     public fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>?
 }
 
+internal fun <C> SingleColumnWithRecursively<C>.recursivelyImpl(
+    includeGroups: Boolean = true,
+    includeTopLevel: Boolean = true,
+): SingleColumn<C> = object : SingleColumn<C> {
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>? =
+        this@recursivelyImpl.resolveSingleRecursively(
+            context = context,
+            includeGroups = includeGroups,
+            includeTopLevel = includeTopLevel,
+        )
+}
+
+public interface SingleColumnWithRecursively<out C> : SingleColumn<C> {
+
+    public fun resolveSingleRecursively(
+        context: ColumnResolutionContext,
+        includeGroups: Boolean = true,
+        includeTopLevel: Boolean = true,
+    ): ColumnWithPath<C>?
+}
+
 
 @OptIn(ExperimentalContracts::class)
 public fun ColumnSet<*>.isSingleColumn(): Boolean {

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/SingleColumn.kt

@@ -29,12 +29,6 @@ internal class ConfiguredAggregateColumn<C> private constructor(
     override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> =
         resolve(context, columns)
 
-    override fun resolveAfterTransform(
-        context: ColumnResolutionContext,
-        transformer: ColumnSetTransformer,
-    ): List<ColumnWithPath<C>> =
-        resolve(context, transformer.transform(columns).cast<C>())
-
     companion object {
 
         fun <C> withDefault(src: ColumnSet<C>, default: C?): ColumnSet<C> = when (src) {

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ConfiguredAggregateColumn.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.recursively(includeGroups = false) }
-            val rightColumns = other.getColumnsWithPaths { rightCol.recursively(includeGroups = false) }
+            val leftColumns = getColumnsWithPaths { leftCol.all().recursively(includeGroups = false) }
+            val rightColumns = other.getColumnsWithPaths { rightCol.all().recursively(includeGroups = false) }
 
             val leftPrefixLength = leftCol.path.size
             val rightPrefixLength = rightCol.path.size

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

@@ -47,13 +47,6 @@ internal class PivotChainColumnSet<C>(val first: ColumnSet<C>, val second: Colum
         }
         return result
     }
-
-    override fun resolveAfterTransform(
-        context: ColumnResolutionContext,
-        transformer: ColumnSetTransformer,
-    ): List<ColumnWithPath<C>> {
-        throw UnsupportedOperationException("Not implemented")
-    }
 }
 
 internal fun <T, C> DataFrame<T>.getPivotSequences(

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/pivot.kt

@@ -106,14 +106,6 @@ 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 resolveAfterTransform(
-        context: ColumnResolutionContext,
-        transformer: ColumnSetTransformer,
-    ): List<ColumnWithPath<C>> = column
-        .let { transformer.transform(it) as ColumnSet<C> }
-        .resolve(context)
-        .map { it.addFlag(flag) }
 }
 
 internal class SortColumnDescriptor<C>(

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/sort.kt

@@ -10,10 +10,4 @@ internal class ColumnsList<C>(val columns: List<ColumnSet<C>>) : ColumnSet<C> {
 
     override fun resolve(context: ColumnResolutionContext) =
         columns.flatMap { it.resolve(context) }
-
-    override fun resolveAfterTransform(
-        context: ColumnResolutionContext,
-        transformer: ColumnSetTransformer,
-    ): List<ColumnWithPath<C>> =
-        columns.flatMap { it.resolveAfterTransform(context, transformer) }
 }

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnsList.kt

@@ -8,9 +8,4 @@ import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
 internal class DistinctColumnSet<T>(val src: ColumnSet<T>) : ColumnSet<T> {
     override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<T>> =
         src.resolve(context).distinctBy { it.path }
-
-    override fun resolveAfterTransform(
-        context: ColumnResolutionContext,
-        transformer: ColumnSetTransformer,
-    ): List<ColumnWithPath<T>> = src.resolveAfterTransform(context, transformer).distinctBy { it.path }
 }