Rework of dfs functions to recursively (changing return type of recurse-able functions)

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,13 +131,23 @@ 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")
 
     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")
     }

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