seems to be working! In the process of converting dfs usage to recursively/rec

Author: Jolanrensen

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

@@ -107,14 +107,6 @@ public interface DataColumn<out T> : BaseColumn<T> {
 
     override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? = this.addPath()
 
-    override fun resolveSingleAfterTransform(
-        context: ColumnResolutionContext,
-        transformer: ColumnSetTransformer,
-    ): ColumnWithPath<T>? =
-        transformer.transformRemainingSingle(this).cast<T>()
-            .let { it as DataColumn<T> }
-            .addPath()
-
     override operator fun getValue(thisRef: Any?, property: KProperty<*>): DataColumn<T> =
         super.getValue(thisRef, property) as DataColumn<T>
 

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

@@ -734,9 +734,8 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
             override fun resolveAfterTransform(
                 context: ColumnResolutionContext,
                 transformer: ColumnSetTransformer,
-            ): List<ColumnWithPath<Any?>> =
-                process(transformer.transformRemainingSingle(this@rangeTo) as AnyColumnReference, context)
-        }
+            ): List<ColumnWithPath<Any?>> = throw UnsupportedOperationException("Not implemented")
+        }.wrap()
 
     /**
      * ## None
@@ -3908,21 +3907,21 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     @Deprecated(
         message = "dfs is deprecated, use recursively instead.",
-        replaceWith = ReplaceWith("this.cols(predicate).recursively(includeTopLevel = false)"),
+        replaceWith = ReplaceWith("this.cols(predicate).recursively(includeTopLevel = true)"),
         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(includeTopLevel = false)"),
+        replaceWith = ReplaceWith("this.cols(predicate).recursively(includeTopLevel = true)"),
         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(includeTopLevel = false)"),
+        replaceWith = ReplaceWith("this.cols(predicate).recursively(includeTopLevel = true)"),
         level = DeprecationLevel.WARNING,
     )
     public fun <C> KProperty<C>.dfs(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> =
@@ -3933,7 +3932,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     // region all
     public fun ColumnSet<*>.all(): ColumnSet<*> = wrap()
 
-    public fun SingleColumn<*>.all(): ColumnSet<*> = transformSingle { it.children() }.wrap()
+    public fun SingleColumn<*>.all(): ColumnSet<*> = transformSingle { it.children() }
 
     public fun String.all(): ColumnSet<*> = toColumnAccessor().all()
 
@@ -3943,22 +3942,22 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     @Deprecated(
         message = "allDfs is deprecated, use recursively instead.",
-        replaceWith = ReplaceWith("this.allRecursively(includeGroups = includeGroups, includeTopLevel = false)"),
+        replaceWith = ReplaceWith("this.all().recursively(includeGroups = includeGroups)"),
         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.allRecursively(includeGroups = includeGroups, includeTopLevel = false)"),
+        replaceWith = ReplaceWith("this.all().recursively(includeGroups = includeGroups)"),
         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.allRecursively(includeGroups = includeGroups, includeTopLevel = false)"),
+        replaceWith = ReplaceWith("this.all().recursively(includeGroups = includeGroups)"),
         level = DeprecationLevel.WARNING,
     )
     public fun KProperty<*>.allDfs(includeGroups: Boolean = false): ColumnSet<Any?> =
@@ -4000,25 +3999,26 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
         includeTopLevel: Boolean = true,
     ): ColumnSet<*> = recursively(includeTopLevel = includeTopLevel, includeGroups = includeGroups)
 
-    public fun <C> ColumnSet<C>.allRecursively(
+    public fun String.recursively(
         includeGroups: Boolean = true,
         includeTopLevel: Boolean = true,
-    ): ColumnSet<C> = wrap().recursivelyImpl(includeTopLevel = includeTopLevel, includeGroups = includeGroups)
+    ): ColumnSet<*> = toColumnAccessor().recursively(includeGroups, includeTopLevel)
 
-    public fun <C> ColumnSet<C>.allRec(
+    public fun String.rec(
         includeGroups: Boolean = true,
         includeTopLevel: Boolean = true,
-    ): ColumnSet<C> = allRecursively(includeTopLevel = includeTopLevel, includeGroups = includeGroups)
+    ): ColumnSet<*> = recursively(includeTopLevel = includeTopLevel, includeGroups = includeGroups)
 
-    public fun SingleColumn<*>.allRecursively(
+    public fun KProperty<*>.recursively(
         includeGroups: Boolean = true,
         includeTopLevel: Boolean = true,
-    ): ColumnSet<*> = all().recursivelyImpl(includeTopLevel = includeTopLevel, includeGroups = includeGroups)
+    ): ColumnSet<*> = toColumnAccessor().recursively(includeGroups, includeTopLevel)
 
-    public fun SingleColumn<*>.allRec(
+    public fun KProperty<*>.rec(
         includeGroups: Boolean = true,
         includeTopLevel: Boolean = true,
-    ): ColumnSet<*> = allRecursively(includeTopLevel = includeTopLevel, includeGroups = includeGroups)
+    ): ColumnSet<*> = recursively(includeTopLevel = includeTopLevel, includeGroups = includeGroups)
+
 
     // endregion
 
@@ -4431,7 +4431,7 @@ internal fun <T, C> ColumnsSelector<T, C>.filter(predicate: (ColumnWithPath<C>)
  */
 internal fun ColumnSet<*>.colsInternal(predicate: ColumnFilter<*>): ColumnSet<*> =
     transform {
-        if (this is SingleColumn<*> && it.singleOrNull()?.isColumnGroup() == true) {
+        if (isSingleColumn() && it.singleOrNull()?.isColumnGroup() == true) {
             it.single().children()
         } else {
             it

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() }

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
 

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

@@ -40,17 +40,16 @@ 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> {
-    return rename {
-        dfs { it.isColumnGroup() && it.name() matches DELIMITED_STRING_REGEX }
+public fun <T> DataFrame<T>.renameToCamelCase(): DataFrame<T> = this
+    .rename {
+        cols { it.isColumnGroup() && it.name() matches DELIMITED_STRING_REGEX }.rec()
     }.toCamelCase()
-        .rename {
-            dfs { !it.isColumnGroup() && it.name() matches DELIMITED_STRING_REGEX }
-        }.toCamelCase()
-        .update {
-            dfsOf<AnyFrame>()
-        }.with { it.renameToCamelCase() }
-}
+    .rename {
+        cols { !it.isColumnGroup() && it.name() matches DELIMITED_STRING_REGEX }.rec()
+    }.toCamelCase()
+    .update {
+        colsOf<AnyFrame>().rec()
+    }.with { it.renameToCamelCase() }
 
 public fun <T, C> RenameClause<T, C>.into(vararg newColumns: ColumnReference<*>): DataFrame<T> =
     into(*newColumns.map { it.name() }.toTypedArray())
@@ -59,6 +58,7 @@ public fun <T, C> RenameClause<T, C>.into(vararg newNames: String): DataFrame<T>
     df.move(columns).intoIndexed { col, index ->
         col.path.dropLast(1) + newNames[index]
     }
+
 public fun <T, C> RenameClause<T, C>.into(vararg newNames: KProperty<*>): DataFrame<T> =
     into(*newNames.map { it.name }.toTypedArray())
 

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

@@ -36,16 +36,6 @@ public interface ColumnReference<out C> : SingleColumn<C> {
         context.df
             .getColumn<C>(path(), context.unresolvedColumnsPolicy)
             ?.addPath(path())
-
-    override fun resolveSingleAfterTransform(
-        context: ColumnResolutionContext,
-        transformer: ColumnSetTransformer,
-    ): ColumnWithPath<C>? =
-        transformer.transformRemainingSingle(context.df.asColumnGroup()).cast<C>()
-            .resolve(context)
-            .toDataFrame()
-            .getColumn<C>(path(), context.unresolvedColumnsPolicy)
-            ?.addPath(path())
 }
 
 internal fun <C> ColumnReference<C>.renamedReference(newName: String): ColumnReference<C> =

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

@@ -32,9 +32,10 @@ public interface ColumnSet<out C> {
 
 public interface ColumnSetTransformer {
 
-    public fun transformRemainingSingle(singleColumn: SingleColumn<*>): SingleColumn<*>
+//    @Deprecated("see if this can be removed")
+//    public fun transformRemainingSingle(singleColumn: SingleColumn<*>): SingleColumn<*>
 
-    public fun transformSingle(singleColumn: SingleColumn<*>): ColumnSet<*>
+//    public fun transformSingle(singleColumn: SingleColumn<*>): ColumnSet<*>
 
     public fun transform(columnSet: ColumnSet<*>): ColumnSet<*>
 }

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

@@ -16,12 +16,12 @@ public interface SingleColumn<out C> : ColumnSet<C> {
     override fun resolveAfterTransform(
         context: ColumnResolutionContext,
         transformer: ColumnSetTransformer,
-    ): List<ColumnWithPath<C>> = resolveSingleAfterTransform(context, transformer)?.let { listOf(it) } ?: emptyList()
+    ): List<ColumnWithPath<C>> =
+        throw UnsupportedOperationException(
+            "SingleColumn.resolveAfterTransform is not supported because transformations can only be applied on normal ColumnSets. use '.wrap()' to wrap a SingleColumn into a ColumnSet"
+        )
 
     public fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>?
-
-    public fun resolveSingleAfterTransform(
-        context: ColumnResolutionContext,
-        transformer: ColumnSetTransformer,
-    ): ColumnWithPath<C>?
 }
+
+public fun ColumnSet<*>.isSingleColumn(): Boolean = this is SingleColumn<*>

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

@@ -55,18 +55,6 @@ internal open class DataFrameReceiver<T>(
     override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<DataRow<T>>? =
         DataColumn.createColumnGroup("", df).addPath(emptyPath())
 
-    override fun resolveSingleAfterTransform(
-        context: ColumnResolutionContext,
-        transformer: ColumnSetTransformer,
-    ): ColumnWithPath<DataRow<T>>? =
-        DataColumn.createColumnGroup(
-            name = "",
-            df = createColumnSet { df.columns().map { it.addPath() } }
-                .let(transformer::transform).cast<T>()
-                .resolve(context)
-                .toDataFrame() as DataFrame<T>,
-        ).addPath(emptyPath())
-
     override fun columns() =
         df.columns().map { if (it.isColumnGroup()) ColumnGroupWithParent(null, it.asColumnGroup()) else it }
 

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)
     }