From 1e856c06ac101788f68c7cf34bf041443c0007b6 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Fri, 28 Jun 2024 20:45:51 +0200
Subject: [PATCH] fixup! updating generated-sources

---
 core/build.gradle.kts                         |   7 +
 .../kotlinx/dataframe/api/DataRowApi.kt       |  29 +-
 .../kotlinx/dataframe/api/JsonPath.kt         |  15 +-
 .../kotlinx/dataframe/api/aggregate.kt        |   4 +-
 .../kotlinx/dataframe/api/allExcept.kt        |  17 +-
 .../jetbrains/kotlinx/dataframe/api/append.kt |  18 +-
 .../jetbrains/kotlinx/dataframe/api/col.kt    |  39 +-
 .../kotlinx/dataframe/api/colGroup.kt         |  38 +-
 .../jetbrains/kotlinx/dataframe/api/cols.kt   |  13 +-
 .../kotlinx/dataframe/api/colsOfKind.kt       |   5 +-
 .../kotlinx/dataframe/api/constructors.kt     |  53 +-
 .../kotlinx/dataframe/api/convert.kt          |   8 +-
 .../kotlinx/dataframe/api/digitize.kt         |   5 +-
 .../jetbrains/kotlinx/dataframe/api/filter.kt |   9 +-
 .../kotlinx/dataframe/api/frameCol.kt         |  46 +-
 .../jetbrains/kotlinx/dataframe/api/into.kt   |   3 +-
 .../jetbrains/kotlinx/dataframe/api/merge.kt  |   3 +-
 .../jetbrains/kotlinx/dataframe/api/move.kt   |   2 +-
 .../jetbrains/kotlinx/dataframe/api/rename.kt |  12 +-
 .../jetbrains/kotlinx/dataframe/api/select.kt |   3 +-
 .../jetbrains/kotlinx/dataframe/api/sort.kt   |  32 +-
 .../jetbrains/kotlinx/dataframe/api/split.kt  |   3 +-
 .../jetbrains/kotlinx/dataframe/api/std.kt    |  10 +-
 .../kotlinx/dataframe/api/valueCol.kt         |  49 +-
 .../dataframe/codeGen/DefaultReadDfMethods.kt |  31 +-
 .../kotlinx/dataframe/codeGen/Marker.kt       |   6 +-
 .../kotlinx/dataframe/codeGen/generateCode.kt |  17 +-
 .../kotlinx/dataframe/columns/SingleColumn.kt |   4 +-
 .../kotlinx/dataframe/dataTypes/IFRAME.kt     |   8 +-
 .../kotlinx/dataframe/impl/DataFrameImpl.kt   |   3 +-
 .../kotlinx/dataframe/impl/DataRowImpl.kt     |   8 +-
 .../kotlinx/dataframe/impl/GroupByImpl.kt     |  39 +-
 .../kotlinx/dataframe/impl/TypeUtils.kt       |  54 +-
 .../jetbrains/kotlinx/dataframe/impl/Utils.kt |   5 +-
 .../impl/aggregation/GroupByReceiverImpl.kt   |   4 +-
 .../impl/aggregation/PivotGroupByImpl.kt      |  13 +-
 .../dataframe/impl/aggregation/PivotImpl.kt   |   1 -
 .../impl/aggregation/aggregations.kt          |  10 +-
 .../dataframe/impl/aggregation/getColumns.kt  |   4 +-
 .../kotlinx/dataframe/impl/api/convert.kt     |  20 +-
 .../kotlinx/dataframe/impl/api/convertTo.kt   | 271 +++++----
 .../kotlinx/dataframe/impl/api/corr.kt        |  10 +-
 .../kotlinx/dataframe/impl/api/describe.kt    |  27 +-
 .../kotlinx/dataframe/impl/api/duplicate.kt   |  47 +-
 .../kotlinx/dataframe/impl/api/explode.kt     |  26 +-
 .../kotlinx/dataframe/impl/api/flatten.kt     |   3 +-
 .../kotlinx/dataframe/impl/api/format.kt      |   3 +-
 .../kotlinx/dataframe/impl/api/implode.kt     |  35 +-
 .../kotlinx/dataframe/impl/api/insert.kt      |  61 +-
 .../kotlinx/dataframe/impl/api/join.kt        |  10 +-
 .../kotlinx/dataframe/impl/api/joinWith.kt    |   7 +-
 .../kotlinx/dataframe/impl/api/move.kt        |  15 +-
 .../kotlinx/dataframe/impl/api/parse.kt       |   3 +-
 .../kotlinx/dataframe/impl/api/pivot.kt       |   4 +-
 .../kotlinx/dataframe/impl/api/remove.kt      |  14 +-
 .../kotlinx/dataframe/impl/api/rename.kt      |   3 +-
 .../kotlinx/dataframe/impl/api/reorder.kt     |   3 +-
 .../kotlinx/dataframe/impl/api/sort.kt        |  17 +-
 .../kotlinx/dataframe/impl/api/toDataFrame.kt |   8 +-
 .../kotlinx/dataframe/impl/api/update.kt      |   9 +-
 .../kotlinx/dataframe/impl/api/xs.kt          |  11 +-
 .../impl/codeGen/CodeGeneratorImpl.kt         |  69 +--
 .../impl/codeGen/SchemaProcessorImpl.kt       |   3 +-
 .../dataframe/impl/columns/AtAnyDepth.kt      |   3 +-
 .../impl/columns/ColumnAccessorImpl.kt        |  22 +-
 .../impl/columns/ColumnGroupWithPathImpl.kt   |   6 +-
 .../impl/columns/ComputedColumnReference.kt   |   5 +-
 .../kotlinx/dataframe/impl/columns/Utils.kt   |  27 +-
 .../dataframe/impl/columns/constructors.kt    |  30 +-
 .../dataframe/impl/columns/tree/Utils.kt      |   3 +-
 .../kotlinx/dataframe/impl/io/readJson.kt     |   7 +-
 .../kotlinx/dataframe/impl/io/writeJson.kt    |  32 +-
 .../kotlinx/dataframe/impl/schema/Utils.kt    |  14 +-
 .../jetbrains/kotlinx/dataframe/io/common.kt  |  19 +-
 .../org/jetbrains/kotlinx/dataframe/io/csv.kt |  24 +-
 .../jetbrains/kotlinx/dataframe/io/html.kt    |  24 +-
 .../jetbrains/kotlinx/dataframe/io/json.kt    |  11 +-
 .../jetbrains/kotlinx/dataframe/io/string.kt  |   3 +-
 .../kotlinx/dataframe/jupyter/CellRenderer.kt |   8 +-
 .../jupyter/KotlinNotebookPluginUtils.kt      |   7 +-
 .../dataframe/api/ColumnsSelectionDsl.kt      |   3 +-
 .../kotlinx/dataframe/api/colsAtAnyDepth.kt   |  29 +-
 .../kotlinx/dataframe/api/convertTo.kt        |   9 +-
 .../kotlinx/dataframe/api/distinct.kt         |  46 +-
 .../kotlinx/dataframe/api/explode.kt          |  12 +-
 .../kotlinx/dataframe/api/flatten.kt          |  18 +-
 .../jetbrains/kotlinx/dataframe/api/gather.kt |   7 +-
 .../jetbrains/kotlinx/dataframe/api/get.kt    |   7 +-
 .../kotlinx/dataframe/api/groupBy.kt          |  18 +-
 .../jetbrains/kotlinx/dataframe/api/move.kt   |   7 +-
 .../jetbrains/kotlinx/dataframe/api/pivot.kt  |   7 +-
 .../jetbrains/kotlinx/dataframe/api/rename.kt |  13 +-
 .../jetbrains/kotlinx/dataframe/api/split.kt  |  22 +-
 .../jetbrains/kotlinx/dataframe/api/toList.kt |   4 +-
 .../dataframe/codeGen/CodeGenerationTests.kt  |  38 +-
 .../dataframe/codeGen/NameGenerationTests.kt  |  19 +-
 .../explainer/PluginCallbackProxy.kt          |  35 +-
 .../kotlinx/dataframe/io/CsvTests.kt          |   3 +-
 .../kotlinx/dataframe/io/ParserTests.kt       |  36 +-
 .../kotlinx/dataframe/io/PlaylistJsonTest.kt  |  35 +-
 .../jetbrains/kotlinx/dataframe/io/json.kt    | 209 +++----
 .../dataframe/jupyter/RenderingTests.kt       |   6 +-
 .../dataframe/jupyter/SampleNotebooksTests.kt |  14 +-
 .../dataframe/puzzles/CleaningDataTests.kt    |  64 +--
 .../kotlinx/dataframe/puzzles/DateTests.kt    |  32 +-
 .../kotlinx/dataframe/puzzles/HardTests.kt    |  38 +-
 .../kotlinx/dataframe/puzzles/MediumTests.kt  |  14 +-
 .../dataframe/rendering/RenderingTests.kt     |  15 +-
 .../kotlinx/dataframe/samples/api/JoinWith.kt |  77 ++-
 .../kotlinx/dataframe/samples/api/TestBase.kt |  20 +-
 .../testSets/animals/AnimalsTests.kt          |   6 +-
 .../testSets/person/DataFrameTests.kt         | 539 ++++++------------
 .../testSets/person/DataFrameTreeTests.kt     |  98 +---
 .../dataframe/testSets/person/DataRowTests.kt |  40 +-
 .../testSets/person/FormattingTests.kt        |   7 +-
 .../dataframe/testSets/person/PivotTests.kt   | 102 ++--
 .../dataframe/testSets/person2/merge.kt       |   6 +-
 .../kotlinx/dataframe/impl/api/remove.kt      |   7 +-
 118 files changed, 1316 insertions(+), 1900 deletions(-)

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 4b88e3c656..3deb7bb460 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -216,6 +216,13 @@ val processKDocsMain by creatingProcessDocTask(processKDocsMainSources) {
     }
 }
 
+tasks.named("ktlintGeneratedSourcesSourceSetCheck") {
+    onlyIf { false }
+}
+tasks.named("runKtlintCheckOverGeneratedSourcesSourceSet") {
+    onlyIf { false }
+}
+
 // Exclude the generated/processed sources from the IDE
 idea {
     module {
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowApi.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowApi.kt
index 6989e315f6..568abfe0b9 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowApi.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowApi.kt
@@ -104,12 +104,8 @@ internal interface DiffOrNullDocs
 @OptIn(ExperimentalTypeInference::class)
 @OverloadResolutionByLambdaReturnType
 public fun <T> DataRow<T>.diff(firstRowResult: Double, expression: RowExpression<T, Double>): Double =
-    prev()?.let { p ->
-        expression(
-            this,
-            this,
-        ) - expression(p, p)
-    } ?: firstRowResult
+    prev()?.let { p -> expression(this, this) - expression(p, p) }
+        ?: firstRowResult
 
 /**
  * Calculates the difference between the results of a row expression computed on the current and previous DataRow.
@@ -120,12 +116,8 @@ public fun <T> DataRow<T>.diff(firstRowResult: Double, expression: RowExpression
 @OverloadResolutionByLambdaReturnType
 // required to resolve `diff(0) { intValue }`
 public fun <T> DataRow<T>.diff(firstRowResult: Int, expression: RowExpression<T, Int>): Int =
-    prev()?.let { p ->
-        expression(
-            this,
-            this,
-        ) - expression(p, p)
-    } ?: firstRowResult
+    prev()?.let { p -> expression(this, this) - expression(p, p) }
+        ?: firstRowResult
 
 /**
  * Calculates the difference between the results of a row expression computed on the current and previous DataRow.
@@ -133,7 +125,8 @@ public fun <T> DataRow<T>.diff(firstRowResult: Int, expression: RowExpression<T,
  * @return [firstRowValue] for the first row; difference between expression computed for current and previous row for the following rows
  */
 public fun <T> DataRow<T>.diff(firstRowResult: Long, expression: RowExpression<T, Long>): Long =
-    prev()?.let { p -> expression(this, this) - expression(p, p) } ?: firstRowResult
+    prev()?.let { p -> expression(this, this) - expression(p, p) }
+        ?: firstRowResult
 
 /**
  * Calculates the difference between the results of a row expression computed on the current and previous DataRow.
@@ -141,7 +134,8 @@ public fun <T> DataRow<T>.diff(firstRowResult: Long, expression: RowExpression<T
  * @return [firstRowValue] for the first row; difference between expression computed for current and previous row for the following rows
  */
 public fun <T> DataRow<T>.diff(firstRowResult: Float, expression: RowExpression<T, Float>): Float =
-    prev()?.let { p -> expression(this, this) - expression(p, p) } ?: firstRowResult
+    prev()?.let { p -> expression(this, this) - expression(p, p) }
+        ?: firstRowResult
 
 /**
  * Calculates the difference between the results of a row expression computed on the current and previous DataRow.
@@ -151,12 +145,7 @@ public fun <T> DataRow<T>.diff(firstRowResult: Float, expression: RowExpression<
 @OptIn(ExperimentalTypeInference::class)
 @OverloadResolutionByLambdaReturnType
 public fun <T> DataRow<T>.diffOrNull(expression: RowExpression<T, Double>): Double? =
-    prev()?.let { p ->
-        expression(
-            this,
-            this,
-        ) - expression(p, p)
-    }
+    prev()?.let { p -> expression(this, this) - expression(p, p) }
 
 /**
  * Calculates the difference between the results of a row expression computed on the current and previous DataRow.
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/JsonPath.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/JsonPath.kt
index b5c89ef927..0150eb2bc4 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/JsonPath.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/JsonPath.kt
@@ -29,14 +29,13 @@ public value class JsonPath(
         JsonPath(
             path.toCharArray().let { chars ->
                 val lastStarIndex = chars.lastIndexOf('*')
-                chars
-                    .flatMapIndexed { i, c ->
-                        if (i == lastStarIndex) {
-                            index.toString().toCharArray().toList()
-                        } else {
-                            listOf(c)
-                        }
-                    }.joinToString("")
+                chars.flatMapIndexed { i, c ->
+                    if (i == lastStarIndex) {
+                        index.toString().toCharArray().toList()
+                    } else {
+                        listOf(c)
+                    }
+                }.joinToString("")
             },
         )
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/aggregate.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/aggregate.kt
index 3f84a6cb86..0c592a4316 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/aggregate.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/aggregate.kt
@@ -21,6 +21,4 @@ public fun <T, R> Pivot<T>.aggregate(separate: Boolean = false, body: Selector<A
 @Refine
 @Interpretable("Aggregate")
 public fun <T, R> Grouped<T>.aggregate(body: AggregateGroupedBody<T, R>): DataFrame<T> =
-    aggregateGroupBy((this as GroupBy<*, *>).toDataFrame(), {
-        groups.cast()
-    }, removeColumns = true, body).cast<T>()
+    aggregateGroupBy((this as GroupBy<*, *>).toDataFrame(), { groups.cast() }, removeColumns = true, body).cast<T>()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/allExcept.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/allExcept.kt
index f0050f0bb2..582be9bdf1 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/allExcept.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/allExcept.kt
@@ -4663,17 +4663,16 @@ internal fun SingleColumn<DataRow<*>>.allColsExceptInternal(other: ColumnsResolv
 internal fun <C> SingleColumn<DataRow<C>>.exceptExperimentalInternal(
     other: ColumnsResolver<*>,
 ): SingleColumn<DataRow<C>> =
-    ensureIsColumnGroup()
-        .transformSingle { singleCol ->
-            val columnsToExcept = singleCol
-                .asColumnGroup()
-                .getColumnsWithPaths { other }
-                .map { it.changePath(singleCol.path + it.path) }
+    ensureIsColumnGroup().transformSingle { singleCol ->
+        val columnsToExcept = singleCol
+            .asColumnGroup()
+            .getColumnsWithPaths { other }
+            .map { it.changePath(singleCol.path + it.path) }
 
-            val newCols = listOf(singleCol).allColumnsExceptKeepingStructure(columnsToExcept)
+        val newCols = listOf(singleCol).allColumnsExceptKeepingStructure(columnsToExcept)
 
-            newCols as List<ColumnWithPath<DataRow<*>>>
-        }.singleInternal() as SingleColumn<DataRow<C>>
+        newCols as List<ColumnWithPath<DataRow<*>>>
+    }.singleInternal() as SingleColumn<DataRow<C>>
 
 /**
  * Functions annotated with this annotation are experimental and will be removed or renamed in the future.
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/append.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/append.kt
index d342b89470..6825337f62 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/append.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/append.kt
@@ -14,23 +14,19 @@ public fun <T> DataFrame<T>.append(vararg values: Any?): DataFrame<T> {
         "Invalid number of arguments. Multiple of $ncol is expected, but actual was: ${values.size}"
     }
     val newRows = values.size / ncol
-    return columns()
-        .mapIndexed { colIndex, col ->
-            val newValues = (0 until newRows).map { values[colIndex + it * ncol] }
-            col.updateWith(col.values + newValues)
-        }.toDataFrame()
-        .cast()
+    return columns().mapIndexed { colIndex, col ->
+        val newValues = (0 until newRows).map { values[colIndex + it * ncol] }
+        col.updateWith(col.values + newValues)
+    }.toDataFrame().cast()
 }
 
 public fun <T> DataFrame<T>.appendNulls(numberOfRows: Int = 1): DataFrame<T> {
     require(numberOfRows >= 0)
     if (numberOfRows == 0) return this
     if (ncol == 0) return DataFrame.empty(nrow + numberOfRows).cast()
-    return columns()
-        .map { col ->
-            col.updateWith(col.values + arrayOfNulls(numberOfRows))
-        }.toDataFrame()
-        .cast()
+    return columns().map { col ->
+        col.updateWith(col.values + arrayOfNulls(numberOfRows))
+    }.toDataFrame().cast()
 }
 
 // endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/col.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/col.kt
index 02dae70118..813aa781c6 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/col.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/col.kt
@@ -338,13 +338,11 @@ public interface ColColumnsSelectionDsl<out _UNUSED> {
      * @param [C] The type of the column.
      */
     public fun <C> SingleColumn<DataRow<*>>.col(col: ColumnAccessor<C>): SingleColumn<C> =
-        this
-            .ensureIsColumnGroup()
-            .transformSingle {
-                val child = it.getCol(col)
-                    ?: throw IllegalStateException("Column '${col.path()}' not found in column group '${it.path}'")
-                listOf(child)
-            }.singleImpl()
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(col)
+                ?: throw IllegalStateException("Column '${col.path()}' not found in column group '${it.path}'")
+            listOf(child)
+        }.singleImpl()
 
     /**
      * ## Col
@@ -814,13 +812,11 @@ public interface ColColumnsSelectionDsl<out _UNUSED> {
      * @param [C] The type of the column.
      */
     public fun <C> SingleColumn<DataRow<*>>.col(name: String): SingleColumn<C> =
-        this
-            .ensureIsColumnGroup()
-            .transformSingle {
-                val child = it.getCol(name)?.cast<C>()
-                    ?: throw IllegalStateException("Column '$name' not found in column group '${it.path}'")
-                listOf(child)
-            }.singleImpl()
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(name)?.cast<C>()
+                ?: throw IllegalStateException("Column '$name' not found in column group '${it.path}'")
+            listOf(child)
+        }.singleImpl()
 
     /**
      * ## Col
@@ -1511,13 +1507,11 @@ public interface ColColumnsSelectionDsl<out _UNUSED> {
      * @param [C] The type of the column.
      */
     public fun <C> SingleColumn<DataRow<*>>.col(path: ColumnPath): SingleColumn<C> =
-        this
-            .ensureIsColumnGroup()
-            .transformSingle {
-                val child = it.getCol(path)?.cast<C>()
-                    ?: throw IllegalStateException("Column '$path' not found in column group '${it.path}'")
-                listOf(child)
-            }.singleImpl()
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(path)?.cast<C>()
+                ?: throw IllegalStateException("Column '$path' not found in column group '${it.path}'")
+            listOf(child)
+        }.singleImpl()
 
     /**
      * ## Col
@@ -2679,8 +2673,7 @@ public interface ColColumnsSelectionDsl<out _UNUSED> {
      * @param [C] The type of the column.
      */
     public fun <C> SingleColumn<DataRow<*>>.col(index: Int): SingleColumn<C> =
-        this
-            .ensureIsColumnGroup()
+        this.ensureIsColumnGroup()
             .allColumnsInternal()
             .getAt(index)
             .cast()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroup.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroup.kt
index bda2b6a195..da08ed0b49 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroup.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroup.kt
@@ -345,16 +345,14 @@ public interface ColGroupColumnsSelectionDsl<out _UNUSED> {
      * @param [C] The type of the column group.
      */
     public fun <C> SingleColumn<DataRow<*>>.colGroup(colGroup: ColumnAccessor<DataRow<C>>): SingleColumn<DataRow<C>> =
-        this
-            .ensureIsColumnGroup()
-            .transformSingle {
-                val child = it.getCol(colGroup)
-                    ?: throw IllegalStateException(
-                        "ColumnGroup '${colGroup.path()}' not found in column group '${it.path}'",
-                    )
-                child.data.ensureIsColumnGroup()
-                listOf(child)
-            }.singleImpl()
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(colGroup)
+                ?: throw IllegalStateException(
+                    "ColumnGroup '${colGroup.path()}' not found in column group '${it.path}'",
+                )
+            child.data.ensureIsColumnGroup()
+            listOf(child)
+        }.singleImpl()
 
     /**
      * ## Col Group
@@ -842,14 +840,12 @@ public interface ColGroupColumnsSelectionDsl<out _UNUSED> {
      * @param [C] The type of the column group.
      */
     public fun <C> SingleColumn<DataRow<*>>.colGroup(name: String): SingleColumn<DataRow<C>> =
-        this
-            .ensureIsColumnGroup()
-            .transformSingle {
-                val child = it.getCol(name)?.cast<DataRow<C>>()
-                    ?: throw IllegalStateException("Column group '$name' not found in column group '${it.path}'")
-                child.data.ensureIsColumnGroup()
-                listOf(child)
-            }.singleImpl()
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(name)?.cast<DataRow<C>>()
+                ?: throw IllegalStateException("Column group '$name' not found in column group '${it.path}'")
+            child.data.ensureIsColumnGroup()
+            listOf(child)
+        }.singleImpl()
 
     /**
      * ## Col Group
@@ -1565,8 +1561,7 @@ public interface ColGroupColumnsSelectionDsl<out _UNUSED> {
      * @param [C] The type of the column group.
      */
     public fun <C> SingleColumn<DataRow<*>>.colGroup(path: ColumnPath): SingleColumn<DataRow<C>> =
-        this
-            .ensureIsColumnGroup()
+        this.ensureIsColumnGroup()
             .transformSingle {
                 val child = it.getCol(path)?.cast<DataRow<C>>()
                     ?: throw IllegalStateException("Column group '$path' not found in column group '${it.path}'")
@@ -3110,8 +3105,7 @@ public interface ColGroupColumnsSelectionDsl<out _UNUSED> {
      * @param [C] The type of the column group.
      */
     public fun <C> SingleColumn<DataRow<*>>.colGroup(index: Int): SingleColumn<DataRow<C>> =
-        this
-            .ensureIsColumnGroup()
+        this.ensureIsColumnGroup()
             .allColumnsInternal()
             .getAt(index)
             .cast<DataRow<C>>()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cols.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cols.kt
index 064b30b66e..ddf58b840b 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cols.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cols.kt
@@ -4893,14 +4893,13 @@ public interface ColsColumnsSelectionDsl<out _UNUSED> {
 }
 
 internal fun SingleColumn<DataRow<*>>.colsInternal(refs: Iterable<ColumnReference<*>>): ColumnSet<*> =
-    ensureIsColumnGroup()
-        .transformSingle { col ->
-            refs.map {
-                col.getCol(it) ?: throw IllegalArgumentException(
-                    "Column at ${col.path.plus(it.path()).joinToString()} was not found.",
-                )
-            }
+    ensureIsColumnGroup().transformSingle { col ->
+        refs.map {
+            col.getCol(it) ?: throw IllegalArgumentException(
+                "Column at ${col.path.plus(it.path()).joinToString()} was not found.",
+            )
         }
+    }
 
 /**
  * If this [ColumnsResolver] is a [SingleColumn], it
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOfKind.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOfKind.kt
index 0f409276a1..6a103d9c25 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOfKind.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOfKind.kt
@@ -397,9 +397,6 @@ public interface ColsOfKindColumnsSelectionDsl {
 internal fun ColumnsResolver<*>.columnsOfKindInternal(
     kinds: Set<ColumnKind>,
     filter: ColumnFilter<*>,
-): TransformableColumnSet<*> =
-    colsInternal {
-        it.kind() in kinds && filter(it)
-    }
+): TransformableColumnSet<*> = colsInternal { it.kind() in kinds && filter(it) }
 
 // endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/constructors.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/constructors.kt
index 68a3bfadeb..497959e7c8 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/constructors.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/constructors.kt
@@ -227,19 +227,18 @@ public fun columnOf(vararg values: AnyBaseCol): DataColumn<AnyRow> = columnOf(va
 public fun <T> columnOf(vararg frames: DataFrame<T>): FrameColumn<T> = columnOf(frames.asIterable()).forceResolve()
 
 public fun columnOf(columns: Iterable<AnyBaseCol>): DataColumn<AnyRow> =
-    DataColumn
-        .createColumnGroup(
-            name = "",
-            df = dataFrameOf(columns),
-        ).asDataColumn()
+    DataColumn.createColumnGroup(
+        name = "",
+        df = dataFrameOf(columns),
+    )
+        .asDataColumn()
         .forceResolve()
 
 public fun <T> columnOf(frames: Iterable<DataFrame<T>>): FrameColumn<T> =
-    DataColumn
-        .createFrameColumn(
-            name = "",
-            groups = frames.toList(),
-        ).forceResolve()
+    DataColumn.createFrameColumn(
+        name = "",
+        groups = frames.toList(),
+    ).forceResolve()
 
 public inline fun <reified T> column(values: Iterable<T>): DataColumn<T> =
     createColumn(values, typeOf<T>(), false).forceResolve()
@@ -283,15 +282,11 @@ public fun dataFrameOf(header: Iterable<String>, values: Iterable<Any?>): AnyFra
     dataFrameOf(header).withValues(values)
 
 public inline fun <T, reified C> dataFrameOf(header: Iterable<T>, fill: (T) -> Iterable<C>): AnyFrame =
-    header
-        .map { value ->
-            fill(value).asList().let {
-                DataColumn.create(
-                    value.toString(),
-                    it,
-                )
-            }
-        }.toDataFrame()
+    header.map { value ->
+        fill(value).asList().let {
+            DataColumn.create(value.toString(), it)
+        }
+    }.toDataFrame()
 
 public fun dataFrameOf(header: CharProgression): DataFrameBuilder = dataFrameOf(header.map { it.toString() })
 
@@ -302,10 +297,9 @@ public class DataFrameBuilder(private val header: List<String>) {
     public operator fun invoke(columns: Iterable<AnyCol>): AnyFrame {
         val cols = columns.asList()
         require(cols.size == header.size) { "Number of columns differs from number of column names" }
-        return cols
-            .mapIndexed { i, col ->
-                col.rename(header[i])
-            }.toDataFrame()
+        return cols.mapIndexed { i, col ->
+            col.rename(header[i])
+        }.toDataFrame()
     }
 
     public operator fun invoke(vararg values: Any?): AnyFrame = withValues(values.asIterable())
@@ -322,13 +316,12 @@ public class DataFrameBuilder(private val header: List<String>) {
 
         val nrow = list.size / ncol
 
-        return (0 until ncol)
-            .map { col ->
-                val colValues = (0 until nrow).map { row ->
-                    list[row * ncol + col]
-                }
-                DataColumn.createWithTypeInference(header[col], colValues)
-            }.toDataFrame()
+        return (0 until ncol).map { col ->
+            val colValues = (0 until nrow).map { row ->
+                list[row * ncol + col]
+            }
+            DataColumn.createWithTypeInference(header[col], colValues)
+        }.toDataFrame()
     }
 
     public operator fun invoke(args: Sequence<Any?>): AnyFrame = invoke(*args.toList().toTypedArray())
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt
index d0c9a5b8ea..f60cbb2bec 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt
@@ -120,11 +120,9 @@ public inline fun <T, C, reified R> Convert<T, C>.perRowCol(
 public inline fun <reified C> AnyCol.convertTo(): DataColumn<C> = convertTo(typeOf<C>()) as DataColumn<C>
 
 public fun AnyCol.convertTo(newType: KType): AnyCol {
-    val isTypesAreCorrect = this
-        .type()
-        .withNullability(true)
-        .isSubtypeOf(typeOf<String?>()) &&
-        newType.withNullability(true) == typeOf<Double?>()
+    val isTypesAreCorrect =
+        this.type().withNullability(true).isSubtypeOf(typeOf<String?>()) &&
+            newType.withNullability(true) == typeOf<Double?>()
 
     if (isTypesAreCorrect) {
         return (this as DataColumn<String?>).convertToDouble().setNullable(newType.isMarkedNullable)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/digitize.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/digitize.kt
index c4daf65d07..da118b3230 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/digitize.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/digitize.kt
@@ -17,10 +17,7 @@ public fun <T : Comparable<T>> DataColumn<T>.digitize(
     right: Boolean = false,
 ): DataColumn<Int> =
     digitize(
-        bins = bins.toList().map {
-            org.jetbrains.kotlinx.dataframe.impl
-                .convert(it, kclass)
-        },
+        bins = bins.toList().map { org.jetbrains.kotlinx.dataframe.impl.convert(it, kclass) },
         right = right,
     )
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/filter.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/filter.kt
index e10a657c00..06c410ee09 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/filter.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/filter.kt
@@ -30,11 +30,10 @@ public fun <T> DataColumn<T>.filter(predicate: Predicate<T>): DataColumn<T> =
 // region DataFrame
 
 public fun <T> DataFrame<T>.filter(predicate: RowFilter<T>): DataFrame<T> =
-    indices
-        .filter {
-            val row = get(it)
-            predicate(row, row)
-        }.let { get(it) }
+    indices.filter {
+        val row = get(it)
+        predicate(row, row)
+    }.let { get(it) }
 
 public fun <T> DataFrame<T>.filterBy(column: ColumnSelector<T, Boolean>): DataFrame<T> =
     getRows(getColumn(column).toList().getTrueIndices())
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCol.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCol.kt
index d99f7c1c15..1536ac368e 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCol.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCol.kt
@@ -347,16 +347,14 @@ public interface FrameColColumnsSelectionDsl<out _UNUSED> {
     public fun <C> SingleColumn<DataRow<*>>.frameCol(
         frameCol: ColumnAccessor<DataFrame<C>>,
     ): SingleColumn<DataFrame<C>> =
-        this
-            .ensureIsColumnGroup()
-            .transformSingle {
-                val child = it.getCol(frameCol)
-                    ?: throw IllegalStateException(
-                        "FrameColumn '${frameCol.path()}' not found in column group '${it.path}'",
-                    )
-                child.data.ensureIsFrameColumn()
-                listOf(child)
-            }.singleImpl()
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(frameCol)
+                ?: throw IllegalStateException(
+                    "FrameColumn '${frameCol.path()}' not found in column group '${it.path}'",
+                )
+            child.data.ensureIsFrameColumn()
+            listOf(child)
+        }.singleImpl()
 
     /**
      * ## Frame Col
@@ -845,14 +843,12 @@ public interface FrameColColumnsSelectionDsl<out _UNUSED> {
      * @param [C] The type of the frame column.
      */
     public fun <C> SingleColumn<DataRow<*>>.frameCol(name: String): SingleColumn<DataFrame<C>> =
-        this
-            .ensureIsColumnGroup()
-            .transformSingle {
-                val child = it.getCol(name)?.cast<DataFrame<C>>()
-                    ?: throw IllegalStateException("Frame column '$name' not found in column group '${it.path}'")
-                child.data.ensureIsFrameColumn()
-                listOf(child)
-            }.singleImpl()
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(name)?.cast<DataFrame<C>>()
+                ?: throw IllegalStateException("Frame column '$name' not found in column group '${it.path}'")
+            child.data.ensureIsFrameColumn()
+            listOf(child)
+        }.singleImpl()
 
     /**
      * ## Frame Col
@@ -1568,14 +1564,12 @@ public interface FrameColColumnsSelectionDsl<out _UNUSED> {
      * @param [C] The type of the frame column.
      */
     public fun <C> SingleColumn<DataRow<*>>.frameCol(path: ColumnPath): SingleColumn<DataFrame<C>> =
-        this
-            .ensureIsColumnGroup()
-            .transformSingle {
-                val child = it.getCol(path)?.cast<DataFrame<C>>()
-                    ?: throw IllegalStateException("Frame column '$path' not found in column group '${it.path}'")
-                child.data.ensureIsFrameColumn()
-                listOf(child)
-            }.singleImpl()
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(path)?.cast<DataFrame<C>>()
+                ?: throw IllegalStateException("Frame column '$path' not found in column group '${it.path}'")
+            child.data.ensureIsFrameColumn()
+            listOf(child)
+        }.singleImpl()
 
     /**
      * ## Frame Col
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/into.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/into.kt
index f0ed8fa52f..7026b72e47 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/into.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/into.kt
@@ -75,8 +75,7 @@ public fun <T, G> ReducedGroupBy<T, G>.into(column: ColumnAccessor<AnyRow>): Dat
 public fun <T, G> ReducedGroupBy<T, G>.into(column: KProperty<AnyRow>): DataFrame<G> = into(column) { this }
 
 public fun <T, G> ReducedGroupBy<T, G>.concat(): DataFrame<G> =
-    groupBy.groups
-        .values()
+    groupBy.groups.values()
         .map { reducer(it, it) }
         .concat()
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/merge.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/merge.kt
index 8475e990fe..1dd19d24c1 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/merge.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/merge.kt
@@ -73,8 +73,7 @@ public fun <T, C, R> Merge<T, C, R>.into(path: ColumnPath): DataFrame<T> {
         res = res
             .removeImpl(allowMissingColumns = true) { path }
             .df
-            .move(mergePath)
-            .into { path }
+            .move(mergePath).into { path }
     }
     return res
 }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
index 530d48f211..7bd545d2aa 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
@@ -111,7 +111,7 @@ public fun <T, C> MoveClause<T, C>.under(
 ): DataFrame<T> =
     moveImpl(
         under = true,
-        column,
+        newPathExpression = column,
     )
 
 // endregion
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 5d8c0f16c8..0904549ceb 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
@@ -46,11 +46,10 @@ public data class RenameClause<T, C>(val df: DataFrame<T>, val columns: ColumnsS
  * Even [DataFrames][DataFrame] inside [FrameColumns][FrameColumn] are traversed recursively.
  */
 public fun <T> DataFrame<T>.renameToCamelCase(): DataFrame<T> =
-    this
-        // recursively rename all columns written with delimiters or starting with a capital to camel case
-        .rename {
-            colsAtAnyDepth { it.name() matches DELIMITED_STRING_REGEX || it.name[0].isUpperCase() }
-        }.toCamelCase()
+    // recursively rename all columns written with delimiters or starting with a capital to camel case
+    rename {
+        colsAtAnyDepth { it.name() matches DELIMITED_STRING_REGEX || it.name[0].isUpperCase() }
+    }.toCamelCase()
         // take all frame columns at any depth and call renameToCamelCase() on all dataframes inside
         .update {
             colsAtAnyDepth().colsOf<AnyFrame>()
@@ -77,8 +76,7 @@ public fun <T, C> RenameClause<T, C>.into(transform: (ColumnWithPath<C>) -> Stri
  */
 public fun <T, C> RenameClause<T, C>.toCamelCase(): DataFrame<T> =
     into {
-        it
-            .name()
+        it.name()
             .toCamelCaseByDelimiters(DELIMITERS_REGEX)
             .replaceFirstChar { it.lowercaseChar() }
     }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt
index b162d24c39..a630a739c3 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt
@@ -560,8 +560,7 @@ internal fun <C, R> SingleColumn<DataRow<C>>.selectInternal(selector: ColumnsSel
                 "Column ${col.path} is not a ColumnGroup and can thus not be selected from."
             }
 
-            col
-                .asColumnGroup()
+            col.asColumnGroup()
                 .getColumnsWithPaths(selector as ColumnsSelector<*, R>)
                 .map { it.changePath(col.path + it.path) }
         } ?: emptyList()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sort.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sort.kt
index 9a365741de..8169368c17 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sort.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sort.kt
@@ -211,29 +211,26 @@ private fun <T, G, C> GroupBy<T, G>.createColumnFromGroupExpression(
     receiver: ColumnsSelectionDsl<T>,
     expression: DataFrameExpression<G, C>,
 ): DataColumn<C?> =
-    receiver
-        .newColumnWithActualType("") { row ->
-            val group = row[groups]
-            expression(group, group)
-        }
+    receiver.newColumnWithActualType("") { row ->
+        val group = row[groups]
+        expression(group, group)
+    }
 
 public fun <T, G, C> GroupBy<T, G>.sortByGroup(
     nullsLast: Boolean = false,
     expression: DataFrameExpression<G, C>,
 ): GroupBy<T, G> =
-    toDataFrame()
-        .sortBy {
-            createColumnFromGroupExpression(this, expression).nullsLast(nullsLast)
-        }.asGroupBy(groups)
+    toDataFrame().sortBy {
+        createColumnFromGroupExpression(this, expression).nullsLast(nullsLast)
+    }.asGroupBy(groups)
 
 public fun <T, G, C> GroupBy<T, G>.sortByGroupDesc(
     nullsLast: Boolean = false,
     expression: DataFrameExpression<G, C>,
 ): GroupBy<T, G> =
-    toDataFrame()
-        .sortBy {
-            createColumnFromGroupExpression(this, expression).desc().nullsLast(nullsLast)
-        }.asGroupBy(groups)
+    toDataFrame().sortBy {
+        createColumnFromGroupExpression(this, expression).desc().nullsLast(nullsLast)
+    }.asGroupBy(groups)
 
 public fun <T, G> GroupBy<T, G>.sortByCountAsc(): GroupBy<T, G> = sortByGroup { nrow }
 
@@ -241,13 +238,8 @@ public fun <T, G> GroupBy<T, G>.sortByCount(): GroupBy<T, G> = sortByGroupDesc {
 
 public fun <T, G> GroupBy<T, G>.sortByKeyDesc(nullsLast: Boolean = false): GroupBy<T, G> =
     toDataFrame()
-        .sortBy {
-            keys
-                .columns()
-                .toColumnSet()
-                .desc()
-                .nullsLast(nullsLast)
-        }.asGroupBy(groups)
+        .sortBy { keys.columns().toColumnSet().desc().nullsLast(nullsLast) }
+        .asGroupBy(groups)
 
 public fun <T, G> GroupBy<T, G>.sortByKey(nullsLast: Boolean = false): GroupBy<T, G> =
     toDataFrame()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/split.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/split.kt
index 6005a9b629..aea9b261c9 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/split.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/split.kt
@@ -114,8 +114,7 @@ public fun <T, C : String?> Split<T, C>.match(regex: String): SplitWithTransform
 public fun <T, C : String?> Split<T, C>.match(regex: Regex): SplitWithTransform<T, C, String?> =
     by {
         it?.let {
-            regex
-                .matchEntire(it)
+            regex.matchEntire(it)
                 ?.groups
                 ?.drop(1)
                 ?.map { it?.value }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/std.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/std.kt
index 8eb3f9f6ae..af6a07ca71 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/std.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/std.kt
@@ -40,10 +40,12 @@ public fun AnyRow.rowStd(skipNA: Boolean = skipNA_default, ddof: Int = ddof_defa
     values().filterIsInstance<Number>().map { it.toDouble() }.std(skipNA, ddof)
 
 public inline fun <reified T : Number> AnyRow.rowStdOf(ddof: Int = ddof_default): Double =
-    values().filterIsInstance<T>().std(
-        type = typeOf<T>(),
-        ddof = ddof,
-    )
+    values()
+        .filterIsInstance<T>()
+        .std(
+            type = typeOf<T>(),
+            ddof = ddof,
+        )
 
 // endregion
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCol.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCol.kt
index 6eaa1c7080..82a2abf914 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCol.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCol.kt
@@ -345,16 +345,14 @@ public interface ValueColColumnsSelectionDsl<out _UNUSED> {
      * @param [C] The type of the value column.
      */
     public fun <C> SingleColumn<DataRow<*>>.valueCol(valueCol: ColumnAccessor<C>): SingleColumn<C> =
-        this
-            .ensureIsColumnGroup()
-            .transformSingle {
-                val child = it.getCol(valueCol)
-                    ?: throw IllegalStateException(
-                        "ValueColumn '${valueCol.path()}' not found in column group '${it.path}'",
-                    )
-                child.data.ensureIsValueColumn()
-                listOf(child)
-            }.singleImpl()
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(valueCol)
+                ?: throw IllegalStateException(
+                    "ValueColumn '${valueCol.path()}' not found in column group '${it.path}'",
+                )
+            child.data.ensureIsValueColumn()
+            listOf(child)
+        }.singleImpl()
 
     /**
      * ## Value Col
@@ -842,14 +840,12 @@ public interface ValueColColumnsSelectionDsl<out _UNUSED> {
      * @param [C] The type of the value column.
      */
     public fun <C> SingleColumn<DataRow<*>>.valueCol(name: String): SingleColumn<C> =
-        this
-            .ensureIsColumnGroup()
-            .transformSingle {
-                val child = it.getCol(name)?.cast<C>()
-                    ?: throw IllegalStateException("Value column '$name' not found in column group '${it.path}'")
-                child.data.ensureIsValueColumn()
-                listOf(child)
-            }.singleImpl()
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(name)?.cast<C>()
+                ?: throw IllegalStateException("Value column '$name' not found in column group '${it.path}'")
+            child.data.ensureIsValueColumn()
+            listOf(child)
+        }.singleImpl()
 
     /**
      * ## Value Col
@@ -1565,14 +1561,12 @@ public interface ValueColColumnsSelectionDsl<out _UNUSED> {
      * @param [C] The type of the value column.
      */
     public fun <C> SingleColumn<DataRow<*>>.valueCol(path: ColumnPath): SingleColumn<C> =
-        this
-            .ensureIsColumnGroup()
-            .transformSingle {
-                val child = it.getCol(path)?.cast<C>()
-                    ?: throw IllegalStateException("Value column '$path' not found in column group '${it.path}'")
-                child.data.ensureIsValueColumn()
-                listOf(child)
-            }.singleImpl()
+        this.ensureIsColumnGroup().transformSingle {
+            val child = it.getCol(path)?.cast<C>()
+                ?: throw IllegalStateException("Value column '$path' not found in column group '${it.path}'")
+            child.data.ensureIsValueColumn()
+            listOf(child)
+        }.singleImpl()
 
     /**
      * ## Value Col
@@ -2720,8 +2714,7 @@ public interface ValueColColumnsSelectionDsl<out _UNUSED> {
      * @param [C] The type of the value column.
      */
     public fun <C> SingleColumn<DataRow<*>>.valueCol(index: Int): SingleColumn<C> =
-        this
-            .ensureIsColumnGroup()
+        this.ensureIsColumnGroup()
             .allColumnsInternal()
             .getAt(index)
             .ensureIsValueColumn()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/DefaultReadDfMethods.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/DefaultReadDfMethods.kt
index c9b2729b58..6ecb10a3cc 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/DefaultReadDfMethods.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/DefaultReadDfMethods.kt
@@ -33,15 +33,13 @@ public abstract class AbstractDefaultReadMethod(
 ) : DefaultReadDfMethod {
     override fun toDeclaration(marker: Marker, visibility: String): String {
         val parameters = arguments.defaultValues.map {
-            ParameterSpec
-                .builder(it.name, it.property.type)
+            ParameterSpec.builder(it.name, it.property.type)
                 .defaultValue("%N", it.property)
                 .build()
         }
 
         val defaultPath = path?.let {
-            PropertySpec
-                .builder("defaultPath", typeNameOf<String>(), KModifier.CONST)
+            PropertySpec.builder("defaultPath", typeNameOf<String>(), KModifier.CONST)
                 .initializer("%S", path)
                 .build()
         }
@@ -50,32 +48,27 @@ public abstract class AbstractDefaultReadMethod(
 
         val arguments = parameters.joinToString(", ") { "${it.name} = ${it.name}" }
 
-        val typeSpec = TypeSpec
-            .companionObjectBuilder()
-            .apply {
-                if (defaultPath != null) {
-                    addProperty(defaultPath)
-                }
-            }.addProperties(this.arguments.defaultValues.map { it.property })
+        val typeSpec = TypeSpec.companionObjectBuilder()
+            .apply { if (defaultPath != null) addProperty(defaultPath) }
+            .addProperties(this.arguments.defaultValues.map { it.property })
             .addFunction(
-                FunSpec
-                    .builder(methodName)
+                FunSpec.builder(methodName)
                     .returns(type)
                     .addParameter(
-                        ParameterSpec
-                            .builder("path", typeNameOf<String>())
+                        ParameterSpec.builder("path", typeNameOf<String>())
                             .apply {
                                 if (defaultPath != null) {
                                     defaultValue("%N", defaultPath)
                                 }
                             }.build(),
-                    ).addParameters(parameters)
+                    )
+                    .addParameters(parameters)
                     .addParameter(
-                        ParameterSpec
-                            .builder("verify", typeNameOf<Boolean?>())
+                        ParameterSpec.builder("verify", typeNameOf<Boolean?>())
                             .defaultValue("null")
                             .build(),
-                    ).addCode(
+                    )
+                    .addCode(
                         """
                         val df = DataFrame.$methodName(path, $arguments)
                         return if ($VERIFY != null) df.$CAST($VERIFY = $VERIFY) else df.$CAST()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/Marker.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/Marker.kt
index 1578223424..d52bd63051 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/Marker.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/Marker.kt
@@ -88,11 +88,7 @@ public open class Marker(
     public val columnNames: List<String> get() = allFields.map { it.columnName }
 
     public val schema: DataFrameSchema by lazy {
-        DataFrameSchemaImpl(
-            allFields.associate {
-                it.columnName to it.columnSchema
-            },
-        )
+        DataFrameSchemaImpl(allFields.associate { it.columnName to it.columnSchema })
     }
 
     public fun implements(schema: Marker): Boolean =
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/generateCode.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/generateCode.kt
index 0efb80ee8a..50aa2fa4e7 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/generateCode.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/generateCode.kt
@@ -23,15 +23,14 @@ public fun <T> DataFrame<T>.generateCode(
     visibility: MarkerVisibility = MarkerVisibility.IMPLICIT_PUBLIC,
 ): String {
     val codeGen = CodeGenerator.create()
-    return codeGen
-        .generate(
-            schema = schema(),
-            name = markerName,
-            fields = fields,
-            extensionProperties = extensionProperties,
-            isOpen = true,
-            visibility = visibility,
-        ).code.declarations
+    return codeGen.generate(
+        schema = schema(),
+        name = markerName,
+        fields = fields,
+        extensionProperties = extensionProperties,
+        isOpen = true,
+        visibility = visibility,
+    ).code.declarations
 }
 
 public inline fun <reified T> DataFrame<T>.generateInterfaces(): String =
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 333333d814..e8d0e048be 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
@@ -17,7 +17,9 @@ import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableSingleColumn
 public interface SingleColumn<out C> : ColumnsResolver<C> {
 
     override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> =
-        resolveSingle(context)?.let { listOf(it) } ?: emptyList()
+        resolveSingle(context)
+            ?.let { listOf(it) }
+            ?: emptyList()
 
     public fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>?
 }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/dataTypes/IFRAME.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/dataTypes/IFRAME.kt
index edf89577c8..547544576d 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/dataTypes/IFRAME.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/dataTypes/IFRAME.kt
@@ -16,7 +16,9 @@ public data class IFRAME(
     ) : this(src.toString(), border, width, height)
 
     override fun toString(): String =
-        """<iframe src="$src" frameborder=${if (border) 1 else 0 }${width?.let {
-            " width=$it"
-        } ?: ""}${height?.let { " height=$it" } ?: ""}/>"""
+        """<iframe src="$src" frameborder=${if (border) 1 else 0}${
+            width?.let { " width=$it" } ?: ""
+        }${
+            height?.let { " height=$it" } ?: ""
+        }/>"""
 }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameImpl.kt
index 23e74c7069..c80d8ebb97 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameImpl.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameImpl.kt
@@ -138,8 +138,7 @@ internal open class DataFrameImpl<T>(cols: List<AnyCol>, val nrow: Int) :
             1 -> getColumnOrNull(path[0])
 
             else ->
-                path
-                    .dropLast(1)
+                path.dropLast(1)
                     .fold(this as AnyFrame?) { df, name -> df?.getColumnOrNull(name) as? AnyFrame? }
                     ?.getColumnOrNull(path.last())
         }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataRowImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataRowImpl.kt
index f479aab54b..e81558550f 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataRowImpl.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataRowImpl.kt
@@ -60,5 +60,11 @@ internal val <T> DataRow<T>.owner: DataFrame<T> get() = df()
 
 internal fun AnyRow.namedValues(): Sequence<NamedValue> =
     owner.columns().asSequence().map {
-        NamedValue.create(it.shortPath(), it[index], it.type(), it.defaultValue(), guessType = false)
+        NamedValue.create(
+            path = it.shortPath(),
+            value = it[index],
+            type = it.type(),
+            defaultValue = it.defaultValue(),
+            guessType = false,
+        )
     }
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 1a09aa5071..848c3043f2 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
@@ -72,27 +72,26 @@ internal fun <T, G, R> aggregateGroupBy(
 
     val hasKeyColumns = removed.df.ncol > 0
 
-    val groupedFrame = column.values
-        .map {
-            if (it == null) {
-                null
-            } else {
-                val builder = GroupByReceiverImpl(it, hasKeyColumns)
-                val result = body(builder, builder)
-                if (result != Unit && result !is NamedValue && result !is AggregatedPivot<*>) {
-                    builder.yield(
-                        NamedValue.create(
-                            path = pathOf(defaultAggregateName),
-                            value = result,
-                            type = null,
-                            defaultValue = null,
-                            guessType = true,
-                        ),
-                    )
-                }
-                builder.compute()
+    val groupedFrame = column.values.map {
+        if (it == null) {
+            null
+        } else {
+            val builder = GroupByReceiverImpl(it, hasKeyColumns)
+            val result = body(builder, builder)
+            if (result != Unit && result !is NamedValue && result !is AggregatedPivot<*>) {
+                builder.yield(
+                    NamedValue.create(
+                        path = pathOf(defaultAggregateName),
+                        value = result,
+                        type = null,
+                        defaultValue = null,
+                        guessType = true,
+                    ),
+                )
             }
-        }.concat()
+            builder.compute()
+        }
+    }.concat()
 
     val removedNode = removed.removedColumns.single()
     val insertPath = removedNode.pathFromRoot().dropLast(1)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/TypeUtils.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/TypeUtils.kt
index 248a899bc9..b38acb2270 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/TypeUtils.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/TypeUtils.kt
@@ -227,19 +227,17 @@ internal fun commonParents(classes: Iterable<KClass<*>>): List<KClass<*>> =
                         it.size == 1 && it[0].visibility == KVisibility.PUBLIC -> listOf(it[0])
 
                         else ->
-                            it
-                                .fold(null as (Set<KClass<*>>?)) { set, clazz ->
-                                    // collect a set of all common superclasses from original classes
-                                    val superclasses =
-                                        (clazz.allSuperclasses + clazz)
-                                            .filter { it.visibility == KVisibility.PUBLIC }
-                                            .toSet()
-                                    set?.intersect(superclasses) ?: superclasses
-                                }!!
-                                .let {
-                                    // leave only 'leaf' classes, that are not super to some other class in a set
-                                    it - it.flatMap { it.superclasses }.toSet()
-                                }.toList()
+                            it.fold(null as (Set<KClass<*>>?)) { set, clazz ->
+                                // collect a set of all common superclasses from original classes
+                                val superclasses =
+                                    (clazz.allSuperclasses + clazz)
+                                        .filter { it.visibility == KVisibility.PUBLIC }
+                                        .toSet()
+                                set?.intersect(superclasses) ?: superclasses
+                            }!!.let {
+                                // leave only 'leaf' classes, that are not super to some other class in a set
+                                it - it.flatMap { it.superclasses }.toSet()
+                            }.toList()
                     }
                 }
         }
@@ -268,14 +266,13 @@ internal fun Iterable<KType>.commonTypeListifyValues(useStar: Boolean = true): K
         distinct.size == 1 -> distinct.single()
 
         else -> {
-            val classes = distinct
-                .map {
-                    if (it == nothingType(false) || it == nothingType(true)) {
-                        Nothing::class
-                    } else {
-                        it.jvmErasure
-                    }
-                }.distinct()
+            val classes = distinct.map {
+                if (it == nothingType(false) || it == nothingType(true)) {
+                    Nothing::class
+                } else {
+                    it.jvmErasure
+                }
+            }.distinct()
             when {
                 classes.size == 1 -> {
                     val typeProjections = classes.single().typeParameters.mapIndexed { index, parameter ->
@@ -300,14 +297,13 @@ internal fun Iterable<KType>.commonTypeListifyValues(useStar: Boolean = true): K
                     val distinctNoNothing = distinct.filterNot {
                         it == nothingType(false) || it == nothingType(true)
                     }
-                    val listTypes = distinctNoNothing
-                        .map {
-                            if (it.classifier == List::class) {
-                                it.arguments[0].type
-                            } else {
-                                it
-                            }
-                        }.toMutableSet()
+                    val listTypes = distinctNoNothing.map {
+                        if (it.classifier == List::class) {
+                            it.arguments[0].type
+                        } else {
+                            it
+                        }
+                    }.toMutableSet()
                     val type = listTypes
                         .filterNotNull()
                         .commonTypeListifyValues()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Utils.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Utils.kt
index dbb6c87c45..08490f973f 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Utils.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Utils.kt
@@ -351,9 +351,8 @@ internal fun String.toSnakeCase(): String =
     }
 
 internal fun List<String>.joinToCamelCaseString(): String =
-    joinToString(separator = "") {
-        it.replaceFirstChar { it.uppercaseChar() }
-    }.replaceFirstChar { it.lowercaseChar() }
+    joinToString(separator = "") { it.replaceFirstChar { it.uppercaseChar() } }
+        .replaceFirstChar { it.lowercaseChar() }
 
 /** Returns `true` if this callable is a getter-like function.
  *
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/GroupByReceiverImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/GroupByReceiverImpl.kt
index 182fd1bdb3..171403c4f8 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/GroupByReceiverImpl.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/GroupByReceiverImpl.kt
@@ -104,9 +104,7 @@ internal class GroupByReceiverImpl<T>(override val df: DataFrame<T>, override va
                 val dropFirstNameInPath =
                     pivot.inward == true &&
                         value.path.isNotEmpty() &&
-                        pivot.aggregator.values
-                            .distinctBy { it.path.firstOrNull() }
-                            .count() == 1
+                        pivot.aggregator.values.distinctBy { it.path.firstOrNull() }.count() == 1
                 pivot.aggregator.values.forEach {
                     val targetPath =
                         if (dropFirstNameInPath && it.path.size > 0) {
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotGroupByImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotGroupByImpl.kt
index b1235310c2..7e7168e864 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotGroupByImpl.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotGroupByImpl.kt
@@ -23,18 +23,15 @@ internal data class PivotGroupByImpl<T>(
 ) : PivotGroupBy<T>,
     AggregatableInternal<T> {
     override fun <R> aggregate(separate: Boolean, body: AggregateBody<T, R>): DataFrame<T> =
-        df
-            .aggregate {
-                aggregatePivot(this as GroupByReceiverImpl<T>, columns, separate, inward, default, body)
-            }.cast()
+        df.aggregate {
+            aggregatePivot(this as GroupByReceiverImpl<T>, columns, separate, inward, default, body)
+        }.cast()
 
     override fun default(value: Any?) = copy(default = value)
 
     override fun remainingColumnsSelector(): ColumnsSelector<*, *> =
-        df.groups
-            .firstOrNull()
-            ?.getPivotColumnPaths(columns)
-            .orEmpty()
+        df.groups.firstOrNull()
+            ?.getPivotColumnPaths(columns).orEmpty()
             .let { pivotPaths ->
                 {
                     all().except(
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotImpl.kt
index 03716da62e..2a3bc93676 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotImpl.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotImpl.kt
@@ -6,7 +6,6 @@ import org.jetbrains.kotlinx.dataframe.api.Pivot
 import org.jetbrains.kotlinx.dataframe.api.PivotColumnsSelector
 import org.jetbrains.kotlinx.dataframe.api.PivotGroupBy
 import org.jetbrains.kotlinx.dataframe.api.groupBy
-import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
 
 internal data class PivotImpl<T>(val df: DataFrame<T>, val columns: PivotColumnsSelector<T, *>, val inward: Boolean?) :
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregations.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregations.kt
index e508ff61d6..67809f6da7 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregations.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregations.kt
@@ -62,17 +62,9 @@ internal fun <T, C> AggregateInternalDsl<T>.columnValues(
         val effectiveDropNA = if (dropNA) col.canHaveNA else false
         // TODO: use Set for distinct values
         val values = when {
-            effectiveDropNA && distinct ->
-                col
-                    .asSequence()
-                    .filter { !it.isNA }
-                    .distinct()
-                    .toList()
-
+            effectiveDropNA && distinct -> col.asSequence().filter { !it.isNA }.distinct().toList()
             effectiveDropNA && !distinct -> col.values.filter { !it.isNA }
-
             distinct -> col.values().distinct()
-
             else -> col.toList()
         }
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/getColumns.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/getColumns.kt
index 991e0b0dc0..46dd1129f1 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/getColumns.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/getColumns.kt
@@ -14,9 +14,7 @@ internal inline fun <T> Aggregatable<T>.remainingColumns(
 ): ColumnsSelector<T, Any?> = remainingColumnsSelector().filter { predicate(it.data) }
 
 internal fun <T> Aggregatable<T>.comparableColumns() =
-    remainingColumns {
-        it.isComparable()
-    } as ColumnsSelector<T, Comparable<Any?>>
+    remainingColumns { it.isComparable() } as ColumnsSelector<T, Comparable<Any?>>
 
 internal fun <T> Aggregatable<T>.numberColumns() = remainingColumns { it.isNumber() } as ColumnsSelector<T, Number?>
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convert.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convert.kt
index 50e3a52f92..e5b2b8e240 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convert.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convert.kt
@@ -104,14 +104,13 @@ internal fun AnyCol.convertToTypeImpl(to: KType): AnyCol {
                     // find converter for every value
                     val values = values.mapIndexed { row, value ->
                         currentRow = row
-                        value
-                            ?.let {
-                                val clazz = it.javaClass.kotlin
-                                val type = clazz.createStarProjectedType(false)
-                                val converter = getConverter(type, to, ParserOptions(locale = Locale.getDefault()))
-                                    ?: throw TypeConverterNotFoundException(from, to, path)
-                                converter(it)
-                            }.checkNulls()
+                        value?.let {
+                            val clazz = it.javaClass.kotlin
+                            val type = clazz.createStarProjectedType(false)
+                            val converter = getConverter(type, to, ParserOptions(locale = Locale.getDefault()))
+                                ?: throw TypeConverterNotFoundException(from, to, path)
+                            converter(it)
+                        }.checkNulls()
                     }
                     DataColumn.createValueColumn(name, values, to.withNullability(nullsFound))
                 }
@@ -225,9 +224,8 @@ internal fun createConverter(from: KType, to: KType, options: ParserOptions? = n
             val converter = getConverter(underlyingType, to)
                 ?: throw TypeConverterNotFoundException(underlyingType, to, null)
             val property =
-                fromClass.memberProperties.single {
-                    it.name == constructorParameter.name
-                } as kotlin.reflect.KProperty1<Any, *>
+                fromClass.memberProperties
+                    .single { it.name == constructorParameter.name } as kotlin.reflect.KProperty1<Any, *>
             if (property.visibility != kotlin.reflect.KVisibility.PUBLIC) {
                 throw TypeConversionException(
                     "Not public member property in primary constructor of value type",
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convertTo.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convertTo.kt
index 0652f13e23..7e4c1a31fa 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convertTo.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convertTo.kt
@@ -106,167 +106,164 @@ internal fun AnyFrame.convertToImpl(
         }
 
         val visited = mutableSetOf<String>()
-        val newColumns = columns()
-            .mapNotNull { originalColumn ->
-                val targetSchema = schema.columns[originalColumn.name()]
-                if (targetSchema == null) {
-                    when (excessiveColumns) {
-                        ExcessiveColumns.Fail -> throw ExcessiveColumnsException(listOf(originalColumn.name))
-                        ExcessiveColumns.Keep -> originalColumn
-                        ExcessiveColumns.Remove -> null
+        val newColumns = columns().mapNotNull { originalColumn ->
+            val targetSchema = schema.columns[originalColumn.name()]
+            if (targetSchema == null) {
+                when (excessiveColumns) {
+                    ExcessiveColumns.Fail -> throw ExcessiveColumnsException(listOf(originalColumn.name))
+                    ExcessiveColumns.Keep -> originalColumn
+                    ExcessiveColumns.Remove -> null
+                }
+            } else {
+                visited.add(originalColumn.name())
+                val currentSchema = originalColumn.extractSchema()
+                when {
+                    targetSchema == currentSchema -> originalColumn
+
+                    !allowConversion -> {
+                        val originalSchema = mapOf(originalColumn.name to currentSchema)
+                            .render(0, StringBuilder(), "\t")
+
+                        val targetSchema = mapOf(originalColumn.name to targetSchema)
+                            .render(0, StringBuilder(), "\t")
+
+                        throw IllegalArgumentException(
+                            "Column has schema:\n $originalSchema\n that differs from target schema:\n $targetSchema",
+                        )
                     }
-                } else {
-                    visited.add(originalColumn.name())
-                    val currentSchema = originalColumn.extractSchema()
-                    when {
-                        targetSchema == currentSchema -> originalColumn
-
-                        !allowConversion -> {
-                            val originalSchema = mapOf(originalColumn.name to currentSchema)
-                                .render(0, StringBuilder(), "\t")
-
-                            val targetSchema = mapOf(originalColumn.name to targetSchema)
-                                .render(0, StringBuilder(), "\t")
-
-                            throw IllegalArgumentException(
-                                "Column has schema:\n $originalSchema\n that differs from target schema:\n $targetSchema",
-                            )
-                        }
-
-                        else -> {
-                            val columnPath = path + originalColumn.name
-
-                            // try to perform any user-specified conversions first
-                            val from = originalColumn.type()
-                            val to = targetSchema.type
-                            val converter = dsl.getConverter(from, targetSchema)
-
-                            val convertedColumn = if (converter != null) {
-                                val nullsAllowed = to.isMarkedNullable
-                                originalColumn.map(to, Infer.Nulls) {
-                                    val result =
-                                        if (it != null || !converter.skipNulls) {
-                                            converter.transform(ConverterScope(from, targetSchema), it)
-                                        } else {
-                                            it
-                                        }
 
-                                    if (!nullsAllowed && result == null) {
-                                        throw TypeConversionException(
-                                            value = it,
-                                            from = from,
-                                            to = to,
-                                            column = originalColumn.path(),
-                                        )
+                    else -> {
+                        val columnPath = path + originalColumn.name
+
+                        // try to perform any user-specified conversions first
+                        val from = originalColumn.type()
+                        val to = targetSchema.type
+                        val converter = dsl.getConverter(from, targetSchema)
+
+                        val convertedColumn = if (converter != null) {
+                            val nullsAllowed = to.isMarkedNullable
+                            originalColumn.map(to, Infer.Nulls) {
+                                val result =
+                                    if (it != null || !converter.skipNulls) {
+                                        converter.transform(ConverterScope(from, targetSchema), it)
+                                    } else {
+                                        it
                                     }
 
-                                    result
+                                if (!nullsAllowed && result == null) {
+                                    throw TypeConversionException(
+                                        value = it,
+                                        from = from,
+                                        to = to,
+                                        column = originalColumn.path(),
+                                    )
                                 }
-                            } else {
-                                null
+
+                                result
                             }
+                        } else {
+                            null
+                        }
 
-                            when (targetSchema.kind) {
-                                ColumnKind.Value ->
-                                    convertedColumn ?: originalColumn.convertTo(to)
-
-                                ColumnKind.Group -> {
-                                    val column = when {
-                                        convertedColumn != null -> convertedColumn
-
-                                        // Value column of DataRows (if it ever occurs) can be converted to a group column
-                                        originalColumn.kind == ColumnKind.Value &&
-                                            originalColumn.all {
-                                                it is DataRow<*>
-                                            } ->
-                                            DataColumn.createColumnGroup(
-                                                name = originalColumn.name,
-                                                df = originalColumn
-                                                    .values()
-                                                    .let { it as Iterable<DataRow<*>> }
-                                                    .toDataFrame(),
-                                            ) as DataColumn<*>
-
-                                        // Value column of nulls can be converted to an empty group column
-                                        originalColumn.kind == ColumnKind.Value && originalColumn.allNulls() ->
-                                            DataColumn.createColumnGroup(
-                                                name = originalColumn.name,
-                                                df = DataFrame.empty(nrow = originalColumn.size),
-                                            ) as DataColumn<*>
-
-                                        else -> originalColumn
-                                    }
-                                    require(column.kind == ColumnKind.Group) {
-                                        "Column `${column.name}` is ${column.kind} and can not be converted to `ColumnGroup`"
-                                    }
-                                    val columnGroup = column.asColumnGroup()
-
-                                    DataColumn.createColumnGroup(
-                                        name = column.name(),
-                                        df = columnGroup.convertToSchema(
-                                            schema = (targetSchema as ColumnSchema.Group).schema,
-                                            path = columnPath,
-                                        ),
-                                    )
+                        when (targetSchema.kind) {
+                            ColumnKind.Value ->
+                                convertedColumn ?: originalColumn.convertTo(to)
+
+                            ColumnKind.Group -> {
+                                val column = when {
+                                    convertedColumn != null -> convertedColumn
+
+                                    // Value column of DataRows (if it ever occurs) can be converted to a group column
+                                    originalColumn.kind == ColumnKind.Value &&
+                                        originalColumn.all { it is DataRow<*> } ->
+                                        DataColumn.createColumnGroup(
+                                            name = originalColumn.name,
+                                            df = originalColumn.values()
+                                                .let { it as Iterable<DataRow<*>> }
+                                                .toDataFrame(),
+                                        ) as DataColumn<*>
+
+                                    // Value column of nulls can be converted to an empty group column
+                                    originalColumn.kind == ColumnKind.Value && originalColumn.allNulls() ->
+                                        DataColumn.createColumnGroup(
+                                            name = originalColumn.name,
+                                            df = DataFrame.empty(nrow = originalColumn.size),
+                                        ) as DataColumn<*>
+
+                                    else -> originalColumn
+                                }
+                                require(column.kind == ColumnKind.Group) {
+                                    "Column `${column.name}` is ${column.kind} and can not be converted to `ColumnGroup`"
                                 }
+                                val columnGroup = column.asColumnGroup()
+
+                                DataColumn.createColumnGroup(
+                                    name = column.name(),
+                                    df = columnGroup.convertToSchema(
+                                        schema = (targetSchema as ColumnSchema.Group).schema,
+                                        path = columnPath,
+                                    ),
+                                )
+                            }
 
-                                ColumnKind.Frame -> {
-                                    val column = convertedColumn ?: originalColumn
-                                    val frameSchema = (targetSchema as ColumnSchema.Frame).schema
-
-                                    val frames = when (column.kind) {
-                                        ColumnKind.Frame ->
-                                            (column as FrameColumn<*>).values()
-
-                                        ColumnKind.Value -> {
-                                            require(
-                                                column.all {
-                                                    it == null ||
-                                                        it is AnyFrame ||
-                                                        (it is List<*> && it.all { it is AnyRow? })
-                                                },
-                                            ) {
-                                                "Column `${column.name}` is ValueColumn and contains objects that can not be converted into `DataFrame`"
-                                            }
-                                            column.values().map {
-                                                when (it) {
-                                                    null -> emptyDataFrame()
-                                                    is AnyFrame -> it
-                                                    else -> (it as List<AnyRow?>).concat()
-                                                }
+                            ColumnKind.Frame -> {
+                                val column = convertedColumn ?: originalColumn
+                                val frameSchema = (targetSchema as ColumnSchema.Frame).schema
+
+                                val frames = when (column.kind) {
+                                    ColumnKind.Frame ->
+                                        (column as FrameColumn<*>).values()
+
+                                    ColumnKind.Value -> {
+                                        require(
+                                            column.all {
+                                                it == null ||
+                                                    it is AnyFrame ||
+                                                    (it is List<*> && it.all { it is AnyRow? })
+                                            },
+                                        ) {
+                                            "Column `${column.name}` is ValueColumn and contains objects that can not be converted into `DataFrame`"
+                                        }
+                                        column.values().map {
+                                            when (it) {
+                                                null -> emptyDataFrame()
+                                                is AnyFrame -> it
+                                                else -> (it as List<AnyRow?>).concat()
                                             }
                                         }
+                                    }
 
-                                        ColumnKind.Group -> {
-                                            (column as ColumnGroup<*>).values().map { it.toDataFrame() }
-                                        }
+                                    ColumnKind.Group -> {
+                                        (column as ColumnGroup<*>).values().map { it.toDataFrame() }
                                     }
+                                }
 
-                                    val convertedFrames = frames.map { it.convertToSchema(frameSchema, columnPath) }
+                                val convertedFrames = frames.map { it.convertToSchema(frameSchema, columnPath) }
 
-                                    DataColumn.createFrameColumn(
-                                        name = column.name(),
-                                        groups = convertedFrames,
-                                        schema = lazy { frameSchema },
-                                    )
-                                }
+                                DataColumn.createFrameColumn(
+                                    name = column.name(),
+                                    groups = convertedFrames,
+                                    schema = lazy { frameSchema },
+                                )
                             }
                         }
                     }
                 }
-            }.toMutableList()
+            }
+        }.toMutableList()
 
         // when the target is nullable but the source does not contain a column, fill it in with nulls / empty dataframes
         val size = this.size.nrow
         schema.columns.forEach { (name, targetColumn) ->
             val isNullable =
+                // like value column of type Int?
                 targetColumn.nullable ||
-                    // like value column of type Int?
-                    targetColumn.type.isMarkedNullable ||
                     // like value column of type Int? (backup check)
-                    targetColumn.contentType?.isMarkedNullable == true ||
+                    targetColumn.type.isMarkedNullable ||
                     // like DataRow<Something?> for a group column (all columns in the group will be nullable)
-                    targetColumn.kind == ColumnKind.Frame // frame column can be filled with empty dataframes
+                    targetColumn.contentType?.isMarkedNullable == true ||
+                    // frame column can be filled with empty dataframes
+                    targetColumn.kind == ColumnKind.Frame
 
             if (name !in visited) {
                 newColumns += targetColumn.createEmptyColumn(name, size)
@@ -292,9 +289,9 @@ internal fun AnyFrame.convertToImpl(
 
     if (missingPaths.isNotEmpty()) {
         throw IllegalArgumentException(
-            "The following columns were not found in DataFrame: ${missingPaths.map {
-                it.joinToString()
-            }}, and their type was not nullable. Use `fill` to initialize these columns",
+            "The following columns were not found in DataFrame: ${
+                missingPaths.map { it.joinToString() }
+            }, and their type was not nullable. Use `fill` to initialize these columns",
         )
     }
 
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 2db668c1f3..5796de0978 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
@@ -31,12 +31,10 @@ internal fun <T, C, R> Corr<T, C>.corrImpl(otherColumns: ColumnsSelector<T, R>):
             }
         }
 
-    var cols1 = df
-        .getColumnsWithPaths(columns)
+    var cols1 = df.getColumnsWithPaths(columns)
         .filter { it.isColumnGroup() || it.isSuitableForCorr() }
 
-    val cols2 = df
-        .getColumnsWithPaths(otherColumns)
+    val cols2 = df.getColumnsWithPaths(otherColumns)
         .filter { it.isColumnGroup() || it.isSuitableForCorr() }
         .unpackColumnGroups()
 
@@ -68,8 +66,8 @@ internal fun <T, C, R> Corr<T, C>.corrImpl(otherColumns: ColumnsSelector<T, R>):
                 val s2 = stdMeans[c2.path]!!
                 val v1 = cols[c1.path]!!
                 val v2 = cols[c2.path]!!
-                val res =
-                    (0 until len).sumOf { (v1[it] - s1.mean) * (v2[it] - s2.mean) } / sqrt(s1.variance * s2.variance)
+                val res = (0 until len)
+                    .sumOf { (v1[it] - s1.mean) * (v2[it] - s2.mean) } / sqrt(s1.variance * s2.variance)
                 cache[c1.path to c2.path] = res
                 res
             }
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 00dc8ac7aa..709d61ea86 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
@@ -35,8 +35,7 @@ internal fun describeImpl(cols: List<AnyCol>): DataFrame<ColumnDescription> {
         flatMap { col ->
             when (col.kind) {
                 ColumnKind.Frame ->
-                    col
-                        .asAnyFrameColumn()
+                    col.asAnyFrameColumn()
                         .concat()
                         .columns()
                         .map { it.addPath(col.path() + it.name) }
@@ -44,8 +43,7 @@ internal fun describeImpl(cols: List<AnyCol>): DataFrame<ColumnDescription> {
 
                 ColumnKind.Group ->
                     if (atAnyDepth) {
-                        col
-                            .asColumnGroup()
+                        col.asColumnGroup()
                             .columns()
                             .map { it.addPath(col.path() + it.name) }
                             .collectAll(true)
@@ -72,10 +70,8 @@ internal fun describeImpl(cols: List<AnyCol>): DataFrame<ColumnDescription> {
         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 }
+            it.values.filterNotNull()
+                .groupBy { it }.maxByOrNull { it.value.size }
                 ?.key
         }
         if (hasNumeric) {
@@ -90,20 +86,17 @@ internal fun describeImpl(cols: List<AnyCol>): DataFrame<ColumnDescription> {
             ColumnDescription::max from inferType { if (it.isComparable()) it.asComparable().maxOrNull() else null }
         }
     }
-    df = df
-        .add(ColumnDescription::freq) {
-            val top = it[ColumnDescription::top]
-            val data = all[index]
-            data.values.count { it == top }
-        }.move(ColumnDescription::freq)
-        .after(ColumnDescription::top)
+    df = df.add(ColumnDescription::freq) {
+        val top = it[ColumnDescription::top]
+        val data = all[index]
+        data.values.count { it == top }
+    }.move(ColumnDescription::freq).after(ColumnDescription::top)
 
     return df.cast()
 }
 
 private fun buildTypeName(it: AnyCol): String {
-    val rawJavaType = it.type.jvmErasure.simpleName
-        .toString()
+    val rawJavaType = it.type.jvmErasure.simpleName.toString()
     return if (it.type.isMarkedNullable) {
         "$rawJavaType?"
     } else {
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/duplicate.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/duplicate.kt
index 7954550749..159c02ca3a 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/duplicate.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/duplicate.kt
@@ -47,11 +47,10 @@ internal fun <T> DataColumn<T>.duplicateValuesImpl(n: Int): DataColumn<T> {
 internal fun <T> DataColumn<T>.duplicateValuesImpl(n: Int, indicesSorted: Iterable<Int>): DataColumn<T> =
     when (this) {
         is ColumnGroup<*> ->
-            DataColumn
-                .createColumnGroup(
-                    name = name,
-                    df = asDataFrame().duplicateRowsImpl(n, indicesSorted),
-                ).asDataColumn()
+            DataColumn.createColumnGroup(
+                name = name,
+                df = asDataFrame().duplicateRowsImpl(n, indicesSorted),
+            ).asDataColumn()
 
         else -> {
             val list = mutableListOf<Any?>()
@@ -75,30 +74,26 @@ internal fun <T> DataColumn<T>.duplicateValuesImpl(n: Int, indicesSorted: Iterab
 
 internal fun <T> DataFrame<T>.duplicateRowsImpl(n: Int, indicesSorted: Iterable<Int>): DataFrame<T> =
     columns()
-        .map {
-            it.duplicateValuesImpl(n, indicesSorted)
-        }.toDataFrame()
+        .map { it.duplicateValuesImpl(n, indicesSorted) }
+        .toDataFrame()
         .cast()
 
 internal fun <T> DataRow<T>.duplicateImpl(n: Int): DataFrame<T> =
-    owner
-        .columns()
-        .map { col ->
-            when (col) {
-                is ColumnGroup<*> -> DataColumn.createColumnGroup(col.name, col[index].duplicateImpl(n))
+    owner.columns().map { col ->
+        when (col) {
+            is ColumnGroup<*> -> DataColumn.createColumnGroup(col.name, col[index].duplicateImpl(n))
 
-                else -> {
-                    val value = col[index]
-                    if (value is AnyFrame) {
-                        DataColumn.createFrameColumn(col.name, List(n) { value })
-                    } else {
-                        DataColumn.createValueColumn(
-                            col.name,
-                            List(n) { value },
-                            col.type.withNullability(value == null),
-                        )
-                    }
+            else -> {
+                val value = col[index]
+                if (value is AnyFrame) {
+                    DataColumn.createFrameColumn(col.name, List(n) { value })
+                } else {
+                    DataColumn.createValueColumn(
+                        col.name,
+                        List(n) { value },
+                        col.type.withNullability(value == null),
+                    )
                 }
             }
-        }.toDataFrame()
-        .cast()
+        }
+    }.toDataFrame().cast()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/explode.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/explode.kt
index df0e5f8e5e..25dc1530f7 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/explode.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/explode.kt
@@ -53,25 +53,23 @@ internal fun <T> DataFrame<T>.explodeImpl(dropEmpty: Boolean = true, columns: Co
 
             val dstCol = data[pathOf(srcCol.name)]
             if (srcCol is ColumnGroup<*>) { // go to nested columns recursively
-                val newData = data
-                    .mapNotNull {
-                        if (it.key.isNotEmpty() && it.key[0] == srcCol.name) {
-                            it.key.drop(1) to it.value
-                        } else {
-                            null
-                        }
-                    }.toMap()
+                val newData = data.mapNotNull {
+                    if (it.key.isNotEmpty() && it.key[0] == srcCol.name) {
+                        it.key.drop(1) to it.value
+                    } else {
+                        null
+                    }
+                }.toMap()
                 val newDf = splitIntoRows(srcCol, newData)
                 DataColumn.createColumnGroup(srcCol.name, newDf)
             } else if (dstCol != null) { // values in current column will be split
                 when (dstCol) {
                     is FrameColumn<*> -> {
-                        val newDf = dstCol.values
-                            .mapIndexed { row, frame ->
-                                val expectedSize = rowExpandSizes[row]
-                                assert(frame.nrow <= expectedSize)
-                                frame.appendNulls(expectedSize - frame.nrow)
-                            }.concat()
+                        val newDf = dstCol.values.mapIndexed { row, frame ->
+                            val expectedSize = rowExpandSizes[row]
+                            assert(frame.nrow <= expectedSize)
+                            frame.appendNulls(expectedSize - frame.nrow)
+                        }.concat()
 
                         DataColumn.createColumnGroup(dstCol.name, newDf)
                     }
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 55245e3a14..25f8f4c415 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
@@ -22,8 +22,7 @@ internal fun <T, C> DataFrame<T>.flattenImpl(
     }
     val rootPrefixes = rootColumns.map { it.path }.toSet()
     val nameGenerators = rootPrefixes.map { it.dropLast() }.distinct().associateWith { path ->
-        val usedNames = get(path)
-            .asColumnGroup()
+        val usedNames = get(path).asColumnGroup()
             .columns()
             .filter { path + it.name() !in rootPrefixes }
             .map { it.name() }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/format.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/format.kt
index 986fb4a4f9..07e6f68039 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/format.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/format.kt
@@ -51,8 +51,7 @@ internal fun linearGradient(
 internal fun <T, C> FormatClause<T, C>.formatImpl(formatter: RowColFormatter<T, C>): FormattedFrame<T> {
     val columns =
         if (columns != null) {
-            df
-                .getColumnsWithPaths(columns)
+            df.getColumnsWithPaths(columns)
                 .mapNotNull { if (it.depth == 0) it.name else null }
                 .toSet()
         } else {
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/implode.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/implode.kt
index 24ddc20918..84b2446d7b 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/implode.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/implode.kt
@@ -17,22 +17,21 @@ import org.jetbrains.kotlinx.dataframe.impl.getListType
 import kotlin.reflect.typeOf
 
 internal fun <T, C> DataFrame<T>.implodeImpl(dropNA: Boolean = false, columns: ColumnsSelector<T, C>): DataFrame<T> =
-    groupBy { allExcept(columns) }
-        .updateGroups {
-            replace(columns).with { column ->
-                val (value, type) = when (column.kind()) {
-                    ColumnKind.Value -> (if (dropNA) column.dropNA() else column).toList() to getListType(column.type())
-                    ColumnKind.Group -> column.asColumnGroup().extractDataFrame() to typeOf<AnyFrame>()
-                    ColumnKind.Frame -> column.asAnyFrameColumn().concat() to typeOf<List<AnyFrame>>()
+    groupBy { allExcept(columns) }.updateGroups {
+        replace(columns).with { column ->
+            val (value, type) = when (column.kind()) {
+                ColumnKind.Value -> (if (dropNA) column.dropNA() else column).toList() to getListType(column.type())
+                ColumnKind.Group -> column.asColumnGroup().extractDataFrame() to typeOf<AnyFrame>()
+                ColumnKind.Frame -> column.asAnyFrameColumn().concat() to typeOf<List<AnyFrame>>()
+            }
+            var first = true
+            column.map(type) {
+                if (first) {
+                    first = false
+                    value
+                } else {
+                    null
                 }
-                var first = true
-                column.map(type) {
-                    if (first) {
-                        first = false
-                        value
-                    } else {
-                        null
-                    }
-                }
-            }[0..0]
-        }.concat()
+            }
+        }[0..0]
+    }.concat()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/insert.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/insert.kt
index 368c5cb35a..c6a43553cd 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/insert.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/insert.kt
@@ -133,9 +133,9 @@ internal fun <Column : GenericColumn, ColumnGroup : GenericColumnGroup<Column>>
             // assert that new columns go directly under current column so they have longer paths
             val invalidPath = subTree.firstOrNull { it.insertionPath.size == childDepth }
             check(invalidPath == null) {
-                "Can not insert column '${invalidPath!!.insertionPath.joinToString(
-                    ".",
-                )}' because column with this path already exists in DataFrame"
+                "Can not insert column '${
+                    invalidPath!!.insertionPath.joinToString(".")
+                }' because column with this path already exists in DataFrame"
             }
             val group = it as? ColumnGroup
             check(
@@ -163,35 +163,34 @@ internal fun <Column : GenericColumn, ColumnGroup : GenericColumnGroup<Column>>
     }
 
     // collect new columns to insert
-    val columnsToAdd = columns
-        .mapNotNull {
-            val name = it.insertionPath[depth]
-            val subTree = columnsMap[name]
-            if (subTree != null) {
-                columnsMap.remove(name)
+    val columnsToAdd = columns.mapNotNull {
+        val name = it.insertionPath[depth]
+        val subTree = columnsMap[name]
+        if (subTree != null) {
+            columnsMap.remove(name)
 
-                // look for columns in subtree that were originally located at the current insertion path
-                // find the minimal original index among them
-                // new column will be inserted at that position
-                val minIndex = subTree.minOf {
-                    if (it.referenceNode == null) {
-                        Int.MAX_VALUE
+            // look for columns in subtree that were originally located at the current insertion path
+            // find the minimal original index among them
+            // new column will be inserted at that position
+            val minIndex = subTree.minOf {
+                if (it.referenceNode == null) {
+                    Int.MAX_VALUE
+                } else {
+                    var col = it.referenceNode
+                    if (col.depth > depth) col = col.getAncestor(depth + 1)
+                    if (col.parent === treeNode) {
+                        if (col.data.wasRemoved) col.data.originalIndex else col.data.originalIndex + 1
                     } else {
-                        var col = it.referenceNode
-                        if (col.depth > depth) col = col.getAncestor(depth + 1)
-                        if (col.parent === treeNode) {
-                            if (col.data.wasRemoved) col.data.originalIndex else col.data.originalIndex + 1
-                        } else {
-                            Int.MAX_VALUE
-                        }
+                        Int.MAX_VALUE
                     }
                 }
-
-                minIndex to (name to subTree)
-            } else {
-                null
             }
-        }.sortedBy { it.first } // sort by insertion index
+
+            minIndex to (name to subTree)
+        } else {
+            null
+        }
+    }.sortedBy { it.first } // sort by insertion index
 
     val removedSiblings = treeNode?.children
     var k = 0 // index in 'removedSiblings' list
@@ -213,11 +212,9 @@ internal fun <Column : GenericColumn, ColumnGroup : GenericColumnGroup<Column>>
         val newCol = if (nodeToInsert != null) {
             val column = nodeToInsert.column
             if (columns.size > 1) {
-                check(
-                    columns.count {
-                        it.insertionPath.size == childDepth
-                    } == 1,
-                ) { "Can not insert more than one column into the path ${nodeToInsert.insertionPath}" }
+                check(columns.count { it.insertionPath.size == childDepth } == 1) {
+                    "Can not insert more than one column into the path ${nodeToInsert.insertionPath}"
+                }
                 column as ColumnGroup
                 val columns1 = columns.filter { it.insertionPath.size > childDepth }
                 val newDf = if (columns1.isEmpty()) {
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 125f163c67..6746eb44a4 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
@@ -31,17 +31,14 @@ import kotlin.reflect.full.withNullability
 
 internal fun <A, B> defaultJoinColumns(left: DataFrame<A>, right: DataFrame<B>): JoinColumnsSelector<A, B> =
     {
-        left
-            .columnNames()
-            .intersect(right.columnNames().toSet())
+        left.columnNames().intersect(right.columnNames().toSet())
             .map { it.toColumnAccessor() }
             .let { ColumnsList(it) }
     }
 
 internal fun <T> defaultJoinColumns(dataFrames: Iterable<DataFrame<T>>): JoinColumnsSelector<T, T> =
     {
-        dataFrames
-            .map { it.columnNames() }
+        dataFrames.map { it.columnNames() }
             .fold<List<String>, Set<String>?>(null) { set, names ->
                 set?.intersect(names.toSet()) ?: names.toSet()
             }.orEmpty()
@@ -174,8 +171,7 @@ internal fun <A, B> DataFrame<A>.joinImpl(
         if (addNewColumns) {
             other.getColumnsWithPaths {
                 colsAtAnyDepth {
-                    !it.isColumnGroup() &&
-                        !rightJoinColumnPaths.contains(it.path)
+                    !it.isColumnGroup() && !rightJoinColumnPaths.contains(it.path)
                 }
             }
         } else {
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/joinWith.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/joinWith.kt
index a23a05fbc2..182ac6747d 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/joinWith.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/joinWith.kt
@@ -91,10 +91,9 @@ internal fun <A, B> DataFrame<A>.joinWithImpl(
         }
     }
 
-    val df: DataFrame<*> = outputData
-        .mapIndexed { index, values ->
-            DataColumn.createWithTypeInference(generator.names[index], values)
-        }.toDataFrame()
+    val df: DataFrame<*> = outputData.mapIndexed { index, values ->
+        DataColumn.createWithTypeInference(generator.names[index], values)
+    }.toDataFrame()
 
     return df.cast()
 }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/move.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/move.kt
index e509bc61d3..cacbe2e028 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/move.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/move.kt
@@ -60,12 +60,13 @@ internal fun <T, C> MoveClause<T, C>.moveTo(columnIndex: Int): DataFrame<T> {
     val removed = df.removeImpl(columns = columns)
     val remainingColumns = removed.df.columns()
     val targetIndex = if (columnIndex > remainingColumns.size) remainingColumns.size else columnIndex
-    val newColumnList = remainingColumns.subList(0, targetIndex) +
-        removed.removedColumns.map { it.data.column as DataColumn<C> } +
-        if (targetIndex < remainingColumns.size) {
-            remainingColumns.subList(targetIndex, remainingColumns.size)
-        } else {
-            emptyList()
-        }
+    val newColumnList =
+        remainingColumns.subList(0, targetIndex) +
+            removed.removedColumns.map { it.data.column as DataColumn<C> } +
+            if (targetIndex < remainingColumns.size) {
+                remainingColumns.subList(targetIndex, remainingColumns.size)
+            } else {
+                emptyList()
+            }
     return newColumnList.toDataFrame().cast()
 }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/parse.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/parse.kt
index 1d1a12907b..1e7f8c18d2 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/parse.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/parse.kt
@@ -393,8 +393,7 @@ internal fun <T> DataFrame<T>.parseImpl(options: ParserOptions?, columns: Column
             it.isFrameColumn() -> it.cast<AnyFrame?>().parse(options)
 
             it.isColumnGroup() ->
-                it
-                    .asColumnGroup()
+                it.asColumnGroup()
                     .parse(options) { all() }
                     .asColumnGroup(it.name())
                     .asDataColumn()
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 77e2b1bdd3..f115063f32 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
@@ -55,9 +55,7 @@ internal class PivotChainColumnSet<C>(val first: ColumnsResolver<C>, val second:
 internal fun <T, C> DataFrame<T>.getPivotSequences(
     columns: PivotColumnsSelector<T, C>,
 ): List<List<PivotChainElement>> =
-    columns
-        .toColumnSet()
-        .resolve(this, UnresolvedColumnsPolicy.Fail)
+    columns.toColumnSet().resolve(this, UnresolvedColumnsPolicy.Fail)
         .map {
             when (val col = it) {
                 is PivotChain<*> -> col.columns as List<PivotChainElement>
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/remove.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/remove.kt
index 18bb51c16c..06e302dcfd 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/remove.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/remove.kt
@@ -24,11 +24,12 @@ internal fun <T> DataFrame<T>.removeImpl(
     columns: ColumnsSelector<T, *>,
 ): RemoveResult<T> {
     val colWithPaths = getColumnsWithPaths(
-        unresolvedColumnsPolicy = if (allowMissingColumns) {
-            UnresolvedColumnsPolicy.Skip
-        } else {
-            UnresolvedColumnsPolicy.Fail
-        },
+        unresolvedColumnsPolicy =
+            if (allowMissingColumns) {
+                UnresolvedColumnsPolicy.Skip
+            } else {
+                UnresolvedColumnsPolicy.Fail
+            },
         selector = columns,
     )
     val colPaths = colWithPaths.map { it.path }
@@ -75,8 +76,7 @@ internal fun <T> DataFrame<T>.removeImpl(
 
     val newDf = dfs(columns(), colWithPaths, root) ?: DataFrame.empty(nrow)
 
-    val removedColumns = root
-        .allRemovedColumns()
+    val removedColumns = root.allRemovedColumns()
         .map { it.pathFromRoot() to it }
         .sortedBy { originalOrder[it.first] }
         .map { it.second }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/rename.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/rename.kt
index f95cea83b9..b0460b6f3f 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/rename.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/rename.kt
@@ -21,8 +21,7 @@ internal fun <T, C> RenameClause<T, C>.renameImpl(newNames: Array<out String>):
 
 internal fun <T, C> RenameClause<T, C>.renameImpl(transform: (ColumnWithPath<C>) -> String): DataFrame<T> {
     // get all selected columns and their paths
-    val selectedColumnsWithPath = df
-        .getColumnsWithPaths(columns)
+    val selectedColumnsWithPath = df.getColumnsWithPaths(columns)
         .associateBy { it.path }
     // gather a tree of all columns where the nodes will be renamed
     val tree = df.getColumnsWithPaths { colsAtAnyDepth() }.collectTree()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/reorder.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/reorder.kt
index 115adadd19..e5c8accd48 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/reorder.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/reorder.kt
@@ -61,8 +61,7 @@ internal fun <T, C, V : Comparable<V>> Reorder<T, C>.reorderImpl(
                 val path = src.treeNode.pathFromRoot().rename(c.column.name())
                 var column = c.column
                 if (inFrameColumns && column.isFrameColumn()) {
-                    column = column
-                        .asAnyFrameColumn()
+                    column = column.asAnyFrameColumn()
                         .map(typeOf<AnyFrame>()) { it.cast<T>().reorder(columns).reorderImpl(desc, expression) }
                         .cast()
                 }
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 873843bd7d..336c2db7d4 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
@@ -42,13 +42,12 @@ internal fun <T, C> DataFrame<T>.sortByImpl(
     val sortColumns = getSortColumns(columns, unresolvedColumnsPolicy)
     if (sortColumns.isEmpty()) return this
 
-    val compChain = sortColumns
-        .map {
-            when (it.direction) {
-                SortDirection.Asc -> it.column.createComparator(it.nullsLast)
-                SortDirection.Desc -> it.column.createComparator(it.nullsLast).reversed()
-            }
-        }.reduce { a, b -> a.then(b) }
+    val compChain = sortColumns.map {
+        when (it.direction) {
+            SortDirection.Asc -> it.column.createComparator(it.nullsLast)
+            SortDirection.Desc -> it.column.createComparator(it.nullsLast).reversed()
+        }
+    }.reduce { a, b -> a.then(b) }
 
     val permutation = (0 until nrow).sortedWith(compChain)
 
@@ -70,9 +69,7 @@ internal fun <T, C> DataFrame<T>.getSortColumns(
     columns: SortColumnsSelector<T, C>,
     unresolvedColumnsPolicy: UnresolvedColumnsPolicy,
 ): List<SortColumnDescriptor<*>> =
-    columns
-        .toColumnSet()
-        .resolve(this, unresolvedColumnsPolicy)
+    columns.toColumnSet().resolve(this, unresolvedColumnsPolicy)
         // can appear using [DataColumn<R>?.check] with UnresolvedColumnsPolicy.Skip
         .filterNot { it.data is MissingColumnGroup<*> }
         .map {
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/toDataFrame.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/toDataFrame.kt
index 1bc77833dd..18a274dd28 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/toDataFrame.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/toDataFrame.kt
@@ -287,13 +287,7 @@ internal fun convertToDataFrame(
                 )
 
             kClass.isSubclassOf(Iterable::class) ->
-                when (
-                    val elementType = returnType
-                        .projectUpTo(Iterable::class)
-                        .arguments
-                        .firstOrNull()
-                        ?.type
-                ) {
+                when (val elementType = returnType.projectUpTo(Iterable::class).arguments.firstOrNull()?.type) {
                     null ->
                         DataColumn.createValueColumn(
                             name = it.columnName,
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/update.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/update.kt
index 04cabb0f67..be27e2761c 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/update.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/update.kt
@@ -132,8 +132,7 @@ internal fun <T> DataColumn<T>.updateWith(values: List<T>): DataColumn<T> =
         }
 
         is ColumnGroup<*> -> {
-            this
-                .columns()
+            this.columns()
                 .mapIndexed { colIndex, col ->
                     val newValues = values.map {
                         when (it) {
@@ -156,9 +155,9 @@ internal fun <T> DataColumn<T>.updateWith(values: List<T>): DataColumn<T> =
                     null -> nulls = true
 
                     else -> {
-                        require(
-                            it.javaClass.kotlin.isSubclassOf(kclass),
-                        ) { "Can not add value '$it' to column '$name' of type $type" }
+                        require(it.javaClass.kotlin.isSubclassOf(kclass)) {
+                            "Can not add value '$it' to column '$name' of type $type"
+                        }
                     }
                 }
             }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/xs.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/xs.kt
index 65f4f4ddad..ffb9489fa7 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/xs.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/xs.kt
@@ -19,11 +19,12 @@ internal fun <T, C> DataFrame<T>.xsImpl(
 ): DataFrame<T> {
     val cols =
         getColumnsImpl(
-            unresolvedColumnsPolicy = if (allowMissingColumns) {
-                UnresolvedColumnsPolicy.Create
-            } else {
-                UnresolvedColumnsPolicy.Fail
-            },
+            unresolvedColumnsPolicy =
+                if (allowMissingColumns) {
+                    UnresolvedColumnsPolicy.Create
+                } else {
+                    UnresolvedColumnsPolicy.Fail
+                },
             selector = keyColumns,
         )
     val n = keyValues.count()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/CodeGeneratorImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/CodeGeneratorImpl.kt
index 2868f14b6e..25bcbcd36c 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/CodeGeneratorImpl.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/CodeGeneratorImpl.kt
@@ -250,9 +250,9 @@ internal open class ExtensionsCodeGeneratorImpl(private val typeRendering: TypeR
                 it
             }
         }
-        return "${visibility}val$typeParameters $typeName.$name: $propertyType @JvmName(\"${renderStringLiteral(
-            jvmName,
-        )}\") get() = $getter as $propertyType"
+        return "${visibility}val$typeParameters $typeName.$name: $propertyType @JvmName(\"${
+            renderStringLiteral(jvmName)
+        }\") get() = $getter as $propertyType"
     }
 
     /**
@@ -289,10 +289,9 @@ internal open class ExtensionsCodeGeneratorImpl(private val typeRendering: TypeR
         val rowTypename = renderRowTypeName(markerType)
         val nullableRowTypename = renderRowTypeName(markerType.toNullable())
 
-        val nullableFields = marker.fields
-            .map {
-                it.toNullable()
-            }.associateBy { it.columnName }
+        val nullableFields = marker.fields.map {
+            it.toNullable()
+        }.associateBy { it.columnName }
 
         marker.fields.sortedBy { it.fieldName.quotedIfNeeded }.forEach {
             val getter = "this[\"${renderStringLiteral(it.columnName)}\"]"
@@ -412,24 +411,20 @@ internal class CodeGeneratorImpl(typeRendering: TypeRenderingStrategy = FullyQua
             "${visibility}enum class ${marker.name}(override val value: ${String::class.qualifiedName}) : ${DataSchemaEnum::class.qualifiedName}"
 
         val fieldNames = mutableSetOf<String>()
-        val fieldsDeclaration = marker.fields
-            .mapIndexed { i, it ->
-                val originalFieldName = it.fieldName.unquoted
-                    .toSnakeCase()
-                    .uppercase()
-                    .ifEmpty { "EMPTY_STRING" }
-                var fieldName = originalFieldName
-                var j = 1
-                while (fieldName in fieldNames) {
-                    fieldName = "${originalFieldName}_${j++}"
-                }
-                fieldNames += fieldName
+        val fieldsDeclaration = marker.fields.mapIndexed { i, it ->
+            val originalFieldName = it.fieldName.unquoted.toSnakeCase().uppercase().ifEmpty { "EMPTY_STRING" }
+            var fieldName = originalFieldName
+            var j = 1
+            while (fieldName in fieldNames) {
+                fieldName = "${originalFieldName}_${j++}"
+            }
+            fieldNames += fieldName
 
-                val valueName = it.fieldName.unquoted
-                val isLast = i == marker.fields.size - 1
+            val valueName = it.fieldName.unquoted
+            val isLast = i == marker.fields.size - 1
 
-                "    ${ValidFieldName.of(fieldName).quotedIfNeeded}(\"$valueName\")${if (isLast) ";" else ","}"
-            }.join()
+            "    ${ValidFieldName.of(fieldName).quotedIfNeeded}(\"$valueName\")${if (isLast) ";" else ","}"
+        }.join()
 
         val body = if (fieldsDeclaration.isNotBlank()) {
             buildString {
@@ -478,28 +473,26 @@ internal class CodeGeneratorImpl(typeRendering: TypeRenderingStrategy = FullyQua
             "@$annotationName${if (marker.isOpen) "" else "(isOpen = false)"}\n${visibility}interface ${marker.name}"
         val baseInterfacesDeclaration =
             if (marker.superMarkers.isNotEmpty()) {
-                " : " +
-                    marker.superMarkers
-                        .map { it.value.name + it.value.typeArguments }
-                        .joinToString()
+                " : " + marker.superMarkers
+                    .map { it.value.name + it.value.typeArguments }
+                    .joinToString()
             } else {
                 ""
             }
         val resultDeclarations = mutableListOf<String>()
 
         val fieldsDeclaration = if (fields) {
-            marker.fields
-                .map {
-                    val override = if (it.overrides) "override " else ""
-                    val columnNameAnnotation = if (it.columnName != it.fieldName.quotedIfNeeded) {
-                        "    @ColumnName(\"${renderStringLiteral(it.columnName)}\")\n"
-                    } else {
-                        ""
-                    }
+            marker.fields.map {
+                val override = if (it.overrides) "override " else ""
+                val columnNameAnnotation = if (it.columnName != it.fieldName.quotedIfNeeded) {
+                    "    @ColumnName(\"${renderStringLiteral(it.columnName)}\")\n"
+                } else {
+                    ""
+                }
 
-                    val fieldType = it.renderFieldType()
-                    "$columnNameAnnotation    ${propertyVisibility}${override}val ${it.fieldName.quotedIfNeeded}: $fieldType"
-                }.join()
+                val fieldType = it.renderFieldType()
+                "$columnNameAnnotation    ${propertyVisibility}${override}val ${it.fieldName.quotedIfNeeded}: $fieldType"
+            }.join()
         } else {
             ""
         }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaProcessorImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaProcessorImpl.kt
index a9e91347e7..d31d433048 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaProcessorImpl.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaProcessorImpl.kt
@@ -22,8 +22,7 @@ internal class SchemaProcessorImpl(
     override val generatedMarkers = mutableListOf<Marker>()
 
     private fun DataFrameSchema.getAllSuperMarkers() =
-        registeredMarkers
-            .filter { it.isOpen && it.schema.compare(this).isSuperOrEqual() }
+        registeredMarkers.filter { it.isOpen && it.schema.compare(this).isSuperOrEqual() }
 
     private fun List<Marker>.onlyLeafs(): List<Marker> {
         val skip = flatMap { it.allSuperMarkers.keys }.toSet()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/AtAnyDepth.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/AtAnyDepth.kt
index 1965d59f1d..887cc15901 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/AtAnyDepth.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/AtAnyDepth.kt
@@ -97,8 +97,7 @@ internal fun ColumnsResolver<*>.flattenRecursively(
         if (includeTopLevel) {
             cols.flattenRecursively()
         } else {
-            cols
-                .filter { it.isColumnGroup() }
+            cols.filter { it.isColumnGroup() }
                 .flatMap { it.cols().flattenRecursively() }
         }.filter { includeGroups || !it.isColumnGroup() }
     }
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 91bd81baa5..819aaa3eec 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
@@ -21,19 +21,17 @@ internal class ColumnAccessorImpl<T>(val path: ColumnPath) : ColumnAccessor<T> {
 
     override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? =
         // resolve the n-1 first columns of the path as column groups (throwing an exception if any of them is not a column group)
-        path
-            .dropLast()
-            .foldIndexed(context.df) { i, df, colName ->
-                val col = df.getColumn<Any?>(colName, context.unresolvedColumnsPolicy) ?: return null
-                if (!col.isColumnGroup()) {
-                    error(
-                        "Cannot resolve column '${path.subList(0, i + 2).joinToString(".")}': " +
-                            "Column '${path.subList(0, i + 1).joinToString(".")}' is not a column group.",
-                    )
-                } else {
-                    col.asColumnGroup()
-                }
+        path.dropLast().foldIndexed(context.df) { i, df, colName ->
+            val col = df.getColumn<Any?>(colName, context.unresolvedColumnsPolicy) ?: return null
+            if (!col.isColumnGroup()) {
+                error(
+                    "Cannot resolve column '${path.subList(0, i + 2).joinToString(".")}': " +
+                        "Column '${path.subList(0, i + 1).joinToString(".")}' is not a column group.",
+                )
+            } else {
+                col.asColumnGroup()
             }
+        }
             // resolve the last column of the path
             .getColumn<Any?>(path.last(), context.unresolvedColumnsPolicy)
             ?.cast<T>()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupWithPathImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupWithPathImpl.kt
index 76ce4d2f5d..99899cbfd2 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupWithPathImpl.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupWithPathImpl.kt
@@ -18,10 +18,8 @@ internal class ColumnGroupWithPathImpl<T> internal constructor(
             this
         } else {
             ColumnGroupWithPathImpl(
-                column.rename(
-                    newName,
-                ),
-                path.dropLast(1) + newName,
+                column = column.rename(newName),
+                path = path.dropLast(1) + newName,
             )
         }
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ComputedColumnReference.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ComputedColumnReference.kt
index d63c490642..763cd1b8f1 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ComputedColumnReference.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ComputedColumnReference.kt
@@ -17,9 +17,8 @@ internal class ComputedColumnReference<R>(
 
     override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<R> =
         context.df
-            .newColumn(type, name, infer) {
-                compute(it, it)
-            }.addPath()
+            .newColumn(type, name, infer) { compute(it, it) }
+            .addPath()
 
     override fun name() = name
 
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 b0ec8f9604..4df8f5cda9 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
@@ -202,8 +202,7 @@ internal fun <A, B> ColumnsResolver<A>.transform(
             context: ColumnResolutionContext,
             transformer: ColumnsResolverTransformer,
         ): List<ColumnWithPath<B>> =
-            transformer
-                .transform(this@transform)
+            transformer.transform(this@transform)
                 .resolve(context)
                 .let { converter(it as List<ColumnWithPath<A>>) }
     }
@@ -253,8 +252,7 @@ internal fun <A, B> ColumnsResolver<A>.transformWithContext(
             context: ColumnResolutionContext,
             transformer: ColumnsResolverTransformer,
         ): List<ColumnWithPath<B>> =
-            transformer
-                .transform(this@transformWithContext)
+            transformer.transform(this@transformWithContext)
                 .resolve(context)
                 .let { converter(context, it as List<ColumnWithPath<A>>) }
     }
@@ -294,11 +292,10 @@ internal fun <T> TransformableColumnSet<T>.singleWithTransformerImpl(): Transfor
             context: ColumnResolutionContext,
             transformer: ColumnsResolverTransformer,
         ): ColumnWithPath<T> =
-            this@singleWithTransformerImpl
-                .transformResolve(
-                    context = context,
-                    transformer = transformer,
-                ).singleImpl()
+            this@singleWithTransformerImpl.transformResolve(
+                context = context,
+                transformer = transformer,
+            ).singleImpl()
     }
 
 /**
@@ -324,11 +321,10 @@ internal fun <T> TransformableColumnSet<T>.singleOrNullWithTransformerImpl(): Tr
             context: ColumnResolutionContext,
             transformer: ColumnsResolverTransformer,
         ): ColumnWithPath<T>? =
-            this@singleOrNullWithTransformerImpl
-                .transformResolve(
-                    context = context,
-                    transformer = transformer,
-                ).singleOrNull()
+            this@singleOrNullWithTransformerImpl.transformResolve(
+                context = context,
+                transformer = transformer,
+            ).singleOrNull()
     }
 
 internal fun <T> ColumnsResolver<T>.getAt(index: Int): SingleColumn<T> =
@@ -461,8 +457,7 @@ internal fun List<ColumnWithPath<*>>.allColumnsExceptKeepingStructure(
                 while (parent != null) {
                     val parentData = parent.data as ColumnGroup<*>? ?: break
                     parent.data = parentData
-                        .replace(currentNode.name)
-                        .with { currentNode.data!! }
+                        .replace(currentNode.name).with { currentNode.data!! }
                         .asColumnGroup(parentData.name)
                         .addPath(parentData.path())
 
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 1006802388..bb9fcc8ab5 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
@@ -108,31 +108,25 @@ internal fun <T> createColumn(values: Iterable<T>, suggestedType: KType, guessTy
     when {
         // values is a non-empty list of AnyRows
         values.any() && values.all { it is AnyRow } ->
-            DataColumn
-                .createColumnGroup(
-                    name = "",
-                    df = (values as Iterable<AnyRow>).toDataFrame(),
-                ).asDataColumn()
-                .cast()
+            DataColumn.createColumnGroup(
+                name = "",
+                df = (values as Iterable<AnyRow>).toDataFrame(),
+            ).asDataColumn().cast()
 
         // values is a non-empty list of DataColumns
         values.any() && values.all { it is AnyCol } ->
-            DataColumn
-                .createColumnGroup(
-                    name = "",
-                    df = (values as Iterable<AnyCol>).toDataFrame(),
-                ).asDataColumn()
-                .cast()
+            DataColumn.createColumnGroup(
+                name = "",
+                df = (values as Iterable<AnyCol>).toDataFrame(),
+            ).asDataColumn().cast()
 
         // values is a non-empty list of DataFrames and nulls
         // (but not just nulls; we cannot assume that should create a FrameColumn)
         values.any() && values.all { it is AnyFrame? } && !values.all { it == null } ->
-            DataColumn
-                .createFrameColumn(
-                    name = "",
-                    groups = values.map { it as? AnyFrame ?: DataFrame.empty() },
-                ).asDataColumn()
-                .cast()
+            DataColumn.createFrameColumn(
+                name = "",
+                groups = values.map { it as? AnyFrame ?: DataFrame.empty() },
+            ).asDataColumn().cast()
 
         guessType ->
             guessColumnType(
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 f9321c8a2c..567bf5eb33 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
@@ -87,8 +87,7 @@ internal fun Iterable<ColumnWithPath<*>>.flattenRecursively(): List<ColumnWithPa
             val path = it.path
             if (it.data.isColumnGroup()) {
                 flattenRecursively(
-                    it.data
-                        .asColumnGroup()
+                    it.data.asColumnGroup()
                         .columns()
                         .map { it.addPath(path + it.name()) },
                 )
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/readJson.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/readJson.kt
index b4403f9163..fca2bd4e76 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/readJson.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/readJson.kt
@@ -326,10 +326,9 @@ internal fun fromJsonListAnyColumns(
                                 parsed.unwrapUnnamedColumns().firstOrNull()
                             }
                         }
-                        val valueType = map.values
-                            .map {
-                                guessValueType(sequenceOf(it))
-                            }.commonType()
+                        val valueType = map.values.map {
+                            guessValueType(sequenceOf(it))
+                        }.commonType()
 
                         valueTypes += valueType
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/writeJson.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/writeJson.kt
index 68847e57c5..fc3eb676c7 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/writeJson.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/writeJson.kt
@@ -226,19 +226,17 @@ internal fun encodeFrameWithMetadata(
 
     val data = frame.indices().map { rowIndex ->
         valueColumn?.get(rowIndex)
-            ?: arrayColumn
-                ?.get(rowIndex)
-                ?.let {
-                    if (arraysAreFrames) {
-                        encodeFrameWithMetadata(
-                            it as AnyFrame,
-                            rowLimit,
-                            imageEncodingOptions,
-                        )
-                    } else {
-                        null
-                    }
+            ?: arrayColumn?.get(rowIndex)?.let {
+                if (arraysAreFrames) {
+                    encodeFrameWithMetadata(
+                        it as AnyFrame,
+                        rowLimit,
+                        imageEncodingOptions,
+                    )
+                } else {
+                    null
                 }
+            }
             ?: encodeRowWithMetadata(frame, rowIndex, rowLimit, imageEncodingOptions)
     }
 
@@ -248,8 +246,7 @@ internal fun encodeFrameWithMetadata(
 internal fun AnyFrame.extractValueColumn(): DataColumn<*>? {
     val allColumns = columns()
 
-    return allColumns
-        .filter { it.name.startsWith(VALUE_COLUMN_NAME) }
+    return allColumns.filter { it.name.startsWith(VALUE_COLUMN_NAME) }
         .takeIf { isPossibleToFindUnnamedColumns }
         ?.maxByOrNull { it.name }
         ?.let { valueCol ->
@@ -289,8 +286,7 @@ internal val AnyFrame.isPossibleToFindUnnamedColumns: Boolean
 internal fun AnyFrame.extractArrayColumn(): DataColumn<*>? {
     val allColumns = columns()
 
-    return columns()
-        .filter { it.name.startsWith(ARRAY_COLUMN_NAME) }
+    return columns().filter { it.name.startsWith(ARRAY_COLUMN_NAME) }
         .takeIf { isPossibleToFindUnnamedColumns }
         ?.maxByOrNull { it.name }
         ?.let { arrayCol ->
@@ -332,9 +328,7 @@ internal fun encodeFrame(frame: AnyFrame): JsonArray {
 
             arrayColumn != null -> arrayColumn[rowIndex]?.let {
                 if (arraysAreFrames) {
-                    encodeFrame(
-                        it as AnyFrame,
-                    )
+                    encodeFrame(it as AnyFrame)
                 } else {
                     null
                 }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/Utils.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/Utils.kt
index ccaa62e04d..bda5ee2730 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/Utils.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/Utils.kt
@@ -132,19 +132,17 @@ internal fun ColumnSchema.createEmptyColumn(name: String, numberOfRows: Int): An
     }
 
 internal fun DataFrameSchema.createEmptyDataFrame(): AnyFrame =
-    columns
-        .map { (name, schema) ->
-            schema.createEmptyColumn(name)
-        }.toDataFrame()
+    columns.map { (name, schema) ->
+        schema.createEmptyColumn(name)
+    }.toDataFrame()
 
 internal fun DataFrameSchema.createEmptyDataFrame(numberOfRows: Int): AnyFrame =
     if (columns.isEmpty()) {
         DataFrame.empty(numberOfRows)
     } else {
-        columns
-            .map { (name, schema) ->
-                schema.createEmptyColumn(name, numberOfRows)
-            }.toDataFrame()
+        columns.map { (name, schema) ->
+            schema.createEmptyColumn(name, numberOfRows)
+        }.toDataFrame()
     }
 
 @PublishedApi
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/common.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/common.kt
index 964ebc0969..9c06fc58a5 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/common.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/common.kt
@@ -42,17 +42,16 @@ public fun <T> List<List<T>>.toDataFrame(containsColumns: Boolean = false): AnyF
         else -> {
             val header = get(0).map { it.toString() }
             val data = drop(1)
-            header
-                .mapIndexed { colIndex, name ->
-                    val values = data.map { row ->
-                        if (row.size <= colIndex) {
-                            null
-                        } else {
-                            row[colIndex]
-                        }
+            header.mapIndexed { colIndex, name ->
+                val values = data.map { row ->
+                    if (row.size <= colIndex) {
+                        null
+                    } else {
+                        row[colIndex]
                     }
-                    guessColumnType(name, values)
-                }.toDataFrame()
+                }
+                guessColumnType(name, values)
+            }.toDataFrame()
         }
     }
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/csv.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/csv.kt
index 173570891f..a5e745c4f3 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/csv.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/csv.kt
@@ -61,15 +61,13 @@ public class CSV(private val delimiter: Char = ',') : SupportedDataFrameFormat {
 
 public enum class CSVType(public val format: CSVFormat) {
     DEFAULT(
-        CSVFormat.DEFAULT
-            .builder()
+        CSVFormat.DEFAULT.builder()
             .setAllowMissingColumnNames(true)
             .setIgnoreSurroundingSpaces(true)
             .build(),
     ),
     TDF(
-        CSVFormat.TDF
-            .builder()
+        CSVFormat.TDF.builder()
             .setAllowMissingColumnNames(true)
             .build(),
     ),
@@ -93,8 +91,7 @@ public fun DataFrame.Companion.readDelimStr(
     readLines: Int? = null,
 ): DataFrame<*> =
     StringReader(text).use {
-        val format = CSVType.DEFAULT.format
-            .builder()
+        val format = CSVType.DEFAULT.format.builder()
             .setHeader()
             .setDelimiter(delimiter)
             .build()
@@ -257,8 +254,7 @@ private fun getFormat(
     header: List<String>,
     duplicate: Boolean,
 ): CSVFormat =
-    type.format
-        .builder()
+    type.format.builder()
         .setDelimiter(delimiter)
         .setHeader(*header.toTypedArray())
         .setAllowMissingColumnNames(duplicate)
@@ -319,8 +315,7 @@ public fun ColType.toType(): KClass<out Any> =
 
 public fun DataFrame.Companion.readDelim(
     reader: Reader,
-    format: CSVFormat = CSVFormat.DEFAULT
-        .builder()
+    format: CSVFormat = CSVFormat.DEFAULT.builder()
         .setHeader()
         .build(),
     colTypes: Map<String, ColType> = mapOf(),
@@ -407,8 +402,7 @@ public fun AnyFrame.writeCSV(writer: Appendable, format: CSVFormat = CSVFormat.D
 }
 
 public fun AnyFrame.toCsv(format: CSVFormat = CSVFormat.DEFAULT): String =
-    StringWriter()
-        .use {
-            this.writeCSV(it, format)
-            it
-        }.toString()
+    StringWriter().use {
+        this.writeCSV(it, format)
+        it
+    }.toString()
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 897e0e4520..ed42b595f0 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
@@ -303,16 +303,15 @@ public fun AnyFrame.toStaticHtml(
 
                         // add the dataframe as a nested table limiting the number of rows if needed
                         // CSS will not be included here, as it is already included in the main table
-                        cellValue
-                            .toStaticHtml(
-                                configuration = configuration.copy(
-                                    rowsLimit = newRowsLimit,
-                                    nestedRowsLimit = newNestedRowsLimit,
-                                ),
-                                cellRenderer = cellRenderer,
-                                includeCss = false,
-                                openNestedDfs = openNestedDfs,
-                            ).let { append(it.body) }
+                        cellValue.toStaticHtml(
+                            configuration = configuration.copy(
+                                rowsLimit = newRowsLimit,
+                                nestedRowsLimit = newNestedRowsLimit,
+                            ),
+                            cellRenderer = cellRenderer,
+                            includeCss = false,
+                            openNestedDfs = openNestedDfs,
+                        ).let { append(it.body) }
 
                         val size = cellValue.rowsCount()
                         if (size > newRowsLimit ?: Int.MAX_VALUE) {
@@ -834,9 +833,8 @@ internal class DataFrameFormatter(
             is Pair<*, *> -> {
                 val key = value.first.toString() + ": "
                 val shortValue =
-                    render(value.second, renderer, configuration.copy(cellContentLimit = 3)) ?: "...".addCss(
-                        structuralClass,
-                    )
+                    render(value.second, renderer, configuration.copy(cellContentLimit = 3))
+                        ?: "...".addCss(structuralClass)
                 val sizeOfValue = shortValue.textLength
                 val keyLimit = limit - sizeOfValue
                 if (key.length > keyLimit) {
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt
index ce16f50f1c..9f14007a31 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt
@@ -65,10 +65,13 @@ public class JSON(
                 .add(
                     "keyValuePaths",
                     typeOf<List<JsonPath>>(),
-                    "listOf(${keyValuePaths.joinToString {
-                        "org.jetbrains.kotlinx.dataframe.api.JsonPath(\"\"\"${it.path}\"\"\")"
-                    }})",
-                ).add(
+                    "listOf(${
+                        keyValuePaths.joinToString {
+                            "org.jetbrains.kotlinx.dataframe.api.JsonPath(\"\"\"${it.path}\"\"\")"
+                        }
+                    })",
+                )
+                .add(
                     "typeClashTactic",
                     typeOf<TypeClashTactic>(),
                     "org.jetbrains.kotlinx.dataframe.io.JSON.TypeClashTactic.${typeClashTactic.name}",
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/string.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/string.kt
index 108a88c022..c1006f54bb 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/string.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/string.kt
@@ -193,8 +193,7 @@ internal fun renderValueToString(value: Any?, decimalFormat: RendererDecimalForm
         is Array<*> -> if (value.isEmpty()) "[ ]" else value.toList().toString()
 
         else ->
-            value
-                ?.asArrayAsListOrNull()
+            value?.asArrayAsListOrNull()
                 ?.let { renderValueToString(it, decimalFormat) }
                 ?: value.toString()
     }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/CellRenderer.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/CellRenderer.kt
index 0aee217410..38c4a533dd 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/CellRenderer.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/CellRenderer.kt
@@ -32,10 +32,10 @@ public data class RenderedContent(
 
     public operator fun plus(other: RenderedContent): RenderedContent =
         RenderedContent(
-            truncatedContent + other.truncatedContent,
-            textLength + other.textLength,
-            fullContent?.plus(other.fullContent) ?: other.fullContent,
-            isFormatted || other.isFormatted,
+            truncatedContent = truncatedContent + other.truncatedContent,
+            textLength = textLength + other.textLength,
+            fullContent = fullContent?.plus(other.fullContent) ?: other.fullContent,
+            isFormatted = isFormatted || other.isFormatted,
         )
 }
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/KotlinNotebookPluginUtils.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/KotlinNotebookPluginUtils.kt
index 2adee33304..88cb0f8f12 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/KotlinNotebookPluginUtils.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/KotlinNotebookPluginUtils.kt
@@ -96,10 +96,9 @@ public object KotlinNotebookPluginUtils {
                 ColumnPath(path)
             }
 
-            (sortKeys zip isDesc)
-                .map { (key, desc) ->
-                    if (desc) key.desc() else key
-                }.toColumnSet()
+            (sortKeys zip isDesc).map { (key, desc) ->
+                if (desc) key.desc() else key
+            }.toColumnSet()
         }
 
     /**
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 436c4eb8a2..45e6434a4f 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
@@ -18,8 +18,7 @@ open class ColumnsSelectionDslTests : TestBase() {
 
     protected val dfWithFrames = df
         .add { expr { df } into frameCol }
-        .convert { name }
-        .to {
+        .convert { name }.to {
             val firstName by it.asColumnGroup().firstName
             val lastName by it.asColumnGroup().lastName
 
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colsAtAnyDepth.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colsAtAnyDepth.kt
index c156aa6c57..fa5adc5969 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colsAtAnyDepth.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/colsAtAnyDepth.kt
@@ -25,25 +25,22 @@ class AtAnyDepth : TestBase() {
     // old function copied over to avoid breaking changes
     private fun ColumnSet<*>.dfsInternal(predicate: (ColumnWithPath<*>) -> Boolean): TransformableColumnSet<Any?> =
         transform {
-            it
-                .filter { it.isColumnGroup() }
+            it.filter { it.isColumnGroup() }
                 .flatMap { it.cols().flattenRecursively().filter(predicate) }
         }
 
     private val atAnyDepthGoal =
-        dfGroup
-            .getColumnsWithPaths {
-                asSingleColumn().ensureIsColumnGroup().asColumnSet().dfsInternal { true }
-            }.sortedBy { it.name }
+        dfGroup.getColumnsWithPaths {
+            asSingleColumn().ensureIsColumnGroup().asColumnSet().dfsInternal { true }
+        }.sortedBy { it.name }
 
     private val atAnyDepthNoGroups =
-        dfGroup
-            .getColumnsWithPaths {
-                asSingleColumn().ensureIsColumnGroup().asColumnSet().dfsInternal { !it.isColumnGroup() }
-            }.sortedBy { it.name }
+        dfGroup.getColumnsWithPaths {
+            asSingleColumn().ensureIsColumnGroup().asColumnSet().dfsInternal { !it.isColumnGroup() }
+        }.sortedBy { it.name }
 
-    private val atAnyDepthString = dfGroup
-        .getColumnsWithPaths {
+    private val atAnyDepthString =
+        dfGroup.getColumnsWithPaths {
             asSingleColumn()
                 .ensureIsColumnGroup()
                 .asColumnSet()
@@ -142,8 +139,7 @@ class AtAnyDepth : TestBase() {
 
         val dfWithFrames = df
             .add { expr { df } into frameCol }
-            .convert { name }
-            .to {
+            .convert { name }.to {
                 val firstName by it.asColumnGroup().firstName
                 val lastName by it.asColumnGroup().lastName
 
@@ -166,7 +162,8 @@ class AtAnyDepth : TestBase() {
             dfGroup.getColumnsWithPaths {
                 asSingleColumn().ensureIsColumnGroup().asColumnSet().dfsInternal { "e" in it.name }
             },
-        ).map { it.sortedBy { it.name }.map { it.name to it.path } }
-            .shouldAllBeEqual()
+        ).map {
+            it.sortedBy { it.name }.map { it.name to it.path }
+        }.shouldAllBeEqual()
     }
 }
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/convertTo.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/convertTo.kt
index a6c3df3014..176ab06975 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/convertTo.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/convertTo.kt
@@ -48,8 +48,7 @@ class ConvertToTests {
             df.convertTo<Schema>()
         }
 
-        df
-            .convertTo<Schema> { parser { A(it.toInt()) } }
+        df.convertTo<Schema> { parser { A(it.toInt()) } }
             .single()
             .a.value shouldBe 1
     }
@@ -62,8 +61,7 @@ class ConvertToTests {
             df.convertTo<Schema>()
         }
 
-        df
-            .convertTo<Schema> { convert<Int>().with { A(it) } }
+        df.convertTo<Schema> { convert<Int>().with { A(it) } }
             .single()
             .a.value shouldBe 1
     }
@@ -232,8 +230,7 @@ class ConvertToTests {
         ).toDataFrame { properties { preserve(DataFrame::class) } }
             .alsoDebug("df5 before convert:")
 
-        df5
-            .convertTo<DataSchemaWithAnyFrame>()
+        df5.convertTo<DataSchemaWithAnyFrame>()
             .alsoDebug("df5 after convert:")
             .convertTo<DataSchemaWithAnyFrame>()
             .alsoDebug("df5 after second convert:")
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt
index b3c956ed17..0cb9a92267 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt
@@ -19,31 +19,29 @@ class DistinctTests : ColumnsSelectionDslTests() {
             df.select { (all() and age and city).distinct() },
         ).shouldAllBeEqual()
 
-        dfGroup
-            .getColumnsWithPaths {
-                cols(
-                    name.firstName,
-                    name.firstName,
-                    name.firstName.firstName,
-                ).distinct()
-            }.let { cols ->
-                cols.size shouldBe 2
-                cols.first().path shouldBe pathOf("name", "firstName")
-                cols.last().path shouldBe pathOf("name", "firstName", "firstName")
-            }
+        dfGroup.getColumnsWithPaths {
+            cols(
+                name.firstName,
+                name.firstName,
+                name.firstName.firstName,
+            ).distinct()
+        }.let { cols ->
+            cols.size shouldBe 2
+            cols.first().path shouldBe pathOf("name", "firstName")
+            cols.last().path shouldBe pathOf("name", "firstName", "firstName")
+        }
 
-        dfGroup
-            .getColumnsWithPaths {
-                cols(
-                    "name"["firstName"],
-                    "name"["firstName"],
-                    "name"["firstName"]["firstName"],
-                ).distinct()
-            }.let { cols ->
-                cols.size shouldBe 2
-                cols.first().path shouldBe pathOf("name", "firstName")
-                cols.last().path shouldBe pathOf("name", "firstName", "firstName")
-            }
+        dfGroup.getColumnsWithPaths {
+            cols(
+                "name"["firstName"],
+                "name"["firstName"],
+                "name"["firstName"]["firstName"],
+            ).distinct()
+        }.let { cols ->
+            cols.size shouldBe 2
+            cols.first().path shouldBe pathOf("name", "firstName")
+            cols.last().path shouldBe pathOf("name", "firstName", "firstName")
+        }
 
         shouldThrow<DuplicateColumnNamesException> {
             dfGroup.select {
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt
index 18c8bd9f3e..cd98357945 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt
@@ -16,13 +16,21 @@ class ExplodeTests {
 
     @Test
     fun `explode list and duplicate value`() {
-        val exploded = dataFrameOf("a", "b")(1, listOf(2, 3)).explode()
+        val exploded = dataFrameOf(
+            "a", "b",
+        )(
+            1, listOf(2, 3),
+        ).explode()
         exploded shouldBe dataFrameOf("a", "b")(1, 2, 1, 3)
     }
 
     @Test
     fun `explode list and frame column`() {
-        val exploded = dataFrameOf("a", "b", "c", "d")(1, listOf(2, 3), dataFrameOf("x", "y")(4, 5, 6, 7), listOf(8))
+        val exploded = dataFrameOf(
+            "a", "b", "c", "d",
+        )(
+            1, listOf(2, 3), dataFrameOf("x", "y")(4, 5, 6, 7), listOf(8),
+        )
             .explode()
             .ungroup("c")
         exploded shouldBe dataFrameOf("a", "b", "x", "y", "d")(
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/flatten.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/flatten.kt
index 098f56e431..6dcd4a93d0 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/flatten.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/flatten.kt
@@ -55,10 +55,8 @@ class FlattenTests {
     fun `flatten nested`() {
         val df = dataFrameOf("a", "b", "c", "d")(1, 2, 3, 4)
         val grouped = df
-            .group("a", "b")
-            .into("e")
-            .group("e", "c")
-            .into("f")
+            .group("a", "b").into("e")
+            .group("e", "c").into("f")
 
         grouped.flatten() shouldBe df
         val flattened = grouped.flatten { "f"["e"] }
@@ -72,12 +70,9 @@ class FlattenTests {
     fun `flatten with parent name conflict`() {
         val df = dataFrameOf("a", "b", "c", "d")(1, 2, 3, 4)
         val grouped = df
-            .group("a", "b")
-            .into("e")
-            .group("e", "c")
-            .into("f")
-            .rename { "f"["e"] }
-            .into("a")
+            .group("a", "b").into("e")
+            .group("e", "c").into("f")
+            .rename { "f"["e"] }.into("a")
         val flattened = grouped.flatten { "f"["a"] }
         flattened.getColumnGroup("f").columnNames() shouldBe listOf("a", "b", "c")
         flattened.ungroup("f") shouldBe df
@@ -96,8 +91,7 @@ class FlattenTests {
         ).cast<Person>()
 
         val aggregate = df
-            .groupBy("city")
-            .aggregate {
+            .groupBy("city").aggregate {
                 mean() into "mean"
                 std() into "std"
             }
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt
index eb83fae634..60f44e27e0 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt
@@ -98,14 +98,11 @@ class GatherTests {
         val mode by column<String>()
         val temp by column<String>()
         val gathered = typed
-            .gather { allExcept(name) }
-            .cast<String>()
-            .into(mode, temp)
+            .gather { allExcept(name) }.cast<String>().into(mode, temp)
             .ungroup(temp)
 
         val expected = typed
-            .groupBy { name }
-            .updateGroups {
+            .groupBy { name }.updateGroups {
                 val cols = columns().drop(1).map { it.asColumnGroup() } // drop 'name' column
                 val dataRows = cols.map { it[0] }
 
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/get.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/get.kt
index 969f788979..5117b18687 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/get.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/get.kt
@@ -64,7 +64,12 @@ class GetTests {
         val df = dataFrameOf(
             columnOf(
                 dataFrameOf("a")(1),
-                dataFrameOf("a", "b")(2, 3, 4, 5),
+                dataFrameOf("a", "b")(
+                    2,
+                    3,
+                    4,
+                    5,
+                ),
             ).named("x"),
         )
         val x by frameColumn<Schema>()
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
index c0b21fcb0d..2632a649b4 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
@@ -48,18 +48,12 @@ class GroupByTests {
         )
         val grouped = df.groupBy("a", "b").into("d")
 
-        grouped
-            .groupBy("a")
-            .aggregate {
-                getColumn("d") into "e"
-            }["e"]
-            .type() shouldBe typeOf<List<AnyFrame>>()
+        grouped.groupBy("a").aggregate {
+            getColumn("d") into "e"
+        }["e"].type() shouldBe typeOf<List<AnyFrame>>()
 
-        grouped
-            .groupBy("a")
-            .aggregate {
-                getFrameColumn("d") into "e"
-            }["e"]
-            .type() shouldBe typeOf<List<AnyFrame>>()
+        grouped.groupBy("a").aggregate {
+            getFrameColumn("d") into "e"
+        }["e"].type() shouldBe typeOf<List<AnyFrame>>()
     }
 }
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 38fcae12fb..66a368144c 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
@@ -36,10 +36,9 @@ class MoveTests {
 
     @Test
     fun `batch ungrouping`() {
-        val ungrouped = grouped
-            .move {
-                colsAtAnyDepth { it.depth() > 0 && !it.isColumnGroup() }
-            }.into { pathOf(it.path.joinToString(".")) }
+        val ungrouped = grouped.move {
+            colsAtAnyDepth { it.depth() > 0 && !it.isColumnGroup() }
+        }.into { pathOf(it.path.joinToString(".")) }
         ungrouped.columnNames() shouldBe listOf("q", "a.b", "a.c.d", "b.c", "b.d", "w", "e.f", "r")
     }
 
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 aa6e094d1f..c85d05e797 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
@@ -144,12 +144,7 @@ class PivotTests {
             2, 1, 3,
             2, 1, 5,
         )
-        df
-            .pivot("a", inward = false)
-            .groupBy("b")
-            .default(-1)
-            .last()
-            .with { "c"<Int>() } shouldBe
+        df.pivot("a", inward = false).groupBy("b").default(-1).last().with { "c"<Int>() } shouldBe
             dataFrameOf("b", "1", "2")(
                 2, 3, -1,
                 0, 2, -1,
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt
index 4c1d569859..f28525a441 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt
@@ -60,10 +60,9 @@ class RenameTests : ColumnsSelectionDslTests() {
         val renamedDf = dataFrameOf("a_renamed", "b_renamed", "c_renamed")(
             1, 2, 3,
             4, 5, 6,
-        ).group { "a_renamed" and "b_renamed" }
-            .into("group_renamed")
-            .group { "group_renamed"["a_renamed"] }
-            .into { "group_renamed"["aGroup_renamed"] }
+        )
+            .group { "a_renamed" and "b_renamed" }.into("group_renamed")
+            .group { "group_renamed"["a_renamed"] }.into { "group_renamed"["aGroup_renamed"] }
 
         doubleGroupedDf
             .rename { colsAtAnyDepth() }
@@ -209,10 +208,8 @@ class RenameToCamelCaseTests {
         val df = deeplyNestedFrameColumn.renameToCamelCase()
         df.schema().asClue {
             shouldNotThrowAny {
-                df["col2"]
-                    .asAnyFrameColumn()
-                    .firstOrNull()!!["col1"]
-                    .asAnyFrameColumn()
+                df["col2"].asAnyFrameColumn()
+                    .firstOrNull()!!["col1"].asAnyFrameColumn()
                     .firstOrNull()!!["col0"]
             }
         }
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/split.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/split.kt
index 61cf51a430..7cdb7ef102 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/split.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/split.kt
@@ -42,11 +42,8 @@ class SplitTests {
         )
 
         val regex = """(.*) \((\d{4})\)""".toRegex()
-        val split = title
-            .toDataFrame()
-            .split { title }
-            .match(regex)
-            .into("title", "year")
+        val split = title.toDataFrame()
+            .split { title }.match(regex).into("title", "year")
             .parse()
         split.schema().print()
         split["title"].hasNulls shouldBe false
@@ -62,17 +59,10 @@ class SplitTests {
             3, 6, 7,
         )
         val res = df
-            .groupBy("a")
-            .updateGroups { it.remove("a") }
-            .into("g")
-            .update("g")
-            .at(1)
-            .with { DataFrame.empty() }
-            .update("g")
-            .at(2)
-            .withNull()
-            .split { "g"<AnyFrame>() }
-            .intoColumns()
+            .groupBy("a").updateGroups { it.remove("a") }.into("g")
+            .update("g").at(1).with { DataFrame.empty() }
+            .update("g").at(2).withNull()
+            .split { "g"<AnyFrame>() }.intoColumns()
             .ungroup("g")
         res shouldBe dataFrameOf("a", "b", "c")(
             1, listOf(2, 4), listOf(3, 5),
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/toList.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/toList.kt
index 9206f80a5a..7feb89ab67 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/toList.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/toList.kt
@@ -17,9 +17,7 @@ class DataClassesTests {
             Record("female", 5, 20),
             Record("female", 6, 15),
         ).toDataFrame()
-            .pivot(Record::sex, inward = false)
-            .groupBy(Record::grade)
-            .values(Record::count)
+            .pivot(Record::sex, inward = false).groupBy(Record::grade).values(Record::count)
             .toListOf<PivotedRecord>() shouldBe
             listOf(
                 PivotedRecord(5, 10, 20),
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeGenerationTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeGenerationTests.kt
index d563f88fd6..960f40bea3 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeGenerationTests.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeGenerationTests.kt
@@ -222,18 +222,15 @@ class CodeGenerationTests : BaseTest() {
     fun `generate derived interface`() {
         val codeGen = CodeGenerator.create()
         val schema = df.dropNulls().schema()
-        val code = codeGen
-            .generate(
-                schema = schema,
-                name = "ValidPerson",
-                fields = true,
-                extensionProperties = true,
-                isOpen = true,
-                visibility = MarkerVisibility.IMPLICIT_PUBLIC,
-                knownMarkers = listOf(
-                    MarkersExtractor.get<Person>(),
-                ),
-            ).code.declarations
+        val code = codeGen.generate(
+            schema = schema,
+            name = "ValidPerson",
+            fields = true,
+            extensionProperties = true,
+            isOpen = true,
+            visibility = MarkerVisibility.IMPLICIT_PUBLIC,
+            knownMarkers = listOf(MarkersExtractor.get<Person>()),
+        ).code.declarations
         val packageName = "org.jetbrains.kotlinx.dataframe"
         val expected =
             """
@@ -310,15 +307,14 @@ class CodeGenerationTests : BaseTest() {
     @Test
     fun `declaration with explicit public visibility`() {
         val repl = CodeGenerator.create()
-        val code = repl
-            .generate(
-                typed.schema(),
-                "DataType",
-                true,
-                true,
-                false,
-                MarkerVisibility.EXPLICIT_PUBLIC,
-            ).code.declarations
+        val code = repl.generate(
+            typed.schema(),
+            "DataType",
+            true,
+            true,
+            false,
+            MarkerVisibility.EXPLICIT_PUBLIC,
+        ).code.declarations
         val packageName = "org.jetbrains.kotlinx.dataframe"
         code shouldBe
             """
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/NameGenerationTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/NameGenerationTests.kt
index 4bc6f59e8e..87e97df689 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/NameGenerationTests.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/NameGenerationTests.kt
@@ -17,16 +17,15 @@ class NameGenerationTests {
     @Test
     fun `interface generation`() {
         val codeGen = CodeGenerator.create()
-        val code = codeGen
-            .generate(
-                schema = df.schema(),
-                name = "DataType",
-                fields = true,
-                extensionProperties = false,
-                isOpen = false,
-                visibility = MarkerVisibility.IMPLICIT_PUBLIC,
-                knownMarkers = emptyList(),
-            ).code
+        val code = codeGen.generate(
+            schema = df.schema(),
+            name = "DataType",
+            fields = true,
+            extensionProperties = false,
+            isOpen = false,
+            visibility = MarkerVisibility.IMPLICIT_PUBLIC,
+            knownMarkers = emptyList(),
+        ).code
 
         val expected =
             """
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/explainer/PluginCallbackProxy.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/explainer/PluginCallbackProxy.kt
index 09b2bd2f54..0f6cafbbe5 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/explainer/PluginCallbackProxy.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/explainer/PluginCallbackProxy.kt
@@ -95,15 +95,15 @@ object PluginCallbackProxy : PluginCallback {
                             body =
                                 """
                                 <details>
-                                <summary>${expressions.joinToString(".") { it.source }
-                                    .also {
+                                <summary>${
+                                    expressions.joinToString(".") { it.source }.also {
                                         if (it.length > 95) {
                                             TODO(
                                                 "expression is too long ${it.length}. better to split sample in multiple snippets",
                                             )
                                         }
-                                    }
-                                    .escapeHtmlForIFrame()}</summary>
+                                    }.escapeHtmlForIFrame()
+                                }</summary>
                                 ${details.body}
                                 </details>
                                 <br>
@@ -247,20 +247,19 @@ private fun convertToHTML(dataframeLike: Any): DataFrameHtmlData {
         is Gather<*, *, *, *> -> dataframeLike.into("key", "value").toHTML()
 
         is Update<*, *> ->
-            dataframeLike.df
-                .let {
-                    var it = it.format(
-                        dataframeLike.columns as ColumnsSelectionDsl<Any?>.(
-                            it: ColumnsSelectionDsl<Any?>,
-                        ) -> ColumnsResolver<*>,
-                    )
-                    if (dataframeLike.filter != null) {
-                        it = it.where(dataframeLike.filter as RowValueFilter<Any?, Any?>)
-                    }
-                    it.with {
-                        background(rgb(152, 251, 152))
-                    }
-                }.toHTML1()
+            dataframeLike.df.let {
+                var it = it.format(
+                    dataframeLike.columns as ColumnsSelectionDsl<Any?>.(
+                        it: ColumnsSelectionDsl<Any?>,
+                    ) -> ColumnsResolver<*>,
+                )
+                if (dataframeLike.filter != null) {
+                    it = it.where(dataframeLike.filter as RowValueFilter<Any?, Any?>)
+                }
+                it.with {
+                    background(rgb(152, 251, 152))
+                }
+            }.toHTML1()
 
         is Convert<*, *> -> DataFrameHtmlData(body = "<p>${dataframeLike::class}</p>")
 
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/CsvTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/CsvTests.kt
index ea0e126ed1..43efdc8c99 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/CsvTests.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/CsvTests.kt
@@ -246,8 +246,7 @@ class CsvTests {
         )
         df.writeCSV(
             "src/test/resources/without_header.csv",
-            CSVFormat.DEFAULT
-                .builder()
+            CSVFormat.DEFAULT.builder()
                 .setSkipHeaderRecord(true)
                 .build(),
         )
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ParserTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ParserTests.kt
index c4b3b8b769..d2980240bc 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ParserTests.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ParserTests.kt
@@ -92,28 +92,16 @@ class ParserTests {
 
         datetimeCol.shouldBe(
             columnOf(
-                java.time.LocalDateTime
-                    .of(1971, 1, 2, 0, 0, 1)
-                    .toKotlinLocalDateTime(),
-                java.time.LocalDateTime
-                    .of(1971, 1, 2, 0, 1, 0)
-                    .toKotlinLocalDateTime(),
-                java.time.LocalDateTime
-                    .of(1971, 1, 2, 1, 0, 0)
-                    .toKotlinLocalDateTime(),
+                java.time.LocalDateTime.of(1971, 1, 2, 0, 0, 1).toKotlinLocalDateTime(),
+                java.time.LocalDateTime.of(1971, 1, 2, 0, 1, 0).toKotlinLocalDateTime(),
+                java.time.LocalDateTime.of(1971, 1, 2, 1, 0, 0).toKotlinLocalDateTime(),
             ),
         )
         longCol.convertToLocalDate(TimeZone.UTC).shouldBe(
             columnOf(
-                java.time.LocalDate
-                    .of(1971, 1, 2)
-                    .toKotlinLocalDate(),
-                java.time.LocalDate
-                    .of(1971, 1, 2)
-                    .toKotlinLocalDate(),
-                java.time.LocalDate
-                    .of(1971, 1, 2)
-                    .toKotlinLocalDate(),
+                java.time.LocalDate.of(1971, 1, 2).toKotlinLocalDate(),
+                java.time.LocalDate.of(1971, 1, 2).toKotlinLocalDate(),
+                java.time.LocalDate.of(1971, 1, 2).toKotlinLocalDate(),
             ),
         )
         longCol.convertToLocalTime(TimeZone.UTC).shouldBe(
@@ -126,15 +114,9 @@ class ParserTests {
 
         datetimeCol.convertToLocalDate().shouldBe(
             columnOf(
-                java.time.LocalDate
-                    .of(1971, 1, 2)
-                    .toKotlinLocalDate(),
-                java.time.LocalDate
-                    .of(1971, 1, 2)
-                    .toKotlinLocalDate(),
-                java.time.LocalDate
-                    .of(1971, 1, 2)
-                    .toKotlinLocalDate(),
+                java.time.LocalDate.of(1971, 1, 2).toKotlinLocalDate(),
+                java.time.LocalDate.of(1971, 1, 2).toKotlinLocalDate(),
+                java.time.LocalDate.of(1971, 1, 2).toKotlinLocalDate(),
             ),
         )
         datetimeCol.convertToLocalTime().shouldBe(
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 49287a2848..c1df64b330 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
@@ -118,8 +118,7 @@ class PlaylistJsonTest {
     @Test
     fun `deep update`() {
         val updated = item.convert { snippet.thumbnails.default.url }.with { IMG(it) }
-        updated.snippet.thumbnails.default.url
-            .type() shouldBe typeOf<IMG>()
+        updated.snippet.thumbnails.default.url.type() shouldBe typeOf<IMG>()
     }
 
     @Test
@@ -131,10 +130,8 @@ class PlaylistJsonTest {
     @Test
     fun `deep batch update`() {
         val updated = item.convert { snippet.thumbnails.default.url and snippet.thumbnails.high.url }.with { IMG(it) }
-        updated.snippet.thumbnails.default.url
-            .type() shouldBe typeOf<IMG>()
-        updated.snippet.thumbnails.high.url
-            .type() shouldBe typeOf<IMG>()
+        updated.snippet.thumbnails.default.url.type() shouldBe typeOf<IMG>()
+        updated.snippet.thumbnails.high.url.type() shouldBe typeOf<IMG>()
     }
 
     @Test
@@ -142,16 +139,11 @@ class PlaylistJsonTest {
         val updated = item
             .convert { colsAtAnyDepth { it.name() == "url" } }
             .with { (it as? String)?.let { IMG(it) } }
-        updated.snippet.thumbnails.default.url
-            .type() shouldBe typeOf<IMG>()
-        updated.snippet.thumbnails.maxres.url
-            .type() shouldBe typeOf<IMG?>()
-        updated.snippet.thumbnails.standard.url
-            .type() shouldBe typeOf<IMG?>()
-        updated.snippet.thumbnails.medium.url
-            .type() shouldBe typeOf<IMG>()
-        updated.snippet.thumbnails.high.url
-            .type() shouldBe typeOf<IMG>()
+        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?>()
+        updated.snippet.thumbnails.medium.url.type() shouldBe typeOf<IMG>()
+        updated.snippet.thumbnails.high.url.type() shouldBe typeOf<IMG>()
     }
 
     @Test
@@ -163,7 +155,9 @@ class PlaylistJsonTest {
     @Test
     fun `deep remove`() {
         val item2 = item.remove {
-            snippet.thumbnails.default and snippet.thumbnails.maxres and snippet.channelId and
+            snippet.thumbnails.default and
+                snippet.thumbnails.maxres and
+                snippet.channelId and
                 etag
         }
         item2.columnsCount() shouldBe item.columnsCount() - 1
@@ -174,7 +168,9 @@ class PlaylistJsonTest {
     @Test
     fun `remove all from group`() {
         val item2 = item.remove {
-            snippet.thumbnails.default and snippet.thumbnails.maxres and snippet.thumbnails.medium and
+            snippet.thumbnails.default and
+                snippet.thumbnails.maxres and
+                snippet.thumbnails.medium and
                 snippet.thumbnails.high and
                 snippet.thumbnails.standard
         }
@@ -184,7 +180,8 @@ class PlaylistJsonTest {
 
     @Test
     fun `deep move with rename`() {
-        val moved = item.move { snippet.thumbnails.default }.into { snippet.path() + "movedDefault" }
+        val moved = item
+            .move { snippet.thumbnails.default }.into { snippet.path() + "movedDefault" }
         moved.snippet.thumbnails.columnNames() shouldBe item.snippet.thumbnails
             .remove { default }
             .columnNames()
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt
index fb2212bc6b..730978aad5 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt
@@ -72,8 +72,7 @@ class JsonTests {
                 [5, "e"]                
             ]
             """.trimIndent()
-        val df = DataFrame
-            .readJsonStr(json, header = listOf("numbers", "letters"))
+        val df = DataFrame.readJsonStr(json, header = listOf("numbers", "letters"))
             .alsoDebug()
 
         df.columnsCount() shouldBe 2
@@ -97,8 +96,7 @@ class JsonTests {
                 [5, "e"]                
             ]
             """.trimIndent()
-        val df = DataFrame
-            .readJsonStr(json, header = listOf("numbers", "letters"), typeClashTactic = ANY_COLUMNS)
+        val df = DataFrame.readJsonStr(json, header = listOf("numbers", "letters"), typeClashTactic = ANY_COLUMNS)
             .alsoDebug()
 
         df.columnsCount() shouldBe 2
@@ -119,9 +117,7 @@ class JsonTests {
                 {"a":2, "b":5, "c":4.5}
             ]
             """.trimIndent()
-        val df = DataFrame
-            .readJsonStr(json)
-            .alsoDebug()
+        val df = DataFrame.readJsonStr(json).alsoDebug()
         df.columnsCount() shouldBe 3
         df.rowsCount() shouldBe 2
         df["a"].type() shouldBe typeOf<Int>()
@@ -139,9 +135,7 @@ class JsonTests {
                 {"a":2, "b":5, "c":4.5}
             ]
             """.trimIndent()
-        val df = DataFrame
-            .readJsonStr(json, typeClashTactic = ANY_COLUMNS)
-            .alsoDebug()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS).alsoDebug()
         df.columnsCount() shouldBe 3
         df.rowsCount() shouldBe 2
         df["a"].type() shouldBe typeOf<Int>()
@@ -160,9 +154,7 @@ class JsonTests {
                 {"a":[6,7,8]}
             ]
             """.trimIndent()
-        val df = DataFrame
-            .readJsonStr(json)
-            .alsoDebug()
+        val df = DataFrame.readJsonStr(json).alsoDebug()
         df.columnsCount() shouldBe 1
         df.rowsCount() shouldBe 3
         val group = df["a"] as ColumnGroup<*>
@@ -183,9 +175,7 @@ class JsonTests {
                 {"a":[6,7,8]}
             ]
             """.trimIndent()
-        val df = DataFrame
-            .readJsonStr(json, typeClashTactic = ANY_COLUMNS)
-            .alsoDebug()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS).alsoDebug()
         df.columnsCount() shouldBe 1
         df.rowsCount() shouldBe 3
         val a = df["a"] as ValueColumn<*>
@@ -206,9 +196,7 @@ class JsonTests {
                 {"a":[3.4, 5.6]}
             ]
             """.trimIndent()
-        val df = DataFrame
-            .readJsonStr(json)
-            .alsoDebug()
+        val df = DataFrame.readJsonStr(json).alsoDebug()
         df.columnsCount() shouldBe 1
         df.rowsCount() shouldBe 3
         df["a"].type() shouldBe typeOf<List<Number>>()
@@ -226,9 +214,7 @@ class JsonTests {
                 {"a":[3.4, 5.6]}
             ]
             """.trimIndent()
-        val df = DataFrame
-            .readJsonStr(json, typeClashTactic = ANY_COLUMNS)
-            .alsoDebug()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS).alsoDebug()
         df.columnsCount() shouldBe 1
         df.rowsCount() shouldBe 3
         df["a"].type() shouldBe typeOf<List<Number>>()
@@ -245,37 +231,31 @@ class JsonTests {
                 {"a":[ {"b":4}, {"d":5} ]}
             ]
             """.trimIndent()
-        val df = DataFrame
-            .readJsonStr(json)
-            .alsoDebug()
+        val df = DataFrame.readJsonStr(json).alsoDebug()
         df.columnsCount() shouldBe 1
         df.rowsCount() shouldBe 2
         val group = df["a"] as FrameColumn<*>
-        group[0]
-            .alsoDebug()
-            .let {
-                it.columnsCount() shouldBe 3
-                it.rowsCount() shouldBe 2
-                it["b"].type() shouldBe typeOf<Int?>()
-                it["c"].type() shouldBe typeOf<Int?>()
-                it["d"].type() shouldBe typeOf<Int?>()
-                it["b"].values.toList() shouldBe listOf(2, null)
-                it["c"].values.toList() shouldBe listOf(null, 3)
-                it["d"].values.toList() shouldBe listOf(null, null)
-            }
+        group[0].alsoDebug().let {
+            it.columnsCount() shouldBe 3
+            it.rowsCount() shouldBe 2
+            it["b"].type() shouldBe typeOf<Int?>()
+            it["c"].type() shouldBe typeOf<Int?>()
+            it["d"].type() shouldBe typeOf<Int?>()
+            it["b"].values.toList() shouldBe listOf(2, null)
+            it["c"].values.toList() shouldBe listOf(null, 3)
+            it["d"].values.toList() shouldBe listOf(null, null)
+        }
 
-        group[1]
-            .alsoDebug()
-            .let {
-                it.columnsCount() shouldBe 3
-                it.rowsCount() shouldBe 2
-                it["b"].type() shouldBe typeOf<Int?>()
-                it["c"].type() shouldBe typeOf<Int?>()
-                it["d"].type() shouldBe typeOf<Int?>()
-                it["b"].values.toList() shouldBe listOf(4, null)
-                it["c"].values.toList() shouldBe listOf(null, null)
-                it["d"].values.toList() shouldBe listOf(null, 5)
-            }
+        group[1].alsoDebug().let {
+            it.columnsCount() shouldBe 3
+            it.rowsCount() shouldBe 2
+            it["b"].type() shouldBe typeOf<Int?>()
+            it["c"].type() shouldBe typeOf<Int?>()
+            it["d"].type() shouldBe typeOf<Int?>()
+            it["b"].values.toList() shouldBe listOf(4, null)
+            it["c"].values.toList() shouldBe listOf(null, null)
+            it["d"].values.toList() shouldBe listOf(null, 5)
+        }
     }
 
     @Test
@@ -288,37 +268,31 @@ class JsonTests {
                 {"a":[ {"b":4}, {"d":5} ]}
             ]
             """.trimIndent()
-        val df = DataFrame
-            .readJsonStr(json, typeClashTactic = ANY_COLUMNS)
-            .alsoDebug()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS).alsoDebug()
         df.columnsCount() shouldBe 1
         df.rowsCount() shouldBe 2
         val group = df["a"] as FrameColumn<*>
-        group[0]
-            .alsoDebug()
-            .let {
-                it.columnsCount() shouldBe 3
-                it.rowsCount() shouldBe 2
-                it["b"].type() shouldBe typeOf<Int?>()
-                it["c"].type() shouldBe typeOf<Int?>()
-                it["d"].type() shouldBe typeOf<Int?>()
-                it["b"].values.toList() shouldBe listOf(2, null)
-                it["c"].values.toList() shouldBe listOf(null, 3)
-                it["d"].values.toList() shouldBe listOf(null, null)
-            }
+        group[0].alsoDebug().let {
+            it.columnsCount() shouldBe 3
+            it.rowsCount() shouldBe 2
+            it["b"].type() shouldBe typeOf<Int?>()
+            it["c"].type() shouldBe typeOf<Int?>()
+            it["d"].type() shouldBe typeOf<Int?>()
+            it["b"].values.toList() shouldBe listOf(2, null)
+            it["c"].values.toList() shouldBe listOf(null, 3)
+            it["d"].values.toList() shouldBe listOf(null, null)
+        }
 
-        group[1]
-            .alsoDebug()
-            .let {
-                it.columnsCount() shouldBe 3
-                it.rowsCount() shouldBe 2
-                it["b"].type() shouldBe typeOf<Int?>()
-                it["c"].type() shouldBe typeOf<Int?>()
-                it["d"].type() shouldBe typeOf<Int?>()
-                it["b"].values.toList() shouldBe listOf(4, null)
-                it["c"].values.toList() shouldBe listOf(null, null)
-                it["d"].values.toList() shouldBe listOf(null, 5)
-            }
+        group[1].alsoDebug().let {
+            it.columnsCount() shouldBe 3
+            it.rowsCount() shouldBe 2
+            it["b"].type() shouldBe typeOf<Int?>()
+            it["c"].type() shouldBe typeOf<Int?>()
+            it["d"].type() shouldBe typeOf<Int?>()
+            it["b"].values.toList() shouldBe listOf(4, null)
+            it["c"].values.toList() shouldBe listOf(null, null)
+            it["d"].values.toList() shouldBe listOf(null, 5)
+        }
     }
 
     @Test
@@ -333,9 +307,7 @@ class JsonTests {
                 {"a":[{"a": "b"}, {"a" : "c"}, {"a" : "d"}]}
             ]
             """.trimIndent()
-        val df = DataFrame
-            .readJsonStr(json)
-            .alsoDebug()
+        val df = DataFrame.readJsonStr(json).alsoDebug()
         df.columnsCount() shouldBe 1
         df.rowsCount() shouldBe 4
         val group = df["a"] as ColumnGroup<*>
@@ -347,15 +319,12 @@ class JsonTests {
         nestedDf["a"].type() shouldBe typeOf<String?>()
         nestedDf["value"].type() shouldBe typeOf<Int?>()
         nestedDf["array"].type() shouldBe typeOf<DataFrame<*>>()
-        group
-            .getFrameColumn("array")[3]
-            .alsoDebug()
-            .let {
-                it.columnsCount() shouldBe 3
-                it.rowsCount() shouldBe 3
-                it["a"].type() shouldBe typeOf<String>()
-                it["a"].values.toList() shouldBe listOf("b", "c", "d")
-            }
+        group.getFrameColumn("array")[3].alsoDebug().let {
+            it.columnsCount() shouldBe 3
+            it.rowsCount() shouldBe 3
+            it["a"].type() shouldBe typeOf<String>()
+            it["a"].values.toList() shouldBe listOf("b", "c", "d")
+        }
     }
 
     @Test
@@ -607,9 +576,7 @@ class JsonTests {
                 null
             ]
             """.trimIndent()
-        val df = DataFrame
-            .readJsonStr(json)
-            .alsoDebug()
+        val df = DataFrame.readJsonStr(json).alsoDebug()
         df.columnsCount() shouldBe 2
         df.rowsCount() shouldBe 4
         df["c"].type() shouldBe typeOf<Int?>()
@@ -640,9 +607,7 @@ class JsonTests {
                 null
             ]
             """.trimIndent()
-        val df = DataFrame
-            .readJsonStr(json, typeClashTactic = ANY_COLUMNS)
-            .alsoDebug()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS).alsoDebug()
         df.columnsCount() shouldBe 2
         df.rowsCount() shouldBe 4
         val c = df["c"] as ValueColumn<*>
@@ -678,9 +643,7 @@ class JsonTests {
                 null
             ]
             """.trimIndent()
-        val df = DataFrame
-            .readJsonStr(json, typeClashTactic = ANY_COLUMNS)
-            .alsoDebug()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS).alsoDebug()
         df.columnsCount() shouldBe 1
         df.rowsCount() shouldBe 7
         val a = df["a"] as ColumnGroup<*>
@@ -707,9 +670,7 @@ class JsonTests {
                 null
             ]
             """.trimIndent()
-        val df = DataFrame
-            .readJsonStr(json, typeClashTactic = ANY_COLUMNS)
-            .alsoDebug()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS).alsoDebug()
         df.columnsCount() shouldBe 1
         df.rowsCount() shouldBe 6
         val a = df["a"] as ValueColumn<*>
@@ -735,9 +696,7 @@ class JsonTests {
                 null
             ]
             """.trimIndent()
-        val df = DataFrame
-            .readJsonStr(json, typeClashTactic = ANY_COLUMNS)
-            .alsoDebug()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS).alsoDebug()
         df.columnsCount() shouldBe 1
         df.rowsCount() shouldBe 6
         val a = df["a"] as FrameColumn<*>
@@ -776,12 +735,11 @@ class JsonTests {
                 {"a":1}
             ]
             """.trimIndent()
-        val df = DataFrame
-            .readJsonStr(
-                text = json,
-                typeClashTactic = ARRAY_AND_VALUE_COLUMNS,
-                keyValuePaths = listOf(JsonPath()),
-            ).alsoDebug()
+        val df = DataFrame.readJsonStr(
+            text = json,
+            typeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+            keyValuePaths = listOf(JsonPath()),
+        ).alsoDebug()
     }
 
     @Test
@@ -795,12 +753,11 @@ class JsonTests {
                 {"a":1}
             ]
             """.trimIndent()
-        val df = DataFrame
-            .readJsonStr(
-                text = json,
-                typeClashTactic = ANY_COLUMNS,
-                keyValuePaths = listOf(JsonPath()),
-            ).alsoDebug()
+        val df = DataFrame.readJsonStr(
+            text = json,
+            typeClashTactic = ANY_COLUMNS,
+            keyValuePaths = listOf(JsonPath()),
+        ).alsoDebug()
     }
 
     @Test
@@ -819,8 +776,7 @@ class JsonTests {
             """.trimIndent()
 
         // before
-        val noKeyValue = DataFrame
-            .readJsonStr(json, typeClashTactic = ARRAY_AND_VALUE_COLUMNS)
+        val noKeyValue = DataFrame.readJsonStr(json, typeClashTactic = ARRAY_AND_VALUE_COLUMNS)
             .alsoDebug()
 
 //        ⌌-------------------------------------------------------⌍
@@ -871,8 +827,7 @@ class JsonTests {
 
         // after
         val withKeyValue =
-            DataFrame
-                .readJsonStr(json, keyValuePaths = keyValuePaths, typeClashTactic = ARRAY_AND_VALUE_COLUMNS)
+            DataFrame.readJsonStr(json, keyValuePaths = keyValuePaths, typeClashTactic = ARRAY_AND_VALUE_COLUMNS)
                 .alsoDebug()
                 .also {
                     it["a"][1].let { it as AnyFrame }.alsoDebug()
@@ -946,8 +901,7 @@ class JsonTests {
             """.trimIndent()
 
         // before
-        val noKeyValue = DataFrame
-            .readJsonStr(json, typeClashTactic = ANY_COLUMNS)
+        val noKeyValue = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS)
             .alsoDebug()
 
 //        ⌌------------------------------⌍
@@ -983,12 +937,13 @@ class JsonTests {
         )
 
         // after
-        val withKeyValue = DataFrame
-            .readJsonStr(json, keyValuePaths = keyValuePaths, typeClashTactic = ANY_COLUMNS)
-            .alsoDebug()
-            .also {
-                it["a"][1].let { it as AnyFrame }.alsoDebug()
-            }
+        val withKeyValue = DataFrame.readJsonStr(
+            text = json,
+            keyValuePaths = keyValuePaths,
+            typeClashTactic = ANY_COLUMNS,
+        ).alsoDebug().also {
+            it["a"][1].let { it as AnyFrame }.alsoDebug()
+        }
 
 //        ⌌------------------------------⌍
 //        |  | a:[key:String, value:Any?]|
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/RenderingTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/RenderingTests.kt
index 08b29f49ce..f4fc065a23 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/RenderingTests.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/RenderingTests.kt
@@ -382,12 +382,10 @@ class RenderingTests : JupyterReplTestCase() {
         assertDataFrameDimensions(json, 2, 2)
 
         val rows = json[KOTLIN_DATAFRAME]!!.jsonArray
-        rows
-            .getObj(0)["group1"]!!
+        rows.getObj(0)["group1"]!!
             .jsonObject[DATA]!!
             .jsonArray.size shouldBe 10
-        rows
-            .getObj(1)["group1"]!!
+        rows.getObj(1)["group1"]!!
             .jsonObject[DATA]!!
             .jsonArray.size shouldBe 10
     }
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
index 4385dfdd54..822e44b3ba 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
@@ -16,7 +16,7 @@ class SampleNotebooksTests : DataFrameJupyterTest() {
     @Test
     fun github() =
         exampleTest(
-            "github",
+            dir = "github",
             cellClause = CellClause.stopAfter { cell ->
                 "personal access token" in cell.source
             },
@@ -29,8 +29,8 @@ class SampleNotebooksTests : DataFrameJupyterTest() {
     @Ignore
     fun titanic() =
         exampleTest(
-            "titanic",
-            "Titanic",
+            dir = "titanic",
+            notebookName = "Titanic",
             replacer = CodeReplacer.byMap(
                 "../../idea-examples/" to "$IDEA_EXAMPLES_PATH/",
             ),
@@ -40,8 +40,8 @@ class SampleNotebooksTests : DataFrameJupyterTest() {
     @Ignore
     fun wine() =
         exampleTest(
-            "wine",
-            "WineNetWIthKotlinDL",
+            dir = "wine",
+            notebookName = "WineNetWIthKotlinDL",
             replacer = CodeReplacer.byMap(
                 testFile("wine", "winequality-red.csv"),
             ),
@@ -56,7 +56,7 @@ class SampleNotebooksTests : DataFrameJupyterTest() {
             Locale.setDefault(Locale.forLanguageTag("en-US"))
 
             exampleTest(
-                "netflix",
+                dir = "netflix",
                 replacer = CodeReplacer.byMap(
                     testFile("netflix", "country_codes.csv"),
                     testFile("netflix", "netflix_titles.csv"),
@@ -71,7 +71,7 @@ class SampleNotebooksTests : DataFrameJupyterTest() {
     @Ignore
     fun movies() =
         exampleTest(
-            "movies",
+            dir = "movies",
             replacer = CodeReplacer.byMap(
                 "ml-latest/movies.csv" to "$IDEA_EXAMPLES_PATH/movies/src/main/resources/movies.csv",
             ),
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/CleaningDataTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/CleaningDataTests.kt
index 78b67c3adf..2e91b03591 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/CleaningDataTests.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/CleaningDataTests.kt
@@ -47,21 +47,15 @@ class CleaningDataTests {
     fun `interpolate test`() {
         val expected = columnOf(10045, 10055, 10065, 10075, 10085).named("FlightNumber")
 
-        df
-            .update { flightNumber }
-            .where { it.isNaN() }
-            .with { prev()!![flightNumber] + (next()!![flightNumber] - prev()!![flightNumber]) / 2 }
-            .convert { flightNumber }
-            .toInt()[flightNumber] shouldBe expected
-
-        df
-            .update { "FlightNumber"<Double>() }
-            .where { it.isNaN() }
-            .with {
-                prev()!![{ "FlightNumber"<Double>() }] +
-                    (next()!![{ "FlightNumber"<Double>() }] - prev()!![{ "FlightNumber"<Double>() }]) / 2
-            }.convert { flightNumber }
-            .toInt()["FlightNumber"] shouldBe expected
+        df.update { flightNumber }.where { it.isNaN() }.with {
+            prev()!![flightNumber] + (next()!![flightNumber] - prev()!![flightNumber]) / 2
+        }.convert { flightNumber }.toInt()[flightNumber] shouldBe expected
+
+        df.update { "FlightNumber"<Double>() }.where { it.isNaN() }.with {
+            prev()!![{ "FlightNumber"<Double>() }] + (
+                next()!![{ "FlightNumber"<Double>() }] - prev()!![{ "FlightNumber"<Double>() }]
+            ) / 2
+        }.convert { flightNumber }.toInt()["FlightNumber"] shouldBe expected
     }
 
     @Test
@@ -91,19 +85,13 @@ class CleaningDataTests {
             "Brussels", "London",
         )
 
-        df
-            .split { fromTo }
-            .by('_')
-            .into("From", "To")[from, to]
-            .update { from and to }
-            .with { it.lowercase().replaceFirstChar(Char::uppercase) } shouldBe expected
-
-        df
-            .split { "From_To"<String>() }
-            .by('_')
-            .into("From", "To")["From", "To"]
-            .update { "From"<String>() and "To"<_>() }
-            .with { it.lowercase().replaceFirstChar(Char::uppercase) } shouldBe expected
+        df.split { fromTo }.by('_').into("From", "To")[from, to]
+            .update { from and to }.with { it.lowercase().replaceFirstChar(Char::uppercase) } shouldBe expected
+
+        df.split { "From_To"<String>() }.by('_').into("From", "To")["From", "To"]
+            .update { "From"<String>() and "To"<_>() }.with {
+                it.lowercase().replaceFirstChar(Char::uppercase)
+            } shouldBe expected
     }
 
     @Test
@@ -133,18 +121,12 @@ class CleaningDataTests {
             67.0, 32.0, Double.NaN,
         )
 
-        df
-            .convert { recentDelays }
-            .with { it.map { d -> d.toDouble() } }
-            .split { recentDelays }
-            .default(Double.NaN)
-            .into { "delay_$it" }[delay1, delay2, delay3] shouldBe expected
-
-        df
-            .convert { "RecentDelays"<List<Int>>() }
-            .with { it.map { d -> d.toDouble() } }
-            .split { "RecentDelays"<List<Double>>() }
-            .default(Double.NaN)
-            .into { "delay_$it" }[delay1, delay2, delay3] shouldBe expected
+        df.convert { recentDelays }.with { it.map { d -> d.toDouble() } }
+            .split { recentDelays }.default(Double.NaN).into { "delay_$it" }[delay1, delay2, delay3] shouldBe expected
+
+        df.convert { "RecentDelays"<List<Int>>() }.with { it.map { d -> d.toDouble() } }
+            .split { "RecentDelays"<List<Double>>() }.default(Double.NaN).into {
+                "delay_$it"
+            }[delay1, delay2, delay3] shouldBe expected
     }
 }
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/DateTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/DateTests.kt
index 485b88b946..9358d9d00c 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/DateTests.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/DateTests.kt
@@ -72,26 +72,22 @@ class DateTests {
         val month4 by column<Int>()
         val month41 by column<Int>()
 
-        df
-            .add("month4") {
-                when (dti().monthNumber) {
-                    in 1..4 -> 1
-                    in 5..8 -> 2
-                    else -> 3
-                }
-            }.groupBy("month4")
-            .aggregate { maxBy(s) into "max" }
+        df.add("month4") {
+            when (dti().monthNumber) {
+                in 1..4 -> 1
+                in 5..8 -> 2
+                else -> 3
+            }
+        }.groupBy("month4").aggregate { maxBy(s) into "max" }
             .flatten()[month4, dti, month41] shouldBe expected
 
-        df
-            .add("month4") {
-                when ("dti"<LocalDate>().monthNumber) {
-                    in 1..4 -> 1
-                    in 5..8 -> 2
-                    else -> 3
-                }
-            }.groupBy("month4")
-            .aggregate { maxBy("s") into "max" }
+        df.add("month4") {
+            when ("dti"<LocalDate>().monthNumber) {
+                in 1..4 -> 1
+                in 5..8 -> 2
+                else -> 3
+            }
+        }.groupBy("month4").aggregate { maxBy("s") into "max" }
             .flatten()["month4", "dti", "month41"] shouldBe expected
     }
 
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/HardTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/HardTests.kt
index 41a66f473d..8ab0a78dac 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/HardTests.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/HardTests.kt
@@ -57,19 +57,13 @@ class HardTests {
 
         val expected = dataFrameOf("index", "name")(0, "d", 2, "c", 3, "f")
 
-        df
-            .add("index") { index() }
-            .gather { dropLast() }
-            .into("name", "vals")
-            .sortByDesc { vals }
-            .take(3)[index, name] shouldBe expected
-
-        df
-            .add("index") { index() }
-            .gather { dropLast() }
-            .into("name", "vals")
-            .sortByDesc("vals")
-            .take(3)["index", "name"] shouldBe expected
+        df.add("index") { index() }
+            .gather { dropLast() }.into("name", "vals")
+            .sortByDesc { vals }.take(3)[index, name] shouldBe expected
+
+        df.add("index") { index() }
+            .gather { dropLast() }.into("name", "vals")
+            .sortByDesc("vals").take(3)["index", "name"] shouldBe expected
     }
 
     @Test
@@ -102,10 +96,8 @@ class HardTests {
 
         val means = df
             .filter { vals >= 0 }
-            .groupBy { grps }
-            .mean()
-            .pivot { grps }
-            .values { vals }
+            .groupBy { grps }.mean()
+            .pivot { grps }.values { vals }
 
         df.add("patched_values") {
             if (vals() < 0) means[grps()] as Double else vals().toDouble()
@@ -113,10 +105,8 @@ class HardTests {
 
         val meansStr = df
             .filter { "vals"<Int>() >= 0 }
-            .groupBy("grps")
-            .mean()
-            .pivot("grps")
-            .values("vals")
+            .groupBy("grps").mean()
+            .pivot("grps").values("vals")
 
         df.add("patched_values") {
             if ("vals"<Int>() < 0) meansStr["grps"<String>()] as Double else "vals"<Int>().toDouble()
@@ -144,10 +134,8 @@ class HardTests {
             "b", 8.0, 4.0,
         )
 
-        df
-            .add("id") { index() }
-            .groupBy { groups }
-            .add("res") {
+        df.add("id") { index() }
+            .groupBy { groups }.add("res") {
                 round(relative(-2..0)[value].filter { !it.isNaN() }.mean())
             }.concat()
             .sortBy("id")
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/MediumTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/MediumTests.kt
index 9cb24e62d1..72fd1dc4dc 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/MediumTests.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/MediumTests.kt
@@ -148,18 +148,12 @@ class MediumTests {
             "(90, 100]", 527,
         )
 
-        df
-            .groupBy { a.map { (it - 1) / 10 } }
-            .sum { b }
+        df.groupBy { a.map { (it - 1) / 10 } }.sum { b }
             .sortBy { a }
-            .convert { a }
-            .with { "(${it * 10}, ${it * 10 + 10}]" } shouldBe expected
+            .convert { a }.with { "(${it * 10}, ${it * 10 + 10}]" } shouldBe expected
 
-        df
-            .groupBy { "A"<Int>().map { (it - 1) / 10 } }
-            .sum("B")
+        df.groupBy { "A"<Int>().map { (it - 1) / 10 } }.sum("B")
             .sortBy("A")
-            .convert { "A"<Int>() }
-            .with { "(${it * 10}, ${it * 10 + 10}]" } shouldBe expected
+            .convert { "A"<Int>() }.with { "(${it * 10}, ${it * 10 + 10}]" } shouldBe expected
     }
 }
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/RenderingTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/RenderingTests.kt
index 1641290cda..9bb63eb258 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/RenderingTests.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/RenderingTests.kt
@@ -95,10 +95,8 @@ class RenderingTests : TestBase() {
     fun `empty row with nested empty row`() {
         val df = dataFrameOf("a", "b", "c")(null, null, null)
         val grouped = df
-            .group("a", "b")
-            .into("d")
-            .group("c", "d")
-            .into("e")[0]
+            .group("a", "b").into("d")
+            .group("c", "d").into("e")[0]
 
         val formatted = formatter.format(grouped, DefaultCellRenderer, DisplayConfiguration())
         Jsoup.parse(formatted).text() shouldBe "{ }"
@@ -125,10 +123,8 @@ class RenderingTests : TestBase() {
     @Test
     fun `render successfully 2`() {
         val df = dataFrameOf("name", "parent", "type")("Boston (MA)", "123wazxdPag5", "Campus")
-            .move("parent")
-            .into { "parent"["id"] }
-            .group { all() }
-            .into("Campus")
+            .move("parent").into { "parent"["id"] }
+            .group { all() }.into("Campus")
         df.toHTML().print()
     }
 
@@ -182,8 +178,7 @@ class RenderingTests : TestBase() {
         dfGroup.name.maxWidth() shouldBe 4
         dfGroup.name.firstName.maxWidth() shouldBe 3
         dfGroup.name.lastName.maxWidth() shouldBe 1
-        dfGroup.name.firstName.secondName
-            .maxWidth() shouldBe 1
+        dfGroup.name.firstName.secondName.maxWidth() shouldBe 1
     }
 
     @Test
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/JoinWith.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/JoinWith.kt
index fe89ae4e18..ed27336e98 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/JoinWith.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/JoinWith.kt
@@ -163,7 +163,7 @@ class JoinWith : TestBase() {
     private fun DataFrameHtmlData.wrap(title: String): DataFrameHtmlData =
         copy(
             body =
-                """
+            """
                 <div class="table-container">
                     <b>$title</b>
                     $body
@@ -174,7 +174,7 @@ class JoinWith : TestBase() {
     private fun DataFrameHtmlData.wrap(): DataFrameHtmlData =
         copy(
             body =
-                """
+            """
                 <div class="table-container">
                     $body
                 </div>
@@ -195,7 +195,7 @@ class JoinWith : TestBase() {
                 .plus(
                     DataFrameHtmlData(
                         style =
-                            """
+                        """
                             body {
                                 display: flex;
                                 align-items: flex-start;
@@ -526,15 +526,15 @@ class JoinWith : TestBase() {
         // SampleEnd
 
         PluginCallbackProxy.overrideHtmlOutput(
-            manualOutput = DataFrameHtmlData
-                .tableDefinitions()
+            manualOutput = DataFrameHtmlData.tableDefinitions()
                 .plus(
                     DataFrameHtmlData()
                         .plus(df1.toColoredHTML().wrap("df1"))
                         .plus(df2.toColoredHTML().wrap("df2"))
                         .plus(df1.innerJoin(df2, "index", "age").toColoredHTML().wrap("result"))
                         .wrapRow(),
-                ).plus(other),
+                )
+                .plus(other),
         )
     }
 
@@ -546,19 +546,18 @@ class JoinWith : TestBase() {
         // SampleEnd
 
         PluginCallbackProxy.overrideHtmlOutput(
-            manualOutput = DataFrameHtmlData
-                .tableDefinitions()
+            manualOutput = DataFrameHtmlData.tableDefinitions()
                 .plus(
                     DataFrameHtmlData()
                         .plus(df1.toColoredHTML().wrap("df1"))
                         .plus(df2.toColoredHTML().wrap("df2"))
                         .plus(
-                            df1
-                                .innerJoinWith(df2) { it["index"] == right["index"] && it["age"] == right["age"] }
-                                .toColoredHTML()
-                                .wrap("result"),
-                        ).wrapRow(),
-                ).plus(other),
+                            df1.innerJoinWith(df2) { it["index"] == right["index"] && it["age"] == right["age"] }
+                                .toColoredHTML().wrap("result")
+                        )
+                        .wrapRow()
+                )
+                .plus(other)
         )
     }
 
@@ -571,27 +570,26 @@ class JoinWith : TestBase() {
         // SampleEnd
 
         PluginCallbackProxy.overrideHtmlOutput(
-            manualOutput = DataFrameHtmlData
-                .tableDefinitions()
+            manualOutput = DataFrameHtmlData.tableDefinitions()
                 .plus(
                     DataFrameHtmlData()
                         .plus(df1.toColoredHTML().wrap("df1"))
                         .plus(df2.toColoredHTML().wrap("df2"))
-                        .plus(
-                            df1.leftJoin(df2, "index", "age").toColoredHTML().wrap("result"),
-                        ).wrapRow(),
-                ).plus(DataFrameHtmlData(body = "<br><br>"))
+                        .plus(df1.leftJoin(df2, "index", "age").toColoredHTML().wrap("result"))
+                        .wrapRow()
+                )
+                .plus(DataFrameHtmlData(body = "<br><br>"))
                 .plus(
                     DataFrameHtmlData()
                         .plus(df1.toColoredHTML().wrap())
                         .plus(df2.toColoredHTML().wrap())
                         .plus(
-                            df1
-                                .leftJoinWith(df2) { it["index"] == right["index"] && it["age"] == right["age"] }
-                                .toColoredHTML()
-                                .wrap(),
-                        ).wrapRow(),
-                ).plus(other),
+                            df1.leftJoinWith(df2) { it["index"] == right["index"] && it["age"] == right["age"] }
+                                .toColoredHTML().wrap()
+                        )
+                        .wrapRow()
+                )
+                .plus(other)
         )
     }
 
@@ -604,34 +602,33 @@ class JoinWith : TestBase() {
         // SampleEnd
 
         PluginCallbackProxy.overrideHtmlOutput(
-            manualOutput = DataFrameHtmlData
-                .tableDefinitions()
+            manualOutput = DataFrameHtmlData.tableDefinitions()
                 .plus(
                     DataFrameHtmlData()
                         .plus(df1.toColoredHTML().wrap("df1"))
                         .plus(df2.toColoredHTML().wrap("df2"))
-                        .plus(
-                            df1.rightJoin(df2, "index", "age").toColoredHTML().wrap("result"),
-                        ).wrapRow(),
-                ).plus(DataFrameHtmlData(body = "<br><br>"))
+                        .plus(df1.rightJoin(df2, "index", "age").toColoredHTML().wrap("result"))
+                        .wrapRow()
+                )
+                .plus(DataFrameHtmlData(body = "<br><br>"))
                 .plus(
                     DataFrameHtmlData()
                         .plus(df1.toColoredHTML().wrap())
                         .plus(df2.toColoredHTML().wrap())
                         .plus(
-                            df1
-                                .rightJoinWith(df2) { it["index"] == right["index"] && it["age"] == right["age"] }
-                                .toColoredHTML()
-                                .wrap(),
-                        ).wrapRow(),
-                ).plus(other),
+                            df1.rightJoinWith(df2) { it["index"] == right["index"] && it["age"] == right["age"] }
+                                .toColoredHTML().wrap()
+                        )
+                        .wrapRow()
+                )
+                .plus(other)
         )
     }
 
     private fun DataFrameHtmlData.wrapRow(): DataFrameHtmlData =
         copy(
             body =
-                """
+            """
                 <div class="table-row">
                     $body
                 </div>
@@ -640,7 +637,7 @@ class JoinWith : TestBase() {
 
     private val other = DataFrameHtmlData(
         style =
-            """
+        """
             body {
                 font-family: "JetBrains Mono", SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
                 font-size: 14px;
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 a1b24d6700..21accfbd8f 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
@@ -54,17 +54,15 @@ 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)
+    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 {
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/animals/AnimalsTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/animals/AnimalsTests.kt
index 85f5fc2e92..f8ee4b37d5 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/animals/AnimalsTests.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/animals/AnimalsTests.kt
@@ -39,10 +39,8 @@ class AnimalsTests {
     @Test
     fun `mean of empty`() {
         val cleared = df
-            .update { age }
-            .with { Double.NaN }
-            .update { visits }
-            .withNull()
+            .update { age }.with { Double.NaN }
+            .update { visits }.withNull()
         val mean = cleared.mean()
         mean[age] shouldBe Double.NaN
         (mean[visits.name()] as Double).isNaN() shouldBe true
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 96bc31025b..c0dcf6ec52 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
@@ -194,6 +194,7 @@ import java.time.LocalDate
 import kotlin.reflect.jvm.jvmErasure
 import kotlin.reflect.typeOf
 
+@Suppress("ktlint:standard:argument-list-wrapping")
 class DataFrameTests : BaseTest() {
 
     @Test
@@ -391,54 +392,18 @@ class DataFrameTests : BaseTest() {
             this["age"].toList() shouldBe typed.rows().map { if (it.age > 25) null else it.age }
         }
 
-        typed
-            .update { age }
-            .where { it > 25 }
-            .withNull()
-            .check()
-        typed
-            .update { age }
-            .where { it > 25 }
-            .withNull()
-            .check()
-        typed
-            .update(typed.age)
-            .where { it > 25 }
-            .withNull()
-            .check()
+        typed.update { age }.where { it > 25 }.withNull().check()
+        typed.update { age }.where { it > 25 }.withNull().check()
+        typed.update(typed.age).where { it > 25 }.withNull().check()
 
-        df
-            .update { age }
-            .where { it > 25 }
-            .withNull()
-            .check()
-        df
-            .update(age)
-            .where { it > 25 }
-            .withNull()
-            .check()
-        df
-            .update(age)
-            .where { it > 25 }
-            .withNull()
-            .check()
+        df.update { age }.where { it > 25 }.withNull().check()
+        df.update(age).where { it > 25 }.withNull().check()
+        df.update(age).where { it > 25 }.withNull().check()
 
-        df
-            .update(Person::age)
-            .where { it > 25 }
-            .withNull()
-            .check()
+        df.update(Person::age).where { it > 25 }.withNull().check()
 
-        df
-            .update("age")
-            .where { it as Int > 25 }
-            .withNull()
-            .check()
-        df
-            .update("age")
-            .where { it as Int > 25 }
-            .withNull()
-            .check()
+        df.update("age").where { it as Int > 25 }.withNull().check()
+        df.update("age").where { it as Int > 25 }.withNull().check()
     }
 
     @Test
@@ -518,10 +483,7 @@ class DataFrameTests : BaseTest() {
 
     @Test
     fun `sort nulls last`() {
-        val expected = typed.city
-            .toList()
-            .filterNotNull()
-            .sortedBy { it } + listOf(null)
+        val expected = typed.city.toList().filterNotNull().sortedBy { it } + listOf(null)
 
         fun AnyFrame.check() = this[city].toList() shouldBe expected
 
@@ -544,19 +506,16 @@ class DataFrameTests : BaseTest() {
     @Test
     fun `get group by complex key`() {
         typed.groupBy { city and name }.xs("Tokyo", "Bob").concat() shouldBe
-            typed
-                .filter { name == "Bob" && city == "Tokyo" }
+            typed.filter { name == "Bob" && city == "Tokyo" }
                 .remove { name and city }
     }
 
     @Test
     fun `get group by partial key`() {
         typed.groupBy { city and name }.xs("Tokyo").toDataFrame() shouldBe
-            typed
-                .filter { city == "Tokyo" }
+            typed.filter { city == "Tokyo" }
                 .remove { city }
-                .groupBy { name }
-                .toDataFrame()
+                .groupBy { name }.toDataFrame()
     }
 
     @Test
@@ -787,82 +746,71 @@ class DataFrameTests : BaseTest() {
             this["ages"].toList() shouldBe listOf(listOf(15, 20), listOf(45, 30), listOf(20, 40, 30))
         }
 
-        typed
-            .groupBy { name }
-            .aggregate {
-                count() into "n"
-                count { age > 25 } into "old count"
-                median { age } into "median age"
-                min { age } into "min age"
-                all { weight != null } into "all with weights"
-                maxBy { age }.city into "oldest origin"
-                sortBy { age }.first().city into "youngest origin"
-                pivot { city.map { "from $it" } }.count()
-                age.toList() into "ages"
-            }.check()
-
-        typed
-            .groupBy { it.name }
-            .aggregate {
-                it.nrow into "n"
-                it.count { it.age > 25 } into "old count"
-                it.median { it.age } into "median age"
-                it.min { it.age } into "min age"
-                it.all { it.weight != null } into "all with weights"
-                it.maxBy { it.age }.city into "oldest origin"
-                it.sortBy { it.age }.first().city into "youngest origin"
-                it.pivot { it.city.map { "from $it" } }.count()
-                it.age.toList() into "ages"
-            }.check()
-
-        df
-            .groupBy(name)
-            .aggregate {
-                count() into "n"
-                count { age > 25 } into "old count"
-                median(age) into "median age"
-                min(age) into "min age"
-                all { weight() != null } into "all with weights"
-                maxBy(age)[city] into "oldest origin"
-                sortBy(age).first()[city] into "youngest origin"
-                pivot(city.map { "from $it" }).count()
-                it[age].toList() into "ages"
-            }.check()
-
-        df
-            .groupBy(Person::name)
-            .aggregate {
-                count() into "n"
-                count { it[Person::age] > 25 } into "old count"
-                median(Person::age) into "median age"
-                min(Person::age) into "min age"
-                all { it[Person::weight] != null } into "all with weights"
-                maxBy(Person::age)[Person::city] into "oldest origin"
-                sortBy(Person::age).first()[Person::city] into "youngest origin"
-                pivot { it[Person::city].map { "from $it" } }.count()
-                it[Person::age].toList() into "ages"
-            }.check()
-
-        df
-            .groupBy("name")
-            .aggregate {
-                count() into "n"
-                count { "age"<Int>() > 25 } into "old count"
-                median { "age"<Int>() } into "median age"
-                min { "age"<Int>() } into "min age"
-                all { it["weight"] != null } into "all with weights"
-                maxBy { "age"<Int>() }["city"] into "oldest origin"
-                sortBy("age").first()["city"] into "youngest origin"
-                pivot { it["city"].map { "from $it" } }.count()
-                it["age"].toList() into "ages"
-            }.check()
+        typed.groupBy { name }.aggregate {
+            count() into "n"
+            count { age > 25 } into "old count"
+            median { age } into "median age"
+            min { age } into "min age"
+            all { weight != null } into "all with weights"
+            maxBy { age }.city into "oldest origin"
+            sortBy { age }.first().city into "youngest origin"
+            pivot { city.map { "from $it" } }.count()
+            age.toList() into "ages"
+        }.check()
+
+        typed.groupBy { it.name }.aggregate {
+            it.nrow into "n"
+            it.count { it.age > 25 } into "old count"
+            it.median { it.age } into "median age"
+            it.min { it.age } into "min age"
+            it.all { it.weight != null } into "all with weights"
+            it.maxBy { it.age }.city into "oldest origin"
+            it.sortBy { it.age }.first().city into "youngest origin"
+            it.pivot { it.city.map { "from $it" } }.count()
+            it.age.toList() into "ages"
+        }.check()
+
+        df.groupBy(name).aggregate {
+            count() into "n"
+            count { age > 25 } into "old count"
+            median(age) into "median age"
+            min(age) into "min age"
+            all { weight() != null } into "all with weights"
+            maxBy(age)[city] into "oldest origin"
+            sortBy(age).first()[city] into "youngest origin"
+            pivot(city.map { "from $it" }).count()
+            it[age].toList() into "ages"
+        }.check()
+
+        df.groupBy(Person::name).aggregate {
+            count() into "n"
+            count { it[Person::age] > 25 } into "old count"
+            median(Person::age) into "median age"
+            min(Person::age) into "min age"
+            all { it[Person::weight] != null } into "all with weights"
+            maxBy(Person::age)[Person::city] into "oldest origin"
+            sortBy(Person::age).first()[Person::city] into "youngest origin"
+            pivot { it[Person::city].map { "from $it" } }.count()
+            it[Person::age].toList() into "ages"
+        }.check()
+
+        df.groupBy("name").aggregate {
+            count() into "n"
+            count { "age"<Int>() > 25 } into "old count"
+            median { "age"<Int>() } into "median age"
+            min { "age"<Int>() } into "min age"
+            all { it["weight"] != null } into "all with weights"
+            maxBy { "age"<Int>() }["city"] into "oldest origin"
+            sortBy("age").first()["city"] into "youngest origin"
+            pivot { it["city"].map { "from $it" } }.count()
+            it["age"].toList() into "ages"
+        }.check()
     }
 
     @Test
     fun `groupBy meanOf`() {
         typed.groupBy { name }.meanOf { age * 2 } shouldBe typed
-            .groupBy { name }
-            .aggregate { mean { age } * 2 into "mean" }
+            .groupBy { name }.aggregate { mean { age } * 2 into "mean" }
     }
 
     @Test
@@ -959,20 +907,19 @@ class DataFrameTests : BaseTest() {
         val expected = typed.rows().map { now - it.age }
         val g by columnGroup()
 
-        val df = typed
-            .add {
-                "a" from { now - age }
-                "b" from now - age
-                now - age into "c"
-                "d" {
-                    "f" from { now - age }
+        val df = typed.add {
+            "a" from { now - age }
+            "b" from now - age
+            now - age into "c"
+            "d" {
+                "f" from { now - age }
+            }
+            group {
+                g from {
+                    add(age.map { now - it }.named("h"))
                 }
-                group {
-                    g from {
-                        add(age.map { now - it }.named("h"))
-                    }
-                } into "e"
-            }.remove { allBefore("a") }
+            } into "e"
+        }.remove { allBefore("a") }
 
         df.columnNames() shouldBe listOf("a", "b", "c", "d", "e")
         df["d"].kind() shouldBe ColumnKind.Group
@@ -1215,11 +1162,10 @@ class DataFrameTests : BaseTest() {
         val trueValuesCount = res.columns().drop(1).sumOf { it.cast<Boolean>().toList().count { it } }
         trueValuesCount shouldBe selected.distinct().nrow
 
-        val pairs = (1 until res.ncol)
-            .flatMap { i ->
-                val col = res.getColumn(i).cast<Boolean>()
-                res.filter { it[col] }.rows().map { it.name to col.name() }
-            }.toSet()
+        val pairs = (1 until res.ncol).flatMap { i ->
+            val col = res.getColumn(i).cast<Boolean>()
+            res.filter { it[col] }.rows().map { it.name to col.name() }
+        }.toSet()
 
         pairs shouldBe typed.rows().map { it.name to it.city.toString() }.toSet()
     }
@@ -1232,11 +1178,9 @@ class DataFrameTests : BaseTest() {
 
         val names = typed.name.distinct().toList()
 
-        val src = typed
-            .select { name }
+        val src = typed.select { name }
             .add(others) { names }
-            .split { others }
-            .intoRows()
+            .split { others }.intoRows()
             .add(sum) { name.length + other().length }
 
         val matrix = src.pivot { other }.groupBy { name }.with { sum }
@@ -1255,9 +1199,7 @@ class DataFrameTests : BaseTest() {
     fun `gather nothing`() {
         val gat = typed.gather { city and name }
 
-        gat
-            .where { false }
-            .into("key", "value")
+        gat.where { false }.into("key", "value")
             .print()
     }
 
@@ -1330,13 +1272,9 @@ class DataFrameTests : BaseTest() {
     @Test
     fun mergeIntoList() {
         val parsed = typed
-            .merge { age and city and weight }
-            .by(", ")
-            .intoList()
+            .merge { age and city and weight }.by(", ").intoList()
             .toDataFrame { "data" from { it } }
-            .split("data")
-            .by(", ")
-            .into(age, city, weight)
+            .split("data").by(", ").into(age, city, weight)
             .parse(ParserOptions(nullStrings = setOf("null")))
 
         val expected = typed[age, city, weight]
@@ -1345,11 +1283,10 @@ class DataFrameTests : BaseTest() {
 
     @Test
     fun mergeColsCustom() {
-        val merged =
-            typed
-                .merge { name and city and age }
-                .by { it[0].toString() + " from " + it[1] + " aged " + it[2] }
-                .into("info")
+        val merged = typed
+            .merge { name and city and age }
+            .by { it[0].toString() + " from " + it[1] + " aged " + it[2] }
+            .into("info")
         merged.ncol shouldBe 2
         merged.nrow shouldBe typed.nrow
         merged[0]["info"] shouldBe "Alice from London aged 15"
@@ -1440,33 +1377,22 @@ class DataFrameTests : BaseTest() {
     @Test
     fun splitStringCols() {
         val merged = typed
-            .merge { name and city }
-            .by(", ")
-            .into("nameAndCity")
-            .merge { age and weight }
-            .into("info")
+            .merge { name and city }.by(", ").into("nameAndCity")
+            .merge { age and weight }.into("info")
         val nameAndCity by column<String>()
         val info by column<List<Number?>>()
         val res = merged
-            .split { nameAndCity }
-            .into("name", "city")
-            .split(info)
-            .into("age", "weight")
+            .split { nameAndCity }.into("name", "city")
+            .split(info).into("age", "weight")
         val expected = typed
-            .update { city }
-            .with { it.toString() }
-            .move { city }
-            .to(1)
+            .update { city }.with { it.toString() }
+            .move { city }.to(1)
         res shouldBe expected
     }
 
     @Test
     fun `split by with default`() {
-        val res = typed
-            .split { city }
-            .by('o')
-            .default("--")
-            .into { "a$it" }
+        val res = typed.split { city }.by('o').default("--").into { "a$it" }
         res.sumOf { values().count { it == "--" } } shouldBe 7
     }
 
@@ -1667,8 +1593,7 @@ class DataFrameTests : BaseTest() {
             grouped[it..it]
         }
         val dst = flattened
-            .concat()
-            .asGroupBy()
+            .concat().asGroupBy()
             .concat()
             .sortBy("id")
             .remove("id")
@@ -1735,10 +1660,8 @@ class DataFrameTests : BaseTest() {
     fun `replace with expression`() {
         val res = typed.replace { age }.with { 2021 - age named "year" }
         val expected = typed
-            .convert { age }
-            .with { 2021 - age }
-            .rename { age }
-            .into("year")
+            .convert { age }.with { 2021 - age }
+            .rename { age }.into("year")
         res shouldBe expected
     }
 
@@ -1766,30 +1689,14 @@ class DataFrameTests : BaseTest() {
         val df = dataFrameOf(values, list1, list2)
         val res = df.explode { list1 and list2 }
         val expected = dataFrameOf(values.name(), list1.name(), list2.name())(
-            1,
-            1,
-            1,
-            1,
-            2,
-            2,
-            1,
-            3,
-            null,
-            2,
-            null,
-            1,
-            2,
-            null,
-            2,
-            3,
-            1,
-            1,
-            3,
-            2,
-            2,
-            4,
-            null,
-            1,
+            1, 1, 1,
+            1, 2, 2,
+            1, 3, null,
+            2, null, 1,
+            2, null, 2,
+            3, 1, 1,
+            3, 2, 2,
+            4, null, 1,
         )
         res shouldBe expected
     }
@@ -1798,45 +1705,23 @@ class DataFrameTests : BaseTest() {
     fun splitUnequalListAndFrames() {
         val values by columnOf(1, 2, 3)
         val list1 by columnOf(listOf(1, 2, 3), listOf(1), listOf(1, 2))
-        val frames by listOf(listOf(1, 2), listOf(1, 2), listOf(1, 2))
-            .map {
-                val data = it.toColumn("data")
-                val dataStr = it.map { it.toString() }.toColumn("dataStr")
-                dataFrameOf(data, dataStr)
-            }.toColumn()
+        val frames by listOf(listOf(1, 2), listOf(1, 2), listOf(1, 2)).map {
+            val data = it.toColumn("data")
+            val dataStr = it.map { it.toString() }.toColumn("dataStr")
+            dataFrameOf(data, dataStr)
+        }.toColumn()
         frames.kind shouldBe ColumnKind.Frame
 
         val df = dataFrameOf(values, list1, frames)
         val res = df.explode { list1 and frames }.ungroup(frames)
         val expected = dataFrameOf(values.name(), list1.name(), "data", "dataStr")(
-            1,
-            1,
-            1,
-            "1",
-            1,
-            2,
-            2,
-            "2",
-            1,
-            3,
-            null,
-            null,
-            2,
-            1,
-            1,
-            "1",
-            2,
-            null,
-            2,
-            "2",
-            3,
-            1,
-            1,
-            "1",
-            3,
-            2,
-            2,
-            "2",
+            1, 1, 1, "1",
+            1, 2, 2, "2",
+            1, 3, null, null,
+            2, 1, 1, "1",
+            2, null, 2, "2",
+            3, 1, 1, "1",
+            3, 2, 2, "2",
         )
         res shouldBe expected
     }
@@ -1864,25 +1749,17 @@ class DataFrameTests : BaseTest() {
         fun DataFrame<Person>.check() = indices { age == 100 } shouldBe listOf(1, 3)
 
         typed
-            .update { age }
-            .at(1..3)
-            .where { it > 20 }
-            .with { 100 }
+            .update { age }.at(1..3).where { it > 20 }.with { 100 }
             .check()
         typed
-            .update { age }
-            .where { it > 20 }
-            .at(1..3)
-            .with { 100 }
+            .update { age }.where { it > 20 }.at(1..3).with { 100 }
             .check()
     }
 
     @Test
     fun `update nulls`() {
         typed
-            .update { weight }
-            .where { it == null }
-            .with { 15 }
+            .update { weight }.where { it == null }.with { 15 }
             .weight.hasNulls shouldBe false
     }
 
@@ -1914,14 +1791,10 @@ class DataFrameTests : BaseTest() {
     @Test
     fun `append many`() {
         val res = typed.append(
-            "John",
-            22,
-            "New York",
-            46,
-            "Philip",
-            25,
-            "Chelyabinsk",
-            36,
+            "John", 22,
+            "New York", 46,
+            "Philip", 25,
+            "Chelyabinsk", 36,
         )
         res.nrow shouldBe typed.nrow + 2
     }
@@ -1930,10 +1803,8 @@ class DataFrameTests : BaseTest() {
     fun `append wrong number of arguments`() {
         shouldThrow<IllegalStateException> {
             dataFrameOf("name", "age")(
-                "Alice",
-                15,
-                "Bob",
-                20,
+                "Alice", 15,
+                "Bob", 20,
             ).append("John")
         }
     }
@@ -2173,13 +2044,9 @@ class DataFrameTests : BaseTest() {
     @Test
     fun `groupBy with map`() {
         typed
-            .groupBy { name.map { it.lowercase() } }
-            .toDataFrame()
-            .name
-            .values() shouldBe typed.name
-            .distinct()
-            .lowercase()
-            .values()
+            .groupBy { name.map { it.lowercase() } }.toDataFrame()
+            .name.values() shouldBe
+            typed.name.distinct().lowercase().values()
     }
 
     @Test
@@ -2262,31 +2129,30 @@ class DataFrameTests : BaseTest() {
     @Test
     fun `grouped sort by count`() {
         val sorted = typed.groupBy { name }.sortByCount()
-        sorted.toDataFrame().name.values() shouldBe typed
-            .rows()
-            .groupBy { it.name }
-            .toList()
-            .sortedByDescending { it.second.size }
-            .map { it.first }
+        sorted.toDataFrame().name.values() shouldBe
+            typed.rows()
+                .groupBy { it.name }
+                .toList()
+                .sortedByDescending { it.second.size }
+                .map { it.first }
     }
 
     @Test
     fun `grouped sort by key`() {
         val sorted = typed.groupBy { name }.sortByKey()
-        sorted.toDataFrame().name.values() shouldBe typed.name
-            .distinct()
-            .values()
-            .sorted()
+        sorted.toDataFrame().name.values() shouldBe
+            typed.name
+                .distinct()
+                .values()
+                .sorted()
     }
 
     @Test
     fun `infer ColumnGroup type in convert with`() {
         val g by frameColumn()
         val grouped = typed
-            .groupBy { name }
-            .toDataFrame(g.name)
-            .convert(g)
-            .with { it.first() }
+            .groupBy { name }.toDataFrame(g.name)
+            .convert(g).with { it.first() }
         grouped[g.name].kind() shouldBe ColumnKind.Group
     }
 
@@ -2335,10 +2201,7 @@ class DataFrameTests : BaseTest() {
     @Test
     fun `pivot null to default`() {
         val pivoted = typed
-            .groupBy { name }
-            .pivot { city }
-            .default(0)
-            .min { weight }
+            .groupBy { name }.pivot { city }.default(0).min { weight }
         pivoted.columns().forEach {
             it.hasNulls() shouldBe false
         }
@@ -2381,11 +2244,9 @@ class DataFrameTests : BaseTest() {
         val added = df.add("col") { 1 }
         added.convertTo(typeOf<Target>(), ExcessiveColumns.Keep) shouldBe added
 
-        df.remove { city }.convertTo<Target>() shouldBe df
-            .update { city }
-            .withNull()
-            .move { city }
-            .toRight()
+        df.remove { city }.convertTo<Target>() shouldBe
+            df.update { city }.withNull()
+                .move { city }.toRight()
 
         shouldThrow<IllegalArgumentException> {
             df.remove { age }.convertTo<Target>()
@@ -2394,17 +2255,11 @@ class DataFrameTests : BaseTest() {
         df.remove { age }.convertTo<Target> {
             fill { age }.with { -1 }
         } shouldBe
-            df
-                .update { age }
-                .with { -1 }
-                .move { age }
-                .toRight()
+            df.update { age }.with { -1 }
+                .move { age }.toRight()
 
         shouldThrow<TypeConversionException> {
-            df
-                .update { name }
-                .at(2)
-                .withNull()
+            df.update { name }.at(2).withNull()
                 .convertTo<Target>()
         }
 
@@ -2478,11 +2333,8 @@ class DataFrameTests : BaseTest() {
         val data by column<String>()
         val merged = typed.merge { name and city }.by("|").into(data)
         merged.split { data }.match("""(.*)\|(.*)""".toRegex()).into("name", "city") shouldBe
-            typed
-                .update { city }
-                .with { it ?: "null" }
-                .move { city }
-                .to(1)
+            typed.update { city }.with { it ?: "null" }
+                .move { city }.to(1)
     }
 
     @Test
@@ -2501,9 +2353,7 @@ class DataFrameTests : BaseTest() {
     @Test
     fun implodeWithNulls() {
         val merged = typed
-            .update { weight }
-            .where { name == "Charlie" }
-            .withNull()
+            .update { weight }.where { name == "Charlie" }.withNull()
             .select { name and weight }
             .implode(dropNA = true) { weight }
 
@@ -2513,11 +2363,8 @@ class DataFrameTests : BaseTest() {
     @Test
     fun updateWithZero() {
         val updated = typed
-            .convert { weight }
-            .toDouble()
-            .update { colsOf<Number?>() }
-            .where { name == "Charlie" }
-            .withZero()
+            .convert { weight }.toDouble()
+            .update { colsOf<Number?>() }.where { name == "Charlie" }.withZero()
         updated.age.type shouldBe typeOf<Int>()
         updated["weight"].type shouldBe typeOf<Double>()
         val filtered = updated.filter { name == "Charlie" }
@@ -2543,20 +2390,16 @@ class DataFrameTests : BaseTest() {
     @Test
     fun `groupByGroup name clash`() {
         val groupName = GroupBy.groupedColumnAccessor.name()
-        typed
-            .add(groupName) { name }
-            .groupBy(groupName)
-            .toDataFrame()
+        typed.add(groupName) { name }
+            .groupBy(groupName).toDataFrame()
             .ncol shouldBe 2
     }
 
     @Test
     fun describe() {
         val desc = typed
-            .group { age and weight }
-            .into("info")
-            .groupBy { city }
-            .toDataFrame()
+            .group { age and weight }.into("info")
+            .groupBy { city }.toDataFrame()
             .describe()
         desc.nrow shouldBe typed.ncol + 1
         desc["type"][0] shouldBe "String?"
@@ -2610,10 +2453,8 @@ class DataFrameTests : BaseTest() {
     @Test
     fun `describe twice`() {
         val df = typed
-            .group { age and weight }
-            .into("info")
-            .groupBy { city }
-            .toDataFrame()
+            .group { age and weight }.into("info")
+            .groupBy { city }.toDataFrame()
         val desc1 = df.describe()
         val desc2 = desc1.describe()
         desc2::class shouldBe DataFrameImpl::class
@@ -2647,8 +2488,7 @@ class DataFrameTests : BaseTest() {
         typed.select { allExcept { age and weight } } shouldBe typed.select { name and city }
 
         typed
-            .group { age and weight and city }
-            .into("info")
+            .group { age and weight and city }.into("info")
             .alsoDebug()
             .select { allExcept { "info"["age"] } }
             .alsoDebug()
@@ -2680,8 +2520,7 @@ class DataFrameTests : BaseTest() {
     fun `merge into same name`() {
         typed.merge { name and city }.into("age") shouldBe
             typed
-                .merge { name and city }
-                .into("data")
+                .merge { name and city }.into("data")
                 .remove("age")
                 .rename("data" to "age")
     }
@@ -2689,23 +2528,19 @@ class DataFrameTests : BaseTest() {
     @Test
     fun `groupBy sort`() {
         typed
-            .groupBy { name }
-            .sortByDesc { age }
-            .xs("Charlie")
-            .concat() shouldBe typed
-            .filter { name == "Charlie" }
-            .sortBy { age.desc() }
-            .remove { name }
+            .groupBy { name }.sortByDesc { age }.xs("Charlie").concat() shouldBe
+            typed
+                .filter { name == "Charlie" }
+                .sortBy { age.desc() }
+                .remove { name }
     }
 
     @Test
     fun `split into columns`() {
         val group by frameColumn()
         typed
-            .groupBy { name }
-            .into(group)
-            .split(group)
-            .intoColumns()
+            .groupBy { name }.into(group)
+            .split(group).intoColumns()
     }
 
     @Test
@@ -2750,9 +2585,7 @@ class DataFrameTests : BaseTest() {
     fun `groupBy xs`() {
         typed.groupBy { name }.xs("Charlie").concat() shouldBe typed.xs("Charlie")
         typed
-            .groupBy { name }
-            .xs("Moscow") { city }
-            .concat()
+            .groupBy { name }.xs("Moscow") { city }.concat()
             .print()
     }
 
@@ -2783,10 +2616,10 @@ class DataFrameTests : BaseTest() {
         typed.groupBy { name }.aggregate {
             count() into n
             count() into Data::count
-        } shouldBe typed
-            .groupBy { name }
-            .count(n.name())
-            .add("total") { "n"<Int>() }
+        } shouldBe
+            typed
+                .groupBy { name }.count(n.name())
+                .add("total") { "n"<Int>() }
     }
 
     @Test
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 f3997f220c..c1b2251ddb 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
@@ -281,9 +281,7 @@ class DataFrameTreeTests : BaseTest() {
         val selected = typed2.select { nameAndCity }
         val nested = selected.implode(dropNA = false) { nameAndCity.city }
         val mergedCity = column<List<String?>>("city")
-        val res = nested
-            .split { nameAndCity[mergedCity] }
-            .intoRows()
+        val res = nested.split { nameAndCity[mergedCity] }.intoRows()
         val expected = selected.sortBy { nameAndCity.name }
         val actual = res.sortBy { nameAndCity.name }
         actual shouldBe expected
@@ -302,17 +300,16 @@ class DataFrameTreeTests : BaseTest() {
                 body(g, g)
             }
 
-        val expected = modified
-            .cast<Person>()
-            .groupBy { name and city }
-            .map {
+        val expected = modified.cast<Person>()
+            .groupBy { name and city }.map {
                 val value = if (key.city == "Moscow") {
                     group.age.toList()
                 } else {
                     group.age[0]
                 }
                 (key.name to key.city.toString()) to value
-            }.plus("Bob" to "Moscow" to emptyList<Int>())
+            }
+            .plus("Bob" to "Moscow" to emptyList<Int>())
             .toMap()
 
         fun <T> DataFrame<T>.check() {
@@ -329,36 +326,19 @@ class DataFrameTreeTests : BaseTest() {
                 }
             }
 
-            val actual = data
-                .flatMap { col ->
-                    val city = col.name()
-                    rows().map { (it[name] to city) to col[it.index()] }.filter { it.second != null }
-                }.toMap()
+            val actual = data.flatMap { col ->
+                val city = col.name()
+                rows().map { (it[name] to city) to col[it.index()] }.filter { it.second != null }
+            }.toMap()
             actual shouldBe expected
         }
 
-        typed2
-            .pivot { nameAndCity.city }
-            .groupBy { nameAndCity.name }
-            .values { age }
-            .check()
-        df2
-            .pivot(nameAndCity[city])
-            .groupBy { nameAndCity[name] }
-            .values(age)
-            .check()
-        df2
-            .pivot {
-                it[GroupedPerson::nameAndCity][NameAndCity::city]
-            }.groupBy { it[GroupedPerson::nameAndCity][NameAndCity::name] }
-            .values(
-                GroupedPerson::age,
-            ).check()
-        df2
-            .pivot { it["nameAndCity"]["city"] }
-            .groupBy { it["nameAndCity"]["name"] }
-            .values("age")
-            .check()
+        typed2.pivot { nameAndCity.city }.groupBy { nameAndCity.name }.values { age }.check()
+        df2.pivot(nameAndCity[city]).groupBy { nameAndCity[name] }.values(age).check()
+        df2.pivot { it[GroupedPerson::nameAndCity][NameAndCity::city] }.groupBy {
+            it[GroupedPerson::nameAndCity][NameAndCity::name]
+        }.values(GroupedPerson::age).check()
+        df2.pivot { it["nameAndCity"]["city"] }.groupBy { it["nameAndCity"]["name"] }.values("age").check()
     }
 
     @Test
@@ -409,8 +389,7 @@ class DataFrameTreeTests : BaseTest() {
                     else -> {
                         val df = value as? AnyFrame
                         df shouldNotBe null
-                        df!!
-                            .rows()
+                        df!!.rows()
                             .map { it["age"] as Int to it["weight"] as Int? }
                             .sortedBy { it.first } shouldBe expValues.sortedBy { it.first }
                     }
@@ -427,7 +406,8 @@ class DataFrameTreeTests : BaseTest() {
         split.nameAndCity.columnNames() shouldBe typed2.nameAndCity.columnNames()
         val nameGroup = split.nameAndCity.name.asColumnGroup()
         nameGroup.name() shouldBe "name"
-        nameGroup.columnsCount() shouldBe typed2.nameAndCity.name
+        nameGroup.columnsCount() shouldBe
+            typed2.nameAndCity.name
             .map { it.length }
             .max()
         nameGroup.columnNames() shouldBe (1..nameGroup.columnsCount()).map { "char$it" }
@@ -477,7 +457,8 @@ class DataFrameTreeTests : BaseTest() {
         val table = col as FrameColumn<*>
         table.schema.value.columns
             .map { it.key }
-            .sorted() shouldBe typed
+            .sorted() shouldBe
+            typed
             .select { age and weight }
             .columnNames()
             .sorted()
@@ -485,8 +466,7 @@ class DataFrameTreeTests : BaseTest() {
 
     @Test
     fun extensionPropertiesTest() {
-        val code = CodeGenerator
-            .create()
+        val code = CodeGenerator.create()
             .generate<GroupedPerson>(
                 interfaceMode = InterfaceGenerationMode.None,
                 extensionProperties = true,
@@ -571,8 +551,7 @@ class DataFrameTreeTests : BaseTest() {
         val groupCol = grouped.groups.name()
         val plain = grouped.toDataFrame()
         val res = plain
-            .split(grouped.groups)
-            .intoRows()
+            .split(grouped.groups).intoRows()
             .remove { it[groupCol]["city"] }
             .ungroup(groupCol)
             .sortBy { name and age }
@@ -585,8 +564,7 @@ class DataFrameTreeTests : BaseTest() {
         val groupCol = grouped.groups.name()
         val plain = grouped.toDataFrame()
         val res = plain
-            .split(grouped.groups)
-            .intoRows()
+            .split(grouped.groups).intoRows()
             .remove { it[groupCol]["city"] }
             .ungroup(groupCol)
             .sortBy { name and age }
@@ -597,17 +575,10 @@ class DataFrameTreeTests : BaseTest() {
     fun explodeFrameColumnWithNulls() {
         val grouped = typed.groupBy { city }
         val groupCol = grouped.groups.toColumnAccessor()
-        val plain = grouped
-            .toDataFrame()
-            .update { groupCol }
-            .at(1)
-            .withNull()
-            .update { groupCol }
-            .at(2)
-            .with { emptyDataFrame() }
-            .update { groupCol }
-            .at(3)
-            .with { it.filter { false } }
+        val plain = grouped.toDataFrame()
+            .update { groupCol }.at(1).withNull()
+            .update { groupCol }.at(2).with { emptyDataFrame() }
+            .update { groupCol }.at(3).with { it.filter { false } }
         val res = plain.explode(dropEmpty = false) { groupCol }
         val expected = plain[groupCol.name()].sumOf { Math.max((it as AnyFrame?)?.rowsCount() ?: 0, 1) }
         res.rowsCount() shouldBe expected
@@ -643,11 +614,8 @@ class DataFrameTreeTests : BaseTest() {
     fun `join by frame column`() {
         val left = typed.groupBy { name }.updateGroups { it.remove { name and city } }
         val right =
-            typed
-                .update { name }
-                .with { it.reversed() }
-                .groupBy { name }
-                .updateGroups { it.remove { name and city } }
+            typed.update { name }.with { it.reversed() }
+                .groupBy { name }.updateGroups { it.remove { name and city } }
         val groupCol = left.groups.toColumnAccessor()
         val joined = left.toDataFrame().join(right.toDataFrame()) { groupCol }
         joined.columnsCount() shouldBe 3
@@ -718,10 +686,7 @@ class DataFrameTreeTests : BaseTest() {
 
     @Test
     fun `distinct at column group`() {
-        typed2.nameAndCity
-            .distinct()
-            .filter { name.startsWith("A") }
-            .columns() shouldBe
+        typed2.nameAndCity.distinct().filter { name.startsWith("A") }.columns() shouldBe
             typed
                 .select { name and city }
                 .distinct()
@@ -814,8 +779,7 @@ class DataFrameTreeTests : BaseTest() {
         val group by frameColumn<GroupedPerson>()
 
         typed2
-            .groupBy { expr { age > 30 } into "isOld" }
-            .into(group)
+            .groupBy { expr { age > 30 } into "isOld" }.into(group)
             .aggregate {
                 group().maxBy { rowsCount() }.weight.median() into "m"
             }["m"] shouldBe 61
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataRowTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataRowTests.kt
index be8dc3b171..e28dcd3943 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataRowTests.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataRowTests.kt
@@ -34,35 +34,28 @@ class DataRowTests : BaseTest() {
 
     @Test
     fun prevNext() {
-        typed
-            .update { age }
-            .with { prev()?.age }
+        typed.update { age }.with { prev()?.age }
             .age
             .drop(1) shouldBe typed.age.dropLast(1)
-        typed
-            .update { age }
-            .with { next()?.age }
+        typed.update { age }.with { next()?.age }
             .age
             .dropLast(1) shouldBe typed.age.drop(1)
     }
 
     @Test
     fun diff() {
-        typed
-            .update { age }
-            .with { diffOrNull { age } }
+        typed.update { age }.with { diffOrNull { age } }
             .age
             .drop(1)
-            .values() shouldBe typed.age
-            .values()
-            .zipWithNext { curr, next -> next - curr }
+            .values() shouldBe typed.age.values().zipWithNext { curr, next -> next - curr }
     }
 
     @Test
     fun mean() {
-        typed.mapToColumn("mean") { rowMean() }.values() shouldBe typed.age
-            .values()
-            .zip(typed.weight.values()) { a, b -> if (b != null) (a + b) / 2.0 else a }
+        typed.mapToColumn("mean") { rowMean() }.values() shouldBe
+            typed.age
+                .values()
+                .zip(typed.weight.values()) { a, b -> if (b != null) (a + b) / 2.0 else a }
     }
 
     @Test
@@ -82,8 +75,7 @@ class DataRowTests : BaseTest() {
     @Test
     fun sum() {
         typed
-            .convert { weight }
-            .toDouble()
+            .convert { weight }.toDouble()
             .mapToColumn("sum") { rowSum() }
             .values() shouldBe
             typed.age.values().zip(typed.weight.values()) { a, b -> a + (b ?: 0).toDouble() }
@@ -91,18 +83,16 @@ class DataRowTests : BaseTest() {
 
     @Test
     fun namedValuesOf() {
-        typed
-            .mapToColumn("vals") {
-                namedValuesOf<Int>().map { it.value }
-            }.values() shouldBe typed.merge { age and weight }.by { it.filterNotNull() }.intoList()
+        typed.mapToColumn("vals") {
+            namedValuesOf<Int>().map { it.value }
+        }.values() shouldBe typed.merge { age and weight }.by { it.filterNotNull() }.intoList()
     }
 
     @Test
     fun valuesOf() {
-        typed
-            .mapToColumn("vals") {
-                valuesOf<String>()
-            }.values() shouldBe typed.merge { name and city }.by { it.filterNotNull() }.intoList()
+        typed.mapToColumn("vals") {
+            valuesOf<String>()
+        }.values() shouldBe typed.merge { name and city }.by { it.filterNotNull() }.intoList()
     }
 
     @Test
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/FormattingTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/FormattingTests.kt
index ee226e31e2..72409ff565 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/FormattingTests.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/FormattingTests.kt
@@ -43,11 +43,8 @@ class FormattingTests : BaseTest() {
     @Test
     fun `override format`() {
         val formatter = typed
-            .format { age }
-            .linearBg(20 to green, 80 to red)
-            .format { age and weight }
-            .where { index % 2 == 0 }
-            .with { background(gray) }
+            .format { age }.linearBg(20 to green, 80 to red)
+            .format { age and weight }.where { index % 2 == 0 }.with { background(gray) }
             .formatter!!
 
         for (row in 0 until typed.nrow step 2) {
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 1b1462dd47..652ef18e8e 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
@@ -120,21 +120,18 @@ class PivotTests {
         res.rowsCount() shouldBe filtered.name.countDistinct()
 
         val expected = filtered.rows().map { (it.name to it.key) }.toSet()
-        val actual = res
-            .columns()
+        val actual = res.columns()
             .subList(1, res.columnsCount())
             .flatMap {
                 val columnName = it.name()
-                res
-                    .rows()
-                    .mapNotNull {
-                        val value = it[columnName] as Boolean
-                        if (value) {
-                            (it.name to columnName)
-                        } else {
-                            null
-                        }
+                res.rows().mapNotNull {
+                    val value = it[columnName] as Boolean
+                    if (value) {
+                        (it.name to columnName)
+                    } else {
+                        null
                     }
+                }
             }.toSet()
 
         actual shouldBe expected
@@ -200,7 +197,8 @@ class PivotTests {
     @Test
     fun `pivot with transform`() {
         val pivoted = typed.pivot { key.map { "_$it" } }.groupBy { name }.with { value }
-        pivoted.getColumns { "key".allCols() }.map { it.name() }.toSet() shouldBe typed.key
+        pivoted.getColumns { "key".allCols() }.map { it.name() }.toSet() shouldBe
+            typed.key
             .distinct()
             .map { "_$it" }
             .toSet()
@@ -254,9 +252,7 @@ class PivotTests {
         val type by column<KClass<*>?>()
         val pivoted = typed
             .add(type) { value?.javaClass?.kotlin }
-            .pivot { key }
-            .groupBy { name }
-            .values(separate = true) { value and type }
+            .pivot { key }.groupBy { name }.values(separate = true) { value and type }
         pivoted.columnsCount() shouldBe 3
     }
 
@@ -300,9 +296,7 @@ class PivotTests {
         val pivoted = withIndex.pivot { name and key }.groupBy("index").with { value }
         pivoted shouldBe
             withIndex
-                .pivot(inward = true) { name }
-                .groupBy("index")
-                .with { value }
+                .pivot(inward = true) { name }.groupBy("index").with { value }
                 .join(withIndex.pivot(inward = true) { key }.groupBy("index").with { value })
 
         val pivotedNoIndex = typed.pivot { name and key }.with { value }
@@ -313,19 +307,17 @@ class PivotTests {
     fun `pivot with two index columns`() {
         val pivoted = typed
             .dropNulls { value }
-            .pivot { value.map { it!!.javaClass.kotlin.simpleName } }
-            .groupBy { name and key }
-            .with { value }
+            .pivot { value.map { it!!.javaClass.kotlin.simpleName } }.groupBy { name and key }.with { value }
 
         val expected = typed
             .dropNulls { value }
             .add {
                 "Int" from { value as? Int }
                 "String" from { value as? String }
-            }.remove("value")
+            }
+            .remove("value")
             .implode("Int", dropNA = true)
-            .group("Int", "String")
-            .into("value")
+            .group("Int", "String").into("value")
 
         pivoted shouldBe expected
     }
@@ -405,15 +397,11 @@ class PivotTests {
     fun `gather with filter`() {
         val pivoted = typed.pivot { key }.groupBy { name }.with { value }
         val gathered = pivoted
-            .gather { "key".allCols() }
-            .explodeLists()
-            .where { it is Int }
-            .into("key", "value")
+            .gather { "key".allCols() }.explodeLists().where { it is Int }.into("key", "value")
         gathered shouldBe typed
             .filter { value is Int }
             .sortBy("name", "key")
-            .convert("value")
-            .toInt() // TODO: replace convert with cast
+            .convert("value").toInt() // TODO: replace convert with cast
     }
 
     @Test
@@ -436,16 +424,11 @@ class PivotTests {
         pivoted3 shouldBe pivoted
 
         val gathered = pivoted
-            .gather { drop(1) }
-            .notNull()
-            .into("key", "value")
-            .convert { value }
-            .with { it as? Comparable<*> } // cast to make the equality test succeed (values are already the same)
+            .gather { drop(1) }.notNull().into("key", "value")
+            .convert { value }.with { it as? Comparable<*> } // cast to make the equality test succeed (values are already the same)
         val expected = expectedFiltered
-            .update { key }
-            .with { keyConverter(it) }
-            .convert { value }
-            .with { valueConverter(it) as? Comparable<*> }
+            .update { key }.with { keyConverter(it) }
+            .convert { value }.with { valueConverter(it) as? Comparable<*> }
         gathered shouldBe expected
     }
 
@@ -457,26 +440,21 @@ class PivotTests {
                 .gather { "key".allCols() }
                 .explodeLists()
                 .notNull()
-                .mapValues { (it as? Double)?.toInt() ?: it }
-                .into("key", "value")
+                .mapValues { (it as? Double)?.toInt() ?: it }.into("key", "value")
         gathered shouldBe expectedFiltered
     }
 
     @Test
     fun `gather doubles with value conversion`() {
         val pivoted = typed.pivot { key }.groupBy { name }.with { valueConverter(value) }
-        val gathered = pivoted
-            .remove { "key"["city"] }
+        val gathered = pivoted.remove { "key"["city"] }
             .gather { "key".allCols() }
             .explodeLists()
             .notNull()
             .cast<Double>()
-            .mapValues { it.toInt() }
-            .into("key", "value")
-        val expected = typed
-            .filter { key != "city" && value != null }
-            .convert { value }
-            .toInt()
+            .mapValues { it.toInt() }.into("key", "value")
+        val expected = typed.filter { key != "city" && value != null }
+            .convert { value }.toInt()
             .sortBy { name and key }
         gathered shouldBe expected
     }
@@ -487,8 +465,7 @@ class PivotTests {
         val gathered = pivoted
             .gather { "key".allCols() }
             .notNull()
-            .mapKeys { it.substring(2) }
-            .into("key", "value")
+            .mapKeys { it.substring(2) }.into("key", "value")
         gathered shouldBe expectedFiltered
     }
 
@@ -527,10 +504,8 @@ class PivotTests {
 
     @Test
     fun `pivot matches yes no`() {
-        val pivoted = typed
-            .drop(1)
-            .pivot(inward = false) { key }
-            .groupBy { name }
+        val pivoted = typed.drop(1)
+            .pivot(inward = false) { key }.groupBy { name }
             .matches("yes", "no")
         pivoted.sumOf { values().count { it == "yes" } } shouldBe typed.rowsCount() - 1
         pivoted.sumOf { values().count { it == "no" } } shouldBe 1
@@ -565,10 +540,8 @@ class PivotTests {
         val type by column<KClass<*>>()
 
         val pivoted =
-            typed
-                .add(type) { value?.javaClass?.kotlin ?: Unit::class }
-                .pivot { key }
-                .groupBy { name }
+            typed.add(type) { value?.javaClass?.kotlin ?: Unit::class }
+                .pivot { key }.groupBy { name }
                 .values { value and (type default Any::class) into "data" }
 
         pivoted.getColumnGroup("key").columns().forEach {
@@ -603,9 +576,7 @@ class PivotTests {
         typed.pivot { name }.count() shouldBe typed.pivot(inward = false) { name }.count()
 
         typed.pivot { name and key }.count().columnNames() shouldBe listOf("name", "key")
-        typed
-            .pivot(inward = false) { name and key }
-            .count()
+        typed.pivot(inward = false) { name and key }.count()
             .columnsCount() shouldBe typed.name.countDistinct() + typed.key.countDistinct()
         typed.pivot(inward = true) { name and key }.count() shouldBe typed.pivot { name and key }.count()
     }
@@ -613,11 +584,8 @@ class PivotTests {
     @Test
     fun `pivot from group`() {
         val pivoted = typed
-            .group { key and value }
-            .into("info")
-            .pivot(inward = true) { "info"["value"] }
-            .groupByOther()
-            .count()
+            .group { key and value }.into("info")
+            .pivot(inward = true) { "info"["value"] }.groupByOther().count()
         pivoted.getColumnGroup("info").getColumnGroup("value").columnsCount() shouldBe typed.value.countDistinct()
     }
 }
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/merge.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/merge.kt
index 754d402807..a4bcf12151 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/merge.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/merge.kt
@@ -14,10 +14,8 @@ class MergeTests : Base() {
     fun `merge inplace`() {
         val merged = df.merge { name.firstName and city }.by { it[0] + " from " + it[1] }.into("name")
 
-        merged shouldBe df
-            .merge { name.firstName and city }
-            .by { it[0] + " from " + it[1] }
-            .into("name2")
+        merged shouldBe
+            df.merge { name.firstName and city }.by { it[0] + " from " + it[1] }.into("name2")
             .remove { name }
             .rename("name2" to "name")
     }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/remove.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/remove.kt
index 3d73021875..06e302dcfd 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/remove.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/remove.kt
@@ -24,7 +24,12 @@ internal fun <T> DataFrame<T>.removeImpl(
     columns: ColumnsSelector<T, *>,
 ): RemoveResult<T> {
     val colWithPaths = getColumnsWithPaths(
-        unresolvedColumnsPolicy = if (allowMissingColumns) UnresolvedColumnsPolicy.Skip else UnresolvedColumnsPolicy.Fail,
+        unresolvedColumnsPolicy =
+            if (allowMissingColumns) {
+                UnresolvedColumnsPolicy.Skip
+            } else {
+                UnresolvedColumnsPolicy.Fail
+            },
         selector = columns,
     )
     val colPaths = colWithPaths.map { it.path }