From e9355027860e691d51753b01063edef8cb6ed865 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Wed, 28 Dec 2022 16:23:34 +0100
Subject: [PATCH 01/50] added jcp support

---
 build.gradle.kts      |  9 +++++++
 core/build.gradle.kts | 59 ++++++++++++++++++++++++++++++++++++++++---
 2 files changed, 64 insertions(+), 4 deletions(-)

diff --git a/build.gradle.kts b/build.gradle.kts
index ced84ec8a..c92ea0d4a 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -3,6 +3,15 @@ import org.jetbrains.kotlinx.publisher.apache2
 import org.jetbrains.kotlinx.publisher.developer
 import org.jetbrains.kotlinx.publisher.githubRepo
 
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+    dependencies {
+        classpath("com.igormaznitsa:jcp:7.0.5")
+    }
+}
+
 @Suppress("DSL_SCOPE_VIOLATION", "UnstableApiUsage")
 plugins {
     kotlin("jvm") version libs.versions.kotlin
diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index dd5ab8281..ddc63bd87 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -1,3 +1,8 @@
+import com.igormaznitsa.jcp.gradle.JcpTask
+import kotlinx.kover.api.KoverTaskExtension
+import org.gradle.jvm.tasks.Jar
+import org.jetbrains.dataframe.gradle.DataSchemaVisibility
+
 @Suppress("DSL_SCOPE_VIOLATION", "UnstableApiUsage")
 plugins {
     kotlin("jvm")
@@ -10,6 +15,7 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
+    id("com.igormaznitsa.jcp")
 }
 
 group = "org.jetbrains.kotlinx"
@@ -127,16 +133,61 @@ tasks.withType<JavaCompile> {
     targetCompatibility = JavaVersion.VERSION_1_8.toString()
 }
 
-tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
+// Setup preprocessing with JCP for main sources
+
+val kotlinMainSources = kotlin.sourceSets.main.get().kotlin.sourceDirectories
+
+val preprocessMain by tasks.creating(JcpTask::class) {
+    sources.set(kotlinMainSources.filter { "ksp" !in it.path })
+    clearTarget.set(true)
+    fileExtensions.set(listOf("kt"))
+    vars.set(
+        mapOf()
+    )
+    outputs.upToDateWhen { target.get().exists() }
+}
+
+tasks.compileKotlin {
     dependsOn(tasks.lintKotlin)
     kotlinOptions {
-        freeCompilerArgs = freeCompilerArgs + listOf("-Xinline-classes", "-Xopt-in=kotlin.RequiresOptIn")
+        freeCompilerArgs += listOf("-Xinline-classes", "-Xopt-in=kotlin.RequiresOptIn")
+    }
+
+    dependsOn(preprocessMain)
+    outputs.upToDateWhen {
+        preprocessMain.outcomingFiles.files.isEmpty()
     }
+
+    doFirst {
+        kotlin {
+            sourceSets {
+                main {
+                    kotlin.setSrcDirs(
+                        kotlinMainSources.filter { "ksp" in it.path } + preprocessMain.target.get()
+                    )
+                }
+            }
+        }
+    }
+
+    doLast {
+        kotlin {
+            sourceSets {
+                main {
+                    kotlin.setSrcDirs(kotlinMainSources)
+                }
+            }
+        }
+    }
+}
+
+tasks.withType<Jar> {
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 }
 
 tasks.test {
     maxHeapSize = "2048m"
-    extensions.configure(kotlinx.kover.api.KoverTaskExtension::class) {
+    extensions.configure(KoverTaskExtension::class) {
         excludes.set(
             listOf(
                 "org.jetbrains.kotlinx.dataframe.jupyter.*",
@@ -174,7 +225,7 @@ artifacts {
 dataframes {
     schema {
         sourceSet = "test"
-        visibility = org.jetbrains.dataframe.gradle.DataSchemaVisibility.IMPLICIT_PUBLIC
+        visibility = DataSchemaVisibility.IMPLICIT_PUBLIC
         data = "https://raw.githubusercontent.com/Kotlin/dataframe/master/data/jetbrains_repositories.csv"
         name = "org.jetbrains.kotlinx.dataframe.samples.api.Repository"
     }

From fcbbf8e356ba97045f59e2817031a95c2ef4a86a Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Wed, 28 Dec 2022 16:24:19 +0100
Subject: [PATCH 02/50] added sample/test for reusable comments in add.kt

---
 .../jetbrains/kotlinx/dataframe/api/add.kt    | 27 +++++--------------
 1 file changed, 6 insertions(+), 21 deletions(-)

diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
index 513840c08..4208a8bd2 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
@@ -17,7 +17,6 @@ import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
 import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.exceptions.DuplicateColumnNamesException
-import org.jetbrains.kotlinx.dataframe.exceptions.UnequalColumnSizesException
 import org.jetbrains.kotlinx.dataframe.impl.api.insertImpl
 import org.jetbrains.kotlinx.dataframe.impl.columns.resolveSingle
 import kotlin.reflect.KProperty
@@ -26,53 +25,39 @@ import kotlin.reflect.KProperty
  * `add` operation adds new columns to DataFrame.
  */
 
+//#local ADD = " * Original [DataFrame] is not modified.\n *\n * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names\n * @throws [org.jetbrains.kotlinx.dataframe.exceptions.UnequalColumnSizesException] if columns in expected result have different sizes\n * @return new [DataFrame] with added columns"
+
 // region Add existing columns
 
 /**
  * Creates new [DataFrame] with given columns added to the end of original [DataFrame.columns] list.
  *
- * Original [DataFrame] is not modified.
- *
+/*$ADD$*/
  * @param columns columns to add
- * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names
- * @throws [UnequalColumnSizesException] if columns in expected result have different sizes
- * @return new [DataFrame] with added columns
  */
 public fun <T> DataFrame<T>.add(vararg columns: AnyBaseCol): DataFrame<T> = addAll(columns.asIterable())
 
 /**
  * Creates new [DataFrame] with given columns added to the end of original [DataFrame.columns] list.
  *
- * Original [DataFrame] is not modified.
- *
+/*$ADD$*/
  * @param columns columns to add
- * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names
- * @throws [UnequalColumnSizesException] if columns in expected result have different sizes
- * @return new [DataFrame] with added columns
  */
 public fun <T> DataFrame<T>.addAll(columns: Iterable<AnyBaseCol>): DataFrame<T> = dataFrameOf(columns() + columns).cast()
 
 /**
  * Creates new [DataFrame] with all columns from given [dataFrames] added to the end of original [DataFrame.columns] list.
  *
- * Original [DataFrame] is not modified.
- *
+/*$ADD$*/
  * @param dataFrames dataFrames to get columns from
- * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names
- * @throws [UnequalColumnSizesException] if columns in expected result have different sizes
- * @return new [DataFrame] with added columns
  */
 public fun <T> DataFrame<T>.add(vararg dataFrames: AnyFrame): DataFrame<T> = addAll(dataFrames.asIterable())
 
 /**
  * Creates new [DataFrame] with all columns from given [dataFrames] added to the end of original [DataFrame.columns] list.
  *
- * Original [DataFrame] is not modified.
- *
+/*$ADD$*/
  * @param dataFrames dataFrames to get columns from
- * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names
- * @throws [UnequalColumnSizesException] if columns in expected result have different sizes
- * @return new [DataFrame] with added columns
  */
 @JvmName("addAllFrames")
 public fun <T> DataFrame<T>.addAll(dataFrames: Iterable<AnyFrame>): DataFrame<T> = addAll(dataFrames.flatMap { it.columns() })

From 1c1fefec3e604380d194965c16361b6d1e00de39 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Wed, 28 Dec 2022 16:48:03 +0100
Subject: [PATCH 03/50] jcp now only gets parsed for building the jar!

---
 core/build.gradle.kts | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index ddc63bd87..5a60dd970 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -153,10 +153,14 @@ tasks.compileKotlin {
         freeCompilerArgs += listOf("-Xinline-classes", "-Xopt-in=kotlin.RequiresOptIn")
     }
 
-    dependsOn(preprocessMain)
     outputs.upToDateWhen {
         preprocessMain.outcomingFiles.files.isEmpty()
     }
+}
+
+tasks.withType<Jar> {
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+    dependsOn(preprocessMain)
 
     doFirst {
         kotlin {
@@ -181,10 +185,6 @@ tasks.compileKotlin {
     }
 }
 
-tasks.withType<Jar> {
-    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-}
-
 tasks.test {
     maxHeapSize = "2048m"
     extensions.configure(KoverTaskExtension::class) {

From 12af079491b58307b375d6cda70c170e75e69b81 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Thu, 29 Dec 2022 13:35:33 +0100
Subject: [PATCH 04/50] updated examples

---
 .../jetbrains/kotlinx/dataframe/api/add.kt    | 31 +++++++++++++++----
 .../jetbrains/kotlinx/dataframe/api/add.txt   |  5 +++
 2 files changed, 30 insertions(+), 6 deletions(-)
 create mode 100644 core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.txt

diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
index 4208a8bd2..6fa7e9d1e 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
@@ -17,6 +17,7 @@ import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
 import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.exceptions.DuplicateColumnNamesException
+import org.jetbrains.kotlinx.dataframe.exceptions.UnequalColumnSizesException
 import org.jetbrains.kotlinx.dataframe.impl.api.insertImpl
 import org.jetbrains.kotlinx.dataframe.impl.columns.resolveSingle
 import kotlin.reflect.KProperty
@@ -25,7 +26,19 @@ import kotlin.reflect.KProperty
  * `add` operation adds new columns to DataFrame.
  */
 
-//#local ADD = " * Original [DataFrame] is not modified.\n *\n * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names\n * @throws [org.jetbrains.kotlinx.dataframe.exceptions.UnequalColumnSizesException] if columns in expected result have different sizes\n * @return new [DataFrame] with added columns"
+/** either
+//#local ADD1234 = evalFile("add.txt")
+ */
+
+/** or
+//#local ADD0 = " * Original [DataFrame] is not modified."
+//#local ADD1 = " *"
+//#local ADD2 = " * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names"
+//#local ADD3 = " * @throws [UnequalColumnSizesException] if columns in expected result have different sizes"
+//#local ADD4 = " * @return new [DataFrame] with added columns"
+//
+//#local ADD = ADD0 + "\n" + ADD1 + "\n" + ADD2 + "\n" + ADD3 + "\n" + ADD4
+ */
 
 // region Add existing columns
 
@@ -43,7 +56,8 @@ public fun <T> DataFrame<T>.add(vararg columns: AnyBaseCol): DataFrame<T> = addA
 /*$ADD$*/
  * @param columns columns to add
  */
-public fun <T> DataFrame<T>.addAll(columns: Iterable<AnyBaseCol>): DataFrame<T> = dataFrameOf(columns() + columns).cast()
+public fun <T> DataFrame<T>.addAll(columns: Iterable<AnyBaseCol>): DataFrame<T> =
+    dataFrameOf(columns() + columns).cast()
 
 /**
  * Creates new [DataFrame] with all columns from given [dataFrames] added to the end of original [DataFrame.columns] list.
@@ -60,7 +74,8 @@ public fun <T> DataFrame<T>.add(vararg dataFrames: AnyFrame): DataFrame<T> = add
  * @param dataFrames dataFrames to get columns from
  */
 @JvmName("addAllFrames")
-public fun <T> DataFrame<T>.addAll(dataFrames: Iterable<AnyFrame>): DataFrame<T> = addAll(dataFrames.flatMap { it.columns() })
+public fun <T> DataFrame<T>.addAll(dataFrames: Iterable<AnyFrame>): DataFrame<T> =
+    addAll(dataFrames.flatMap { it.columns() })
 
 // endregion
 
@@ -151,11 +166,15 @@ public class AddDsl<T>(@PublishedApi internal val df: DataFrame<T>) : ColumnsCon
         return df.mapToColumn("", Infer.Nulls, expression)
     }
 
-    public inline infix fun <reified R> String.from(noinline expression: RowExpression<T, R>): Boolean = add(this, Infer.Nulls, expression)
+    public inline infix fun <reified R> String.from(noinline expression: RowExpression<T, R>): Boolean =
+        add(this, Infer.Nulls, expression)
 
     // TODO: use path instead of name
-    public inline infix fun <reified R> ColumnAccessor<R>.from(noinline expression: RowExpression<T, R>): Boolean = name().from(expression)
-    public inline infix fun <reified R> KProperty<R>.from(noinline expression: RowExpression<T, R>): Boolean = add(name, Infer.Nulls, expression)
+    public inline infix fun <reified R> ColumnAccessor<R>.from(noinline expression: RowExpression<T, R>): Boolean =
+        name().from(expression)
+
+    public inline infix fun <reified R> KProperty<R>.from(noinline expression: RowExpression<T, R>): Boolean =
+        add(name, Infer.Nulls, expression)
 
     public infix fun String.from(column: Column): Boolean = add(column.rename(this))
     public inline infix fun <reified R> ColumnAccessor<R>.from(column: ColumnReference<R>): Boolean = name() from column
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.txt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.txt
new file mode 100644
index 000000000..791d99b89
--- /dev/null
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.txt
@@ -0,0 +1,5 @@
+ * Original [DataFrame] is not modified.
+ *
+ * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names
+ * @throws [org.jetbrains.kotlinx.dataframe.exceptions.UnequalColumnSizesException] if columns in expected result have different sizes
+ * @return new [DataFrame] with added columns

From e4442fedada772dd970756f47b21c4c8055d4611 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Wed, 18 Jan 2023 16:06:19 +0100
Subject: [PATCH 05/50] now using kdocIncludeGradlePlugin

---
 core/build.gradle.kts                         | 101 +++++++++---------
 .../jetbrains/kotlinx/dataframe/api/add.kt    |  53 ++++-----
 settings.gradle.kts                           |  15 +++
 3 files changed, 81 insertions(+), 88 deletions(-)

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 5a60dd970..fab1207f1 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -1,7 +1,5 @@
-import com.igormaznitsa.jcp.gradle.JcpTask
-import kotlinx.kover.api.KoverTaskExtension
+import nl.jolanrensen.kdocInclude.ProcessKdocIncludeTask
 import org.gradle.jvm.tasks.Jar
-import org.jetbrains.dataframe.gradle.DataSchemaVisibility
 
 @Suppress("DSL_SCOPE_VIOLATION", "UnstableApiUsage")
 plugins {
@@ -15,7 +13,7 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-    id("com.igormaznitsa.jcp")
+    id("com.github.jolanrensen.kdocIncludeGradlePlugin") version "main-SNAPSHOT"
 }
 
 group = "org.jetbrains.kotlinx"
@@ -58,6 +56,48 @@ kotlin.sourceSets {
     }
 }
 
+// Backup the kotlin source files location
+val kotlinMainSources = kotlin.sourceSets.main.get().kotlin.sourceDirectories
+
+val processKdocIncludeMain by tasks.creating(ProcessKdocIncludeTask::class) {
+    sources.set(
+        kotlinMainSources
+            .filterNot { "build/generated" in it.path } // Exclude generated sources
+    )
+    debug.set(true)
+}
+
+// Modify all Jar tasks such that before running the Kotlin sources are set to
+// the target of processKdocIncludeMain and they are returned back to normal afterwards.
+tasks.withType<Jar> {
+    dependsOn(processKdocIncludeMain)
+    outputs.upToDateWhen { false }
+
+    doFirst {
+        kotlin {
+            sourceSets {
+                main {
+                    kotlin.setSrcDirs(
+                        processKdocIncludeMain.targets +
+                            kotlinMainSources.filter { "build/generated" in it.path } // Include generated sources (which were excluded above)
+                    )
+                }
+            }
+        }
+    }
+
+    doLast {
+        kotlin {
+            sourceSets {
+                main {
+                    kotlin.setSrcDirs(kotlinMainSources)
+                }
+            }
+        }
+    }
+}
+
+
 tasks.lintKotlinMain {
     exclude("**/*keywords*/**")
     exclude {
@@ -133,61 +173,16 @@ tasks.withType<JavaCompile> {
     targetCompatibility = JavaVersion.VERSION_1_8.toString()
 }
 
-// Setup preprocessing with JCP for main sources
-
-val kotlinMainSources = kotlin.sourceSets.main.get().kotlin.sourceDirectories
-
-val preprocessMain by tasks.creating(JcpTask::class) {
-    sources.set(kotlinMainSources.filter { "ksp" !in it.path })
-    clearTarget.set(true)
-    fileExtensions.set(listOf("kt"))
-    vars.set(
-        mapOf()
-    )
-    outputs.upToDateWhen { target.get().exists() }
-}
-
-tasks.compileKotlin {
+tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
     dependsOn(tasks.lintKotlin)
     kotlinOptions {
-        freeCompilerArgs += listOf("-Xinline-classes", "-Xopt-in=kotlin.RequiresOptIn")
-    }
-
-    outputs.upToDateWhen {
-        preprocessMain.outcomingFiles.files.isEmpty()
-    }
-}
-
-tasks.withType<Jar> {
-    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-    dependsOn(preprocessMain)
-
-    doFirst {
-        kotlin {
-            sourceSets {
-                main {
-                    kotlin.setSrcDirs(
-                        kotlinMainSources.filter { "ksp" in it.path } + preprocessMain.target.get()
-                    )
-                }
-            }
-        }
-    }
-
-    doLast {
-        kotlin {
-            sourceSets {
-                main {
-                    kotlin.setSrcDirs(kotlinMainSources)
-                }
-            }
-        }
+        freeCompilerArgs = freeCompilerArgs + listOf("-Xinline-classes", "-Xopt-in=kotlin.RequiresOptIn")
     }
 }
 
 tasks.test {
     maxHeapSize = "2048m"
-    extensions.configure(KoverTaskExtension::class) {
+    extensions.configure(kotlinx.kover.api.KoverTaskExtension::class) {
         excludes.set(
             listOf(
                 "org.jetbrains.kotlinx.dataframe.jupyter.*",
@@ -225,7 +220,7 @@ artifacts {
 dataframes {
     schema {
         sourceSet = "test"
-        visibility = DataSchemaVisibility.IMPLICIT_PUBLIC
+        visibility = org.jetbrains.dataframe.gradle.DataSchemaVisibility.IMPLICIT_PUBLIC
         data = "https://raw.githubusercontent.com/Kotlin/dataframe/master/data/jetbrains_repositories.csv"
         name = "org.jetbrains.kotlinx.dataframe.samples.api.Repository"
     }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
index 6fa7e9d1e..4ab4a1fa3 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
@@ -26,56 +26,43 @@ import kotlin.reflect.KProperty
  * `add` operation adds new columns to DataFrame.
  */
 
-/** either
-//#local ADD1234 = evalFile("add.txt")
- */
-
-/** or
-//#local ADD0 = " * Original [DataFrame] is not modified."
-//#local ADD1 = " *"
-//#local ADD2 = " * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names"
-//#local ADD3 = " * @throws [UnequalColumnSizesException] if columns in expected result have different sizes"
-//#local ADD4 = " * @return new [DataFrame] with added columns"
-//
-//#local ADD = ADD0 + "\n" + ADD1 + "\n" + ADD2 + "\n" + ADD3 + "\n" + ADD4
+/**
+ * Creates new [DataFrame] with given columns added to the end of original [DataFrame.columns] list.
+ *
+ * Original [DataFrame] is not modified.
+ *
+ * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names
+ * @throws [UnequalColumnSizesException] if columns in expected result have different sizes
+ * @return new [DataFrame] with added columns
  */
+private interface Add
 
 // region Add existing columns
 
 /**
- * Creates new [DataFrame] with given columns added to the end of original [DataFrame.columns] list.
- *
-/*$ADD$*/
+ * @include [Add]
  * @param columns columns to add
  */
 public fun <T> DataFrame<T>.add(vararg columns: AnyBaseCol): DataFrame<T> = addAll(columns.asIterable())
 
 /**
- * Creates new [DataFrame] with given columns added to the end of original [DataFrame.columns] list.
- *
-/*$ADD$*/
+ * @include [Add]
  * @param columns columns to add
  */
-public fun <T> DataFrame<T>.addAll(columns: Iterable<AnyBaseCol>): DataFrame<T> =
-    dataFrameOf(columns() + columns).cast()
+public fun <T> DataFrame<T>.addAll(columns: Iterable<AnyBaseCol>): DataFrame<T> = dataFrameOf(columns() + columns).cast()
 
 /**
- * Creates new [DataFrame] with all columns from given [dataFrames] added to the end of original [DataFrame.columns] list.
- *
-/*$ADD$*/
+ * @include [Add]
  * @param dataFrames dataFrames to get columns from
  */
 public fun <T> DataFrame<T>.add(vararg dataFrames: AnyFrame): DataFrame<T> = addAll(dataFrames.asIterable())
 
 /**
- * Creates new [DataFrame] with all columns from given [dataFrames] added to the end of original [DataFrame.columns] list.
- *
-/*$ADD$*/
+ * @include [Add]
  * @param dataFrames dataFrames to get columns from
  */
 @JvmName("addAllFrames")
-public fun <T> DataFrame<T>.addAll(dataFrames: Iterable<AnyFrame>): DataFrame<T> =
-    addAll(dataFrames.flatMap { it.columns() })
+public fun <T> DataFrame<T>.addAll(dataFrames: Iterable<AnyFrame>): DataFrame<T> = addAll(dataFrames.flatMap { it.columns() })
 
 // endregion
 
@@ -166,15 +153,11 @@ public class AddDsl<T>(@PublishedApi internal val df: DataFrame<T>) : ColumnsCon
         return df.mapToColumn("", Infer.Nulls, expression)
     }
 
-    public inline infix fun <reified R> String.from(noinline expression: RowExpression<T, R>): Boolean =
-        add(this, Infer.Nulls, expression)
+    public inline infix fun <reified R> String.from(noinline expression: RowExpression<T, R>): Boolean = add(this, Infer.Nulls, expression)
 
     // TODO: use path instead of name
-    public inline infix fun <reified R> ColumnAccessor<R>.from(noinline expression: RowExpression<T, R>): Boolean =
-        name().from(expression)
-
-    public inline infix fun <reified R> KProperty<R>.from(noinline expression: RowExpression<T, R>): Boolean =
-        add(name, Infer.Nulls, expression)
+    public inline infix fun <reified R> ColumnAccessor<R>.from(noinline expression: RowExpression<T, R>): Boolean = name().from(expression)
+    public inline infix fun <reified R> KProperty<R>.from(noinline expression: RowExpression<T, R>): Boolean = add(name, Infer.Nulls, expression)
 
     public infix fun String.from(column: Column): Boolean = add(column.rename(this))
     public inline infix fun <reified R> ColumnAccessor<R>.from(column: ColumnReference<R>): Boolean = name() from column
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 24f580668..e8686a670 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -28,6 +28,21 @@ pluginManagement {
     repositories {
         mavenLocal()
         gradlePluginPortal()
+        maven(url = "https://jitpack.io")
+    }
+
+    resolutionStrategy {
+        eachPlugin {
+            requested.apply {
+                val jitpackPlugins = listOf(
+                    "com.github.jolanrensen.kdocIncludeGradlePlugin",
+                )
+                if ("$id" in jitpackPlugins) {
+                    val (_, _, user, name) = "$id".split(".", limit = 4)
+                    useModule("com.github.$user:$name:$version")
+                }
+            }
+        }
     }
 }
 include("dataframe-excel")

From da0be85dd1180bec81a65a5cda64d2d8faca16eb Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Wed, 18 Jan 2023 16:08:41 +0100
Subject: [PATCH 06/50] now using kdocIncludeGradlePlugin

---
 .../main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.txt  | 5 -----
 1 file changed, 5 deletions(-)
 delete mode 100644 core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.txt

diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.txt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.txt
deleted file mode 100644
index 791d99b89..000000000
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.txt
+++ /dev/null
@@ -1,5 +0,0 @@
- * Original [DataFrame] is not modified.
- *
- * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names
- * @throws [org.jetbrains.kotlinx.dataframe.exceptions.UnequalColumnSizesException] if columns in expected result have different sizes
- * @return new [DataFrame] with added columns

From d7dd6bc2fec47ba676615259b3bb14be98dad23a Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Mon, 23 Jan 2023 14:58:05 +0100
Subject: [PATCH 07/50] upgraded to docProcessor

---
 core/build.gradle.kts | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index fab1207f1..5e94b4e51 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -1,4 +1,5 @@
-import nl.jolanrensen.kdocInclude.ProcessKdocIncludeTask
+import nl.jolanrensen.docProcessor.*
+import nl.jolanrensen.docProcessor.defaultProcessors.*
 import org.gradle.jvm.tasks.Jar
 
 @Suppress("DSL_SCOPE_VIOLATION", "UnstableApiUsage")
@@ -13,7 +14,7 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-    id("com.github.jolanrensen.kdocIncludeGradlePlugin") version "main-SNAPSHOT"
+    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.1"
 }
 
 group = "org.jetbrains.kotlinx"
@@ -59,12 +60,11 @@ kotlin.sourceSets {
 // Backup the kotlin source files location
 val kotlinMainSources = kotlin.sourceSets.main.get().kotlin.sourceDirectories
 
-val processKdocIncludeMain by tasks.creating(ProcessKdocIncludeTask::class) {
-    sources.set(
-        kotlinMainSources
-            .filterNot { "build/generated" in it.path } // Exclude generated sources
-    )
-    debug.set(true)
+val processKdocIncludeMain by creatingProcessDocTask(
+    sources = kotlinMainSources.filterNot { "build/generated" in it.path } // Exclude generated sources
+) {
+    processors = listOf(INCLUDE_DOC_PROCESSOR)
+    debug = true
 }
 
 // Modify all Jar tasks such that before running the Kotlin sources are set to

From c017319ee6e2350100d9da68013eedd2cf50c80f Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Mon, 23 Jan 2023 20:57:17 +0100
Subject: [PATCH 08/50] removed add again, fixed some small thing

---
 build.gradle.kts                              |  9 -----
 .../jetbrains/kotlinx/dataframe/api/add.kt    | 35 +++++++++++++------
 settings.gradle.kts                           |  2 +-
 3 files changed, 25 insertions(+), 21 deletions(-)

diff --git a/build.gradle.kts b/build.gradle.kts
index c92ea0d4a..ced84ec8a 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -3,15 +3,6 @@ import org.jetbrains.kotlinx.publisher.apache2
 import org.jetbrains.kotlinx.publisher.developer
 import org.jetbrains.kotlinx.publisher.githubRepo
 
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-    dependencies {
-        classpath("com.igormaznitsa:jcp:7.0.5")
-    }
-}
-
 @Suppress("DSL_SCOPE_VIOLATION", "UnstableApiUsage")
 plugins {
     kotlin("jvm") version libs.versions.kotlin
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
index 4ab4a1fa3..513840c08 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
@@ -26,40 +26,53 @@ import kotlin.reflect.KProperty
  * `add` operation adds new columns to DataFrame.
  */
 
+// region Add existing columns
+
 /**
  * Creates new [DataFrame] with given columns added to the end of original [DataFrame.columns] list.
  *
  * Original [DataFrame] is not modified.
  *
+ * @param columns columns to add
  * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names
  * @throws [UnequalColumnSizesException] if columns in expected result have different sizes
  * @return new [DataFrame] with added columns
  */
-private interface Add
-
-// region Add existing columns
-
-/**
- * @include [Add]
- * @param columns columns to add
- */
 public fun <T> DataFrame<T>.add(vararg columns: AnyBaseCol): DataFrame<T> = addAll(columns.asIterable())
 
 /**
- * @include [Add]
+ * Creates new [DataFrame] with given columns added to the end of original [DataFrame.columns] list.
+ *
+ * Original [DataFrame] is not modified.
+ *
  * @param columns columns to add
+ * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names
+ * @throws [UnequalColumnSizesException] if columns in expected result have different sizes
+ * @return new [DataFrame] with added columns
  */
 public fun <T> DataFrame<T>.addAll(columns: Iterable<AnyBaseCol>): DataFrame<T> = dataFrameOf(columns() + columns).cast()
 
 /**
- * @include [Add]
+ * Creates new [DataFrame] with all columns from given [dataFrames] added to the end of original [DataFrame.columns] list.
+ *
+ * Original [DataFrame] is not modified.
+ *
  * @param dataFrames dataFrames to get columns from
+ * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names
+ * @throws [UnequalColumnSizesException] if columns in expected result have different sizes
+ * @return new [DataFrame] with added columns
  */
 public fun <T> DataFrame<T>.add(vararg dataFrames: AnyFrame): DataFrame<T> = addAll(dataFrames.asIterable())
 
 /**
- * @include [Add]
+ * Creates new [DataFrame] with all columns from given [dataFrames] added to the end of original [DataFrame.columns] list.
+ *
+ * Original [DataFrame] is not modified.
+ *
  * @param dataFrames dataFrames to get columns from
+ * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names
+ * @throws [UnequalColumnSizesException] if columns in expected result have different sizes
+ * @return new [DataFrame] with added columns
  */
 @JvmName("addAllFrames")
 public fun <T> DataFrame<T>.addAll(dataFrames: Iterable<AnyFrame>): DataFrame<T> = addAll(dataFrames.flatMap { it.columns() })
diff --git a/settings.gradle.kts b/settings.gradle.kts
index e8686a670..c908e5c26 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -35,7 +35,7 @@ pluginManagement {
         eachPlugin {
             requested.apply {
                 val jitpackPlugins = listOf(
-                    "com.github.jolanrensen.kdocIncludeGradlePlugin",
+                    "com.github.jolanrensen.docProcessorGradlePlugin",
                 )
                 if ("$id" in jitpackPlugins) {
                     val (_, _, user, name) = "$id".split(".", limit = 4)

From 63ccc2914137605d748f6a0c2d0b41c11b78d3e9 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Tue, 24 Jan 2023 18:24:05 +0100
Subject: [PATCH 09/50] started on example doc structure using doc processor

---
 core/build.gradle.kts                         |   8 +-
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  | 163 ++++++++++++------
 .../jetbrains/kotlinx/dataframe/api/update.kt |  18 ++
 .../dataframe/documentation/AccessApi.kt      |  70 ++++++++
 .../documentation/DocumentationUrls.kt        |  33 ++++
 .../documentation/samples/ApiLevels.kt        | 132 ++++++++++++++
 6 files changed, 366 insertions(+), 58 deletions(-)
 create mode 100644 core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
 create mode 100644 core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
 create mode 100644 core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/samples/ApiLevels.kt

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 5e94b4e51..64ade3457 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -14,7 +14,8 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.1"
+    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.3"
+//    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
 }
 
 group = "org.jetbrains.kotlinx"
@@ -63,7 +64,10 @@ val kotlinMainSources = kotlin.sourceSets.main.get().kotlin.sourceDirectories
 val processKdocIncludeMain by creatingProcessDocTask(
     sources = kotlinMainSources.filterNot { "build/generated" in it.path } // Exclude generated sources
 ) {
-    processors = listOf(INCLUDE_DOC_PROCESSOR)
+    processors = listOf(
+        INCLUDE_DOC_PROCESSOR,
+        SAMPLE_DOC_PROCESSOR,
+    )
     debug = true
 }
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index 14daf12e8..f9b87caaa 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -9,6 +9,7 @@ import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.documentation.*
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
 import org.jetbrains.kotlinx.dataframe.kind
@@ -17,20 +18,70 @@ import kotlin.reflect.KProperty
 
 // region fillNulls
 
-public fun <T, C> DataFrame<T>.fillNulls(cols: ColumnsSelector<T, C?>): Update<T, C?> =
-    update(cols).where { it == null }
-
-public fun <T> DataFrame<T>.fillNulls(vararg cols: String): Update<T, Any?> =
-    fillNulls { cols.toColumns() }
-
-public fun <T, C> DataFrame<T>.fillNulls(vararg cols: KProperty<C>): Update<T, C?> =
-    fillNulls { cols.toColumns() }
-
-public fun <T, C> DataFrame<T>.fillNulls(vararg cols: ColumnReference<C>): Update<T, C?> =
-    fillNulls { cols.toColumns() }
-
-public fun <T, C> DataFrame<T>.fillNulls(cols: Iterable<ColumnReference<C>>): Update<T, C?> =
-    fillNulls { cols.toColumnSet() }
+/**
+ * Replace `null` values with given value or expression.
+ * Specific case of [UpdateOperation].
+ * TODO samples
+ *
+ * @include [DocumentationUrls.Fill.FillNulls]
+ */
+internal interface FillNullsOperation
+
+/**
+ * @include [FillNullsOperation]
+ *
+ * @param columns The [ColumnsSelector] used to select columns to update.
+ */
+public fun <T, C> DataFrame<T>.fillNulls(columns: ColumnsSelector<T, C?>): Update<T, C?> =
+    update(columns).where { it == null }
+
+/**
+ * @include [FillNullsOperation]
+ *
+ * @receiver [DataFrame]
+ * @param T T
+ * @param C C
+ * @param columns Cols
+ * @return [Update]
+ */
+public fun <T> DataFrame<T>.fillNulls(vararg columns: String): Update<T, Any?> =
+    fillNulls { columns.toColumns() }
+
+/**
+ * @include [FillNullsOperation]
+ *
+ * @receiver [DataFrame]
+ * @param T T
+ * @param C C
+ * @param columns Cols
+ * @return [Update]
+ */
+public fun <T, C> DataFrame<T>.fillNulls(vararg columns: KProperty<C>): Update<T, C?> =
+    fillNulls { columns.toColumns() }
+
+/**
+ * @include [FillNullsOperation]
+ *
+ * @receiver [DataFrame]
+ * @param T T
+ * @param C C
+ * @param columns Cols
+ * @return [Update]
+ */
+public fun <T, C> DataFrame<T>.fillNulls(vararg columns: ColumnReference<C>): Update<T, C?> =
+    fillNulls { columns.toColumns() }
+
+/**
+ * @include [FillNullsOperation]
+ *
+ * @receiver [DataFrame]
+ * @param T T
+ * @param C C
+ * @param columns Cols
+ * @return [Update]
+ */
+public fun <T, C> DataFrame<T>.fillNulls(columns: Iterable<ColumnReference<C>>): Update<T, C?> =
+    fillNulls { columns.toColumnSet() }
 
 // endregion
 
@@ -56,64 +107,64 @@ internal inline val Float?.isNA: Boolean get() = this == null || this.isNaN()
 
 // region fillNaNs
 
-public fun <T, C> DataFrame<T>.fillNaNs(cols: ColumnsSelector<T, C>): Update<T, C> =
-    update(cols).where { it.isNaN }
+public fun <T, C> DataFrame<T>.fillNaNs(columns: ColumnsSelector<T, C>): Update<T, C> =
+    update(columns).where { it.isNaN }
 
-public fun <T> DataFrame<T>.fillNaNs(vararg cols: String): Update<T, Any?> =
-    fillNaNs { cols.toColumns() }
+public fun <T> DataFrame<T>.fillNaNs(vararg columns: String): Update<T, Any?> =
+    fillNaNs { columns.toColumns() }
 
-public fun <T, C> DataFrame<T>.fillNaNs(vararg cols: KProperty<C>): Update<T, C> =
-    fillNaNs { cols.toColumns() }
+public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: KProperty<C>): Update<T, C> =
+    fillNaNs { columns.toColumns() }
 
-public fun <T, C> DataFrame<T>.fillNaNs(vararg cols: ColumnReference<C>): Update<T, C> =
-    fillNaNs { cols.toColumns() }
+public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: ColumnReference<C>): Update<T, C> =
+    fillNaNs { columns.toColumns() }
 
-public fun <T, C> DataFrame<T>.fillNaNs(cols: Iterable<ColumnReference<C>>): Update<T, C> =
-    fillNaNs { cols.toColumnSet() }
+public fun <T, C> DataFrame<T>.fillNaNs(columns: Iterable<ColumnReference<C>>): Update<T, C> =
+    fillNaNs { columns.toColumnSet() }
 
 // endregion
 
 // region fillNA
 
-public fun <T, C> DataFrame<T>.fillNA(cols: ColumnsSelector<T, C?>): Update<T, C?> =
-    update(cols).where { it.isNA }
+public fun <T, C> DataFrame<T>.fillNA(columns: ColumnsSelector<T, C?>): Update<T, C?> =
+    update(columns).where { it.isNA }
 
-public fun <T> DataFrame<T>.fillNA(vararg cols: String): Update<T, Any?> =
-    fillNA { cols.toColumns() }
+public fun <T> DataFrame<T>.fillNA(vararg columns: String): Update<T, Any?> =
+    fillNA { columns.toColumns() }
 
-public fun <T, C> DataFrame<T>.fillNA(vararg cols: KProperty<C>): Update<T, C?> =
-    fillNA { cols.toColumns() }
+public fun <T, C> DataFrame<T>.fillNA(vararg columns: KProperty<C>): Update<T, C?> =
+    fillNA { columns.toColumns() }
 
-public fun <T, C> DataFrame<T>.fillNA(vararg cols: ColumnReference<C>): Update<T, C?> =
-    fillNA { cols.toColumns() }
+public fun <T, C> DataFrame<T>.fillNA(vararg columns: ColumnReference<C>): Update<T, C?> =
+    fillNA { columns.toColumns() }
 
-public fun <T, C> DataFrame<T>.fillNA(cols: Iterable<ColumnReference<C>>): Update<T, C?> =
-    fillNA { cols.toColumnSet() }
+public fun <T, C> DataFrame<T>.fillNA(columns: Iterable<ColumnReference<C>>): Update<T, C?> =
+    fillNA { columns.toColumnSet() }
 
 // endregion
 
 // region dropNulls
 
 public fun <T> DataFrame<T>.dropNulls(whereAllNull: Boolean = false, selector: ColumnsSelector<T, *>): DataFrame<T> {
-    val cols = this[selector]
-    return if (whereAllNull) drop { row -> cols.all { col -> col[row] == null } }
-    else drop { row -> cols.any { col -> col[row] == null } }
+    val columns = this[selector]
+    return if (whereAllNull) drop { row -> columns.all { col -> col[row] == null } }
+    else drop { row -> columns.any { col -> col[row] == null } }
 }
 
 public fun <T> DataFrame<T>.dropNulls(whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { all() }
 
-public fun <T> DataFrame<T>.dropNulls(vararg cols: KProperty<*>, whereAllNull: Boolean = false): DataFrame<T> =
-    dropNulls(whereAllNull) { cols.toColumns() }
+public fun <T> DataFrame<T>.dropNulls(vararg columns: KProperty<*>, whereAllNull: Boolean = false): DataFrame<T> =
+    dropNulls(whereAllNull) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNulls(vararg cols: String, whereAllNull: Boolean = false): DataFrame<T> =
-    dropNulls(whereAllNull) { cols.toColumns() }
+public fun <T> DataFrame<T>.dropNulls(vararg columns: String, whereAllNull: Boolean = false): DataFrame<T> =
+    dropNulls(whereAllNull) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNulls(vararg cols: Column, whereAllNull: Boolean = false): DataFrame<T> =
-    dropNulls(whereAllNull) { cols.toColumns() }
+public fun <T> DataFrame<T>.dropNulls(vararg columns: Column, whereAllNull: Boolean = false): DataFrame<T> =
+    dropNulls(whereAllNull) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNulls(cols: Iterable<Column>, whereAllNull: Boolean = false): DataFrame<T> =
-    dropNulls(whereAllNull) { cols.toColumnSet() }
+public fun <T> DataFrame<T>.dropNulls(columns: Iterable<Column>, whereAllNull: Boolean = false): DataFrame<T> =
+    dropNulls(whereAllNull) { columns.toColumnSet() }
 
 public fun <T> DataColumn<T?>.dropNulls(): DataColumn<T> =
     (if (!hasNulls()) this else filter { it != null }) as DataColumn<T>
@@ -123,23 +174,23 @@ public fun <T> DataColumn<T?>.dropNulls(): DataColumn<T> =
 // region dropNA
 
 public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false, selector: ColumnsSelector<T, *>): DataFrame<T> {
-    val cols = this[selector]
+    val columns = this[selector]
 
-    return if (whereAllNA) drop { cols.all { this[it].isNA } }
-    else drop { cols.any { this[it].isNA } }
+    return if (whereAllNA) drop { columns.all { this[it].isNA } }
+    else drop { columns.any { this[it].isNA } }
 }
 
-public fun <T> DataFrame<T>.dropNA(vararg cols: KProperty<*>, whereAllNA: Boolean = false): DataFrame<T> =
-    dropNA(whereAllNA) { cols.toColumns() }
+public fun <T> DataFrame<T>.dropNA(vararg columns: KProperty<*>, whereAllNA: Boolean = false): DataFrame<T> =
+    dropNA(whereAllNA) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNA(vararg cols: String, whereAllNA: Boolean = false): DataFrame<T> =
-    dropNA(whereAllNA) { cols.toColumns() }
+public fun <T> DataFrame<T>.dropNA(vararg columns: String, whereAllNA: Boolean = false): DataFrame<T> =
+    dropNA(whereAllNA) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNA(vararg cols: Column, whereAllNA: Boolean = false): DataFrame<T> =
-    dropNA(whereAllNA) { cols.toColumns() }
+public fun <T> DataFrame<T>.dropNA(vararg columns: Column, whereAllNA: Boolean = false): DataFrame<T> =
+    dropNA(whereAllNA) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNA(cols: Iterable<Column>, whereAllNA: Boolean = false): DataFrame<T> =
-    dropNA(whereAllNA) { cols.toColumnSet() }
+public fun <T> DataFrame<T>.dropNA(columns: Iterable<Column>, whereAllNA: Boolean = false): DataFrame<T> =
+    dropNA(whereAllNA) { columns.toColumnSet() }
 
 public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { all() }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index b0e6d9a1e..e89a13d5c 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -19,6 +19,24 @@ import org.jetbrains.kotlinx.dataframe.impl.headPlusArray
 import org.jetbrains.kotlinx.dataframe.index
 import kotlin.reflect.KProperty
 
+/**
+ * Returns [DataFrame] with changed values in some cells.
+ * Column types can not be changed.
+ *
+ * TODO
+ */
+internal interface UpdateOperation {
+
+    /** @param columns The [ColumnsSelector] used to select the columns of this [DataFrame] to update. */
+    val columnsSelector: Nothing
+
+    /** @param columns An [Iterable] of [ColumnReference]s belonging to this [DataFrame] to update. */
+    val columnReferenceIterable: Nothing
+
+    /** @param columns The column names belonging to this [DataFrame] to update. */
+    val stringColumns: Nothing
+}
+
 public fun <T, C> DataFrame<T>.update(columns: ColumnsSelector<T, C>): Update<T, C> =
     Update(this, null, columns)
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
new file mode 100644
index 000000000..b7b541fe4
--- /dev/null
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
@@ -0,0 +1,70 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.documentation.samples.ApiLevels as ApiLevelsSample
+
+/**
+ * By nature data frames are dynamic objects, column labels depend on the input source and also new columns could be added
+ * or deleted while wrangling. Kotlin, in contrast, is a statically typed language and all types are defined and verified
+ * ahead of execution. That's why creating a flexible, handy, and, at the same time, safe API to a data frame is tricky.
+ *
+ * In `Kotlin DataFrame` we provide four different ways to access columns, and, while they are essentially different, they
+ * look pretty similar in the data wrangling DSL. These include:
+ *  - [StringApi]
+ *  - [ColumnAccessorsApi]
+ *  - [KPropertiesApi]
+ *  - [ExtensionPropertiesApi]
+ *
+ * @include [DocumentationUrls.AccessApis]
+ */
+internal interface AccessApi {
+
+    /**
+     * String API.
+     * In this [AccessApi], columns are accessed by a [String] representing their name.
+     * Type-checking is done at runtime, name-checking too.
+     *
+     * @include [DocumentationUrls.AccessApis.StringApi]
+     *
+     * For example:
+     * @sample [ApiLevelsSample.strings]
+     */
+    interface StringApi
+
+    /**
+     * Column Accessors API.
+     * In this [AccessApi], every column has a descriptor;
+     * a variable that represents its name and type.
+     *
+     * @include [DocumentationUrls.AccessApis.ColumnAccessorsApi]
+     *
+     * For example:
+     * @sample [ApiLevelsSample.accessors3]
+     */
+    interface ColumnAccessorsApi
+
+    /**
+     * KProperties API.
+     * In this [AccessApi], columns accessed by the
+     * [`KProperty`](https://kotlinlang.org/docs/reflection.html#property-references)
+     * of some class.
+     * The name and type of column should match the name and type of property, respectively.
+     *
+     * @include [DocumentationUrls.AccessApis.KPropertiesApi]
+     *
+     * For example:
+     * @sample [ApiLevelsSample.kproperties1]
+     */
+    interface KPropertiesApi
+
+    /**
+     * Extension Properties API.
+     * In this [AccessApi], extension access properties are generated based on the dataframe schema.
+     * The name and type of properties are inferred from the name and type of the corresponding columns.
+     *
+     * @include [DocumentationUrls.AccessApis.ExtensionPropertiesApi]
+     *
+     * For example:
+     * @sample [ApiLevelsSample.extensionProperties1]
+     */
+    interface ExtensionPropertiesApi
+}
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
new file mode 100644
index 000000000..84a17e89b
--- /dev/null
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
@@ -0,0 +1,33 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+internal interface DocumentationUrls {
+
+    /** [See `fill` documentation.](https://kotlin.github.io/dataframe/fill.html) */
+    interface Fill {
+
+        /** [See `fillNulls` documentation](https://kotlin.github.io/dataframe/fill.html#fillnulls) */
+        interface FillNulls
+
+        /** [See `fillNaNs` documentation](https://kotlin.github.io/dataframe/fill.html#fillnans) */
+        interface FillNaNs
+
+        /** [See `fillNA` documentation](https://kotlin.github.io/dataframe/fill.html#fillna) */
+        interface FillNA
+    }
+
+    /** [See Access APIs documentation.](https://kotlin.github.io/dataframe/apilevels.html) */
+    interface AccessApis {
+
+        /** [See String API documentation.](https://kotlin.github.io/dataframe/stringapi.html) */
+        interface StringApi
+
+        /** [See Column Accessors API documentation.](https://kotlin.github.io/dataframe/columnaccessorsapi.html) */
+        interface ColumnAccessorsApi
+
+        /** [See KProperties API documentation.](https://kotlin.github.io/dataframe/kpropertiesapi.html) */
+        interface KPropertiesApi
+
+        /** [See Extension Properties API documentation.](https://kotlin.github.io/dataframe/extensionpropertiesapi.html) */
+        interface ExtensionPropertiesApi
+    }
+}
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/samples/ApiLevels.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/samples/ApiLevels.kt
new file mode 100644
index 000000000..699763eb1
--- /dev/null
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/samples/ApiLevels.kt
@@ -0,0 +1,132 @@
+@file:Suppress("RemoveExplicitTypeArguments")
+
+package org.jetbrains.kotlinx.dataframe.documentation.samples
+
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.ColumnName
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.dropNulls
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.toListOf
+import org.jetbrains.kotlinx.dataframe.io.read
+
+internal interface ApiLevels {
+
+    fun strings() {
+        DataFrame.read("titanic.csv")
+            .add("lastName") { "name"<String>().split(",").last() }
+            .dropNulls("age")
+            .filter {
+                "survived"<Boolean>() &&
+                    "home"<String>().endsWith("NY") &&
+                    "age"<Int>() in 10..20
+            }
+    }
+
+    fun accessors1() {
+        val survived by column<Boolean>() // accessor for Boolean column with name 'survived'
+        val home by column<String>()
+        val age by column<Int?>()
+        val name by column<String>()
+        val lastName by column<String>()
+    }
+
+    fun accessors2() {
+        val survived by column<Boolean>()
+        val home by column<String>()
+        val age by column<Int?>()
+        val name by column<String>()
+        val lastName by column<String>()
+
+        DataFrame.read("titanic.csv")
+            .add(lastName) { name().split(",").last() }
+            .dropNulls { age }
+            .filter { survived() && home().endsWith("NY") && age()!! in 10..20 }
+    }
+
+    fun accessors3() {
+        val survived by column<Boolean>()
+        val home by column<String>()
+        val age by column<Int?>()
+        val name by column<String>()
+        val lastName by column<String>()
+
+        DataFrame.read("titanic.csv")
+            .add(lastName) { name().split(",").last() }
+            .dropNulls { age }
+            .filter { survived() && home().endsWith("NY") && age()!! in 10..20 }
+    }
+
+    fun kproperties1() {
+        data class Passenger(
+            val survived: Boolean,
+            val home: String,
+            val age: Int,
+            val lastName: String
+        )
+
+        val passengers = DataFrame.read("titanic.csv")
+            .add(Passenger::lastName) { "name"<String>().split(",").last() }
+            .dropNulls(Passenger::age)
+            .filter {
+                it[Passenger::survived] &&
+                    it[Passenger::home].endsWith("NY") &&
+                    it[Passenger::age] in 10..20
+            }
+            .toListOf<Passenger>()
+    }
+
+    fun kproperties2() {
+        data class Passenger(
+            @ColumnName("survived") val isAlive: Boolean,
+            @ColumnName("home") val city: String,
+            val name: String
+        )
+
+        val passengers = DataFrame.read("titanic.csv")
+            .filter { it.get(Passenger::city).endsWith("NY") }
+            .toListOf<Passenger>()
+    }
+
+    //    @DataSchema
+    interface TitanicPassenger {
+        val survived: Boolean
+        val home: String
+        val age: Int
+        val name: String
+    }
+
+    fun extensionProperties2() {
+        val df = DataFrame.read("titanic.csv").cast<TitanicPassenger>()
+
+        df.add("lastName") { name.split(",").last() }
+            .dropNulls { age }
+            .filter { survived && home.endsWith("NY") && age in 10..20 }
+    }
+
+    fun extensionProperties1() {
+        val df = DataFrame.read("titanic.csv")
+    }
+}
+
+internal val ColumnsContainer<ApiLevels.TitanicPassenger>.age: DataColumn<Int> @JvmName("TitanicPassenger_age") get() = this["age"] as DataColumn<Int>
+internal val DataRow<ApiLevels.TitanicPassenger>.age: Int @JvmName("TitanicPassenger_age") get() = this["age"] as Int
+internal val ColumnsContainer<ApiLevels.TitanicPassenger?>.age: DataColumn<Int?> @JvmName("NullableTitanicPassenger_age") get() = this["age"] as DataColumn<Int?>
+internal val DataRow<ApiLevels.TitanicPassenger?>.age: Int? @JvmName("NullableTitanicPassenger_age") get() = this["age"] as Int?
+internal val ColumnsContainer<ApiLevels.TitanicPassenger>.home: DataColumn<String> @JvmName("TitanicPassenger_home") get() = this["home"] as DataColumn<String>
+internal val DataRow<ApiLevels.TitanicPassenger>.home: String @JvmName("TitanicPassenger_home") get() = this["home"] as String
+internal val ColumnsContainer<ApiLevels.TitanicPassenger?>.home: DataColumn<String?> @JvmName("NullableTitanicPassenger_home") get() = this["home"] as DataColumn<String?>
+internal val DataRow<ApiLevels.TitanicPassenger?>.home: String? @JvmName("NullableTitanicPassenger_home") get() = this["home"] as String?
+internal val ColumnsContainer<ApiLevels.TitanicPassenger>.name: DataColumn<String> @JvmName("TitanicPassenger_name") get() = this["name"] as DataColumn<String>
+internal val DataRow<ApiLevels.TitanicPassenger>.name: String @JvmName("TitanicPassenger_name") get() = this["name"] as String
+internal val ColumnsContainer<ApiLevels.TitanicPassenger?>.name: DataColumn<String?> @JvmName("NullableTitanicPassenger_name") get() = this["name"] as DataColumn<String?>
+internal val DataRow<ApiLevels.TitanicPassenger?>.name: String? @JvmName("NullableTitanicPassenger_name") get() = this["name"] as String?
+internal val ColumnsContainer<ApiLevels.TitanicPassenger>.survived: DataColumn<Boolean> @JvmName("TitanicPassenger_survived") get() = this["survived"] as DataColumn<Boolean>
+internal val DataRow<ApiLevels.TitanicPassenger>.survived: Boolean @JvmName("TitanicPassenger_survived") get() = this["survived"] as Boolean
+internal val ColumnsContainer<ApiLevels.TitanicPassenger?>.survived: DataColumn<Boolean?> @JvmName("NullableTitanicPassenger_survived") get() = this["survived"] as DataColumn<Boolean?>
+internal val DataRow<ApiLevels.TitanicPassenger?>.survived: Boolean? @JvmName("NullableTitanicPassenger_survived") get() = this["survived"] as Boolean?

From 970873252f88210bb9e8d2270feb799529e76fcb Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Thu, 26 Jan 2023 23:12:07 +0100
Subject: [PATCH 10/50] starting with update operation as template to figure
 out where to go next

---
 core/build.gradle.kts                         |   4 +-
 .../jetbrains/kotlinx/dataframe/api/update.kt | 150 +++++++++++++++++-
 .../dataframe/documentation/AccessApi.kt      |  32 +++-
 .../documentation/DocumentationUrls.kt        |   8 +-
 .../documentation/samples/ApiLevels.kt        |  14 ++
 5 files changed, 190 insertions(+), 18 deletions(-)

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 64ade3457..70c10d4d1 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -14,7 +14,7 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.3"
+    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.6"
 //    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
 }
 
@@ -67,6 +67,8 @@ val processKdocIncludeMain by creatingProcessDocTask(
     processors = listOf(
         INCLUDE_DOC_PROCESSOR,
         SAMPLE_DOC_PROCESSOR,
+        INCLUDE_FILE_DOC_PROCESSOR,
+        COMMENT_DOC_PROCESSOR,
     )
     debug = true
 }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index e89a13d5c..651f9a3d9 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -11,6 +11,7 @@ import org.jetbrains.kotlinx.dataframe.RowValueExpression
 import org.jetbrains.kotlinx.dataframe.RowValueFilter
 import org.jetbrains.kotlinx.dataframe.Selector
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.documentation.AccessApi
 import org.jetbrains.kotlinx.dataframe.impl.api.updateImpl
 import org.jetbrains.kotlinx.dataframe.impl.api.updateWithValuePerColumnImpl
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
@@ -21,33 +22,139 @@ import kotlin.reflect.KProperty
 
 /**
  * Returns [DataFrame] with changed values in some cells.
+ *
  * Column types can not be changed.
  *
- * TODO
+ * Usage:
+ *
+ * [update] { columns }
+ *
+ *   [.[where] { [rowCondition][UpdateOperation.Where.Predicate] } ]
+ *
+ *   [.[at] ([rowIndices][UpdateOperation.At.RowIndices]) ]
+ *
+ *   .[with][Update.with] { [rowExpression][UpdateOperation.With.Expression] } | .[notNull] { rowExpression } | .[perCol] { colExpression } | .[perRowCol] { rowColExpression } | .[withValue] (value) | .[withNull] () | .[withZero] () | .[asFrame] { frameExpression }
+ *
+ * @comment TODO
+ * rowExpression: DataRow.(OldValue) -> NewValue
+ * colExpression: DataColumn.(DataColumn) -> NewValue
+ * rowColExpression: DataRow.(DataColumn) -> NewValue
+ * frameExpression: DataFrame.(DataFrame) -> DataFrame
+ *
  */
 internal interface UpdateOperation {
 
     /** @param columns The [ColumnsSelector] used to select the columns of this [DataFrame] to update. */
-    val columnsSelector: Nothing
+    interface ColumnsSelectorParam
+
+    /** @param columns An [Iterable] of [ColumnReference]s of this [DataFrame] to update. */
+    interface ColumnReferenceIterableParam
 
-    /** @param columns An [Iterable] of [ColumnReference]s belonging to this [DataFrame] to update. */
-    val columnReferenceIterable: Nothing
+    /** @param columns The [ColumnReference]s of this [DataFrame] to update. */
+    interface ColumnReferencesParam
+
+    /** @param columns The [KProperty] values corresponding to columns of this [DataFrame] to update. */
+    interface KPropertyColumnsParam
 
     /** @param columns The column names belonging to this [DataFrame] to update. */
-    val stringColumns: Nothing
+    interface StringColumnsParam
+
+    /**
+     * Only update the columns that pass a certain [predicate][UpdateOperation.Where.Predicate].
+     *
+     * For example:
+     * ```kotlin
+     * df.update { city }.where { name.firstName == "Alice" }.withValue("Paris")
+     * ```
+     */
+    interface Where {
+
+        /** The condition for rows to be included. A filter if you will.
+         *
+         * Can be seen as [DataRow].(oldValue: [C]) -> [Boolean] */
+        interface Predicate
+    }
+
+    /**
+     * Only update the columns at certain given [row indices][UpdateOperation.At.RowIndices]:
+     *
+     * Either a [Collection]<[Int]>, an [IntRange], or just `vararg` indices.
+     *
+     * For example:
+     * ```kotlin
+     * df.update { city }.at(5..10).withValue("Paris")
+     * ```
+     */
+    interface At {
+
+        /** The indices of the rows to update. */
+        interface RowIndices
+    }
+
+    /**
+     * Update the selected columns using the given [expression][With.Expression].
+     *
+     * For example:
+     * ```kotlin
+     * df.update { city }.with { name.firstName + " from " + it }
+     * ```
+     */
+    interface With {
+
+        /** The expression to update the selected columns with.
+         *
+         * Can be seen as [DataRow].(oldValue: [C]) -> newValue: [C]?
+         * */
+        interface Expression
+    }
 }
 
+/**
+ * @include [UpdateOperation]
+ * @include [AccessApi.AnyApiLink]
+ * @include [UpdateOperation.ColumnsSelectorParam]
+ */
 public fun <T, C> DataFrame<T>.update(columns: ColumnsSelector<T, C>): Update<T, C> =
     Update(this, null, columns)
 
-public fun <T, C> DataFrame<T>.update(columns: Iterable<ColumnReference<C>>): Update<T, C> =
-    update { columns.toColumnSet() }
-
+/**
+ * @include [UpdateOperation]
+ * API:
+ *  - {@include [AccessApi.StringApiLink]}
+ *
+ * @include [UpdateOperation.StringColumnsParam]
+ */
 public fun <T> DataFrame<T>.update(vararg columns: String): Update<T, Any?> = update { columns.toColumns() }
+
+/**
+ * @include [UpdateOperation]
+ * API:
+ *  - {@include [AccessApi.KPropertiesApiLink]}
+ *
+ * @include [UpdateOperation.KPropertyColumnsParam]
+ */
 public fun <T, C> DataFrame<T>.update(vararg columns: KProperty<C>): Update<T, C> = update { columns.toColumns() }
+
+/**
+ * @include [UpdateOperation]
+ * API:
+ *  - {@include [AccessApi.ColumnAccessorsApiLink]}
+ *
+ * @include [UpdateOperation.ColumnReferencesParam]
+ */
 public fun <T, C> DataFrame<T>.update(vararg columns: ColumnReference<C>): Update<T, C> =
     update { columns.toColumns() }
 
+/**
+ * @include [UpdateOperation]
+ * API:
+ *  - {@include [AccessApi.ColumnAccessorsApiLink]}
+ *
+ * @include [UpdateOperation.ColumnReferenceIterableParam]
+ */
+public fun <T, C> DataFrame<T>.update(columns: Iterable<ColumnReference<C>>): Update<T, C> =
+    update { columns.toColumnSet() }
+
 public data class Update<T, C>(
     val df: DataFrame<T>,
     val filter: RowValueFilter<T, C>?,
@@ -57,11 +164,33 @@ public data class Update<T, C>(
         Update(df, filter as RowValueFilter<T, R>?, columns as ColumnsSelector<T, R>)
 }
 
+/**
+ * @include [UpdateOperation.Where]
+ *
+ * @param predicate {@include [UpdateOperation.Where.Predicate]}
+ */
 public fun <T, C> Update<T, C>.where(predicate: RowValueFilter<T, C>): Update<T, C> =
     copy(filter = filter and predicate)
 
+/**
+ * @include [UpdateOperation.At]
+ *
+ * @param rowIndices {@include [UpdateOperation.At.RowIndices]}
+ */
 public fun <T, C> Update<T, C>.at(rowIndices: Collection<Int>): Update<T, C> = where { index in rowIndices }
+
+/**
+ * @include [UpdateOperation.At]
+ *
+ * @param rowIndices {@include [UpdateOperation.At.RowIndices]}
+ */
 public fun <T, C> Update<T, C>.at(vararg rowIndices: Int): Update<T, C> = at(rowIndices.toSet())
+
+/**
+ * @include [UpdateOperation.At]
+ *
+ * @param rowRange {@include [UpdateOperation.At.RowIndices]}
+ */
 public fun <T, C> Update<T, C>.at(rowRange: IntRange): Update<T, C> = where { index in rowRange }
 
 public infix fun <T, C> Update<T, C>.perRowCol(expression: RowColumnExpression<T, C, C>): DataFrame<T> =
@@ -69,6 +198,11 @@ public infix fun <T, C> Update<T, C>.perRowCol(expression: RowColumnExpression<T
 
 public typealias UpdateExpression<T, C, R> = AddDataRow<T>.(C) -> R
 
+/**
+ * @include [UpdateOperation.With]
+ *
+ * @param expression {@include [UpdateOperation.With.Expression]}
+ */
 public infix fun <T, C> Update<T, C>.with(expression: UpdateExpression<T, C, C?>): DataFrame<T> =
     updateImpl { row, _, value ->
         expression(row, value)
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
index b7b541fe4..3217ddde7 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
@@ -14,34 +14,50 @@ import org.jetbrains.kotlinx.dataframe.documentation.samples.ApiLevels as ApiLev
  *  - [KPropertiesApi]
  *  - [ExtensionPropertiesApi]
  *
- * @include [DocumentationUrls.AccessApis]
+ * For more information: {@include [DocumentationUrls.AccessApis]}
+ *
+ * @comment We can link to here whenever we want to explain the different access APIs.
  */
 internal interface AccessApi {
 
+    /** API:
+     * - {@include [AccessApi.ExtensionPropertiesApiLink]}
+     * - {@include [AccessApi.KPropertiesApiLink]}
+     * - {@include [AccessApi.ColumnAccessorsApiLink]}
+     * - {@include [AccessApi.StringApiLink]}
+     * */
+    interface AnyApiLink
+
     /**
      * String API.
      * In this [AccessApi], columns are accessed by a [String] representing their name.
      * Type-checking is done at runtime, name-checking too.
      *
-     * @include [DocumentationUrls.AccessApis.StringApi]
+     * For more information: {@include [DocumentationUrls.AccessApis.StringApi]}
      *
      * For example:
      * @sample [ApiLevelsSample.strings]
      */
     interface StringApi
 
+    /** String API [AccessApi.StringApi]. */
+    interface StringApiLink
+
     /**
      * Column Accessors API.
      * In this [AccessApi], every column has a descriptor;
      * a variable that represents its name and type.
      *
-     * @include [DocumentationUrls.AccessApis.ColumnAccessorsApi]
+     * For more information: {@include [DocumentationUrls.AccessApis.ColumnAccessorsApi]}
      *
      * For example:
      * @sample [ApiLevelsSample.accessors3]
      */
     interface ColumnAccessorsApi
 
+    /** Column Accessors API [AccessApi.ColumnAccessorsApi]. */
+    interface ColumnAccessorsApiLink
+
     /**
      * KProperties API.
      * In this [AccessApi], columns accessed by the
@@ -49,22 +65,28 @@ internal interface AccessApi {
      * of some class.
      * The name and type of column should match the name and type of property, respectively.
      *
-     * @include [DocumentationUrls.AccessApis.KPropertiesApi]
+     * For more information: {@include [DocumentationUrls.AccessApis.KPropertiesApi]}
      *
      * For example:
      * @sample [ApiLevelsSample.kproperties1]
      */
     interface KPropertiesApi
 
+    /** KProperties API [AccessApi.KPropertiesApi]. */
+    interface KPropertiesApiLink
+
     /**
      * Extension Properties API.
      * In this [AccessApi], extension access properties are generated based on the dataframe schema.
      * The name and type of properties are inferred from the name and type of the corresponding columns.
      *
-     * @include [DocumentationUrls.AccessApis.ExtensionPropertiesApi]
+     * For more information: {@include [DocumentationUrls.AccessApis.ExtensionPropertiesApi]}
      *
      * For example:
      * @sample [ApiLevelsSample.extensionProperties1]
      */
     interface ExtensionPropertiesApi
+
+    /** Extension Properties API [AccessApi.ExtensionPropertiesApi]. */
+    interface ExtensionPropertiesApiLink
 }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
index 84a17e89b..011579998 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
@@ -1,17 +1,17 @@
 package org.jetbrains.kotlinx.dataframe.documentation
 
-internal interface DocumentationUrls {
+private interface DocumentationUrls {
 
     /** [See `fill` documentation.](https://kotlin.github.io/dataframe/fill.html) */
     interface Fill {
 
-        /** [See `fillNulls` documentation](https://kotlin.github.io/dataframe/fill.html#fillnulls) */
+        /** [See `fillNulls` documentation.](https://kotlin.github.io/dataframe/fill.html#fillnulls) */
         interface FillNulls
 
-        /** [See `fillNaNs` documentation](https://kotlin.github.io/dataframe/fill.html#fillnans) */
+        /** [See `fillNaNs` documentation.](https://kotlin.github.io/dataframe/fill.html#fillnans) */
         interface FillNaNs
 
-        /** [See `fillNA` documentation](https://kotlin.github.io/dataframe/fill.html#fillna) */
+        /** [See `fillNA` documentation.](https://kotlin.github.io/dataframe/fill.html#fillna) */
         interface FillNA
     }
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/samples/ApiLevels.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/samples/ApiLevels.kt
index 699763eb1..81c553b0c 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/samples/ApiLevels.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/samples/ApiLevels.kt
@@ -18,6 +18,7 @@ import org.jetbrains.kotlinx.dataframe.io.read
 internal interface ApiLevels {
 
     fun strings() {
+        // SampleStart
         DataFrame.read("titanic.csv")
             .add("lastName") { "name"<String>().split(",").last() }
             .dropNulls("age")
@@ -26,17 +27,21 @@ internal interface ApiLevels {
                     "home"<String>().endsWith("NY") &&
                     "age"<Int>() in 10..20
             }
+        // SampleEnd
     }
 
     fun accessors1() {
+        // SampleStart
         val survived by column<Boolean>() // accessor for Boolean column with name 'survived'
         val home by column<String>()
         val age by column<Int?>()
         val name by column<String>()
         val lastName by column<String>()
+        // SampleEnd
     }
 
     fun accessors2() {
+        // SampleStart
         val survived by column<Boolean>()
         val home by column<String>()
         val age by column<Int?>()
@@ -47,9 +52,11 @@ internal interface ApiLevels {
             .add(lastName) { name().split(",").last() }
             .dropNulls { age }
             .filter { survived() && home().endsWith("NY") && age()!! in 10..20 }
+        // SampleEnd
     }
 
     fun accessors3() {
+        // SampleStart
         val survived by column<Boolean>()
         val home by column<String>()
         val age by column<Int?>()
@@ -60,9 +67,11 @@ internal interface ApiLevels {
             .add(lastName) { name().split(",").last() }
             .dropNulls { age }
             .filter { survived() && home().endsWith("NY") && age()!! in 10..20 }
+        // SampleEnd
     }
 
     fun kproperties1() {
+        // SampleStart
         data class Passenger(
             val survived: Boolean,
             val home: String,
@@ -79,9 +88,11 @@ internal interface ApiLevels {
                     it[Passenger::age] in 10..20
             }
             .toListOf<Passenger>()
+        // SampleEnd
     }
 
     fun kproperties2() {
+        // SampleStart
         data class Passenger(
             @ColumnName("survived") val isAlive: Boolean,
             @ColumnName("home") val city: String,
@@ -91,6 +102,7 @@ internal interface ApiLevels {
         val passengers = DataFrame.read("titanic.csv")
             .filter { it.get(Passenger::city).endsWith("NY") }
             .toListOf<Passenger>()
+        // SampleEnd
     }
 
     //    @DataSchema
@@ -102,11 +114,13 @@ internal interface ApiLevels {
     }
 
     fun extensionProperties2() {
+        // SampleStart
         val df = DataFrame.read("titanic.csv").cast<TitanicPassenger>()
 
         df.add("lastName") { name.split(",").last() }
             .dropNulls { age }
             .filter { survived && home.endsWith("NY") && age in 10..20 }
+        // SampleEnd
     }
 
     fun extensionProperties1() {

From fdda5ba5ebf5019630a94277df3d878a38d9aabd Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Mon, 30 Jan 2023 15:33:47 +0100
Subject: [PATCH 11/50] renamed Column to AnyColumnReference, similar to
 AnyFrame. Continuing with KDoc example structure

---
 core/build.gradle.kts                         |  2 +-
 .../jetbrains/kotlinx/dataframe/DataFrame.kt  |  2 +-
 .../jetbrains/kotlinx/dataframe/DataRow.kt    |  2 +-
 .../jetbrains/kotlinx/dataframe/aliases.kt    |  2 +-
 .../dataframe/api/ColumnsSelectionDsl.kt      | 15 +--
 .../kotlinx/dataframe/api/DataFrameGet.kt     |  5 +-
 .../kotlinx/dataframe/api/DataRowApi.kt       |  6 +-
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  | 15 +--
 .../jetbrains/kotlinx/dataframe/api/add.kt    | 26 +++--
 .../kotlinx/dataframe/api/countDistinct.kt    |  5 +-
 .../jetbrains/kotlinx/dataframe/api/cumSum.kt |  6 +-
 .../kotlinx/dataframe/api/distinct.kt         | 10 +-
 .../jetbrains/kotlinx/dataframe/api/group.kt  |  6 +-
 .../kotlinx/dataframe/api/groupBy.kt          | 17 ++--
 .../jetbrains/kotlinx/dataframe/api/move.kt   | 16 +--
 .../jetbrains/kotlinx/dataframe/api/pivot.kt  | 20 ++--
 .../jetbrains/kotlinx/dataframe/api/remove.kt | 10 +-
 .../jetbrains/kotlinx/dataframe/api/select.kt | 32 ++++--
 .../kotlinx/dataframe/api/toDataFrame.kt      | 16 ++-
 .../jetbrains/kotlinx/dataframe/api/unfold.kt |  4 +-
 .../kotlinx/dataframe/api/ungroup.kt          |  4 +-
 .../jetbrains/kotlinx/dataframe/api/update.kt | 98 +++++++++----------
 .../kotlinx/dataframe/api/valueCounts.kt      |  4 +-
 .../jetbrains/kotlinx/dataframe/api/values.kt | 14 +--
 .../jetbrains/kotlinx/dataframe/api/with.kt   |  4 +-
 .../dataframe/documentation/AccessApi.kt      | 21 ++--
 .../documentation/HighLevelOperations.kt      | 70 +++++++++++++
 .../impl/aggregation/aggregations.kt          |  4 +-
 .../kotlinx/dataframe/impl/api/move.kt        |  4 +-
 29 files changed, 277 insertions(+), 163 deletions(-)
 create mode 100644 core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/HighLevelOperations.kt

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 70c10d4d1..f1f48fe68 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -14,7 +14,7 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.6"
+    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.7"
 //    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
 }
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataFrame.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataFrame.kt
index dd1c55636..9698f9630 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataFrame.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataFrame.kt
@@ -57,7 +57,7 @@ public interface DataFrame<out T> : Aggregatable<T>, ColumnsContainer<T> {
     override operator fun <C> get(columns: ColumnsSelector<T, C>): List<DataColumn<C>> =
         getColumnsImpl(UnresolvedColumnsPolicy.Fail, columns)
 
-    public operator fun get(first: Column, vararg other: Column): DataFrame<T> = select(listOf(first) + other)
+    public operator fun get(first: AnyColumnReference, vararg other: AnyColumnReference): DataFrame<T> = select(listOf(first) + other)
     public operator fun get(first: String, vararg other: String): DataFrame<T> = select(listOf(first) + other)
     public operator fun get(columnRange: ClosedRange<String>): DataFrame<T> =
         select { columnRange.start..columnRange.endInclusive }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataRow.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataRow.kt
index 989fb3df2..5a1375436 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataRow.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataRow.kt
@@ -28,7 +28,7 @@ public interface DataRow<out T> {
     public operator fun <R> get(column: ColumnReference<R>): R
     public operator fun <R> get(columns: List<ColumnReference<R>>): List<R> = columns.map { get(it) }
     public operator fun <R> get(property: KProperty<R>): R = get(property.columnName) as R
-    public operator fun get(first: Column, vararg other: Column): DataRow<T> = owner.get(first, *other)[index]
+    public operator fun get(first: AnyColumnReference, vararg other: AnyColumnReference): DataRow<T> = owner.get(first, *other)[index]
     public operator fun get(first: String, vararg other: String): DataRow<T> = owner.get(first, *other)[index]
     public operator fun get(path: ColumnPath): Any? = owner.get(path)[index]
     public operator fun get(name: String): Any?
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt
index c7d63224e..74552bae8 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt
@@ -138,7 +138,7 @@ public typealias RowValueFilter<T, C> = RowValueExpression<T, C, Boolean>
 
 // region columns
 
-public typealias Column = ColumnReference<*>
+public typealias AnyColumnReference = ColumnReference<*>
 
 public typealias ColumnGroupReference = ColumnReference<AnyRow>
 public typealias ColumnGroupAccessor<T> = ColumnAccessor<DataRow<T>>
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
index 66b47de17..88d62b4e3 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
@@ -31,7 +31,6 @@ import org.jetbrains.kotlinx.dataframe.impl.columns.top
 import org.jetbrains.kotlinx.dataframe.impl.columns.transform
 import org.jetbrains.kotlinx.dataframe.impl.columns.transformSingle
 import org.jetbrains.kotlinx.dataframe.impl.columns.tree.dfs
-import org.jetbrains.kotlinx.dataframe.impl.getColumnsWithPaths
 import kotlin.reflect.KProperty
 import kotlin.reflect.KType
 import kotlin.reflect.typeOf
@@ -51,6 +50,10 @@ public interface ColumnSelectionDsl<out T> : ColumnsContainer<T> {
     public operator fun String.get(column: String): ColumnPath = pathOf(this, column)
 }
 
+
+/** [Columns Selection DSL][ColumnsSelectionDsl] */
+internal interface ColumnSelectionDslLink
+
 public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColumn<DataRow<T>> {
 
     public fun <C> ColumnSet<C>.first(condition: ColumnFilter<C>): SingleColumn<C> =
@@ -67,7 +70,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     public operator fun String.rangeTo(endInclusive: String): ColumnSet<*> = toColumnAccessor().rangeTo(endInclusive.toColumnAccessor())
 
-    public operator fun Column.rangeTo(endInclusive: Column): ColumnSet<*> = object : ColumnSet<Any?> {
+    public operator fun AnyColumnReference.rangeTo(endInclusive: AnyColumnReference): ColumnSet<*> = object : ColumnSet<Any?> {
         override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<Any?>> {
             val startPath = this@rangeTo.resolveSingle(context)!!.path
             val endPath = endInclusive.resolveSingle(context)!!.path
@@ -161,7 +164,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     }
 
     public fun SingleColumn<*>.allAfter(colName: String): ColumnSet<Any?> = allAfter(pathOf(colName))
-    public fun SingleColumn<*>.allAfter(column: Column): ColumnSet<Any?> = allAfter(column.path())
+    public fun SingleColumn<*>.allAfter(column: AnyColumnReference): ColumnSet<Any?> = allAfter(column.path())
 
     // endregion
 
@@ -180,7 +183,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     }
 
     public fun SingleColumn<*>.allSince(colName: String): ColumnSet<Any?> = allSince(pathOf(colName))
-    public fun SingleColumn<*>.allSince(column: Column): ColumnSet<Any?> = allSince(column.path())
+    public fun SingleColumn<*>.allSince(column: AnyColumnReference): ColumnSet<Any?> = allSince(column.path())
 
     // endregion
 
@@ -199,7 +202,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     }
 
     public fun SingleColumn<*>.allBefore(colName: String): ColumnSet<Any?> = allBefore(pathOf(colName))
-    public fun SingleColumn<*>.allBefore(column: Column): ColumnSet<Any?> = allBefore(column.path())
+    public fun SingleColumn<*>.allBefore(column: AnyColumnReference): ColumnSet<Any?> = allBefore(column.path())
 
     // endregion
 
@@ -218,7 +221,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     }
 
     public fun SingleColumn<*>.allUntil(colName: String): ColumnSet<Any?> = allUntil(pathOf(colName))
-    public fun SingleColumn<*>.allUntil(column: Column): ColumnSet<Any?> = allUntil(column.path())
+    public fun SingleColumn<*>.allUntil(column: AnyColumnReference): ColumnSet<Any?> = allUntil(column.path())
 
     // endregion
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataFrameGet.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataFrameGet.kt
index 8a49a3aa4..354d5990d 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataFrameGet.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataFrameGet.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyCol
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnSelector
 import org.jetbrains.kotlinx.dataframe.ColumnsContainer
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
@@ -19,7 +19,6 @@ import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
 import org.jetbrains.kotlinx.dataframe.impl.getColumnPaths
 import org.jetbrains.kotlinx.dataframe.impl.getColumnsWithPaths
-import org.jetbrains.kotlinx.dataframe.indices
 import org.jetbrains.kotlinx.dataframe.ncol
 import org.jetbrains.kotlinx.dataframe.nrow
 import kotlin.reflect.KProperty
@@ -89,7 +88,7 @@ public fun <T> ColumnsContainer<T>.getColumnGroupOrNull(column: KProperty<*>): C
 public fun <C> ColumnsContainer<*>.containsColumn(column: ColumnReference<C>): Boolean = getColumnOrNull(column) != null
 public fun ColumnsContainer<*>.containsColumn(column: KProperty<*>): Boolean = containsColumn(column.columnName)
 
-public operator fun ColumnsContainer<*>.contains(column: Column): Boolean = containsColumn(column)
+public operator fun ColumnsContainer<*>.contains(column: AnyColumnReference): Boolean = containsColumn(column)
 public operator fun ColumnsContainer<*>.contains(column: KProperty<*>): Boolean = containsColumn(column)
 
 // region rows
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowApi.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowApi.kt
index 9cdc67e72..d7987f5c4 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowApi.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowApi.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.AnyRow
-import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsContainer
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -57,10 +57,10 @@ public fun <T> AnyRow.getValueOrNull(column: KProperty<T>): T? = getValueOrNull<
 // region contains
 
 public fun AnyRow.containsKey(columnName: String): Boolean = owner.containsColumn(columnName)
-public fun AnyRow.containsKey(column: Column): Boolean = owner.containsColumn(column)
+public fun AnyRow.containsKey(column: AnyColumnReference): Boolean = owner.containsColumn(column)
 public fun AnyRow.containsKey(column: KProperty<*>): Boolean = owner.containsColumn(column)
 
-public operator fun AnyRow.contains(column: Column): Boolean = containsKey(column)
+public operator fun AnyRow.contains(column: AnyColumnReference): Boolean = containsKey(column)
 public operator fun AnyRow.contains(column: KProperty<*>): Boolean = containsKey(column)
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index f9b87caaa..3b8a9c8f6 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -1,9 +1,9 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.AnyFrame
 import org.jetbrains.kotlinx.dataframe.AnyRow
-import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -20,7 +20,7 @@ import kotlin.reflect.KProperty
 
 /**
  * Replace `null` values with given value or expression.
- * Specific case of [UpdateOperation].
+ * Specific case of [Update].
  * TODO samples
  *
  * @include [DocumentationUrls.Fill.FillNulls]
@@ -160,10 +160,13 @@ public fun <T> DataFrame<T>.dropNulls(vararg columns: KProperty<*>, whereAllNull
 public fun <T> DataFrame<T>.dropNulls(vararg columns: String, whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNulls(vararg columns: Column, whereAllNull: Boolean = false): DataFrame<T> =
+public fun <T> DataFrame<T>.dropNulls(vararg columns: AnyColumnReference, whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNulls(columns: Iterable<Column>, whereAllNull: Boolean = false): DataFrame<T> =
+public fun <T> DataFrame<T>.dropNulls(
+    columns: Iterable<AnyColumnReference>,
+    whereAllNull: Boolean = false
+): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumnSet() }
 
 public fun <T> DataColumn<T?>.dropNulls(): DataColumn<T> =
@@ -186,10 +189,10 @@ public fun <T> DataFrame<T>.dropNA(vararg columns: KProperty<*>, whereAllNA: Boo
 public fun <T> DataFrame<T>.dropNA(vararg columns: String, whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNA(vararg columns: Column, whereAllNA: Boolean = false): DataFrame<T> =
+public fun <T> DataFrame<T>.dropNA(vararg columns: AnyColumnReference, whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNA(columns: Iterable<Column>, whereAllNA: Boolean = false): DataFrame<T> =
+public fun <T> DataFrame<T>.dropNA(columns: Iterable<AnyColumnReference>, whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { columns.toColumnSet() }
 
 public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false): DataFrame<T> =
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
index 513840c08..4b045a455 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
@@ -3,9 +3,9 @@ package org.jetbrains.kotlinx.dataframe.api
 import org.jetbrains.kotlinx.dataframe.AnyBaseCol
 import org.jetbrains.kotlinx.dataframe.AnyCol
 import org.jetbrains.kotlinx.dataframe.AnyColumnGroupAccessor
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.AnyFrame
 import org.jetbrains.kotlinx.dataframe.AnyRow
-import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsContainer
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -50,7 +50,8 @@ public fun <T> DataFrame<T>.add(vararg columns: AnyBaseCol): DataFrame<T> = addA
  * @throws [UnequalColumnSizesException] if columns in expected result have different sizes
  * @return new [DataFrame] with added columns
  */
-public fun <T> DataFrame<T>.addAll(columns: Iterable<AnyBaseCol>): DataFrame<T> = dataFrameOf(columns() + columns).cast()
+public fun <T> DataFrame<T>.addAll(columns: Iterable<AnyBaseCol>): DataFrame<T> =
+    dataFrameOf(columns() + columns).cast()
 
 /**
  * Creates new [DataFrame] with all columns from given [dataFrames] added to the end of original [DataFrame.columns] list.
@@ -75,7 +76,8 @@ public fun <T> DataFrame<T>.add(vararg dataFrames: AnyFrame): DataFrame<T> = add
  * @return new [DataFrame] with added columns
  */
 @JvmName("addAllFrames")
-public fun <T> DataFrame<T>.addAll(dataFrames: Iterable<AnyFrame>): DataFrame<T> = addAll(dataFrames.flatMap { it.columns() })
+public fun <T> DataFrame<T>.addAll(dataFrames: Iterable<AnyFrame>): DataFrame<T> =
+    addAll(dataFrames.flatMap { it.columns() })
 
 // endregion
 
@@ -149,9 +151,9 @@ public class AddDsl<T>(@PublishedApi internal val df: DataFrame<T>) : ColumnsCon
     // TODO: support adding column into path
     internal val columns = mutableListOf<AnyCol>()
 
-    public fun add(column: Column): Boolean = columns.add(column.resolveSingle(df)!!.data)
+    public fun add(column: AnyColumnReference): Boolean = columns.add(column.resolveSingle(df)!!.data)
 
-    public operator fun Column.unaryPlus(): Boolean = add(this)
+    public operator fun AnyColumnReference.unaryPlus(): Boolean = add(this)
 
     public operator fun String.unaryPlus(): Boolean = add(df[this])
 
@@ -166,17 +168,21 @@ public class AddDsl<T>(@PublishedApi internal val df: DataFrame<T>) : ColumnsCon
         return df.mapToColumn("", Infer.Nulls, expression)
     }
 
-    public inline infix fun <reified R> String.from(noinline expression: RowExpression<T, R>): Boolean = add(this, Infer.Nulls, expression)
+    public inline infix fun <reified R> String.from(noinline expression: RowExpression<T, R>): Boolean =
+        add(this, Infer.Nulls, expression)
 
     // TODO: use path instead of name
-    public inline infix fun <reified R> ColumnAccessor<R>.from(noinline expression: RowExpression<T, R>): Boolean = name().from(expression)
-    public inline infix fun <reified R> KProperty<R>.from(noinline expression: RowExpression<T, R>): Boolean = add(name, Infer.Nulls, expression)
+    public inline infix fun <reified R> ColumnAccessor<R>.from(noinline expression: RowExpression<T, R>): Boolean =
+        name().from(expression)
 
-    public infix fun String.from(column: Column): Boolean = add(column.rename(this))
+    public inline infix fun <reified R> KProperty<R>.from(noinline expression: RowExpression<T, R>): Boolean =
+        add(name, Infer.Nulls, expression)
+
+    public infix fun String.from(column: AnyColumnReference): Boolean = add(column.rename(this))
     public inline infix fun <reified R> ColumnAccessor<R>.from(column: ColumnReference<R>): Boolean = name() from column
     public inline infix fun <reified R> KProperty<R>.from(column: ColumnReference<R>): Boolean = name from column
 
-    public infix fun Column.into(name: String): Boolean = add(rename(name))
+    public infix fun AnyColumnReference.into(name: String): Boolean = add(rename(name))
     public infix fun <R> ColumnReference<R>.into(column: ColumnAccessor<R>): Boolean = into(column.name())
     public infix fun <R> ColumnReference<R>.into(column: KProperty<R>): Boolean = into(column.name)
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
index 37cfdb6c9..cc4b04301 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.AnyFrame
-import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
@@ -19,6 +19,7 @@ public fun <T, C> DataFrame<T>.countDistinct(columns: ColumnsSelector<T, C>): In
 
 public fun <T> DataFrame<T>.countDistinct(vararg columns: String): Int = countDistinct { columns.toColumns() }
 public fun <T, C> DataFrame<T>.countDistinct(vararg columns: KProperty<C>): Int = countDistinct { columns.toColumns() }
-public fun <T> DataFrame<T>.countDistinct(vararg columns: Column): Int = countDistinct { columns.toColumns() }
+public fun <T> DataFrame<T>.countDistinct(vararg columns: AnyColumnReference): Int =
+    countDistinct { columns.toColumns() }
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt
index be60508cd..f67760cf3 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -38,7 +38,7 @@ private val supportedClasses = setOf(Double::class, Float::class, Int::class, Lo
 public fun <T, C> DataFrame<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA, columns: ColumnsSelector<T, C>): DataFrame<T> =
     convert(columns).to { if (it.typeClass in supportedClasses) it.cast<Number?>().cumSum(skipNA) else it }
 public fun <T> DataFrame<T>.cumSum(vararg columns: String, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) { columns.toColumns() }
-public fun <T> DataFrame<T>.cumSum(vararg columns: Column, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) { columns.toColumns() }
+public fun <T> DataFrame<T>.cumSum(vararg columns: AnyColumnReference, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) { columns.toColumns() }
 public fun <T> DataFrame<T>.cumSum(vararg columns: KProperty<*>, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) { columns.toColumns() }
 
 public fun <T> DataFrame<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) { allDfs() }
@@ -50,7 +50,7 @@ public fun <T> DataFrame<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataF
 public fun <T, G, C> GroupBy<T, G>.cumSum(skipNA: Boolean = defaultCumSumSkipNA, columns: ColumnsSelector<G, C>): GroupBy<T, G> =
     updateGroups { cumSum(skipNA, columns) }
 public fun <T, G> GroupBy<T, G>.cumSum(vararg columns: String, skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> = cumSum(skipNA) { columns.toColumns() }
-public fun <T, G> GroupBy<T, G>.cumSum(vararg columns: Column, skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> = cumSum(skipNA) { columns.toColumns() }
+public fun <T, G> GroupBy<T, G>.cumSum(vararg columns: AnyColumnReference, skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> = cumSum(skipNA) { columns.toColumns() }
 public fun <T, G> GroupBy<T, G>.cumSum(vararg columns: KProperty<*>, skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> = cumSum(skipNA) { columns.toColumns() }
 public fun <T, G> GroupBy<T, G>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> = cumSum(skipNA) { allDfs() }
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt
index c0c072c33..7c72af4e6 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
@@ -18,19 +18,19 @@ public fun <T> DataFrame<T>.distinct(vararg columns: KProperty<*>): DataFrame<T>
     set
 }
 public fun <T> DataFrame<T>.distinct(vararg columns: String): DataFrame<T> = distinct { columns.toColumns() }
-public fun <T> DataFrame<T>.distinct(vararg columns: Column): DataFrame<T> = distinct { columns.toColumns() }
+public fun <T> DataFrame<T>.distinct(vararg columns: AnyColumnReference): DataFrame<T> = distinct { columns.toColumns() }
 
 @JvmName("distinctT")
 public fun <T> DataFrame<T>.distinct(columns: Iterable<String>): DataFrame<T> = distinct { columns.toColumns() }
-public fun <T> DataFrame<T>.distinct(columns: Iterable<Column>): DataFrame<T> = distinct { columns.toColumnSet() }
+public fun <T> DataFrame<T>.distinct(columns: Iterable<AnyColumnReference>): DataFrame<T> = distinct { columns.toColumnSet() }
 
 public fun <T> DataFrame<T>.distinctBy(vararg columns: KProperty<*>): DataFrame<T> = distinctBy { columns.toColumns() }
 public fun <T> DataFrame<T>.distinctBy(vararg columns: String): DataFrame<T> = distinctBy { columns.toColumns() }
-public fun <T> DataFrame<T>.distinctBy(vararg columns: Column): DataFrame<T> = distinctBy { columns.toColumns() }
+public fun <T> DataFrame<T>.distinctBy(vararg columns: AnyColumnReference): DataFrame<T> = distinctBy { columns.toColumns() }
 
 @JvmName("distinctByT")
 public fun <T> DataFrame<T>.distinctBy(columns: Iterable<String>): DataFrame<T> = distinctBy { columns.toColumns() }
-public fun <T> DataFrame<T>.distinctBy(columns: Iterable<Column>): DataFrame<T> = distinctBy { columns.toColumnSet() }
+public fun <T> DataFrame<T>.distinctBy(columns: Iterable<AnyColumnReference>): DataFrame<T> = distinctBy { columns.toColumnSet() }
 
 public fun <T, C> DataFrame<T>.distinctBy(columns: ColumnsSelector<T, C>): DataFrame<T> {
     val cols = get(columns)
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt
index 2c75681d3..c83f2db3f 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyColumnGroupAccessor
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
@@ -16,7 +16,7 @@ public data class GroupClause<T, C>(val df: DataFrame<T>, val columns: ColumnsSe
 
 public fun <T, C> DataFrame<T>.group(columns: ColumnsSelector<T, C>): GroupClause<T, C> = GroupClause(this, columns)
 public fun <T> DataFrame<T>.group(vararg columns: String): GroupClause<T, Any?> = group { columns.toColumns() }
-public fun <T> DataFrame<T>.group(vararg columns: Column): GroupClause<T, Any?> = group { columns.toColumns() }
+public fun <T> DataFrame<T>.group(vararg columns: AnyColumnReference): GroupClause<T, Any?> = group { columns.toColumns() }
 public fun <T> DataFrame<T>.group(vararg columns: KProperty<*>): GroupClause<T, Any?> = group { columns.toColumns() }
 
 @JvmName("intoString")
@@ -25,7 +25,7 @@ public fun <T> DataFrame<T>.group(vararg columns: KProperty<*>): GroupClause<T,
 public infix fun <T, C> GroupClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> String): DataFrame<T> = df.move(columns).under { column(it).toColumnAccessor() }
 
 @JvmName("intoColumn")
-public infix fun <T, C> GroupClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> Column): DataFrame<T> = df.move(columns).under(column)
+public infix fun <T, C> GroupClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> AnyColumnReference): DataFrame<T> = df.move(columns).under(column)
 public infix fun <T, C> GroupClause<T, C>.into(column: String): DataFrame<T> = into(columnGroup().named(column))
 public infix fun <T, C> GroupClause<T, C>.into(column: AnyColumnGroupAccessor): DataFrame<T> = df.move(columns).under(column)
 public infix fun <T, C> GroupClause<T, C>.into(column: KProperty<*>): DataFrame<T> = into(column.columnName)
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
index e5f8032be..8796681dd 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.AnyFrame
-import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
@@ -18,18 +18,23 @@ import kotlin.reflect.KProperty
 
 // region DataFrame
 
-public fun <T> DataFrame<T>.groupBy(moveToTop: Boolean = true, cols: ColumnsSelector<T, *>): GroupBy<T, T> = groupByImpl(moveToTop, cols)
-public fun <T> DataFrame<T>.groupBy(cols: Iterable<Column>): GroupBy<T, T> = groupBy { cols.toColumnSet() }
+public fun <T> DataFrame<T>.groupBy(moveToTop: Boolean = true, cols: ColumnsSelector<T, *>): GroupBy<T, T> =
+    groupByImpl(moveToTop, cols)
+
+public fun <T> DataFrame<T>.groupBy(cols: Iterable<AnyColumnReference>): GroupBy<T, T> = groupBy { cols.toColumnSet() }
 public fun <T> DataFrame<T>.groupBy(vararg cols: KProperty<*>): GroupBy<T, T> = groupBy { cols.toColumns() }
 public fun <T> DataFrame<T>.groupBy(vararg cols: String): GroupBy<T, T> = groupBy { cols.toColumns() }
-public fun <T> DataFrame<T>.groupBy(vararg cols: Column, moveToTop: Boolean = true): GroupBy<T, T> = groupBy(moveToTop) { cols.toColumns() }
+public fun <T> DataFrame<T>.groupBy(vararg cols: AnyColumnReference, moveToTop: Boolean = true): GroupBy<T, T> =
+    groupBy(moveToTop) { cols.toColumns() }
 
 // endregion
 
 // region Pivot
 
-public fun <T> Pivot<T>.groupBy(moveToTop: Boolean = true, columns: ColumnsSelector<T, *>): PivotGroupBy<T> = (this as PivotImpl<T>).toGroupedPivot(moveToTop, columns)
-public fun <T> Pivot<T>.groupBy(vararg columns: Column): PivotGroupBy<T> = groupBy { columns.toColumns() }
+public fun <T> Pivot<T>.groupBy(moveToTop: Boolean = true, columns: ColumnsSelector<T, *>): PivotGroupBy<T> =
+    (this as PivotImpl<T>).toGroupedPivot(moveToTop, columns)
+
+public fun <T> Pivot<T>.groupBy(vararg columns: AnyColumnReference): PivotGroupBy<T> = groupBy { columns.toColumns() }
 public fun <T> Pivot<T>.groupBy(vararg columns: String): PivotGroupBy<T> = groupBy { columns.toColumns() }
 public fun <T> Pivot<T>.groupBy(vararg columns: KProperty<*>): PivotGroupBy<T> = groupBy { columns.toColumns() }
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
index 5a01944c5..90ec36cf3 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyColumnGroupAccessor
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnSelector
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -21,20 +21,20 @@ public fun <T, C> DataFrame<T>.move(vararg cols: KProperty<C>): MoveClause<T, C>
 
 public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, columns: ColumnsSelector<T, *>): DataFrame<T> = move(columns).to(newColumnIndex)
 public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, vararg columns: String): DataFrame<T> = moveTo(newColumnIndex) { columns.toColumns() }
-public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, vararg columns: Column): DataFrame<T> = moveTo(newColumnIndex) { columns.toColumns() }
+public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, vararg columns: AnyColumnReference): DataFrame<T> = moveTo(newColumnIndex) { columns.toColumns() }
 public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, vararg columns: KProperty<*>): DataFrame<T> = moveTo(newColumnIndex) { columns.toColumns() }
 
 public fun <T> DataFrame<T>.moveToLeft(columns: ColumnsSelector<T, *>): DataFrame<T> = move(columns).toLeft()
 public fun <T> DataFrame<T>.moveToLeft(vararg columns: String): DataFrame<T> = moveToLeft { columns.toColumns() }
-public fun <T> DataFrame<T>.moveToLeft(vararg columns: Column): DataFrame<T> = moveToLeft { columns.toColumns() }
+public fun <T> DataFrame<T>.moveToLeft(vararg columns: AnyColumnReference): DataFrame<T> = moveToLeft { columns.toColumns() }
 public fun <T> DataFrame<T>.moveToLeft(vararg columns: KProperty<*>): DataFrame<T> = moveToLeft { columns.toColumns() }
 
 public fun <T> DataFrame<T>.moveToRight(columns: ColumnsSelector<T, *>): DataFrame<T> = move(columns).toRight()
 public fun <T> DataFrame<T>.moveToRight(vararg columns: String): DataFrame<T> = moveToRight { columns.toColumns() }
-public fun <T> DataFrame<T>.moveToRight(vararg columns: Column): DataFrame<T> = moveToRight { columns.toColumns() }
+public fun <T> DataFrame<T>.moveToRight(vararg columns: AnyColumnReference): DataFrame<T> = moveToRight { columns.toColumns() }
 public fun <T> DataFrame<T>.moveToRight(vararg columns: KProperty<*>): DataFrame<T> = moveToRight { columns.toColumns() }
 
-public fun <T, C> MoveClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> Column): DataFrame<T> = moveImpl(
+public fun <T, C> MoveClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> AnyColumnReference): DataFrame<T> = moveImpl(
     under = false,
     column
 )
@@ -42,7 +42,7 @@ public fun <T, C> MoveClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWi
 public fun <T, C> MoveClause<T, C>.into(column: String): DataFrame<T> = pathOf(column).let { path -> into { path } }
 
 public fun <T, C> MoveClause<T, C>.intoIndexed(
-    newPathExpression: ColumnsSelectionDsl<T>.(ColumnWithPath<C>, Int) -> Column
+    newPathExpression: ColumnsSelectionDsl<T>.(ColumnWithPath<C>, Int) -> AnyColumnReference
 ): DataFrame<T> {
     var counter = 0
     return into { col ->
@@ -52,7 +52,7 @@ public fun <T, C> MoveClause<T, C>.intoIndexed(
 
 public fun <T, C> MoveClause<T, C>.under(column: String): DataFrame<T> = pathOf(column).let { path -> under { path } }
 public fun <T, C> MoveClause<T, C>.under(column: AnyColumnGroupAccessor): DataFrame<T> = column.path().let { path -> under { path } }
-public fun <T, C> MoveClause<T, C>.under(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> Column): DataFrame<T> = moveImpl(
+public fun <T, C> MoveClause<T, C>.under(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> AnyColumnReference): DataFrame<T> = moveImpl(
     under = true,
     column
 )
@@ -66,7 +66,7 @@ public fun <T, C> MoveClause<T, C>.toTop(
 
 public fun <T, C> MoveClause<T, C>.after(column: ColumnSelector<T, *>): DataFrame<T> = afterOrBefore(column, true)
 public fun <T, C> MoveClause<T, C>.after(column: String): DataFrame<T> = after { column.toColumnAccessor() }
-public fun <T, C> MoveClause<T, C>.after(column: Column): DataFrame<T> = after { column }
+public fun <T, C> MoveClause<T, C>.after(column: AnyColumnReference): DataFrame<T> = after { column }
 public fun <T, C> MoveClause<T, C>.after(column: KProperty<*>): DataFrame<T> = after { column.toColumnAccessor() }
 
 // TODO: implement 'before'
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
index c4023430c..ed99ff907 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
@@ -41,17 +41,17 @@ public interface PivotDsl<out T> : ColumnsSelectionDsl<T> {
 
 public fun <T> DataFrame<T>.pivot(inward: Boolean? = null, columns: PivotColumnsSelector<T, *>): Pivot<T> = PivotImpl(this, columns, inward)
 public fun <T> DataFrame<T>.pivot(vararg columns: String, inward: Boolean? = null): Pivot<T> = pivot(inward) { columns.toColumns() }
-public fun <T> DataFrame<T>.pivot(vararg columns: Column, inward: Boolean? = null): Pivot<T> = pivot(inward) { columns.toColumns() }
+public fun <T> DataFrame<T>.pivot(vararg columns: AnyColumnReference, inward: Boolean? = null): Pivot<T> = pivot(inward) { columns.toColumns() }
 public fun <T> DataFrame<T>.pivot(vararg columns: KProperty<*>, inward: Boolean? = null): Pivot<T> = pivot(inward) { columns.toColumns() }
 
 public fun <T> DataFrame<T>.pivotMatches(inward: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T> = pivot(inward, columns).groupByOther().matches()
 public fun <T> DataFrame<T>.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
-public fun <T> DataFrame<T>.pivotMatches(vararg columns: Column, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
+public fun <T> DataFrame<T>.pivotMatches(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
 public fun <T> DataFrame<T>.pivotMatches(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
 
 public fun <T> DataFrame<T>.pivotCounts(inward: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T> = pivot(inward, columns).groupByOther().count()
 public fun <T> DataFrame<T>.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
-public fun <T> DataFrame<T>.pivotCounts(vararg columns: Column, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
+public fun <T> DataFrame<T>.pivotCounts(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
 public fun <T> DataFrame<T>.pivotCounts(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
 
 // endregion
@@ -59,18 +59,18 @@ public fun <T> DataFrame<T>.pivotCounts(vararg columns: KProperty<*>, inward: Bo
 // region GroupBy
 
 public fun <G> GroupBy<*, G>.pivot(inward: Boolean = true, columns: ColumnsSelector<G, *>): PivotGroupBy<G> = PivotGroupByImpl(this, columns, inward)
-public fun <G> GroupBy<*, G>.pivot(vararg columns: Column, inward: Boolean = true): PivotGroupBy<G> = pivot(inward) { columns.toColumns() }
+public fun <G> GroupBy<*, G>.pivot(vararg columns: AnyColumnReference, inward: Boolean = true): PivotGroupBy<G> = pivot(inward) { columns.toColumns() }
 public fun <G> GroupBy<*, G>.pivot(vararg columns: String, inward: Boolean = true): PivotGroupBy<G> = pivot(inward) { columns.toColumns() }
 public fun <G> GroupBy<*, G>.pivot(vararg columns: KProperty<*>, inward: Boolean = true): PivotGroupBy<G> = pivot(inward) { columns.toColumns() }
 
 public fun <G> GroupBy<*, G>.pivotMatches(inward: Boolean = true, columns: ColumnsSelector<G, *>): DataFrame<G> = pivot(inward, columns).matches()
 public fun <G> GroupBy<*, G>.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame<G> = pivotMatches(inward) { columns.toColumns() }
-public fun <G> GroupBy<*, G>.pivotMatches(vararg columns: Column, inward: Boolean = true): DataFrame<G> = pivotMatches(inward) { columns.toColumns() }
+public fun <G> GroupBy<*, G>.pivotMatches(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<G> = pivotMatches(inward) { columns.toColumns() }
 public fun <G> GroupBy<*, G>.pivotMatches(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<G> = pivotMatches(inward) { columns.toColumns() }
 
 public fun <G> GroupBy<*, G>.pivotCounts(inward: Boolean = true, columns: ColumnsSelector<G, *>): DataFrame<G> = pivot(inward, columns).count()
 public fun <G> GroupBy<*, G>.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame<G> = pivotCounts(inward) { columns.toColumns() }
-public fun <G> GroupBy<*, G>.pivotCounts(vararg columns: Column, inward: Boolean = true): DataFrame<G> = pivotCounts(inward) { columns.toColumns() }
+public fun <G> GroupBy<*, G>.pivotCounts(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<G> = pivotCounts(inward) { columns.toColumns() }
 public fun <G> GroupBy<*, G>.pivotCounts(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<G> = pivotCounts(inward) { columns.toColumns() }
 
 // endregion
@@ -80,17 +80,17 @@ public fun <G> GroupBy<*, G>.pivotCounts(vararg columns: KProperty<*>, inward: B
 public fun <T> AggregateGroupedDsl<T>.pivot(inward: Boolean = true, columns: ColumnsSelector<T, *>): PivotGroupBy<T> =
     PivotInAggregateImpl(this, columns, inward)
 public fun <T> AggregateGroupedDsl<T>.pivot(vararg columns: String, inward: Boolean = true): PivotGroupBy<T> = pivot(inward) { columns.toColumns() }
-public fun <T> AggregateGroupedDsl<T>.pivot(vararg columns: Column, inward: Boolean = true): PivotGroupBy<T> = pivot(inward) { columns.toColumns() }
+public fun <T> AggregateGroupedDsl<T>.pivot(vararg columns: AnyColumnReference, inward: Boolean = true): PivotGroupBy<T> = pivot(inward) { columns.toColumns() }
 public fun <T> AggregateGroupedDsl<T>.pivot(vararg columns: KProperty<*>, inward: Boolean = true): PivotGroupBy<T> = pivot(inward) { columns.toColumns() }
 
 public fun <T> AggregateGroupedDsl<T>.pivotMatches(inward: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T> = pivot(inward, columns).matches()
 public fun <T> AggregateGroupedDsl<T>.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
-public fun <T> AggregateGroupedDsl<T>.pivotMatches(vararg columns: Column, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
+public fun <T> AggregateGroupedDsl<T>.pivotMatches(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
 public fun <T> AggregateGroupedDsl<T>.pivotMatches(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
 
 public fun <T> AggregateGroupedDsl<T>.pivotCounts(inward: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T> = pivot(inward, columns).matches()
 public fun <T> AggregateGroupedDsl<T>.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
-public fun <T> AggregateGroupedDsl<T>.pivotCounts(vararg columns: Column, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
+public fun <T> AggregateGroupedDsl<T>.pivotCounts(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
 public fun <T> AggregateGroupedDsl<T>.pivotCounts(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt
index b252b7ed0..85226f1c3 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.impl.api.removeImpl
@@ -13,12 +13,12 @@ import kotlin.reflect.KProperty
 public fun <T> DataFrame<T>.remove(columns: ColumnsSelector<T, *>): DataFrame<T> = removeImpl(allowMissingColumns = true, columns = columns).df
 public fun <T> DataFrame<T>.remove(vararg columns: KProperty<*>): DataFrame<T> = remove { columns.toColumns() }
 public fun <T> DataFrame<T>.remove(vararg columns: String): DataFrame<T> = remove { columns.toColumns() }
-public fun <T> DataFrame<T>.remove(vararg columns: Column): DataFrame<T> = remove { columns.toColumns() }
-public fun <T> DataFrame<T>.remove(columns: Iterable<Column>): DataFrame<T> = remove { columns.toColumnSet() }
+public fun <T> DataFrame<T>.remove(vararg columns: AnyColumnReference): DataFrame<T> = remove { columns.toColumns() }
+public fun <T> DataFrame<T>.remove(columns: Iterable<AnyColumnReference>): DataFrame<T> = remove { columns.toColumnSet() }
 
 public infix operator fun <T> DataFrame<T>.minus(columns: ColumnsSelector<T, *>): DataFrame<T> = remove(columns)
 public infix operator fun <T> DataFrame<T>.minus(column: String): DataFrame<T> = remove(column)
-public infix operator fun <T> DataFrame<T>.minus(column: Column): DataFrame<T> = remove(column)
-public infix operator fun <T> DataFrame<T>.minus(columns: Iterable<Column>): DataFrame<T> = remove(columns)
+public infix operator fun <T> DataFrame<T>.minus(column: AnyColumnReference): DataFrame<T> = remove(column)
+public infix operator fun <T> DataFrame<T>.minus(columns: Iterable<AnyColumnReference>): DataFrame<T> = remove(columns)
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt
index 5f9b8a8bb..4a91e748f 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.impl.columnName
@@ -10,12 +10,28 @@ import kotlin.reflect.KProperty
 
 // region DataFrame
 
-public fun <T> DataFrame<T>.select(columns: ColumnsSelector<T, *>): DataFrame<T> = get(columns).toDataFrame().cast()
-public fun <T> DataFrame<T>.select(vararg columns: KProperty<*>): DataFrame<T> = select(columns.map { it.columnName })
-public fun <T> DataFrame<T>.select(vararg columns: String): DataFrame<T> = select(columns.asIterable())
-public fun <T> DataFrame<T>.select(vararg columns: Column): DataFrame<T> = select { columns.toColumns() }
-@JvmName("selectT")
-public fun <T> DataFrame<T>.select(columns: Iterable<String>): DataFrame<T> = columns.map { get(it) }.toDataFrame().cast()
-public fun <T> DataFrame<T>.select(columns: Iterable<Column>): DataFrame<T> = select { columns.toColumnSet() }
+public fun <T> DataFrame<T>.select(columns: ColumnsSelector<T, *>): DataFrame<T> =
+    get(columns).toDataFrame().cast()
+
+public fun <T> DataFrame<T>.select(vararg columns: KProperty<*>): DataFrame<T> =
+    select(columns.asIterable())
+
+@JvmName("selectKPropertyIterable")
+public fun <T> DataFrame<T>.select(columns: Iterable<KProperty<*>>): DataFrame<T> =
+    select(columns.map { it.columnName })
+
+public fun <T> DataFrame<T>.select(vararg columns: String): DataFrame<T> =
+    select(columns.asIterable())
+
+@JvmName("selectStringIterable")
+public fun <T> DataFrame<T>.select(columns: Iterable<String>): DataFrame<T> =
+    columns.map { get(it) }.toDataFrame().cast()
+
+public fun <T> DataFrame<T>.select(vararg columns: AnyColumnReference): DataFrame<T> =
+    select { columns.toColumns() }
+
+@JvmName("selectAnyColumnReferenceIterable")
+public fun <T> DataFrame<T>.select(columns: Iterable<AnyColumnReference>): DataFrame<T> =
+    select { columns.toColumnSet() }
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
index 6c79cf73a..89d7581a2 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
@@ -1,8 +1,8 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.AnyFrame
-import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -23,7 +23,8 @@ public inline fun <reified T> Iterable<T>.toDataFrame(): DataFrame<T> = toDataFr
     properties()
 }
 
-public inline fun <reified T> Iterable<T>.toDataFrame(noinline body: CreateDataFrameDsl<T>.() -> Unit): DataFrame<T> = createDataFrameImpl(T::class, body)
+public inline fun <reified T> Iterable<T>.toDataFrame(noinline body: CreateDataFrameDsl<T>.() -> Unit): DataFrame<T> =
+    createDataFrameImpl(T::class, body)
 
 public inline fun <reified T> Iterable<T>.toDataFrame(vararg props: KProperty<*>, maxDepth: Int = 0): DataFrame<T> =
     toDataFrame {
@@ -40,7 +41,7 @@ public fun <T> DataFrame<T>.read(vararg columns: String): DataFrame<T> = unfold(
 public fun <T> DataFrame<T>.read(vararg columns: KProperty<*>): DataFrame<T> = unfold(*columns)
 
 @Deprecated("Replaced with `unfold` operation.", ReplaceWith("this.unfold(*columns)"), DeprecationLevel.ERROR)
-public fun <T> DataFrame<T>.read(vararg columns: Column): DataFrame<T> = unfold(*columns)
+public fun <T> DataFrame<T>.read(vararg columns: AnyColumnReference): DataFrame<T> = unfold(*columns)
 
 @JvmName("toDataFrameT")
 public fun <T> Iterable<DataRow<T>>.toDataFrame(): DataFrame<T> {
@@ -76,6 +77,7 @@ public fun <T> Iterable<Pair<ColumnPath, AnyBaseCol>>.toDataFrameFromPairs(): Da
         when (path.size) {
             0 -> {
             }
+
             1 -> {
                 val name = path[0]
                 val uniqueName = nameGenerator.addUnique(name)
@@ -85,6 +87,7 @@ public fun <T> Iterable<Pair<ColumnPath, AnyBaseCol>>.toDataFrameFromPairs(): Da
                 columns.add(col.rename(uniqueName))
                 columnIndices[uniqueName] = index
             }
+
             else -> {
                 val name = path[0]
                 val uniqueName = columnGroupName.getOrPut(name) {
@@ -195,7 +198,12 @@ public fun Map<String, Iterable<Any?>>.toDataFrame(): AnyFrame {
 
 @JvmName("toDataFrameColumnPathAnyNullable")
 public fun Map<ColumnPath, Iterable<Any?>>.toDataFrame(): AnyFrame {
-    return map { it.key to DataColumn.createWithTypeInference(it.key.last(), it.value.asList()) }.toDataFrameFromPairs<Unit>()
+    return map {
+        it.key to DataColumn.createWithTypeInference(
+            it.key.last(),
+            it.value.asList()
+        )
+    }.toDataFrameFromPairs<Unit>()
 }
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/unfold.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/unfold.kt
index 54f59bf95..1ad347213 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/unfold.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/unfold.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyCol
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -25,4 +25,4 @@ public inline fun <reified T> DataColumn<T>.unfold(): AnyCol =
 public fun <T> DataFrame<T>.unfold(columns: ColumnsSelector<T, *>): DataFrame<T> = replace(columns).with { it.unfold() }
 public fun <T> DataFrame<T>.unfold(vararg columns: String): DataFrame<T> = unfold { columns.toColumns() }
 public fun <T> DataFrame<T>.unfold(vararg columns: KProperty<*>): DataFrame<T> = unfold { columns.toColumns() }
-public fun <T> DataFrame<T>.unfold(vararg columns: Column): DataFrame<T> = unfold { columns.toColumns() }
+public fun <T> DataFrame<T>.unfold(vararg columns: AnyColumnReference): DataFrame<T> = unfold { columns.toColumns() }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt
index 65e0f820c..7633687ba 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
@@ -15,7 +15,7 @@ public fun <T, C> DataFrame<T>.ungroup(columns: ColumnsSelector<T, C>): DataFram
 }
 
 public fun <T> DataFrame<T>.ungroup(vararg columns: String): DataFrame<T> = ungroup { columns.toColumns() }
-public fun <T> DataFrame<T>.ungroup(vararg columns: Column): DataFrame<T> = ungroup { columns.toColumns() }
+public fun <T> DataFrame<T>.ungroup(vararg columns: AnyColumnReference): DataFrame<T> = ungroup { columns.toColumns() }
 public fun <T> DataFrame<T>.ungroup(vararg columns: KProperty<*>): DataFrame<T> = ungroup { columns.toColumns() }
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index 651f9a3d9..53302c2ed 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -17,6 +17,7 @@ import org.jetbrains.kotlinx.dataframe.impl.api.updateWithValuePerColumnImpl
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
 import org.jetbrains.kotlinx.dataframe.impl.headPlusArray
+import org.jetbrains.kotlinx.dataframe.documentation.*
 import org.jetbrains.kotlinx.dataframe.index
 import kotlin.reflect.KProperty
 
@@ -25,49 +26,57 @@ import kotlin.reflect.KProperty
  *
  * Column types can not be changed.
  *
- * Usage:
+ * Update operation usage:
  *
- * [update] { columns }
+ * [update] { [columns][Update.Columns] }
  *
- *   [.[where] { [rowCondition][UpdateOperation.Where.Predicate] } ]
+ *   [.[where] { [rowCondition][Update.Where.Predicate] } ]
  *
- *   [.[at] ([rowIndices][UpdateOperation.At.RowIndices]) ]
+ *   [.[at] ([rowIndices][Update.At.RowIndices]) ]
  *
- *   .[with][Update.with] { [rowExpression][UpdateOperation.With.Expression] } | .[notNull] { rowExpression } | .[perCol] { colExpression } | .[perRowCol] { rowColExpression } | .[withValue] (value) | .[withNull] () | .[withZero] () | .[asFrame] { frameExpression }
+ *   .[with][Update.with] { [rowExpression][Update.With.Expression] } | .[notNull] { rowExpression } | .[perCol] { colExpression } | .[perRowCol] { rowColExpression } | .[withValue] (value) | .[withNull] () | .[withZero] () | .[asFrame] { frameExpression }
  *
- * @comment TODO
+ * {@comment TODO
  * rowExpression: DataRow.(OldValue) -> NewValue
  * colExpression: DataColumn.(DataColumn) -> NewValue
  * rowColExpression: DataRow.(DataColumn) -> NewValue
- * frameExpression: DataFrame.(DataFrame) -> DataFrame
- *
+ * frameExpression: DataFrame.(DataFrame) -> DataFrame}
  */
-internal interface UpdateOperation {
+public data class Update<T, C>(
+    val df: DataFrame<T>,
+    val filter: RowValueFilter<T, C>?,
+    val columns: ColumnsSelector<T, C>,
+) {
+    public fun <R : C> cast(): Update<T, R> =
+        Update(df, filter as RowValueFilter<T, R>?, columns as ColumnsSelector<T, R>)
+
+    /** Select the columns to update. See {@include [SelectingColumnsLink]}. */
+    internal interface Columns
 
     /** @param columns The [ColumnsSelector] used to select the columns of this [DataFrame] to update. */
-    interface ColumnsSelectorParam
+    internal interface ColumnsSelectorParam
 
     /** @param columns An [Iterable] of [ColumnReference]s of this [DataFrame] to update. */
-    interface ColumnReferenceIterableParam
+    internal interface ColumnReferenceIterableParam
 
     /** @param columns The [ColumnReference]s of this [DataFrame] to update. */
-    interface ColumnReferencesParam
+    internal interface ColumnReferencesParam
 
     /** @param columns The [KProperty] values corresponding to columns of this [DataFrame] to update. */
-    interface KPropertyColumnsParam
+    internal interface KPropertyColumnsParam
 
     /** @param columns The column names belonging to this [DataFrame] to update. */
-    interface StringColumnsParam
+    internal interface StringColumnsParam
 
     /**
-     * Only update the columns that pass a certain [predicate][UpdateOperation.Where.Predicate].
+     * Only update the columns that pass a certain [predicate][Update.Where.Predicate].
      *
      * For example:
      * ```kotlin
      * df.update { city }.where { name.firstName == "Alice" }.withValue("Paris")
      * ```
      */
-    interface Where {
+    internal interface Where {
 
         /** The condition for rows to be included. A filter if you will.
          *
@@ -76,7 +85,7 @@ internal interface UpdateOperation {
     }
 
     /**
-     * Only update the columns at certain given [row indices][UpdateOperation.At.RowIndices]:
+     * Only update the columns at certain given [row indices][Update.At.RowIndices]:
      *
      * Either a [Collection]<[Int]>, an [IntRange], or just `vararg` indices.
      *
@@ -85,7 +94,7 @@ internal interface UpdateOperation {
      * df.update { city }.at(5..10).withValue("Paris")
      * ```
      */
-    interface At {
+    internal interface At {
 
         /** The indices of the rows to update. */
         interface RowIndices
@@ -99,7 +108,7 @@ internal interface UpdateOperation {
      * df.update { city }.with { name.firstName + " from " + it }
      * ```
      */
-    interface With {
+    internal interface With {
 
         /** The expression to update the selected columns with.
          *
@@ -110,86 +119,77 @@ internal interface UpdateOperation {
 }
 
 /**
- * @include [UpdateOperation]
- * @include [AccessApi.AnyApiLink]
- * @include [UpdateOperation.ColumnsSelectorParam]
+ * @include [Update]
+ * @include [AccessApi.AnyApiLinks]
+ * @include [Update.ColumnsSelectorParam]
  */
 public fun <T, C> DataFrame<T>.update(columns: ColumnsSelector<T, C>): Update<T, C> =
     Update(this, null, columns)
 
 /**
- * @include [UpdateOperation]
+ * @include [Update]
  * API:
  *  - {@include [AccessApi.StringApiLink]}
  *
- * @include [UpdateOperation.StringColumnsParam]
+ * @include [Update.StringColumnsParam]
  */
 public fun <T> DataFrame<T>.update(vararg columns: String): Update<T, Any?> = update { columns.toColumns() }
 
 /**
- * @include [UpdateOperation]
+ * @include [Update]
  * API:
  *  - {@include [AccessApi.KPropertiesApiLink]}
  *
- * @include [UpdateOperation.KPropertyColumnsParam]
+ * @include [Update.KPropertyColumnsParam]
  */
 public fun <T, C> DataFrame<T>.update(vararg columns: KProperty<C>): Update<T, C> = update { columns.toColumns() }
 
 /**
- * @include [UpdateOperation]
+ * @include [Update]
  * API:
  *  - {@include [AccessApi.ColumnAccessorsApiLink]}
  *
- * @include [UpdateOperation.ColumnReferencesParam]
+ * @include [Update.ColumnReferencesParam]
  */
 public fun <T, C> DataFrame<T>.update(vararg columns: ColumnReference<C>): Update<T, C> =
     update { columns.toColumns() }
 
 /**
- * @include [UpdateOperation]
+ * @include [Update]
  * API:
  *  - {@include [AccessApi.ColumnAccessorsApiLink]}
  *
- * @include [UpdateOperation.ColumnReferenceIterableParam]
+ * @include [Update.ColumnReferenceIterableParam]
  */
 public fun <T, C> DataFrame<T>.update(columns: Iterable<ColumnReference<C>>): Update<T, C> =
     update { columns.toColumnSet() }
 
-public data class Update<T, C>(
-    val df: DataFrame<T>,
-    val filter: RowValueFilter<T, C>?,
-    val columns: ColumnsSelector<T, C>
-) {
-    public fun <R : C> cast(): Update<T, R> =
-        Update(df, filter as RowValueFilter<T, R>?, columns as ColumnsSelector<T, R>)
-}
-
 /**
- * @include [UpdateOperation.Where]
+ * @include [Update.Where]
  *
- * @param predicate {@include [UpdateOperation.Where.Predicate]}
+ * @param predicate {@include [Update.Where.Predicate]}
  */
 public fun <T, C> Update<T, C>.where(predicate: RowValueFilter<T, C>): Update<T, C> =
     copy(filter = filter and predicate)
 
 /**
- * @include [UpdateOperation.At]
+ * @include [Update.At]
  *
- * @param rowIndices {@include [UpdateOperation.At.RowIndices]}
+ * @param rowIndices {@include [Update.At.RowIndices]}
  */
 public fun <T, C> Update<T, C>.at(rowIndices: Collection<Int>): Update<T, C> = where { index in rowIndices }
 
 /**
- * @include [UpdateOperation.At]
+ * @include [Update.At]
  *
- * @param rowIndices {@include [UpdateOperation.At.RowIndices]}
+ * @param rowIndices {@include [Update.At.RowIndices]}
  */
 public fun <T, C> Update<T, C>.at(vararg rowIndices: Int): Update<T, C> = at(rowIndices.toSet())
 
 /**
- * @include [UpdateOperation.At]
+ * @include [Update.At]
  *
- * @param rowRange {@include [UpdateOperation.At.RowIndices]}
+ * @param rowRange {@include [Update.At.RowIndices]}
  */
 public fun <T, C> Update<T, C>.at(rowRange: IntRange): Update<T, C> = where { index in rowRange }
 
@@ -199,9 +199,9 @@ public infix fun <T, C> Update<T, C>.perRowCol(expression: RowColumnExpression<T
 public typealias UpdateExpression<T, C, R> = AddDataRow<T>.(C) -> R
 
 /**
- * @include [UpdateOperation.With]
+ * @include [Update.With]
  *
- * @param expression {@include [UpdateOperation.With.Expression]}
+ * @param expression {@include [Update.With.Expression]}
  */
 public infix fun <T, C> Update<T, C>.with(expression: UpdateExpression<T, C, C?>): DataFrame<T> =
     updateImpl { row, _, value ->
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt
index 7de0675a8..fcfef0e04 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -70,7 +70,7 @@ public fun <T> DataFrame<T>.valueCounts(
     resultColumn: String = defaultCountColumnName
 ): DataFrame<T> = valueCounts(sort, ascending, dropNA, resultColumn) { columns.toColumns() }
 public fun <T> DataFrame<T>.valueCounts(
-    vararg columns: Column,
+    vararg columns: AnyColumnReference,
     sort: Boolean = true,
     ascending: Boolean = false,
     dropNA: Boolean = true,
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/values.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/values.kt
index 417487f73..a6e949a9e 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/values.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/values.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
@@ -24,7 +24,7 @@ public fun <T> DataFrame<T>.valuesNotNull(byRow: Boolean = false): Sequence<Any>
 
 // region GroupBy
 
-public fun <T> Grouped<T>.values(vararg columns: Column, dropNA: Boolean = false, distinct: Boolean = false): DataFrame<T> = values(dropNA, distinct) { columns.toColumns() }
+public fun <T> Grouped<T>.values(vararg columns: AnyColumnReference, dropNA: Boolean = false, distinct: Boolean = false): DataFrame<T> = values(dropNA, distinct) { columns.toColumns() }
 public fun <T> Grouped<T>.values(vararg columns: String, dropNA: Boolean = false, distinct: Boolean = false): DataFrame<T> = values(dropNA, distinct) { columns.toColumns() }
 public fun <T> Grouped<T>.values(
     dropNA: Boolean = false,
@@ -40,7 +40,7 @@ public fun <T> Grouped<T>.values(dropNA: Boolean = false, distinct: Boolean = fa
 public fun <T, G> ReducedGroupBy<T, G>.values(): DataFrame<G> = values(groupBy.remainingColumnsSelector())
 
 public fun <T, G> ReducedGroupBy<T, G>.values(
-    vararg columns: Column
+    vararg columns: AnyColumnReference
 ): DataFrame<G> = values { columns.toColumns() }
 
 public fun <T, G> ReducedGroupBy<T, G>.values(
@@ -66,7 +66,7 @@ public fun <T> Pivot<T>.values(
     columns: ColumnsForAggregateSelector<T, *>
 ): DataRow<T> = delegate { values(dropNA, distinct, separate, columns) }
 public fun <T> Pivot<T>.values(
-    vararg columns: Column,
+    vararg columns: AnyColumnReference,
     dropNA: Boolean = false,
     distinct: Boolean = false,
     separate: Boolean = false
@@ -95,7 +95,7 @@ public fun <T> ReducedPivot<T>.values(
 ): DataRow<T> = pivot.delegate { reduce(reducer).values(separate = separate) }
 
 public fun <T> ReducedPivot<T>.values(
-    vararg columns: Column,
+    vararg columns: AnyColumnReference,
     separate: Boolean = false
 ): DataRow<T> = values(separate) { columns.toColumns() }
 
@@ -121,7 +121,7 @@ public fun <T> ReducedPivot<T>.values(
 public fun <T> PivotGroupBy<T>.values(dropNA: Boolean = false, distinct: Boolean = false, separate: Boolean = false): DataFrame<T> = values(dropNA, distinct, separate, remainingColumnsSelector())
 
 public fun <T> PivotGroupBy<T>.values(
-    vararg columns: Column,
+    vararg columns: AnyColumnReference,
     dropNA: Boolean = false,
     distinct: Boolean = false,
     separate: Boolean = false
@@ -155,7 +155,7 @@ public fun <T> ReducedPivotGroupBy<T>.values(
 ): DataFrame<T> = values(separate, pivot.remainingColumnsSelector())
 
 public fun <T> ReducedPivotGroupBy<T>.values(
-    vararg columns: Column,
+    vararg columns: AnyColumnReference,
     separate: Boolean = false
 ): DataFrame<T> = values(separate) { columns.toColumns() }
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/with.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/with.kt
index 7b5942b83..04ae27ae3 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/with.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/with.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.RowExpression
@@ -37,7 +37,7 @@ public inline fun <T, reified V> ReducedPivotGroupBy<T>.with(noinline expression
     return pivot.aggregate {
         val value = reducer(this)?.let {
             val value = expression(it, it)
-            if (value is Column) it[value]
+            if (value is AnyColumnReference) it[value]
             else value
         }
         internal().yield(emptyPath(), value, type)
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
index 3217ddde7..073ea65c2 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
@@ -21,12 +21,12 @@ import org.jetbrains.kotlinx.dataframe.documentation.samples.ApiLevels as ApiLev
 internal interface AccessApi {
 
     /** API:
-     * - {@include [AccessApi.ExtensionPropertiesApiLink]}
-     * - {@include [AccessApi.KPropertiesApiLink]}
-     * - {@include [AccessApi.ColumnAccessorsApiLink]}
-     * - {@include [AccessApi.StringApiLink]}
+     * - {@include [ExtensionPropertiesApiLink]}
+     * - {@include [KPropertiesApiLink]}
+     * - {@include [ColumnAccessorsApiLink]}
+     * - {@include [StringApiLink]}
      * */
-    interface AnyApiLink
+    interface AnyApiLinks
 
     /**
      * String API.
@@ -40,7 +40,7 @@ internal interface AccessApi {
      */
     interface StringApi
 
-    /** String API [AccessApi.StringApi]. */
+    /** [String API][StringApi] */
     interface StringApiLink
 
     /**
@@ -55,7 +55,7 @@ internal interface AccessApi {
      */
     interface ColumnAccessorsApi
 
-    /** Column Accessors API [AccessApi.ColumnAccessorsApi]. */
+    /** [Column Accessors API][AccessApi.ColumnAccessorsApi] */
     interface ColumnAccessorsApiLink
 
     /**
@@ -72,7 +72,7 @@ internal interface AccessApi {
      */
     interface KPropertiesApi
 
-    /** KProperties API [AccessApi.KPropertiesApi]. */
+    /** [KProperties API][KPropertiesApi] */
     interface KPropertiesApiLink
 
     /**
@@ -87,6 +87,9 @@ internal interface AccessApi {
      */
     interface ExtensionPropertiesApi
 
-    /** Extension Properties API [AccessApi.ExtensionPropertiesApi]. */
+    /** [Extension Properties API][ExtensionPropertiesApi] */
     interface ExtensionPropertiesApiLink
 }
+
+/** [Access Api][AccessApi] */
+internal interface AccessApiLink
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/HighLevelOperations.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/HighLevelOperations.kt
new file mode 100644
index 000000000..dc6a989b8
--- /dev/null
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/HighLevelOperations.kt
@@ -0,0 +1,70 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.api.*
+
+/** [Selecting Columns][SelectingColumns] */
+internal interface SelectingColumnsLink
+
+/**
+ * Selecting columns for various operations (including but not limited to
+ * [DataFrame.select], [DataFrame.update], [DataFrame.gather], and [DataFrame.fillNulls])
+ * can be done in the following ways:
+ * - {@include [Dsl]}
+ * - {@include [ColumnNames]}
+ * - {@include [ColumnAccessors]}
+ * - {@include [KProperties]}
+ */
+internal interface SelectingColumns {
+
+    /**
+     * The column selector DSL (Any {@include [AccessApiLink]}).
+     * See {@include [ColumnSelectionDslLink]} for more details.
+     *
+     * For example:
+     * ```kotlin
+     * df.select { length and age }
+     * df.select { cols(1..5) }
+     * df.select { colsOf<Double>() }
+     * ```
+     */
+    interface Dsl
+
+    /**
+     * Column names ({@include [AccessApi.StringApiLink]}).
+     *
+     * For example:
+     * ```kotlin
+     * df.select("length", "age")
+     * df.select(listOf("length", "age"))
+     * ```
+     */
+    interface ColumnNames
+
+    /**
+     * Column accessors ({@include [AccessApi.ColumnAccessorsApiLink]}).
+     *
+     * For example:
+     * ```kotlin
+     * val length by column<Double>()
+     * val age by column<Double>()
+     * df.select(length, age)
+     * df.select(listOf(length, age))
+     * ```
+     */
+    interface ColumnAccessors
+
+    /**
+     * KProperties ({@include [AccessApi.KPropertiesApiLink]}).
+     *
+     * For example:
+     * ```kotlin
+     * data class Person(val length: Double, val age: Double)
+     *
+     * df.select(Person::length, Person::age)
+     * df.select(listOf(Person::length, Person::age))
+     * ```
+     */
+    interface KProperties
+
+}
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregations.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregations.kt
index 925a70fdd..f18c558ca 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregations.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregations.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.impl.aggregation
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.RowExpression
@@ -90,7 +90,7 @@ internal fun <T, C> AggregateInternalDsl<T>.columnValues(
 internal fun <T, V> AggregateInternalDsl<T>.withExpr(type: KType, path: ColumnPath, expression: RowExpression<T, V>) {
     val values = df.rows().map {
         val value = expression(it, it)
-        if (value is Column) it[value]
+        if (value is AnyColumnReference) it[value]
         else value
     }
     yieldOneOrMany(path, values, type)
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/move.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/move.kt
index 0e51a7362..e70c945ef 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/move.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/move.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.impl.api
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -43,7 +43,7 @@ internal fun <T, C> MoveClause<T, C>.afterOrBefore(column: ColumnSelector<T, *>,
 
 internal fun <T, C> MoveClause<T, C>.moveImpl(
     under: Boolean = false,
-    newPathExpression: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> Column
+    newPathExpression: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> AnyColumnReference
 ): DataFrame<T> {
     val receiver = object : DataFrameReceiver<T>(df, UnresolvedColumnsPolicy.Fail), ColumnsSelectionDsl<T> {}
     val removeResult = df.removeImpl(columns = columns)

From 9ec93b43dab298a26db0d9572975b82f06b8bc31 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Wed, 1 Feb 2023 18:31:03 +0100
Subject: [PATCH 12/50] continuing with kdocs with updated processor

---
 core/build.gradle.kts                         |   5 +-
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  | 105 +++++++++++++-----
 .../jetbrains/kotlinx/dataframe/api/update.kt |  95 +++++++++-------
 .../documentation/DocumentationUrls.kt        |   3 +
 .../documentation/HighLevelOperations.kt      |  42 ++++---
 5 files changed, 158 insertions(+), 92 deletions(-)

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index f1f48fe68..3e54374f3 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -14,7 +14,7 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.7"
+    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.10"
 //    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
 }
 
@@ -66,9 +66,10 @@ val processKdocIncludeMain by creatingProcessDocTask(
 ) {
     processors = listOf(
         INCLUDE_DOC_PROCESSOR,
-        SAMPLE_DOC_PROCESSOR,
         INCLUDE_FILE_DOC_PROCESSOR,
+        INCLUDE_ARG_DOC_PROCESSOR,
         COMMENT_DOC_PROCESSOR,
+        SAMPLE_DOC_PROCESSOR,
     )
     debug = true
 }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index 3b8a9c8f6..afa6c3770 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -7,6 +7,7 @@ import org.jetbrains.kotlinx.dataframe.AnyRow
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.Update.Usage
 import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.documentation.*
@@ -21,64 +22,61 @@ import kotlin.reflect.KProperty
 /**
  * Replace `null` values with given value or expression.
  * Specific case of [Update].
- * TODO samples
  *
- * @include [DocumentationUrls.Fill.FillNulls]
+ * Check out [how to use `fillNulls`][Usage].
+ *
+ * For more information: {@include [DocumentationUrls.Fill.FillNulls]}
  */
-internal interface FillNullsOperation
+internal interface FillNulls {
+
+    /** @include [Update.Usage] {@arg [Update.UpdateOperationArg] [fillNulls]} */
+    interface Usage
+}
+
+/** {@arg [OperationArg] fillNulls} */
+internal interface SetFillNullsOperationArg
 
 /**
- * @include [FillNullsOperation]
+ * @include [FillNulls]
  *
- * @param columns The [ColumnsSelector] used to select columns to update.
+ * @include [Update.DslParam]
+ * @include [SetFillNullsOperationArg]
  */
 public fun <T, C> DataFrame<T>.fillNulls(columns: ColumnsSelector<T, C?>): Update<T, C?> =
     update(columns).where { it == null }
 
 /**
- * @include [FillNullsOperation]
+ * @include [FillNulls]
  *
- * @receiver [DataFrame]
- * @param T T
- * @param C C
- * @param columns Cols
- * @return [Update]
+ * @include [Update.ColumnNamesParam]
+ * @include [SetFillNullsOperationArg]
  */
 public fun <T> DataFrame<T>.fillNulls(vararg columns: String): Update<T, Any?> =
     fillNulls { columns.toColumns() }
 
 /**
- * @include [FillNullsOperation]
+ * @include [FillNulls]
  *
- * @receiver [DataFrame]
- * @param T T
- * @param C C
- * @param columns Cols
- * @return [Update]
+ * @include [Update.KPropertiesParam]
+ * @include [SetFillNullsOperationArg]
  */
 public fun <T, C> DataFrame<T>.fillNulls(vararg columns: KProperty<C>): Update<T, C?> =
     fillNulls { columns.toColumns() }
 
 /**
- * @include [FillNullsOperation]
+ * @include [FillNulls]
  *
- * @receiver [DataFrame]
- * @param T T
- * @param C C
- * @param columns Cols
- * @return [Update]
+ * @include [Update.ColumnAccessorsParam]
+ * @include [SetFillNullsOperationArg]
  */
 public fun <T, C> DataFrame<T>.fillNulls(vararg columns: ColumnReference<C>): Update<T, C?> =
     fillNulls { columns.toColumns() }
 
 /**
- * @include [FillNullsOperation]
+ * @include [FillNulls]
  *
- * @receiver [DataFrame]
- * @param T T
- * @param C C
- * @param columns Cols
- * @return [Update]
+ * @include [Update.ColumnAccessorsParam]
+ * @include [SetFillNullsOperationArg]
  */
 public fun <T, C> DataFrame<T>.fillNulls(columns: Iterable<ColumnReference<C>>): Update<T, C?> =
     fillNulls { columns.toColumnSet() }
@@ -107,18 +105,67 @@ internal inline val Float?.isNA: Boolean get() = this == null || this.isNaN()
 
 // region fillNaNs
 
+
+/**
+ * Replace `NaN` values with given value or expression.
+ * Specific case of [Update].
+ *
+ * Check out [how to use `fillNaNs`][Usage].
+ *
+ * For more information: {@include [DocumentationUrls.Fill.FillNaNs]}
+ */
+internal interface FillNaNs {
+
+    /** @include [Update.Usage] {@arg [Update.UpdateOperationArg] [fillNaNs]} */
+    interface Usage
+}
+
+
+/** {@arg [OperationArg] fillNaNs} */
+internal interface SetFillNaNsOperationArg
+
+/**
+ * @include [FillNaNs]
+ *
+ * @include [Update.DslParam]
+ * @include [SetFillNaNsOperationArg]
+ */
 public fun <T, C> DataFrame<T>.fillNaNs(columns: ColumnsSelector<T, C>): Update<T, C> =
     update(columns).where { it.isNaN }
 
+/**
+ * @include [FillNaNs]
+ *
+ * @include [Update.ColumnNamesParam]
+ * @include [SetFillNaNsOperationArg]
+ */
 public fun <T> DataFrame<T>.fillNaNs(vararg columns: String): Update<T, Any?> =
     fillNaNs { columns.toColumns() }
 
+/**
+ * @include [FillNaNs]
+ *
+ * @include [Update.KPropertiesParam]
+ * @include [SetFillNaNsOperationArg]
+ */
 public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: KProperty<C>): Update<T, C> =
     fillNaNs { columns.toColumns() }
 
+/**
+ * @include [FillNaNs]
+ *
+ * @include [Update.ColumnAccessorsParam]
+ * @include [SetFillNaNsOperationArg]
+ */
 public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: ColumnReference<C>): Update<T, C> =
     fillNaNs { columns.toColumns() }
 
+/**
+ * @include [FillNaNs]
+ *
+ * @include [Update.ColumnAccessorsParam]
+ * @include [SetFillNaNsOperationArg]
+ */
 public fun <T, C> DataFrame<T>.fillNaNs(columns: Iterable<ColumnReference<C>>): Update<T, C> =
     fillNaNs { columns.toColumnSet() }
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index 53302c2ed..7b6a0dab5 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -11,7 +11,6 @@ import org.jetbrains.kotlinx.dataframe.RowValueExpression
 import org.jetbrains.kotlinx.dataframe.RowValueFilter
 import org.jetbrains.kotlinx.dataframe.Selector
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
-import org.jetbrains.kotlinx.dataframe.documentation.AccessApi
 import org.jetbrains.kotlinx.dataframe.impl.api.updateImpl
 import org.jetbrains.kotlinx.dataframe.impl.api.updateWithValuePerColumnImpl
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
@@ -22,25 +21,12 @@ import org.jetbrains.kotlinx.dataframe.index
 import kotlin.reflect.KProperty
 
 /**
- * Returns [DataFrame] with changed values in some cells.
+ * Returns the [DataFrame] with changed values in some cells
+ * (column types can not be changed).
  *
- * Column types can not be changed.
+ * Check out [how to use `update`][Usage].
  *
- * Update operation usage:
- *
- * [update] { [columns][Update.Columns] }
- *
- *   [.[where] { [rowCondition][Update.Where.Predicate] } ]
- *
- *   [.[at] ([rowIndices][Update.At.RowIndices]) ]
- *
- *   .[with][Update.with] { [rowExpression][Update.With.Expression] } | .[notNull] { rowExpression } | .[perCol] { colExpression } | .[perRowCol] { rowColExpression } | .[withValue] (value) | .[withNull] () | .[withZero] () | .[asFrame] { frameExpression }
- *
- * {@comment TODO
- * rowExpression: DataRow.(OldValue) -> NewValue
- * colExpression: DataColumn.(DataColumn) -> NewValue
- * rowColExpression: DataRow.(DataColumn) -> NewValue
- * frameExpression: DataFrame.(DataFrame) -> DataFrame}
+ * For more information: {@include [DocumentationUrls.Update]}
  */
 public data class Update<T, C>(
     val df: DataFrame<T>,
@@ -50,23 +36,46 @@ public data class Update<T, C>(
     public fun <R : C> cast(): Update<T, R> =
         Update(df, filter as RowValueFilter<T, R>?, columns as ColumnsSelector<T, R>)
 
+    internal interface UpdateOperationArg
+
+    /**
+     * {@includeArg [UpdateOperationArg]} operation usage:
+     *
+     * {@includeArg [UpdateOperationArg]} { [columns][Columns] }
+     *
+     *   [.[where] { [rowCondition][Where.Predicate] } ]
+     *
+     *   [.[at] ([rowIndices][At.RowIndices]) ]
+     *
+     *   .[with] { [rowExpression][With.Expression] } | .[notNull] { rowExpression } | .[perCol] { colExpression } | .[perRowCol] { rowColExpression } | .[withValue] (value) | .[withNull] () | .[withZero] () | .[asFrame] { frameExpression }
+     *
+     * {@comment TODO
+     * rowExpression: DataRow.(OldValue) -> NewValue
+     * colExpression: DataColumn.(DataColumn) -> NewValue
+     * rowColExpression: DataRow.(DataColumn) -> NewValue
+     * frameExpression: DataFrame.(DataFrame) -> DataFrame}
+     * {@arg [UpdateOperationArg] [update]}
+     */
+    internal interface Usage
+
     /** Select the columns to update. See {@include [SelectingColumnsLink]}. */
     internal interface Columns
 
-    /** @param columns The [ColumnsSelector] used to select the columns of this [DataFrame] to update. */
-    internal interface ColumnsSelectorParam
-
-    /** @param columns An [Iterable] of [ColumnReference]s of this [DataFrame] to update. */
-    internal interface ColumnReferenceIterableParam
+    /** {@include [SelectingColumns.Dsl]}
+     * @param columns The [ColumnsSelector] used to select the columns of this [DataFrame] to update. */
+    internal interface DslParam
 
-    /** @param columns The [ColumnReference]s of this [DataFrame] to update. */
-    internal interface ColumnReferencesParam
+    /** {@include [SelectingColumns.ColumnAccessors]}
+     * @param columns An [Iterable] of [ColumnReference]s of this [DataFrame] to update. */
+    internal interface ColumnAccessorsParam
 
-    /** @param columns The [KProperty] values corresponding to columns of this [DataFrame] to update. */
-    internal interface KPropertyColumnsParam
+    /** {@include [SelectingColumns.KProperties]}
+     * @param columns The [KProperty] values corresponding to columns of this [DataFrame] to update. */
+    internal interface KPropertiesParam
 
-    /** @param columns The column names belonging to this [DataFrame] to update. */
-    internal interface StringColumnsParam
+    /** {@include [SelectingColumns.ColumnNames]}
+     * @param columns The column names belonging to this [DataFrame] to update. */
+    internal interface ColumnNamesParam
 
     /**
      * Only update the columns that pass a certain [predicate][Update.Where.Predicate].
@@ -118,48 +127,48 @@ public data class Update<T, C>(
     }
 }
 
+/** {@arg [OperationArg] update} */
+internal interface SetUpdateOperationArg
+
 /**
  * @include [Update]
- * @include [AccessApi.AnyApiLinks]
- * @include [Update.ColumnsSelectorParam]
+ *
+ * @include [Update.DslParam]
+ * @include [SetUpdateOperationArg]
  */
 public fun <T, C> DataFrame<T>.update(columns: ColumnsSelector<T, C>): Update<T, C> =
     Update(this, null, columns)
 
 /**
  * @include [Update]
- * API:
- *  - {@include [AccessApi.StringApiLink]}
  *
- * @include [Update.StringColumnsParam]
+ * @include [Update.ColumnNamesParam]
+ * @include [SetUpdateOperationArg]
  */
 public fun <T> DataFrame<T>.update(vararg columns: String): Update<T, Any?> = update { columns.toColumns() }
 
 /**
  * @include [Update]
- * API:
- *  - {@include [AccessApi.KPropertiesApiLink]}
  *
- * @include [Update.KPropertyColumnsParam]
+ * @include [Update.KPropertiesParam]
+ * @include [SetUpdateOperationArg]
  */
 public fun <T, C> DataFrame<T>.update(vararg columns: KProperty<C>): Update<T, C> = update { columns.toColumns() }
 
 /**
  * @include [Update]
- * API:
- *  - {@include [AccessApi.ColumnAccessorsApiLink]}
  *
- * @include [Update.ColumnReferencesParam]
+ * @include [Update.ColumnAccessorsParam]
+ * @include [SetUpdateOperationArg]
  */
 public fun <T, C> DataFrame<T>.update(vararg columns: ColumnReference<C>): Update<T, C> =
     update { columns.toColumns() }
 
 /**
  * @include [Update]
- * API:
- *  - {@include [AccessApi.ColumnAccessorsApiLink]}
  *
- * @include [Update.ColumnReferenceIterableParam]
+ * @include [Update.ColumnAccessorsParam]
+ * @include [SetUpdateOperationArg]
  */
 public fun <T, C> DataFrame<T>.update(columns: Iterable<ColumnReference<C>>): Update<T, C> =
     update { columns.toColumnSet() }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
index 011579998..7ab0acb26 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
@@ -2,6 +2,9 @@ package org.jetbrains.kotlinx.dataframe.documentation
 
 private interface DocumentationUrls {
 
+    /** [See `update` documentation.](https://kotlin.github.io/dataframe/update.html) */
+    interface Update
+
     /** [See `fill` documentation.](https://kotlin.github.io/dataframe/fill.html) */
     interface Fill {
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/HighLevelOperations.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/HighLevelOperations.kt
index dc6a989b8..66e1f0724 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/HighLevelOperations.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/HighLevelOperations.kt
@@ -2,6 +2,10 @@ package org.jetbrains.kotlinx.dataframe.documentation
 
 import org.jetbrains.kotlinx.dataframe.*
 import org.jetbrains.kotlinx.dataframe.api.*
+import kotlin.reflect.KProperty
+
+/** The key for an @arg that will define the operation name for the examples below. */
+internal interface OperationArg
 
 /** [Selecting Columns][SelectingColumns] */
 internal interface SelectingColumnsLink
@@ -17,53 +21,55 @@ internal interface SelectingColumnsLink
  */
 internal interface SelectingColumns {
 
-    /**
-     * The column selector DSL (Any {@include [AccessApiLink]}).
-     * See {@include [ColumnSelectionDslLink]} for more details.
+    /** {@arg [OperationArg] <operation>} */
+    interface SetDefaultOperationArg
+
+    /** Select columns using the {@include [ColumnSelectionDslLink]} (Any {@include [AccessApiLink]}).
      *
      * For example:
      * ```kotlin
-     * df.select { length and age }
-     * df.select { cols(1..5) }
-     * df.select { colsOf<Double>() }
+     * df.{@includeArg [OperationArg]} { length and age }
+     * df.{@includeArg [OperationArg]} { cols(1..5) }
+     * df.{@includeArg [OperationArg]} { colsOf<Double>() }
      * ```
+     * @include [SetDefaultOperationArg]
      */
     interface Dsl
 
-    /**
-     * Column names ({@include [AccessApi.StringApiLink]}).
+    /** Select columns using their column names ({@include [AccessApi.StringApiLink]}).
      *
      * For example:
      * ```kotlin
-     * df.select("length", "age")
-     * df.select(listOf("length", "age"))
+     * df.{@includeArg [OperationArg]}("length", "age")
+     * df.{@includeArg [OperationArg]}(listOf("length", "age"))
      * ```
+     * @include [SetDefaultOperationArg]
      */
     interface ColumnNames
 
-    /**
-     * Column accessors ({@include [AccessApi.ColumnAccessorsApiLink]}).
+    /** Select columns using column accessors ({@include [AccessApi.ColumnAccessorsApiLink]}).
      *
      * For example:
      * ```kotlin
      * val length by column<Double>()
      * val age by column<Double>()
-     * df.select(length, age)
-     * df.select(listOf(length, age))
+     * df.{@includeArg [OperationArg]}(length, age)
+     * df.{@includeArg [OperationArg]}(listOf(length, age))
      * ```
+     * @include [SetDefaultOperationArg]
      */
     interface ColumnAccessors
 
-    /**
-     * KProperties ({@include [AccessApi.KPropertiesApiLink]}).
+    /** Select columns using [KProperty]'s ({@include [AccessApi.KPropertiesApiLink]}).
      *
      * For example:
      * ```kotlin
      * data class Person(val length: Double, val age: Double)
      *
-     * df.select(Person::length, Person::age)
-     * df.select(listOf(Person::length, Person::age))
+     * df.{@includeArg [OperationArg]}(Person::length, Person::age)
+     * df.{@includeArg [OperationArg]}(listOf(Person::length, Person::age))
      * ```
+     * @include [SetDefaultOperationArg]
      */
     interface KProperties
 

From 09da9b67f8b4a0e3b9f42f2c1880694aa7d711dc Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Thu, 2 Feb 2023 15:27:54 +0100
Subject: [PATCH 13/50] continuing with kdocs

---
 core/build.gradle.kts                         |  2 +-
 .../dataframe/api/ColumnsSelectionDsl.kt      |  8 +++-
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  | 24 ++++++------
 .../jetbrains/kotlinx/dataframe/api/update.kt | 37 ++++++++++---------
 .../documentation/HighLevelOperations.kt      | 32 +++++++++++-----
 .../kotlinx/dataframe/impl/api/convertTo.kt   |  5 ++-
 .../dataframe/impl/columns/constructors.kt    |  2 +-
 7 files changed, 63 insertions(+), 47 deletions(-)

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 3e54374f3..3ac6a0e85 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -14,7 +14,7 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.10"
+    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.11"
 //    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
 }
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
index 88d62b4e3..448b7bf36 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
@@ -35,6 +35,10 @@ import kotlin.reflect.KProperty
 import kotlin.reflect.KType
 import kotlin.reflect.typeOf
 
+/** [Column Selection DSL][ColumnSelectionDsl] */
+internal interface ColumnSelectionDslLink
+
+/** TODO: Put examples and explanations here */
 public interface ColumnSelectionDsl<out T> : ColumnsContainer<T> {
 
     public operator fun <C> ColumnReference<C>.invoke(): DataColumn<C> = get(this)
@@ -50,10 +54,10 @@ public interface ColumnSelectionDsl<out T> : ColumnsContainer<T> {
     public operator fun String.get(column: String): ColumnPath = pathOf(this, column)
 }
 
-
 /** [Columns Selection DSL][ColumnsSelectionDsl] */
-internal interface ColumnSelectionDslLink
+internal interface ColumnsSelectionDslLink
 
+/** TODO: Put examples and explanations here */
 public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColumn<DataRow<T>> {
 
     public fun <C> ColumnSet<C>.first(condition: ColumnFilter<C>): SingleColumn<C> =
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index afa6c3770..0d17a890d 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -39,8 +39,8 @@ internal interface SetFillNullsOperationArg
 /**
  * @include [FillNulls]
  *
+ * @include [SelectingColumns.Dsl] {@include [SetFillNullsOperationArg]}
  * @include [Update.DslParam]
- * @include [SetFillNullsOperationArg]
  */
 public fun <T, C> DataFrame<T>.fillNulls(columns: ColumnsSelector<T, C?>): Update<T, C?> =
     update(columns).where { it == null }
@@ -48,8 +48,8 @@ public fun <T, C> DataFrame<T>.fillNulls(columns: ColumnsSelector<T, C?>): Updat
 /**
  * @include [FillNulls]
  *
+ * @include [SelectingColumns.ColumnNames] {@include [SetFillNullsOperationArg]}
  * @include [Update.ColumnNamesParam]
- * @include [SetFillNullsOperationArg]
  */
 public fun <T> DataFrame<T>.fillNulls(vararg columns: String): Update<T, Any?> =
     fillNulls { columns.toColumns() }
@@ -57,8 +57,8 @@ public fun <T> DataFrame<T>.fillNulls(vararg columns: String): Update<T, Any?> =
 /**
  * @include [FillNulls]
  *
+ * @include [SelectingColumns.KProperties] {@include [SetFillNullsOperationArg]}
  * @include [Update.KPropertiesParam]
- * @include [SetFillNullsOperationArg]
  */
 public fun <T, C> DataFrame<T>.fillNulls(vararg columns: KProperty<C>): Update<T, C?> =
     fillNulls { columns.toColumns() }
@@ -66,8 +66,8 @@ public fun <T, C> DataFrame<T>.fillNulls(vararg columns: KProperty<C>): Update<T
 /**
  * @include [FillNulls]
  *
+ * @include [SelectingColumns.ColumnAccessors] {@include [SetFillNullsOperationArg]}
  * @include [Update.ColumnAccessorsParam]
- * @include [SetFillNullsOperationArg]
  */
 public fun <T, C> DataFrame<T>.fillNulls(vararg columns: ColumnReference<C>): Update<T, C?> =
     fillNulls { columns.toColumns() }
@@ -75,8 +75,8 @@ public fun <T, C> DataFrame<T>.fillNulls(vararg columns: ColumnReference<C>): Up
 /**
  * @include [FillNulls]
  *
+ * @include [SelectingColumns.ColumnAccessors] {@include [SetFillNullsOperationArg]}
  * @include [Update.ColumnAccessorsParam]
- * @include [SetFillNullsOperationArg]
  */
 public fun <T, C> DataFrame<T>.fillNulls(columns: Iterable<ColumnReference<C>>): Update<T, C?> =
     fillNulls { columns.toColumnSet() }
@@ -105,7 +105,6 @@ internal inline val Float?.isNA: Boolean get() = this == null || this.isNaN()
 
 // region fillNaNs
 
-
 /**
  * Replace `NaN` values with given value or expression.
  * Specific case of [Update].
@@ -120,15 +119,14 @@ internal interface FillNaNs {
     interface Usage
 }
 
-
 /** {@arg [OperationArg] fillNaNs} */
 internal interface SetFillNaNsOperationArg
 
 /**
  * @include [FillNaNs]
- *
+ * @include [SelectingColumns.Dsl] {@include [SetFillNaNsOperationArg]}
  * @include [Update.DslParam]
- * @include [SetFillNaNsOperationArg]
+ *
  */
 public fun <T, C> DataFrame<T>.fillNaNs(columns: ColumnsSelector<T, C>): Update<T, C> =
     update(columns).where { it.isNaN }
@@ -136,8 +134,8 @@ public fun <T, C> DataFrame<T>.fillNaNs(columns: ColumnsSelector<T, C>): Update<
 /**
  * @include [FillNaNs]
  *
+ * @include [SelectingColumns.ColumnNames] {@include [SetFillNaNsOperationArg]}
  * @include [Update.ColumnNamesParam]
- * @include [SetFillNaNsOperationArg]
  */
 public fun <T> DataFrame<T>.fillNaNs(vararg columns: String): Update<T, Any?> =
     fillNaNs { columns.toColumns() }
@@ -145,8 +143,8 @@ public fun <T> DataFrame<T>.fillNaNs(vararg columns: String): Update<T, Any?> =
 /**
  * @include [FillNaNs]
  *
+ * @include [SelectingColumns.KProperties] {@include [SetFillNaNsOperationArg]}
  * @include [Update.KPropertiesParam]
- * @include [SetFillNaNsOperationArg]
  */
 public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: KProperty<C>): Update<T, C> =
     fillNaNs { columns.toColumns() }
@@ -154,8 +152,8 @@ public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: KProperty<C>): Update<T,
 /**
  * @include [FillNaNs]
  *
+ * @include [SelectingColumns.ColumnAccessors] {@include [SetFillNaNsOperationArg]}
  * @include [Update.ColumnAccessorsParam]
- * @include [SetFillNaNsOperationArg]
  */
 public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: ColumnReference<C>): Update<T, C> =
     fillNaNs { columns.toColumns() }
@@ -163,8 +161,8 @@ public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: ColumnReference<C>): Upd
 /**
  * @include [FillNaNs]
  *
+ * @include [SelectingColumns.ColumnAccessors] {@include [SetFillNaNsOperationArg]}
  * @include [Update.ColumnAccessorsParam]
- * @include [SetFillNaNsOperationArg]
  */
 public fun <T, C> DataFrame<T>.fillNaNs(columns: Iterable<ColumnReference<C>>): Update<T, C> =
     fillNaNs { columns.toColumnSet() }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index 7b6a0dab5..668a1d077 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -10,13 +10,14 @@ import org.jetbrains.kotlinx.dataframe.RowColumnExpression
 import org.jetbrains.kotlinx.dataframe.RowValueExpression
 import org.jetbrains.kotlinx.dataframe.RowValueFilter
 import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.api.Update.Usage
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.documentation.*
 import org.jetbrains.kotlinx.dataframe.impl.api.updateImpl
 import org.jetbrains.kotlinx.dataframe.impl.api.updateWithValuePerColumnImpl
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
 import org.jetbrains.kotlinx.dataframe.impl.headPlusArray
-import org.jetbrains.kotlinx.dataframe.documentation.*
 import org.jetbrains.kotlinx.dataframe.index
 import kotlin.reflect.KProperty
 
@@ -40,14 +41,14 @@ public data class Update<T, C>(
 
     /**
      * {@includeArg [UpdateOperationArg]} operation usage:
-     *
+     * ___
      * {@includeArg [UpdateOperationArg]} { [columns][Columns] }
      *
-     *   [.[where] { [rowCondition][Where.Predicate] } ]
+     * - [.[where] { [rowCondition][Where.Predicate] } ]
      *
-     *   [.[at] ([rowIndices][At.RowIndices]) ]
+     * - [.[at] ([rowIndices][At.RowIndices]) ]
      *
-     *   .[with] { [rowExpression][With.Expression] } | .[notNull] { rowExpression } | .[perCol] { colExpression } | .[perRowCol] { rowColExpression } | .[withValue] (value) | .[withNull] () | .[withZero] () | .[asFrame] { frameExpression }
+     * - .[with] { [rowExpression][With.Expression] } | .[notNull] { rowExpression } | .[perCol] { colExpression } | .[perRowCol] { rowColExpression } | .[withValue] (value) | .[withNull] () | .[withZero] () | .[asFrame] { frameExpression }
      *
      * {@comment TODO
      * rowExpression: DataRow.(OldValue) -> NewValue
@@ -61,20 +62,16 @@ public data class Update<T, C>(
     /** Select the columns to update. See {@include [SelectingColumnsLink]}. */
     internal interface Columns
 
-    /** {@include [SelectingColumns.Dsl]}
-     * @param columns The [ColumnsSelector] used to select the columns of this [DataFrame] to update. */
+    /** @param columns The [ColumnsSelector] used to select the columns of this [DataFrame] to update. */
     internal interface DslParam
 
-    /** {@include [SelectingColumns.ColumnAccessors]}
-     * @param columns An [Iterable] of [ColumnReference]s of this [DataFrame] to update. */
+    /** @param columns The [ColumnReference]s of this [DataFrame] to update. */
     internal interface ColumnAccessorsParam
 
-    /** {@include [SelectingColumns.KProperties]}
-     * @param columns The [KProperty] values corresponding to columns of this [DataFrame] to update. */
+    /** @param columns The [KProperty] values corresponding to columns of this [DataFrame] to update. */
     internal interface KPropertiesParam
 
-    /** {@include [SelectingColumns.ColumnNames]}
-     * @param columns The column names belonging to this [DataFrame] to update. */
+    /** @param columns The column names belonging to this [DataFrame] to update. */
     internal interface ColumnNamesParam
 
     /**
@@ -127,14 +124,16 @@ public data class Update<T, C>(
     }
 }
 
+// region update
+
 /** {@arg [OperationArg] update} */
 internal interface SetUpdateOperationArg
 
 /**
  * @include [Update]
  *
+ * @include [SelectingColumns.Dsl] {@include [SetUpdateOperationArg]}
  * @include [Update.DslParam]
- * @include [SetUpdateOperationArg]
  */
 public fun <T, C> DataFrame<T>.update(columns: ColumnsSelector<T, C>): Update<T, C> =
     Update(this, null, columns)
@@ -142,24 +141,24 @@ public fun <T, C> DataFrame<T>.update(columns: ColumnsSelector<T, C>): Update<T,
 /**
  * @include [Update]
  *
+ * @include [SelectingColumns.ColumnNames] {@include [SetUpdateOperationArg]}
  * @include [Update.ColumnNamesParam]
- * @include [SetUpdateOperationArg]
  */
 public fun <T> DataFrame<T>.update(vararg columns: String): Update<T, Any?> = update { columns.toColumns() }
 
 /**
  * @include [Update]
  *
+ * @include [SelectingColumns.KProperties] {@include [SetUpdateOperationArg]}
  * @include [Update.KPropertiesParam]
- * @include [SetUpdateOperationArg]
  */
 public fun <T, C> DataFrame<T>.update(vararg columns: KProperty<C>): Update<T, C> = update { columns.toColumns() }
 
 /**
  * @include [Update]
  *
+ * @include [SelectingColumns.ColumnAccessors] {@include [SetUpdateOperationArg]}
  * @include [Update.ColumnAccessorsParam]
- * @include [SetUpdateOperationArg]
  */
 public fun <T, C> DataFrame<T>.update(vararg columns: ColumnReference<C>): Update<T, C> =
     update { columns.toColumns() }
@@ -167,12 +166,14 @@ public fun <T, C> DataFrame<T>.update(vararg columns: ColumnReference<C>): Updat
 /**
  * @include [Update]
  *
+ * @include [SelectingColumns.ColumnAccessors] {@include [SetUpdateOperationArg]}
  * @include [Update.ColumnAccessorsParam]
- * @include [SetUpdateOperationArg]
  */
 public fun <T, C> DataFrame<T>.update(columns: Iterable<ColumnReference<C>>): Update<T, C> =
     update { columns.toColumnSet() }
 
+// endregion
+
 /**
  * @include [Update.Where]
  *
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/HighLevelOperations.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/HighLevelOperations.kt
index 66e1f0724..00f52803f 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/HighLevelOperations.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/HighLevelOperations.kt
@@ -2,16 +2,24 @@ package org.jetbrains.kotlinx.dataframe.documentation
 
 import org.jetbrains.kotlinx.dataframe.*
 import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
 import kotlin.reflect.KProperty
 
+/** {@comment
+ * In this file we provide documentation for high-level operations such as
+ * the operation of selecting columns.
+ * }
+ */
+
+
 /** The key for an @arg that will define the operation name for the examples below. */
 internal interface OperationArg
 
 /** [Selecting Columns][SelectingColumns] */
 internal interface SelectingColumnsLink
 
-/**
- * Selecting columns for various operations (including but not limited to
+/** Selecting columns for various operations (including but not limited to
  * [DataFrame.select], [DataFrame.update], [DataFrame.gather], and [DataFrame.fillNulls])
  * can be done in the following ways:
  * - {@include [Dsl]}
@@ -24,7 +32,12 @@ internal interface SelectingColumns {
     /** {@arg [OperationArg] <operation>} */
     interface SetDefaultOperationArg
 
-    /** Select columns using the {@include [ColumnSelectionDslLink]} (Any {@include [AccessApiLink]}).
+    /** Select or express columns using the Column(s) Selection DSL.
+     * (Any {@include [AccessApiLink]}).
+     *
+     * The DSL comes in the form of either a [ColumnSelector]- or [ColumnsSelector] lambda,
+     * which operate in the {@include [ColumnSelectionDslLink]} or the {@include [ColumnsSelectionDslLink]} and
+     * expect you to return a [SingleColumn] or [ColumnSet], respectively.
      *
      * For example:
      * ```kotlin
@@ -36,41 +49,40 @@ internal interface SelectingColumns {
      */
     interface Dsl
 
-    /** Select columns using their column names ({@include [AccessApi.StringApiLink]}).
+    /** Select columns using their column names
+     * ({@include [AccessApi.StringApiLink]}).
      *
      * For example:
      * ```kotlin
      * df.{@includeArg [OperationArg]}("length", "age")
-     * df.{@includeArg [OperationArg]}(listOf("length", "age"))
      * ```
      * @include [SetDefaultOperationArg]
      */
     interface ColumnNames
 
-    /** Select columns using column accessors ({@include [AccessApi.ColumnAccessorsApiLink]}).
+    /** Select columns using column accessors
+     * ({@include [AccessApi.ColumnAccessorsApiLink]}).
      *
      * For example:
      * ```kotlin
      * val length by column<Double>()
      * val age by column<Double>()
      * df.{@includeArg [OperationArg]}(length, age)
-     * df.{@includeArg [OperationArg]}(listOf(length, age))
      * ```
      * @include [SetDefaultOperationArg]
      */
     interface ColumnAccessors
 
-    /** Select columns using [KProperty]'s ({@include [AccessApi.KPropertiesApiLink]}).
+    /** Select columns using [KProperty]'s
+     * ({@include [AccessApi.KPropertiesApiLink]}).
      *
      * For example:
      * ```kotlin
      * data class Person(val length: Double, val age: Double)
      *
      * df.{@includeArg [OperationArg]}(Person::length, Person::age)
-     * df.{@includeArg [OperationArg]}(listOf(Person::length, Person::age))
      * ```
      * @include [SetDefaultOperationArg]
      */
     interface KProperties
-
 }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convertTo.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convertTo.kt
index 405078255..e11e8bc0b 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convertTo.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convertTo.kt
@@ -31,6 +31,7 @@ import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
 import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
 import org.jetbrains.kotlinx.dataframe.exceptions.ExcessiveColumnsException
 import org.jetbrains.kotlinx.dataframe.exceptions.TypeConversionException
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.emptyPath
 import org.jetbrains.kotlinx.dataframe.impl.schema.createEmptyColumn
 import org.jetbrains.kotlinx.dataframe.impl.schema.createEmptyDataFrame
@@ -265,8 +266,8 @@ internal fun AnyFrame.convertToImpl(
 
     dsl.fillers.forEach { filler ->
         val paths = result.getColumnPaths(filler.columns)
-        missingPaths.removeAll(paths)
-        result = result.update(paths).with {
+        missingPaths.removeAll(paths.toSet())
+        result = result.update { paths.toColumnSet() }.with {
             filler.expr(this, this)
         }
     }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt
index 5ba0ffaaf..68f50e0e4 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt
@@ -189,7 +189,7 @@ internal fun <C> Array<out KProperty<C>>.toColumns(): ColumnSet<C> = map { it.to
 
 @PublishedApi
 internal fun <T> Array<out ColumnReference<T>>.toColumns(): ColumnSet<T> = asIterable().toColumnSet()
-internal fun Iterable<String>.toColumns() = map { it.toColumnAccessor() }.toColumnSet()
+internal fun Iterable<String>.toColumns(): ColumnSet<Any?> = map { it.toColumnAccessor() }.toColumnSet()
 
 // endregion
 

From f87819e0b7677adb16bb3a71d388fc8c4841eac3 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Sun, 5 Feb 2023 13:26:16 +0100
Subject: [PATCH 14/50] gather.where now uses RowValueFilter instead of
 Predicate, similar to other where-occurrences

---
 .../jetbrains/kotlinx/dataframe/api/gather.kt | 21 ++++++++++++-------
 .../kotlinx/dataframe/impl/api/gather.kt      |  8 +++----
 2 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt
index a65dfcc1f..c65604ae1 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt
@@ -2,10 +2,9 @@ package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.Predicate
+import org.jetbrains.kotlinx.dataframe.RowValueFilter
 import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
-import org.jetbrains.kotlinx.dataframe.impl.and
 import org.jetbrains.kotlinx.dataframe.impl.api.gatherImpl
 import org.jetbrains.kotlinx.dataframe.impl.columnName
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
@@ -17,11 +16,19 @@ public fun <T, C> DataFrame<T>.gather(selector: ColumnsSelector<T, C>): Gather<T
     this, selector, null, typeOf<String>(),
     { it }, null
 )
-public fun <T> DataFrame<T>.gather(vararg columns: String): Gather<T, Any?, String, Any?> = gather { columns.toColumns() }
-public fun <T, C> DataFrame<T>.gather(vararg columns: ColumnReference<C>): Gather<T, C, String, C> = gather { columns.toColumns() }
-public fun <T, C> DataFrame<T>.gather(vararg columns: KProperty<C>): Gather<T, C, String, C> = gather { columns.toColumns() }
 
-public fun <T, C, K, R> Gather<T, C, K, R>.where(filter: Predicate<C>): Gather<T, C, K, R> = copy(filter = this.filter and filter)
+public fun <T> DataFrame<T>.gather(vararg columns: String): Gather<T, Any?, String, Any?> =
+    gather { columns.toColumns() }
+
+public fun <T, C> DataFrame<T>.gather(vararg columns: ColumnReference<C>): Gather<T, C, String, C> =
+    gather { columns.toColumns() }
+
+public fun <T, C> DataFrame<T>.gather(vararg columns: KProperty<C>): Gather<T, C, String, C> =
+    gather { columns.toColumns() }
+
+public fun <T, C, K, R> Gather<T, C, K, R>.where(filter: RowValueFilter<T, C>): Gather<T, C, K, R> =
+    copy(filter = this.filter and filter)
+
 public fun <T, C, K, R> Gather<T, C?, K, R>.notNull(): Gather<T, C, K, R> = where { it != null } as Gather<T, C, K, R>
 
 public fun <T, C, K, R> Gather<T, C, K, R>.explodeLists(): Gather<T, C, K, R> = copy(explode = true)
@@ -35,7 +42,7 @@ public fun <T, C, K, R> Gather<T, C, K, *>.mapValues(transform: (C) -> R): Gathe
 public data class Gather<T, C, K, R>(
     internal val df: DataFrame<T>,
     internal val columns: ColumnsSelector<T, C>,
-    internal val filter: ((C) -> Boolean)? = null,
+    internal val filter: RowValueFilter<T, C>? = null,
     internal val keyType: KType? = null,
     internal val keyTransform: ((String) -> K),
     internal val valueTransform: ((C) -> R)? = null,
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/gather.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/gather.kt
index af046e5ef..4844853dd 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/gather.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/gather.kt
@@ -60,9 +60,9 @@ internal fun <T, C, K, R> Gather<T, C, K, R>.gatherImpl(
         }
 
         // explode keys and values
-        when {
-            keysColumn != null && valuesColumn != null -> df = df.explode(keysColumn, valuesColumn)
-            else -> df = df.explode(keysColumn ?: valuesColumn!!)
+        df = when {
+            keysColumn != null && valuesColumn != null -> df.explode(keysColumn, valuesColumn)
+            else -> df.explode(keysColumn ?: valuesColumn!!)
         }
 
         // explode values in lists
@@ -76,7 +76,7 @@ internal fun <T, C, K, R> Gather<T, C, K, R>.gatherImpl(
                 val value = col[row]
                 when {
                     explode && value is List<*> -> {
-                        val filtered = (value as List<C>).filter(filter)
+                        val filtered = (value as List<C>).filter { filter(it) }
                         val transformed = valueTransform?.let { filtered.map(it) } ?: filtered
                         keys[colIndex] to transformed
                     }

From 005e11d58d1d4330c7a10fa3a3ce1da75ba4ed0f Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Sun, 5 Feb 2023 18:28:56 +0100
Subject: [PATCH 15/50] wip update documentation

---
 core/build.gradle.kts                         |  4 +-
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  |  4 +-
 .../jetbrains/kotlinx/dataframe/api/update.kt | 70 +++++++++++--------
 .../documentation/DocumentationUrls.kt        | 34 ++++++---
 ...LevelOperations.kt => SelectingColumns.kt} | 35 +++++-----
 .../dataframe/documentation/SelectingRows.kt  | 47 +++++++++++++
 6 files changed, 135 insertions(+), 59 deletions(-)
 rename core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/{HighLevelOperations.kt => SelectingColumns.kt} (78%)
 create mode 100644 core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 3ac6a0e85..4135f0e4f 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -14,8 +14,8 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.11"
-//    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
+//    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.11"
+    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
 }
 
 group = "org.jetbrains.kotlinx"
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index 0d17a890d..44f1de548 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -33,7 +33,7 @@ internal interface FillNulls {
     interface Usage
 }
 
-/** {@arg [OperationArg] fillNulls} */
+/** {@arg [OperationArg] [fillNulls][fillNulls]} */
 internal interface SetFillNullsOperationArg
 
 /**
@@ -119,7 +119,7 @@ internal interface FillNaNs {
     interface Usage
 }
 
-/** {@arg [OperationArg] fillNaNs} */
+/** {@arg [OperationArg] [fillNaNs][fillNaNs]} */
 internal interface SetFillNaNsOperationArg
 
 /**
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index 668a1d077..0d32ef3ab 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -22,11 +22,12 @@ import org.jetbrains.kotlinx.dataframe.index
 import kotlin.reflect.KProperty
 
 /**
+ * ## The Update Operation
+ *
  * Returns the [DataFrame] with changed values in some cells
  * (column types can not be changed).
  *
- * Check out [how to use `update`][Usage].
- *
+ * Check out [how to use the update operation fully][Usage].
  * For more information: {@include [DocumentationUrls.Update]}
  */
 public data class Update<T, C>(
@@ -37,29 +38,38 @@ public data class Update<T, C>(
     public fun <R : C> cast(): Update<T, R> =
         Update(df, filter as RowValueFilter<T, R>?, columns as ColumnsSelector<T, R>)
 
+    /** This argument providing the (clickable) name of the update-like function.
+     * Note: If clickable, make sure to [alias][your type].
+     */
     internal interface UpdateOperationArg
 
     /**
      * {@includeArg [UpdateOperationArg]} operation usage:
      * ___
-     * {@includeArg [UpdateOperationArg]} { [columns][Columns] }
+     * {@includeArg [UpdateOperationArg]} `{ `[columns][Columns]` }`
      *
-     * - [.[where] { [rowCondition][Where.Predicate] } ]
+     * - `[.`[where][where]` { `[rowCondition][SelectingRows.RowValueCondition]` } ]`
      *
-     * - [.[at] ([rowIndices][At.RowIndices]) ]
+     * - `[.`[at][at]` (`[rowIndices][At.RowIndices]`) ]`
      *
-     * - .[with] { [rowExpression][With.Expression] } | .[notNull] { rowExpression } | .[perCol] { colExpression } | .[perRowCol] { rowColExpression } | .[withValue] (value) | .[withNull] () | .[withZero] () | .[asFrame] { frameExpression }
+     * - `.`[with][with]` { `[rowExpression][With.Expression]` }
+     *   | .`[notNull][notNull]` { rowExpression }
+     *   | .`[perCol][perCol]` { colExpression }
+     *   | .`[perRowCol][perRowCol]` { rowColExpression }
+     *   | .`[withValue][withValue]`(value) | .`[withNull]`()
+     *   | .`[withZero][withZero]`()
+     *   | .`[asFrame][asFrame]` { frameExpression }`
      *
      * {@comment TODO
      * rowExpression: DataRow.(OldValue) -> NewValue
      * colExpression: DataColumn.(DataColumn) -> NewValue
      * rowColExpression: DataRow.(DataColumn) -> NewValue
      * frameExpression: DataFrame.(DataFrame) -> DataFrame}
-     * {@arg [UpdateOperationArg] [update]}
+     * {@arg [UpdateOperationArg] [update][update]}
      */
     internal interface Usage
 
-    /** Select the columns to update. See {@include [SelectingColumnsLink]}. */
+    /** Select the columns to update. See {@include [SelectingColumnsLink]} for all the options. */
     internal interface Columns
 
     /** @param columns The [ColumnsSelector] used to select the columns of this [DataFrame] to update. */
@@ -74,22 +84,6 @@ public data class Update<T, C>(
     /** @param columns The column names belonging to this [DataFrame] to update. */
     internal interface ColumnNamesParam
 
-    /**
-     * Only update the columns that pass a certain [predicate][Update.Where.Predicate].
-     *
-     * For example:
-     * ```kotlin
-     * df.update { city }.where { name.firstName == "Alice" }.withValue("Paris")
-     * ```
-     */
-    internal interface Where {
-
-        /** The condition for rows to be included. A filter if you will.
-         *
-         * Can be seen as [DataRow].(oldValue: [C]) -> [Boolean] */
-        interface Predicate
-    }
-
     /**
      * Only update the columns at certain given [row indices][Update.At.RowIndices]:
      *
@@ -119,19 +113,23 @@ public data class Update<T, C>(
         /** The expression to update the selected columns with.
          *
          * Can be seen as [DataRow].(oldValue: [C]) -> newValue: [C]?
-         * */
+         */
         interface Expression
     }
 }
 
 // region update
 
-/** {@arg [OperationArg] update} */
+/** {@arg [OperationArg] [update][update]} */
 internal interface SetUpdateOperationArg
 
 /**
  * @include [Update]
  *
+ * @include [Update.Columns]
+ *
+ * ## This overload:
+ *
  * @include [SelectingColumns.Dsl] {@include [SetUpdateOperationArg]}
  * @include [Update.DslParam]
  */
@@ -141,6 +139,10 @@ public fun <T, C> DataFrame<T>.update(columns: ColumnsSelector<T, C>): Update<T,
 /**
  * @include [Update]
  *
+ * @include [Update.Columns]
+ *
+ * ## This overload:
+ *
  * @include [SelectingColumns.ColumnNames] {@include [SetUpdateOperationArg]}
  * @include [Update.ColumnNamesParam]
  */
@@ -149,6 +151,10 @@ public fun <T> DataFrame<T>.update(vararg columns: String): Update<T, Any?> = up
 /**
  * @include [Update]
  *
+ * @include [Update.Columns]
+ *
+ * ## This overload:
+ *
  * @include [SelectingColumns.KProperties] {@include [SetUpdateOperationArg]}
  * @include [Update.KPropertiesParam]
  */
@@ -157,6 +163,10 @@ public fun <T, C> DataFrame<T>.update(vararg columns: KProperty<C>): Update<T, C
 /**
  * @include [Update]
  *
+ * @include [Update.Columns]
+ *
+ * ## This overload:
+ *
  * @include [SelectingColumns.ColumnAccessors] {@include [SetUpdateOperationArg]}
  * @include [Update.ColumnAccessorsParam]
  */
@@ -166,6 +176,10 @@ public fun <T, C> DataFrame<T>.update(vararg columns: ColumnReference<C>): Updat
 /**
  * @include [Update]
  *
+ * @include [Update.Columns]
+ *
+ * ## This overload:
+ *
  * @include [SelectingColumns.ColumnAccessors] {@include [SetUpdateOperationArg]}
  * @include [Update.ColumnAccessorsParam]
  */
@@ -175,9 +189,9 @@ public fun <T, C> DataFrame<T>.update(columns: Iterable<ColumnReference<C>>): Up
 // endregion
 
 /**
- * @include [Update.Where]
+ * @include [SelectingRows.RowValueCondition] {@include [SetUpdateOperationArg]}
  *
- * @param predicate {@include [Update.Where.Predicate]}
+ * @param predicate The [row value filter][RowValueFilter] to select the rows to update.
  */
 public fun <T, C> Update<T, C>.where(predicate: RowValueFilter<T, C>): Update<T, C> =
     copy(filter = filter and predicate)
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
index 7ab0acb26..b448ec1fe 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
@@ -2,35 +2,49 @@ package org.jetbrains.kotlinx.dataframe.documentation
 
 private interface DocumentationUrls {
 
-    /** [See `update` documentation.](https://kotlin.github.io/dataframe/update.html) */
+    interface NameArg
+
+    /** See {@includeArg [NameArg]} on the documentation website. */
+    interface Text
+
+    interface DataRow {
+
+        /** [{@include [Text]}{@arg [NameArg] Row Expressions}](https://kotlin.github.io/dataframe/datarow.html#row-expressions) */
+        interface RowExpressions
+
+        /** [{@include [Text]}{@arg [NameArg] Row Conditions}](https://kotlin.github.io/dataframe/datarow.html#row-conditions) */
+        interface RowConditions
+    }
+
+    /** [{@include [Text]}{@arg [NameArg] `update`}](https://kotlin.github.io/dataframe/update.html) */
     interface Update
 
-    /** [See `fill` documentation.](https://kotlin.github.io/dataframe/fill.html) */
+    /** [{@include [Text]}{@arg [NameArg] `fill`}](https://kotlin.github.io/dataframe/fill.html) */
     interface Fill {
 
-        /** [See `fillNulls` documentation.](https://kotlin.github.io/dataframe/fill.html#fillnulls) */
+        /** [{@include [Text]}{@arg [NameArg] `fillNulls`}](https://kotlin.github.io/dataframe/fill.html#fillnulls) */
         interface FillNulls
 
-        /** [See `fillNaNs` documentation.](https://kotlin.github.io/dataframe/fill.html#fillnans) */
+        /** [{@include [Text]}{@arg [NameArg] `fillNaNs`}](https://kotlin.github.io/dataframe/fill.html#fillnans) */
         interface FillNaNs
 
-        /** [See `fillNA` documentation.](https://kotlin.github.io/dataframe/fill.html#fillna) */
+        /** [{@include [Text]}{@arg [NameArg] `fillNA`}](https://kotlin.github.io/dataframe/fill.html#fillna) */
         interface FillNA
     }
 
-    /** [See Access APIs documentation.](https://kotlin.github.io/dataframe/apilevels.html) */
+    /** [{@include [Text]}{@arg [NameArg] Access APIs}](https://kotlin.github.io/dataframe/apilevels.html) */
     interface AccessApis {
 
-        /** [See String API documentation.](https://kotlin.github.io/dataframe/stringapi.html) */
+        /** [{@include [Text]}{@arg [NameArg] String API}](https://kotlin.github.io/dataframe/stringapi.html) */
         interface StringApi
 
-        /** [See Column Accessors API documentation.](https://kotlin.github.io/dataframe/columnaccessorsapi.html) */
+        /** [{@include [Text]}{@arg [NameArg] Column Accessors API}](https://kotlin.github.io/dataframe/columnaccessorsapi.html) */
         interface ColumnAccessorsApi
 
-        /** [See KProperties API documentation.](https://kotlin.github.io/dataframe/kpropertiesapi.html) */
+        /** [{@include [Text]}{@arg [NameArg] KProperties API}](https://kotlin.github.io/dataframe/kpropertiesapi.html) */
         interface KPropertiesApi
 
-        /** [See Extension Properties API documentation.](https://kotlin.github.io/dataframe/extensionpropertiesapi.html) */
+        /** [{@include [Text]}{@arg [NameArg] Extension Properties API}](https://kotlin.github.io/dataframe/extensionpropertiesapi.html) */
         interface ExtensionPropertiesApi
     }
 }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/HighLevelOperations.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
similarity index 78%
rename from core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/HighLevelOperations.kt
rename to core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
index 00f52803f..2dcc75786 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/HighLevelOperations.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
@@ -12,7 +12,6 @@ import kotlin.reflect.KProperty
  * }
  */
 
-
 /** The key for an @arg that will define the operation name for the examples below. */
 internal interface OperationArg
 
@@ -29,7 +28,7 @@ internal interface SelectingColumnsLink
  */
 internal interface SelectingColumns {
 
-    /** {@arg [OperationArg] <operation>} */
+    /** {@arg [OperationArg] operation} */
     interface SetDefaultOperationArg
 
     /** Select or express columns using the Column(s) Selection DSL.
@@ -40,11 +39,13 @@ internal interface SelectingColumns {
      * expect you to return a [SingleColumn] or [ColumnSet], respectively.
      *
      * For example:
-     * ```kotlin
-     * df.{@includeArg [OperationArg]} { length and age }
-     * df.{@includeArg [OperationArg]} { cols(1..5) }
-     * df.{@includeArg [OperationArg]} { colsOf<Double>() }
-     * ```
+     *
+     * `df.`{@includeArg [OperationArg]}` { length `[and][ColumnsSelectionDsl.and]` age }`
+     *
+     * `df.`{@includeArg [OperationArg]}` { `[cols][ColumnsSelectionDsl.cols]`(1..5) }`
+     *
+     * `df.`{@includeArg [OperationArg]}` { `[colsOf][colsOf]`<Double>() }`
+     *
      * @include [SetDefaultOperationArg]
      */
     interface Dsl
@@ -53,9 +54,8 @@ internal interface SelectingColumns {
      * ({@include [AccessApi.StringApiLink]}).
      *
      * For example:
-     * ```kotlin
-     * df.{@includeArg [OperationArg]}("length", "age")
-     * ```
+     *
+     * `df.`{@includeArg [OperationArg]}`("length", "age")`
      * @include [SetDefaultOperationArg]
      */
     interface ColumnNames
@@ -64,11 +64,13 @@ internal interface SelectingColumns {
      * ({@include [AccessApi.ColumnAccessorsApiLink]}).
      *
      * For example:
-     * ```kotlin
-     * val length by column<Double>()
-     * val age by column<Double>()
-     * df.{@includeArg [OperationArg]}(length, age)
-     * ```
+     *
+     * `val length by `[column]`<Double>()`
+     *
+     * `val age by `[column]`<Double>()`
+     *
+     * `df.`{@includeArg [OperationArg]}`(length, age)`
+     *
      * @include [SetDefaultOperationArg]
      */
     interface ColumnAccessors
@@ -79,9 +81,8 @@ internal interface SelectingColumns {
      * For example:
      * ```kotlin
      * data class Person(val length: Double, val age: Double)
-     *
-     * df.{@includeArg [OperationArg]}(Person::length, Person::age)
      * ```
+     * `df.`{@includeArg [OperationArg]}`(Person::length, Person::age)`
      * @include [SetDefaultOperationArg]
      */
     interface KProperties
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
new file mode 100644
index 000000000..fbb66ffd2
--- /dev/null
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
@@ -0,0 +1,47 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.api.*
+
+/**
+ * Selecting rows that satisfy a "Row Condition" ({@include [DocumentationUrls.DataRow.RowConditions]})
+ * can occur in the following two types of operations:
+ * - Selecting entire rows ({@include [RowConditionLink]}), for instance in [filter], [drop], [first], and [count].
+ * - Selecting parts of rows using a `where` operation after selecting columns ({@include [RowValueConditionLink]}),
+ * such as with [update], [gather], and [format] ([RowValueFilter]).
+ * {@comment TODO Is where present everywhere it should be?}
+ */
+internal interface SelectingRows {
+
+    /** {@arg [OperationArg] <operation>} */
+    interface SetDefaultOperationArg
+
+    /** [Entire-Row Condition][EntireRowCondition] */
+    interface RowConditionLink
+
+    /** Filter or find rows to operate on using a [row filter][RowFilter].
+     *
+     * For example:
+     *
+     * `df.`{@includeArg [OperationArg]}` { `[index][index]`() % 2 == 0 }`
+     *
+     * `df.`{@includeArg [OperationArg]}` { `[diff][diff]` { age } == 0 }`
+     */
+    interface EntireRowCondition
+
+    /** [Row-Value Condition][RowValueCondition] */
+    interface RowValueConditionLink
+
+    /** Filter or find rows to operate on after [selecting columns][SelectingColumns] using a
+     * [row value filter][RowValueFilter].
+     *
+     * For example:
+     *
+     * `df.`{@includeArg [OperationArg]}` { length }.`[where][where]` { it > 10.0 }`
+     *
+     * `df.`{@includeArg [OperationArg]}` { `[cols][ColumnsSelectionDsl.cols]`(1..5) }.`[where][where]` { `[index][index]`() > 4 && city != "Paris" }`
+     *
+     * @include [SetDefaultOperationArg]
+     */
+    interface RowValueCondition
+}

From 1db9d70052c09aa83ed808e1c5961e051679722b Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Tue, 7 Feb 2023 14:46:56 +0100
Subject: [PATCH 16/50] working on docs, found bug in kdoc highlighting

---
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  |  2 +-
 .../jetbrains/kotlinx/dataframe/api/update.kt | 66 +++++++------------
 .../documentation/SelectingColumns.kt         |  2 +-
 .../dataframe/documentation/SelectingRows.kt  |  2 +-
 4 files changed, 28 insertions(+), 44 deletions(-)

diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index 44f1de548..3821af2d0 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -29,7 +29,7 @@ import kotlin.reflect.KProperty
  */
 internal interface FillNulls {
 
-    /** @include [Update.Usage] {@arg [Update.UpdateOperationArg] [fillNulls]} */
+    /** @include [Update.Usage] {@arg [Update.UpdateOperationArg] [fillNulls][fillNulls]} */
     interface Usage
 }
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index 0d32ef3ab..acf6232d4 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -27,7 +27,7 @@ import kotlin.reflect.KProperty
  * Returns the [DataFrame] with changed values in some cells
  * (column types can not be changed).
  *
- * Check out [how to use the update operation fully][Usage].
+ * Check out the [Update Operation Usage][Usage].
  * For more information: {@include [DocumentationUrls.Update]}
  */
 public data class Update<T, C>(
@@ -44,21 +44,22 @@ public data class Update<T, C>(
     internal interface UpdateOperationArg
 
     /**
-     * {@includeArg [UpdateOperationArg]} operation usage:
-     * ___
+     * ## {@includeArg [UpdateOperationArg]} Operation Usage
+     *
      * {@includeArg [UpdateOperationArg]} `{ `[columns][Columns]` }`
      *
-     * - `[.`[where][where]` { `[rowCondition][SelectingRows.RowValueCondition]` } ]`
+     * - `[.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { `[rowCondition][SelectingRows.RowValueCondition]` } ]`
      *
-     * - `[.`[at][at]` (`[rowIndices][At.RowIndices]`) ]`
+     * - `[.`[at][org.jetbrains.kotlinx.dataframe.api.Update.at]` (`[rowIndices][At.RowIndices]`) ]`
      *
-     * - `.`[with][with]` { `[rowExpression][With.Expression]` }
-     *   | .`[notNull][notNull]` { rowExpression }
-     *   | .`[perCol][perCol]` { colExpression }
-     *   | .`[perRowCol][perRowCol]` { rowColExpression }
-     *   | .`[withValue][withValue]`(value) | .`[withNull]`()
-     *   | .`[withZero][withZero]`()
-     *   | .`[asFrame][asFrame]` { frameExpression }`
+     * - `.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { `[rowExpression][With.Expression]` }
+     *   | .`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { rowExpression }
+     *   | .`[perCol][org.jetbrains.kotlinx.dataframe.api.Update.perCol]` { colExpression }
+     *   | .`[perRowCol][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol]` { rowColExpression }
+     *   | .`[withValue][org.jetbrains.kotlinx.dataframe.api.Update.withValue]`(value)
+     *   | .`[withNull][org.jetbrains.kotlinx.dataframe.api.Update.withNull]`()
+     *   | .`[withZero][org.jetbrains.kotlinx.dataframe.api.Update.withZero]`()
+     *   | .`[asFrame][org.jetbrains.kotlinx.dataframe.api.Update.asFrame]` { frameExpression }`
      *
      * {@comment TODO
      * rowExpression: DataRow.(OldValue) -> NewValue
@@ -124,12 +125,15 @@ public data class Update<T, C>(
 internal interface SetUpdateOperationArg
 
 /**
- * @include [Update]
- *
- * @include [Update.Columns]
- *
- * ## This overload:
+ * @include [Update] {@comment Description of the update operation.}
  *
+ * @include [Update.Columns] {@comment Description of what this function expects the user to do.}
+ * ## This Update Overload:
+ */
+internal interface CommonUpdateFunctionDoc
+
+/**
+ * @include [CommonUpdateFunctionDoc]
  * @include [SelectingColumns.Dsl] {@include [SetUpdateOperationArg]}
  * @include [Update.DslParam]
  */
@@ -137,36 +141,21 @@ public fun <T, C> DataFrame<T>.update(columns: ColumnsSelector<T, C>): Update<T,
     Update(this, null, columns)
 
 /**
- * @include [Update]
- *
- * @include [Update.Columns]
- *
- * ## This overload:
- *
+ * @include [CommonUpdateFunctionDoc]
  * @include [SelectingColumns.ColumnNames] {@include [SetUpdateOperationArg]}
  * @include [Update.ColumnNamesParam]
  */
 public fun <T> DataFrame<T>.update(vararg columns: String): Update<T, Any?> = update { columns.toColumns() }
 
 /**
- * @include [Update]
- *
- * @include [Update.Columns]
- *
- * ## This overload:
- *
+ * @include [CommonUpdateFunctionDoc]
  * @include [SelectingColumns.KProperties] {@include [SetUpdateOperationArg]}
  * @include [Update.KPropertiesParam]
  */
 public fun <T, C> DataFrame<T>.update(vararg columns: KProperty<C>): Update<T, C> = update { columns.toColumns() }
 
 /**
- * @include [Update]
- *
- * @include [Update.Columns]
- *
- * ## This overload:
- *
+ * @include [CommonUpdateFunctionDoc]
  * @include [SelectingColumns.ColumnAccessors] {@include [SetUpdateOperationArg]}
  * @include [Update.ColumnAccessorsParam]
  */
@@ -174,12 +163,7 @@ public fun <T, C> DataFrame<T>.update(vararg columns: ColumnReference<C>): Updat
     update { columns.toColumns() }
 
 /**
- * @include [Update]
- *
- * @include [Update.Columns]
- *
- * ## This overload:
- *
+ * @include [CommonUpdateFunctionDoc]
  * @include [SelectingColumns.ColumnAccessors] {@include [SetUpdateOperationArg]}
  * @include [Update.ColumnAccessorsParam]
  */
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
index 2dcc75786..78462658a 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
@@ -34,7 +34,7 @@ internal interface SelectingColumns {
     /** Select or express columns using the Column(s) Selection DSL.
      * (Any {@include [AccessApiLink]}).
      *
-     * The DSL comes in the form of either a [ColumnSelector]- or [ColumnsSelector] lambda,
+     * This DSL comes in the form of either a [Column Selector][ColumnSelector]- or [Columns Selector][ColumnsSelector] lambda,
      * which operate in the {@include [ColumnSelectionDslLink]} or the {@include [ColumnsSelectionDslLink]} and
      * expect you to return a [SingleColumn] or [ColumnSet], respectively.
      *
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
index fbb66ffd2..29c62b755 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
@@ -9,7 +9,7 @@ import org.jetbrains.kotlinx.dataframe.api.*
  * - Selecting entire rows ({@include [RowConditionLink]}), for instance in [filter], [drop], [first], and [count].
  * - Selecting parts of rows using a `where` operation after selecting columns ({@include [RowValueConditionLink]}),
  * such as with [update], [gather], and [format] ([RowValueFilter]).
- * {@comment TODO Is where present everywhere it should be?}
+ * {@comment TODO Is `where` present everywhere it should be?}
  */
 internal interface SelectingRows {
 

From a7a4b1b00e8279f58107f0f935b9f75e8915c0b1 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Wed, 8 Feb 2023 16:09:54 +0100
Subject: [PATCH 17/50] row expressions and updating docs

---
 core/build.gradle.kts                         |   4 +-
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  |   9 +-
 .../jetbrains/kotlinx/dataframe/api/add.kt    |  11 +-
 .../jetbrains/kotlinx/dataframe/api/update.kt | 163 +++++++++++-------
 .../dataframe/documentation/RowCondition.kt   |  69 ++++++++
 .../dataframe/documentation/RowExpressions.kt |  82 +++++++++
 .../documentation/SelectingColumns.kt         |   9 +-
 .../dataframe/documentation/SelectingRows.kt  |  47 -----
 8 files changed, 280 insertions(+), 114 deletions(-)
 create mode 100644 core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowCondition.kt
 create mode 100644 core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowExpressions.kt
 delete mode 100644 core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 4135f0e4f..a0372c9f8 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -14,8 +14,8 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-//    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.11"
-    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
+    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.13"
+//    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
 }
 
 group = "org.jetbrains.kotlinx"
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index 3821af2d0..5bd6c86e1 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -7,7 +7,7 @@ import org.jetbrains.kotlinx.dataframe.AnyRow
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.api.Update.Usage
+import org.jetbrains.kotlinx.dataframe.api.Update.UpdateOperationArg
 import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.documentation.*
@@ -29,11 +29,14 @@ import kotlin.reflect.KProperty
  */
 internal interface FillNulls {
 
-    /** @include [Update.Usage] {@arg [Update.UpdateOperationArg] [fillNulls][fillNulls]} */
+    /** @include [Update.Usage]
+     * {@arg [UpdateOperationArg] [fillNulls][fillNulls]}
+     * {@arg [RowCondition.FirstOperationArg] [fillNulls][fillNulls]}
+     * {@arg [RowExpressions.OperationArg] [fillNulls][fillNulls]} */
     interface Usage
 }
 
-/** {@arg [OperationArg] [fillNulls][fillNulls]} */
+/** {@arg [SelectingColumns.OperationArg] [fillNulls][fillNulls]} */
 internal interface SetFillNullsOperationArg
 
 /**
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
index 4b045a455..2a9375869 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
@@ -98,7 +98,16 @@ public interface AddDataRow<out T> : DataRow<T> {
     public fun <C> AnyRow.newValue(): C
 }
 
-public typealias AddExpression<T, C> = Selector<AddDataRow<T>, C>
+/**
+ * [AddExpression] is used to express or select any instance of `R` using the given instance of [AddDataRow]`<T>` as
+ * `this` and `it`.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * AddDataRow<T>.(it: AddDataRow<T>) -> R
+ * ```
+ */
+public typealias AddExpression<T, R> = Selector<AddDataRow<T>, R>
 
 /**
  * Creates new column using row [expression] and adds it to the end of [DataFrame]
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index acf6232d4..fb5d9c34d 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -48,12 +48,12 @@ public data class Update<T, C>(
      *
      * {@includeArg [UpdateOperationArg]} `{ `[columns][Columns]` }`
      *
-     * - `[.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { `[rowCondition][SelectingRows.RowValueCondition]` } ]`
+     * - `[.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { `[rowValueCondition][RowCondition.RowValueCondition]` } ]`
      *
      * - `[.`[at][org.jetbrains.kotlinx.dataframe.api.Update.at]` (`[rowIndices][At.RowIndices]`) ]`
      *
-     * - `.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { `[rowExpression][With.Expression]` }
-     *   | .`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { rowExpression }
+     * - `.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { `[rowExpression][RowExpressions.RowValueExpression]` }
+     *   | .`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { `[rowExpression][RowExpressions.RowValueExpression]` }
      *   | .`[perCol][org.jetbrains.kotlinx.dataframe.api.Update.perCol]` { colExpression }
      *   | .`[perRowCol][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol]` { rowColExpression }
      *   | .`[withValue][org.jetbrains.kotlinx.dataframe.api.Update.withValue]`(value)
@@ -62,7 +62,6 @@ public data class Update<T, C>(
      *   | .`[asFrame][org.jetbrains.kotlinx.dataframe.api.Update.asFrame]` { frameExpression }`
      *
      * {@comment TODO
-     * rowExpression: DataRow.(OldValue) -> NewValue
      * colExpression: DataColumn.(DataColumn) -> NewValue
      * rowColExpression: DataRow.(DataColumn) -> NewValue
      * frameExpression: DataFrame.(DataFrame) -> DataFrame}
@@ -84,57 +83,24 @@ public data class Update<T, C>(
 
     /** @param columns The column names belonging to this [DataFrame] to update. */
     internal interface ColumnNamesParam
-
-    /**
-     * Only update the columns at certain given [row indices][Update.At.RowIndices]:
-     *
-     * Either a [Collection]<[Int]>, an [IntRange], or just `vararg` indices.
-     *
-     * For example:
-     * ```kotlin
-     * df.update { city }.at(5..10).withValue("Paris")
-     * ```
-     */
-    internal interface At {
-
-        /** The indices of the rows to update. */
-        interface RowIndices
-    }
-
-    /**
-     * Update the selected columns using the given [expression][With.Expression].
-     *
-     * For example:
-     * ```kotlin
-     * df.update { city }.with { name.firstName + " from " + it }
-     * ```
-     */
-    internal interface With {
-
-        /** The expression to update the selected columns with.
-         *
-         * Can be seen as [DataRow].(oldValue: [C]) -> newValue: [C]?
-         */
-        interface Expression
-    }
 }
 
 // region update
 
-/** {@arg [OperationArg] [update][update]} */
-internal interface SetUpdateOperationArg
+/** {@arg [SelectingColumns.OperationArg] [update][update]} */
+private interface SetSelectingColumnsOperationArg
 
 /**
  * @include [Update] {@comment Description of the update operation.}
  *
  * @include [Update.Columns] {@comment Description of what this function expects the user to do.}
- * ## This Update Overload:
+ * ## This Update Overload
  */
 internal interface CommonUpdateFunctionDoc
 
 /**
  * @include [CommonUpdateFunctionDoc]
- * @include [SelectingColumns.Dsl] {@include [SetUpdateOperationArg]}
+ * @include [SelectingColumns.Dsl] {@include [SetSelectingColumnsOperationArg]}
  * @include [Update.DslParam]
  */
 public fun <T, C> DataFrame<T>.update(columns: ColumnsSelector<T, C>): Update<T, C> =
@@ -142,21 +108,21 @@ public fun <T, C> DataFrame<T>.update(columns: ColumnsSelector<T, C>): Update<T,
 
 /**
  * @include [CommonUpdateFunctionDoc]
- * @include [SelectingColumns.ColumnNames] {@include [SetUpdateOperationArg]}
+ * @include [SelectingColumns.ColumnNames] {@include [SetSelectingColumnsOperationArg]}
  * @include [Update.ColumnNamesParam]
  */
 public fun <T> DataFrame<T>.update(vararg columns: String): Update<T, Any?> = update { columns.toColumns() }
 
 /**
  * @include [CommonUpdateFunctionDoc]
- * @include [SelectingColumns.KProperties] {@include [SetUpdateOperationArg]}
+ * @include [SelectingColumns.KProperties] {@include [SetSelectingColumnsOperationArg]}
  * @include [Update.KPropertiesParam]
  */
 public fun <T, C> DataFrame<T>.update(vararg columns: KProperty<C>): Update<T, C> = update { columns.toColumns() }
 
 /**
  * @include [CommonUpdateFunctionDoc]
- * @include [SelectingColumns.ColumnAccessors] {@include [SetUpdateOperationArg]}
+ * @include [SelectingColumns.ColumnAccessors] {@include [SetSelectingColumnsOperationArg]}
  * @include [Update.ColumnAccessorsParam]
  */
 public fun <T, C> DataFrame<T>.update(vararg columns: ColumnReference<C>): Update<T, C> =
@@ -164,7 +130,7 @@ public fun <T, C> DataFrame<T>.update(vararg columns: ColumnReference<C>): Updat
 
 /**
  * @include [CommonUpdateFunctionDoc]
- * @include [SelectingColumns.ColumnAccessors] {@include [SetUpdateOperationArg]}
+ * @include [SelectingColumns.ColumnAccessors] {@include [SetSelectingColumnsOperationArg]}
  * @include [Update.ColumnAccessorsParam]
  */
 public fun <T, C> DataFrame<T>.update(columns: Iterable<ColumnReference<C>>): Update<T, C> =
@@ -172,78 +138,121 @@ public fun <T, C> DataFrame<T>.update(columns: Iterable<ColumnReference<C>>): Up
 
 // endregion
 
-/**
- * @include [SelectingRows.RowValueCondition] {@include [SetUpdateOperationArg]}
+/** ## Where
+ * @include [RowCondition.RowValueCondition]
+ * {@arg [RowCondition.FirstOperationArg] [update][update]}
+ * {@arg [RowCondition.SecondOperationArg] [where][where]}
  *
  * @param predicate The [row value filter][RowValueFilter] to select the rows to update.
  */
 public fun <T, C> Update<T, C>.where(predicate: RowValueFilter<T, C>): Update<T, C> =
     copy(filter = filter and predicate)
 
+/** ## At
+ * Only update the columns at certain given [row indices][CommonUpdateAtFunctionDoc.RowIndicesParam]:
+ *
+ * Either a [Collection]<[Int]>, an [IntRange], or just `vararg` indices.
+ *
+ * For example:
+ *
+ * `df.`[update][update]` { city }.`[at][at]`(5..10).`[with][with]` { "Paris" }`
+ *
+ * `df.`[update][update]` { name }.`[at][at]`(1, 2, 3, 4).`[with][with]` { "Empty" }`
+ *
+ * ## This At Overload
+ */
+private interface CommonUpdateAtFunctionDoc {
+
+    /** The indices of the rows to update. */
+    interface RowIndicesParam
+}
+
 /**
- * @include [Update.At]
+ * @include [CommonUpdateAtFunctionDoc]
+ *
+ * Provide a [Collection]<[Int]> of row indices to update.
  *
- * @param rowIndices {@include [Update.At.RowIndices]}
+ * @param rowIndices {@include [CommonUpdateAtFunctionDoc.RowIndicesParam]}
  */
 public fun <T, C> Update<T, C>.at(rowIndices: Collection<Int>): Update<T, C> = where { index in rowIndices }
 
 /**
- * @include [Update.At]
+ * @include [CommonUpdateAtFunctionDoc]
  *
- * @param rowIndices {@include [Update.At.RowIndices]}
+ * Provide a `vararg` of [Ints][Int] of row indices to update.
+ *
+ * @param rowIndices {@include [CommonUpdateAtFunctionDoc.RowIndicesParam]}
  */
 public fun <T, C> Update<T, C>.at(vararg rowIndices: Int): Update<T, C> = at(rowIndices.toSet())
 
 /**
- * @include [Update.At]
+ * @include [CommonUpdateAtFunctionDoc]
+ *
+ * Provide an [IntRange] of row indices to update.
  *
- * @param rowRange {@include [Update.At.RowIndices]}
+ * @param rowRange {@include [CommonUpdateAtFunctionDoc.RowIndicesParam]}
  */
 public fun <T, C> Update<T, C>.at(rowRange: IntRange): Update<T, C> = where { index in rowRange }
 
+/** TODO */
 public infix fun <T, C> Update<T, C>.perRowCol(expression: RowColumnExpression<T, C, C>): DataFrame<T> =
     updateImpl { row, column, _ -> expression(row, column) }
 
 public typealias UpdateExpression<T, C, R> = AddDataRow<T>.(C) -> R
 
-/**
- * @include [Update.With]
+/** ## With
+ * {@include [RowExpressions.RowValueExpression]}
+ * {@arg [RowExpressions.OperationArg] [update][update]` { city \}.`[with][with]}
  *
- * @param expression {@include [Update.With.Expression]}
+ * ## Note
+ * @include [RowExpressions.AddDataRowNote]
+ * @param expression The {@include [RowExpressions.RowValueExpressionLink]} to update the rows with.
  */
 public infix fun <T, C> Update<T, C>.with(expression: UpdateExpression<T, C, C?>): DataFrame<T> =
     updateImpl { row, _, value ->
         expression(row, value)
     }
 
+/** TODO */
 public infix fun <T, C, R> Update<T, DataRow<C>>.asFrame(expression: DataFrameExpression<C, DataFrame<R>>): DataFrame<T> =
     df.replace(columns).with { it.asColumnGroup().let { expression(it, it) }.asColumnGroup(it.name()) }
 
+@Deprecated(
+    "Useless unless in combination with `withValue(null)`, but then users can just use `with { null }`...",
+    ReplaceWith("this as Update<T, C?>")
+)
 public fun <T, C> Update<T, C>.asNullable(): Update<T, C?> = this as Update<T, C?>
 
+/** TODO */
 public fun <T, C> Update<T, C>.perCol(values: Map<String, C>): DataFrame<T> = updateWithValuePerColumnImpl {
     values[it.name()] ?: throw IllegalArgumentException("Update value for column ${it.name()} is not defined")
 }
 
+/** TODO */
 public fun <T, C> Update<T, C>.perCol(values: AnyRow): DataFrame<T> = perCol(values.toMap() as Map<String, C>)
 
+/** TODO */
 public fun <T, C> Update<T, C>.perCol(valueSelector: Selector<DataColumn<C>, C>): DataFrame<T> =
     updateWithValuePerColumnImpl(valueSelector)
 
+/** TODO */
 internal infix fun <T, C> RowValueFilter<T, C>?.and(other: RowValueFilter<T, C>): RowValueFilter<T, C> {
     if (this == null) return other
     val thisExp = this
     return { thisExp(this, it) && other(this, it) }
 }
 
+/** TODO */
 public fun <T, C> Update<T, C?>.notNull(): Update<T, C> =
     copy(filter = filter and { it != null }) as Update<T, C>
 
+/** TODO */
 public fun <T, C> Update<T, C?>.notNull(expression: RowValueExpression<T, C, C>): DataFrame<T> =
     notNull().updateImpl { row, column, value ->
         expression(row, value)
     }
 
+/** TODO */
 public fun <T, C> DataFrame<T>.update(
     firstCol: ColumnReference<C>,
     vararg cols: ColumnReference<C>,
@@ -251,6 +260,7 @@ public fun <T, C> DataFrame<T>.update(
 ): DataFrame<T> =
     update(*headPlusArray(firstCol, cols)).with(expression)
 
+/** TODO */
 public fun <T, C> DataFrame<T>.update(
     firstCol: KProperty<C>,
     vararg cols: KProperty<C>,
@@ -258,6 +268,7 @@ public fun <T, C> DataFrame<T>.update(
 ): DataFrame<T> =
     update(*headPlusArray(firstCol, cols)).with(expression)
 
+/** TODO */
 public fun <T> DataFrame<T>.update(
     firstCol: String,
     vararg cols: String,
@@ -265,8 +276,44 @@ public fun <T> DataFrame<T>.update(
 ): DataFrame<T> =
     update(*headPlusArray(firstCol, cols)).with(expression)
 
-public fun <T, C> Update<T, C>.withNull(): DataFrame<T> = asNullable().withValue(null)
 
-public fun <T, C> Update<T, C>.withZero(): DataFrame<T> = updateWithValuePerColumnImpl { 0 as C }
+/**
+ * Specific version of [with] that simply sets the value of each selected row to {@includeArg [CommonSpecificWithDocFirstArg]}.
+ *
+ * For example:
+ *
+ * `df.`[update][update]` { id }.`[where][Update.where]` { it < 0 }.`{@includeArg [CommonSpecificWithDocSecondArg]}`
+ */
+private interface CommonSpecificWithDoc
+
+/** Arg for the resulting value */
+private interface CommonSpecificWithDocFirstArg
 
+/** Arg for the function call */
+private interface CommonSpecificWithDocSecondArg
+
+/**
+ * ## With Null
+ * @include [CommonSpecificWithDoc]
+ * {@arg [CommonSpecificWithDocFirstArg] `null`}
+ * {@arg [CommonSpecificWithDocSecondArg] [withNull][withNull]`()}
+ */
+public fun <T, C> Update<T, C>.withNull(): DataFrame<T> = with { null }
+
+/**
+ * ## With Zero
+ * @include [CommonSpecificWithDoc]
+ * {@arg [CommonSpecificWithDocFirstArg] `0`}
+ * {@arg [CommonSpecificWithDocSecondArg] [withZero][withZero]`()}
+ */
+public fun <T, C : Number?> Update<T, C>.withZero(): DataFrame<T> = updateWithValuePerColumnImpl { 0 as C }
+
+/**
+ * ## With Value
+ * @include [CommonSpecificWithDoc]
+ * {@arg [CommonSpecificWithDocFirstArg] [value]}
+ * {@arg [CommonSpecificWithDocSecondArg] [withValue][withValue]`(-1)}
+ *
+ * @param value The value to set the selected rows to. In contrast to [with][Update.with], this must be the same exact type.
+ */
 public infix fun <T, C> Update<T, C>.withValue(value: C): DataFrame<T> = with { value }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowCondition.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowCondition.kt
new file mode 100644
index 000000000..7eeabe4b9
--- /dev/null
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowCondition.kt
@@ -0,0 +1,69 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.api.*
+
+/**
+ * ## Row Condition
+ * Selecting rows that satisfy a "Row Condition" ({@include [DocumentationUrls.DataRow.RowConditions]})
+ * can occur in the following two types of operations:
+ * - Selecting entire rows ({@include [RowConditionLink]}), for instance in [filter], [drop], [first], and [count]
+ * (using [RowFilter]).
+ * - Selecting parts of rows using a `where` operation after selecting columns ({@include [RowValueConditionLink]}),
+ * such as with [update], [gather], and [format]
+ * (using [RowValueFilter]).
+ *
+ * A Row Condition is similar to a {@include [RowExpressionsLink]} but expects a [Boolean] as result.
+ * {@comment TODO Is `where` present everywhere it should be?}
+ */
+internal interface RowCondition {
+
+    /**
+     * The key for an @arg that will define the operation name for the examples below.
+     * Make sure to [alias][your examples].
+     */
+    interface FirstOperationArg
+
+    /**
+     * The key for an @arg that will define the operation name for the examples below.
+     * Make sure to [alias][your examples].
+     */
+    interface SecondOperationArg
+
+    /** {@arg [FirstOperationArg] operation}{@arg [SecondOperationArg] where} */
+    interface SetDefaultOperationArg
+
+    /** [Entire-Row Condition][EntireRowCondition] */
+    interface RowConditionLink
+
+    /** Filter or find rows to operate on using a [row filter][RowFilter].
+     *
+     * For example:
+     *
+     * `df.`{@includeArg [FirstOperationArg]}` { `[index][index]`() % 2 == 0 }`
+     *
+     * `df.`{@includeArg [FirstOperationArg]}` { `[diff][diff]` { age } == 0 }`
+     *
+     * @include [SetDefaultOperationArg]
+     */
+    interface EntireRowCondition
+
+    /** [Row-Value Condition][RowValueCondition] */
+    interface RowValueConditionLink
+
+    /** Filter or find rows to operate on after [selecting columns][SelectingColumns] using a
+     * [row value filter][RowValueFilter].
+     *
+     * For example:
+     *
+     * `df.`{@includeArg [FirstOperationArg]}` { length }.`{@includeArg [SecondOperationArg]}` { it > 10.0 }`
+     *
+     * `df.`{@includeArg [FirstOperationArg]}` { `[cols][ColumnsSelectionDsl.cols]`(1..5) }.`{@includeArg [SecondOperationArg]}` { `[index][index]`() > 4 && city != "Paris" }`
+     *
+     * @include [SetDefaultOperationArg]
+     */
+    interface RowValueCondition
+}
+
+/** [Row Condition][RowCondition] */
+internal interface RowConditionLink
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowExpressions.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowExpressions.kt
new file mode 100644
index 000000000..d8c6cfedd
--- /dev/null
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowExpressions.kt
@@ -0,0 +1,82 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.documentation.RowExpressions.AddDataRowNote
+import org.jetbrains.kotlinx.dataframe.documentation.RowExpressions.RowExpressionLink
+import org.jetbrains.kotlinx.dataframe.documentation.RowExpressions.RowValueExpressionLink
+import org.jetbrains.kotlinx.dataframe.RowExpression as DfRowExpression
+import org.jetbrains.kotlinx.dataframe.RowValueExpression as DfRowValueExpression
+
+/**
+ * ## Row expressions
+ * Expressing values using a "Row Expression" ({@include [DocumentationUrls.DataRow.RowExpressions]})
+ * can occur in the following two types of operations:
+ *
+ * - Providing a new value for every selected row given the row ({@include [RowExpressionLink]}),
+ * for instance in [map][DataFrame.map], [add][DataFrame.add], and [insert][DataFrame.insert]
+ * (using [RowExpression][DfRowExpression]).
+ *
+ * - Providing a new value for every selected row given the row and the previous value ({@include [RowValueExpressionLink]}),
+ * for instance in [update.with][Update.with], and [convert.notNull][Convert.notNull]
+ * (using [RowValueExpression][DfRowValueExpression]).
+ *
+ * Note:
+ * @include [AddDataRowNote]
+ *
+ * A Row Expression is similar to a {@include [RowConditionLink]} but that expects a [Boolean] as result.
+ */
+internal interface RowExpressions {
+
+    /**
+     * The key for an @arg that will define the operation name for the examples below.
+     * Make sure to [alias][your examples].
+     */
+    interface OperationArg
+
+    /** {@arg [OperationArg] operation} */
+    interface SetDefaultOperationArg
+
+    /**
+     * [with][org.jetbrains.kotlinx.dataframe.api.Update.with] and [add][org.jetbrains.kotlinx.dataframe.api.add] use [AddDataRow] instead of [DataRow] as the DSL's receiver type.
+     * This is an extension to [RowValueExpression][DfRowValueExpression] and
+     * [RowExpression][DfRowExpression] that provides access to
+     * the modified/generated value of the preceding row ([AddDataRow.newValue]).
+     */
+    interface AddDataRowNote
+
+    /** Provide a new value for every selected row given the row using a
+     * [row expression][DfRowExpression].
+     *
+     * For example:
+     *
+     * `df.`{@includeArg [OperationArg]}` { name.firstName + " " + name.lastName }`
+     *
+     * `df.`{@includeArg [OperationArg]}` { 2021 - age }`
+     *
+     * @include [SetDefaultOperationArg]
+     */
+    interface RowExpression
+
+    /** [Row Expression][RowExpression] */
+    interface RowExpressionLink
+
+    /** Provide a new value for every selected row given the row and the previous value using a
+     * [row value expression][DfRowValueExpression].
+     *
+     * For example:
+     *
+     * `df.`{@includeArg [OperationArg]}` { name.firstName + " from " + it }`
+     *
+     * `df.`{@includeArg [OperationArg]}` { it.uppercase() }`
+     * {@include [SetDefaultOperationArg]}
+     */
+    interface RowValueExpression
+
+    /** [Row Value Expression][RowValueExpression] */
+    interface RowValueExpressionLink
+}
+
+/** [Row Expressions][RowExpressions] */
+internal interface RowExpressionsLink
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
index 78462658a..6c1c77c54 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
@@ -12,9 +12,6 @@ import kotlin.reflect.KProperty
  * }
  */
 
-/** The key for an @arg that will define the operation name for the examples below. */
-internal interface OperationArg
-
 /** [Selecting Columns][SelectingColumns] */
 internal interface SelectingColumnsLink
 
@@ -28,6 +25,12 @@ internal interface SelectingColumnsLink
  */
 internal interface SelectingColumns {
 
+    /**
+     * The key for an @arg that will define the operation name for the examples below.
+     * Make sure to [alias][your examples].
+     */
+    interface OperationArg
+
     /** {@arg [OperationArg] operation} */
     interface SetDefaultOperationArg
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
deleted file mode 100644
index 29c62b755..000000000
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
+++ /dev/null
@@ -1,47 +0,0 @@
-package org.jetbrains.kotlinx.dataframe.documentation
-
-import org.jetbrains.kotlinx.dataframe.*
-import org.jetbrains.kotlinx.dataframe.api.*
-
-/**
- * Selecting rows that satisfy a "Row Condition" ({@include [DocumentationUrls.DataRow.RowConditions]})
- * can occur in the following two types of operations:
- * - Selecting entire rows ({@include [RowConditionLink]}), for instance in [filter], [drop], [first], and [count].
- * - Selecting parts of rows using a `where` operation after selecting columns ({@include [RowValueConditionLink]}),
- * such as with [update], [gather], and [format] ([RowValueFilter]).
- * {@comment TODO Is `where` present everywhere it should be?}
- */
-internal interface SelectingRows {
-
-    /** {@arg [OperationArg] <operation>} */
-    interface SetDefaultOperationArg
-
-    /** [Entire-Row Condition][EntireRowCondition] */
-    interface RowConditionLink
-
-    /** Filter or find rows to operate on using a [row filter][RowFilter].
-     *
-     * For example:
-     *
-     * `df.`{@includeArg [OperationArg]}` { `[index][index]`() % 2 == 0 }`
-     *
-     * `df.`{@includeArg [OperationArg]}` { `[diff][diff]` { age } == 0 }`
-     */
-    interface EntireRowCondition
-
-    /** [Row-Value Condition][RowValueCondition] */
-    interface RowValueConditionLink
-
-    /** Filter or find rows to operate on after [selecting columns][SelectingColumns] using a
-     * [row value filter][RowValueFilter].
-     *
-     * For example:
-     *
-     * `df.`{@includeArg [OperationArg]}` { length }.`[where][where]` { it > 10.0 }`
-     *
-     * `df.`{@includeArg [OperationArg]}` { `[cols][ColumnsSelectionDsl.cols]`(1..5) }.`[where][where]` { `[index][index]`() > 4 && city != "Paris" }`
-     *
-     * @include [SetDefaultOperationArg]
-     */
-    interface RowValueCondition
-}

From 394a795efe618f95b0426af54e18e6cd33189659 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Wed, 8 Feb 2023 19:58:32 +0100
Subject: [PATCH 18/50] refactored examples separate from docs, working on
 update overloads docs

---
 core/build.gradle.kts                         |   2 +-
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  |  20 ++--
 .../jetbrains/kotlinx/dataframe/api/update.kt |  51 ++++++---
 .../dataframe/documentation/AccessApi.kt      |   8 +-
 .../dataframe/documentation/RowCondition.kt   |  53 +++++----
 .../dataframe/documentation/RowExpressions.kt |  53 +++++----
 .../documentation/SelectingColumns.kt         | 106 +++++++++++-------
 7 files changed, 177 insertions(+), 116 deletions(-)

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index a0372c9f8..b9f725f90 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -14,7 +14,7 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.13"
+    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.14"
 //    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
 }
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index 5bd6c86e1..b5d6670ba 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -42,7 +42,7 @@ internal interface SetFillNullsOperationArg
 /**
  * @include [FillNulls]
  *
- * @include [SelectingColumns.Dsl] {@include [SetFillNullsOperationArg]}
+ * @include [SelectingColumns.Dsl.WithExample] {@include [SetFillNullsOperationArg]}
  * @include [Update.DslParam]
  */
 public fun <T, C> DataFrame<T>.fillNulls(columns: ColumnsSelector<T, C?>): Update<T, C?> =
@@ -51,7 +51,7 @@ public fun <T, C> DataFrame<T>.fillNulls(columns: ColumnsSelector<T, C?>): Updat
 /**
  * @include [FillNulls]
  *
- * @include [SelectingColumns.ColumnNames] {@include [SetFillNullsOperationArg]}
+ * @include [SelectingColumns.ColumnNames.WithExample] {@include [SetFillNullsOperationArg]}
  * @include [Update.ColumnNamesParam]
  */
 public fun <T> DataFrame<T>.fillNulls(vararg columns: String): Update<T, Any?> =
@@ -60,7 +60,7 @@ public fun <T> DataFrame<T>.fillNulls(vararg columns: String): Update<T, Any?> =
 /**
  * @include [FillNulls]
  *
- * @include [SelectingColumns.KProperties] {@include [SetFillNullsOperationArg]}
+ * @include [SelectingColumns.KProperties.WithExample] {@include [SetFillNullsOperationArg]}
  * @include [Update.KPropertiesParam]
  */
 public fun <T, C> DataFrame<T>.fillNulls(vararg columns: KProperty<C>): Update<T, C?> =
@@ -69,7 +69,7 @@ public fun <T, C> DataFrame<T>.fillNulls(vararg columns: KProperty<C>): Update<T
 /**
  * @include [FillNulls]
  *
- * @include [SelectingColumns.ColumnAccessors] {@include [SetFillNullsOperationArg]}
+ * @include [SelectingColumns.ColumnAccessors.WithExample] {@include [SetFillNullsOperationArg]}
  * @include [Update.ColumnAccessorsParam]
  */
 public fun <T, C> DataFrame<T>.fillNulls(vararg columns: ColumnReference<C>): Update<T, C?> =
@@ -78,7 +78,7 @@ public fun <T, C> DataFrame<T>.fillNulls(vararg columns: ColumnReference<C>): Up
 /**
  * @include [FillNulls]
  *
- * @include [SelectingColumns.ColumnAccessors] {@include [SetFillNullsOperationArg]}
+ * @include [SelectingColumns.ColumnAccessors.WithExample] {@include [SetFillNullsOperationArg]}
  * @include [Update.ColumnAccessorsParam]
  */
 public fun <T, C> DataFrame<T>.fillNulls(columns: Iterable<ColumnReference<C>>): Update<T, C?> =
@@ -127,7 +127,7 @@ internal interface SetFillNaNsOperationArg
 
 /**
  * @include [FillNaNs]
- * @include [SelectingColumns.Dsl] {@include [SetFillNaNsOperationArg]}
+ * @include [SelectingColumns.Dsl.WithExample] {@include [SetFillNaNsOperationArg]}
  * @include [Update.DslParam]
  *
  */
@@ -137,7 +137,7 @@ public fun <T, C> DataFrame<T>.fillNaNs(columns: ColumnsSelector<T, C>): Update<
 /**
  * @include [FillNaNs]
  *
- * @include [SelectingColumns.ColumnNames] {@include [SetFillNaNsOperationArg]}
+ * @include [SelectingColumns.ColumnNames.WithExample] {@include [SetFillNaNsOperationArg]}
  * @include [Update.ColumnNamesParam]
  */
 public fun <T> DataFrame<T>.fillNaNs(vararg columns: String): Update<T, Any?> =
@@ -146,7 +146,7 @@ public fun <T> DataFrame<T>.fillNaNs(vararg columns: String): Update<T, Any?> =
 /**
  * @include [FillNaNs]
  *
- * @include [SelectingColumns.KProperties] {@include [SetFillNaNsOperationArg]}
+ * @include [SelectingColumns.KProperties.WithExample] {@include [SetFillNaNsOperationArg]}
  * @include [Update.KPropertiesParam]
  */
 public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: KProperty<C>): Update<T, C> =
@@ -155,7 +155,7 @@ public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: KProperty<C>): Update<T,
 /**
  * @include [FillNaNs]
  *
- * @include [SelectingColumns.ColumnAccessors] {@include [SetFillNaNsOperationArg]}
+ * @include [SelectingColumns.ColumnAccessors.WithExample] {@include [SetFillNaNsOperationArg]}
  * @include [Update.ColumnAccessorsParam]
  */
 public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: ColumnReference<C>): Update<T, C> =
@@ -164,7 +164,7 @@ public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: ColumnReference<C>): Upd
 /**
  * @include [FillNaNs]
  *
- * @include [SelectingColumns.ColumnAccessors] {@include [SetFillNaNsOperationArg]}
+ * @include [SelectingColumns.ColumnAccessors.WithExample] {@include [SetFillNaNsOperationArg]}
  * @include [Update.ColumnAccessorsParam]
  */
 public fun <T, C> DataFrame<T>.fillNaNs(columns: Iterable<ColumnReference<C>>): Update<T, C> =
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index fb5d9c34d..9e2161893 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -28,6 +28,7 @@ import kotlin.reflect.KProperty
  * (column types can not be changed).
  *
  * Check out the [Update Operation Usage][Usage].
+ *
  * For more information: {@include [DocumentationUrls.Update]}
  */
 public data class Update<T, C>(
@@ -48,12 +49,12 @@ public data class Update<T, C>(
      *
      * {@includeArg [UpdateOperationArg]} `{ `[columns][Columns]` }`
      *
-     * - `[.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { `[rowValueCondition][RowCondition.RowValueCondition]` } ]`
+     * - `[.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { `[rowValueCondition][RowCondition.RowValueCondition.WithExample]` } ]`
      *
-     * - `[.`[at][org.jetbrains.kotlinx.dataframe.api.Update.at]` (`[rowIndices][At.RowIndices]`) ]`
+     * - `[.`[at][org.jetbrains.kotlinx.dataframe.api.Update.at]` (`[rowIndices][CommonUpdateAtFunctionDoc]`) ]`
      *
-     * - `.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { `[rowExpression][RowExpressions.RowValueExpression]` }
-     *   | .`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { `[rowExpression][RowExpressions.RowValueExpression]` }
+     * - `.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { `[rowExpression][RowExpressions.RowValueExpression.WithExample]` }
+     *   | .`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { `[rowExpression][RowExpressions.RowValueExpression.WithExample]` }
      *   | .`[perCol][org.jetbrains.kotlinx.dataframe.api.Update.perCol]` { colExpression }
      *   | .`[perRowCol][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol]` { rowColExpression }
      *   | .`[withValue][org.jetbrains.kotlinx.dataframe.api.Update.withValue]`(value)
@@ -69,7 +70,7 @@ public data class Update<T, C>(
      */
     internal interface Usage
 
-    /** Select the columns to update. See {@include [SelectingColumnsLink]} for all the options. */
+    /** The columns to update need to be selected. See {@include [SelectingColumnsLink]} for all the selecting options. */
     internal interface Columns
 
     /** @param columns The [ColumnsSelector] used to select the columns of this [DataFrame] to update. */
@@ -92,15 +93,22 @@ private interface SetSelectingColumnsOperationArg
 
 /**
  * @include [Update] {@comment Description of the update operation.}
- *
+ * ## {@comment Line break}
  * @include [Update.Columns] {@comment Description of what this function expects the user to do.}
  * ## This Update Overload
  */
 internal interface CommonUpdateFunctionDoc
 
+/**
+ * ## Optional
+ * Combine `df.`[update][update]`(...).`[with][Update.with]` { ... }`
+ * into `df.`[update][update]`(...) { ... }`
+ */
+private interface UpdatePlusWithNote
+
 /**
  * @include [CommonUpdateFunctionDoc]
- * @include [SelectingColumns.Dsl] {@include [SetSelectingColumnsOperationArg]}
+ * @include [SelectingColumns.Dsl.WithExample] {@include [SetSelectingColumnsOperationArg]}
  * @include [Update.DslParam]
  */
 public fun <T, C> DataFrame<T>.update(columns: ColumnsSelector<T, C>): Update<T, C> =
@@ -108,21 +116,24 @@ public fun <T, C> DataFrame<T>.update(columns: ColumnsSelector<T, C>): Update<T,
 
 /**
  * @include [CommonUpdateFunctionDoc]
- * @include [SelectingColumns.ColumnNames] {@include [SetSelectingColumnsOperationArg]}
+ * @include [SelectingColumns.ColumnNames.WithExample] {@include [SetSelectingColumnsOperationArg]}
+ * @include [UpdatePlusWithNote]
  * @include [Update.ColumnNamesParam]
  */
 public fun <T> DataFrame<T>.update(vararg columns: String): Update<T, Any?> = update { columns.toColumns() }
 
 /**
  * @include [CommonUpdateFunctionDoc]
- * @include [SelectingColumns.KProperties] {@include [SetSelectingColumnsOperationArg]}
+ * @include [SelectingColumns.KProperties.WithExample] {@include [SetSelectingColumnsOperationArg]}
+ * @include [UpdatePlusWithNote]
  * @include [Update.KPropertiesParam]
  */
 public fun <T, C> DataFrame<T>.update(vararg columns: KProperty<C>): Update<T, C> = update { columns.toColumns() }
 
 /**
  * @include [CommonUpdateFunctionDoc]
- * @include [SelectingColumns.ColumnAccessors] {@include [SetSelectingColumnsOperationArg]}
+ * @include [SelectingColumns.ColumnAccessors.WithExample] {@include [SetSelectingColumnsOperationArg]}
+ * @include [UpdatePlusWithNote]
  * @include [Update.ColumnAccessorsParam]
  */
 public fun <T, C> DataFrame<T>.update(vararg columns: ColumnReference<C>): Update<T, C> =
@@ -130,8 +141,9 @@ public fun <T, C> DataFrame<T>.update(vararg columns: ColumnReference<C>): Updat
 
 /**
  * @include [CommonUpdateFunctionDoc]
- * @include [SelectingColumns.ColumnAccessors] {@include [SetSelectingColumnsOperationArg]}
+ * @include [SelectingColumns.ColumnAccessors.WithExample] {@include [SetSelectingColumnsOperationArg]}
  * @include [Update.ColumnAccessorsParam]
+ * TODO this will be deprecated
  */
 public fun <T, C> DataFrame<T>.update(columns: Iterable<ColumnReference<C>>): Update<T, C> =
     update { columns.toColumnSet() }
@@ -139,7 +151,7 @@ public fun <T, C> DataFrame<T>.update(columns: Iterable<ColumnReference<C>>): Up
 // endregion
 
 /** ## Where
- * @include [RowCondition.RowValueCondition]
+ * @include [RowCondition.RowValueCondition.WithExample]
  * {@arg [RowCondition.FirstOperationArg] [update][update]}
  * {@arg [RowCondition.SecondOperationArg] [where][where]}
  *
@@ -201,7 +213,7 @@ public infix fun <T, C> Update<T, C>.perRowCol(expression: RowColumnExpression<T
 public typealias UpdateExpression<T, C, R> = AddDataRow<T>.(C) -> R
 
 /** ## With
- * {@include [RowExpressions.RowValueExpression]}
+ * {@include [RowExpressions.RowValueExpression.WithExample]}
  * {@arg [RowExpressions.OperationArg] [update][update]` { city \}.`[with][with]}
  *
  * ## Note
@@ -252,7 +264,18 @@ public fun <T, C> Update<T, C?>.notNull(expression: RowValueExpression<T, C, C>)
         expression(row, value)
     }
 
-/** TODO */
+/**
+ * @include [CommonUpdateFunctionDoc]
+ * ### A combination of [update] and [with][Update.with].
+ *
+ * @include [SelectingColumns.ColumnAccessors]
+ *
+ * {@include [RowExpressions.RowValueExpression.WithExample]}
+ * {@arg [RowExpressions.OperationArg] [update][update]`("city")` }
+ *
+ * @include [Update.ColumnAccessorsParam]
+ * @param expression The {@include [RowExpressions.RowValueExpressionLink]} to update the rows with.
+ */
 public fun <T, C> DataFrame<T>.update(
     firstCol: ColumnReference<C>,
     vararg cols: ColumnReference<C>,
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
index 073ea65c2..02f5ae125 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
@@ -9,10 +9,10 @@ import org.jetbrains.kotlinx.dataframe.documentation.samples.ApiLevels as ApiLev
  *
  * In `Kotlin DataFrame` we provide four different ways to access columns, and, while they are essentially different, they
  * look pretty similar in the data wrangling DSL. These include:
- *  - [StringApi]
- *  - [ColumnAccessorsApi]
- *  - [KPropertiesApi]
- *  - [ExtensionPropertiesApi]
+ *  - {@include [ExtensionPropertiesApiLink]}
+ *  - {@include [KPropertiesApiLink]}
+ *  - {@include [ColumnAccessorsApiLink]}
+ *  - {@include [StringApiLink]}
  *
  * For more information: {@include [DocumentationUrls.AccessApis]}
  *
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowCondition.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowCondition.kt
index 7eeabe4b9..3158a0232 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowCondition.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowCondition.kt
@@ -33,36 +33,45 @@ internal interface RowCondition {
     /** {@arg [FirstOperationArg] operation}{@arg [SecondOperationArg] where} */
     interface SetDefaultOperationArg
 
-    /** [Entire-Row Condition][EntireRowCondition] */
+    /** [Entire-Row Condition][EntireRowCondition.WithExample] */
     interface RowConditionLink
 
-    /** Filter or find rows to operate on using a [row filter][RowFilter].
-     *
-     * For example:
-     *
-     * `df.`{@includeArg [FirstOperationArg]}` { `[index][index]`() % 2 == 0 }`
-     *
-     * `df.`{@includeArg [FirstOperationArg]}` { `[diff][diff]` { age } == 0 }`
-     *
-     * @include [SetDefaultOperationArg]
-     */
-    interface EntireRowCondition
+    /** Filter or find rows to operate on using a [row filter][RowFilter]. */
+    interface EntireRowCondition {
+
+        /**
+         * {@include [EntireRowCondition]}
+         *
+         * For example:
+         *
+         * `df.`{@includeArg [FirstOperationArg]}` { `[index][index]`() % 2 == 0 }`
+         *
+         * `df.`{@includeArg [FirstOperationArg]}` { `[diff][diff]` { age } == 0 }`
+         * @include [SetDefaultOperationArg]
+         */
+        interface WithExample
+    }
 
-    /** [Row-Value Condition][RowValueCondition] */
+    /** [Row-Value Condition][RowValueCondition.WithExample] */
     interface RowValueConditionLink
 
     /** Filter or find rows to operate on after [selecting columns][SelectingColumns] using a
      * [row value filter][RowValueFilter].
-     *
-     * For example:
-     *
-     * `df.`{@includeArg [FirstOperationArg]}` { length }.`{@includeArg [SecondOperationArg]}` { it > 10.0 }`
-     *
-     * `df.`{@includeArg [FirstOperationArg]}` { `[cols][ColumnsSelectionDsl.cols]`(1..5) }.`{@includeArg [SecondOperationArg]}` { `[index][index]`() > 4 && city != "Paris" }`
-     *
-     * @include [SetDefaultOperationArg]
      */
-    interface RowValueCondition
+    interface RowValueCondition {
+
+        /**
+         * {@include [RowValueCondition]}
+         *
+         * For example:
+         *
+         * `df.`{@includeArg [FirstOperationArg]}` { length }.`{@includeArg [SecondOperationArg]}` { it > 10.0 }`
+         *
+         * `df.`{@includeArg [FirstOperationArg]}` { `[cols][ColumnsSelectionDsl.cols]`(1..5) }.`{@includeArg [SecondOperationArg]}` { `[index][index]`() > 4 && city != "Paris" }`
+         * @include [SetDefaultOperationArg]
+         */
+        interface WithExample
+    }
 }
 
 /** [Row Condition][RowCondition] */
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowExpressions.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowExpressions.kt
index d8c6cfedd..e2b60f624 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowExpressions.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowExpressions.kt
@@ -46,35 +46,44 @@ internal interface RowExpressions {
      */
     interface AddDataRowNote
 
-    /** Provide a new value for every selected row given the row using a
-     * [row expression][DfRowExpression].
-     *
-     * For example:
-     *
-     * `df.`{@includeArg [OperationArg]}` { name.firstName + " " + name.lastName }`
-     *
-     * `df.`{@includeArg [OperationArg]}` { 2021 - age }`
-     *
-     * @include [SetDefaultOperationArg]
-     */
-    interface RowExpression
+    /** Provide a new value for every selected row given the row using a [row expression][DfRowExpression]. */
+    interface RowExpression {
+
+        /**
+         * {@include [RowExpression]}
+         *
+         * For example:
+         *
+         * `df.`{@includeArg [OperationArg]}` { name.firstName + " " + name.lastName }`
+         *
+         * `df.`{@includeArg [OperationArg]}` { 2021 - age }`
+         * @include [SetDefaultOperationArg]
+         */
+        interface WithExample
+    }
 
-    /** [Row Expression][RowExpression] */
+    /** [Row Expression][RowExpression.WithExample] */
     interface RowExpressionLink
 
     /** Provide a new value for every selected row given the row and the previous value using a
      * [row value expression][DfRowValueExpression].
-     *
-     * For example:
-     *
-     * `df.`{@includeArg [OperationArg]}` { name.firstName + " from " + it }`
-     *
-     * `df.`{@includeArg [OperationArg]}` { it.uppercase() }`
-     * {@include [SetDefaultOperationArg]}
      */
-    interface RowValueExpression
+    interface RowValueExpression {
+
+        /**
+         * {@include [RowValueExpression]}
+         *
+         * For example:
+         *
+         * `df.`{@includeArg [OperationArg]}` { name.firstName + " from " + it }`
+         *
+         * `df.`{@includeArg [OperationArg]}` { it.uppercase() }`
+         * {@include [SetDefaultOperationArg]}
+         */
+        interface WithExample
+    }
 
-    /** [Row Value Expression][RowValueExpression] */
+    /** [Row Value Expression][RowValueExpression.WithExample] */
     interface RowValueExpressionLink
 }
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
index 6c1c77c54..d857e7966 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
@@ -18,10 +18,10 @@ internal interface SelectingColumnsLink
 /** Selecting columns for various operations (including but not limited to
  * [DataFrame.select], [DataFrame.update], [DataFrame.gather], and [DataFrame.fillNulls])
  * can be done in the following ways:
- * - {@include [Dsl]}
- * - {@include [ColumnNames]}
- * - {@include [ColumnAccessors]}
- * - {@include [KProperties]}
+ * - {@include [Dsl.WithExample]}
+ * - {@include [ColumnNames.WithExample]}
+ * - {@include [ColumnAccessors.WithExample]}
+ * - {@include [KProperties.WithExample]}
  */
 internal interface SelectingColumns {
 
@@ -40,53 +40,73 @@ internal interface SelectingColumns {
      * This DSL comes in the form of either a [Column Selector][ColumnSelector]- or [Columns Selector][ColumnsSelector] lambda,
      * which operate in the {@include [ColumnSelectionDslLink]} or the {@include [ColumnsSelectionDslLink]} and
      * expect you to return a [SingleColumn] or [ColumnSet], respectively.
-     *
-     * For example:
-     *
-     * `df.`{@includeArg [OperationArg]}` { length `[and][ColumnsSelectionDsl.and]` age }`
-     *
-     * `df.`{@includeArg [OperationArg]}` { `[cols][ColumnsSelectionDsl.cols]`(1..5) }`
-     *
-     * `df.`{@includeArg [OperationArg]}` { `[colsOf][colsOf]`<Double>() }`
-     *
-     * @include [SetDefaultOperationArg]
      */
-    interface Dsl
+    interface Dsl {
+
+        /**
+         * {@include [Dsl]}
+         *
+         * For example:
+         * `df.`{@includeArg [OperationArg]}` { length `[and][ColumnsSelectionDsl.and]` age }`
+         *
+         * `df.`{@includeArg [OperationArg]}` { `[cols][ColumnsSelectionDsl.cols]`(1..5) }`
+         *
+         * `df.`{@includeArg [OperationArg]}` { `[colsOf][colsOf]`<Double>() }`
+         * @include [SetDefaultOperationArg]
+         */
+        interface WithExample
+    }
 
     /** Select columns using their column names
      * ({@include [AccessApi.StringApiLink]}).
-     *
-     * For example:
-     *
-     * `df.`{@includeArg [OperationArg]}`("length", "age")`
-     * @include [SetDefaultOperationArg]
      */
-    interface ColumnNames
+    interface ColumnNames {
+
+        /**
+         * {@include [ColumnNames]}
+         *
+         * For example:
+         *
+         * `df.`{@includeArg [OperationArg]}`("length", "age")`
+         * @include [SetDefaultOperationArg]
+         */
+        interface WithExample
+    }
 
     /** Select columns using column accessors
      * ({@include [AccessApi.ColumnAccessorsApiLink]}).
-     *
-     * For example:
-     *
-     * `val length by `[column]`<Double>()`
-     *
-     * `val age by `[column]`<Double>()`
-     *
-     * `df.`{@includeArg [OperationArg]}`(length, age)`
-     *
-     * @include [SetDefaultOperationArg]
      */
-    interface ColumnAccessors
+    interface ColumnAccessors {
 
-    /** Select columns using [KProperty]'s
-     * ({@include [AccessApi.KPropertiesApiLink]}).
-     *
-     * For example:
-     * ```kotlin
-     * data class Person(val length: Double, val age: Double)
-     * ```
-     * `df.`{@includeArg [OperationArg]}`(Person::length, Person::age)`
-     * @include [SetDefaultOperationArg]
-     */
-    interface KProperties
+        /**
+         * {@include [ColumnAccessors]}
+         *
+         * For example:
+         *
+         * `val length by `[column]`<Double>()`
+         *
+         * `val age by `[column]`<Double>()`
+         *
+         * `df.`{@includeArg [OperationArg]}`(length, age)`
+         * @include [SetDefaultOperationArg]
+         */
+        interface WithExample
+    }
+
+    /** Select columns using [KProperties][KProperty] ({@include [AccessApi.KPropertiesApiLink]}). */
+    interface KProperties {
+
+        /**
+         * {@include [KProperties]}
+         *
+         * For example:
+         * ```kotlin
+         * data class Person(val length: Double, val age: Double)
+         * ```
+         *
+         * `df.`{@includeArg [OperationArg]}`(Person::length, Person::age)`
+         * @include [SetDefaultOperationArg]
+         */
+        interface WithExample
+    }
 }

From 83cfa31a0669fc90596ca2e62e044b52a0b6e819 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Thu, 9 Feb 2023 14:21:34 +0100
Subject: [PATCH 19/50] final update overloads, fillNA and NA/NaN info

---
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  | 152 ++++++++++++++----
 .../jetbrains/kotlinx/dataframe/api/update.kt |  39 +++--
 2 files changed, 149 insertions(+), 42 deletions(-)

diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index b5d6670ba..f090b0659 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -20,28 +20,34 @@ import kotlin.reflect.KProperty
 // region fillNulls
 
 /**
- * Replace `null` values with given value or expression.
- * Specific case of [Update].
+ * ## The Fill Nulls Operation
  *
- * Check out [how to use `fillNulls`][Usage].
+ * Replaces `null` values with given value or expression.
+ * Specific case of [update].
+ *
+ * Check out the [`fillNulls` Operation Usage][Usage].
  *
  * For more information: {@include [DocumentationUrls.Fill.FillNulls]}
  */
 internal interface FillNulls {
 
-    /** @include [Update.Usage]
-     * {@arg [UpdateOperationArg] [fillNulls][fillNulls]}
-     * {@arg [RowCondition.FirstOperationArg] [fillNulls][fillNulls]}
-     * {@arg [RowExpressions.OperationArg] [fillNulls][fillNulls]} */
+    /** @include [Update.Usage] {@arg [UpdateOperationArg] [fillNulls][fillNulls]} */
     interface Usage
 }
 
 /** {@arg [SelectingColumns.OperationArg] [fillNulls][fillNulls]} */
-internal interface SetFillNullsOperationArg
+private interface SetFillNullsOperationArg
 
 /**
- * @include [FillNulls]
- *
+ * @include [FillNulls] {@comment Description of the fillNulls operation.}
+ * ## {@comment Line break}
+ * @include [Update.Columns] {@comment Description of what this function expects the user to do: select columns}
+ * ## This Fill Nulls Overload
+ */
+private interface CommonFillNullsFunctionDoc
+
+/**
+ * @include [CommonFillNullsFunctionDoc]
  * @include [SelectingColumns.Dsl.WithExample] {@include [SetFillNullsOperationArg]}
  * @include [Update.DslParam]
  */
@@ -49,8 +55,7 @@ public fun <T, C> DataFrame<T>.fillNulls(columns: ColumnsSelector<T, C?>): Updat
     update(columns).where { it == null }
 
 /**
- * @include [FillNulls]
- *
+ * @include [CommonFillNullsFunctionDoc]
  * @include [SelectingColumns.ColumnNames.WithExample] {@include [SetFillNullsOperationArg]}
  * @include [Update.ColumnNamesParam]
  */
@@ -58,8 +63,7 @@ public fun <T> DataFrame<T>.fillNulls(vararg columns: String): Update<T, Any?> =
     fillNulls { columns.toColumns() }
 
 /**
- * @include [FillNulls]
- *
+ * @include [CommonFillNullsFunctionDoc]
  * @include [SelectingColumns.KProperties.WithExample] {@include [SetFillNullsOperationArg]}
  * @include [Update.KPropertiesParam]
  */
@@ -67,8 +71,7 @@ public fun <T, C> DataFrame<T>.fillNulls(vararg columns: KProperty<C>): Update<T
     fillNulls { columns.toColumns() }
 
 /**
- * @include [FillNulls]
- *
+ * @include [CommonFillNullsFunctionDoc]
  * @include [SelectingColumns.ColumnAccessors.WithExample] {@include [SetFillNullsOperationArg]}
  * @include [Update.ColumnAccessorsParam]
  */
@@ -76,16 +79,40 @@ public fun <T, C> DataFrame<T>.fillNulls(vararg columns: ColumnReference<C>): Up
     fillNulls { columns.toColumns() }
 
 /**
- * @include [FillNulls]
- *
+ * @include [CommonFillNullsFunctionDoc]
  * @include [SelectingColumns.ColumnAccessors.WithExample] {@include [SetFillNullsOperationArg]}
  * @include [Update.ColumnAccessorsParam]
+ * TODO this will be deprecated
  */
 public fun <T, C> DataFrame<T>.fillNulls(columns: Iterable<ColumnReference<C>>): Update<T, C?> =
     fillNulls { columns.toColumnSet() }
 
 // endregion
 
+/**
+ * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
+ * in cases where a mathematical operation is undefined, such as dividing by zero.
+ * In Dataframe we have helper functions to check for `NaNs`, such as [Any?.isNaN][Any.isNaN] and
+ * [column.canHaveNaN][DataColumn.canHaveNaN].
+ * You can also use [fillNaNs][fillNaNs] to replace `NaNs` in certain columns with a given value or expression.
+ *
+ * @see NA
+ */
+internal interface NaN
+
+/**
+ * `NA` in Dataframe can be seen as "[NaN] or `null`".
+ *
+ * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
+ * in cases where a mathematical operation is undefined, such as dividing by zero.
+ *
+ * In Dataframe we have helper functions to check for `NAs`, such as [Any?.isNA][Any.isNA] and
+ * [column.canHaveNA][DataColumn.canHaveNA].
+ * You can also use [fillNA][fillNA] to replace `NAs` in certain columns with a given value or expression.
+ * @see NaN
+ */
+internal interface NA
+
 internal inline val Any?.isNaN: Boolean get() = (this is Double && isNaN()) || (this is Float && isNaN())
 
 internal inline val Any?.isNA: Boolean
@@ -109,34 +136,42 @@ internal inline val Float?.isNA: Boolean get() = this == null || this.isNaN()
 // region fillNaNs
 
 /**
- * Replace `NaN` values with given value or expression.
- * Specific case of [Update].
+ * ## The Fill NaNs Operation
  *
- * Check out [how to use `fillNaNs`][Usage].
+ * Replaces [`NaN`][NaN] values with given value or expression.
+ * Specific case of [update].
+ *
+ * Check out the [`fillNaNs` Operation Usage][Usage].
  *
  * For more information: {@include [DocumentationUrls.Fill.FillNaNs]}
  */
 internal interface FillNaNs {
 
-    /** @include [Update.Usage] {@arg [Update.UpdateOperationArg] [fillNaNs]} */
+    /** @include [Update.Usage] {@arg [Update.UpdateOperationArg] [fillNaNs][fillNaNs]} */
     interface Usage
 }
 
-/** {@arg [OperationArg] [fillNaNs][fillNaNs]} */
+/** {@arg [SelectingColumns.OperationArg] [fillNaNs][fillNaNs]} */
 internal interface SetFillNaNsOperationArg
 
 /**
- * @include [FillNaNs]
+ * @include [FillNaNs] {@comment Description of the fillNaNs operation.}
+ * ## {@comment Line break}
+ * @include [Update.Columns] {@comment Description of what this function expects the user to do: select columns}
+ * ## This Fill NaNs Overload
+ */
+private interface CommonFillNaNsFunctionDoc
+
+/**
+ * @include [CommonFillNaNsFunctionDoc]
  * @include [SelectingColumns.Dsl.WithExample] {@include [SetFillNaNsOperationArg]}
  * @include [Update.DslParam]
- *
  */
 public fun <T, C> DataFrame<T>.fillNaNs(columns: ColumnsSelector<T, C>): Update<T, C> =
     update(columns).where { it.isNaN }
 
 /**
- * @include [FillNaNs]
- *
+ * @include [CommonFillNaNsFunctionDoc]
  * @include [SelectingColumns.ColumnNames.WithExample] {@include [SetFillNaNsOperationArg]}
  * @include [Update.ColumnNamesParam]
  */
@@ -144,8 +179,7 @@ public fun <T> DataFrame<T>.fillNaNs(vararg columns: String): Update<T, Any?> =
     fillNaNs { columns.toColumns() }
 
 /**
- * @include [FillNaNs]
- *
+ * @include [CommonFillNaNsFunctionDoc]
  * @include [SelectingColumns.KProperties.WithExample] {@include [SetFillNaNsOperationArg]}
  * @include [Update.KPropertiesParam]
  */
@@ -153,8 +187,7 @@ public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: KProperty<C>): Update<T,
     fillNaNs { columns.toColumns() }
 
 /**
- * @include [FillNaNs]
- *
+ * @include [CommonFillNaNsFunctionDoc]
  * @include [SelectingColumns.ColumnAccessors.WithExample] {@include [SetFillNaNsOperationArg]}
  * @include [Update.ColumnAccessorsParam]
  */
@@ -162,10 +195,10 @@ public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: ColumnReference<C>): Upd
     fillNaNs { columns.toColumns() }
 
 /**
- * @include [FillNaNs]
- *
+ * @include [CommonFillNaNsFunctionDoc]
  * @include [SelectingColumns.ColumnAccessors.WithExample] {@include [SetFillNaNsOperationArg]}
  * @include [Update.ColumnAccessorsParam]
+ * TODO this will be deprecated
  */
 public fun <T, C> DataFrame<T>.fillNaNs(columns: Iterable<ColumnReference<C>>): Update<T, C> =
     fillNaNs { columns.toColumnSet() }
@@ -174,18 +207,71 @@ public fun <T, C> DataFrame<T>.fillNaNs(columns: Iterable<ColumnReference<C>>):
 
 // region fillNA
 
+/**
+ * ## The Fill NA Operation
+ *
+ * Replaces [`NA`][NA] values with given value or expression.
+ * Specific case of [update].
+ *
+ * Check out the [`fillNA` Operation Usage][Usage].
+ *
+ * For more information: {@include [DocumentationUrls.Fill.FillNA]}
+ */
+internal interface FillNA {
+
+    /** @include [Update.Usage] {@arg [Update.UpdateOperationArg] [fillNA][fillNA]} */
+    interface Usage
+}
+
+/** {@arg [SelectingColumns.OperationArg] [fillNA][fillNA]} */
+internal interface SetFillNAOperationArg
+
+/**
+ * @include [FillNA] {@comment Description of the fillNA operation.}
+ * ## {@comment Line break}
+ * @include [Update.Columns] {@comment Description of what this function expects the user to do: select columns}
+ * ## This Fill NA Overload
+ */
+private interface CommonFillNAFunctionDoc
+
+/**
+ * @include [CommonFillNAFunctionDoc]
+ * @include [SelectingColumns.Dsl.WithExample] {@include [SetFillNAOperationArg]}
+ * @include [Update.DslParam]
+ */
 public fun <T, C> DataFrame<T>.fillNA(columns: ColumnsSelector<T, C?>): Update<T, C?> =
     update(columns).where { it.isNA }
 
+/**
+ * @include [CommonFillNAFunctionDoc]
+ * @include [SelectingColumns.ColumnNames.WithExample] {@include [SetFillNAOperationArg]}
+ * @include [Update.ColumnNamesParam]
+ */
 public fun <T> DataFrame<T>.fillNA(vararg columns: String): Update<T, Any?> =
     fillNA { columns.toColumns() }
 
+/**
+ * @include [CommonFillNAFunctionDoc]
+ * @include [SelectingColumns.KProperties.WithExample] {@include [SetFillNAOperationArg]}
+ * @include [Update.KPropertiesParam]
+ */
 public fun <T, C> DataFrame<T>.fillNA(vararg columns: KProperty<C>): Update<T, C?> =
     fillNA { columns.toColumns() }
 
+/**
+ * @include [CommonFillNAFunctionDoc]
+ * @include [SelectingColumns.ColumnAccessors.WithExample] {@include [SetFillNAOperationArg]}
+ * @include [Update.ColumnAccessorsParam]
+ */
 public fun <T, C> DataFrame<T>.fillNA(vararg columns: ColumnReference<C>): Update<T, C?> =
     fillNA { columns.toColumns() }
 
+/**
+ * @include [CommonFillNAFunctionDoc]
+ * @include [SelectingColumns.ColumnAccessors.WithExample] {@include [SetFillNAOperationArg]}
+ * @include [Update.ColumnAccessorsParam]
+ * TODO this will be deprecated
+ */
 public fun <T, C> DataFrame<T>.fillNA(columns: Iterable<ColumnReference<C>>): Update<T, C?> =
     fillNA { columns.toColumnSet() }
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index 9e2161893..34481d31f 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -27,7 +27,7 @@ import kotlin.reflect.KProperty
  * Returns the [DataFrame] with changed values in some cells
  * (column types can not be changed).
  *
- * Check out the [Update Operation Usage][Usage].
+ * Check out the [`update` Operation Usage][Usage].
  *
  * For more information: {@include [DocumentationUrls.Update]}
  */
@@ -51,7 +51,7 @@ public data class Update<T, C>(
      *
      * - `[.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { `[rowValueCondition][RowCondition.RowValueCondition.WithExample]` } ]`
      *
-     * - `[.`[at][org.jetbrains.kotlinx.dataframe.api.Update.at]` (`[rowIndices][CommonUpdateAtFunctionDoc]`) ]`
+     * - `[.`[at][org.jetbrains.kotlinx.dataframe.api.Update.at]` (`[rowIndices][CommonUpdateAtFunctionDoc.RowIndicesParam]`) ]`
      *
      * - `.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { `[rowExpression][RowExpressions.RowValueExpression.WithExample]` }
      *   | .`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { `[rowExpression][RowExpressions.RowValueExpression.WithExample]` }
@@ -94,10 +94,10 @@ private interface SetSelectingColumnsOperationArg
 /**
  * @include [Update] {@comment Description of the update operation.}
  * ## {@comment Line break}
- * @include [Update.Columns] {@comment Description of what this function expects the user to do.}
+ * @include [Update.Columns] {@comment Description of what this function expects the user to do: select columns}
  * ## This Update Overload
  */
-internal interface CommonUpdateFunctionDoc
+private interface CommonUpdateFunctionDoc
 
 /**
  * ## Optional
@@ -175,7 +175,7 @@ public fun <T, C> Update<T, C>.where(predicate: RowValueFilter<T, C>): Update<T,
  */
 private interface CommonUpdateAtFunctionDoc {
 
-    /** The indices of the rows to update. */
+    /** The indices of the rows to update. Either a [Collection]<[Int]>, an [IntRange], or just `vararg` indices. */
     interface RowIndicesParam
 }
 
@@ -266,7 +266,7 @@ public fun <T, C> Update<T, C?>.notNull(expression: RowValueExpression<T, C, C>)
 
 /**
  * @include [CommonUpdateFunctionDoc]
- * ### A combination of [update] and [with][Update.with].
+ * ### This overload is a combination of [update] and [with][Update.with].
  *
  * @include [SelectingColumns.ColumnAccessors]
  *
@@ -283,7 +283,18 @@ public fun <T, C> DataFrame<T>.update(
 ): DataFrame<T> =
     update(*headPlusArray(firstCol, cols)).with(expression)
 
-/** TODO */
+/**
+ * @include [CommonUpdateFunctionDoc]
+ * ### This overload is a combination of [update] and [with][Update.with].
+ *
+ * @include [SelectingColumns.KProperties]
+ *
+ * {@include [RowExpressions.RowValueExpression.WithExample]}
+ * {@arg [RowExpressions.OperationArg] [update][update]`("city")` }
+ *
+ * @include [Update.KPropertiesParam]
+ * @param expression The {@include [RowExpressions.RowValueExpressionLink]} to update the rows with.
+ */
 public fun <T, C> DataFrame<T>.update(
     firstCol: KProperty<C>,
     vararg cols: KProperty<C>,
@@ -291,7 +302,18 @@ public fun <T, C> DataFrame<T>.update(
 ): DataFrame<T> =
     update(*headPlusArray(firstCol, cols)).with(expression)
 
-/** TODO */
+/**
+ * @include [CommonUpdateFunctionDoc]
+ * ### This overload is a combination of [update] and [with][Update.with].
+ *
+ * @include [SelectingColumns.ColumnNames]
+ *
+ * {@include [RowExpressions.RowValueExpression.WithExample]}
+ * {@arg [RowExpressions.OperationArg] [update][update]`("city")` }
+ *
+ * @include [Update.ColumnNamesParam]
+ * @param expression The {@include [RowExpressions.RowValueExpressionLink]} to update the rows with.
+ */
 public fun <T> DataFrame<T>.update(
     firstCol: String,
     vararg cols: String,
@@ -299,7 +321,6 @@ public fun <T> DataFrame<T>.update(
 ): DataFrame<T> =
     update(*headPlusArray(firstCol, cols)).with(expression)
 
-
 /**
  * Specific version of [with] that simply sets the value of each selected row to {@includeArg [CommonSpecificWithDocFirstArg]}.
  *

From 28b1df9f992313c7c006df9beb65b39a78b12896 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Fri, 10 Feb 2023 18:01:53 +0100
Subject: [PATCH 20/50] slight refactoring and updated gradle plugin

---
 core/build.gradle.kts                         | 14 +++++++++-
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  |  6 ++--
 .../jetbrains/kotlinx/dataframe/api/update.kt | 28 +++++++++----------
 .../kotlinx/dataframe/documentation/utils.kt  |  4 +++
 4 files changed, 34 insertions(+), 18 deletions(-)
 create mode 100644 core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/utils.kt

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index b9f725f90..41c8854d3 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -14,7 +14,7 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.14"
+    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.15"
 //    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
 }
 
@@ -74,6 +74,18 @@ val processKdocIncludeMain by creatingProcessDocTask(
     debug = true
 }
 
+// As a bonus, this will update dokka if you use that
+tasks.withType<org.jetbrains.dokka.gradle.AbstractDokkaLeafTask> {
+    dependsOn(processKdocIncludeMain)
+    dokkaSourceSets {
+        all {
+            sourceRoot(processKdocIncludeMain.target.get())
+//            for (root in processKdocIncludeMain.targets)
+//                sourceRoot(root)
+        }
+    }
+}
+
 // Modify all Jar tasks such that before running the Kotlin sources are set to
 // the target of processKdocIncludeMain and they are returned back to normal afterwards.
 tasks.withType<Jar> {
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index f090b0659..49a99d8b5 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -40,7 +40,7 @@ private interface SetFillNullsOperationArg
 
 /**
  * @include [FillNulls] {@comment Description of the fillNulls operation.}
- * ## {@comment Line break}
+ * @include [LineBreak]
  * @include [Update.Columns] {@comment Description of what this function expects the user to do: select columns}
  * ## This Fill Nulls Overload
  */
@@ -156,7 +156,7 @@ internal interface SetFillNaNsOperationArg
 
 /**
  * @include [FillNaNs] {@comment Description of the fillNaNs operation.}
- * ## {@comment Line break}
+ * @include [LineBreak]
  * @include [Update.Columns] {@comment Description of what this function expects the user to do: select columns}
  * ## This Fill NaNs Overload
  */
@@ -228,7 +228,7 @@ internal interface SetFillNAOperationArg
 
 /**
  * @include [FillNA] {@comment Description of the fillNA operation.}
- * ## {@comment Line break}
+ * @include [LineBreak]
  * @include [Update.Columns] {@comment Description of what this function expects the user to do: select columns}
  * ## This Fill NA Overload
  */
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index 34481d31f..3630201f5 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -49,18 +49,18 @@ public data class Update<T, C>(
      *
      * {@includeArg [UpdateOperationArg]} `{ `[columns][Columns]` }`
      *
-     * - `[.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { `[rowValueCondition][RowCondition.RowValueCondition.WithExample]` } ]`
+     * - `[.`[where][Update.where]` { `[rowValueCondition][RowCondition.RowValueCondition.WithExample]` } ]`
      *
-     * - `[.`[at][org.jetbrains.kotlinx.dataframe.api.Update.at]` (`[rowIndices][CommonUpdateAtFunctionDoc.RowIndicesParam]`) ]`
+     * - `[.`[at][Update.at]` (`[rowIndices][CommonUpdateAtFunctionDoc.RowIndicesParam]`) ]`
      *
-     * - `.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { `[rowExpression][RowExpressions.RowValueExpression.WithExample]` }
-     *   | .`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { `[rowExpression][RowExpressions.RowValueExpression.WithExample]` }
-     *   | .`[perCol][org.jetbrains.kotlinx.dataframe.api.Update.perCol]` { colExpression }
-     *   | .`[perRowCol][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol]` { rowColExpression }
-     *   | .`[withValue][org.jetbrains.kotlinx.dataframe.api.Update.withValue]`(value)
-     *   | .`[withNull][org.jetbrains.kotlinx.dataframe.api.Update.withNull]`()
-     *   | .`[withZero][org.jetbrains.kotlinx.dataframe.api.Update.withZero]`()
-     *   | .`[asFrame][org.jetbrains.kotlinx.dataframe.api.Update.asFrame]` { frameExpression }`
+     * - `.`[with][Update.with]` { `[rowExpression][RowExpressions.RowValueExpression.WithExample]` }
+     *   | .`[notNull][Update.notNull]` { `[rowExpression][RowExpressions.RowValueExpression.WithExample]` }
+     *   | .`[perCol][Update.perCol]` { colExpression }
+     *   | .`[perRowCol][Update.perRowCol]` { rowColExpression }
+     *   | .`[withValue][Update.withValue]`(value)
+     *   | .`[withNull][Update.withNull]`()
+     *   | .`[withZero][Update.withZero]`()
+     *   | .`[asFrame][Update.asFrame]` { frameExpression }`
      *
      * {@comment TODO
      * colExpression: DataColumn.(DataColumn) -> NewValue
@@ -68,10 +68,10 @@ public data class Update<T, C>(
      * frameExpression: DataFrame.(DataFrame) -> DataFrame}
      * {@arg [UpdateOperationArg] [update][update]}
      */
-    internal interface Usage
+    public interface Usage
 
     /** The columns to update need to be selected. See {@include [SelectingColumnsLink]} for all the selecting options. */
-    internal interface Columns
+    public interface Columns
 
     /** @param columns The [ColumnsSelector] used to select the columns of this [DataFrame] to update. */
     internal interface DslParam
@@ -93,7 +93,7 @@ private interface SetSelectingColumnsOperationArg
 
 /**
  * @include [Update] {@comment Description of the update operation.}
- * ## {@comment Line break}
+ * @include [LineBreak]
  * @include [Update.Columns] {@comment Description of what this function expects the user to do: select columns}
  * ## This Update Overload
  */
@@ -350,7 +350,7 @@ public fun <T, C> Update<T, C>.withNull(): DataFrame<T> = with { null }
  * {@arg [CommonSpecificWithDocFirstArg] `0`}
  * {@arg [CommonSpecificWithDocSecondArg] [withZero][withZero]`()}
  */
-public fun <T, C : Number?> Update<T, C>.withZero(): DataFrame<T> = updateWithValuePerColumnImpl { 0 as C }
+public fun <T, C> Update<T, C>.withZero(): DataFrame<T> = updateWithValuePerColumnImpl { 0 as C }
 
 /**
  * ## With Value
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/utils.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/utils.kt
new file mode 100644
index 000000000..3660dd539
--- /dev/null
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/utils.kt
@@ -0,0 +1,4 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+/** ## ‎ */
+internal interface LineBreak

From f70f0bc128226dd77f2cdb306b54bfaec89df02f Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Tue, 14 Feb 2023 17:43:13 +0100
Subject: [PATCH 21/50] added ColumnExpression typealias and uses across the
 api.

---
 .../kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt | 11 +++++++++++
 .../org/jetbrains/kotlinx/dataframe/api/reorder.kt    |  5 +++--
 .../org/jetbrains/kotlinx/dataframe/api/update.kt     |  5 ++---
 .../jetbrains/kotlinx/dataframe/impl/api/reorder.kt   |  4 ++--
 .../jetbrains/kotlinx/dataframe/impl/api/update.kt    |  4 ++--
 5 files changed, 20 insertions(+), 9 deletions(-)

diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt
index 74552bae8..064bbeb02 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt
@@ -74,6 +74,17 @@ public typealias RowValueExpression<T, C, R> = DataRow<T>.(it: C) -> R
  */
 public typealias RowColumnExpression<T, C, R> = (row: DataRow<T>, col: DataColumn<C>) -> R
 
+/**
+ * [ColumnExpression] is used to express or select any instance of `R` using the given instance of [DataColumn]`<C>` as
+ * `this` and `it`.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * DataColumn<C>.(it: DataColumn<C>) -> R
+ * ```
+ */
+public typealias ColumnExpression<C, R> = Selector<DataColumn<C>, R>
+
 /**
  * [ColumnSelector] is used to express or select a single column, represented by [SingleColumn]`<C>`, using the
  * context of [ColumnsSelectionDsl]`<T>` as `this` and `it`.
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
index 31e8ee869..64c2e5b63 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
@@ -1,6 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.ColumnExpression
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -25,11 +26,11 @@ public fun <T, C> DataFrame<T>.reorder(vararg columns: ColumnReference<C>): Reor
 public fun <T, C> DataFrame<T>.reorder(vararg columns: KProperty<C>): Reorder<T, C> = reorder { columns.toColumns() }
 public fun <T> DataFrame<T>.reorder(vararg columns: String): Reorder<T, *> = reorder { columns.toColumns() }
 
-public fun <T, C, V : Comparable<V>> Reorder<T, C>.by(expression: Selector<DataColumn<C>, V>): DataFrame<T> = reorderImpl(false, expression)
+public fun <T, C, V : Comparable<V>> Reorder<T, C>.by(expression: ColumnExpression<C, V>): DataFrame<T> = reorderImpl(false, expression)
 
 public fun <T, C> Reorder<T, C>.byName(desc: Boolean = false): DataFrame<T> = if (desc) byDesc { it.name } else by { it.name }
 
-public fun <T, C, V : Comparable<V>> Reorder<T, C>.byDesc(expression: Selector<DataColumn<C>, V>): DataFrame<T> = reorderImpl(true, expression)
+public fun <T, C, V : Comparable<V>> Reorder<T, C>.byDesc(expression: ColumnExpression<C, V>): DataFrame<T> = reorderImpl(true, expression)
 
 public fun <T, V : Comparable<V>> DataFrame<T>.reorderColumnsBy(
     dfs: Boolean = true,
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index 3630201f5..9a71b2125 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -1,15 +1,14 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnExpression
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
-import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataFrameExpression
 import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.RowColumnExpression
 import org.jetbrains.kotlinx.dataframe.RowValueExpression
 import org.jetbrains.kotlinx.dataframe.RowValueFilter
-import org.jetbrains.kotlinx.dataframe.Selector
 import org.jetbrains.kotlinx.dataframe.api.Update.Usage
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.documentation.*
@@ -244,7 +243,7 @@ public fun <T, C> Update<T, C>.perCol(values: Map<String, C>): DataFrame<T> = up
 public fun <T, C> Update<T, C>.perCol(values: AnyRow): DataFrame<T> = perCol(values.toMap() as Map<String, C>)
 
 /** TODO */
-public fun <T, C> Update<T, C>.perCol(valueSelector: Selector<DataColumn<C>, C>): DataFrame<T> =
+public fun <T, C> Update<T, C>.perCol(valueSelector: ColumnExpression<C, C>): DataFrame<T> =
     updateWithValuePerColumnImpl(valueSelector)
 
 /** TODO */
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/reorder.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/reorder.kt
index db04a39c1..2ce9f4db8 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/reorder.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/reorder.kt
@@ -1,9 +1,9 @@
 package org.jetbrains.kotlinx.dataframe.impl.api
 
 import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnExpression
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.Selector
 import org.jetbrains.kotlinx.dataframe.api.Reorder
 import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
 import org.jetbrains.kotlinx.dataframe.api.cast
@@ -23,7 +23,7 @@ import kotlin.reflect.typeOf
 
 internal fun <T, C, V : Comparable<V>> Reorder<T, C>.reorderImpl(
     desc: Boolean,
-    expression: Selector<DataColumn<C>, V>
+    expression: ColumnExpression<C, V>
 ): DataFrame<T> {
     data class ColumnInfo(
         val treeNode: TreeNode<ColumnPosition>,
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/update.kt
index 082ccc11a..b3fca01b3 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/update.kt
@@ -2,10 +2,10 @@ package org.jetbrains.kotlinx.dataframe.impl.api
 
 import org.jetbrains.kotlinx.dataframe.AnyFrame
 import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnExpression
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.RowValueFilter
-import org.jetbrains.kotlinx.dataframe.Selector
 import org.jetbrains.kotlinx.dataframe.api.AddDataRow
 import org.jetbrains.kotlinx.dataframe.api.Update
 import org.jetbrains.kotlinx.dataframe.api.cast
@@ -30,7 +30,7 @@ internal fun <T, C> Update<T, C>.updateImpl(expression: (AddDataRow<T>, DataColu
     if (df.isEmpty()) df
     else df.replace(columns).with { it.updateImpl(df, filter, expression) }
 
-internal fun <T, C> Update<T, C>.updateWithValuePerColumnImpl(selector: Selector<DataColumn<C>, C>) =
+internal fun <T, C> Update<T, C>.updateWithValuePerColumnImpl(selector: ColumnExpression<C, C>) =
     if (df.isEmpty()) df
     else {
         df.replace(columns).with {

From 428cff3b0159f01f5a48de44b4052e51a4d39020 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Tue, 14 Feb 2023 18:16:10 +0100
Subject: [PATCH 22/50] created stubs for columnExpression and
 dataframeexpression

---
 .../jetbrains/kotlinx/dataframe/api/update.kt | 15 +++----
 .../documentation/ColumnExpressions.kt        | 39 +++++++++++++++++++
 .../documentation/DataFrameExpressions.kt     | 24 ++++++++++++
 .../dataframe/documentation/RowExpressions.kt |  3 ++
 .../documentation/SelectingColumns.kt         |  1 +
 5 files changed, 72 insertions(+), 10 deletions(-)
 create mode 100644 core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ColumnExpressions.kt
 create mode 100644 core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DataFrameExpressions.kt

diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index 9a71b2125..6f1a2987d 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -46,7 +46,7 @@ public data class Update<T, C>(
     /**
      * ## {@includeArg [UpdateOperationArg]} Operation Usage
      *
-     * {@includeArg [UpdateOperationArg]} `{ `[columns][Columns]` }`
+     * {@includeArg [UpdateOperationArg]} `{ `[columns][SelectingColumns]` }`
      *
      * - `[.`[where][Update.where]` { `[rowValueCondition][RowCondition.RowValueCondition.WithExample]` } ]`
      *
@@ -54,18 +54,13 @@ public data class Update<T, C>(
      *
      * - `.`[with][Update.with]` { `[rowExpression][RowExpressions.RowValueExpression.WithExample]` }
      *   | .`[notNull][Update.notNull]` { `[rowExpression][RowExpressions.RowValueExpression.WithExample]` }
-     *   | .`[perCol][Update.perCol]` { colExpression }
-     *   | .`[perRowCol][Update.perRowCol]` { rowColExpression }
+     *   | .`[perCol][Update.perCol]` { [colExpression][ColumnExpressions.ColumnExpression.WithExample] }
+     *   | .`[perRowCol][Update.perRowCol]` { [rowColExpression][ColumnExpressions.RowColumnExpression.WithExample] }
      *   | .`[withValue][Update.withValue]`(value)
      *   | .`[withNull][Update.withNull]`()
      *   | .`[withZero][Update.withZero]`()
-     *   | .`[asFrame][Update.asFrame]` { frameExpression }`
-     *
-     * {@comment TODO
-     * colExpression: DataColumn.(DataColumn) -> NewValue
-     * rowColExpression: DataRow.(DataColumn) -> NewValue
-     * frameExpression: DataFrame.(DataFrame) -> DataFrame}
-     * {@arg [UpdateOperationArg] [update][update]}
+     *   | .`[asFrame][Update.asFrame]` { [dataFrameExpression][DataFrameExpressions.DataFrameExpression.WithExample] }`
+     * {@arg [UpdateOperationArg] [update][update]}{@comment The default name of the `update` operation function name.}
      */
     public interface Usage
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ColumnExpressions.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ColumnExpressions.kt
new file mode 100644
index 000000000..7226e8e16
--- /dev/null
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ColumnExpressions.kt
@@ -0,0 +1,39 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+/**
+ * Column expressions.
+ */
+internal interface ColumnExpressions {
+
+
+    /**
+     * TODO
+     */
+    interface ColumnExpression {
+
+        /**
+         * TODO
+         * @include [ColumnExpression]
+         */
+        interface WithExample
+    }
+
+    /** [Column Expression][ColumnExpression] */
+    interface ColumnExpressionLink
+
+    /**
+     * TODO
+     */
+    interface RowColumnExpression {
+
+        /**
+         * TODO
+         * @include [RowColumnExpression]
+         */
+        interface WithExample
+    }
+
+    /** [Row Column Expression][RowColumnExpression] */
+    interface RowColumnExpressionLink
+
+}
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DataFrameExpressions.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DataFrameExpressions.kt
new file mode 100644
index 000000000..be4f81151
--- /dev/null
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DataFrameExpressions.kt
@@ -0,0 +1,24 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+/**
+ * TODO
+ */
+internal interface DataFrameExpressions {
+
+    /**
+     * TODO
+     */
+    interface DataFrameExpression {
+
+        /**
+         * TODO
+         * @include [DataFrameExpression]
+         */
+        interface WithExample
+    }
+
+    /** [Data Frame Expression][DataFrameExpression] */
+    interface DataFrameExpressionLink
+
+
+}
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowExpressions.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowExpressions.kt
index e2b60f624..62bef20f8 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowExpressions.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowExpressions.kt
@@ -85,6 +85,9 @@ internal interface RowExpressions {
 
     /** [Row Value Expression][RowValueExpression.WithExample] */
     interface RowValueExpressionLink
+
+    /** @include [ColumnExpressions.RowColumnExpression] */
+    interface RowColumnExpression
 }
 
 /** [Row Expressions][RowExpressions] */
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
index d857e7966..92ce06e7e 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
@@ -47,6 +47,7 @@ internal interface SelectingColumns {
          * {@include [Dsl]}
          *
          * For example:
+         *
          * `df.`{@includeArg [OperationArg]}` { length `[and][ColumnsSelectionDsl.and]` age }`
          *
          * `df.`{@includeArg [OperationArg]}` { `[cols][ColumnsSelectionDsl.cols]`(1..5) }`

From 6ff4176b4e4d37fd8bcfa19f6f2bd776df5bdc3f Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Fri, 17 Feb 2023 15:19:25 +0100
Subject: [PATCH 23/50] small refactorings and renaming

---
 .../kotlinx/dataframe/api/reorder.kt          | 17 +++++----
 .../jetbrains/kotlinx/dataframe/api/update.kt | 36 +++++++++----------
 .../documentation/DocumentationUrls.kt        | 27 +++++++-------
 ...umnExpressions.kt => ExpressingColumns.kt} |  4 +--
 ...Expressions.kt => ExpressingDataFrames.kt} |  4 +--
 .../{RowExpressions.kt => ExpressingRows.kt}  | 14 ++++----
 .../documentation/SelectingColumns.kt         |  4 ++-
 7 files changed, 56 insertions(+), 50 deletions(-)
 rename core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/{ColumnExpressions.kt => ExpressingColumns.kt} (93%)
 rename core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/{DataFrameExpressions.kt => ExpressingDataFrames.kt} (88%)
 rename core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/{RowExpressions.kt => ExpressingRows.kt} (88%)

diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
index 64c2e5b63..f6eb6cdfd 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
@@ -3,7 +3,6 @@ package org.jetbrains.kotlinx.dataframe.api
 import org.jetbrains.kotlinx.dataframe.AnyCol
 import org.jetbrains.kotlinx.dataframe.ColumnExpression
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
-import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.Selector
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
@@ -22,15 +21,20 @@ public data class Reorder<T, C>(
 }
 
 public fun <T, C> DataFrame<T>.reorder(selector: ColumnsSelector<T, C>): Reorder<T, C> = Reorder(this, selector, false)
-public fun <T, C> DataFrame<T>.reorder(vararg columns: ColumnReference<C>): Reorder<T, C> = reorder { columns.toColumns() }
+public fun <T, C> DataFrame<T>.reorder(vararg columns: ColumnReference<C>): Reorder<T, C> =
+    reorder { columns.toColumns() }
+
 public fun <T, C> DataFrame<T>.reorder(vararg columns: KProperty<C>): Reorder<T, C> = reorder { columns.toColumns() }
 public fun <T> DataFrame<T>.reorder(vararg columns: String): Reorder<T, *> = reorder { columns.toColumns() }
 
-public fun <T, C, V : Comparable<V>> Reorder<T, C>.by(expression: ColumnExpression<C, V>): DataFrame<T> = reorderImpl(false, expression)
+public fun <T, C, V : Comparable<V>> Reorder<T, C>.by(expression: ColumnExpression<C, V>): DataFrame<T> =
+    reorderImpl(false, expression)
 
-public fun <T, C> Reorder<T, C>.byName(desc: Boolean = false): DataFrame<T> = if (desc) byDesc { it.name } else by { it.name }
+public fun <T, C> Reorder<T, C>.byName(desc: Boolean = false): DataFrame<T> =
+    if (desc) byDesc { it.name } else by { it.name }
 
-public fun <T, C, V : Comparable<V>> Reorder<T, C>.byDesc(expression: ColumnExpression<C, V>): DataFrame<T> = reorderImpl(true, expression)
+public fun <T, C, V : Comparable<V>> Reorder<T, C>.byDesc(expression: ColumnExpression<C, V>): DataFrame<T> =
+    reorderImpl(true, expression)
 
 public fun <T, V : Comparable<V>> DataFrame<T>.reorderColumnsBy(
     dfs: Boolean = true,
@@ -38,6 +42,7 @@ public fun <T, V : Comparable<V>> DataFrame<T>.reorderColumnsBy(
     expression: Selector<AnyCol, V>
 ): DataFrame<T> = Reorder(this, { if (dfs) allDfs(true) else all() }, dfs).reorderImpl(desc, expression)
 
-public fun <T> DataFrame<T>.reorderColumnsByName(dfs: Boolean = true, desc: Boolean = false): DataFrame<T> = reorderColumnsBy(dfs, desc) { name() }
+public fun <T> DataFrame<T>.reorderColumnsByName(dfs: Boolean = true, desc: Boolean = false): DataFrame<T> =
+    reorderColumnsBy(dfs, desc) { name() }
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index 6f1a2987d..b0ed4e3b2 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -52,14 +52,14 @@ public data class Update<T, C>(
      *
      * - `[.`[at][Update.at]` (`[rowIndices][CommonUpdateAtFunctionDoc.RowIndicesParam]`) ]`
      *
-     * - `.`[with][Update.with]` { `[rowExpression][RowExpressions.RowValueExpression.WithExample]` }
-     *   | .`[notNull][Update.notNull]` { `[rowExpression][RowExpressions.RowValueExpression.WithExample]` }
-     *   | .`[perCol][Update.perCol]` { [colExpression][ColumnExpressions.ColumnExpression.WithExample] }
-     *   | .`[perRowCol][Update.perRowCol]` { [rowColExpression][ColumnExpressions.RowColumnExpression.WithExample] }
+     * - `.`[with][Update.with]` { `[rowExpression][ExpressingRows.RowValueExpression.WithExample]` }
+     *   | .`[notNull][Update.notNull]` { `[rowExpression][ExpressingRows.RowValueExpression.WithExample]` }
+     *   | .`[perCol][Update.perCol]` { [colExpression][ExpressingColumns.ColumnExpression.WithExample] }
+     *   | .`[perRowCol][Update.perRowCol]` { [rowColExpression][ExpressingColumns.RowColumnExpression.WithExample] }
      *   | .`[withValue][Update.withValue]`(value)
      *   | .`[withNull][Update.withNull]`()
      *   | .`[withZero][Update.withZero]`()
-     *   | .`[asFrame][Update.asFrame]` { [dataFrameExpression][DataFrameExpressions.DataFrameExpression.WithExample] }`
+     *   | .`[asFrame][Update.asFrame]` { [dataFrameExpression][ExpressingDataFrames.DataFrameExpression.WithExample] }`
      * {@arg [UpdateOperationArg] [update][update]}{@comment The default name of the `update` operation function name.}
      */
     public interface Usage
@@ -207,12 +207,12 @@ public infix fun <T, C> Update<T, C>.perRowCol(expression: RowColumnExpression<T
 public typealias UpdateExpression<T, C, R> = AddDataRow<T>.(C) -> R
 
 /** ## With
- * {@include [RowExpressions.RowValueExpression.WithExample]}
- * {@arg [RowExpressions.OperationArg] [update][update]` { city \}.`[with][with]}
+ * {@include [ExpressingRows.RowValueExpression.WithExample]}
+ * {@arg [ExpressingRows.OperationArg] [update][update]` { city \}.`[with][with]}
  *
  * ## Note
- * @include [RowExpressions.AddDataRowNote]
- * @param expression The {@include [RowExpressions.RowValueExpressionLink]} to update the rows with.
+ * @include [ExpressingRows.AddDataRowNote]
+ * @param expression The {@include [ExpressingRows.RowValueExpressionLink]} to update the rows with.
  */
 public infix fun <T, C> Update<T, C>.with(expression: UpdateExpression<T, C, C?>): DataFrame<T> =
     updateImpl { row, _, value ->
@@ -264,11 +264,11 @@ public fun <T, C> Update<T, C?>.notNull(expression: RowValueExpression<T, C, C>)
  *
  * @include [SelectingColumns.ColumnAccessors]
  *
- * {@include [RowExpressions.RowValueExpression.WithExample]}
- * {@arg [RowExpressions.OperationArg] [update][update]`("city")` }
+ * {@include [ExpressingRows.RowValueExpression.WithExample]}
+ * {@arg [ExpressingRows.OperationArg] [update][update]`("city")` }
  *
  * @include [Update.ColumnAccessorsParam]
- * @param expression The {@include [RowExpressions.RowValueExpressionLink]} to update the rows with.
+ * @param expression The {@include [ExpressingRows.RowValueExpressionLink]} to update the rows with.
  */
 public fun <T, C> DataFrame<T>.update(
     firstCol: ColumnReference<C>,
@@ -283,11 +283,11 @@ public fun <T, C> DataFrame<T>.update(
  *
  * @include [SelectingColumns.KProperties]
  *
- * {@include [RowExpressions.RowValueExpression.WithExample]}
- * {@arg [RowExpressions.OperationArg] [update][update]`("city")` }
+ * {@include [ExpressingRows.RowValueExpression.WithExample]}
+ * {@arg [ExpressingRows.OperationArg] [update][update]`("city")` }
  *
  * @include [Update.KPropertiesParam]
- * @param expression The {@include [RowExpressions.RowValueExpressionLink]} to update the rows with.
+ * @param expression The {@include [ExpressingRows.RowValueExpressionLink]} to update the rows with.
  */
 public fun <T, C> DataFrame<T>.update(
     firstCol: KProperty<C>,
@@ -302,11 +302,11 @@ public fun <T, C> DataFrame<T>.update(
  *
  * @include [SelectingColumns.ColumnNames]
  *
- * {@include [RowExpressions.RowValueExpression.WithExample]}
- * {@arg [RowExpressions.OperationArg] [update][update]`("city")` }
+ * {@include [ExpressingRows.RowValueExpression.WithExample]}
+ * {@arg [ExpressingRows.OperationArg] [update][update]`("city")` }
  *
  * @include [Update.ColumnNamesParam]
- * @param expression The {@include [RowExpressions.RowValueExpressionLink]} to update the rows with.
+ * @param expression The {@include [ExpressingRows.RowValueExpressionLink]} to update the rows with.
  */
 public fun <T> DataFrame<T>.update(
     firstCol: String,
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
index b448ec1fe..01d072f10 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
@@ -7,44 +7,47 @@ private interface DocumentationUrls {
     /** See {@includeArg [NameArg]} on the documentation website. */
     interface Text
 
+    /** https://kotlin.github.io/dataframe */
+    interface Url
+
     interface DataRow {
 
-        /** [{@include [Text]}{@arg [NameArg] Row Expressions}](https://kotlin.github.io/dataframe/datarow.html#row-expressions) */
+        /** [{@include [Text]}{@arg [NameArg] Row Expressions}]({@include [Url]}/datarow.html#row-expressions) */
         interface RowExpressions
 
-        /** [{@include [Text]}{@arg [NameArg] Row Conditions}](https://kotlin.github.io/dataframe/datarow.html#row-conditions) */
+        /** [{@include [Text]}{@arg [NameArg] Row Conditions}]({@include [Url]}/datarow.html#row-conditions) */
         interface RowConditions
     }
 
-    /** [{@include [Text]}{@arg [NameArg] `update`}](https://kotlin.github.io/dataframe/update.html) */
+    /** [{@include [Text]}{@arg [NameArg] `update`}]({@include [Url]}/update.html) */
     interface Update
 
-    /** [{@include [Text]}{@arg [NameArg] `fill`}](https://kotlin.github.io/dataframe/fill.html) */
+    /** [{@include [Text]}{@arg [NameArg] `fill`}]({@include [Url]}/fill.html) */
     interface Fill {
 
-        /** [{@include [Text]}{@arg [NameArg] `fillNulls`}](https://kotlin.github.io/dataframe/fill.html#fillnulls) */
+        /** [{@include [Text]}{@arg [NameArg] `fillNulls`}]({@include [Url]}/fill.html#fillnulls) */
         interface FillNulls
 
-        /** [{@include [Text]}{@arg [NameArg] `fillNaNs`}](https://kotlin.github.io/dataframe/fill.html#fillnans) */
+        /** [{@include [Text]}{@arg [NameArg] `fillNaNs`}]({@include [Url]}/fill.html#fillnans) */
         interface FillNaNs
 
-        /** [{@include [Text]}{@arg [NameArg] `fillNA`}](https://kotlin.github.io/dataframe/fill.html#fillna) */
+        /** [{@include [Text]}{@arg [NameArg] `fillNA`}]({@include [Url]}/fill.html#fillna) */
         interface FillNA
     }
 
-    /** [{@include [Text]}{@arg [NameArg] Access APIs}](https://kotlin.github.io/dataframe/apilevels.html) */
+    /** [{@include [Text]}{@arg [NameArg] Access APIs}]({@include [Url]}/apilevels.html) */
     interface AccessApis {
 
-        /** [{@include [Text]}{@arg [NameArg] String API}](https://kotlin.github.io/dataframe/stringapi.html) */
+        /** [{@include [Text]}{@arg [NameArg] String API}]({@include [Url]}/stringapi.html) */
         interface StringApi
 
-        /** [{@include [Text]}{@arg [NameArg] Column Accessors API}](https://kotlin.github.io/dataframe/columnaccessorsapi.html) */
+        /** [{@include [Text]}{@arg [NameArg] Column Accessors API}]({@include [Url]}/columnaccessorsapi.html) */
         interface ColumnAccessorsApi
 
-        /** [{@include [Text]}{@arg [NameArg] KProperties API}](https://kotlin.github.io/dataframe/kpropertiesapi.html) */
+        /** [{@include [Text]}{@arg [NameArg] KProperties API}]({@include [Url]}/kpropertiesapi.html) */
         interface KPropertiesApi
 
-        /** [{@include [Text]}{@arg [NameArg] Extension Properties API}](https://kotlin.github.io/dataframe/extensionpropertiesapi.html) */
+        /** [{@include [Text]}{@arg [NameArg] Extension Properties API}]({@include [Url]}/extensionpropertiesapi.html) */
         interface ExtensionPropertiesApi
     }
 }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ColumnExpressions.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingColumns.kt
similarity index 93%
rename from core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ColumnExpressions.kt
rename to core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingColumns.kt
index 7226e8e16..c30536a42 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ColumnExpressions.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingColumns.kt
@@ -3,8 +3,7 @@ package org.jetbrains.kotlinx.dataframe.documentation
 /**
  * Column expressions.
  */
-internal interface ColumnExpressions {
-
+internal interface ExpressingColumns {
 
     /**
      * TODO
@@ -35,5 +34,4 @@ internal interface ColumnExpressions {
 
     /** [Row Column Expression][RowColumnExpression] */
     interface RowColumnExpressionLink
-
 }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DataFrameExpressions.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingDataFrames.kt
similarity index 88%
rename from core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DataFrameExpressions.kt
rename to core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingDataFrames.kt
index be4f81151..7dea513de 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DataFrameExpressions.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingDataFrames.kt
@@ -3,7 +3,7 @@ package org.jetbrains.kotlinx.dataframe.documentation
 /**
  * TODO
  */
-internal interface DataFrameExpressions {
+internal interface ExpressingDataFrames {
 
     /**
      * TODO
@@ -19,6 +19,4 @@ internal interface DataFrameExpressions {
 
     /** [Data Frame Expression][DataFrameExpression] */
     interface DataFrameExpressionLink
-
-
 }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowExpressions.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingRows.kt
similarity index 88%
rename from core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowExpressions.kt
rename to core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingRows.kt
index 62bef20f8..4425b821e 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowExpressions.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingRows.kt
@@ -3,14 +3,14 @@ package org.jetbrains.kotlinx.dataframe.documentation
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.api.*
-import org.jetbrains.kotlinx.dataframe.documentation.RowExpressions.AddDataRowNote
-import org.jetbrains.kotlinx.dataframe.documentation.RowExpressions.RowExpressionLink
-import org.jetbrains.kotlinx.dataframe.documentation.RowExpressions.RowValueExpressionLink
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressingRows.AddDataRowNote
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressingRows.RowExpressionLink
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressingRows.RowValueExpressionLink
 import org.jetbrains.kotlinx.dataframe.RowExpression as DfRowExpression
 import org.jetbrains.kotlinx.dataframe.RowValueExpression as DfRowValueExpression
 
 /**
- * ## Row expressions
+ * ## Expressing Rows
  * Expressing values using a "Row Expression" ({@include [DocumentationUrls.DataRow.RowExpressions]})
  * can occur in the following two types of operations:
  *
@@ -27,7 +27,7 @@ import org.jetbrains.kotlinx.dataframe.RowValueExpression as DfRowValueExpressio
  *
  * A Row Expression is similar to a {@include [RowConditionLink]} but that expects a [Boolean] as result.
  */
-internal interface RowExpressions {
+internal interface ExpressingRows {
 
     /**
      * The key for an @arg that will define the operation name for the examples below.
@@ -86,9 +86,9 @@ internal interface RowExpressions {
     /** [Row Value Expression][RowValueExpression.WithExample] */
     interface RowValueExpressionLink
 
-    /** @include [ColumnExpressions.RowColumnExpression] */
+    /** @include [ExpressingColumns.RowColumnExpression] */
     interface RowColumnExpression
 }
 
-/** [Row Expressions][RowExpressions] */
+/** [Row Expressions][ExpressingRows] */
 internal interface RowExpressionsLink
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
index 92ce06e7e..d493f94bc 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
@@ -15,7 +15,9 @@ import kotlin.reflect.KProperty
 /** [Selecting Columns][SelectingColumns] */
 internal interface SelectingColumnsLink
 
-/** Selecting columns for various operations (including but not limited to
+/**
+ * ## Selecting Columns
+ * Selecting columns for various operations (including but not limited to
  * [DataFrame.select], [DataFrame.update], [DataFrame.gather], and [DataFrame.fillNulls])
  * can be done in the following ways:
  * - {@include [Dsl.WithExample]}

From fd1e545cde97e6cc13fea5348ea9ae8c601d3550 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Mon, 20 Feb 2023 17:38:56 +0100
Subject: [PATCH 24/50] notNull, dataframe expression, refactoring

---
 core/build.gradle.kts                         | 10 +--
 .../jetbrains/kotlinx/dataframe/api/update.kt | 63 ++++++++++++-------
 .../documentation/ExpressingDataFrames.kt     | 21 +++++--
 .../dataframe/documentation/ExpressingRows.kt |  2 +-
 4 files changed, 64 insertions(+), 32 deletions(-)

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 41c8854d3..bf73141b9 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -61,7 +61,7 @@ kotlin.sourceSets {
 // Backup the kotlin source files location
 val kotlinMainSources = kotlin.sourceSets.main.get().kotlin.sourceDirectories
 
-val processKdocIncludeMain by creatingProcessDocTask(
+val processKDocsMain by creatingProcessDocTask(
     sources = kotlinMainSources.filterNot { "build/generated" in it.path } // Exclude generated sources
 ) {
     processors = listOf(
@@ -76,10 +76,10 @@ val processKdocIncludeMain by creatingProcessDocTask(
 
 // As a bonus, this will update dokka if you use that
 tasks.withType<org.jetbrains.dokka.gradle.AbstractDokkaLeafTask> {
-    dependsOn(processKdocIncludeMain)
+    dependsOn(processKDocsMain)
     dokkaSourceSets {
         all {
-            sourceRoot(processKdocIncludeMain.target.get())
+            sourceRoot(processKDocsMain.target.get())
 //            for (root in processKdocIncludeMain.targets)
 //                sourceRoot(root)
         }
@@ -89,7 +89,7 @@ tasks.withType<org.jetbrains.dokka.gradle.AbstractDokkaLeafTask> {
 // Modify all Jar tasks such that before running the Kotlin sources are set to
 // the target of processKdocIncludeMain and they are returned back to normal afterwards.
 tasks.withType<Jar> {
-    dependsOn(processKdocIncludeMain)
+    dependsOn(processKDocsMain)
     outputs.upToDateWhen { false }
 
     doFirst {
@@ -97,7 +97,7 @@ tasks.withType<Jar> {
             sourceSets {
                 main {
                     kotlin.setSrcDirs(
-                        processKdocIncludeMain.targets +
+                        processKDocsMain.targets +
                             kotlinMainSources.filter { "build/generated" in it.path } // Include generated sources (which were excluded above)
                     )
                 }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index b0ed4e3b2..6b88e5d6f 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -1,15 +1,8 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.AnyRow
-import org.jetbrains.kotlinx.dataframe.ColumnExpression
-import org.jetbrains.kotlinx.dataframe.ColumnsSelector
-import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.DataFrameExpression
-import org.jetbrains.kotlinx.dataframe.DataRow
-import org.jetbrains.kotlinx.dataframe.RowColumnExpression
-import org.jetbrains.kotlinx.dataframe.RowValueExpression
-import org.jetbrains.kotlinx.dataframe.RowValueFilter
+import org.jetbrains.kotlinx.dataframe.*
 import org.jetbrains.kotlinx.dataframe.api.Update.Usage
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.documentation.*
 import org.jetbrains.kotlinx.dataframe.impl.api.updateImpl
@@ -17,7 +10,6 @@ import org.jetbrains.kotlinx.dataframe.impl.api.updateWithValuePerColumnImpl
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
 import org.jetbrains.kotlinx.dataframe.impl.headPlusArray
-import org.jetbrains.kotlinx.dataframe.index
 import kotlin.reflect.KProperty
 
 /**
@@ -204,6 +196,10 @@ public fun <T, C> Update<T, C>.at(rowRange: IntRange): Update<T, C> = where { in
 public infix fun <T, C> Update<T, C>.perRowCol(expression: RowColumnExpression<T, C, C>): DataFrame<T> =
     updateImpl { row, column, _ -> expression(row, column) }
 
+/** ## Update Expression
+ * @see ExpressingRows.RowValueExpression.WithExample
+ * @see ExpressingRows.AddDataRowNote
+ */ // doc processor plugin does not work with type aliases yet
 public typealias UpdateExpression<T, C, R> = AddDataRow<T>.(C) -> R
 
 /** ## With
@@ -219,7 +215,14 @@ public infix fun <T, C> Update<T, C>.with(expression: UpdateExpression<T, C, C?>
         expression(row, value)
     }
 
-/** TODO */
+/** ## As Frame
+ *
+ * Updates selected [column group][ColumnGroup] as a [DataFrame] with the given [expression].
+ *
+ * {@include [ExpressingDataFrames.DataFrameExpression.WithExample]}
+ * {@arg [ExpressingDataFrames.OperationArg] `df.`[update][update]` { name \}.`[asFrame][asFrame]}
+ * @param expression The [DataFrameExpression] to replace the selected column group with.
+ */
 public infix fun <T, C, R> Update<T, DataRow<C>>.asFrame(expression: DataFrameExpression<C, DataFrame<R>>): DataFrame<T> =
     df.replace(columns).with { it.asColumnGroup().let { expression(it, it) }.asColumnGroup(it.name()) }
 
@@ -248,15 +251,33 @@ internal infix fun <T, C> RowValueFilter<T, C>?.and(other: RowValueFilter<T, C>)
     return { thisExp(this, it) && other(this, it) }
 }
 
-/** TODO */
+/** @include [Update.notNull] */
 public fun <T, C> Update<T, C?>.notNull(): Update<T, C> =
-    copy(filter = filter and { it != null }) as Update<T, C>
+    where { it != null } as Update<T, C>
 
-/** TODO */
-public fun <T, C> Update<T, C?>.notNull(expression: RowValueExpression<T, C, C>): DataFrame<T> =
-    notNull().updateImpl { row, column, value ->
-        expression(row, value)
-    }
+/**
+ * ## Not Null
+ *
+ * Selects only the rows where the values in the selected columns are not null.
+ *
+ * Shorthand for: [update][update]` { ... }.`[where][Update.where]` { it != null }`
+ *
+ * For example:
+ *
+ * `df.`[update][update]` { `[colsOf][colsOf]`<`[Number][Number]`?>() }.`[notNull][notNull]`()`.[perCol][Update.perCol] `{ `[mean][mean]`() }`
+ *
+ * ### Optional
+ * Provide an [expression] to update the rows with.
+ * This combines [with][Update.with] with [notNull].
+ *
+ * For example:
+ *
+ * `df.`[notNull][Update.notNull]` { city }.{ it.`[toUpperCase][String.toUpperCase]`() }`
+ *
+ * @param expression Optional {@include [ExpressingRows.RowExpressionLink]} to update the rows with.
+ */
+public fun <T, C> Update<T, C?>.notNull(expression: UpdateExpression<T, C, C>): DataFrame<T> =
+    notNull().with(expression)
 
 /**
  * @include [CommonUpdateFunctionDoc]
@@ -273,7 +294,7 @@ public fun <T, C> Update<T, C?>.notNull(expression: RowValueExpression<T, C, C>)
 public fun <T, C> DataFrame<T>.update(
     firstCol: ColumnReference<C>,
     vararg cols: ColumnReference<C>,
-    expression: RowValueExpression<T, C, C>
+    expression: UpdateExpression<T, C, C>
 ): DataFrame<T> =
     update(*headPlusArray(firstCol, cols)).with(expression)
 
@@ -292,7 +313,7 @@ public fun <T, C> DataFrame<T>.update(
 public fun <T, C> DataFrame<T>.update(
     firstCol: KProperty<C>,
     vararg cols: KProperty<C>,
-    expression: RowValueExpression<T, C, C>
+    expression: UpdateExpression<T, C, C>
 ): DataFrame<T> =
     update(*headPlusArray(firstCol, cols)).with(expression)
 
@@ -311,7 +332,7 @@ public fun <T, C> DataFrame<T>.update(
 public fun <T> DataFrame<T>.update(
     firstCol: String,
     vararg cols: String,
-    expression: RowValueExpression<T, Any?, Any?>
+    expression: UpdateExpression<T, Any?, Any?>
 ): DataFrame<T> =
     update(*headPlusArray(firstCol, cols)).with(expression)
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingDataFrames.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingDataFrames.kt
index 7dea513de..f4df459eb 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingDataFrames.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingDataFrames.kt
@@ -1,18 +1,29 @@
 package org.jetbrains.kotlinx.dataframe.documentation
 
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressingDataFrames.DataFrameExpressionLink
+import org.jetbrains.kotlinx.dataframe.DataFrameExpression as DfDataFrameExpression
+
 /**
- * TODO
+ * ## Expressing Data Frames
+ * Expressing values using a "Data Frame Expression" can occur exclusively in a
+ * {@include [DataFrameExpressionLink]}
+ *
  */
 internal interface ExpressingDataFrames {
 
-    /**
-     * TODO
-     */
+    interface OperationArg
+
+    /** Provide a new value for every selected data frame using a [dataframe expression][DfDataFrameExpression]. */
     interface DataFrameExpression {
 
         /**
-         * TODO
          * @include [DataFrameExpression]
+         *
+         * For example:
+         *
+         * {@includeArg [OperationArg]}` { `[select][DataFrame.select]` { lastName } }`
          */
         interface WithExample
     }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingRows.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingRows.kt
index 4425b821e..da6a3f707 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingRows.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingRows.kt
@@ -39,7 +39,7 @@ internal interface ExpressingRows {
     interface SetDefaultOperationArg
 
     /**
-     * [with][org.jetbrains.kotlinx.dataframe.api.Update.with] and [add][org.jetbrains.kotlinx.dataframe.api.add] use [AddDataRow] instead of [DataRow] as the DSL's receiver type.
+     * [update with][org.jetbrains.kotlinx.dataframe.api.Update.with]- and [add][org.jetbrains.kotlinx.dataframe.api.add]-like expressions use [AddDataRow] instead of [DataRow] as the DSL's receiver type.
      * This is an extension to [RowValueExpression][DfRowValueExpression] and
      * [RowExpression][DfRowExpression] that provides access to
      * the modified/generated value of the preceding row ([AddDataRow.newValue]).

From a795a9d663454052d4892c02d3544c36564428e4 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Mon, 20 Feb 2023 21:50:42 +0100
Subject: [PATCH 25/50] refactoring

---
 core/build.gradle.kts                                |  4 +---
 .../org/jetbrains/kotlinx/dataframe/api/Nulls.kt     |  9 ---------
 .../org/jetbrains/kotlinx/dataframe/api/update.kt    |  3 ---
 .../dataframe/documentation/SelectingColumns.kt      | 12 ++++--------
 4 files changed, 5 insertions(+), 23 deletions(-)

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index bf73141b9..7c57203f5 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -14,7 +14,7 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.15"
+    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.16"
 //    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
 }
 
@@ -80,8 +80,6 @@ tasks.withType<org.jetbrains.dokka.gradle.AbstractDokkaLeafTask> {
     dokkaSourceSets {
         all {
             sourceRoot(processKDocsMain.target.get())
-//            for (root in processKdocIncludeMain.targets)
-//                sourceRoot(root)
         }
     }
 }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index 49a99d8b5..1e20fd6ab 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -79,9 +79,6 @@ public fun <T, C> DataFrame<T>.fillNulls(vararg columns: ColumnReference<C>): Up
     fillNulls { columns.toColumns() }
 
 /**
- * @include [CommonFillNullsFunctionDoc]
- * @include [SelectingColumns.ColumnAccessors.WithExample] {@include [SetFillNullsOperationArg]}
- * @include [Update.ColumnAccessorsParam]
  * TODO this will be deprecated
  */
 public fun <T, C> DataFrame<T>.fillNulls(columns: Iterable<ColumnReference<C>>): Update<T, C?> =
@@ -195,9 +192,6 @@ public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: ColumnReference<C>): Upd
     fillNaNs { columns.toColumns() }
 
 /**
- * @include [CommonFillNaNsFunctionDoc]
- * @include [SelectingColumns.ColumnAccessors.WithExample] {@include [SetFillNaNsOperationArg]}
- * @include [Update.ColumnAccessorsParam]
  * TODO this will be deprecated
  */
 public fun <T, C> DataFrame<T>.fillNaNs(columns: Iterable<ColumnReference<C>>): Update<T, C> =
@@ -267,9 +261,6 @@ public fun <T, C> DataFrame<T>.fillNA(vararg columns: ColumnReference<C>): Updat
     fillNA { columns.toColumns() }
 
 /**
- * @include [CommonFillNAFunctionDoc]
- * @include [SelectingColumns.ColumnAccessors.WithExample] {@include [SetFillNAOperationArg]}
- * @include [Update.ColumnAccessorsParam]
  * TODO this will be deprecated
  */
 public fun <T, C> DataFrame<T>.fillNA(columns: Iterable<ColumnReference<C>>): Update<T, C?> =
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index 6b88e5d6f..1974d8a9e 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -126,9 +126,6 @@ public fun <T, C> DataFrame<T>.update(vararg columns: ColumnReference<C>): Updat
     update { columns.toColumns() }
 
 /**
- * @include [CommonUpdateFunctionDoc]
- * @include [SelectingColumns.ColumnAccessors.WithExample] {@include [SetSelectingColumnsOperationArg]}
- * @include [Update.ColumnAccessorsParam]
  * TODO this will be deprecated
  */
 public fun <T, C> DataFrame<T>.update(columns: Iterable<ColumnReference<C>>): Update<T, C> =
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
index d493f94bc..aea0fa8e5 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
@@ -45,8 +45,7 @@ internal interface SelectingColumns {
      */
     interface Dsl {
 
-        /**
-         * {@include [Dsl]}
+        /** {@include [Dsl]}
          *
          * For example:
          *
@@ -65,8 +64,7 @@ internal interface SelectingColumns {
      */
     interface ColumnNames {
 
-        /**
-         * {@include [ColumnNames]}
+        /** {@include [ColumnNames]}
          *
          * For example:
          *
@@ -81,8 +79,7 @@ internal interface SelectingColumns {
      */
     interface ColumnAccessors {
 
-        /**
-         * {@include [ColumnAccessors]}
+        /** {@include [ColumnAccessors]}
          *
          * For example:
          *
@@ -99,8 +96,7 @@ internal interface SelectingColumns {
     /** Select columns using [KProperties][KProperty] ({@include [AccessApi.KPropertiesApiLink]}). */
     interface KProperties {
 
-        /**
-         * {@include [KProperties]}
+        /** {@include [KProperties]}
          *
          * For example:
          * ```kotlin

From e9f7fd0d5959d0268899353eba4a99fd70c8e64e Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Tue, 21 Feb 2023 14:06:42 +0100
Subject: [PATCH 26/50] fixed some rendering issues

---
 .../kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt    | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index 1974d8a9e..ece8835a4 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -46,12 +46,12 @@ public data class Update<T, C>(
      *
      * - `.`[with][Update.with]` { `[rowExpression][ExpressingRows.RowValueExpression.WithExample]` }
      *   | .`[notNull][Update.notNull]` { `[rowExpression][ExpressingRows.RowValueExpression.WithExample]` }
-     *   | .`[perCol][Update.perCol]` { [colExpression][ExpressingColumns.ColumnExpression.WithExample] }
-     *   | .`[perRowCol][Update.perRowCol]` { [rowColExpression][ExpressingColumns.RowColumnExpression.WithExample] }
+     *   | .`[perCol][Update.perCol]` { `[colExpression][ExpressingColumns.ColumnExpression.WithExample]` }
+     *   | .`[perRowCol][Update.perRowCol]` { `[rowColExpression][ExpressingColumns.RowColumnExpression.WithExample]` }
      *   | .`[withValue][Update.withValue]`(value)
      *   | .`[withNull][Update.withNull]`()
      *   | .`[withZero][Update.withZero]`()
-     *   | .`[asFrame][Update.asFrame]` { [dataFrameExpression][ExpressingDataFrames.DataFrameExpression.WithExample] }`
+     *   | .`[asFrame][Update.asFrame]` { `[dataFrameExpression][ExpressingDataFrames.DataFrameExpression.WithExample]` }`
      * {@arg [UpdateOperationArg] [update][update]}{@comment The default name of the `update` operation function name.}
      */
     public interface Usage

From d6c5f1bbc0318716b9552c2364ad18030be3b3da Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Tue, 21 Feb 2023 16:29:25 +0100
Subject: [PATCH 27/50] refactoring

---
 .../org/jetbrains/kotlinx/dataframe/api/update.kt    | 12 ++++++------
 .../dataframe/documentation/SelectingColumns.kt      |  2 +-
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index ece8835a4..88d0679ed 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -90,7 +90,7 @@ private interface CommonUpdateFunctionDoc
  * Combine `df.`[update][update]`(...).`[with][Update.with]` { ... }`
  * into `df.`[update][update]`(...) { ... }`
  */
-private interface UpdatePlusWithNote
+private interface UpdateWithNote
 
 /**
  * @include [CommonUpdateFunctionDoc]
@@ -103,7 +103,7 @@ public fun <T, C> DataFrame<T>.update(columns: ColumnsSelector<T, C>): Update<T,
 /**
  * @include [CommonUpdateFunctionDoc]
  * @include [SelectingColumns.ColumnNames.WithExample] {@include [SetSelectingColumnsOperationArg]}
- * @include [UpdatePlusWithNote]
+ * @include [UpdateWithNote]
  * @include [Update.ColumnNamesParam]
  */
 public fun <T> DataFrame<T>.update(vararg columns: String): Update<T, Any?> = update { columns.toColumns() }
@@ -111,7 +111,7 @@ public fun <T> DataFrame<T>.update(vararg columns: String): Update<T, Any?> = up
 /**
  * @include [CommonUpdateFunctionDoc]
  * @include [SelectingColumns.KProperties.WithExample] {@include [SetSelectingColumnsOperationArg]}
- * @include [UpdatePlusWithNote]
+ * @include [UpdateWithNote]
  * @include [Update.KPropertiesParam]
  */
 public fun <T, C> DataFrame<T>.update(vararg columns: KProperty<C>): Update<T, C> = update { columns.toColumns() }
@@ -119,7 +119,7 @@ public fun <T, C> DataFrame<T>.update(vararg columns: KProperty<C>): Update<T, C
 /**
  * @include [CommonUpdateFunctionDoc]
  * @include [SelectingColumns.ColumnAccessors.WithExample] {@include [SetSelectingColumnsOperationArg]}
- * @include [UpdatePlusWithNote]
+ * @include [UpdateWithNote]
  * @include [Update.ColumnAccessorsParam]
  */
 public fun <T, C> DataFrame<T>.update(vararg columns: ColumnReference<C>): Update<T, C> =
@@ -241,7 +241,7 @@ public fun <T, C> Update<T, C>.perCol(values: AnyRow): DataFrame<T> = perCol(val
 public fun <T, C> Update<T, C>.perCol(valueSelector: ColumnExpression<C, C>): DataFrame<T> =
     updateWithValuePerColumnImpl(valueSelector)
 
-/** TODO */
+/** Chains up two row value filters together. */
 internal infix fun <T, C> RowValueFilter<T, C>?.and(other: RowValueFilter<T, C>): RowValueFilter<T, C> {
     if (this == null) return other
     val thisExp = this
@@ -269,7 +269,7 @@ public fun <T, C> Update<T, C?>.notNull(): Update<T, C> =
  *
  * For example:
  *
- * `df.`[notNull][Update.notNull]` { city }.{ it.`[toUpperCase][String.toUpperCase]`() }`
+ * `df.`[update][update]` { city }.`[notNull][Update.notNull]` { it.`[toUpperCase][String.toUpperCase]`() }`
  *
  * @param expression Optional {@include [ExpressingRows.RowExpressionLink]} to update the rows with.
  */
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
index aea0fa8e5..36108f6d5 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
@@ -49,7 +49,7 @@ internal interface SelectingColumns {
          *
          * For example:
          *
-         * `df.`{@includeArg [OperationArg]}` { length `[and][ColumnsSelectionDsl.and]` age }`
+         * `df.`{@includeArg [OperationArg]}` { length `[and][ColumnsSelectionDsl.and]` age }`{@comment TODO this links up like "kotlin.String.and"}
          *
          * `df.`{@includeArg [OperationArg]}` { `[cols][ColumnsSelectionDsl.cols]`(1..5) }`
          *

From 2c2a6109f2b7d9f0712cd0388acf068bfe78c8b3 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Tue, 21 Feb 2023 17:51:30 +0100
Subject: [PATCH 28/50] updated doc processor plugin

---
 core/build.gradle.kts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 7c57203f5..089fd3803 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -14,7 +14,7 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.16"
+    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.17"
 //    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
 }
 

From eeb36c0f81988ce31200a61346cb5cc3071b7dfa Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Wed, 22 Feb 2023 14:02:52 +0100
Subject: [PATCH 29/50] updating doc processor plugin

---
 core/build.gradle.kts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 089fd3803..2a4c7ff51 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -14,7 +14,7 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.17"
+    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.18"
 //    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
 }
 

From aa311a4d10a1a7f0eeaa707a1b9d5440aab8a409 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Wed, 22 Feb 2023 14:10:16 +0100
Subject: [PATCH 30/50] reverted Column -> AnyColumnReference to not clog up
 the PR

---
 .../jetbrains/kotlinx/dataframe/DataFrame.kt  |  2 +-
 .../jetbrains/kotlinx/dataframe/DataRow.kt    |  2 +-
 .../jetbrains/kotlinx/dataframe/aliases.kt    |  2 +-
 .../dataframe/api/ColumnsSelectionDsl.kt      | 10 +++++-----
 .../kotlinx/dataframe/api/DataFrameGet.kt     |  4 ++--
 .../kotlinx/dataframe/api/DataRowApi.kt       |  6 +++---
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  | 10 +++++-----
 .../jetbrains/kotlinx/dataframe/api/add.kt    | 10 +++++-----
 .../kotlinx/dataframe/api/countDistinct.kt    |  4 ++--
 .../jetbrains/kotlinx/dataframe/api/cumSum.kt |  6 +++---
 .../kotlinx/dataframe/api/distinct.kt         | 10 +++++-----
 .../jetbrains/kotlinx/dataframe/api/group.kt  |  6 +++---
 .../kotlinx/dataframe/api/groupBy.kt          |  8 ++++----
 .../jetbrains/kotlinx/dataframe/api/move.kt   | 16 +++++++--------
 .../jetbrains/kotlinx/dataframe/api/pivot.kt  | 20 +++++++++----------
 .../jetbrains/kotlinx/dataframe/api/remove.kt | 10 +++++-----
 .../jetbrains/kotlinx/dataframe/api/select.kt |  6 +++---
 .../kotlinx/dataframe/api/toDataFrame.kt      |  4 ++--
 .../jetbrains/kotlinx/dataframe/api/unfold.kt |  4 ++--
 .../kotlinx/dataframe/api/ungroup.kt          |  4 ++--
 .../kotlinx/dataframe/api/valueCounts.kt      |  4 ++--
 .../jetbrains/kotlinx/dataframe/api/values.kt | 14 ++++++-------
 .../jetbrains/kotlinx/dataframe/api/with.kt   |  4 ++--
 .../impl/aggregation/aggregations.kt          |  4 ++--
 .../kotlinx/dataframe/impl/api/move.kt        |  4 ++--
 25 files changed, 87 insertions(+), 87 deletions(-)

diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataFrame.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataFrame.kt
index 9698f9630..dd1c55636 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataFrame.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataFrame.kt
@@ -57,7 +57,7 @@ public interface DataFrame<out T> : Aggregatable<T>, ColumnsContainer<T> {
     override operator fun <C> get(columns: ColumnsSelector<T, C>): List<DataColumn<C>> =
         getColumnsImpl(UnresolvedColumnsPolicy.Fail, columns)
 
-    public operator fun get(first: AnyColumnReference, vararg other: AnyColumnReference): DataFrame<T> = select(listOf(first) + other)
+    public operator fun get(first: Column, vararg other: Column): DataFrame<T> = select(listOf(first) + other)
     public operator fun get(first: String, vararg other: String): DataFrame<T> = select(listOf(first) + other)
     public operator fun get(columnRange: ClosedRange<String>): DataFrame<T> =
         select { columnRange.start..columnRange.endInclusive }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataRow.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataRow.kt
index 5a1375436..989fb3df2 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataRow.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataRow.kt
@@ -28,7 +28,7 @@ public interface DataRow<out T> {
     public operator fun <R> get(column: ColumnReference<R>): R
     public operator fun <R> get(columns: List<ColumnReference<R>>): List<R> = columns.map { get(it) }
     public operator fun <R> get(property: KProperty<R>): R = get(property.columnName) as R
-    public operator fun get(first: AnyColumnReference, vararg other: AnyColumnReference): DataRow<T> = owner.get(first, *other)[index]
+    public operator fun get(first: Column, vararg other: Column): DataRow<T> = owner.get(first, *other)[index]
     public operator fun get(first: String, vararg other: String): DataRow<T> = owner.get(first, *other)[index]
     public operator fun get(path: ColumnPath): Any? = owner.get(path)[index]
     public operator fun get(name: String): Any?
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt
index 064bbeb02..de7a58df5 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt
@@ -149,7 +149,7 @@ public typealias RowValueFilter<T, C> = RowValueExpression<T, C, Boolean>
 
 // region columns
 
-public typealias AnyColumnReference = ColumnReference<*>
+public typealias Column = ColumnReference<*>
 
 public typealias ColumnGroupReference = ColumnReference<AnyRow>
 public typealias ColumnGroupAccessor<T> = ColumnAccessor<DataRow<T>>
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
index 448b7bf36..43ffc0908 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
@@ -74,7 +74,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     public operator fun String.rangeTo(endInclusive: String): ColumnSet<*> = toColumnAccessor().rangeTo(endInclusive.toColumnAccessor())
 
-    public operator fun AnyColumnReference.rangeTo(endInclusive: AnyColumnReference): ColumnSet<*> = object : ColumnSet<Any?> {
+    public operator fun Column.rangeTo(endInclusive: Column): ColumnSet<*> = object : ColumnSet<Any?> {
         override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<Any?>> {
             val startPath = this@rangeTo.resolveSingle(context)!!.path
             val endPath = endInclusive.resolveSingle(context)!!.path
@@ -168,7 +168,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     }
 
     public fun SingleColumn<*>.allAfter(colName: String): ColumnSet<Any?> = allAfter(pathOf(colName))
-    public fun SingleColumn<*>.allAfter(column: AnyColumnReference): ColumnSet<Any?> = allAfter(column.path())
+    public fun SingleColumn<*>.allAfter(column: Column): ColumnSet<Any?> = allAfter(column.path())
 
     // endregion
 
@@ -187,7 +187,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     }
 
     public fun SingleColumn<*>.allSince(colName: String): ColumnSet<Any?> = allSince(pathOf(colName))
-    public fun SingleColumn<*>.allSince(column: AnyColumnReference): ColumnSet<Any?> = allSince(column.path())
+    public fun SingleColumn<*>.allSince(column: Column): ColumnSet<Any?> = allSince(column.path())
 
     // endregion
 
@@ -206,7 +206,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     }
 
     public fun SingleColumn<*>.allBefore(colName: String): ColumnSet<Any?> = allBefore(pathOf(colName))
-    public fun SingleColumn<*>.allBefore(column: AnyColumnReference): ColumnSet<Any?> = allBefore(column.path())
+    public fun SingleColumn<*>.allBefore(column: Column): ColumnSet<Any?> = allBefore(column.path())
 
     // endregion
 
@@ -225,7 +225,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     }
 
     public fun SingleColumn<*>.allUntil(colName: String): ColumnSet<Any?> = allUntil(pathOf(colName))
-    public fun SingleColumn<*>.allUntil(column: AnyColumnReference): ColumnSet<Any?> = allUntil(column.path())
+    public fun SingleColumn<*>.allUntil(column: Column): ColumnSet<Any?> = allUntil(column.path())
 
     // endregion
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataFrameGet.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataFrameGet.kt
index 354d5990d..63588c4e9 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataFrameGet.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataFrameGet.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyCol
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnSelector
 import org.jetbrains.kotlinx.dataframe.ColumnsContainer
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
@@ -88,7 +88,7 @@ public fun <T> ColumnsContainer<T>.getColumnGroupOrNull(column: KProperty<*>): C
 public fun <C> ColumnsContainer<*>.containsColumn(column: ColumnReference<C>): Boolean = getColumnOrNull(column) != null
 public fun ColumnsContainer<*>.containsColumn(column: KProperty<*>): Boolean = containsColumn(column.columnName)
 
-public operator fun ColumnsContainer<*>.contains(column: AnyColumnReference): Boolean = containsColumn(column)
+public operator fun ColumnsContainer<*>.contains(column: Column): Boolean = containsColumn(column)
 public operator fun ColumnsContainer<*>.contains(column: KProperty<*>): Boolean = containsColumn(column)
 
 // region rows
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowApi.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowApi.kt
index d7987f5c4..2860c274e 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowApi.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowApi.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.AnyRow
 import org.jetbrains.kotlinx.dataframe.ColumnsContainer
 import org.jetbrains.kotlinx.dataframe.DataColumn
@@ -57,10 +57,10 @@ public fun <T> AnyRow.getValueOrNull(column: KProperty<T>): T? = getValueOrNull<
 // region contains
 
 public fun AnyRow.containsKey(columnName: String): Boolean = owner.containsColumn(columnName)
-public fun AnyRow.containsKey(column: AnyColumnReference): Boolean = owner.containsColumn(column)
+public fun AnyRow.containsKey(column: Column): Boolean = owner.containsColumn(column)
 public fun AnyRow.containsKey(column: KProperty<*>): Boolean = owner.containsColumn(column)
 
-public operator fun AnyRow.contains(column: AnyColumnReference): Boolean = containsKey(column)
+public operator fun AnyRow.contains(column: Column): Boolean = containsKey(column)
 public operator fun AnyRow.contains(column: KProperty<*>): Boolean = containsKey(column)
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index 1e20fd6ab..bc6477885 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyCol
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.AnyFrame
 import org.jetbrains.kotlinx.dataframe.AnyRow
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
@@ -285,11 +285,11 @@ public fun <T> DataFrame<T>.dropNulls(vararg columns: KProperty<*>, whereAllNull
 public fun <T> DataFrame<T>.dropNulls(vararg columns: String, whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNulls(vararg columns: AnyColumnReference, whereAllNull: Boolean = false): DataFrame<T> =
+public fun <T> DataFrame<T>.dropNulls(vararg columns: Column, whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumns() }
 
 public fun <T> DataFrame<T>.dropNulls(
-    columns: Iterable<AnyColumnReference>,
+    columns: Iterable<Column>,
     whereAllNull: Boolean = false
 ): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumnSet() }
@@ -314,10 +314,10 @@ public fun <T> DataFrame<T>.dropNA(vararg columns: KProperty<*>, whereAllNA: Boo
 public fun <T> DataFrame<T>.dropNA(vararg columns: String, whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNA(vararg columns: AnyColumnReference, whereAllNA: Boolean = false): DataFrame<T> =
+public fun <T> DataFrame<T>.dropNA(vararg columns: Column, whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNA(columns: Iterable<AnyColumnReference>, whereAllNA: Boolean = false): DataFrame<T> =
+public fun <T> DataFrame<T>.dropNA(columns: Iterable<Column>, whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { columns.toColumnSet() }
 
 public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false): DataFrame<T> =
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
index 2a9375869..c33d5b947 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
@@ -3,7 +3,7 @@ package org.jetbrains.kotlinx.dataframe.api
 import org.jetbrains.kotlinx.dataframe.AnyBaseCol
 import org.jetbrains.kotlinx.dataframe.AnyCol
 import org.jetbrains.kotlinx.dataframe.AnyColumnGroupAccessor
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.AnyFrame
 import org.jetbrains.kotlinx.dataframe.AnyRow
 import org.jetbrains.kotlinx.dataframe.ColumnsContainer
@@ -160,9 +160,9 @@ public class AddDsl<T>(@PublishedApi internal val df: DataFrame<T>) : ColumnsCon
     // TODO: support adding column into path
     internal val columns = mutableListOf<AnyCol>()
 
-    public fun add(column: AnyColumnReference): Boolean = columns.add(column.resolveSingle(df)!!.data)
+    public fun add(column: Column): Boolean = columns.add(column.resolveSingle(df)!!.data)
 
-    public operator fun AnyColumnReference.unaryPlus(): Boolean = add(this)
+    public operator fun Column.unaryPlus(): Boolean = add(this)
 
     public operator fun String.unaryPlus(): Boolean = add(df[this])
 
@@ -187,11 +187,11 @@ public class AddDsl<T>(@PublishedApi internal val df: DataFrame<T>) : ColumnsCon
     public inline infix fun <reified R> KProperty<R>.from(noinline expression: RowExpression<T, R>): Boolean =
         add(name, Infer.Nulls, expression)
 
-    public infix fun String.from(column: AnyColumnReference): Boolean = add(column.rename(this))
+    public infix fun String.from(column: Column): Boolean = add(column.rename(this))
     public inline infix fun <reified R> ColumnAccessor<R>.from(column: ColumnReference<R>): Boolean = name() from column
     public inline infix fun <reified R> KProperty<R>.from(column: ColumnReference<R>): Boolean = name from column
 
-    public infix fun AnyColumnReference.into(name: String): Boolean = add(rename(name))
+    public infix fun Column.into(name: String): Boolean = add(rename(name))
     public infix fun <R> ColumnReference<R>.into(column: ColumnAccessor<R>): Boolean = into(column.name())
     public infix fun <R> ColumnReference<R>.into(column: KProperty<R>): Boolean = into(column.name)
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
index cc4b04301..931983e76 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.AnyFrame
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -19,7 +19,7 @@ public fun <T, C> DataFrame<T>.countDistinct(columns: ColumnsSelector<T, C>): In
 
 public fun <T> DataFrame<T>.countDistinct(vararg columns: String): Int = countDistinct { columns.toColumns() }
 public fun <T, C> DataFrame<T>.countDistinct(vararg columns: KProperty<C>): Int = countDistinct { columns.toColumns() }
-public fun <T> DataFrame<T>.countDistinct(vararg columns: AnyColumnReference): Int =
+public fun <T> DataFrame<T>.countDistinct(vararg columns: Column): Int =
     countDistinct { columns.toColumns() }
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt
index f67760cf3..be60508cd 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -38,7 +38,7 @@ private val supportedClasses = setOf(Double::class, Float::class, Int::class, Lo
 public fun <T, C> DataFrame<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA, columns: ColumnsSelector<T, C>): DataFrame<T> =
     convert(columns).to { if (it.typeClass in supportedClasses) it.cast<Number?>().cumSum(skipNA) else it }
 public fun <T> DataFrame<T>.cumSum(vararg columns: String, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) { columns.toColumns() }
-public fun <T> DataFrame<T>.cumSum(vararg columns: AnyColumnReference, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) { columns.toColumns() }
+public fun <T> DataFrame<T>.cumSum(vararg columns: Column, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) { columns.toColumns() }
 public fun <T> DataFrame<T>.cumSum(vararg columns: KProperty<*>, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) { columns.toColumns() }
 
 public fun <T> DataFrame<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) { allDfs() }
@@ -50,7 +50,7 @@ public fun <T> DataFrame<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataF
 public fun <T, G, C> GroupBy<T, G>.cumSum(skipNA: Boolean = defaultCumSumSkipNA, columns: ColumnsSelector<G, C>): GroupBy<T, G> =
     updateGroups { cumSum(skipNA, columns) }
 public fun <T, G> GroupBy<T, G>.cumSum(vararg columns: String, skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> = cumSum(skipNA) { columns.toColumns() }
-public fun <T, G> GroupBy<T, G>.cumSum(vararg columns: AnyColumnReference, skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> = cumSum(skipNA) { columns.toColumns() }
+public fun <T, G> GroupBy<T, G>.cumSum(vararg columns: Column, skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> = cumSum(skipNA) { columns.toColumns() }
 public fun <T, G> GroupBy<T, G>.cumSum(vararg columns: KProperty<*>, skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> = cumSum(skipNA) { columns.toColumns() }
 public fun <T, G> GroupBy<T, G>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> = cumSum(skipNA) { allDfs() }
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt
index 7c72af4e6..c0c072c33 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
@@ -18,19 +18,19 @@ public fun <T> DataFrame<T>.distinct(vararg columns: KProperty<*>): DataFrame<T>
     set
 }
 public fun <T> DataFrame<T>.distinct(vararg columns: String): DataFrame<T> = distinct { columns.toColumns() }
-public fun <T> DataFrame<T>.distinct(vararg columns: AnyColumnReference): DataFrame<T> = distinct { columns.toColumns() }
+public fun <T> DataFrame<T>.distinct(vararg columns: Column): DataFrame<T> = distinct { columns.toColumns() }
 
 @JvmName("distinctT")
 public fun <T> DataFrame<T>.distinct(columns: Iterable<String>): DataFrame<T> = distinct { columns.toColumns() }
-public fun <T> DataFrame<T>.distinct(columns: Iterable<AnyColumnReference>): DataFrame<T> = distinct { columns.toColumnSet() }
+public fun <T> DataFrame<T>.distinct(columns: Iterable<Column>): DataFrame<T> = distinct { columns.toColumnSet() }
 
 public fun <T> DataFrame<T>.distinctBy(vararg columns: KProperty<*>): DataFrame<T> = distinctBy { columns.toColumns() }
 public fun <T> DataFrame<T>.distinctBy(vararg columns: String): DataFrame<T> = distinctBy { columns.toColumns() }
-public fun <T> DataFrame<T>.distinctBy(vararg columns: AnyColumnReference): DataFrame<T> = distinctBy { columns.toColumns() }
+public fun <T> DataFrame<T>.distinctBy(vararg columns: Column): DataFrame<T> = distinctBy { columns.toColumns() }
 
 @JvmName("distinctByT")
 public fun <T> DataFrame<T>.distinctBy(columns: Iterable<String>): DataFrame<T> = distinctBy { columns.toColumns() }
-public fun <T> DataFrame<T>.distinctBy(columns: Iterable<AnyColumnReference>): DataFrame<T> = distinctBy { columns.toColumnSet() }
+public fun <T> DataFrame<T>.distinctBy(columns: Iterable<Column>): DataFrame<T> = distinctBy { columns.toColumnSet() }
 
 public fun <T, C> DataFrame<T>.distinctBy(columns: ColumnsSelector<T, C>): DataFrame<T> {
     val cols = get(columns)
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt
index c83f2db3f..2c75681d3 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyColumnGroupAccessor
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
@@ -16,7 +16,7 @@ public data class GroupClause<T, C>(val df: DataFrame<T>, val columns: ColumnsSe
 
 public fun <T, C> DataFrame<T>.group(columns: ColumnsSelector<T, C>): GroupClause<T, C> = GroupClause(this, columns)
 public fun <T> DataFrame<T>.group(vararg columns: String): GroupClause<T, Any?> = group { columns.toColumns() }
-public fun <T> DataFrame<T>.group(vararg columns: AnyColumnReference): GroupClause<T, Any?> = group { columns.toColumns() }
+public fun <T> DataFrame<T>.group(vararg columns: Column): GroupClause<T, Any?> = group { columns.toColumns() }
 public fun <T> DataFrame<T>.group(vararg columns: KProperty<*>): GroupClause<T, Any?> = group { columns.toColumns() }
 
 @JvmName("intoString")
@@ -25,7 +25,7 @@ public fun <T> DataFrame<T>.group(vararg columns: KProperty<*>): GroupClause<T,
 public infix fun <T, C> GroupClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> String): DataFrame<T> = df.move(columns).under { column(it).toColumnAccessor() }
 
 @JvmName("intoColumn")
-public infix fun <T, C> GroupClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> AnyColumnReference): DataFrame<T> = df.move(columns).under(column)
+public infix fun <T, C> GroupClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> Column): DataFrame<T> = df.move(columns).under(column)
 public infix fun <T, C> GroupClause<T, C>.into(column: String): DataFrame<T> = into(columnGroup().named(column))
 public infix fun <T, C> GroupClause<T, C>.into(column: AnyColumnGroupAccessor): DataFrame<T> = df.move(columns).under(column)
 public infix fun <T, C> GroupClause<T, C>.into(column: KProperty<*>): DataFrame<T> = into(column.columnName)
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
index 8796681dd..8bd1d05f5 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.AnyFrame
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -21,10 +21,10 @@ import kotlin.reflect.KProperty
 public fun <T> DataFrame<T>.groupBy(moveToTop: Boolean = true, cols: ColumnsSelector<T, *>): GroupBy<T, T> =
     groupByImpl(moveToTop, cols)
 
-public fun <T> DataFrame<T>.groupBy(cols: Iterable<AnyColumnReference>): GroupBy<T, T> = groupBy { cols.toColumnSet() }
+public fun <T> DataFrame<T>.groupBy(cols: Iterable<Column>): GroupBy<T, T> = groupBy { cols.toColumnSet() }
 public fun <T> DataFrame<T>.groupBy(vararg cols: KProperty<*>): GroupBy<T, T> = groupBy { cols.toColumns() }
 public fun <T> DataFrame<T>.groupBy(vararg cols: String): GroupBy<T, T> = groupBy { cols.toColumns() }
-public fun <T> DataFrame<T>.groupBy(vararg cols: AnyColumnReference, moveToTop: Boolean = true): GroupBy<T, T> =
+public fun <T> DataFrame<T>.groupBy(vararg cols: Column, moveToTop: Boolean = true): GroupBy<T, T> =
     groupBy(moveToTop) { cols.toColumns() }
 
 // endregion
@@ -34,7 +34,7 @@ public fun <T> DataFrame<T>.groupBy(vararg cols: AnyColumnReference, moveToTop:
 public fun <T> Pivot<T>.groupBy(moveToTop: Boolean = true, columns: ColumnsSelector<T, *>): PivotGroupBy<T> =
     (this as PivotImpl<T>).toGroupedPivot(moveToTop, columns)
 
-public fun <T> Pivot<T>.groupBy(vararg columns: AnyColumnReference): PivotGroupBy<T> = groupBy { columns.toColumns() }
+public fun <T> Pivot<T>.groupBy(vararg columns: Column): PivotGroupBy<T> = groupBy { columns.toColumns() }
 public fun <T> Pivot<T>.groupBy(vararg columns: String): PivotGroupBy<T> = groupBy { columns.toColumns() }
 public fun <T> Pivot<T>.groupBy(vararg columns: KProperty<*>): PivotGroupBy<T> = groupBy { columns.toColumns() }
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
index 90ec36cf3..5a01944c5 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyColumnGroupAccessor
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnSelector
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -21,20 +21,20 @@ public fun <T, C> DataFrame<T>.move(vararg cols: KProperty<C>): MoveClause<T, C>
 
 public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, columns: ColumnsSelector<T, *>): DataFrame<T> = move(columns).to(newColumnIndex)
 public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, vararg columns: String): DataFrame<T> = moveTo(newColumnIndex) { columns.toColumns() }
-public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, vararg columns: AnyColumnReference): DataFrame<T> = moveTo(newColumnIndex) { columns.toColumns() }
+public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, vararg columns: Column): DataFrame<T> = moveTo(newColumnIndex) { columns.toColumns() }
 public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, vararg columns: KProperty<*>): DataFrame<T> = moveTo(newColumnIndex) { columns.toColumns() }
 
 public fun <T> DataFrame<T>.moveToLeft(columns: ColumnsSelector<T, *>): DataFrame<T> = move(columns).toLeft()
 public fun <T> DataFrame<T>.moveToLeft(vararg columns: String): DataFrame<T> = moveToLeft { columns.toColumns() }
-public fun <T> DataFrame<T>.moveToLeft(vararg columns: AnyColumnReference): DataFrame<T> = moveToLeft { columns.toColumns() }
+public fun <T> DataFrame<T>.moveToLeft(vararg columns: Column): DataFrame<T> = moveToLeft { columns.toColumns() }
 public fun <T> DataFrame<T>.moveToLeft(vararg columns: KProperty<*>): DataFrame<T> = moveToLeft { columns.toColumns() }
 
 public fun <T> DataFrame<T>.moveToRight(columns: ColumnsSelector<T, *>): DataFrame<T> = move(columns).toRight()
 public fun <T> DataFrame<T>.moveToRight(vararg columns: String): DataFrame<T> = moveToRight { columns.toColumns() }
-public fun <T> DataFrame<T>.moveToRight(vararg columns: AnyColumnReference): DataFrame<T> = moveToRight { columns.toColumns() }
+public fun <T> DataFrame<T>.moveToRight(vararg columns: Column): DataFrame<T> = moveToRight { columns.toColumns() }
 public fun <T> DataFrame<T>.moveToRight(vararg columns: KProperty<*>): DataFrame<T> = moveToRight { columns.toColumns() }
 
-public fun <T, C> MoveClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> AnyColumnReference): DataFrame<T> = moveImpl(
+public fun <T, C> MoveClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> Column): DataFrame<T> = moveImpl(
     under = false,
     column
 )
@@ -42,7 +42,7 @@ public fun <T, C> MoveClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWi
 public fun <T, C> MoveClause<T, C>.into(column: String): DataFrame<T> = pathOf(column).let { path -> into { path } }
 
 public fun <T, C> MoveClause<T, C>.intoIndexed(
-    newPathExpression: ColumnsSelectionDsl<T>.(ColumnWithPath<C>, Int) -> AnyColumnReference
+    newPathExpression: ColumnsSelectionDsl<T>.(ColumnWithPath<C>, Int) -> Column
 ): DataFrame<T> {
     var counter = 0
     return into { col ->
@@ -52,7 +52,7 @@ public fun <T, C> MoveClause<T, C>.intoIndexed(
 
 public fun <T, C> MoveClause<T, C>.under(column: String): DataFrame<T> = pathOf(column).let { path -> under { path } }
 public fun <T, C> MoveClause<T, C>.under(column: AnyColumnGroupAccessor): DataFrame<T> = column.path().let { path -> under { path } }
-public fun <T, C> MoveClause<T, C>.under(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> AnyColumnReference): DataFrame<T> = moveImpl(
+public fun <T, C> MoveClause<T, C>.under(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> Column): DataFrame<T> = moveImpl(
     under = true,
     column
 )
@@ -66,7 +66,7 @@ public fun <T, C> MoveClause<T, C>.toTop(
 
 public fun <T, C> MoveClause<T, C>.after(column: ColumnSelector<T, *>): DataFrame<T> = afterOrBefore(column, true)
 public fun <T, C> MoveClause<T, C>.after(column: String): DataFrame<T> = after { column.toColumnAccessor() }
-public fun <T, C> MoveClause<T, C>.after(column: AnyColumnReference): DataFrame<T> = after { column }
+public fun <T, C> MoveClause<T, C>.after(column: Column): DataFrame<T> = after { column }
 public fun <T, C> MoveClause<T, C>.after(column: KProperty<*>): DataFrame<T> = after { column.toColumnAccessor() }
 
 // TODO: implement 'before'
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
index ed99ff907..c4023430c 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
@@ -41,17 +41,17 @@ public interface PivotDsl<out T> : ColumnsSelectionDsl<T> {
 
 public fun <T> DataFrame<T>.pivot(inward: Boolean? = null, columns: PivotColumnsSelector<T, *>): Pivot<T> = PivotImpl(this, columns, inward)
 public fun <T> DataFrame<T>.pivot(vararg columns: String, inward: Boolean? = null): Pivot<T> = pivot(inward) { columns.toColumns() }
-public fun <T> DataFrame<T>.pivot(vararg columns: AnyColumnReference, inward: Boolean? = null): Pivot<T> = pivot(inward) { columns.toColumns() }
+public fun <T> DataFrame<T>.pivot(vararg columns: Column, inward: Boolean? = null): Pivot<T> = pivot(inward) { columns.toColumns() }
 public fun <T> DataFrame<T>.pivot(vararg columns: KProperty<*>, inward: Boolean? = null): Pivot<T> = pivot(inward) { columns.toColumns() }
 
 public fun <T> DataFrame<T>.pivotMatches(inward: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T> = pivot(inward, columns).groupByOther().matches()
 public fun <T> DataFrame<T>.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
-public fun <T> DataFrame<T>.pivotMatches(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
+public fun <T> DataFrame<T>.pivotMatches(vararg columns: Column, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
 public fun <T> DataFrame<T>.pivotMatches(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
 
 public fun <T> DataFrame<T>.pivotCounts(inward: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T> = pivot(inward, columns).groupByOther().count()
 public fun <T> DataFrame<T>.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
-public fun <T> DataFrame<T>.pivotCounts(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
+public fun <T> DataFrame<T>.pivotCounts(vararg columns: Column, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
 public fun <T> DataFrame<T>.pivotCounts(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
 
 // endregion
@@ -59,18 +59,18 @@ public fun <T> DataFrame<T>.pivotCounts(vararg columns: KProperty<*>, inward: Bo
 // region GroupBy
 
 public fun <G> GroupBy<*, G>.pivot(inward: Boolean = true, columns: ColumnsSelector<G, *>): PivotGroupBy<G> = PivotGroupByImpl(this, columns, inward)
-public fun <G> GroupBy<*, G>.pivot(vararg columns: AnyColumnReference, inward: Boolean = true): PivotGroupBy<G> = pivot(inward) { columns.toColumns() }
+public fun <G> GroupBy<*, G>.pivot(vararg columns: Column, inward: Boolean = true): PivotGroupBy<G> = pivot(inward) { columns.toColumns() }
 public fun <G> GroupBy<*, G>.pivot(vararg columns: String, inward: Boolean = true): PivotGroupBy<G> = pivot(inward) { columns.toColumns() }
 public fun <G> GroupBy<*, G>.pivot(vararg columns: KProperty<*>, inward: Boolean = true): PivotGroupBy<G> = pivot(inward) { columns.toColumns() }
 
 public fun <G> GroupBy<*, G>.pivotMatches(inward: Boolean = true, columns: ColumnsSelector<G, *>): DataFrame<G> = pivot(inward, columns).matches()
 public fun <G> GroupBy<*, G>.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame<G> = pivotMatches(inward) { columns.toColumns() }
-public fun <G> GroupBy<*, G>.pivotMatches(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<G> = pivotMatches(inward) { columns.toColumns() }
+public fun <G> GroupBy<*, G>.pivotMatches(vararg columns: Column, inward: Boolean = true): DataFrame<G> = pivotMatches(inward) { columns.toColumns() }
 public fun <G> GroupBy<*, G>.pivotMatches(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<G> = pivotMatches(inward) { columns.toColumns() }
 
 public fun <G> GroupBy<*, G>.pivotCounts(inward: Boolean = true, columns: ColumnsSelector<G, *>): DataFrame<G> = pivot(inward, columns).count()
 public fun <G> GroupBy<*, G>.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame<G> = pivotCounts(inward) { columns.toColumns() }
-public fun <G> GroupBy<*, G>.pivotCounts(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<G> = pivotCounts(inward) { columns.toColumns() }
+public fun <G> GroupBy<*, G>.pivotCounts(vararg columns: Column, inward: Boolean = true): DataFrame<G> = pivotCounts(inward) { columns.toColumns() }
 public fun <G> GroupBy<*, G>.pivotCounts(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<G> = pivotCounts(inward) { columns.toColumns() }
 
 // endregion
@@ -80,17 +80,17 @@ public fun <G> GroupBy<*, G>.pivotCounts(vararg columns: KProperty<*>, inward: B
 public fun <T> AggregateGroupedDsl<T>.pivot(inward: Boolean = true, columns: ColumnsSelector<T, *>): PivotGroupBy<T> =
     PivotInAggregateImpl(this, columns, inward)
 public fun <T> AggregateGroupedDsl<T>.pivot(vararg columns: String, inward: Boolean = true): PivotGroupBy<T> = pivot(inward) { columns.toColumns() }
-public fun <T> AggregateGroupedDsl<T>.pivot(vararg columns: AnyColumnReference, inward: Boolean = true): PivotGroupBy<T> = pivot(inward) { columns.toColumns() }
+public fun <T> AggregateGroupedDsl<T>.pivot(vararg columns: Column, inward: Boolean = true): PivotGroupBy<T> = pivot(inward) { columns.toColumns() }
 public fun <T> AggregateGroupedDsl<T>.pivot(vararg columns: KProperty<*>, inward: Boolean = true): PivotGroupBy<T> = pivot(inward) { columns.toColumns() }
 
 public fun <T> AggregateGroupedDsl<T>.pivotMatches(inward: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T> = pivot(inward, columns).matches()
 public fun <T> AggregateGroupedDsl<T>.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
-public fun <T> AggregateGroupedDsl<T>.pivotMatches(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
+public fun <T> AggregateGroupedDsl<T>.pivotMatches(vararg columns: Column, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
 public fun <T> AggregateGroupedDsl<T>.pivotMatches(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
 
 public fun <T> AggregateGroupedDsl<T>.pivotCounts(inward: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T> = pivot(inward, columns).matches()
 public fun <T> AggregateGroupedDsl<T>.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
-public fun <T> AggregateGroupedDsl<T>.pivotCounts(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
+public fun <T> AggregateGroupedDsl<T>.pivotCounts(vararg columns: Column, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
 public fun <T> AggregateGroupedDsl<T>.pivotCounts(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt
index 85226f1c3..b252b7ed0 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.impl.api.removeImpl
@@ -13,12 +13,12 @@ import kotlin.reflect.KProperty
 public fun <T> DataFrame<T>.remove(columns: ColumnsSelector<T, *>): DataFrame<T> = removeImpl(allowMissingColumns = true, columns = columns).df
 public fun <T> DataFrame<T>.remove(vararg columns: KProperty<*>): DataFrame<T> = remove { columns.toColumns() }
 public fun <T> DataFrame<T>.remove(vararg columns: String): DataFrame<T> = remove { columns.toColumns() }
-public fun <T> DataFrame<T>.remove(vararg columns: AnyColumnReference): DataFrame<T> = remove { columns.toColumns() }
-public fun <T> DataFrame<T>.remove(columns: Iterable<AnyColumnReference>): DataFrame<T> = remove { columns.toColumnSet() }
+public fun <T> DataFrame<T>.remove(vararg columns: Column): DataFrame<T> = remove { columns.toColumns() }
+public fun <T> DataFrame<T>.remove(columns: Iterable<Column>): DataFrame<T> = remove { columns.toColumnSet() }
 
 public infix operator fun <T> DataFrame<T>.minus(columns: ColumnsSelector<T, *>): DataFrame<T> = remove(columns)
 public infix operator fun <T> DataFrame<T>.minus(column: String): DataFrame<T> = remove(column)
-public infix operator fun <T> DataFrame<T>.minus(column: AnyColumnReference): DataFrame<T> = remove(column)
-public infix operator fun <T> DataFrame<T>.minus(columns: Iterable<AnyColumnReference>): DataFrame<T> = remove(columns)
+public infix operator fun <T> DataFrame<T>.minus(column: Column): DataFrame<T> = remove(column)
+public infix operator fun <T> DataFrame<T>.minus(columns: Iterable<Column>): DataFrame<T> = remove(columns)
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt
index 4a91e748f..3277ec595 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.impl.columnName
@@ -27,11 +27,11 @@ public fun <T> DataFrame<T>.select(vararg columns: String): DataFrame<T> =
 public fun <T> DataFrame<T>.select(columns: Iterable<String>): DataFrame<T> =
     columns.map { get(it) }.toDataFrame().cast()
 
-public fun <T> DataFrame<T>.select(vararg columns: AnyColumnReference): DataFrame<T> =
+public fun <T> DataFrame<T>.select(vararg columns: Column): DataFrame<T> =
     select { columns.toColumns() }
 
 @JvmName("selectAnyColumnReferenceIterable")
-public fun <T> DataFrame<T>.select(columns: Iterable<AnyColumnReference>): DataFrame<T> =
+public fun <T> DataFrame<T>.select(columns: Iterable<Column>): DataFrame<T> =
     select { columns.toColumnSet() }
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
index 89d7581a2..7d06eb151 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyBaseCol
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.AnyFrame
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
@@ -41,7 +41,7 @@ public fun <T> DataFrame<T>.read(vararg columns: String): DataFrame<T> = unfold(
 public fun <T> DataFrame<T>.read(vararg columns: KProperty<*>): DataFrame<T> = unfold(*columns)
 
 @Deprecated("Replaced with `unfold` operation.", ReplaceWith("this.unfold(*columns)"), DeprecationLevel.ERROR)
-public fun <T> DataFrame<T>.read(vararg columns: AnyColumnReference): DataFrame<T> = unfold(*columns)
+public fun <T> DataFrame<T>.read(vararg columns: Column): DataFrame<T> = unfold(*columns)
 
 @JvmName("toDataFrameT")
 public fun <T> Iterable<DataRow<T>>.toDataFrame(): DataFrame<T> {
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/unfold.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/unfold.kt
index 1ad347213..54f59bf95 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/unfold.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/unfold.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyCol
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -25,4 +25,4 @@ public inline fun <reified T> DataColumn<T>.unfold(): AnyCol =
 public fun <T> DataFrame<T>.unfold(columns: ColumnsSelector<T, *>): DataFrame<T> = replace(columns).with { it.unfold() }
 public fun <T> DataFrame<T>.unfold(vararg columns: String): DataFrame<T> = unfold { columns.toColumns() }
 public fun <T> DataFrame<T>.unfold(vararg columns: KProperty<*>): DataFrame<T> = unfold { columns.toColumns() }
-public fun <T> DataFrame<T>.unfold(vararg columns: AnyColumnReference): DataFrame<T> = unfold { columns.toColumns() }
+public fun <T> DataFrame<T>.unfold(vararg columns: Column): DataFrame<T> = unfold { columns.toColumns() }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt
index 7633687ba..65e0f820c 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
@@ -15,7 +15,7 @@ public fun <T, C> DataFrame<T>.ungroup(columns: ColumnsSelector<T, C>): DataFram
 }
 
 public fun <T> DataFrame<T>.ungroup(vararg columns: String): DataFrame<T> = ungroup { columns.toColumns() }
-public fun <T> DataFrame<T>.ungroup(vararg columns: AnyColumnReference): DataFrame<T> = ungroup { columns.toColumns() }
+public fun <T> DataFrame<T>.ungroup(vararg columns: Column): DataFrame<T> = ungroup { columns.toColumns() }
 public fun <T> DataFrame<T>.ungroup(vararg columns: KProperty<*>): DataFrame<T> = ungroup { columns.toColumns() }
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt
index fcfef0e04..7de0675a8 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -70,7 +70,7 @@ public fun <T> DataFrame<T>.valueCounts(
     resultColumn: String = defaultCountColumnName
 ): DataFrame<T> = valueCounts(sort, ascending, dropNA, resultColumn) { columns.toColumns() }
 public fun <T> DataFrame<T>.valueCounts(
-    vararg columns: AnyColumnReference,
+    vararg columns: Column,
     sort: Boolean = true,
     ascending: Boolean = false,
     dropNA: Boolean = true,
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/values.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/values.kt
index a6e949a9e..417487f73 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/values.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/values.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
@@ -24,7 +24,7 @@ public fun <T> DataFrame<T>.valuesNotNull(byRow: Boolean = false): Sequence<Any>
 
 // region GroupBy
 
-public fun <T> Grouped<T>.values(vararg columns: AnyColumnReference, dropNA: Boolean = false, distinct: Boolean = false): DataFrame<T> = values(dropNA, distinct) { columns.toColumns() }
+public fun <T> Grouped<T>.values(vararg columns: Column, dropNA: Boolean = false, distinct: Boolean = false): DataFrame<T> = values(dropNA, distinct) { columns.toColumns() }
 public fun <T> Grouped<T>.values(vararg columns: String, dropNA: Boolean = false, distinct: Boolean = false): DataFrame<T> = values(dropNA, distinct) { columns.toColumns() }
 public fun <T> Grouped<T>.values(
     dropNA: Boolean = false,
@@ -40,7 +40,7 @@ public fun <T> Grouped<T>.values(dropNA: Boolean = false, distinct: Boolean = fa
 public fun <T, G> ReducedGroupBy<T, G>.values(): DataFrame<G> = values(groupBy.remainingColumnsSelector())
 
 public fun <T, G> ReducedGroupBy<T, G>.values(
-    vararg columns: AnyColumnReference
+    vararg columns: Column
 ): DataFrame<G> = values { columns.toColumns() }
 
 public fun <T, G> ReducedGroupBy<T, G>.values(
@@ -66,7 +66,7 @@ public fun <T> Pivot<T>.values(
     columns: ColumnsForAggregateSelector<T, *>
 ): DataRow<T> = delegate { values(dropNA, distinct, separate, columns) }
 public fun <T> Pivot<T>.values(
-    vararg columns: AnyColumnReference,
+    vararg columns: Column,
     dropNA: Boolean = false,
     distinct: Boolean = false,
     separate: Boolean = false
@@ -95,7 +95,7 @@ public fun <T> ReducedPivot<T>.values(
 ): DataRow<T> = pivot.delegate { reduce(reducer).values(separate = separate) }
 
 public fun <T> ReducedPivot<T>.values(
-    vararg columns: AnyColumnReference,
+    vararg columns: Column,
     separate: Boolean = false
 ): DataRow<T> = values(separate) { columns.toColumns() }
 
@@ -121,7 +121,7 @@ public fun <T> ReducedPivot<T>.values(
 public fun <T> PivotGroupBy<T>.values(dropNA: Boolean = false, distinct: Boolean = false, separate: Boolean = false): DataFrame<T> = values(dropNA, distinct, separate, remainingColumnsSelector())
 
 public fun <T> PivotGroupBy<T>.values(
-    vararg columns: AnyColumnReference,
+    vararg columns: Column,
     dropNA: Boolean = false,
     distinct: Boolean = false,
     separate: Boolean = false
@@ -155,7 +155,7 @@ public fun <T> ReducedPivotGroupBy<T>.values(
 ): DataFrame<T> = values(separate, pivot.remainingColumnsSelector())
 
 public fun <T> ReducedPivotGroupBy<T>.values(
-    vararg columns: AnyColumnReference,
+    vararg columns: Column,
     separate: Boolean = false
 ): DataFrame<T> = values(separate) { columns.toColumns() }
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/with.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/with.kt
index 04ae27ae3..7b5942b83 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/with.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/with.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.RowExpression
@@ -37,7 +37,7 @@ public inline fun <T, reified V> ReducedPivotGroupBy<T>.with(noinline expression
     return pivot.aggregate {
         val value = reducer(this)?.let {
             val value = expression(it, it)
-            if (value is AnyColumnReference) it[value]
+            if (value is Column) it[value]
             else value
         }
         internal().yield(emptyPath(), value, type)
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregations.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregations.kt
index f18c558ca..925a70fdd 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregations.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregations.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.impl.aggregation
 
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.RowExpression
@@ -90,7 +90,7 @@ internal fun <T, C> AggregateInternalDsl<T>.columnValues(
 internal fun <T, V> AggregateInternalDsl<T>.withExpr(type: KType, path: ColumnPath, expression: RowExpression<T, V>) {
     val values = df.rows().map {
         val value = expression(it, it)
-        if (value is AnyColumnReference) it[value]
+        if (value is Column) it[value]
         else value
     }
     yieldOneOrMany(path, values, type)
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/move.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/move.kt
index e70c945ef..0e51a7362 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/move.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/move.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.impl.api
 
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -43,7 +43,7 @@ internal fun <T, C> MoveClause<T, C>.afterOrBefore(column: ColumnSelector<T, *>,
 
 internal fun <T, C> MoveClause<T, C>.moveImpl(
     under: Boolean = false,
-    newPathExpression: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> AnyColumnReference
+    newPathExpression: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> Column
 ): DataFrame<T> {
     val receiver = object : DataFrameReceiver<T>(df, UnresolvedColumnsPolicy.Fail), ColumnsSelectionDsl<T> {}
     val removeResult = df.removeImpl(columns = columns)

From 341da804e48bb260a91c5ea2a36e17d09f801271 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Wed, 22 Feb 2023 17:11:04 +0100
Subject: [PATCH 31/50] refactored and renamed some of the general docs

---
 .../kotlinx/dataframe/api/DataRowApi.kt       |  2 +-
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  |  2 +-
 .../jetbrains/kotlinx/dataframe/api/add.kt    |  2 +-
 .../kotlinx/dataframe/api/countDistinct.kt    |  2 +-
 .../kotlinx/dataframe/api/groupBy.kt          |  2 +-
 .../kotlinx/dataframe/api/toDataFrame.kt      |  2 +-
 .../jetbrains/kotlinx/dataframe/api/update.kt | 57 ++++++++++---------
 ...ngColumns.kt => ExpressionsGivenColumn.kt} |  6 +-
 ...Frames.kt => ExpressionsGivenDataFrame.kt} |  9 ++-
 ...pressingRows.kt => ExpressionsGivenRow.kt} | 22 +++----
 .../{RowCondition.kt => SelectingRows.kt}     |  6 +-
 11 files changed, 58 insertions(+), 54 deletions(-)
 rename core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/{ExpressingColumns.kt => ExpressionsGivenColumn.kt} (87%)
 rename core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/{ExpressingDataFrames.kt => ExpressionsGivenDataFrame.kt} (78%)
 rename core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/{ExpressingRows.kt => ExpressionsGivenRow.kt} (75%)
 rename core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/{RowCondition.kt => SelectingRows.kt} (96%)

diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowApi.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowApi.kt
index 2860c274e..9cdc67e72 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowApi.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowApi.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsContainer
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index bc6477885..d187efef9 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -1,9 +1,9 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyCol
-import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.AnyFrame
 import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
index c33d5b947..a81da1c9a 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
@@ -3,9 +3,9 @@ package org.jetbrains.kotlinx.dataframe.api
 import org.jetbrains.kotlinx.dataframe.AnyBaseCol
 import org.jetbrains.kotlinx.dataframe.AnyCol
 import org.jetbrains.kotlinx.dataframe.AnyColumnGroupAccessor
-import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.AnyFrame
 import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsContainer
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
index 931983e76..4239b8da3 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
index 8bd1d05f5..b02c37e7b 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
index 7d06eb151..3bf5ec6d9 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
@@ -1,8 +1,8 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyBaseCol
-import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index 88d0679ed..13ce718b4 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -40,18 +40,18 @@ public data class Update<T, C>(
      *
      * {@includeArg [UpdateOperationArg]} `{ `[columns][SelectingColumns]` }`
      *
-     * - `[.`[where][Update.where]` { `[rowValueCondition][RowCondition.RowValueCondition.WithExample]` } ]`
+     * - `[.`[where][Update.where]` { `[rowValueCondition][SelectingRows.RowValueCondition.WithExample]` } ]`
      *
      * - `[.`[at][Update.at]` (`[rowIndices][CommonUpdateAtFunctionDoc.RowIndicesParam]`) ]`
      *
-     * - `.`[with][Update.with]` { `[rowExpression][ExpressingRows.RowValueExpression.WithExample]` }
-     *   | .`[notNull][Update.notNull]` { `[rowExpression][ExpressingRows.RowValueExpression.WithExample]` }
-     *   | .`[perCol][Update.perCol]` { `[colExpression][ExpressingColumns.ColumnExpression.WithExample]` }
-     *   | .`[perRowCol][Update.perRowCol]` { `[rowColExpression][ExpressingColumns.RowColumnExpression.WithExample]` }
+     * - `.`[with][Update.with]` { `[rowExpression][ExpressionsGivenRow.RowValueExpression.WithExample]` }
+     *   | .`[notNull][Update.notNull]` { `[rowExpression][ExpressionsGivenRow.RowValueExpression.WithExample]` }
+     *   | .`[perCol][Update.perCol]` { `[colExpression][ExpressionsGivenColumn.ColumnExpression.WithExample]` }
+     *   | .`[perRowCol][Update.perRowCol]` { `[rowColExpression][ExpressionsGivenColumn.RowColumnExpression.WithExample]` }
      *   | .`[withValue][Update.withValue]`(value)
      *   | .`[withNull][Update.withNull]`()
      *   | .`[withZero][Update.withZero]`()
-     *   | .`[asFrame][Update.asFrame]` { `[dataFrameExpression][ExpressingDataFrames.DataFrameExpression.WithExample]` }`
+     *   | .`[asFrame][Update.asFrame]` { `[dataFrameExpression][ExpressionsGivenDataFrame.DataFrameExpression.WithExample]` }`
      * {@arg [UpdateOperationArg] [update][update]}{@comment The default name of the `update` operation function name.}
      */
     public interface Usage
@@ -134,9 +134,9 @@ public fun <T, C> DataFrame<T>.update(columns: Iterable<ColumnReference<C>>): Up
 // endregion
 
 /** ## Where
- * @include [RowCondition.RowValueCondition.WithExample]
- * {@arg [RowCondition.FirstOperationArg] [update][update]}
- * {@arg [RowCondition.SecondOperationArg] [where][where]}
+ * @include [SelectingRows.RowValueCondition.WithExample]
+ * {@arg [SelectingRows.FirstOperationArg] [update][update]}
+ * {@arg [SelectingRows.SecondOperationArg] [where][where]}
  *
  * @param predicate The [row value filter][RowValueFilter] to select the rows to update.
  */
@@ -194,18 +194,21 @@ public infix fun <T, C> Update<T, C>.perRowCol(expression: RowColumnExpression<T
     updateImpl { row, column, _ -> expression(row, column) }
 
 /** ## Update Expression
- * @see ExpressingRows.RowValueExpression.WithExample
- * @see ExpressingRows.AddDataRowNote
+ * @see ExpressionsGivenRow.RowValueExpression.WithExample
+ * @see ExpressionsGivenRow.AddDataRowNote
  */ // doc processor plugin does not work with type aliases yet
 public typealias UpdateExpression<T, C, R> = AddDataRow<T>.(C) -> R
 
 /** ## With
- * {@include [ExpressingRows.RowValueExpression.WithExample]}
- * {@arg [ExpressingRows.OperationArg] [update][update]` { city \}.`[with][with]}
+ * {@include [ExpressionsGivenRow.RowValueExpression.WithExample]}
+ * {@arg [ExpressionsGivenRow.OperationArg] [update][update]` { city \}.`[with][with]}
  *
  * ## Note
- * @include [ExpressingRows.AddDataRowNote]
- * @param expression The {@include [ExpressingRows.RowValueExpressionLink]} to update the rows with.
+ * @include [ExpressionsGivenRow.AddDataRowNote]
+ * ## See Also
+ * - [Update per col][Update.perCol] to provide a new value for every selected row giving the column.
+ * - [Update per row col][Update.perRowCol] to provide a new value for every selected row giving the row and the column.
+ * @param expression The {@include [ExpressionsGivenRow.RowValueExpressionLink]} to update the rows with.
  */
 public infix fun <T, C> Update<T, C>.with(expression: UpdateExpression<T, C, C?>): DataFrame<T> =
     updateImpl { row, _, value ->
@@ -216,8 +219,8 @@ public infix fun <T, C> Update<T, C>.with(expression: UpdateExpression<T, C, C?>
  *
  * Updates selected [column group][ColumnGroup] as a [DataFrame] with the given [expression].
  *
- * {@include [ExpressingDataFrames.DataFrameExpression.WithExample]}
- * {@arg [ExpressingDataFrames.OperationArg] `df.`[update][update]` { name \}.`[asFrame][asFrame]}
+ * {@include [ExpressionsGivenDataFrame.DataFrameExpression.WithExample]}
+ * {@arg [ExpressionsGivenDataFrame.OperationArg] `df.`[update][update]` { name \}.`[asFrame][asFrame]}
  * @param expression The [DataFrameExpression] to replace the selected column group with.
  */
 public infix fun <T, C, R> Update<T, DataRow<C>>.asFrame(expression: DataFrameExpression<C, DataFrame<R>>): DataFrame<T> =
@@ -271,7 +274,7 @@ public fun <T, C> Update<T, C?>.notNull(): Update<T, C> =
  *
  * `df.`[update][update]` { city }.`[notNull][Update.notNull]` { it.`[toUpperCase][String.toUpperCase]`() }`
  *
- * @param expression Optional {@include [ExpressingRows.RowExpressionLink]} to update the rows with.
+ * @param expression Optional {@include [ExpressionsGivenRow.RowExpressionLink]} to update the rows with.
  */
 public fun <T, C> Update<T, C?>.notNull(expression: UpdateExpression<T, C, C>): DataFrame<T> =
     notNull().with(expression)
@@ -282,11 +285,11 @@ public fun <T, C> Update<T, C?>.notNull(expression: UpdateExpression<T, C, C>):
  *
  * @include [SelectingColumns.ColumnAccessors]
  *
- * {@include [ExpressingRows.RowValueExpression.WithExample]}
- * {@arg [ExpressingRows.OperationArg] [update][update]`("city")` }
+ * {@include [ExpressionsGivenRow.RowValueExpression.WithExample]}
+ * {@arg [ExpressionsGivenRow.OperationArg] [update][update]`("city")` }
  *
  * @include [Update.ColumnAccessorsParam]
- * @param expression The {@include [ExpressingRows.RowValueExpressionLink]} to update the rows with.
+ * @param expression The {@include [ExpressionsGivenRow.RowValueExpressionLink]} to update the rows with.
  */
 public fun <T, C> DataFrame<T>.update(
     firstCol: ColumnReference<C>,
@@ -301,11 +304,11 @@ public fun <T, C> DataFrame<T>.update(
  *
  * @include [SelectingColumns.KProperties]
  *
- * {@include [ExpressingRows.RowValueExpression.WithExample]}
- * {@arg [ExpressingRows.OperationArg] [update][update]`("city")` }
+ * {@include [ExpressionsGivenRow.RowValueExpression.WithExample]}
+ * {@arg [ExpressionsGivenRow.OperationArg] [update][update]`("city")` }
  *
  * @include [Update.KPropertiesParam]
- * @param expression The {@include [ExpressingRows.RowValueExpressionLink]} to update the rows with.
+ * @param expression The {@include [ExpressionsGivenRow.RowValueExpressionLink]} to update the rows with.
  */
 public fun <T, C> DataFrame<T>.update(
     firstCol: KProperty<C>,
@@ -320,11 +323,11 @@ public fun <T, C> DataFrame<T>.update(
  *
  * @include [SelectingColumns.ColumnNames]
  *
- * {@include [ExpressingRows.RowValueExpression.WithExample]}
- * {@arg [ExpressingRows.OperationArg] [update][update]`("city")` }
+ * {@include [ExpressionsGivenRow.RowValueExpression.WithExample]}
+ * {@arg [ExpressionsGivenRow.OperationArg] [update][update]`("city")` }
  *
  * @include [Update.ColumnNamesParam]
- * @param expression The {@include [ExpressingRows.RowValueExpressionLink]} to update the rows with.
+ * @param expression The {@include [ExpressionsGivenRow.RowValueExpressionLink]} to update the rows with.
  */
 public fun <T> DataFrame<T>.update(
     firstCol: String,
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingColumns.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt
similarity index 87%
rename from core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingColumns.kt
rename to core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt
index c30536a42..0bc4c4285 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingColumns.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt
@@ -1,9 +1,11 @@
 package org.jetbrains.kotlinx.dataframe.documentation
 
 /**
- * Column expressions.
+ * ## Expressions Given Column
+ *
+ * TODO
  */
-internal interface ExpressingColumns {
+internal interface ExpressionsGivenColumn {
 
     /**
      * TODO
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingDataFrames.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenDataFrame.kt
similarity index 78%
rename from core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingDataFrames.kt
rename to core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenDataFrame.kt
index f4df459eb..eba50e165 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingDataFrames.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenDataFrame.kt
@@ -2,16 +2,15 @@ package org.jetbrains.kotlinx.dataframe.documentation
 
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.api.*
-import org.jetbrains.kotlinx.dataframe.documentation.ExpressingDataFrames.DataFrameExpressionLink
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.DataFrameExpressionLink
 import org.jetbrains.kotlinx.dataframe.DataFrameExpression as DfDataFrameExpression
 
 /**
- * ## Expressing Data Frames
+ * ## Expressions Given DataFrame
  * Expressing values using a "Data Frame Expression" can occur exclusively in a
- * {@include [DataFrameExpressionLink]}
- *
+ * {@include [DataFrameExpressionLink]}.
  */
-internal interface ExpressingDataFrames {
+internal interface ExpressionsGivenDataFrame {
 
     interface OperationArg
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingRows.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
similarity index 75%
rename from core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingRows.kt
rename to core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
index da6a3f707..078697015 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressingRows.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
@@ -3,22 +3,22 @@ package org.jetbrains.kotlinx.dataframe.documentation
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.api.*
-import org.jetbrains.kotlinx.dataframe.documentation.ExpressingRows.AddDataRowNote
-import org.jetbrains.kotlinx.dataframe.documentation.ExpressingRows.RowExpressionLink
-import org.jetbrains.kotlinx.dataframe.documentation.ExpressingRows.RowValueExpressionLink
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.AddDataRowNote
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowExpressionLink
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpressionLink
 import org.jetbrains.kotlinx.dataframe.RowExpression as DfRowExpression
 import org.jetbrains.kotlinx.dataframe.RowValueExpression as DfRowValueExpression
 
 /**
- * ## Expressing Rows
+ * ## Expressions Given Row
  * Expressing values using a "Row Expression" ({@include [DocumentationUrls.DataRow.RowExpressions]})
  * can occur in the following two types of operations:
  *
- * - Providing a new value for every selected row given the row ({@include [RowExpressionLink]}),
+ * - Providing a new value for every selected cell given the row of that cell ({@include [RowExpressionLink]}),
  * for instance in [map][DataFrame.map], [add][DataFrame.add], and [insert][DataFrame.insert]
  * (using [RowExpression][DfRowExpression]).
  *
- * - Providing a new value for every selected row given the row and the previous value ({@include [RowValueExpressionLink]}),
+ * - Providing a new value for every selected cell given the row of that cell and its previous value ({@include [RowValueExpressionLink]}),
  * for instance in [update.with][Update.with], and [convert.notNull][Convert.notNull]
  * (using [RowValueExpression][DfRowValueExpression]).
  *
@@ -27,7 +27,7 @@ import org.jetbrains.kotlinx.dataframe.RowValueExpression as DfRowValueExpressio
  *
  * A Row Expression is similar to a {@include [RowConditionLink]} but that expects a [Boolean] as result.
  */
-internal interface ExpressingRows {
+internal interface ExpressionsGivenRow {
 
     /**
      * The key for an @arg that will define the operation name for the examples below.
@@ -46,7 +46,7 @@ internal interface ExpressingRows {
      */
     interface AddDataRowNote
 
-    /** Provide a new value for every selected row given the row using a [row expression][DfRowExpression]. */
+    /** Provide a new value for every selected cell given its row using a [row expression][DfRowExpression]. */
     interface RowExpression {
 
         /**
@@ -65,7 +65,7 @@ internal interface ExpressingRows {
     /** [Row Expression][RowExpression.WithExample] */
     interface RowExpressionLink
 
-    /** Provide a new value for every selected row given the row and the previous value using a
+    /** Provide a new value for every selected cell given its row and its previous value using a
      * [row value expression][DfRowValueExpression].
      */
     interface RowValueExpression {
@@ -86,9 +86,9 @@ internal interface ExpressingRows {
     /** [Row Value Expression][RowValueExpression.WithExample] */
     interface RowValueExpressionLink
 
-    /** @include [ExpressingColumns.RowColumnExpression] */
+    /** @include [ExpressionsGivenColumn.RowColumnExpression] */
     interface RowColumnExpression
 }
 
-/** [Row Expressions][ExpressingRows] */
+/** [Row Expression][ExpressionsGivenRow] */
 internal interface RowExpressionsLink
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowCondition.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
similarity index 96%
rename from core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowCondition.kt
rename to core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
index 3158a0232..6438b05aa 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/RowCondition.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
@@ -4,7 +4,7 @@ import org.jetbrains.kotlinx.dataframe.*
 import org.jetbrains.kotlinx.dataframe.api.*
 
 /**
- * ## Row Condition
+ * ## Selecting Rows
  * Selecting rows that satisfy a "Row Condition" ({@include [DocumentationUrls.DataRow.RowConditions]})
  * can occur in the following two types of operations:
  * - Selecting entire rows ({@include [RowConditionLink]}), for instance in [filter], [drop], [first], and [count]
@@ -16,7 +16,7 @@ import org.jetbrains.kotlinx.dataframe.api.*
  * A Row Condition is similar to a {@include [RowExpressionsLink]} but expects a [Boolean] as result.
  * {@comment TODO Is `where` present everywhere it should be?}
  */
-internal interface RowCondition {
+internal interface SelectingRows {
 
     /**
      * The key for an @arg that will define the operation name for the examples below.
@@ -74,5 +74,5 @@ internal interface RowCondition {
     }
 }
 
-/** [Row Condition][RowCondition] */
+/** [Row Condition][SelectingRows] */
 internal interface RowConditionLink

From 87710c16c6edf1d436931341da63e4ee65bdc38f Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Thu, 23 Feb 2023 17:46:40 +0100
Subject: [PATCH 32/50] docs and examples for ColumnExpression, links for
 SelectingColumns, docs for perCol with examples, updated gradle plugin

---
 core/build.gradle.kts                         |  2 +-
 .../jetbrains/kotlinx/dataframe/api/update.kt | 83 ++++++++++++++++---
 .../documentation/ExpressionsGivenColumn.kt   | 23 ++++-
 .../documentation/SelectingColumns.kt         | 19 ++++-
 4 files changed, 109 insertions(+), 18 deletions(-)

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 2a4c7ff51..0b001588d 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -14,7 +14,7 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.18"
+    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.19"
 //    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
 }
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index 13ce718b4..80d0f70c4 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -59,16 +59,16 @@ public data class Update<T, C>(
     /** The columns to update need to be selected. See {@include [SelectingColumnsLink]} for all the selecting options. */
     public interface Columns
 
-    /** @param columns The [ColumnsSelector] used to select the columns of this [DataFrame] to update. */
+    /** @param columns The {@include [SelectingColumns.DslLink]} used to select the columns of this [DataFrame] to update. */
     internal interface DslParam
 
-    /** @param columns The [ColumnReference]s of this [DataFrame] to update. */
+    /** @param columns The {@include [SelectingColumns.ColumnAccessorsLink]} of this [DataFrame] to update. */
     internal interface ColumnAccessorsParam
 
-    /** @param columns The [KProperty] values corresponding to columns of this [DataFrame] to update. */
+    /** @param columns The {@include [SelectingColumns.KPropertiesLink]} corresponding to columns of this [DataFrame] to update. */
     internal interface KPropertiesParam
 
-    /** @param columns The column names belonging to this [DataFrame] to update. */
+    /** @param columns The {@include [SelectingColumns.ColumnNamesLink]} belonging to this [DataFrame] to update. */
     internal interface ColumnNamesParam
 }
 
@@ -193,6 +193,9 @@ public fun <T, C> Update<T, C>.at(rowRange: IntRange): Update<T, C> = where { in
 public infix fun <T, C> Update<T, C>.perRowCol(expression: RowColumnExpression<T, C, C>): DataFrame<T> =
     updateImpl { row, column, _ -> expression(row, column) }
 
+/** [Update per row col][Update.perRowCol] to provide a new value for every selected cell giving its row and column. */
+private interface SeeAlsoPerRowCol
+
 /** ## Update Expression
  * @see ExpressionsGivenRow.RowValueExpression.WithExample
  * @see ExpressionsGivenRow.AddDataRowNote
@@ -206,8 +209,8 @@ public typealias UpdateExpression<T, C, R> = AddDataRow<T>.(C) -> R
  * ## Note
  * @include [ExpressionsGivenRow.AddDataRowNote]
  * ## See Also
- * - [Update per col][Update.perCol] to provide a new value for every selected row giving the column.
- * - [Update per row col][Update.perRowCol] to provide a new value for every selected row giving the row and the column.
+ * - {@include [SeeAlsoPerCol]}
+ * - {@include [SeeAlsoPerRowCol]}
  * @param expression The {@include [ExpressionsGivenRow.RowValueExpressionLink]} to update the rows with.
  */
 public infix fun <T, C> Update<T, C>.with(expression: UpdateExpression<T, C, C?>): DataFrame<T> =
@@ -215,13 +218,16 @@ public infix fun <T, C> Update<T, C>.with(expression: UpdateExpression<T, C, C?>
         expression(row, value)
     }
 
+/** [Update with][Update.with] to provide a new value for every selected cell giving its row. */
+private interface SeeAlsoWith
+
 /** ## As Frame
  *
  * Updates selected [column group][ColumnGroup] as a [DataFrame] with the given [expression].
  *
  * {@include [ExpressionsGivenDataFrame.DataFrameExpression.WithExample]}
  * {@arg [ExpressionsGivenDataFrame.OperationArg] `df.`[update][update]` { name \}.`[asFrame][asFrame]}
- * @param expression The [DataFrameExpression] to replace the selected column group with.
+ * @param expression The {@include [ExpressionsGivenDataFrame.DataFrameExpressionLink]} to replace the selected column group with.
  */
 public infix fun <T, C, R> Update<T, DataRow<C>>.asFrame(expression: DataFrameExpression<C, DataFrame<R>>): DataFrame<T> =
     df.replace(columns).with { it.asColumnGroup().let { expression(it, it) }.asColumnGroup(it.name()) }
@@ -232,18 +238,75 @@ public infix fun <T, C, R> Update<T, DataRow<C>>.asFrame(expression: DataFrameEx
 )
 public fun <T, C> Update<T, C>.asNullable(): Update<T, C?> = this as Update<T, C?>
 
-/** TODO */
+/** ## Per Col
+ *
+ * Per Col can be used for two different types of operations:
+ *  - {@include [ExpressionsGivenColumn.ColumnExpression]}
+ *  - {@include [UpdatePerColMap]}
+ *
+ * ## See Also
+ *  - {@include [SeeAlsoWith]}
+ *  - {@include [SeeAlsoPerRowCol]}
+ * ## This Per Col Overload
+ */
+private interface CommonUpdatePerColDoc
+
+/** Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][DataRow] as Map. */
+private interface UpdatePerColMap
+
+/**
+ * @include [CommonUpdatePerColDoc]
+ * @include [UpdatePerColMap]
+ *
+ * For example:
+ *
+ * `val defaults = {@includeArg [CommonUpdatePerColMapDoc]}`
+ *
+ * `df.`[update][update]` { name and age }.`[where][Update.where]` { ... }.`[perCol][perCol]`(defaults)`
+ *
+ * @throws IllegalArgumentException if a value for a selected cell's column is not defined in [values\].
+ */
+private interface CommonUpdatePerColMapDoc
+
+/**
+ * @include [CommonUpdatePerColMapDoc]
+ * {@arg [CommonUpdatePerColMapDoc] `[mapOf][mapOf]`("name" to "Empty", "age" to 0)}
+ *
+ * @param values The [Map]<[String], Value> to provide a new value for every selected cell.
+ *   For each selected column, there must be a value in the map with the same name.
+ */
 public fun <T, C> Update<T, C>.perCol(values: Map<String, C>): DataFrame<T> = updateWithValuePerColumnImpl {
     values[it.name()] ?: throw IllegalArgumentException("Update value for column ${it.name()} is not defined")
 }
 
-/** TODO */
+/**
+ * @include [CommonUpdatePerColMapDoc]
+ * {@arg [CommonUpdatePerColMapDoc] df.`[getRows][DataFrame.getRows]`(`[listOf][listOf]`(0))`
+ *
+ *   `.`[update][update]` { name \}.`[with][Update.with]` { "Empty" \}`
+ *
+ *   `.`[update][update]` { age \}.`[with][Update.with]` { 0 \}`
+ *
+ *   `.first()}
+ *
+ * @param values The [DataRow] to provide a new value for every selected cell.
+ */
 public fun <T, C> Update<T, C>.perCol(values: AnyRow): DataFrame<T> = perCol(values.toMap() as Map<String, C>)
 
-/** TODO */
+/**
+ * @include [CommonUpdatePerColDoc]
+ * @include [ExpressionsGivenColumn.ColumnExpression.WithExample]
+ * {@arg [ExpressionsGivenColumn.OperationArg] [update][update]` { age \}.`[perCol][perCol]}
+ *
+ * @param valueSelector The {@include [ExpressionsGivenColumn.ColumnExpressionLink]} to provide a new value for every selected cell giving its column.
+ */
 public fun <T, C> Update<T, C>.perCol(valueSelector: ColumnExpression<C, C>): DataFrame<T> =
     updateWithValuePerColumnImpl(valueSelector)
 
+/** [Update per col][Update.perCol] to provide a new value for every selected cell giving its column. */
+private interface SeeAlsoPerCol
+
 /** Chains up two row value filters together. */
 internal infix fun <T, C> RowValueFilter<T, C>?.and(other: RowValueFilter<T, C>): RowValueFilter<T, C> {
     if (this == null) return other
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt
index 0bc4c4285..b02417b83 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt
@@ -1,5 +1,9 @@
 package org.jetbrains.kotlinx.dataframe.documentation
 
+import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.ColumnExpression as DfColumnExpression
+
 /**
  * ## Expressions Given Column
  *
@@ -8,13 +12,26 @@ package org.jetbrains.kotlinx.dataframe.documentation
 internal interface ExpressionsGivenColumn {
 
     /**
-     * TODO
+     * The key for an @arg that will define the operation name for the examples below.
+     * Make sure to [alias][your examples].
      */
+    interface OperationArg
+
+    /** {@arg [OperationArg] operation} */
+    interface SetDefaultOperationArg
+
+    /** Provide a new value for every selected cell given its column using a [column expression][DfColumnExpression]. */
     interface ColumnExpression {
 
         /**
-         * TODO
-         * @include [ColumnExpression]
+         * {@include [ColumnExpression]}
+         *
+         * For example:
+         *
+         * `df.`{@includeArg [OperationArg]}` { it / `[mean][DataColumn.mean]`(skipNA = true) }`
+         *
+         * `df.`{@includeArg [OperationArg]}` { `[count][DataColumn.count]` { it > 10 } }`
+         * @include [SetDefaultOperationArg]
          */
         interface WithExample
     }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
index 36108f6d5..c87c94827 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
@@ -2,8 +2,7 @@ package org.jetbrains.kotlinx.dataframe.documentation
 
 import org.jetbrains.kotlinx.dataframe.*
 import org.jetbrains.kotlinx.dataframe.api.*
-import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
-import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.*
 import kotlin.reflect.KProperty
 
 /** {@comment
@@ -59,7 +58,10 @@ internal interface SelectingColumns {
         interface WithExample
     }
 
-    /** Select columns using their column names
+    /** [Columns selector DSL][Dsl.WithExample] */
+    interface DslLink
+
+    /** Select columns using their [column names][String]
      * ({@include [AccessApi.StringApiLink]}).
      */
     interface ColumnNames {
@@ -74,7 +76,10 @@ internal interface SelectingColumns {
         interface WithExample
     }
 
-    /** Select columns using column accessors
+    /** [Column names][ColumnNames.WithExample] */
+    interface ColumnNamesLink
+
+    /** Select columns using [column accessors][ColumnReference]
      * ({@include [AccessApi.ColumnAccessorsApiLink]}).
      */
     interface ColumnAccessors {
@@ -93,6 +98,9 @@ internal interface SelectingColumns {
         interface WithExample
     }
 
+    /** [Column references][ColumnAccessors.WithExample] */
+    interface ColumnAccessorsLink
+
     /** Select columns using [KProperties][KProperty] ({@include [AccessApi.KPropertiesApiLink]}). */
     interface KProperties {
 
@@ -108,4 +116,7 @@ internal interface SelectingColumns {
          */
         interface WithExample
     }
+
+    /** [KProperties][KProperties.WithExample] */
+    interface KPropertiesLink
 }

From 03c398ffa694de133b73959c225870ae5f47f717 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Thu, 23 Feb 2023 18:15:52 +0100
Subject: [PATCH 33/50] per row col. update.kt finished!

---
 .../jetbrains/kotlinx/dataframe/api/update.kt  | 10 +++++++++-
 .../documentation/ExpressionsGivenColumn.kt    | 18 +++++++++++++-----
 .../documentation/ExpressionsGivenRow.kt       | 16 ++++++++++++++--
 3 files changed, 36 insertions(+), 8 deletions(-)

diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index 80d0f70c4..58f81fd31 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -189,7 +189,15 @@ public fun <T, C> Update<T, C>.at(vararg rowIndices: Int): Update<T, C> = at(row
  */
 public fun <T, C> Update<T, C>.at(rowRange: IntRange): Update<T, C> = where { index in rowRange }
 
-/** TODO */
+/** ## Per Row Col
+ * @include [ExpressionsGivenColumn.RowColumnExpression.WithExample]
+ * {@arg [ExpressionsGivenColumn.OperationArg] [update][update]` { age \}.`[perRowCol][perRowCol]}
+ *
+ * ## See Also
+ *  - {@include [SeeAlsoWith]}
+ *  - {@include [SeeAlsoPerCol]}
+ * @param expression The {@include [ExpressionsGivenColumn.RowColumnExpressionLink]} to provide a new value for every selected cell giving its row and column.
+ */
 public infix fun <T, C> Update<T, C>.perRowCol(expression: RowColumnExpression<T, C, C>): DataFrame<T> =
     updateImpl { row, column, _ -> expression(row, column) }
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt
index b02417b83..e2fa5f4d8 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt
@@ -3,6 +3,7 @@ package org.jetbrains.kotlinx.dataframe.documentation
 import org.jetbrains.kotlinx.dataframe.*
 import org.jetbrains.kotlinx.dataframe.api.*
 import org.jetbrains.kotlinx.dataframe.ColumnExpression as DfColumnExpression
+import org.jetbrains.kotlinx.dataframe.RowColumnExpression as DfRowColumnExpression
 
 /**
  * ## Expressions Given Column
@@ -28,7 +29,7 @@ internal interface ExpressionsGivenColumn {
          *
          * For example:
          *
-         * `df.`{@includeArg [OperationArg]}` { it / `[mean][DataColumn.mean]`(skipNA = true) }`
+         * `df.`{@includeArg [OperationArg]}` { `[mean][DataColumn.mean]`(skipNA = true) }`
          *
          * `df.`{@includeArg [OperationArg]}` { `[count][DataColumn.count]` { it > 10 } }`
          * @include [SetDefaultOperationArg]
@@ -39,14 +40,21 @@ internal interface ExpressionsGivenColumn {
     /** [Column Expression][ColumnExpression] */
     interface ColumnExpressionLink
 
-    /**
-     * TODO
-     */
+    /** Provide a new value for every selected cell given both its row and column using a [row-column expression][DfRowColumnExpression]. */
     interface RowColumnExpression {
 
         /**
-         * TODO
          * @include [RowColumnExpression]
+         *
+         * For example:
+         *
+         * `df.`{@includeArg [OperationArg]}` { row, col ->`
+         *
+         * `row.age / col.`[mean][DataColumn.mean]`(skipNA = true)`
+         *
+         * `}`
+         *
+         * @include [SetDefaultOperationArg]
          */
         interface WithExample
     }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
index 078697015..74db05625 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
@@ -86,8 +86,20 @@ internal interface ExpressionsGivenRow {
     /** [Row Value Expression][RowValueExpression.WithExample] */
     interface RowValueExpressionLink
 
-    /** @include [ExpressionsGivenColumn.RowColumnExpression] */
-    interface RowColumnExpression
+//    @Deprecated(
+//        "This is located in another file",
+//        ReplaceWith("ExpressionsGivenColumn.RowColumnExpression"),
+//        DeprecationLevel.ERROR,
+//    )
+//    interface RowColumnExpression {
+//
+//        @Deprecated(
+//            "This is located in another file",
+//            ReplaceWith("ExpressionsGivenColumn.RowColumnExpression.WithExample"),
+//            DeprecationLevel.ERROR,
+//        )
+//        interface WithExample
+//    }
 }
 
 /** [Row Expression][ExpressionsGivenRow] */

From 15026b7e0264e276f4a1f72c28220d7503ef5692 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Fri, 24 Feb 2023 12:48:30 +0100
Subject: [PATCH 34/50] updated doc processor gradle plugin

---
 core/build.gradle.kts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 0b001588d..23e4accd9 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -14,7 +14,7 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.19"
+    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.20"
 //    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
 }
 

From 91e97548c70b489990d7e9f28f8f7625b29cb70a Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Mon, 27 Feb 2023 14:36:16 +0100
Subject: [PATCH 35/50] cleaning PR a bit and added new target folder with
 generated sources

---
 core/build.gradle.kts                         |  1 +
 .../kotlinx/dataframe/api/countDistinct.kt    |  3 +--
 .../jetbrains/kotlinx/dataframe/api/gather.kt | 19 +++++++++++++------
 3 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 23e4accd9..c37074534 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -64,6 +64,7 @@ val kotlinMainSources = kotlin.sourceSets.main.get().kotlin.sourceDirectories
 val processKDocsMain by creatingProcessDocTask(
     sources = kotlinMainSources.filterNot { "build/generated" in it.path } // Exclude generated sources
 ) {
+    target = file("generated-sources")
     processors = listOf(
         INCLUDE_DOC_PROCESSOR,
         INCLUDE_FILE_DOC_PROCESSOR,
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
index 4239b8da3..37cfdb6c9 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
@@ -19,7 +19,6 @@ public fun <T, C> DataFrame<T>.countDistinct(columns: ColumnsSelector<T, C>): In
 
 public fun <T> DataFrame<T>.countDistinct(vararg columns: String): Int = countDistinct { columns.toColumns() }
 public fun <T, C> DataFrame<T>.countDistinct(vararg columns: KProperty<C>): Int = countDistinct { columns.toColumns() }
-public fun <T> DataFrame<T>.countDistinct(vararg columns: Column): Int =
-    countDistinct { columns.toColumns() }
+public fun <T> DataFrame<T>.countDistinct(vararg columns: Column): Int = countDistinct { columns.toColumns() }
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt
index c65604ae1..119ab658a 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt
@@ -12,10 +12,15 @@ import kotlin.reflect.KProperty
 import kotlin.reflect.KType
 import kotlin.reflect.typeOf
 
-public fun <T, C> DataFrame<T>.gather(selector: ColumnsSelector<T, C>): Gather<T, C, String, C> = Gather(
-    this, selector, null, typeOf<String>(),
-    { it }, null
-)
+public fun <T, C> DataFrame<T>.gather(selector: ColumnsSelector<T, C>): Gather<T, C, String, C> =
+    Gather(
+        df = this,
+        columns = selector,
+        filter = null,
+        keyType = typeOf<String>(),
+        keyTransform = { it },
+        valueTransform = null,
+    )
 
 public fun <T> DataFrame<T>.gather(vararg columns: String): Gather<T, Any?, String, Any?> =
     gather { columns.toColumns() }
@@ -29,9 +34,11 @@ public fun <T, C> DataFrame<T>.gather(vararg columns: KProperty<C>): Gather<T, C
 public fun <T, C, K, R> Gather<T, C, K, R>.where(filter: RowValueFilter<T, C>): Gather<T, C, K, R> =
     copy(filter = this.filter and filter)
 
-public fun <T, C, K, R> Gather<T, C?, K, R>.notNull(): Gather<T, C, K, R> = where { it != null } as Gather<T, C, K, R>
+public fun <T, C, K, R> Gather<T, C?, K, R>.notNull(): Gather<T, C, K, R> =
+    where { it != null } as Gather<T, C, K, R>
 
-public fun <T, C, K, R> Gather<T, C, K, R>.explodeLists(): Gather<T, C, K, R> = copy(explode = true)
+public fun <T, C, K, R> Gather<T, C, K, R>.explodeLists(): Gather<T, C, K, R> =
+    copy(explode = true)
 
 public inline fun <T, C, reified K, R> Gather<T, C, *, R>.mapKeys(noinline transform: (String) -> K): Gather<T, C, K, R> =
     copy(keyTransform = transform as ((String) -> Nothing), keyType = typeOf<K>()) as Gather<T, C, K, R>

From 91c9e8e917e9c8e6832a1b95615025c59e80993a Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Mon, 27 Feb 2023 14:40:29 +0100
Subject: [PATCH 36/50] added generated sources with docs. Do we want to do it
 like this?

---
 .../kotlinx/dataframe/ColumnsContainer.kt     |  66 ++
 .../jetbrains/kotlinx/dataframe/DataColumn.kt | 138 +++
 .../jetbrains/kotlinx/dataframe/DataFrame.kt  |  93 ++
 .../jetbrains/kotlinx/dataframe/DataRow.kt    | 100 ++
 .../dataframe/aggregation/Aggregatable.kt     |   3 +
 .../dataframe/aggregation/AggregateDsl.kt     |  25 +
 .../aggregation/AggregateGroupedDsl.kt        |   3 +
 .../ColumnsForAggregateSelectionDsl.kt        |  19 +
 .../dataframe/aggregation/NamedValue.kt       |  26 +
 .../kotlinx/dataframe/aggregation/aliases.kt  |  10 +
 .../jetbrains/kotlinx/dataframe/aliases.kt    | 175 ++++
 .../dataframe/annotations/ColumnName.kt       |   4 +
 .../dataframe/annotations/DataSchema.kt       |   4 +
 .../dataframe/annotations/ImportDataSchema.kt |  61 ++
 .../dataframe/api/ColumnAccessorApi.kt        |   5 +
 .../dataframe/api/ColumnReferenceApi.kt       |  21 +
 .../dataframe/api/ColumnsSelectionDsl.kt      | 376 +++++++
 .../kotlinx/dataframe/api/Cumulative.kt       |   1 +
 .../dataframe/api/DataColumnArithmetics.kt    | 111 ++
 .../kotlinx/dataframe/api/DataColumnType.kt   |  27 +
 .../kotlinx/dataframe/api/DataFrameGet.kt     | 126 +++
 .../kotlinx/dataframe/api/DataRowApi.kt       | 119 +++
 .../kotlinx/dataframe/api/Defaults.kt         |   7 +
 .../kotlinx/dataframe/api/JsonPath.kt         |  69 ++
 .../kotlinx/dataframe/api/KeyValueProperty.kt |  15 +
 .../jetbrains/kotlinx/dataframe/api/Misc.kt   |   1 +
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  | 638 ++++++++++++
 .../kotlinx/dataframe/api/TypeConversions.kt  | 312 ++++++
 .../jetbrains/kotlinx/dataframe/api/add.kt    | 236 +++++
 .../jetbrains/kotlinx/dataframe/api/addId.kt  |  22 +
 .../kotlinx/dataframe/api/aggregate.kt        |  11 +
 .../jetbrains/kotlinx/dataframe/api/all.kt    |  34 +
 .../jetbrains/kotlinx/dataframe/api/any.kt    |  19 +
 .../jetbrains/kotlinx/dataframe/api/append.kt |  30 +
 .../kotlinx/dataframe/api/asIterable.kt       |   9 +
 .../kotlinx/dataframe/api/asSequence.kt       |  17 +
 .../kotlinx/dataframe/api/associate.kt        |  15 +
 .../kotlinx/dataframe/api/between.kt          |  11 +
 .../jetbrains/kotlinx/dataframe/api/cast.kt   |  49 +
 .../kotlinx/dataframe/api/chunked.kt          |  25 +
 .../jetbrains/kotlinx/dataframe/api/concat.kt |  58 ++
 .../kotlinx/dataframe/api/constructors.kt     | 332 ++++++
 .../kotlinx/dataframe/api/convert.kt          | 387 +++++++
 .../kotlinx/dataframe/api/convertTo.kt        | 200 ++++
 .../jetbrains/kotlinx/dataframe/api/copy.kt   |   9 +
 .../jetbrains/kotlinx/dataframe/api/corr.kt   |  35 +
 .../jetbrains/kotlinx/dataframe/api/count.kt  |  54 +
 .../kotlinx/dataframe/api/countDistinct.kt    |  24 +
 .../jetbrains/kotlinx/dataframe/api/cumSum.kt |  57 +
 .../kotlinx/dataframe/api/describe.kt         |  48 +
 .../kotlinx/dataframe/api/digitize.kt         |  29 +
 .../kotlinx/dataframe/api/distinct.kt         |  41 +
 .../jetbrains/kotlinx/dataframe/api/drop.kt   |  57 +
 .../kotlinx/dataframe/api/duplicate.kt        |  18 +
 .../jetbrains/kotlinx/dataframe/api/enum.kt   |  11 +
 .../kotlinx/dataframe/api/explode.kt          |  59 ++
 .../jetbrains/kotlinx/dataframe/api/filter.kt |  34 +
 .../jetbrains/kotlinx/dataframe/api/first.kt  |  57 +
 .../kotlinx/dataframe/api/flatten.kt          |  15 +
 .../kotlinx/dataframe/api/forEach.kt          |  29 +
 .../jetbrains/kotlinx/dataframe/api/format.kt | 118 +++
 .../jetbrains/kotlinx/dataframe/api/frames.kt |  16 +
 .../jetbrains/kotlinx/dataframe/api/gather.kt | 102 ++
 .../jetbrains/kotlinx/dataframe/api/group.kt  |  33 +
 .../kotlinx/dataframe/api/groupBy.kt          |  91 ++
 .../jetbrains/kotlinx/dataframe/api/head.kt   |   9 +
 .../kotlinx/dataframe/api/implode.kt          |  24 +
 .../kotlinx/dataframe/api/indices.kt          |  17 +
 .../kotlinx/dataframe/api/inferType.kt        |  19 +
 .../jetbrains/kotlinx/dataframe/api/insert.kt |  51 +
 .../jetbrains/kotlinx/dataframe/api/into.kt   |  68 ++
 .../kotlinx/dataframe/api/isEmpty.kt          |  12 +
 .../jetbrains/kotlinx/dataframe/api/join.kt   | 128 +++
 .../jetbrains/kotlinx/dataframe/api/last.kt   |  58 ++
 .../jetbrains/kotlinx/dataframe/api/length.kt |  10 +
 .../kotlinx/dataframe/api/lowercase.kt        |   9 +
 .../jetbrains/kotlinx/dataframe/api/map.kt    | 130 +++
 .../kotlinx/dataframe/api/matches.kt          |  10 +
 .../jetbrains/kotlinx/dataframe/api/max.kt    | 170 +++
 .../jetbrains/kotlinx/dataframe/api/mean.kt   | 183 ++++
 .../jetbrains/kotlinx/dataframe/api/median.kt | 150 +++
 .../jetbrains/kotlinx/dataframe/api/merge.kt  | 104 ++
 .../jetbrains/kotlinx/dataframe/api/min.kt    | 170 +++
 .../jetbrains/kotlinx/dataframe/api/move.kt   |  84 ++
 .../jetbrains/kotlinx/dataframe/api/parse.kt  |  65 ++
 .../jetbrains/kotlinx/dataframe/api/pivot.kt  | 125 +++
 .../jetbrains/kotlinx/dataframe/api/print.kt  |  44 +
 .../jetbrains/kotlinx/dataframe/api/remove.kt |  24 +
 .../jetbrains/kotlinx/dataframe/api/rename.kt |  77 ++
 .../kotlinx/dataframe/api/reorder.kt          |  48 +
 .../kotlinx/dataframe/api/replace.kt          |  50 +
 .../kotlinx/dataframe/api/reverse.kt          |  18 +
 .../jetbrains/kotlinx/dataframe/api/schema.kt |  25 +
 .../jetbrains/kotlinx/dataframe/api/select.kt |  37 +
 .../kotlinx/dataframe/api/shuffle.kt          |  17 +
 .../jetbrains/kotlinx/dataframe/api/single.kt |  31 +
 .../jetbrains/kotlinx/dataframe/api/sort.kt   | 141 +++
 .../jetbrains/kotlinx/dataframe/api/split.kt  | 300 ++++++
 .../jetbrains/kotlinx/dataframe/api/std.kt    | 252 +++++
 .../jetbrains/kotlinx/dataframe/api/sum.kt    | 143 +++
 .../jetbrains/kotlinx/dataframe/api/tail.kt   |   9 +
 .../jetbrains/kotlinx/dataframe/api/take.kt   |  49 +
 .../kotlinx/dataframe/api/toDataFrame.kt      | 209 ++++
 .../jetbrains/kotlinx/dataframe/api/toList.kt |  14 +
 .../kotlinx/dataframe/api/transpose.kt        |  29 +
 .../jetbrains/kotlinx/dataframe/api/unfold.kt |  28 +
 .../kotlinx/dataframe/api/ungroup.kt          |  21 +
 .../jetbrains/kotlinx/dataframe/api/update.kt | 778 ++++++++++++++
 .../kotlinx/dataframe/api/uppercase.kt        |   9 +
 .../kotlinx/dataframe/api/valueCounts.kt      |  87 ++
 .../jetbrains/kotlinx/dataframe/api/values.kt | 177 ++++
 .../jetbrains/kotlinx/dataframe/api/with.kt   |  47 +
 .../org/jetbrains/kotlinx/dataframe/api/xs.kt |  21 +
 .../dataframe/codeGen/CodeGenerator.kt        |  73 ++
 .../dataframe/codeGen/CodeWithConverter.kt    |  29 +
 .../dataframe/codeGen/DefaultReadDfMethods.kt | 103 ++
 .../codeGen/ExtensionsCodeGenerator.kt        |  12 +
 .../dataframe/codeGen/GeneratedField.kt       | 145 +++
 .../kotlinx/dataframe/codeGen/Marker.kt       | 119 +++
 .../dataframe/codeGen/MarkersExtractor.kt     |  91 ++
 .../dataframe/codeGen/NameNormalizer.kt       |   5 +
 .../dataframe/codeGen/ReplCodeGenerator.kt    |  30 +
 .../dataframe/codeGen/SchemaProcessor.kt      |  27 +
 .../kotlinx/dataframe/codeGen/generateCode.kt |  43 +
 .../kotlinx/dataframe/columns/BaseColumn.kt   |  72 ++
 .../dataframe/columns/ColumnAccessor.kt       |  27 +
 .../kotlinx/dataframe/columns/ColumnGroup.kt  |  42 +
 .../kotlinx/dataframe/columns/ColumnKind.kt   |  13 +
 .../kotlinx/dataframe/columns/ColumnPath.kt   |  57 +
 .../dataframe/columns/ColumnReference.kt      |  44 +
 .../kotlinx/dataframe/columns/ColumnSet.kt    |  26 +
 .../dataframe/columns/ColumnWithPath.kt       |  27 +
 .../kotlinx/dataframe/columns/FrameColumn.kt  |  23 +
 .../kotlinx/dataframe/columns/SingleColumn.kt |  15 +
 .../kotlinx/dataframe/columns/ValueColumn.kt  |  24 +
 .../kotlinx/dataframe/dataTypes/IFRAME.kt     |  16 +
 .../kotlinx/dataframe/dataTypes/IMG.kt        |  22 +
 .../dataframe/documentation/AccessApi.kt      | 135 +++
 .../documentation/DocumentationUrls.kt        |  53 +
 .../documentation/ExpressionsGivenColumn.kt   |  61 ++
 .../ExpressionsGivenDataFrame.kt              |  32 +
 .../documentation/ExpressionsGivenRow.kt      | 109 ++
 .../documentation/SelectingColumns.kt         | 169 +++
 .../dataframe/documentation/SelectingRows.kt  |  76 ++
 .../documentation/samples/ApiLevels.kt        | 146 +++
 .../kotlinx/dataframe/documentation/utils.kt  |   4 +
 .../exceptions/CellConversionException.kt     |  16 +
 .../exceptions/ColumnNotFoundException.kt     |   3 +
 .../DuplicateColumnNamesException.kt          |   9 +
 .../exceptions/ExcessiveColumnsException.kt   |   7 +
 .../exceptions/TypeConversionException.kt     |  16 +
 .../TypeConverterNotFoundException.kt         |  15 +
 .../exceptions/UnequalColumnSizesException.kt |  10 +
 .../jetbrains/kotlinx/dataframe/impl/Cache.kt |   8 +
 .../dataframe/impl/ColumnAccessTracker.kt     |  33 +
 .../dataframe/impl/ColumnDataCollector.kt     |  75 ++
 .../dataframe/impl/ColumnNameGenerator.kt     |  37 +
 .../kotlinx/dataframe/impl/DataFrameImpl.kt   | 149 +++
 .../dataframe/impl/DataFrameReceiver.kt       |  73 ++
 .../kotlinx/dataframe/impl/DataFrameSize.kt   |   5 +
 .../kotlinx/dataframe/impl/DataRowImpl.kt     |  62 ++
 .../kotlinx/dataframe/impl/ExceptionUtils.kt  |   6 +
 .../kotlinx/dataframe/impl/GroupByImpl.kt     | 102 ++
 .../kotlinx/dataframe/impl/MathUtils.kt       |  28 +
 .../kotlinx/dataframe/impl/Rendering.kt       |  90 ++
 .../kotlinx/dataframe/impl/TypeUtils.kt       | 430 ++++++++
 .../jetbrains/kotlinx/dataframe/impl/Utils.kt | 288 ++++++
 .../impl/aggregation/AggregatableInternal.kt  |  21 +
 .../aggregation/AggregateColumnDescriptor.kt  |  32 +
 .../aggregation/ConfiguredAggregateColumn.kt  |  45 +
 .../impl/aggregation/GroupByReceiverImpl.kt   |  88 ++
 .../impl/aggregation/PivotGroupByImpl.kt      |  32 +
 .../dataframe/impl/aggregation/PivotImpl.kt   |  21 +
 .../impl/aggregation/PivotInAggregateImpl.kt  |  30 +
 .../impl/aggregation/ValueWithDefault.kt      |   3 +
 .../impl/aggregation/aggregations.kt          |  97 ++
 .../aggregation/aggregators/Aggregator.kt     |  24 +
 .../aggregation/aggregators/AggregatorBase.kt |  18 +
 .../aggregators/AggregatorOptionSwitch.kt     |  30 +
 .../aggregators/AggregatorProvider.kt         |  10 +
 .../aggregation/aggregators/Aggregators.kt    |  41 +
 .../aggregators/MergedValuesAggregator.kt     |  41 +
 .../aggregators/NumbersAggregator.kt          |  28 +
 .../aggregators/TwoStepAggregator.kt          |  27 +
 .../dataframe/impl/aggregation/getColumns.kt  |  25 +
 .../impl/aggregation/modes/aggregateBy.kt     |  23 +
 .../impl/aggregation/modes/forEveryColumn.kt  |  51 +
 .../impl/aggregation/modes/noAggregation.kt   |  17 +
 .../impl/aggregation/modes/ofRowExpression.kt |  89 ++
 .../aggregation/modes/withinAllColumns.kt     |  60 ++
 .../receivers/AggregateInternalDsl.kt         |  36 +
 .../receivers/AggregatePivotDslImpl.kt        |  24 +
 .../kotlinx/dataframe/impl/api/concat.kt      |  91 ++
 .../kotlinx/dataframe/impl/api/convert.kt     | 446 ++++++++
 .../kotlinx/dataframe/impl/api/convertTo.kt   | 280 +++++
 .../kotlinx/dataframe/impl/api/corr.kt        |  75 ++
 .../kotlinx/dataframe/impl/api/describe.kt    |  76 ++
 .../kotlinx/dataframe/impl/api/duplicate.kt   |  73 ++
 .../kotlinx/dataframe/impl/api/explode.kt     | 110 ++
 .../kotlinx/dataframe/impl/api/flatten.kt     |  36 +
 .../kotlinx/dataframe/impl/api/format.kt      |  63 ++
 .../kotlinx/dataframe/impl/api/gather.kt      | 118 +++
 .../kotlinx/dataframe/impl/api/groupBy.kt     |  61 ++
 .../kotlinx/dataframe/impl/api/implode.kt     |  36 +
 .../kotlinx/dataframe/impl/api/insert.kt      | 135 +++
 .../kotlinx/dataframe/impl/api/join.kt        | 229 +++++
 .../kotlinx/dataframe/impl/api/map.kt         |  18 +
 .../kotlinx/dataframe/impl/api/move.kt        |  65 ++
 .../kotlinx/dataframe/impl/api/parse.kt       | 383 +++++++
 .../kotlinx/dataframe/impl/api/pivot.kt       | 123 +++
 .../kotlinx/dataframe/impl/api/remove.kt      |  65 ++
 .../kotlinx/dataframe/impl/api/reorder.kt     |  73 ++
 .../kotlinx/dataframe/impl/api/sort.kt        | 123 +++
 .../kotlinx/dataframe/impl/api/split.kt       |  67 ++
 .../kotlinx/dataframe/impl/api/toDataFrame.kt | 229 +++++
 .../kotlinx/dataframe/impl/api/toList.kt      |  75 ++
 .../kotlinx/dataframe/impl/api/update.kt      | 104 ++
 .../kotlinx/dataframe/impl/api/xs.kt          |  42 +
 .../impl/codeGen/CodeGeneratorImpl.kt         | 518 ++++++++++
 .../impl/codeGen/NameNormalizerImpl.kt        |  23 +
 .../impl/codeGen/ReplCodeGeneratorImpl.kt     | 144 +++
 .../impl/codeGen/SchemaProcessorImpl.kt       | 159 +++
 .../dataframe/impl/codeGen/SchemaReader.kt    |  94 ++
 .../impl/columns/ColumnAccessorImpl.kt        |  42 +
 .../dataframe/impl/columns/ColumnGroupImpl.kt | 105 ++
 .../impl/columns/ColumnGroupWithParent.kt     |  60 ++
 .../impl/columns/ColumnGroupWithPathImpl.kt   |  26 +
 .../impl/columns/ColumnWithParent.kt          |  34 +
 .../dataframe/impl/columns/ColumnsList.kt     |  10 +
 .../impl/columns/ComputedColumnReference.kt   |  33 +
 .../dataframe/impl/columns/DataColumnGroup.kt |  21 +
 .../dataframe/impl/columns/DataColumnImpl.kt  |  43 +
 .../impl/columns/DataColumnInternal.kt        |  20 +
 .../impl/columns/DistinctColumnSet.kt         |  10 +
 .../impl/columns/ForceResolvedColumn.kt       |   7 +
 .../dataframe/impl/columns/FrameColumnImpl.kt |  72 ++
 .../impl/columns/FrameColumnWithParent.kt     |  32 +
 .../impl/columns/FrameColumnWithPathImpl.kt   |  19 +
 .../impl/columns/RenamedColumnReference.kt    |  21 +
 .../kotlinx/dataframe/impl/columns/Utils.kt   | 191 ++++
 .../dataframe/impl/columns/ValueColumnImpl.kt |  71 ++
 .../impl/columns/ValueColumnWithParent.kt     |  27 +
 .../impl/columns/ValueColumnWithPathImpl.kt   |  18 +
 .../dataframe/impl/columns/constructors.kt    | 290 ++++++
 .../columns/missing/MissingColumnGroup.kt     |  69 ++
 .../impl/columns/missing/MissingDataColumn.kt |  36 +
 .../impl/columns/tree/ColumnPosition.kt       |   9 +
 .../impl/columns/tree/ReadonlyTreeNode.kt     |  14 +
 .../impl/columns/tree/ReferenceData.kt        |   6 +
 .../dataframe/impl/columns/tree/TreeNode.kt   |  66 ++
 .../dataframe/impl/columns/tree/Utils.kt      | 132 +++
 .../impl/schema/DataFrameSchemaImpl.kt        |  81 ++
 .../kotlinx/dataframe/impl/schema/Utils.kt    | 145 +++
 .../jetbrains/kotlinx/dataframe/io/common.kt  |  60 ++
 .../org/jetbrains/kotlinx/dataframe/io/csv.kt | 355 +++++++
 .../jetbrains/kotlinx/dataframe/io/guess.kt   | 297 ++++++
 .../jetbrains/kotlinx/dataframe/io/html.kt    | 461 +++++++++
 .../jetbrains/kotlinx/dataframe/io/json.kt    | 971 ++++++++++++++++++
 .../jetbrains/kotlinx/dataframe/io/string.kt  | 187 ++++
 .../org/jetbrains/kotlinx/dataframe/io/tsv.kt | 108 ++
 .../kotlinx/dataframe/jupyter/CellRenderer.kt |  90 ++
 .../kotlinx/dataframe/jupyter/Integration.kt  | 267 +++++
 .../dataframe/jupyter/JupyterConfiguration.kt |  10 +
 .../dataframe/jupyter/JupyterHtmlRenderer.kt  |  34 +
 .../dataframe/jupyter/importDataSchema.kt     |  46 +
 .../dataframe/jupyter/kernelUpdateMessages.kt |  26 +
 .../kotlinx/dataframe/math/cumsum.kt          | 139 +++
 .../jetbrains/kotlinx/dataframe/math/mean.kt  | 111 ++
 .../kotlinx/dataframe/math/median.kt          |  68 ++
 .../kotlinx/dataframe/math/minmax.kt          |  23 +
 .../jetbrains/kotlinx/dataframe/math/std.kt   |  42 +
 .../kotlinx/dataframe/math/stdMean.kt         | 110 ++
 .../jetbrains/kotlinx/dataframe/math/sum.kt   |  58 ++
 .../kotlinx/dataframe/schema/ColumnSchema.kt  |  95 ++
 .../kotlinx/dataframe/schema/CompareResult.kt |  28 +
 .../dataframe/schema/DataFrameSchema.kt       |   8 +
 .../dataframe/test/sampleExtensions.kt        |  17 +
 .../jetbrains/kotlinx/dataframe/test/usage.kt |  17 +
 278 files changed, 22945 insertions(+)
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/ColumnsContainer.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataColumn.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataFrame.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataRow.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/Aggregatable.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateDsl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateGroupedDsl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/ColumnsForAggregateSelectionDsl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/NamedValue.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/aliases.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/ColumnName.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/DataSchema.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/ImportDataSchema.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnAccessorApi.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnReferenceApi.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Cumulative.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnArithmetics.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnType.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataFrameGet.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowApi.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Defaults.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/JsonPath.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/KeyValueProperty.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Misc.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/TypeConversions.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/addId.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/aggregate.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/all.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/any.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/append.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/asIterable.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/asSequence.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/associate.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/between.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/chunked.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/concat.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/constructors.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convertTo.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/copy.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/count.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/digitize.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/drop.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/duplicate.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/enum.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/filter.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/first.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/flatten.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/forEach.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/format.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frames.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/head.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/implode.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/indices.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/insert.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/into.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/isEmpty.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/last.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/length.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/lowercase.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/map.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/matches.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/mean.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/merge.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/parse.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/print.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reverse.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/schema.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/shuffle.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/single.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sort.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/split.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/std.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sum.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/tail.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/take.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toList.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/transpose.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/unfold.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/uppercase.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/values.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/with.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/xs.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeGenerator.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeWithConverter.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/DefaultReadDfMethods.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ExtensionsCodeGenerator.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/GeneratedField.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/Marker.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/MarkersExtractor.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/NameNormalizer.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ReplCodeGenerator.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/SchemaProcessor.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/generateCode.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/BaseColumn.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnAccessor.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnGroup.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnKind.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnPath.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnReference.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnSet.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnWithPath.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/FrameColumn.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/SingleColumn.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ValueColumn.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/dataTypes/IFRAME.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/dataTypes/IMG.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenDataFrame.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/samples/ApiLevels.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/utils.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/CellConversionException.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/ColumnNotFoundException.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/DuplicateColumnNamesException.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/ExcessiveColumnsException.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/TypeConversionException.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/TypeConverterNotFoundException.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/UnequalColumnSizesException.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Cache.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ColumnAccessTracker.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ColumnDataCollector.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ColumnNameGenerator.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameImpl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameReceiver.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameSize.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataRowImpl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ExceptionUtils.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/GroupByImpl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/MathUtils.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Rendering.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/TypeUtils.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Utils.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/AggregatableInternal.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/AggregateColumnDescriptor.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ConfiguredAggregateColumn.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/GroupByReceiverImpl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotGroupByImpl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotImpl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotInAggregateImpl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ValueWithDefault.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregations.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregator.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorBase.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorOptionSwitch.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorProvider.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregators.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/MergedValuesAggregator.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/NumbersAggregator.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/TwoStepAggregator.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/getColumns.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/aggregateBy.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/forEveryColumn.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/noAggregation.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/ofRowExpression.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/withinAllColumns.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/receivers/AggregateInternalDsl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/receivers/AggregatePivotDslImpl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/concat.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convert.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convertTo.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/corr.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/describe.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/duplicate.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/explode.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/flatten.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/format.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/gather.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/groupBy.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/implode.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/insert.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/join.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/map.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/move.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/parse.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/pivot.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/remove.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/reorder.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/sort.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/split.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/toDataFrame.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/toList.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/update.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/xs.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/CodeGeneratorImpl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/NameNormalizerImpl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/ReplCodeGeneratorImpl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaProcessorImpl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaReader.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnAccessorImpl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupImpl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupWithParent.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupWithPathImpl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnWithParent.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnsList.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ComputedColumnReference.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnGroup.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnImpl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnInternal.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DistinctColumnSet.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ForceResolvedColumn.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/FrameColumnImpl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/FrameColumnWithParent.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/FrameColumnWithPathImpl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/RenamedColumnReference.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/Utils.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnImpl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnWithParent.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnWithPathImpl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingColumnGroup.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingDataColumn.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/ColumnPosition.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/ReadonlyTreeNode.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/ReferenceData.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/TreeNode.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/Utils.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/DataFrameSchemaImpl.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/Utils.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/common.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/csv.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/guess.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/html.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/string.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/tsv.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/CellRenderer.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/Integration.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterConfiguration.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterHtmlRenderer.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/importDataSchema.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/kernelUpdateMessages.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/cumsum.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/mean.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/median.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/minmax.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/std.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/stdMean.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/sum.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/ColumnSchema.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/CompareResult.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/DataFrameSchema.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/test/sampleExtensions.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/test/usage.kt

diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/ColumnsContainer.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/ColumnsContainer.kt
new file mode 100644
index 000000000..397ce223a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/ColumnsContainer.kt
@@ -0,0 +1,66 @@
+package org.jetbrains.kotlinx.dataframe
+
+import org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.castFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import kotlin.reflect.KProperty
+
+/**
+ * Provides access to [columns][DataColumn].
+ *
+ * Base interface for [DataFrame] and [ColumnSelectionDsl]
+ *
+ * @param T Schema marker. Used to generate extension properties for typed column access.
+ */
+public interface ColumnsContainer<out T> {
+
+    // region columns
+
+    public fun columns(): List<AnyCol>
+    public fun columnsCount(): Int
+    public fun containsColumn(name: String): Boolean
+    public fun containsColumn(path: ColumnPath): Boolean
+    public fun getColumnIndex(name: String): Int
+
+    // endregion
+
+    // region getColumnOrNull
+
+    public fun getColumnOrNull(name: String): AnyCol?
+    public fun getColumnOrNull(index: Int): AnyCol?
+    public fun <R> getColumnOrNull(column: ColumnReference<R>): DataColumn<R>?
+    public fun getColumnOrNull(path: ColumnPath): AnyCol?
+    public fun <R> getColumnOrNull(column: ColumnSelector<T, R>): DataColumn<R>?
+
+    // endregion
+
+    // region get
+
+    public operator fun get(columnName: String): AnyCol = getColumn(columnName)
+    public operator fun get(columnPath: ColumnPath): AnyCol = getColumn(columnPath)
+
+    public operator fun <R> get(column: DataColumn<R>): DataColumn<R> = getColumn(column.name()).cast()
+    public operator fun <R> get(column: DataColumn<DataRow<R>>): ColumnGroup<R> = getColumn(column)
+    public operator fun <R> get(column: DataColumn<DataFrame<R>>): FrameColumn<R> = getColumn(column)
+
+    public operator fun <R> get(column: ColumnReference<R>): DataColumn<R> = getColumn(column)
+    public operator fun <R> get(column: ColumnReference<DataRow<R>>): ColumnGroup<R> = getColumn(column)
+    public operator fun <R> get(column: ColumnReference<DataFrame<R>>): FrameColumn<R> = getColumn(column)
+
+    public operator fun <R> get(column: KProperty<R>): DataColumn<R> = get(column.columnName).cast()
+    public operator fun <R> get(column: KProperty<DataRow<R>>): ColumnGroup<R> = get(column.columnName).asColumnGroup().cast()
+    public operator fun <R> get(column: KProperty<DataFrame<R>>): FrameColumn<R> = get(column.columnName).asAnyFrameColumn().castFrameColumn()
+
+    public operator fun <C> get(columns: ColumnsSelector<T, C>): List<DataColumn<C>>
+    public operator fun <C> get(column: ColumnSelector<T, C>): DataColumn<C> = get(column as ColumnsSelector<T, C>).single()
+
+    // endregion
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataColumn.kt
new file mode 100644
index 000000000..37d387567
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataColumn.kt
@@ -0,0 +1,138 @@
+package org.jetbrains.kotlinx.dataframe
+
+import org.jetbrains.kotlinx.dataframe.api.Infer
+import org.jetbrains.kotlinx.dataframe.api.asDataColumn
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.api.take
+import org.jetbrains.kotlinx.dataframe.columns.BaseColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnGroupImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.FrameColumnImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.ValueColumnImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.guessColumnType
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnKind
+import org.jetbrains.kotlinx.dataframe.impl.getValuesType
+import org.jetbrains.kotlinx.dataframe.impl.splitByIndices
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import kotlin.reflect.KClass
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+/**
+ * Column with [name] and [values] of specific [type].
+ *
+ * Base interface for [ValueColumn] and [FrameColumn], but not for [ColumnGroup]. However, implementations for all three [column kinds][ColumnKind] derive from DataColumn and can cast to it safely.
+ * Column operations that have signature clash with [DataFrame] API ([filter], [take], [map] etc.) are defined for [DataColumn] and not for [BaseColumn].
+ *
+ * @param T type of values in the column.
+ */
+public interface DataColumn<out T> : BaseColumn<T> {
+
+    public companion object {
+
+        /**
+         * Creates [ValueColumn] using given [name], [values] and [type].
+         *
+         * @param name name of the column
+         * @param values list of column values
+         * @param type type of the column
+         * @param infer column type inference mode
+         */
+        public fun <T> createValueColumn(
+            name: String,
+            values: List<T>,
+            type: KType,
+            infer: Infer = Infer.None,
+            defaultValue: T? = null
+        ): ValueColumn<T> = ValueColumnImpl(values, name, getValuesType(values, type, infer), defaultValue)
+
+        /**
+         * Creates [ValueColumn] using given [name], [values] and reified column [type].
+         *
+         * Note, that column [type] will be defined at compile-time using [T] argument
+         *
+         * @param T type of the column
+         * @param name name of the column
+         * @param values list of column values
+         * @param infer column type inference mode
+         */
+        public inline fun <reified T> createValueColumn(name: String, values: List<T>, infer: Infer = Infer.None): ValueColumn<T> = createValueColumn(
+            name, values,
+            getValuesType(
+                values,
+                typeOf<T>(),
+                infer
+            )
+        )
+
+        public fun <T> createColumnGroup(name: String, df: DataFrame<T>): ColumnGroup<T> = ColumnGroupImpl(name, df)
+
+        public fun <T> createFrameColumn(
+            name: String,
+            df: DataFrame<T>,
+            startIndices: Iterable<Int>
+        ): FrameColumn<T> =
+            FrameColumnImpl(name, df.splitByIndices(startIndices.asSequence()).toList(), lazy { df.schema() })
+
+        public fun <T> createFrameColumn(
+            name: String,
+            groups: List<DataFrame<T>>,
+            schema: Lazy<DataFrameSchema>? = null
+        ): FrameColumn<T> = FrameColumnImpl(name, groups, schema)
+
+        public fun <T> createWithTypeInference(name: String, values: List<T>, nullable: Boolean? = null): DataColumn<T> = guessColumnType(name, values, nullable = nullable)
+
+        public fun <T> create(name: String, values: List<T>, type: KType, infer: Infer = Infer.None): DataColumn<T> {
+            return when (type.toColumnKind()) {
+                ColumnKind.Value -> createValueColumn(name, values, type, infer)
+                ColumnKind.Group -> createColumnGroup(name, (values as List<AnyRow?>).concat()).asDataColumn().cast()
+                ColumnKind.Frame -> createFrameColumn(name, values as List<AnyFrame>).asDataColumn().cast()
+            }
+        }
+
+        public inline fun <reified T> create(name: String, values: List<T>, infer: Infer = Infer.None): DataColumn<T> = create(name, values, typeOf<T>(), infer)
+
+        public fun empty(name: String = ""): AnyCol = createValueColumn(name, emptyList<Unit>(), typeOf<Unit>())
+    }
+
+    public fun hasNulls(): Boolean = type().isMarkedNullable
+
+    override fun distinct(): DataColumn<T>
+
+    override fun get(indices: Iterable<Int>): DataColumn<T>
+
+    override fun rename(newName: String): DataColumn<T>
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? = this.addPath()
+
+    override operator fun getValue(thisRef: Any?, property: KProperty<*>): DataColumn<T> = super.getValue(thisRef, property) as DataColumn<T>
+
+    public operator fun iterator(): Iterator<T> = values().iterator()
+
+    public override operator fun get(range: IntRange): DataColumn<T>
+}
+
+public val AnyCol.name: String get() = name()
+public val AnyCol.path: ColumnPath get() = path()
+
+public val <T> DataColumn<T>.values: Iterable<T> get() = values()
+public val AnyCol.hasNulls: Boolean get() = hasNulls()
+public val AnyCol.size: Int get() = size()
+public val AnyCol.indices: IntRange get() = indices()
+
+public val AnyCol.type: KType get() = type()
+public val AnyCol.kind: ColumnKind get() = kind()
+public val AnyCol.typeClass: KClass<*> get() = type.classifier as? KClass<*> ?: error("Cannot cast ${type.classifier?.javaClass} to a ${KClass::class}. Column $name: $type")
+
+public fun AnyBaseCol.indices(): IntRange = 0 until size()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataFrame.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataFrame.kt
new file mode 100644
index 000000000..dd1c55636
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataFrame.kt
@@ -0,0 +1,93 @@
+package org.jetbrains.kotlinx.dataframe
+
+import org.jetbrains.kotlinx.dataframe.aggregation.Aggregatable
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedBody
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.getRows
+import org.jetbrains.kotlinx.dataframe.api.indices
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameImpl
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameSize
+import org.jetbrains.kotlinx.dataframe.impl.getColumnsImpl
+import org.jetbrains.kotlinx.dataframe.impl.headPlusArray
+import org.jetbrains.kotlinx.dataframe.impl.headPlusIterable
+import org.jetbrains.kotlinx.dataframe.impl.schema.createEmptyDataFrameOf
+import kotlin.reflect.KType
+
+/**
+ * Readonly interface for an ordered list of [columns][DataColumn].
+ *
+ * Columns in `DataFrame` have distinct non-empty [names][DataColumn.name] and equal [sizes][DataColumn.size].
+ *
+ * @param T Schema marker. It identifies column schema and is used to generate schema-specific extension properties for typed data access. It is covariant, so `DataFrame<A>` is assignable to variable of type `DataFrame<B>` if `A` is a subtype of `B`.
+ */
+public interface DataFrame<out T> : Aggregatable<T>, ColumnsContainer<T> {
+
+    public companion object {
+        public val Empty: AnyFrame = DataFrameImpl<Unit>(emptyList(), 0)
+        public fun empty(nrow: Int = 0): AnyFrame = if (nrow == 0) Empty else DataFrameImpl<Unit>(emptyList(), nrow)
+
+        public inline fun <reified T> emptyOf(): DataFrame<T> = createEmptyDataFrameOf(T::class).cast()
+    }
+
+    // region columns
+
+    public fun columnNames(): List<String>
+
+    public fun columnTypes(): List<KType>
+
+    // endregion
+
+    // region rows
+
+    public fun rowsCount(): Int
+
+    public operator fun iterator(): Iterator<DataRow<T>> = rows().iterator()
+
+    // endregion
+
+    public fun <R> aggregate(body: AggregateGroupedBody<T, R>): DataRow<T>
+
+    // region get columns
+
+    override operator fun <C> get(columns: ColumnsSelector<T, C>): List<DataColumn<C>> =
+        getColumnsImpl(UnresolvedColumnsPolicy.Fail, columns)
+
+    public operator fun get(first: Column, vararg other: Column): DataFrame<T> = select(listOf(first) + other)
+    public operator fun get(first: String, vararg other: String): DataFrame<T> = select(listOf(first) + other)
+    public operator fun get(columnRange: ClosedRange<String>): DataFrame<T> =
+        select { columnRange.start..columnRange.endInclusive }
+
+    // endregion
+
+    // region get rows
+
+    public operator fun get(index: Int): DataRow<T>
+    public operator fun get(indices: Iterable<Int>): DataFrame<T> = getRows(indices)
+    public operator fun get(range: IntRange): DataFrame<T> = getRows(range)
+    public operator fun get(first: IntRange, vararg ranges: IntRange): DataFrame<T> =
+        getRows(headPlusArray(first, ranges).asSequence().flatMap { it.asSequence() }.asIterable())
+
+    public operator fun get(firstIndex: Int, vararg otherIndices: Int): DataFrame<T> =
+        get(headPlusIterable(firstIndex, otherIndices.asIterable()))
+
+    // endregion
+
+    // region plus columns
+
+    public operator fun plus(col: AnyBaseCol): DataFrame<T> = add(col)
+    public operator fun plus(cols: Iterable<AnyBaseCol>): DataFrame<T> = (columns() + cols).toDataFrame().cast()
+
+    // endregion
+}
+
+internal val ColumnsContainer<*>.ncol get() = columnsCount()
+internal val AnyFrame.nrow get() = rowsCount()
+internal val AnyFrame.indices get() = indices()
+internal val AnyFrame.size: DataFrameSize get() = size()
+
+public fun AnyFrame.size(): DataFrameSize = DataFrameSize(ncol, nrow)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataRow.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataRow.kt
new file mode 100644
index 000000000..989fb3df2
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataRow.kt
@@ -0,0 +1,100 @@
+package org.jetbrains.kotlinx.dataframe
+
+import org.jetbrains.kotlinx.dataframe.api.next
+import org.jetbrains.kotlinx.dataframe.api.prev
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.owner
+import org.jetbrains.kotlinx.dataframe.impl.toIterable
+import kotlin.reflect.KProperty
+
+/**
+ * Single row of a [DataFrame].
+ *
+ * @param T Schema marker. See [DataFrame] for details
+ */
+public interface DataRow<out T> {
+
+    public fun index(): Int
+
+    public fun df(): DataFrame<T>
+
+    // region get cell value
+
+    public operator fun get(columnIndex: Int): Any?
+    public operator fun <R> get(expression: RowExpression<T, R>): R = expression(this, this)
+    public operator fun <R> get(column: ColumnReference<R>): R
+    public operator fun <R> get(columns: List<ColumnReference<R>>): List<R> = columns.map { get(it) }
+    public operator fun <R> get(property: KProperty<R>): R = get(property.columnName) as R
+    public operator fun get(first: Column, vararg other: Column): DataRow<T> = owner.get(first, *other)[index]
+    public operator fun get(first: String, vararg other: String): DataRow<T> = owner.get(first, *other)[index]
+    public operator fun get(path: ColumnPath): Any? = owner.get(path)[index]
+    public operator fun get(name: String): Any?
+    public fun getColumnGroup(columnName: String): AnyRow {
+        val value = get(columnName)
+        if (value == null) {
+            val kind = df()[columnName].kind()
+            if (kind != ColumnKind.Group) {
+                error("Cannot cast null value of a $kind to a ${DataRow::class}")
+            }
+        }
+        return value as AnyRow
+    }
+
+    public fun getOrNull(name: String): Any?
+    public fun <R> getValueOrNull(column: ColumnReference<R>): R?
+
+    // endregion
+
+    public fun values(): List<Any?>
+
+    public operator fun String.get(vararg path: String): ColumnPath = ColumnPath(listOf(this) + path)
+
+    public operator fun <R> ColumnReference<R>.invoke(): R = get(this)
+    public operator fun <R> String.invoke(): R = this@DataRow[this@invoke] as R
+    public operator fun <R> ColumnPath.invoke(): R = this@DataRow.get(this) as R
+
+    public fun forwardIterable(): Iterable<DataRow<T>> = this.toIterable { it.next }
+    public fun backwardIterable(): Iterable<DataRow<T>> = this.toIterable { it.prev }
+
+    public operator fun <R : Comparable<R>> ColumnReference<R>.compareTo(other: R): Int = get(this).compareTo(other)
+    public operator fun ColumnReference<Int>.plus(a: Int): Int = get(this) + a
+    public operator fun ColumnReference<Long>.plus(a: Long): Long = get(this) + a
+    public operator fun ColumnReference<Double>.plus(a: Double): Double = get(this) + a
+    public operator fun ColumnReference<String>.plus(a: String): String = get(this) + a
+    public operator fun Int.plus(col: ColumnReference<Int>): Int = this + get(col)
+    public operator fun Long.plus(col: ColumnReference<Long>): Long = this + get(col)
+    public operator fun Double.plus(col: ColumnReference<Double>): Double = this + get(col)
+
+    public operator fun ColumnReference<Int>.minus(a: Int): Int = get(this) - a
+    public operator fun ColumnReference<Long>.minus(a: Long): Long = get(this) - a
+    public operator fun ColumnReference<Double>.minus(a: Double): Double = get(this) - a
+    public operator fun Int.minus(col: ColumnReference<Int>): Int = this - get(col)
+    public operator fun Long.minus(col: ColumnReference<Long>): Long = this - get(col)
+    public operator fun Double.minus(col: ColumnReference<Double>): Double = this - get(col)
+
+    public operator fun ColumnReference<Int>.times(a: Int): Int = get(this) * a
+    public operator fun ColumnReference<Long>.times(a: Long): Long = get(this) * a
+    public operator fun ColumnReference<Double>.times(a: Double): Double = get(this) * a
+    public operator fun ColumnReference<Double>.times(a: Int): Double = get(this) * a
+    public operator fun ColumnReference<Long>.times(a: Int): Long = get(this) * a
+    public operator fun ColumnReference<Double>.times(a: Long): Double = get(this) * a
+
+    public operator fun ColumnReference<Int>.div(a: Int): Int = get(this) / a
+    public operator fun ColumnReference<Long>.div(a: Long): Long = get(this) / a
+    public operator fun ColumnReference<Double>.div(a: Double): Double = get(this) / a
+    public operator fun ColumnReference<Double>.div(a: Int): Double = get(this) / a
+    public operator fun ColumnReference<Long>.div(a: Int): Long = get(this) / a
+    public operator fun ColumnReference<Double>.div(a: Long): Double = get(this) / a
+
+    public companion object {
+        public val empty: AnyRow = DataFrame.empty(1)[0]
+    }
+}
+
+internal val AnyRow.values: List<Any?> get() = values()
+internal val AnyRow.index: Int get() = index()
+internal val <T> DataRow<T>.prev: DataRow<T>? get() = this.prev()
+internal val <T> DataRow<T>.next: DataRow<T>? get() = this.next()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/Aggregatable.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/Aggregatable.kt
new file mode 100644
index 000000000..7cb74c05f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/Aggregatable.kt
@@ -0,0 +1,3 @@
+package org.jetbrains.kotlinx.dataframe.aggregation
+
+public interface Aggregatable<out T>
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateDsl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateDsl.kt
new file mode 100644
index 000000000..ae8388e3d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateDsl.kt
@@ -0,0 +1,25 @@
+package org.jetbrains.kotlinx.dataframe.aggregation
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.ValueWithDefault
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.internal
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import kotlin.reflect.KProperty
+import kotlin.reflect.typeOf
+
+public abstract class AggregateDsl<out T> : DataFrame<T>, ColumnSelectionDsl<T> {
+
+    public inline infix fun <reified R> R.into(name: String): NamedValue = internal().yield(pathOf(name), this, typeOf<R>())
+
+    public inline infix fun <reified R> R.into(column: ColumnAccessor<R>): NamedValue = internal().yield(pathOf(column.name()), this, typeOf<R>())
+
+    public inline infix fun <reified R> R.into(column: KProperty<R>): NamedValue = internal().yield(pathOf(column.columnName), this, typeOf<R>())
+
+    public infix fun <R> R.default(defaultValue: R): Any = when (this) {
+        is NamedValue -> this.also { it.default = defaultValue }
+        else -> ValueWithDefault(this, defaultValue)
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateGroupedDsl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateGroupedDsl.kt
new file mode 100644
index 000000000..43b529522
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateGroupedDsl.kt
@@ -0,0 +1,3 @@
+package org.jetbrains.kotlinx.dataframe.aggregation
+
+public abstract class AggregateGroupedDsl<out T> : AggregateDsl<T>()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/ColumnsForAggregateSelectionDsl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/ColumnsForAggregateSelectionDsl.kt
new file mode 100644
index 000000000..776e6166d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/ColumnsForAggregateSelectionDsl.kt
@@ -0,0 +1,19 @@
+package org.jetbrains.kotlinx.dataframe.aggregation
+
+import org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.ConfiguredAggregateColumn
+
+public interface ColumnsForAggregateSelectionDsl<out T> : ColumnsSelectionDsl<T> {
+
+    public infix fun <C> ColumnSet<C>.default(defaultValue: C): ColumnSet<C> =
+        ConfiguredAggregateColumn.withDefault(this, defaultValue)
+
+    public fun path(vararg names: String): ColumnPath = ColumnPath(names.asList())
+
+    public infix fun <C> ColumnSet<C>.into(name: String): ColumnSet<C> = ConfiguredAggregateColumn.withPath(this, pathOf(name))
+
+    public infix fun <C> ColumnSet<C>.into(path: ColumnPath): ColumnSet<C> = ConfiguredAggregateColumn.withPath(this, path)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/NamedValue.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/NamedValue.kt
new file mode 100644
index 000000000..b1d15f734
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/NamedValue.kt
@@ -0,0 +1,26 @@
+package org.jetbrains.kotlinx.dataframe.aggregation
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.ValueWithDefault
+import org.jetbrains.kotlinx.dataframe.impl.emptyPath
+import kotlin.reflect.KType
+
+@Suppress("DataClassPrivateConstructor")
+public data class NamedValue private constructor(
+    val path: ColumnPath,
+    val value: Any?,
+    val type: KType?,
+    var default: Any?,
+    val guessType: Boolean = false
+) {
+    public companion object {
+        internal fun create(path: ColumnPath, value: Any?, type: KType?, defaultValue: Any?, guessType: Boolean = false): NamedValue = when (value) {
+            is ValueWithDefault<*> -> create(path, value.value, type, value.default, guessType)
+            else -> NamedValue(path, value, type, defaultValue, guessType)
+        }
+        internal fun aggregator(builder: AggregateGroupedDsl<*>): NamedValue =
+            NamedValue(emptyPath(), builder, null, null, false)
+    }
+
+    val name: String get() = path.last()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/aliases.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/aliases.kt
new file mode 100644
index 000000000..07c0d7708
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/aliases.kt
@@ -0,0 +1,10 @@
+package org.jetbrains.kotlinx.dataframe.aggregation
+
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+
+public typealias AggregateBody<T, R> = Selector<AggregateDsl<T>, R>
+
+public typealias AggregateGroupedBody<G, R> = Selector<AggregateGroupedDsl<G>, R>
+
+public typealias ColumnsForAggregateSelector<T, C> = Selector<ColumnsForAggregateSelectionDsl<T>, ColumnSet<C>>
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt
new file mode 100644
index 000000000..de7a58df5
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt
@@ -0,0 +1,175 @@
+package org.jetbrains.kotlinx.dataframe
+
+import org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl
+import org.jetbrains.kotlinx.dataframe.columns.BaseColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+
+/**
+ * [Predicate] is used to reach a [Boolean] result using the given instance of `T` as `it`.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * (it: T) -> Boolean
+ * ```
+ */
+public typealias Predicate<T> = (it: T) -> Boolean
+
+/**
+ * [Selector] is used to express or select any instance of `R` using the given instance of `T` as `this` and `it`.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * T.(it: T) -> R
+ * ```
+ */
+public typealias Selector<T, R> = T.(it: T) -> R
+
+// region selectors
+
+/**
+ * [DataFrameExpression] is used to express or select any instance of `R` using the given instance of [DataFrame]`<T>`
+ * as `this` and `it`.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * DataFrame<T>.(it: DataFrame<T>) -> R
+ * ```
+ */
+public typealias DataFrameExpression<T, R> = Selector<DataFrame<T>, R>
+
+/**
+ * [RowExpression] is used to express or select any instance of `R` using the given instance of [DataRow]`<T>` as
+ * `this` and `it`.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * DataRow<T>.(it: DataRow<T>) -> R
+ * ```
+ */
+public typealias RowExpression<T, R> = Selector<DataRow<T>, R>
+
+/**
+ * [RowValueExpression] is used to express or select any instance of `R` using the given value `it: C` and the given
+ * instance of [DataRow]`<T>` as `this`.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * DataRow<T>.(it: C) -> R
+ * ```
+ */
+public typealias RowValueExpression<T, C, R> = DataRow<T>.(it: C) -> R
+
+/**
+ * [RowColumnExpression] is used to express or select any instance of `R` using the given instances of
+ * [DataRow]`<T>` as `row` and [DataColumn]`<C>` as `col`.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * (row: DataRow<T>, col: DataColumn<C>) -> R
+ * ```
+ */
+public typealias RowColumnExpression<T, C, R> = (row: DataRow<T>, col: DataColumn<C>) -> R
+
+/**
+ * [ColumnExpression] is used to express or select any instance of `R` using the given instance of [DataColumn]`<C>` as
+ * `this` and `it`.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * DataColumn<C>.(it: DataColumn<C>) -> R
+ * ```
+ */
+public typealias ColumnExpression<C, R> = Selector<DataColumn<C>, R>
+
+/**
+ * [ColumnSelector] is used to express or select a single column, represented by [SingleColumn]`<C>`, using the
+ * context of [ColumnsSelectionDsl]`<T>` as `this` and `it`.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * ColumnsSelectionDsl<T>.(it: ColumnsSelectionDsl<T>) -> SingleColumn<C>
+ * ```
+ */
+public typealias ColumnSelector<T, C> = Selector<ColumnsSelectionDsl<T>, SingleColumn<C>>
+
+/**
+ * [ColumnsSelector] is used to express or select multiple columns, represented by [ColumnSet]`<C>`, using the
+ * context of [ColumnsSelectionDsl]`<T>` as `this` and `it`.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * ColumnsSelectionDsl<T>.(it: ColumnsSelectionDsl<T>) -> ColumnSet<C>
+ * ```
+ */
+public typealias ColumnsSelector<T, C> = Selector<ColumnsSelectionDsl<T>, ColumnSet<C>>
+
+// endregion
+
+// region filters
+
+/**
+ * [RowFilter] is used to filter or find rows using the given instance of [DataRow]`<T>` as `this` and `it`.
+ * Return `true` if the row should be included in the result.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * DataRow<T>.(it: DataRow<T>) -> Boolean
+ * ```
+ */
+public typealias RowFilter<T> = RowExpression<T, Boolean>
+
+/**
+ * [ColumnFilter] is used to filter or find columns using the given instance of [ColumnWithPath]`<T>` as `it`.
+ * Return `true` if the column should be included in the result.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * (it: ColumnWithPath<T>) -> Boolean
+ * ```
+ */
+public typealias ColumnFilter<T> = Predicate<ColumnWithPath<T>>
+
+/**
+ * [RowValueFilter] is used to filter or find rows using the given value of `it: C` and the given instance of
+ * [DataRow]`<T>` as `this`.
+ * Return `true` if the row should be included in the result.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * DataRow<T>.(it: C) -> Boolean
+ * ```
+ */
+public typealias RowValueFilter<T, C> = RowValueExpression<T, C, Boolean>
+
+// endregion
+
+// region columns
+
+public typealias Column = ColumnReference<*>
+
+public typealias ColumnGroupReference = ColumnReference<AnyRow>
+public typealias ColumnGroupAccessor<T> = ColumnAccessor<DataRow<T>>
+public typealias AnyColumnGroupAccessor = ColumnGroupAccessor<*>
+
+public typealias DoubleCol = DataColumn<Double?>
+public typealias BooleanCol = DataColumn<Boolean?>
+public typealias IntCol = DataColumn<Int?>
+public typealias NumberCol = DataColumn<Number?>
+public typealias StringCol = DataColumn<String?>
+public typealias AnyCol = DataColumn<*>
+
+// endregion
+
+// region Any*
+
+public typealias AnyFrame = DataFrame<*>
+
+public typealias AnyRow = DataRow<*>
+
+public typealias AnyBaseCol = BaseColumn<*>
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/ColumnName.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/ColumnName.kt
new file mode 100644
index 000000000..11ea05df3
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/ColumnName.kt
@@ -0,0 +1,4 @@
+package org.jetbrains.kotlinx.dataframe.annotations
+
+@Target(AnnotationTarget.PROPERTY)
+public annotation class ColumnName(val name: String)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/DataSchema.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/DataSchema.kt
new file mode 100644
index 000000000..2422c1d33
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/DataSchema.kt
@@ -0,0 +1,4 @@
+package org.jetbrains.kotlinx.dataframe.annotations
+
+@Target(AnnotationTarget.CLASS)
+public annotation class DataSchema(val isOpen: Boolean = true)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/ImportDataSchema.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/ImportDataSchema.kt
new file mode 100644
index 000000000..462fd7b73
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/annotations/ImportDataSchema.kt
@@ -0,0 +1,61 @@
+package org.jetbrains.kotlinx.dataframe.annotations
+
+import org.jetbrains.kotlinx.dataframe.api.JsonPath
+import org.jetbrains.kotlinx.dataframe.api.KeyValueProperty
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.io.JSON
+
+/**
+ * Annotation preprocessing will generate a DataSchema interface from the data at `path`.
+ * Data must be of supported format: CSV, JSON, Apache Arrow, Excel, OpenAPI (Swagger) in YAML/JSON.
+ * Generated data schema has properties inferred from data and a companion object with `read method`.
+ * `read method` is either `readCSV` or `readJson` that returns `DataFrame<name>`
+ *
+ * @param name name of the generated interface
+ * @param path URL or relative path to data.
+ * if path starts with protocol (http, https, ftp), it's considered a URL. Otherwise, it's treated as relative path.
+ * By default, it will be resolved relatively to project dir, i.e. File(projectDir, path)
+ * You can configure it by passing `dataframe.resolutionDir` option to preprocessor, see https://kotlinlang.org/docs/ksp-quickstart.html#pass-options-to-processors
+ * @param visibility visibility of the generated interface.
+ * @param normalizationDelimiters if not empty, split property names by delimiters,
+ * lowercase parts and join to camel case. Set empty list to disable normalization
+ * @param withDefaultPath if `true`, generate `defaultPath` property to the data schema's companion object and make it default argument for a `read method`
+ * @param csvOptions options to parse CSV data. Not used when data is not Csv
+ * @param jsonOptions options to parse JSON data. Not used when data is not Json
+ */
+@Retention(AnnotationRetention.SOURCE)
+@Target(AnnotationTarget.FILE)
+@Repeatable
+public annotation class ImportDataSchema(
+    val name: String,
+    val path: String,
+    val visibility: DataSchemaVisibility = DataSchemaVisibility.IMPLICIT_PUBLIC,
+    val normalizationDelimiters: CharArray = ['\t', ' ', '_'],
+    val withDefaultPath: Boolean = true,
+    val csvOptions: CsvOptions = CsvOptions(','),
+    val jsonOptions: JsonOptions = JsonOptions(),
+)
+
+public enum class DataSchemaVisibility {
+    INTERNAL, IMPLICIT_PUBLIC, EXPLICIT_PUBLIC
+}
+
+public annotation class CsvOptions(
+    public val delimiter: Char,
+)
+
+public annotation class JsonOptions(
+
+    /** Allows the choice of how to handle type clashes when reading a JSON file. */
+    public val typeClashTactic: JSON.TypeClashTactic = JSON.TypeClashTactic.ARRAY_AND_VALUE_COLUMNS,
+
+    /**
+     * List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+     *     will be created.
+     *
+     * Example:
+     * `["""$["store"]["book"][*]["author"]"""]`
+     */
+    public val keyValuePaths: Array<String> = [],
+)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnAccessorApi.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnAccessorApi.kt
new file mode 100644
index 000000000..834fbdd5f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnAccessorApi.kt
@@ -0,0 +1,5 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+
+public inline fun <reified T> ColumnAccessor<T>.nullable(): ColumnAccessor<T?> = cast()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnReferenceApi.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnReferenceApi.kt
new file mode 100644
index 000000000..7f8b85125
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnReferenceApi.kt
@@ -0,0 +1,21 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import kotlin.reflect.typeOf
+
+internal val ColumnReference<*>.name: String get() = name()
+public inline fun <reified T> ColumnReference<T>.withValues(vararg values: T): ValueColumn<T> = withValues(values.asIterable())
+public inline fun <reified T> ColumnReference<T>.withValues(values: Iterable<T>): ValueColumn<T> =
+    DataColumn.createValueColumn(name(), values.asList(), typeOf<T>())
+
+public infix fun <C : Comparable<C>> ColumnReference<C>.gt(value: C): ColumnReference<Boolean> = map { it > value }
+public infix fun <C : Comparable<C>> ColumnReference<C>.lt(value: C): ColumnReference<Boolean> = map { it < value }
+public infix fun <C> ColumnReference<C>.eq(value: C): ColumnReference<Boolean> = map { it == value }
+public infix fun <C> ColumnReference<C>.neq(value: C): ColumnReference<Boolean> = map { it != value }
+
+public fun ColumnReference<String?>.length(): ColumnReference<Int> = map { it?.length ?: 0 }
+public fun ColumnReference<String?>.lowercase(): ColumnReference<String?> = map { it?.lowercase() }
+public fun ColumnReference<String?>.uppercase(): ColumnReference<String?> = map { it?.uppercase() }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
new file mode 100644
index 000000000..43ffc0908
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
@@ -0,0 +1,376 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.ColumnFilter
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.Predicate
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.renamedReference
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnsList
+import org.jetbrains.kotlinx.dataframe.impl.columns.DistinctColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.allColumnsExcept
+import org.jetbrains.kotlinx.dataframe.impl.columns.changePath
+import org.jetbrains.kotlinx.dataframe.impl.columns.createColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.getAt
+import org.jetbrains.kotlinx.dataframe.impl.columns.getChildrenAt
+import org.jetbrains.kotlinx.dataframe.impl.columns.single
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.impl.columns.top
+import org.jetbrains.kotlinx.dataframe.impl.columns.transform
+import org.jetbrains.kotlinx.dataframe.impl.columns.transformSingle
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.dfs
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+/** [Column Selection DSL][ColumnSelectionDsl] */
+internal interface ColumnSelectionDslLink
+
+/** TODO: Put examples and explanations here */
+public interface ColumnSelectionDsl<out T> : ColumnsContainer<T> {
+
+    public operator fun <C> ColumnReference<C>.invoke(): DataColumn<C> = get(this)
+
+    public operator fun <T> ColumnReference<DataRow<T>>.invoke(): ColumnGroup<T> = get(this)
+
+    public operator fun <T> ColumnReference<DataFrame<T>>.invoke(): FrameColumn<T> = get(this)
+
+    public operator fun <C> ColumnPath.invoke(): DataColumn<C> = getColumn(this).cast()
+
+    public operator fun <C> String.invoke(): DataColumn<C> = getColumn(this).cast()
+
+    public operator fun String.get(column: String): ColumnPath = pathOf(this, column)
+}
+
+/** [Columns Selection DSL][ColumnsSelectionDsl] */
+internal interface ColumnsSelectionDslLink
+
+/** TODO: Put examples and explanations here */
+public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColumn<DataRow<T>> {
+
+    public fun <C> ColumnSet<C>.first(condition: ColumnFilter<C>): SingleColumn<C> =
+        transform { listOf(it.first(condition)) }.single()
+
+    public fun <C> ColumnSet<C>.single(condition: ColumnFilter<C>): SingleColumn<C> =
+        transform { listOf(it.single(condition)) }.single()
+
+    public fun SingleColumn<AnyRow>.col(index: Int): SingleColumn<Any?> = getChildrenAt(index).single()
+
+    public operator fun <C> ColumnSet<C>.get(index: Int): SingleColumn<C> = getAt(index)
+
+    public fun ColumnsContainer<*>.group(name: String): ColumnGroupReference = name.toColumnOf()
+
+    public operator fun String.rangeTo(endInclusive: String): ColumnSet<*> = toColumnAccessor().rangeTo(endInclusive.toColumnAccessor())
+
+    public operator fun Column.rangeTo(endInclusive: Column): ColumnSet<*> = object : ColumnSet<Any?> {
+        override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<Any?>> {
+            val startPath = this@rangeTo.resolveSingle(context)!!.path
+            val endPath = endInclusive.resolveSingle(context)!!.path
+            val parentPath = startPath.parent()!!
+            require(parentPath == endPath.parent()) { "Start and end columns have different parent column paths" }
+            val parentCol = context.df.getColumnGroup(parentPath)
+            val startIndex = parentCol.getColumnIndex(startPath.name)
+            val endIndex = parentCol.getColumnIndex(endPath.name)
+            return (startIndex..endIndex).map {
+                parentCol.getColumn(it).let {
+                    it.addPath(parentPath + it.name)
+                }
+            }
+        }
+    }
+
+    public fun none(): ColumnSet<*> = ColumnsList<Any?>(emptyList())
+
+    // region cols
+
+    public fun ColumnSet<*>.cols(predicate: (AnyCol) -> Boolean = { true }): ColumnSet<Any?> = colsInternal(predicate)
+
+    public fun <C> ColumnSet<*>.cols(firstCol: ColumnReference<C>, vararg otherCols: ColumnReference<C>): ColumnSet<C> =
+        (listOf(firstCol) + otherCols).let { refs ->
+            transform { it.flatMap { col -> refs.mapNotNull { col.getChild(it) } } }
+        }
+
+    public fun ColumnSet<*>.cols(firstCol: String, vararg otherCols: String): ColumnSet<Any?> =
+        (listOf(firstCol) + otherCols).let { names ->
+            transform { it.flatMap { col -> names.mapNotNull { col.getChild(it) } } }
+        }
+
+    public fun ColumnSet<*>.cols(vararg indices: Int): ColumnSet<Any?> =
+        transform { it.flatMap { it.children().let { children -> indices.map { children[it] } } } }
+
+    public fun ColumnSet<*>.cols(range: IntRange): ColumnSet<Any?> =
+        transform { it.flatMap { it.children().subList(range.start, range.endInclusive + 1) } }
+
+    // region select
+
+    public fun <C> ColumnSet<DataRow<C>>.select(vararg columns: String): ColumnSet<*> = select { columns.toColumns() }
+
+    public fun <C, R> ColumnSet<DataRow<C>>.select(vararg columns: KProperty<R>): ColumnSet<R> = select { columns.toColumns() }
+
+    public fun <C, R> ColumnSet<DataRow<C>>.select(selector: ColumnsSelector<C, R>): ColumnSet<R> = createColumnSet {
+        this@select.resolve(it).flatMap { group ->
+            group.asColumnGroup().getColumnsWithPaths(selector).map {
+                it.changePath(group.path + it.path)
+            }
+        }
+    }
+
+    // endregion
+
+    // endregion
+
+    // region dfs
+
+    public fun <C> ColumnSet<C>.dfs(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<Any?> = dfsInternal(predicate)
+
+    public fun String.dfs(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> = toColumnAccessor().dfs(predicate)
+
+    // endregion
+
+    // region all
+
+    public fun SingleColumn<*>.all(): ColumnSet<*> = transformSingle { it.children() }
+
+    public fun String.all(): ColumnSet<*> = toColumnAccessor().transformSingle { it.children() }
+
+    // region allDfs
+
+    public fun ColumnSet<*>.allDfs(includeGroups: Boolean = false): ColumnSet<Any?> = if (includeGroups) dfs { true } else dfs { !it.isColumnGroup() }
+
+    public fun String.allDfs(includeGroups: Boolean = false): ColumnSet<Any?> = toColumnAccessor().allDfs(includeGroups)
+
+    // endregion
+
+    // region allAfter
+
+    // excluding current
+    public fun SingleColumn<*>.allAfter(colPath: ColumnPath): ColumnSet<Any?> {
+        var take = false
+        return children {
+            if (take) true
+            else {
+                take = colPath == it.path
+                false
+            }
+        }
+    }
+
+    public fun SingleColumn<*>.allAfter(colName: String): ColumnSet<Any?> = allAfter(pathOf(colName))
+    public fun SingleColumn<*>.allAfter(column: Column): ColumnSet<Any?> = allAfter(column.path())
+
+    // endregion
+
+    // region allSince
+
+    // including current
+    public fun SingleColumn<*>.allSince(colPath: ColumnPath): ColumnSet<Any?> {
+        var take = false
+        return children {
+            if (take) true
+            else {
+                take = colPath == it.path
+                take
+            }
+        }
+    }
+
+    public fun SingleColumn<*>.allSince(colName: String): ColumnSet<Any?> = allSince(pathOf(colName))
+    public fun SingleColumn<*>.allSince(column: Column): ColumnSet<Any?> = allSince(column.path())
+
+    // endregion
+
+    // region allBefore
+
+    // excluding current
+    public fun SingleColumn<*>.allBefore(colPath: ColumnPath): ColumnSet<Any?> {
+        var take = true
+        return children {
+            if (!take) false
+            else {
+                take = colPath != it.path
+                take
+            }
+        }
+    }
+
+    public fun SingleColumn<*>.allBefore(colName: String): ColumnSet<Any?> = allBefore(pathOf(colName))
+    public fun SingleColumn<*>.allBefore(column: Column): ColumnSet<Any?> = allBefore(column.path())
+
+    // endregion
+
+    // region allUntil
+
+    // including current
+    public fun SingleColumn<*>.allUntil(colPath: ColumnPath): ColumnSet<Any?> {
+        var take = true
+        return children {
+            if (!take) false
+            else {
+                take = colPath != it.path
+                true
+            }
+        }
+    }
+
+    public fun SingleColumn<*>.allUntil(colName: String): ColumnSet<Any?> = allUntil(pathOf(colName))
+    public fun SingleColumn<*>.allUntil(column: Column): ColumnSet<Any?> = allUntil(column.path())
+
+    // endregion
+
+    // endregion
+
+    public fun SingleColumn<*>.groups(filter: (ColumnGroup<*>) -> Boolean = { true }): ColumnSet<AnyRow> =
+        children { it.isColumnGroup() && filter(it.asColumnGroup()) } as ColumnSet<AnyRow>
+
+    public fun <C> ColumnSet<C>.children(predicate: (ColumnWithPath<Any?>) -> Boolean = { true }): ColumnSet<Any?> =
+        transform { it.flatMap { it.children().filter { predicate(it) } } }
+
+    public fun ColumnGroupReference.children(): ColumnSet<Any?> = transformSingle { it.children() }
+
+    public operator fun <C> List<DataColumn<C>>.get(range: IntRange): ColumnSet<C> =
+        ColumnsList(subList(range.first, range.last + 1))
+
+    public fun <C> col(property: KProperty<C>): ColumnAccessor<C> = property.toColumnAccessor()
+
+    public operator fun ColumnSet<*>.get(colName: String): ColumnSet<Any?> = transform { it.mapNotNull { it.getChild(colName) } }
+    public operator fun <C> ColumnSet<*>.get(column: ColumnReference<C>): ColumnSet<C> = cols(column)
+
+    public fun SingleColumn<AnyRow>.take(n: Int): ColumnSet<*> = transformSingle { it.children().take(n) }
+    public fun SingleColumn<AnyRow>.takeLast(n: Int): ColumnSet<*> = transformSingle { it.children().takeLast(n) }
+    public fun SingleColumn<AnyRow>.drop(n: Int): ColumnSet<*> = transformSingle { it.children().drop(n) }
+    public fun SingleColumn<AnyRow>.dropLast(n: Int = 1): ColumnSet<*> = transformSingle { it.children().dropLast(n) }
+
+    public fun <C> ColumnSet<C>.drop(n: Int): ColumnSet<C> = transform { it.drop(n) }
+    public fun <C> ColumnSet<C>.take(n: Int): ColumnSet<C> = transform { it.take(n) }
+    public fun <C> ColumnSet<C>.dropLast(n: Int = 1): ColumnSet<C> = transform { it.dropLast(n) }
+    public fun <C> ColumnSet<C>.takeLast(n: Int): ColumnSet<C> = transform { it.takeLast(n) }
+    public fun <C> ColumnSet<C>.top(): ColumnSet<C> = transform { it.top() }
+    public fun <C> ColumnSet<C>.takeWhile(predicate: Predicate<ColumnWithPath<C>>): ColumnSet<C> =
+        transform { it.takeWhile(predicate) }
+
+    public fun <C> ColumnSet<C>.takeLastWhile(predicate: Predicate<ColumnWithPath<C>>): ColumnSet<C> =
+        transform { it.takeLastWhile(predicate) }
+
+    public fun <C> ColumnSet<C>.filter(predicate: Predicate<ColumnWithPath<C>>): ColumnSet<C> =
+        transform { it.filter(predicate) }
+
+    public fun ColumnSet<*>.nameContains(text: CharSequence): ColumnSet<Any?> = cols { it.name.contains(text) }
+    public fun ColumnSet<*>.nameContains(regex: Regex): ColumnSet<Any?> = cols { it.name.contains(regex) }
+    public fun ColumnSet<*>.startsWith(prefix: CharSequence): ColumnSet<Any?> = cols { it.name.startsWith(prefix) }
+    public fun ColumnSet<*>.endsWith(suffix: CharSequence): ColumnSet<Any?> = cols { it.name.endsWith(suffix) }
+
+    public fun <C> ColumnSet<C>.except(vararg other: ColumnSet<*>): ColumnSet<*> = except(other.toColumns())
+    public fun <C> ColumnSet<C>.except(vararg other: String): ColumnSet<*> = except(other.toColumns())
+
+    public fun <C> ColumnSet<C?>.withoutNulls(): ColumnSet<C> = transform { it.filter { !it.hasNulls } } as ColumnSet<C>
+
+    public infix fun <C> ColumnSet<C>.except(other: ColumnSet<*>): ColumnSet<*> =
+        createColumnSet { resolve(it).allColumnsExcept(other.resolve(it)) }
+
+    public infix fun <C> ColumnSet<C>.except(selector: ColumnsSelector<T, *>): ColumnSet<C> =
+        except(selector.toColumns()) as ColumnSet<C>
+
+    public operator fun <C> ColumnsSelector<T, C>.invoke(): ColumnSet<C> =
+        this(this@ColumnsSelectionDsl, this@ColumnsSelectionDsl)
+
+    public infix fun <C> ColumnReference<C>.into(newName: String): ColumnReference<C> = named(newName)
+    public infix fun <C> ColumnReference<C>.into(column: ColumnAccessor<*>): ColumnReference<C> = into(column.name())
+    public infix fun <C> ColumnReference<C>.into(column: KProperty<*>): ColumnReference<C> = named(column.columnName)
+
+    public infix fun String.into(newName: String): ColumnReference<Any?> = toColumnAccessor().into(newName)
+    public infix fun String.into(column: ColumnAccessor<*>): ColumnReference<Any?> = toColumnAccessor().into(column.name())
+    public infix fun String.into(column: KProperty<*>): ColumnReference<Any?> = toColumnAccessor().into(column.columnName)
+
+    public infix fun <C> ColumnReference<C>.named(newName: String): ColumnReference<C> = renamedReference(newName)
+    public infix fun <C> ColumnReference<C>.named(name: KProperty<*>): ColumnReference<C> = named(name.columnName)
+
+    public infix fun String.named(newName: String): ColumnReference<Any?> = toColumnAccessor().named(newName)
+
+    // region and
+
+    // region String
+    public infix fun String.and(other: String): ColumnSet<Any?> = toColumnAccessor() and other.toColumnAccessor()
+    public infix fun <C> String.and(other: ColumnSet<C>): ColumnSet<Any?> = toColumnAccessor() and other
+    public infix fun <C> String.and(other: KProperty<C>): ColumnSet<Any?> = toColumnAccessor() and other
+    public infix fun <C> String.and(other: ColumnsSelector<T, C>): ColumnSet<Any?> = toColumnAccessor() and other()
+
+    // endregion
+
+    // region KProperty
+    public infix fun <C> KProperty<C>.and(other: ColumnSet<C>): ColumnSet<C> = toColumnAccessor() and other
+    public infix fun <C> KProperty<C>.and(other: String): ColumnSet<Any?> = toColumnAccessor() and other
+    public infix fun <C> KProperty<C>.and(other: KProperty<C>): ColumnSet<C> =
+        toColumnAccessor() and other.toColumnAccessor()
+    public infix fun <C> KProperty<C>.and(other: ColumnsSelector<T, C>): ColumnSet<C> = toColumnAccessor() and other()
+
+    // endregion
+
+    // region ColumnSet
+
+    public infix fun <C> ColumnSet<C>.and(other: KProperty<C>): ColumnSet<C> = this and other.toColumnAccessor()
+    public infix fun <C> ColumnSet<C>.and(other: String): ColumnSet<Any?> = this and other.toColumnAccessor()
+    public infix fun <C> ColumnSet<C>.and(other: ColumnSet<C>): ColumnSet<C> = ColumnsList(this, other)
+    public infix fun <C> ColumnSet<C>.and(other: ColumnsSelector<T, C>): ColumnSet<C> = this and other()
+
+    // endregion
+
+    // region ColumnsSelector
+
+    public infix fun <C> ColumnsSelector<T, C>.and(other: KProperty<C>): ColumnSet<C> = this() and other
+    public infix fun <C> ColumnsSelector<T, C>.and(other: String): ColumnSet<Any?> = this() and other
+    public infix fun <C> ColumnsSelector<T, C>.and(other: ColumnSet<C>): ColumnSet<C> = this() and other
+    public infix fun <C> ColumnsSelector<T, C>.and(other: ColumnsSelector<T, C>): ColumnSet<C> = this() and other
+
+    // endregion
+
+    public fun <C> ColumnSet<C>.distinct(): ColumnSet<C> = DistinctColumnSet(this)
+}
+
+public inline fun <T, reified R> ColumnsSelectionDsl<T>.expr(
+    name: String = "",
+    infer: Infer = Infer.Nulls,
+    noinline expression: AddExpression<T, R>
+): DataColumn<R> = mapToColumn(name, infer, expression)
+
+internal fun <T, C> ColumnsSelector<T, C>.filter(predicate: (ColumnWithPath<C>) -> Boolean): ColumnsSelector<T, C> =
+    { this@filter(it, it).filter(predicate) }
+// internal fun Columns<*>.filter(predicate: (AnyCol) -> Boolean) = transform { it.filter { predicate(it.data) } }
+
+internal fun ColumnSet<*>.colsInternal(predicate: (AnyCol) -> Boolean) =
+    transform { it.flatMap { it.children().filter { predicate(it.data) } } }
+
+internal fun ColumnSet<*>.dfsInternal(predicate: (ColumnWithPath<*>) -> Boolean) =
+    transform { it.filter { it.isColumnGroup() }.flatMap { it.children().dfs().filter(predicate) } }
+
+public fun <C> ColumnSet<*>.dfsOf(type: KType, predicate: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<*> =
+    dfsInternal { it.isSubtypeOf(type) && predicate(it.cast()) }
+
+public inline fun <reified C> ColumnSet<*>.dfsOf(noinline filter: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<C> =
+    dfsOf(
+        typeOf<C>(),
+        filter
+    ) as ColumnSet<C>
+
+public fun ColumnSet<*>.colsOf(type: KType): ColumnSet<Any?> = colsOf(type) { true }
+
+public inline fun <reified C> ColumnSet<*>.colsOf(): ColumnSet<C> = colsOf(typeOf<C>()) as ColumnSet<C>
+
+public fun <C> ColumnSet<*>.colsOf(type: KType, filter: (DataColumn<C>) -> Boolean): ColumnSet<C> =
+    colsInternal { it.isSubtypeOf(type) && filter(it.cast()) } as ColumnSet<C>
+
+public inline fun <reified C> ColumnSet<*>.colsOf(noinline filter: (DataColumn<C>) -> Boolean = { true }): ColumnSet<C> =
+    colsOf(
+        typeOf<C>(), filter
+    )
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Cumulative.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Cumulative.kt
new file mode 100644
index 000000000..5da628238
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Cumulative.kt
@@ -0,0 +1 @@
+package org.jetbrains.kotlinx.dataframe.api
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnArithmetics.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnArithmetics.kt
new file mode 100644
index 000000000..7d3531fc3
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnArithmetics.kt
@@ -0,0 +1,111 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.Predicate
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import java.math.BigDecimal
+
+public operator fun DataColumn<Int>.plus(value: Int): DataColumn<Int> = map { it + value }
+public operator fun DataColumn<Int>.minus(value: Int): DataColumn<Int> = map { it - value }
+public operator fun Int.plus(column: DataColumn<Int>): DataColumn<Int> = column.map { this + it }
+public operator fun Int.minus(column: DataColumn<Int>): DataColumn<Int> = column.map { this - it }
+public operator fun DataColumn<Int>.unaryMinus(): DataColumn<Int> = map { -it }
+public operator fun DataColumn<Int>.times(value: Int): DataColumn<Int> = map { it * value }
+public operator fun DataColumn<Int>.div(value: Int): DataColumn<Int> = map { it / value }
+public operator fun Int.div(column: DataColumn<Int>): DataColumn<Int> = column.map { this / it }
+public operator fun AnyCol.plus(str: String): DataColumn<String> = map { it.toString() + str }
+
+public operator fun ColumnReference<Int>.plus(value: Int): ColumnReference<Int> = map { it + value }
+public operator fun ColumnReference<Int>.minus(value: Int): ColumnReference<Int> = map { it - value }
+public operator fun Int.plus(column: ColumnReference<Int>): ColumnReference<Int> = column.map { this + it }
+public operator fun Int.minus(column: ColumnReference<Int>): ColumnReference<Int> = column.map { this - it }
+public operator fun ColumnReference<Int>.unaryMinus(): ColumnReference<Int> = map { -it }
+public operator fun ColumnReference<Int>.times(value: Int): ColumnReference<Int> = map { it * value }
+public operator fun ColumnReference<Int>.div(value: Int): ColumnReference<Int> = map { it / value }
+public operator fun Int.div(column: ColumnReference<Int>): ColumnReference<Int> = column.map { this / it }
+public operator fun ColumnReference<Any?>.plus(str: String): ColumnReference<String> = map { it.toString() + str }
+
+@JvmName("plusIntNullable")
+public operator fun DataColumn<Int?>.plus(value: Int): DataColumn<Int?> = map { it?.plus(value) }
+@JvmName("minusIntNullable")
+public operator fun DataColumn<Int?>.minus(value: Int): DataColumn<Int?> = map { it?.minus(value) }
+@JvmName("plusNullable")
+public operator fun Int.plus(column: DataColumn<Int?>): DataColumn<Int?> = column.map { it?.plus(this) }
+@JvmName("minusNullable")
+public operator fun Int.minus(column: DataColumn<Int?>): DataColumn<Int?> = column.map { it?.let { this - it } }
+@JvmName("unaryMinusIntNullable")
+public operator fun DataColumn<Int?>.unaryMinus(): DataColumn<Int?> = map { it?.unaryMinus() }
+@JvmName("timesIntNullable")
+public operator fun DataColumn<Int?>.times(value: Int): DataColumn<Int?> = map { it?.times(value) }
+@JvmName("divIntNullable")
+public operator fun DataColumn<Int?>.div(value: Int): DataColumn<Int?> = map { it?.div(value) }
+@JvmName("divNullable")
+public operator fun Int.div(column: DataColumn<Int?>): DataColumn<Int?> = column.map { it?.let { this / it } }
+
+@JvmName("plusInt")
+public operator fun DataColumn<Int>.plus(value: Double): DataColumn<Double> = map { it + value }
+@JvmName("minusInt")
+public operator fun DataColumn<Int>.minus(value: Double): DataColumn<Double> = map { it - value }
+@JvmName("doublePlus")
+public operator fun Double.plus(column: DataColumn<Int>): DataColumn<Double> = column.map { this + it }
+@JvmName("doubleMinus")
+public operator fun Double.minus(column: DataColumn<Int>): DataColumn<Double> = column.map { this - it }
+@JvmName("timesInt")
+public operator fun DataColumn<Int>.times(value: Double): DataColumn<Double> = map { it * value }
+@JvmName("divInt")
+public operator fun DataColumn<Int>.div(value: Double): DataColumn<Double> = map { it / value }
+@JvmName("doubleDiv")
+public operator fun Double.div(column: DataColumn<Int>): DataColumn<Double> = column.map { this / it }
+
+@JvmName("plusDouble")
+public operator fun DataColumn<Double>.plus(value: Int): DataColumn<Double> = map { it + value }
+@JvmName("minusDouble")
+public operator fun DataColumn<Double>.minus(value: Int): DataColumn<Double> = map { it - value }
+@JvmName("intPlus")
+public operator fun Int.plus(column: DataColumn<Double>): DataColumn<Double> = column.map { this + it }
+@JvmName("intMinus")
+public operator fun Int.minus(column: DataColumn<Double>): DataColumn<Double> = column.map { this - it }
+@JvmName("timesDouble")
+public operator fun DataColumn<Double>.times(value: Int): DataColumn<Double> = map { it * value }
+@JvmName("divDouble")
+public operator fun DataColumn<Double>.div(value: Int): DataColumn<Double> = map { it / value }
+@JvmName("intDiv")
+public operator fun Int.div(column: DataColumn<Double>): DataColumn<Double> = column.map { this / it }
+
+public operator fun DataColumn<Double>.plus(value: Double): DataColumn<Double> = map { it + value }
+public operator fun DataColumn<Double>.minus(value: Double): DataColumn<Double> = map { it - value }
+public operator fun Double.plus(column: DataColumn<Double>): DataColumn<Double> = column.map { this + it }
+public operator fun Double.minus(column: DataColumn<Double>): DataColumn<Double> = column.map { this - it }
+@JvmName("unaryMinusDouble")
+public operator fun DataColumn<Double>.unaryMinus(): DataColumn<Double> = map { -it }
+public operator fun DataColumn<Double>.times(value: Double): DataColumn<Double> = map { it * value }
+public operator fun DataColumn<Double>.div(value: Double): DataColumn<Double> = map { it / value }
+public operator fun Double.div(column: DataColumn<Double>): DataColumn<Double> = column.map { this / it }
+
+public operator fun DataColumn<Long>.plus(value: Long): DataColumn<Long> = map { it + value }
+public operator fun DataColumn<Long>.minus(value: Long): DataColumn<Long> = map { it - value }
+public operator fun Long.plus(column: DataColumn<Long>): DataColumn<Long> = column.map { this + it }
+public operator fun Long.minus(column: DataColumn<Long>): DataColumn<Long> = column.map { this - it }
+@JvmName("unaryMinusLong")
+public operator fun DataColumn<Long>.unaryMinus(): DataColumn<Long> = map { -it }
+public operator fun DataColumn<Long>.times(value: Long): DataColumn<Long> = map { it * value }
+public operator fun DataColumn<Long>.div(value: Long): DataColumn<Long> = map { it / value }
+public operator fun Long.div(column: DataColumn<Long>): DataColumn<Long> = column.map { this / it }
+
+public operator fun DataColumn<BigDecimal>.plus(value: BigDecimal): DataColumn<BigDecimal> = map { it + value }
+public operator fun DataColumn<BigDecimal>.minus(value: BigDecimal): DataColumn<BigDecimal> = map { it - value }
+public operator fun BigDecimal.plus(column: DataColumn<BigDecimal>): DataColumn<BigDecimal> = column.map { this + it }
+public operator fun BigDecimal.minus(column: DataColumn<BigDecimal>): DataColumn<BigDecimal> = column.map { this - it }
+@JvmName("unaryMinusBigDecimal")
+public operator fun DataColumn<BigDecimal>.unaryMinus(): DataColumn<BigDecimal> = map { -it }
+public operator fun DataColumn<BigDecimal>.times(value: BigDecimal): DataColumn<BigDecimal> = map { it * value }
+public operator fun DataColumn<BigDecimal>.div(value: BigDecimal): DataColumn<BigDecimal> = map { it / value }
+public operator fun BigDecimal.div(column: DataColumn<BigDecimal>): DataColumn<BigDecimal> = column.map { this / it }
+
+public infix fun <T> DataColumn<T>.eq(value: T): DataColumn<Boolean> = isMatching { it == value }
+public infix fun <T> DataColumn<T>.neq(value: T): DataColumn<Boolean> = isMatching { it != value }
+public infix fun <T : Comparable<T>> DataColumn<T>.gt(value: T): DataColumn<Boolean> = isMatching { it > value }
+public infix fun <T : Comparable<T>> DataColumn<T>.lt(value: T): DataColumn<Boolean> = isMatching { it < value }
+
+internal infix fun <T> DataColumn<T>.isMatching(predicate: Predicate<T>): DataColumn<Boolean> = map { predicate(it) }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnType.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnType.kt
new file mode 100644
index 000000000..3e3b2729c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnType.kt
@@ -0,0 +1,27 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.type
+import org.jetbrains.kotlinx.dataframe.typeClass
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+import kotlin.reflect.full.isSubclassOf
+import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.typeOf
+
+public fun AnyCol.isColumnGroup(): Boolean = kind() == ColumnKind.Group
+public fun AnyCol.isFrameColumn(): Boolean = kind() == ColumnKind.Frame
+public fun AnyCol.isValueColumn(): Boolean = kind() == ColumnKind.Value
+
+public fun AnyCol.isSubtypeOf(type: KType): Boolean = this.type.isSubtypeOf(type) && (!this.type.isMarkedNullable || type.isMarkedNullable)
+public inline fun <reified T> AnyCol.isSubtypeOf(): Boolean = isSubtypeOf(typeOf<T>())
+public inline fun <reified T> AnyCol.isType(): Boolean = type() == typeOf<T>()
+public fun AnyCol.isNumber(): Boolean = isSubtypeOf<Number?>()
+public fun AnyCol.isList(): Boolean = typeClass == List::class
+public fun AnyCol.isComparable(): Boolean = isSubtypeOf<Comparable<*>?>()
+
+@PublishedApi
+internal fun AnyCol.isPrimitive(): Boolean = typeClass.isPrimitive()
+
+internal fun KClass<*>.isPrimitive(): Boolean = isSubclassOf(Number::class) || this == String::class || this == Char::class || this == Array::class || isSubclassOf(Collection::class)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataFrameGet.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataFrameGet.kt
new file mode 100644
index 000000000..63588c4e9
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataFrameGet.kt
@@ -0,0 +1,126 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.impl.getColumnPaths
+import org.jetbrains.kotlinx.dataframe.impl.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+import kotlin.reflect.KProperty
+
+public fun <T, C> DataFrame<T>.getColumnsWithPaths(selector: ColumnsSelector<T, C>): List<ColumnWithPath<C>> =
+    getColumnsWithPaths(UnresolvedColumnsPolicy.Fail, selector)
+
+public fun <T, C> DataFrame<T>.getColumnPath(selector: ColumnSelector<T, C>): ColumnPath = getColumnPaths(selector).single()
+public fun <T, C> DataFrame<T>.getColumnPaths(selector: ColumnsSelector<T, C>): List<ColumnPath> =
+    getColumnPaths(UnresolvedColumnsPolicy.Fail, selector)
+
+public fun <T, C> DataFrame<T>.getColumnWithPath(selector: ColumnSelector<T, C>): ColumnWithPath<C> = getColumnsWithPaths(selector).single()
+public fun <T, C> DataFrame<T>.getColumns(selector: ColumnsSelector<T, C>): List<DataColumn<C>> = get(selector)
+public fun <T> DataFrame<T>.getColumns(vararg columns: String): List<AnyCol> = getColumns { columns.toColumns() }
+
+public fun <T> DataFrame<T>.getColumnIndex(col: AnyCol): Int = getColumnIndex(col.name())
+public fun <T> DataFrame<T>.getRows(range: IntRange): DataFrame<T> = if (range == indices()) this else columns().map { col -> col[range] }.toDataFrame().cast()
+public fun <T> DataFrame<T>.getRows(indices: Iterable<Int>): DataFrame<T> = columns().map { col -> col[indices] }.toDataFrame().cast()
+public fun <T> DataFrame<T>.getOrNull(index: Int): DataRow<T>? = if (index < 0 || index >= nrow) null else get(index)
+
+public fun <T> ColumnsContainer<T>.getFrameColumn(columnPath: ColumnPath): FrameColumn<*> = get(columnPath).asAnyFrameColumn()
+public fun <T> ColumnsContainer<T>.getFrameColumn(columnName: String): FrameColumn<*> = get(columnName).asAnyFrameColumn()
+public fun <T> ColumnsContainer<T>.getColumnGroup(columnPath: ColumnPath): ColumnGroup<*> = get(columnPath).asColumnGroup()
+
+// region getColumn
+
+public fun <T> ColumnsContainer<T>.getColumn(name: String): AnyCol = getColumnOrNull(name) ?: throw IllegalArgumentException("Column not found: '$name'")
+
+public fun <T, R> ColumnsContainer<T>.getColumn(column: ColumnReference<DataFrame<R>>): FrameColumn<R> = getColumnOrNull(column)?.asFrameColumn() ?: throw IllegalArgumentException("FrameColumn not found: '$column'")
+
+public fun <T, R> ColumnsContainer<T>.getColumn(column: ColumnReference<DataRow<R>>): ColumnGroup<R> = getColumnOrNull(column)?.asColumnGroup() ?: throw IllegalArgumentException("ColumnGroup not found: '$column'")
+
+public fun <T, R> ColumnsContainer<T>.getColumn(column: ColumnReference<R>): DataColumn<R> = getColumnOrNull(column) ?: throw IllegalArgumentException("Column not found: '$column'")
+
+public fun <T> ColumnsContainer<T>.getColumn(path: ColumnPath): AnyCol = getColumnOrNull(path) ?: throw IllegalArgumentException("Column not found: '$path'")
+
+public fun <T> ColumnsContainer<T>.getColumn(index: Int): AnyCol = getColumnOrNull(index) ?: throw IllegalArgumentException("Column index is out of bounds: $index. Columns count = $ncol")
+
+public fun <T, C> ColumnsContainer<T>.getColumn(selector: ColumnSelector<T, C>): DataColumn<C> = get(selector)
+
+// endregion
+
+// region getColumnGroup
+
+public fun <T> ColumnsContainer<T>.getColumnGroup(index: Int): ColumnGroup<*> = getColumn(index).asColumnGroup()
+
+public fun <T> ColumnsContainer<T>.getColumnGroup(name: String): ColumnGroup<*> = getColumn(name).asColumnGroup()
+
+public fun <T> ColumnsContainer<T>.getColumnGroup(column: KProperty<*>): ColumnGroup<*> = getColumnGroup(column.columnName)
+
+public fun <T, C> ColumnsContainer<T>.getColumnGroup(column: ColumnReference<DataRow<C>>): ColumnGroup<C> = getColumn(column)
+
+public fun <T, C> ColumnsContainer<T>.getColumnGroup(column: ColumnSelector<T, DataRow<C>>): ColumnGroup<C> = get(column).asColumnGroup()
+
+// endregion
+
+// region getColumnGroupOrNull
+
+public fun <T> ColumnsContainer<T>.getColumnGroupOrNull(name: String): ColumnGroup<*>? = getColumnOrNull(name)?.asColumnGroup()
+
+public fun <T> ColumnsContainer<T>.getColumnGroupOrNull(column: KProperty<*>): ColumnGroup<*>? = getColumnGroupOrNull(column.columnName)
+
+// endregion
+
+// region containsColumn
+
+public fun <C> ColumnsContainer<*>.containsColumn(column: ColumnReference<C>): Boolean = getColumnOrNull(column) != null
+public fun ColumnsContainer<*>.containsColumn(column: KProperty<*>): Boolean = containsColumn(column.columnName)
+
+public operator fun ColumnsContainer<*>.contains(column: Column): Boolean = containsColumn(column)
+public operator fun ColumnsContainer<*>.contains(column: KProperty<*>): Boolean = containsColumn(column)
+
+// region rows
+
+public fun <T> DataFrame<T>.rows(): Iterable<DataRow<T>> = object : Iterable<DataRow<T>> {
+    override fun iterator() =
+
+        object : Iterator<DataRow<T>> {
+            var nextRow = 0
+
+            override fun hasNext(): Boolean = nextRow < nrow
+
+            override fun next(): DataRow<T> {
+                require(nextRow < nrow)
+                return get(nextRow++)
+            }
+        }
+}
+
+public fun <T> DataFrame<T>.rowsReversed(): Iterable<DataRow<T>> = object : Iterable<DataRow<T>> {
+    override fun iterator() =
+
+        object : Iterator<DataRow<T>> {
+            var nextRow = nrow - 1
+
+            override fun hasNext(): Boolean = nextRow >= 0
+
+            override fun next(): DataRow<T> {
+                require(nextRow >= 0)
+                return get(nextRow--)
+            }
+        }
+}
+
+// endregion
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
new file mode 100644
index 000000000..9cdc67e72
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataRowApi.kt
@@ -0,0 +1,119 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.owner
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.indices
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+import kotlin.experimental.ExperimentalTypeInference
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+
+public fun AnyRow.isEmpty(): Boolean = owner.columns().all { it[index] == null }
+public fun AnyRow.isNotEmpty(): Boolean = !isEmpty()
+
+public inline fun <reified R> AnyRow.valuesOf(): List<R> = values().filterIsInstance<R>()
+
+// region DataSchema
+@DataSchema
+public data class NameValuePair<V>(val name: String, val value: V)
+
+// Without these overloads row.transpose().name or row.map { name } won't resolve
+public val ColumnsContainer<NameValuePair<*>>.name: DataColumn<String> @JvmName("NameValuePairAny_name") get() = this["name"] as DataColumn<String>
+public val DataRow<NameValuePair<*>>.name: String @JvmName("NameValuePairAny_name") get() = this["name"] as String
+
+public val ColumnsContainer<NameValuePair<*>>.value: DataColumn<*> @JvmName("NameValuePairAny_value") get() = this["value"]
+public val DataRow<NameValuePair<*>>.value: Any? @JvmName("NameValuePairAny_value") get() = this["value"]
+
+// endregion
+
+public inline fun <reified R> AnyRow.namedValuesOf(): List<NameValuePair<R>> =
+    values().zip(columnNames()).filter { it.first is R }.map { NameValuePair(it.second, it.first as R) }
+
+public fun AnyRow.namedValues(): List<NameValuePair<Any?>> =
+    values().zip(columnNames()) { value, name -> NameValuePair(name, value) }
+
+// region getValue
+
+public fun <T> AnyRow.getValue(columnName: String): T = get(columnName) as T
+public fun <T> AnyRow.getValue(column: ColumnReference<T>): T = get(column)
+public fun <T> AnyRow.getValue(column: KProperty<T>): T = get(column)
+
+public fun <T> AnyRow.getValueOrNull(columnName: String): T? = getOrNull(columnName) as T?
+public fun <T> AnyRow.getValueOrNull(column: KProperty<T>): T? = getValueOrNull<T>(column.columnName)
+
+// endregion
+
+// region contains
+
+public fun AnyRow.containsKey(columnName: String): Boolean = owner.containsColumn(columnName)
+public fun AnyRow.containsKey(column: Column): Boolean = owner.containsColumn(column)
+public fun AnyRow.containsKey(column: KProperty<*>): Boolean = owner.containsColumn(column)
+
+public operator fun AnyRow.contains(column: Column): Boolean = containsKey(column)
+public operator fun AnyRow.contains(column: KProperty<*>): Boolean = containsKey(column)
+
+// endregion
+
+@OptIn(ExperimentalTypeInference::class)
+@OverloadResolutionByLambdaReturnType
+public fun <T> DataRow<T>.diff(expression: RowExpression<T, Double>): Double? =
+    prev()?.let { p -> expression(this, this) - expression(p, p) }
+
+public fun <T> DataRow<T>.diff(expression: RowExpression<T, Int>): Int? =
+    prev()?.let { p -> expression(this, this) - expression(p, p) }
+
+public fun <T> DataRow<T>.diff(expression: RowExpression<T, Long>): Long? =
+    prev()?.let { p -> expression(this, this) - expression(p, p) }
+
+public fun <T> DataRow<T>.diff(expression: RowExpression<T, Float>): Float? =
+    prev()?.let { p -> expression(this, this) - expression(p, p) }
+
+public fun AnyRow.columnsCount(): Int = df().ncol
+public fun AnyRow.columnNames(): List<String> = df().columnNames()
+public fun AnyRow.columnTypes(): List<KType> = df().columnTypes()
+
+public fun <T> DataRow<T>.getRow(index: Int): DataRow<T> = getRowOrNull(index)!!
+
+public fun <T> DataRow<T>.getRows(indices: Iterable<Int>): DataFrame<T> = df().getRows(indices)
+public fun <T> DataRow<T>.getRows(indices: IntRange): DataFrame<T> = df().getRows(indices)
+
+public fun <T> DataRow<T>.getRowOrNull(index: Int): DataRow<T>? {
+    val df = df()
+    return if (index >= 0 && index < df.nrow) df[index] else null
+}
+
+public fun <T> DataRow<T>.prev(): DataRow<T>? {
+    val index = index()
+    return if (index > 0) df()[index - 1] else null
+}
+
+public fun <T> DataRow<T>.next(): DataRow<T>? {
+    val index = index()
+    val df = df()
+    return if (index < df.nrow - 1) df[index + 1] else null
+}
+
+public fun <T> DataRow<T>.relative(relativeIndices: Iterable<Int>): DataFrame<T> =
+    getRows(relativeIndices.mapNotNull { (index + it).let { if (it >= 0 && it < df().rowsCount()) it else null } })
+
+public fun <T> DataRow<T>.relative(relativeIndices: IntRange): DataFrame<T> =
+    getRows((relativeIndices.first + index).coerceIn(df().indices)..(relativeIndices.last + index).coerceIn(df().indices))
+
+public fun <T> DataRow<T>.movingAverage(k: Int, expression: RowExpression<T, Number>): Double {
+    var count = 0
+    return backwardIterable().take(k).sumOf {
+        count++
+        expression(it).toDouble()
+    } / count
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Defaults.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Defaults.kt
new file mode 100644
index 000000000..646954aa4
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Defaults.kt
@@ -0,0 +1,7 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+@PublishedApi
+internal val skipNA_default: Boolean = false
+
+@PublishedApi
+internal val ddof_default: Int = 1
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
new file mode 100644
index 000000000..58a719da9
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/JsonPath.kt
@@ -0,0 +1,69 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.intellij.lang.annotations.Language
+import java.io.Serializable
+
+/**
+ * Simplistic JSON path implementation.
+ * Supports just keys (in bracket notation), double quotes, arrays and wildcards.
+ *
+ * Examples:
+ * `$["store"]["book"][*]["author"]`
+ *
+ * `$[1]` will match `$[*]`
+ */
+@JvmInline
+public value class JsonPath(@Language("jsonpath") public val path: String = "$") : Serializable {
+
+    public fun append(name: String): JsonPath = JsonPath("$path[\"$name\"]")
+
+    public fun appendWildcard(): JsonPath = JsonPath("$path[*]")
+
+    public fun appendArrayWithIndex(index: Int): JsonPath = JsonPath("$path[$index]")
+
+    public fun appendArrayWithWildcard(): JsonPath = JsonPath("$path[*]")
+
+    public fun replaceLastWildcardWithIndex(index: Int): 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("")
+        }
+    )
+
+    public fun prepend(name: String): JsonPath = JsonPath(
+        "\$[\"$name\"]" + path.removePrefix("$")
+    )
+
+    public fun prependWildcard(): JsonPath = JsonPath(
+        "\$[*]" + path.removePrefix("$")
+    )
+
+    public fun prependArrayWithIndex(index: Int): JsonPath = JsonPath(
+        "\$[$index]" + path.removePrefix("$")
+    )
+
+    public fun prependArrayWithWildcard(): JsonPath = JsonPath(
+        "\$[*]" + path.removePrefix("$")
+    )
+
+    public fun erasedIndices(): JsonPath = JsonPath(
+        path.replace("""\[[0-9]+]""".toRegex(), "[*]")
+    )
+
+    private fun splitPath() = path.split("[", "]").filter { it.isNotBlank() }
+
+    public fun matches(other: JsonPath): Boolean =
+        path == other.path ||
+            run {
+                val path = splitPath()
+                val otherPath = other.splitPath()
+
+                if (path.size != otherPath.size) false
+                else path.zip(otherPath).all { (p, o) ->
+                    p == o || p == "*" || o == "*"
+                }
+            }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/KeyValueProperty.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/KeyValueProperty.kt
new file mode 100644
index 000000000..56a52c2f3
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/KeyValueProperty.kt
@@ -0,0 +1,15 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.annotations.ColumnName
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+
+/** A [DataSchema] interface / class can implement this if it represents a map-like data schema (so key: value). */
+@DataSchema
+public interface KeyValueProperty<T> {
+    // needs to be explicitly overridden in @DataSchema interface, otherwise extension functions won't generate (TODO)
+    public val key: String
+
+    // needs to be explicitly overridden in @DataSchema interface, otherwise type will be read as `T` and extensions won't generate (TODO)
+    @ColumnName("value")
+    public val `value`: T
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Misc.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Misc.kt
new file mode 100644
index 000000000..5da628238
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Misc.kt
@@ -0,0 +1 @@
+package org.jetbrains.kotlinx.dataframe.api
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
new file mode 100644
index 000000000..6c04bc01a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -0,0 +1,638 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.Update.UpdateOperationArg
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.documentation.*
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.kind
+import org.jetbrains.kotlinx.dataframe.typeClass
+import kotlin.reflect.KProperty
+
+// region fillNulls
+
+/**
+ * ## The Fill Nulls Operation
+ * 
+ * Replaces `null` values with given value or expression.
+ * Specific case of [update].
+ * 
+ * Check out the [`fillNulls` Operation Usage][Usage].
+ * 
+ * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls)
+ */
+internal interface FillNulls {
+
+    /**
+     * ## [fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls] Operation Usage
+     * 
+     * [fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls] `{ `[columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]` }`
+     * 
+     * - `[.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { `[rowValueCondition][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows.RowValueCondition.WithExample]` } ]`
+     * 
+     * - `[.`[at][org.jetbrains.kotlinx.dataframe.api.Update.at]` (`[rowIndices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]`) ]`
+     * 
+     * - `.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
+     *   | .`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
+     *   | .`[perCol][org.jetbrains.kotlinx.dataframe.api.Update.perCol]` { `[colExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpression.WithExample]` }
+     *   | .`[perRowCol][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol]` { `[rowColExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.RowColumnExpression.WithExample]` }
+     *   | .`[withValue][org.jetbrains.kotlinx.dataframe.api.Update.withValue]`(value)
+     *   | .`[withNull][org.jetbrains.kotlinx.dataframe.api.Update.withNull]`()
+     *   | .`[withZero][org.jetbrains.kotlinx.dataframe.api.Update.withZero]`()
+     *   | .`[asFrame][org.jetbrains.kotlinx.dataframe.api.Update.asFrame]` { `[dataFrameExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.DataFrameExpression.WithExample]` }`
+     */
+    interface Usage
+}
+
+
+private interface SetFillNullsOperationArg
+
+/**
+ * ## The Fill Nulls Operation
+ * 
+ * Replaces `null` values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ * 
+ * Check out the [`fillNulls` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNulls.Usage].
+ * 
+ * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill Nulls Overload
+ */
+private interface CommonFillNullsFunctionDoc
+
+/**
+ * ## The Fill Nulls Operation
+ * 
+ * Replaces `null` values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ * 
+ * Check out the [`fillNulls` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNulls.Usage].
+ * 
+ * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill Nulls Overload
+ * Select or express columns using the Column(s) Selection DSL.
+ * (Any [Access Api][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ * 
+ * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
+ * 
+ * For example:
+ * 
+ * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]` { length `[and][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.and]` age }`
+ * 
+ * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ * 
+ * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<Double>() }`
+ *  
+ * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNulls(columns: ColumnsSelector<T, C?>): Update<T, C?> =
+    update(columns).where { it == null }
+
+/**
+ * ## The Fill Nulls Operation
+ * 
+ * Replaces `null` values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ * 
+ * Check out the [`fillNulls` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNulls.Usage].
+ * 
+ * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill Nulls Overload
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ * 
+ * For example:
+ * 
+ * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]`("length", "age")`
+ *  
+ * @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] belonging to this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T> DataFrame<T>.fillNulls(vararg columns: String): Update<T, Any?> =
+    fillNulls { columns.toColumns() }
+
+/**
+ * ## The Fill Nulls Operation
+ * 
+ * Replaces `null` values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ * 
+ * Check out the [`fillNulls` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNulls.Usage].
+ * 
+ * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill Nulls Overload
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ * 
+ * For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ * 
+ * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]`(Person::length, Person::age)`
+ *  
+ * @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] corresponding to columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNulls(vararg columns: KProperty<C>): Update<T, C?> =
+    fillNulls { columns.toColumns() }
+
+/**
+ * ## The Fill Nulls Operation
+ * 
+ * Replaces `null` values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ * 
+ * Check out the [`fillNulls` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNulls.Usage].
+ * 
+ * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill Nulls Overload
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ * 
+ * For example:
+ * 
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
+ * 
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
+ * 
+ * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]`(length, age)`
+ *  
+ * @param columns The [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample] of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNulls(vararg columns: ColumnReference<C>): Update<T, C?> =
+    fillNulls { columns.toColumns() }
+
+/**
+ * TODO this will be deprecated
+ */
+public fun <T, C> DataFrame<T>.fillNulls(columns: Iterable<ColumnReference<C>>): Update<T, C?> =
+    fillNulls { columns.toColumnSet() }
+
+// endregion
+
+/**
+ * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
+ * in cases where a mathematical operation is undefined, such as dividing by zero.
+ * In Dataframe we have helper functions to check for `NaNs`, such as [Any?.isNaN][Any.isNaN] and
+ * [column.canHaveNaN][DataColumn.canHaveNaN].
+ * You can also use [fillNaNs][fillNaNs] to replace `NaNs` in certain columns with a given value or expression.
+ *
+ * @see NA
+ */
+internal interface NaN
+
+/**
+ * `NA` in Dataframe can be seen as "[NaN] or `null`".
+ *
+ * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
+ * in cases where a mathematical operation is undefined, such as dividing by zero.
+ *
+ * In Dataframe we have helper functions to check for `NAs`, such as [Any?.isNA][Any.isNA] and
+ * [column.canHaveNA][DataColumn.canHaveNA].
+ * You can also use [fillNA][fillNA] to replace `NAs` in certain columns with a given value or expression.
+ * @see NaN
+ */
+internal interface NA
+
+internal inline val Any?.isNaN: Boolean get() = (this is Double && isNaN()) || (this is Float && isNaN())
+
+internal inline val Any?.isNA: Boolean
+    get() = when (this) {
+        null -> true
+        is Double -> isNaN()
+        is Float -> isNaN()
+        is AnyRow -> allNA()
+        is AnyFrame -> isEmpty()
+        else -> false
+    }
+
+internal inline val AnyCol.canHaveNaN: Boolean get() = typeClass.let { it == Double::class || it == Float::class }
+
+internal inline val AnyCol.canHaveNA: Boolean get() = hasNulls() || canHaveNaN || kind != ColumnKind.Value
+
+internal inline val Double?.isNA: Boolean get() = this == null || this.isNaN()
+
+internal inline val Float?.isNA: Boolean get() = this == null || this.isNaN()
+
+// region fillNaNs
+
+/**
+ * ## The Fill NaNs Operation
+ * 
+ * Replaces [`NaN`][NaN] values with given value or expression.
+ * Specific case of [update].
+ * 
+ * Check out the [`fillNaNs` Operation Usage][Usage].
+ * 
+ * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans)
+ */
+internal interface FillNaNs {
+
+    /**
+     * ## [fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs] Operation Usage
+     * 
+     * [fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs] `{ `[columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]` }`
+     * 
+     * - `[.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { `[rowValueCondition][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows.RowValueCondition.WithExample]` } ]`
+     * 
+     * - `[.`[at][org.jetbrains.kotlinx.dataframe.api.Update.at]` (`[rowIndices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]`) ]`
+     * 
+     * - `.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
+     *   | .`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
+     *   | .`[perCol][org.jetbrains.kotlinx.dataframe.api.Update.perCol]` { `[colExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpression.WithExample]` }
+     *   | .`[perRowCol][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol]` { `[rowColExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.RowColumnExpression.WithExample]` }
+     *   | .`[withValue][org.jetbrains.kotlinx.dataframe.api.Update.withValue]`(value)
+     *   | .`[withNull][org.jetbrains.kotlinx.dataframe.api.Update.withNull]`()
+     *   | .`[withZero][org.jetbrains.kotlinx.dataframe.api.Update.withZero]`()
+     *   | .`[asFrame][org.jetbrains.kotlinx.dataframe.api.Update.asFrame]` { `[dataFrameExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.DataFrameExpression.WithExample]` }`
+     */
+    interface Usage
+}
+
+
+internal interface SetFillNaNsOperationArg
+
+/**
+ * ## The Fill NaNs Operation
+ * 
+ * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.api.NaN] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ * 
+ * Check out the [`fillNaNs` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Usage].
+ * 
+ * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill NaNs Overload
+ */
+private interface CommonFillNaNsFunctionDoc
+
+/**
+ * ## The Fill NaNs Operation
+ * 
+ * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.api.NaN] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ * 
+ * Check out the [`fillNaNs` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Usage].
+ * 
+ * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill NaNs Overload
+ * Select or express columns using the Column(s) Selection DSL.
+ * (Any [Access Api][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ * 
+ * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
+ * 
+ * For example:
+ * 
+ * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]` { length `[and][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.and]` age }`
+ * 
+ * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ * 
+ * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<Double>() }`
+ *  
+ * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNaNs(columns: ColumnsSelector<T, C>): Update<T, C> =
+    update(columns).where { it.isNaN }
+
+/**
+ * ## The Fill NaNs Operation
+ * 
+ * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.api.NaN] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ * 
+ * Check out the [`fillNaNs` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Usage].
+ * 
+ * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill NaNs Overload
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ * 
+ * For example:
+ * 
+ * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]`("length", "age")`
+ *  
+ * @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] belonging to this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T> DataFrame<T>.fillNaNs(vararg columns: String): Update<T, Any?> =
+    fillNaNs { columns.toColumns() }
+
+/**
+ * ## The Fill NaNs Operation
+ * 
+ * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.api.NaN] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ * 
+ * Check out the [`fillNaNs` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Usage].
+ * 
+ * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill NaNs Overload
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ * 
+ * For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ * 
+ * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]`(Person::length, Person::age)`
+ *  
+ * @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] corresponding to columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: KProperty<C>): Update<T, C> =
+    fillNaNs { columns.toColumns() }
+
+/**
+ * ## The Fill NaNs Operation
+ * 
+ * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.api.NaN] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ * 
+ * Check out the [`fillNaNs` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Usage].
+ * 
+ * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill NaNs Overload
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ * 
+ * For example:
+ * 
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
+ * 
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
+ * 
+ * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]`(length, age)`
+ *  
+ * @param columns The [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample] of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: ColumnReference<C>): Update<T, C> =
+    fillNaNs { columns.toColumns() }
+
+/**
+ * TODO this will be deprecated
+ */
+public fun <T, C> DataFrame<T>.fillNaNs(columns: Iterable<ColumnReference<C>>): Update<T, C> =
+    fillNaNs { columns.toColumnSet() }
+
+// endregion
+
+// region fillNA
+
+/**
+ * ## The Fill NA Operation
+ * 
+ * Replaces [`NA`][NA] values with given value or expression.
+ * Specific case of [update].
+ * 
+ * Check out the [`fillNA` Operation Usage][Usage].
+ * 
+ * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna)
+ */
+internal interface FillNA {
+
+    /**
+     * ## [fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA] Operation Usage
+     * 
+     * [fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA] `{ `[columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]` }`
+     * 
+     * - `[.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { `[rowValueCondition][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows.RowValueCondition.WithExample]` } ]`
+     * 
+     * - `[.`[at][org.jetbrains.kotlinx.dataframe.api.Update.at]` (`[rowIndices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]`) ]`
+     * 
+     * - `.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
+     *   | .`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
+     *   | .`[perCol][org.jetbrains.kotlinx.dataframe.api.Update.perCol]` { `[colExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpression.WithExample]` }
+     *   | .`[perRowCol][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol]` { `[rowColExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.RowColumnExpression.WithExample]` }
+     *   | .`[withValue][org.jetbrains.kotlinx.dataframe.api.Update.withValue]`(value)
+     *   | .`[withNull][org.jetbrains.kotlinx.dataframe.api.Update.withNull]`()
+     *   | .`[withZero][org.jetbrains.kotlinx.dataframe.api.Update.withZero]`()
+     *   | .`[asFrame][org.jetbrains.kotlinx.dataframe.api.Update.asFrame]` { `[dataFrameExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.DataFrameExpression.WithExample]` }`
+     */
+    interface Usage
+}
+
+
+internal interface SetFillNAOperationArg
+
+/**
+ * ## The Fill NA Operation
+ * 
+ * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ * 
+ * Check out the [`fillNA` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNA.Usage].
+ * 
+ * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill NA Overload
+ */
+private interface CommonFillNAFunctionDoc
+
+/**
+ * ## The Fill NA Operation
+ * 
+ * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ * 
+ * Check out the [`fillNA` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNA.Usage].
+ * 
+ * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill NA Overload
+ * Select or express columns using the Column(s) Selection DSL.
+ * (Any [Access Api][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ * 
+ * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
+ * 
+ * For example:
+ * 
+ * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]` { length `[and][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.and]` age }`
+ * 
+ * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ * 
+ * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<Double>() }`
+ *  
+ * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNA(columns: ColumnsSelector<T, C?>): Update<T, C?> =
+    update(columns).where { it.isNA }
+
+/**
+ * ## The Fill NA Operation
+ * 
+ * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ * 
+ * Check out the [`fillNA` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNA.Usage].
+ * 
+ * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill NA Overload
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ * 
+ * For example:
+ * 
+ * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]`("length", "age")`
+ *  
+ * @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] belonging to this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T> DataFrame<T>.fillNA(vararg columns: String): Update<T, Any?> =
+    fillNA { columns.toColumns() }
+
+/**
+ * ## The Fill NA Operation
+ * 
+ * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ * 
+ * Check out the [`fillNA` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNA.Usage].
+ * 
+ * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill NA Overload
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ * 
+ * For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ * 
+ * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]`(Person::length, Person::age)`
+ *  
+ * @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] corresponding to columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNA(vararg columns: KProperty<C>): Update<T, C?> =
+    fillNA { columns.toColumns() }
+
+/**
+ * ## The Fill NA Operation
+ * 
+ * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ * 
+ * Check out the [`fillNA` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNA.Usage].
+ * 
+ * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill NA Overload
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ * 
+ * For example:
+ * 
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
+ * 
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
+ * 
+ * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]`(length, age)`
+ *  
+ * @param columns The [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample] of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNA(vararg columns: ColumnReference<C>): Update<T, C?> =
+    fillNA { columns.toColumns() }
+
+/**
+ * TODO this will be deprecated
+ */
+public fun <T, C> DataFrame<T>.fillNA(columns: Iterable<ColumnReference<C>>): Update<T, C?> =
+    fillNA { columns.toColumnSet() }
+
+// endregion
+
+// region dropNulls
+
+public fun <T> DataFrame<T>.dropNulls(whereAllNull: Boolean = false, selector: ColumnsSelector<T, *>): DataFrame<T> {
+    val columns = this[selector]
+    return if (whereAllNull) drop { row -> columns.all { col -> col[row] == null } }
+    else drop { row -> columns.any { col -> col[row] == null } }
+}
+
+public fun <T> DataFrame<T>.dropNulls(whereAllNull: Boolean = false): DataFrame<T> =
+    dropNulls(whereAllNull) { all() }
+
+public fun <T> DataFrame<T>.dropNulls(vararg columns: KProperty<*>, whereAllNull: Boolean = false): DataFrame<T> =
+    dropNulls(whereAllNull) { columns.toColumns() }
+
+public fun <T> DataFrame<T>.dropNulls(vararg columns: String, whereAllNull: Boolean = false): DataFrame<T> =
+    dropNulls(whereAllNull) { columns.toColumns() }
+
+public fun <T> DataFrame<T>.dropNulls(vararg columns: Column, whereAllNull: Boolean = false): DataFrame<T> =
+    dropNulls(whereAllNull) { columns.toColumns() }
+
+public fun <T> DataFrame<T>.dropNulls(
+    columns: Iterable<Column>,
+    whereAllNull: Boolean = false
+): DataFrame<T> =
+    dropNulls(whereAllNull) { columns.toColumnSet() }
+
+public fun <T> DataColumn<T?>.dropNulls(): DataColumn<T> =
+    (if (!hasNulls()) this else filter { it != null }) as DataColumn<T>
+
+// endregion
+
+// region dropNA
+
+public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false, selector: ColumnsSelector<T, *>): DataFrame<T> {
+    val columns = this[selector]
+
+    return if (whereAllNA) drop { columns.all { this[it].isNA } }
+    else drop { columns.any { this[it].isNA } }
+}
+
+public fun <T> DataFrame<T>.dropNA(vararg columns: KProperty<*>, whereAllNA: Boolean = false): DataFrame<T> =
+    dropNA(whereAllNA) { columns.toColumns() }
+
+public fun <T> DataFrame<T>.dropNA(vararg columns: String, whereAllNA: Boolean = false): DataFrame<T> =
+    dropNA(whereAllNA) { columns.toColumns() }
+
+public fun <T> DataFrame<T>.dropNA(vararg columns: Column, whereAllNA: Boolean = false): DataFrame<T> =
+    dropNA(whereAllNA) { columns.toColumns() }
+
+public fun <T> DataFrame<T>.dropNA(columns: Iterable<Column>, whereAllNA: Boolean = false): DataFrame<T> =
+    dropNA(whereAllNA) { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false): DataFrame<T> =
+    dropNA(whereAllNA) { all() }
+
+public fun <T> DataColumn<T?>.dropNA(): DataColumn<T> =
+    when (typeClass) {
+        Double::class, Float::class -> filter { !it.isNA }.cast()
+        else -> (if (!hasNulls()) this else filter { it != null }) as DataColumn<T>
+    }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/TypeConversions.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/TypeConversions.kt
new file mode 100644
index 000000000..7ad2921da
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/TypeConversions.kt
@@ -0,0 +1,312 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnGroupAccessor
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.impl.GroupByImpl
+import org.jetbrains.kotlinx.dataframe.impl.anyNull
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnAccessorImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.asValues
+import org.jetbrains.kotlinx.dataframe.impl.columns.forceResolve
+import org.jetbrains.kotlinx.dataframe.impl.owner
+import org.jetbrains.kotlinx.dataframe.index
+import kotlin.reflect.KProperty
+import kotlin.reflect.typeOf
+
+// region String
+
+public fun String.toColumnAccessor(): ColumnAccessor<Any?> = ColumnAccessorImpl(this)
+
+public fun <T> String.toColumnOf(): ColumnAccessor<T> = ColumnAccessorImpl(this)
+
+// endregion
+
+// region ColumnPath
+
+public fun <T> ColumnPath.toColumnOf(): ColumnAccessor<T> = ColumnAccessorImpl(this)
+
+public fun ColumnPath.toColumnAccessor(): ColumnAccessor<Any?> = ColumnAccessorImpl(this)
+
+public fun ColumnPath.toColumnGroupAccessor(): ColumnAccessor<AnyRow> = ColumnAccessorImpl(this)
+public fun ColumnPath.toFrameColumnAccessor(): ColumnAccessor<AnyFrame> = ColumnAccessorImpl(this)
+
+// endregion
+
+// region ColumnReference
+
+public fun <T> ColumnReference<T>.toColumnAccessor(): ColumnAccessor<T> = when (this) {
+    is ColumnAccessor<T> -> this
+    else -> ColumnAccessorImpl(path())
+}
+
+// endregion
+
+// region KProperty
+
+public fun <T> KProperty<T>.toColumnAccessor(): ColumnAccessor<T> = ColumnAccessorImpl<T>(columnName)
+
+// endregion
+
+// region DataColumn
+
+public fun AnyBaseCol.toDataFrame(): AnyFrame = dataFrameOf(listOf(this))
+
+@JvmName("asNumberAnyNullable")
+public fun DataColumn<Any?>.asNumbers(): ValueColumn<Number?> {
+    require(isNumber())
+    return this.asValues()
+}
+
+@JvmName("asNumberAny")
+public fun DataColumn<Any>.asNumbers(): ValueColumn<Number> {
+    require(isNumber())
+    return this as ValueColumn<Number>
+}
+
+public fun <T> DataColumn<T>.asComparable(): DataColumn<Comparable<T>> {
+    require(isComparable())
+    return this as DataColumn<Comparable<T>>
+}
+
+public fun <T> ColumnReference<T?>.castToNotNullable(): ColumnReference<T> = cast()
+
+public fun <T> DataColumn<T?>.castToNotNullable(): DataColumn<T> {
+    require(!hasNulls()) { "Column `$name` has nulls" }
+    return this as DataColumn<T>
+}
+
+public fun <T> DataColumn<T>.castToNullable(): DataColumn<T?> = cast()
+
+public fun <T> ColumnReference<T>.castToNullable(): ColumnReference<T?> = cast()
+
+// region to array
+
+public inline fun <reified T> DataColumn<T>.toTypedArray(): Array<T> = toList().toTypedArray()
+
+public fun DataColumn<Number>.toFloatArray(): FloatArray = convertToFloat().toList().toFloatArray()
+
+public fun DataColumn<Number>.toDoubleArray(): DoubleArray = convertToDouble().toList().toDoubleArray()
+
+public fun DataColumn<Number>.toIntArray(): IntArray = convertToInt().toList().toIntArray()
+
+public fun DataColumn<Number>.toLongArray(): LongArray = convertToLong().toList().toLongArray()
+
+public fun DataColumn<Number>.toShortArray(): ShortArray = convertTo<Short>().toList().toShortArray()
+
+public fun DataColumn<Number>.toByteArray(): ByteArray = convertTo<Byte>().toList().toByteArray()
+
+// endregion
+
+public fun AnyCol.asColumnGroup(): ColumnGroup<*> = this as ColumnGroup<*>
+
+public fun <T> DataColumn<DataFrame<T>>.asFrameColumn(): FrameColumn<T> = (this as AnyCol).asAnyFrameColumn().castFrameColumn()
+
+@JvmName("asGroupedT")
+public fun <T> DataColumn<DataRow<T>>.asColumnGroup(): ColumnGroup<T> = (this as AnyCol).asColumnGroup().cast()
+
+public fun <T> DataColumn<DataRow<T>>.asDataFrame(): DataFrame<T> = asColumnGroup()
+
+// endregion
+
+// region ColumnGroup
+
+public fun <T> ColumnGroup<T>.asDataColumn(): DataColumn<DataRow<T>> = this as DataColumn<DataRow<T>>
+
+public fun <T> ColumnGroup<T>.asDataFrame(): DataFrame<T> = this
+
+// endregion
+
+// region FrameColumn
+
+public fun <T> FrameColumn<T>.asDataColumn(): DataColumn<DataFrame<T>?> = this
+
+public fun <T> FrameColumn<T>.toValueColumn(): ValueColumn<DataFrame<T>?> =
+    DataColumn.createValueColumn(name, toList(), type())
+
+// endregion
+
+// region ColumnSet
+
+@JvmName("asNumbersAny")
+public fun ColumnSet<Any>.asNumbers(): ColumnSet<Number> = this as ColumnSet<Number>
+
+@JvmName("asNumbersAnyNullable")
+public fun ColumnSet<Any?>.asNumbers(): ColumnSet<Number?> = this as ColumnSet<Number?>
+
+public fun <T> ColumnSet<T>.asComparable(): ColumnSet<Comparable<T>> = this as ColumnSet<Comparable<T>>
+
+// endregion
+
+// region Iterable
+
+public fun <T> Iterable<DataFrame<T>>.toFrameColumn(name: String = ""): FrameColumn<T> =
+    DataColumn.createFrameColumn(name, asList()).forceResolve()
+
+public inline fun <reified T> Iterable<T>.toValueColumn(name: String = ""): ValueColumn<T> =
+    DataColumn.createValueColumn(name, asList()).forceResolve()
+
+public inline fun <reified T> Iterable<T>.toValueColumn(column: ColumnAccessor<T>): ValueColumn<T> =
+    toValueColumn(column.name())
+
+public inline fun <reified T> Iterable<T>.toValueColumn(column: KProperty<T>): ValueColumn<T> =
+    toValueColumn(column.columnName)
+
+/**
+ * Indicates how [DataColumn.type] should be calculated.
+ *
+ * Used in [add], [insert], [convert], [map], [merge], [split] and other [DataFrame] operations
+ */
+public enum class Infer {
+
+    /**
+     * Use reified type argument of an inline [DataFrame] operation as [DataColumn.type].
+     */
+    None,
+
+    /**
+     * Use reified type argument of an inline [DataFrame] operation as [DataColumn.type], but compute [DataColumn.hasNulls] by checking column [DataColumn.values] for an actual presence of *null* values.
+     */
+    Nulls,
+
+    /**
+     * Infer [DataColumn.type] and [DataColumn.hasNulls] from actual [DataColumn.values] using optionally provided base type as an upper bound.
+     */
+    Type
+}
+
+/**
+ * Indicates how [DataColumn.hasNulls] (or, more accurately, DataColumn.type.isMarkedNullable) should be initialized from
+ * expected schema and actual data when reading schema-defined data formats.
+ */
+public enum class NullabilityOptions {
+    /**
+     * Use only actual data, set [DataColumn.hasNulls] to true if and only if there are null values in the column.
+     * On empty dataset use False.
+     */
+    Infer,
+
+    /**
+     * Set [DataColumn.hasNulls] to expected value. Throw exception if column should be not nullable but there are null values.
+     */
+    Checking,
+
+    /**
+     * Set [DataColumn.hasNulls] to expected value by default. Change False to True if column should be not nullable but there are null values.
+     */
+    Widening
+}
+
+public class NullabilityException() : Exception()
+
+/**
+ * @return if column should be marked nullable for current [NullabilityOptions] value with actual [data] and [expectedNulls] per some schema/signature.
+ * @throws [NullabilityException] for [NullabilityOptions.Checking] if [expectedNulls] is false and [data] contains nulls.
+ */
+public fun NullabilityOptions.applyNullability(data: List<Any?>, expectedNulls: Boolean): Boolean {
+    val hasNulls = data.anyNull()
+    return when (this) {
+        NullabilityOptions.Infer -> hasNulls
+        NullabilityOptions.Checking -> {
+            if (!expectedNulls && hasNulls) {
+                throw NullabilityException()
+            }
+            expectedNulls
+        }
+        NullabilityOptions.Widening -> {
+            expectedNulls || hasNulls
+        }
+    }
+}
+
+public inline fun <reified T> Iterable<T>.toColumn(
+    name: String = "",
+    infer: Infer = Infer.None
+): DataColumn<T> =
+    (
+        if (infer == Infer.Type) DataColumn.createWithTypeInference(name, asList())
+        else DataColumn.create(name, asList(), typeOf<T>(), infer)
+        ).forceResolve()
+
+public inline fun <reified T> Iterable<*>.toColumnOf(name: String = ""): DataColumn<T> =
+    DataColumn.create(name, asList() as List<T>, typeOf<T>()).forceResolve()
+
+public inline fun <reified T> Iterable<T>.toColumn(ref: ColumnReference<T>): DataColumn<T> =
+    DataColumn.create(ref.name(), asList()).forceResolve()
+
+public inline fun <reified T> Iterable<T>.toColumn(property: KProperty<T>): DataColumn<T> =
+    DataColumn.create(property.columnName, asList()).forceResolve()
+
+public fun Iterable<String>.toPath(): ColumnPath = ColumnPath(asList())
+
+public fun Iterable<AnyBaseCol>.toColumnGroup(name: String): ColumnGroup<*> = dataFrameOf(this).asColumnGroup(name)
+public fun <T> Iterable<AnyBaseCol>.toColumnGroup(column: ColumnGroupAccessor<T>): ColumnGroup<T> = dataFrameOf(this).cast<T>().asColumnGroup(column)
+
+public fun <T> Iterable<AnyBaseCol>.toColumnGroupOf(name: String): ColumnGroup<T> = toColumnGroup(name).cast()
+
+// endregion
+
+// region DataFrame
+
+public fun AnyFrame.toMap(): Map<String, List<Any?>> = columns().associateBy({ it.name }, { it.toList() })
+
+public fun <T> DataFrame<T>.asColumnGroup(name: String = ""): ColumnGroup<T> = when (this) {
+    is ColumnGroup<T> -> rename(name)
+    else -> DataColumn.createColumnGroup(name, this)
+}
+
+public fun <T> DataFrame<T>.asColumnGroup(column: ColumnGroupAccessor<T>): ColumnGroup<T> = asColumnGroup(column.name)
+
+// region as GroupedDataFrame
+
+public fun <T> DataFrame<T>.asGroupBy(groupedColumnName: String): GroupBy<T, T> =
+    GroupByImpl(this, getFrameColumn(groupedColumnName).castFrameColumn()) { none() }
+
+public fun <T, G> DataFrame<T>.asGroupBy(groupedColumn: ColumnReference<DataFrame<G>>): GroupBy<T, G> =
+    GroupByImpl(this, getFrameColumn(groupedColumn.name()).castFrameColumn()) { none() }
+
+public fun <T> DataFrame<T>.asGroupBy(): GroupBy<T, T> {
+    val groupCol = columns().single { it.isFrameColumn() }.asAnyFrameColumn().castFrameColumn<T>()
+    return asGroupBy { groupCol }
+}
+
+public fun <T, G> DataFrame<T>.asGroupBy(selector: ColumnSelector<T, DataFrame<G>>): GroupBy<T, G> {
+    val column = getColumn(selector).asFrameColumn()
+    return GroupByImpl(this, column) { none() }
+}
+
+// endregion
+
+// endregion
+
+// region DataRow
+
+public fun <T> DataRow<T>.toDataFrame(): DataFrame<T> = owner[index..index]
+
+public fun AnyRow.toMap(): Map<String, Any?> = df().columns().associate { it.name() to it[index] }
+
+// endregion
+
+// region Array
+
+public inline fun <reified T> Array<T>.toValueColumn(name: String): ValueColumn<T> =
+    DataColumn.createValueColumn(name, this.asList(), typeOf<T>())
+
+public fun Array<out String>.toPath(): ColumnPath = ColumnPath(this.asList())
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
new file mode 100644
index 000000000..a81da1c9a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
@@ -0,0 +1,236 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyColumnGroupAccessor
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.columns.BaseColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.exceptions.DuplicateColumnNamesException
+import org.jetbrains.kotlinx.dataframe.exceptions.UnequalColumnSizesException
+import org.jetbrains.kotlinx.dataframe.impl.api.insertImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.resolveSingle
+import kotlin.reflect.KProperty
+
+/**
+ * `add` operation adds new columns to DataFrame.
+ */
+
+// region Add existing columns
+
+/**
+ * Creates new [DataFrame] with given columns added to the end of original [DataFrame.columns] list.
+ *
+ * Original [DataFrame] is not modified.
+ *
+ * @param columns columns to add
+ * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names
+ * @throws [UnequalColumnSizesException] if columns in expected result have different sizes
+ * @return new [DataFrame] with added columns
+ */
+public fun <T> DataFrame<T>.add(vararg columns: AnyBaseCol): DataFrame<T> = addAll(columns.asIterable())
+
+/**
+ * Creates new [DataFrame] with given columns added to the end of original [DataFrame.columns] list.
+ *
+ * Original [DataFrame] is not modified.
+ *
+ * @param columns columns to add
+ * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names
+ * @throws [UnequalColumnSizesException] if columns in expected result have different sizes
+ * @return new [DataFrame] with added columns
+ */
+public fun <T> DataFrame<T>.addAll(columns: Iterable<AnyBaseCol>): DataFrame<T> =
+    dataFrameOf(columns() + columns).cast()
+
+/**
+ * Creates new [DataFrame] with all columns from given [dataFrames] added to the end of original [DataFrame.columns] list.
+ *
+ * Original [DataFrame] is not modified.
+ *
+ * @param dataFrames dataFrames to get columns from
+ * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names
+ * @throws [UnequalColumnSizesException] if columns in expected result have different sizes
+ * @return new [DataFrame] with added columns
+ */
+public fun <T> DataFrame<T>.add(vararg dataFrames: AnyFrame): DataFrame<T> = addAll(dataFrames.asIterable())
+
+/**
+ * Creates new [DataFrame] with all columns from given [dataFrames] added to the end of original [DataFrame.columns] list.
+ *
+ * Original [DataFrame] is not modified.
+ *
+ * @param dataFrames dataFrames to get columns from
+ * @throws [DuplicateColumnNamesException] if columns in expected result have repeated names
+ * @throws [UnequalColumnSizesException] if columns in expected result have different sizes
+ * @return new [DataFrame] with added columns
+ */
+@JvmName("addAllFrames")
+public fun <T> DataFrame<T>.addAll(dataFrames: Iterable<AnyFrame>): DataFrame<T> =
+    addAll(dataFrames.flatMap { it.columns() })
+
+// endregion
+
+// region Create and add a single column
+
+/**
+ * Receiver that is used in [add] and [update] operations to access new (added or updated) column value in preceding row.
+ */
+public interface AddDataRow<out T> : DataRow<T> {
+
+    /**
+     * Returns a new value that was already computed for some preceding row during current [add] or [update] column operation.
+     *
+     * Can be used to compute series of values with recurrence relations, e.g. fibonacci.
+     *
+     * @throws IndexOutOfBoundsException when called on a successive row that doesn't have new value yet
+     */
+    public fun <C> AnyRow.newValue(): C
+}
+
+/**
+ * [AddExpression] is used to express or select any instance of `R` using the given instance of [AddDataRow]`<T>` as
+ * `this` and `it`.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * AddDataRow<T>.(it: AddDataRow<T>) -> R
+ * ```
+ */
+public typealias AddExpression<T, R> = Selector<AddDataRow<T>, R>
+
+/**
+ * Creates new column using row [expression] and adds it to the end of [DataFrame]
+ *
+ * Original [DataFrame] is not modified.
+ *
+ * @param name name for a new column. If it is empty, a unique column name will be generated. Otherwise, it should be unique for original [DataFrame].
+ * @param infer a value of [Infer] that specifies how to compute column [type][BaseColumn.type] for a new column
+ * @param expression [AddExpression] that computes column value for every [DataRow]
+ * @return new [DataFrame] with added column
+ * @throws DuplicateColumnNamesException if [DataFrame] already contains a column with given [name]
+ */
+public inline fun <reified R, T> DataFrame<T>.add(
+    name: String,
+    infer: Infer = Infer.Nulls,
+    noinline expression: AddExpression<T, R>
+): DataFrame<T> =
+    (this + mapToColumn(name, infer, expression))
+
+public inline fun <reified R, T> DataFrame<T>.add(
+    property: KProperty<R>,
+    infer: Infer = Infer.Nulls,
+    noinline expression: AddExpression<T, R>
+): DataFrame<T> =
+    (this + mapToColumn(property, infer, expression))
+
+public inline fun <reified R, T> DataFrame<T>.add(
+    column: ColumnAccessor<R>,
+    infer: Infer = Infer.Nulls,
+    noinline expression: AddExpression<T, R>
+): DataFrame<T> =
+    add(column.path(), infer, expression)
+
+public inline fun <reified R, T> DataFrame<T>.add(
+    path: ColumnPath,
+    infer: Infer = Infer.Nulls,
+    noinline expression: AddExpression<T, R>
+): DataFrame<T> {
+    val col = mapToColumn(path.name(), infer, expression)
+    if (path.size == 1) return this + col
+    return insertImpl(path, col)
+}
+
+// endregion
+
+// region Create and add several columns
+
+public class AddDsl<T>(@PublishedApi internal val df: DataFrame<T>) : ColumnsContainer<T> by df, ColumnSelectionDsl<T> {
+
+    // TODO: support adding column into path
+    internal val columns = mutableListOf<AnyCol>()
+
+    public fun add(column: Column): Boolean = columns.add(column.resolveSingle(df)!!.data)
+
+    public operator fun Column.unaryPlus(): Boolean = add(this)
+
+    public operator fun String.unaryPlus(): Boolean = add(df[this])
+
+    @PublishedApi
+    internal inline fun <reified R> add(
+        name: String,
+        infer: Infer = Infer.Nulls,
+        noinline expression: RowExpression<T, R>
+    ): Boolean = add(df.mapToColumn(name, infer, expression))
+
+    public inline fun <reified R> expr(noinline expression: RowExpression<T, R>): DataColumn<R> {
+        return df.mapToColumn("", Infer.Nulls, expression)
+    }
+
+    public inline infix fun <reified R> String.from(noinline expression: RowExpression<T, R>): Boolean =
+        add(this, Infer.Nulls, expression)
+
+    // TODO: use path instead of name
+    public inline infix fun <reified R> ColumnAccessor<R>.from(noinline expression: RowExpression<T, R>): Boolean =
+        name().from(expression)
+
+    public inline infix fun <reified R> KProperty<R>.from(noinline expression: RowExpression<T, R>): Boolean =
+        add(name, Infer.Nulls, expression)
+
+    public infix fun String.from(column: Column): Boolean = add(column.rename(this))
+    public inline infix fun <reified R> ColumnAccessor<R>.from(column: ColumnReference<R>): Boolean = name() from column
+    public inline infix fun <reified R> KProperty<R>.from(column: ColumnReference<R>): Boolean = name from column
+
+    public infix fun Column.into(name: String): Boolean = add(rename(name))
+    public infix fun <R> ColumnReference<R>.into(column: ColumnAccessor<R>): Boolean = into(column.name())
+    public infix fun <R> ColumnReference<R>.into(column: KProperty<R>): Boolean = into(column.name)
+
+    public operator fun String.invoke(body: AddDsl<T>.() -> Unit): Unit = group(this, body)
+    public infix fun AnyColumnGroupAccessor.from(body: AddDsl<T>.() -> Unit): Unit = group(this, body)
+
+    public fun group(column: AnyColumnGroupAccessor, body: AddDsl<T>.() -> Unit): Unit = group(column.name(), body)
+    public fun group(name: String, body: AddDsl<T>.() -> Unit) {
+        val dsl = AddDsl(df)
+        body(dsl)
+        add(dsl.columns.toColumnGroup(name))
+    }
+
+    public fun group(body: AddDsl<T>.() -> Unit): AddGroup<T> = AddGroup(body)
+
+    public infix fun AddGroup<T>.into(groupName: String): Unit = group(groupName, body)
+    public infix fun AddGroup<T>.into(column: AnyColumnGroupAccessor): Unit = into(column.name())
+}
+
+public fun <T> DataFrame<T>.add(body: AddDsl<T>.() -> Unit): DataFrame<T> {
+    val dsl = AddDsl(this)
+    body(dsl)
+    return dataFrameOf(this@add.columns() + dsl.columns).cast()
+}
+
+public inline fun <reified R, T, G> GroupBy<T, G>.add(
+    name: String,
+    infer: Infer = Infer.Nulls,
+    noinline expression: RowExpression<G, R>
+): GroupBy<T, G> =
+    updateGroups { add(name, infer, expression) }
+
+public inline fun <reified R, T, G> GroupBy<T, G>.add(
+    column: ColumnAccessor<G>,
+    infer: Infer = Infer.Nulls,
+    noinline expression: RowExpression<G, R>
+): GroupBy<T, G> =
+    add(column.name(), infer, expression)
+
+public class AddGroup<T>(internal val body: AddDsl<T>.() -> Unit)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/addId.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/addId.kt
new file mode 100644
index 000000000..51251c8ad
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/addId.kt
@@ -0,0 +1,22 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+
+// region DataColumn
+
+public fun AnyCol.addId(columnName: String = "id"): AnyFrame =
+    toDataFrame().addId(columnName)
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.addId(column: ColumnAccessor<Int>): DataFrame<T> = insert(column) { index() }.at(0)
+
+public fun <T> DataFrame<T>.addId(columnName: String = "id"): DataFrame<T> =
+    insert(columnName) { index() }.at(0)
+
+// endregion
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
new file mode 100644
index 000000000..ad893e9be
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/aggregate.kt
@@ -0,0 +1,11 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateDsl
+
+// region Pivot
+
+public fun <T, R> Pivot<T>.aggregate(separate: Boolean = false, body: Selector<AggregateDsl<T>, R>): DataRow<T> = delegate { aggregate(separate, body) }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/all.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/all.kt
new file mode 100644
index 000000000..f12fed700
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/all.kt
@@ -0,0 +1,34 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.Predicate
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.owner
+import org.jetbrains.kotlinx.dataframe.index
+
+// region DataColumn
+
+/** Returns `true` if all [values] match the given [predicate] or [values] is empty. */
+public fun <T> DataColumn<T>.all(predicate: Predicate<T>): Boolean = values.all(predicate)
+
+/** Returns `true` if all [values] are `null` or [values] is empty. */
+public fun <C> DataColumn<C>.allNulls(): Boolean = size == 0 || all { it == null }
+
+// endregion
+
+// region DataRow
+
+public fun AnyRow.allNA(): Boolean = owner.columns().all { it[index].isNA }
+
+// endregion
+
+// region DataFrame
+
+/** Returns `true` if all [rows] match the given [predicate] or [rows] is empty. */
+public fun <T> DataFrame<T>.all(predicate: RowFilter<T>): Boolean = rows().all { predicate(it, it) }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/any.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/any.kt
new file mode 100644
index 000000000..d8af3cf83
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/any.kt
@@ -0,0 +1,19 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.Predicate
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.columns.values
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.any(predicate: Predicate<T>): Boolean = values.any(predicate)
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.any(predicate: RowFilter<T>): Boolean = rows().any { predicate(it, it) }
+
+// endregion
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
new file mode 100644
index 000000000..aa2e1e286
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/append.kt
@@ -0,0 +1,30 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.api.updateWith
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.append(vararg values: Any?): DataFrame<T> {
+    val ncol = ncol
+    check(values.size % ncol == 0) { "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()
+}
+
+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()
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/asIterable.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/asIterable.kt
new file mode 100644
index 000000000..2b5c379f4
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/asIterable.kt
@@ -0,0 +1,9 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.asIterable(): Iterable<T> = values()
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/asSequence.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/asSequence.kt
new file mode 100644
index 000000000..73af1ef41
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/asSequence.kt
@@ -0,0 +1,17 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.asSequence(): Sequence<T> = asIterable().asSequence()
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.asSequence(): Sequence<DataRow<T>> = rows().asSequence()
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/associate.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/associate.kt
new file mode 100644
index 000000000..3e6d9fb44
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/associate.kt
@@ -0,0 +1,15 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+
+// region DataFrame
+
+public fun <T, V> DataFrame<T>.associateBy(transform: RowExpression<T, V>): Map<V, DataRow<T>> =
+    rows().associateBy { transform(it, it) }
+
+public fun <T, K, V> DataFrame<T>.associate(transform: RowExpression<T, Pair<K, V>>): Map<K, V> =
+    rows().associate { transform(it, it) }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/between.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/between.kt
new file mode 100644
index 000000000..d25611827
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/between.kt
@@ -0,0 +1,11 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.impl.between
+
+// region DataColumn
+
+public fun <T : Comparable<T>> DataColumn<T>.between(left: T, right: T, includeBoundaries: Boolean = true): DataColumn<Boolean> =
+    map { it.between(left, right, includeBoundaries) }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt
new file mode 100644
index 000000000..921fdd412
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt
@@ -0,0 +1,49 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.impl.api.convertToImpl
+import kotlin.reflect.typeOf
+
+public fun <T> AnyFrame.cast(): DataFrame<T> = this as DataFrame<T>
+
+public inline fun <reified T> AnyFrame.cast(verify: Boolean = true): DataFrame<T> = if (verify) convertToImpl(
+    typeOf<T>(),
+    allowConversion = false,
+    ExcessiveColumns.Keep
+).cast()
+else cast()
+
+public fun <T> AnyRow.cast(): DataRow<T> = this as DataRow<T>
+
+public inline fun <reified T> AnyRow.cast(verify: Boolean = true): DataRow<T> = df().cast<T>(verify)[0]
+
+public fun <T> AnyCol.cast(): DataColumn<T> = this as DataColumn<T>
+
+public fun <T> ValueColumn<*>.cast(): ValueColumn<T> = this as ValueColumn<T>
+
+public fun <T> FrameColumn<*>.castFrameColumn(): FrameColumn<T> = this as FrameColumn<T>
+
+public fun <T> ColumnGroup<*>.cast(): ColumnGroup<T> = this as ColumnGroup<T>
+
+public fun <T> ColumnWithPath<*>.cast(): ColumnWithPath<T> = this as ColumnWithPath<T>
+
+public fun <T> ColumnAccessor<*>.cast(): ColumnAccessor<T> = this as ColumnAccessor<T>
+
+public fun <C> ColumnSet<*>.cast(): ColumnSet<C> = this as ColumnSet<C>
+
+public fun <C> ColumnReference<*>.cast(): ColumnReference<C> = this as ColumnReference<C>
+
+public fun <C> SingleColumn<*>.cast(): SingleColumn<C> = this as SingleColumn<C>
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/chunked.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/chunked.kt
new file mode 100644
index 000000000..67f3dec6d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/chunked.kt
@@ -0,0 +1,25 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.impl.getListType
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.type
+
+public fun <T> DataFrame<T>.chunked(size: Int, name: String = "groups"): FrameColumn<T> {
+    val startIndices = (0 until nrow step size)
+    return DataColumn.createFrameColumn(name, this, startIndices)
+}
+
+public fun <T> DataColumn<T>.chunked(size: Int): ValueColumn<List<T>> {
+    val values = toList().chunked(size)
+    return DataColumn.createValueColumn(name(), values, getListType(type))
+}
+
+public fun <T> ColumnGroup<T>.chunked(size: Int): FrameColumn<T> = chunked(size, name())
+
+public fun <T> DataColumn<DataRow<T>>.chunked(size: Int): FrameColumn<T> = asColumnGroup().chunked(size)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/concat.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/concat.kt
new file mode 100644
index 000000000..c74cfc4a0
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/concat.kt
@@ -0,0 +1,58 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.api.concatImpl
+import org.jetbrains.kotlinx.dataframe.impl.asList
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.concat(vararg other: DataColumn<T>): DataColumn<T> = concatImpl(name, listOf(this) + other)
+
+public fun <T> DataColumn<DataFrame<T>>.concat(): DataFrame<T> = values.concat()
+
+public fun <T> DataColumn<Collection<T>>.concat(): List<T> = values.flatten()
+
+// endregion
+
+// region DataRow
+
+public fun <T> DataRow<T>.concat(vararg rows: DataRow<T>): DataFrame<T> = (listOf(this) + rows).concat()
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.concat(vararg frames: DataFrame<T>): DataFrame<T> = concatImpl(listOf(this) + frames)
+
+@JvmName("concatT")
+public fun <T> DataFrame<T>.concat(rows: Iterable<DataRow<T>>): DataFrame<T> = (rows() + rows).concat()
+
+public fun <T> DataFrame<T>.concat(frames: Iterable<DataFrame<T>>): DataFrame<T> = (listOf(this) + frames).concat()
+
+// endregion
+
+// region GroupBy
+
+public fun <T, G> GroupBy<T, G>.concat(): DataFrame<G> = groups.concat()
+
+// endregion
+
+// region Iterable
+
+public fun <T> Iterable<DataFrame<T>>.concat(): DataFrame<T> {
+    return concatImpl(asList())
+}
+
+public fun <T> Iterable<DataColumn<T>>.concat(): DataColumn<T> {
+    val list = asList()
+    if (list.isEmpty()) return DataColumn.empty().cast()
+    return concatImpl(list[0].name(), list)
+}
+
+@JvmName("concatRows")
+public fun <T> Iterable<DataRow<T>?>.concat(): DataFrame<T> = concatImpl(map { it?.toDataFrame() ?: DataFrame.empty(1).cast() })
+
+// 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
new file mode 100644
index 000000000..5431d66d7
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/constructors.kt
@@ -0,0 +1,332 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnGroupReference
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.exceptions.DuplicateColumnNamesException
+import org.jetbrains.kotlinx.dataframe.exceptions.UnequalColumnSizesException
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameImpl
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnAccessorImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.createColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.createComputedColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.columns.forceResolve
+import org.jetbrains.kotlinx.dataframe.impl.columns.unbox
+import org.jetbrains.kotlinx.dataframe.size
+import kotlin.random.Random
+import kotlin.random.nextInt
+import kotlin.reflect.KProperty
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.typeOf
+
+// region create ColumnAccessor
+
+// region column
+
+public fun <T> column(): ColumnDelegate<T> = ColumnDelegate()
+public fun <T> column(name: String): ColumnAccessor<T> = ColumnAccessorImpl(name)
+public fun <T> column(path: ColumnPath): ColumnAccessor<T> = ColumnAccessorImpl(path)
+public fun <T> ColumnGroupReference.column(): ColumnDelegate<T> = ColumnDelegate(this)
+public fun <T> ColumnGroupReference.column(name: String): ColumnAccessor<T> = ColumnAccessorImpl(path() + name)
+public fun <T> ColumnGroupReference.column(path: ColumnPath): ColumnAccessor<T> = ColumnAccessorImpl(this.path() + path)
+
+public inline fun <reified T> column(
+    name: String = "",
+    infer: Infer = Infer.Nulls,
+    noinline expression: RowExpression<Any?, T>,
+): ColumnReference<T> = createComputedColumnReference(name, typeOf<T>(), infer, expression)
+
+public inline fun <T, reified C> column(
+    df: DataFrame<T>,
+    name: String = "",
+    infer: Infer = Infer.Nulls,
+    noinline expression: RowExpression<T, C>,
+): ColumnReference<C> = createComputedColumnReference(name, typeOf<C>(), infer, expression as RowExpression<Any?, C>)
+
+// endregion
+
+// region columnGroup
+
+public fun columnGroup(): ColumnDelegate<AnyRow> = column()
+
+@JvmName("columnGroupTyped")
+public fun <T> columnGroup(): ColumnDelegate<DataRow<T>> = column()
+
+public fun columnGroup(name: String): ColumnAccessor<AnyRow> = column(name)
+
+@JvmName("columnGroupTyped")
+public fun <T> columnGroup(name: String): ColumnAccessor<DataRow<T>> = column(name)
+
+public fun columnGroup(path: ColumnPath): ColumnAccessor<AnyRow> = column(path)
+
+@JvmName("columnGroupTyped")
+public fun <T> columnGroup(path: ColumnPath): ColumnAccessor<DataRow<T>> = column(path)
+
+public fun ColumnGroupReference.columnGroup(): ColumnDelegate<AnyRow> = ColumnDelegate(this)
+
+@JvmName("columnGroupTyped")
+public fun <T> ColumnGroupReference.columnGroup(): ColumnDelegate<DataRow<T>> = ColumnDelegate(this)
+
+public fun ColumnGroupReference.columnGroup(name: String): ColumnAccessor<AnyRow> = ColumnAccessorImpl(path() + name)
+
+@JvmName("columnGroupTyped")
+public fun <T> ColumnGroupReference.columnGroup(name: String): ColumnAccessor<DataRow<T>> =
+    ColumnAccessorImpl(path() + name)
+
+public fun ColumnGroupReference.columnGroup(path: ColumnPath): ColumnAccessor<AnyRow> =
+    ColumnAccessorImpl(this.path() + path)
+
+@JvmName("columnGroupTyped")
+public fun <T> ColumnGroupReference.columnGroup(path: ColumnPath): ColumnAccessor<DataRow<T>> =
+    ColumnAccessorImpl(this.path() + path)
+
+// endregion
+
+// region frameColumn
+
+public fun frameColumn(): ColumnDelegate<AnyFrame> = column()
+
+@JvmName("frameColumnTyped")
+public fun <T> frameColumn(): ColumnDelegate<DataFrame<T>> = column()
+
+public fun frameColumn(name: String): ColumnAccessor<AnyFrame> = column(name)
+
+@JvmName("frameColumnTyped")
+public fun <T> frameColumn(name: String): ColumnAccessor<DataFrame<T>> = column(name)
+
+public fun frameColumn(path: ColumnPath): ColumnAccessor<AnyFrame> = column(path)
+
+@JvmName("frameColumnTyped")
+public fun <T> frameColumn(path: ColumnPath): ColumnAccessor<DataFrame<T>> = column(path)
+
+public fun ColumnGroupReference.frameColumn(): ColumnDelegate<AnyFrame> = ColumnDelegate(this)
+
+@JvmName("frameColumnTyped")
+public fun <T> ColumnGroupReference.frameColumn(): ColumnDelegate<DataFrame<T>> = ColumnDelegate(this)
+
+public fun ColumnGroupReference.frameColumn(name: String): ColumnAccessor<AnyFrame> = ColumnAccessorImpl(path() + name)
+
+@JvmName("frameColumnTyped")
+public fun <T> ColumnGroupReference.frameColumn(name: String): ColumnAccessor<DataFrame<T>> =
+    ColumnAccessorImpl(path() + name)
+
+public fun ColumnGroupReference.frameColumn(path: ColumnPath): ColumnAccessor<AnyFrame> =
+    ColumnAccessorImpl(this.path() + path)
+
+@JvmName("frameColumnTyped")
+public fun <T> ColumnGroupReference.frameColumn(path: ColumnPath): ColumnAccessor<DataFrame<T>> =
+    ColumnAccessorImpl(this.path() + path)
+
+// endregion
+
+public class ColumnDelegate<T>(private val parent: ColumnGroupReference? = null) {
+    public operator fun getValue(thisRef: Any?, property: KProperty<*>): ColumnAccessor<T> = named(property.columnName)
+
+    public infix fun named(name: String): ColumnAccessor<T> =
+        parent?.let { ColumnAccessorImpl(it.path() + name) } ?: ColumnAccessorImpl(name)
+}
+
+// endregion
+
+// region create DataColumn
+
+public inline fun <reified T> columnOf(vararg values: T): DataColumn<T> =
+    createColumn(values.asIterable(), typeOf<T>(), true).forceResolve()
+
+public fun columnOf(vararg values: AnyBaseCol): DataColumn<AnyRow> = columnOf(values.asIterable()).forceResolve()
+
+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()
+        .forceResolve()
+
+public fun <T> columnOf(frames: Iterable<DataFrame<T>>): FrameColumn<T> = DataColumn.createFrameColumn(
+    "",
+    frames.toList()
+).forceResolve()
+
+public inline fun <reified T> column(values: Iterable<T>): DataColumn<T> =
+    createColumn(values, typeOf<T>(), false).forceResolve()
+
+// endregion
+
+// region create DataFrame
+
+/**
+ * Creates new [DataFrame] with given [columns]
+ *
+ * All named columns must have unique names. For columns with empty names unique column names are generated: "untitled", "untitiled1", "untitled2" etc.
+ *
+ * All columns must have equal sizes.
+ *
+ * @throws [DuplicateColumnNamesException] if column names are not unique
+ * @throws [UnequalColumnSizesException] if column size are not equal
+ * @param columns columns for [DataFrame]
+ */
+public fun dataFrameOf(columns: Iterable<AnyBaseCol>): AnyFrame {
+    val cols = columns.map { it.unbox() }
+    val nrow = if (cols.isEmpty()) 0 else cols[0].size
+    return DataFrameImpl<Unit>(cols, nrow)
+}
+
+public fun dataFrameOf(vararg header: ColumnReference<*>): DataFrameBuilder = DataFrameBuilder(header.map { it.name() })
+
+public fun dataFrameOf(vararg columns: AnyBaseCol): AnyFrame = dataFrameOf(columns.asIterable())
+
+public fun dataFrameOf(vararg header: String): DataFrameBuilder = dataFrameOf(header.toList())
+
+public inline fun <reified C> dataFrameOf(vararg header: String, fill: (String) -> Iterable<C>): AnyFrame =
+    dataFrameOf(header.asIterable(), fill)
+
+public fun dataFrameOf(header: Iterable<String>): DataFrameBuilder = DataFrameBuilder(header.asList())
+
+public fun dataFrameOf(vararg columns: Pair<String, List<Any?>>): AnyFrame =
+    columns.map { it.second.toColumn(it.first, Infer.Type) }.toDataFrame()
+
+public fun dataFrameOf(header: Iterable<String>, values: Iterable<Any?>): AnyFrame =
+    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()
+
+public fun dataFrameOf(header: CharProgression): DataFrameBuilder = dataFrameOf(header.map { it.toString() })
+
+public class DataFrameBuilder(private val header: List<String>) {
+
+    public operator fun invoke(vararg columns: AnyCol): AnyFrame = invoke(columns.asIterable())
+
+    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()
+    }
+
+    public operator fun invoke(vararg values: Any?): AnyFrame = withValues(values.asIterable())
+
+    @JvmName("invoke1")
+    internal fun withValues(values: Iterable<Any?>): AnyFrame {
+        val list = values.asList()
+
+        val ncol = header.size
+
+        require(header.size > 0 && list.size.rem(ncol) == 0) {
+            "Number of values ${list.size} is not divisible by number of columns $ncol"
+        }
+
+        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()
+    }
+
+    public operator fun invoke(args: Sequence<Any?>): AnyFrame = invoke(*args.toList().toTypedArray())
+
+    public fun withColumns(columnBuilder: (String) -> AnyCol): AnyFrame = header.map(columnBuilder).toDataFrame()
+
+    public inline operator fun <reified T> invoke(crossinline valuesBuilder: (String) -> Iterable<T>): AnyFrame =
+        withColumns { name ->
+            valuesBuilder(name).let {
+                DataColumn.create(
+                    name,
+                    it.asList()
+                )
+            }
+        }
+
+    public inline fun <reified C> fill(nrow: Int, value: C): AnyFrame = withColumns { name ->
+        DataColumn.createValueColumn(
+            name,
+            List(nrow) { value },
+            typeOf<C>().withNullability(value == null)
+        )
+    }
+
+    public inline fun <reified C> nulls(nrow: Int): AnyFrame = fill<C?>(nrow, null)
+
+    public inline fun <reified C> fillIndexed(nrow: Int, crossinline init: (Int, String) -> C): AnyFrame =
+        withColumns { name ->
+            DataColumn.create(
+                name,
+                List(nrow) { init(it, name) }
+            )
+        }
+
+    public inline fun <reified C> fill(nrow: Int, crossinline init: (Int) -> C): AnyFrame = withColumns { name ->
+        DataColumn.create(
+            name,
+            List(nrow, init)
+        )
+    }
+
+    private inline fun <reified C> fillNotNull(nrow: Int, crossinline init: (Int) -> C) = withColumns { name ->
+        DataColumn.createValueColumn(
+            name,
+            List(nrow, init),
+            typeOf<C>()
+        )
+    }
+
+    public fun randomInt(nrow: Int): AnyFrame = fillNotNull(nrow) { Random.nextInt() }
+
+    public fun randomInt(nrow: Int, range: IntRange): AnyFrame = fillNotNull(nrow) { Random.nextInt(range) }
+
+    public fun randomDouble(nrow: Int): AnyFrame = fillNotNull(nrow) { Random.nextDouble() }
+
+    public fun randomDouble(nrow: Int, range: ClosedRange<Double>): AnyFrame =
+        fillNotNull(nrow) { Random.nextDouble(range.start, range.endInclusive) }
+
+    public fun randomFloat(nrow: Int): AnyFrame = fillNotNull(nrow) { Random.nextFloat() }
+
+    public fun randomLong(nrow: Int): AnyFrame = fillNotNull(nrow) { Random.nextLong() }
+
+    public fun randomLong(nrow: Int, range: ClosedRange<Long>): AnyFrame =
+        fillNotNull(nrow) { Random.nextLong(range.start, range.endInclusive) }
+
+    public fun randomBoolean(nrow: Int): AnyFrame = fillNotNull(nrow) { Random.nextBoolean() }
+}
+
+/**
+ * Returns [DataFrame] with no rows and no columns.
+ *
+ * To create [DataFrame] with empty columns or empty rows see [DataFrame.empty]
+ *
+ * @param T schema marker for [DataFrame]
+ */
+public fun <T> emptyDataFrame(): DataFrame<T> = DataFrame.empty().cast()
+
+// endregion
+
+// region create ColumnPath
+
+public fun pathOf(vararg columnNames: String): ColumnPath = ColumnPath(columnNames.asList())
+
+// endregion
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
new file mode 100644
index 000000000..a8eb4bdba
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt
@@ -0,0 +1,387 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import kotlinx.datetime.Instant
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toLocalDateTime
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.RowColumnExpression
+import org.jetbrains.kotlinx.dataframe.RowValueExpression
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.dataTypes.IFRAME
+import org.jetbrains.kotlinx.dataframe.dataTypes.IMG
+import org.jetbrains.kotlinx.dataframe.exceptions.CellConversionException
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConversionException
+import org.jetbrains.kotlinx.dataframe.impl.api.Parsers
+import org.jetbrains.kotlinx.dataframe.impl.api.convertRowColumnImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.convertToTypeImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.defaultTimeZone
+import org.jetbrains.kotlinx.dataframe.impl.api.toLocalDate
+import org.jetbrains.kotlinx.dataframe.impl.api.toLocalDateTime
+import org.jetbrains.kotlinx.dataframe.impl.api.toLocalTime
+import org.jetbrains.kotlinx.dataframe.impl.api.withRowCellImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.impl.headPlusArray
+import org.jetbrains.kotlinx.dataframe.io.toDataFrame
+import org.jetbrains.kotlinx.dataframe.path
+import java.math.BigDecimal
+import java.net.URL
+import java.time.LocalTime
+import java.util.Locale
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+public fun <T, C> DataFrame<T>.convert(columns: ColumnsSelector<T, C>): Convert<T, C> =
+    Convert(this, columns)
+
+public fun <T, C> DataFrame<T>.convert(vararg columns: KProperty<C>): Convert<T, C> =
+    convert { columns.toColumns() }
+
+public fun <T> DataFrame<T>.convert(vararg columns: String): Convert<T, Any?> = convert { columns.toColumns() }
+public fun <T, C> DataFrame<T>.convert(vararg columns: ColumnReference<C>): Convert<T, C> =
+    convert { columns.toColumns() }
+
+public inline fun <T, C, reified R> DataFrame<T>.convert(
+    firstCol: ColumnReference<C>,
+    vararg cols: ColumnReference<C>,
+    infer: Infer = Infer.Nulls,
+    noinline expression: RowValueExpression<T, C, R>
+): DataFrame<T> =
+    convert(*headPlusArray(firstCol, cols)).with(infer, expression)
+
+public inline fun <T, C, reified R> DataFrame<T>.convert(
+    firstCol: KProperty<C>,
+    vararg cols: KProperty<C>,
+    infer: Infer = Infer.Nulls,
+    noinline expression: RowValueExpression<T, C, R>
+): DataFrame<T> =
+    convert(*headPlusArray(firstCol, cols)).with(infer, expression)
+
+public inline fun <T, reified R> DataFrame<T>.convert(
+    firstCol: String,
+    vararg cols: String,
+    infer: Infer = Infer.Nulls,
+    noinline expression: RowValueExpression<T, Any?, R>
+): DataFrame<T> =
+    convert(*headPlusArray(firstCol, cols)).with(infer, expression)
+
+public inline fun <T, C, reified R> Convert<T, C?>.notNull(crossinline expression: RowValueExpression<T, C, R>): DataFrame<T> =
+    with {
+        if (it == null) null
+        else expression(this, it)
+    }
+
+public data class Convert<T, out C>(val df: DataFrame<T>, val columns: ColumnsSelector<T, C>) {
+    public fun <R> cast(): Convert<T, R> = Convert(df, columns as ColumnsSelector<T, R>)
+
+    public inline fun <reified D> to(): DataFrame<T> = to(typeOf<D>())
+}
+
+public fun <T> Convert<T, *>.to(type: KType): DataFrame<T> = to { it.convertTo(type) }
+
+public inline fun <T, C, reified R> Convert<T, C>.with(
+    infer: Infer = Infer.Nulls,
+    noinline rowConverter: RowValueExpression<T, C, R>
+): DataFrame<T> =
+    withRowCellImpl(typeOf<R>(), infer, rowConverter)
+
+public inline fun <T, C, reified R> Convert<T, C>.perRowCol(
+    infer: Infer = Infer.Nulls,
+    noinline expression: RowColumnExpression<T, C, R>
+): DataFrame<T> =
+    convertRowColumnImpl(typeOf<R>(), infer, expression)
+
+public fun <T, C> Convert<T, C>.to(columnConverter: DataFrame<T>.(DataColumn<C>) -> AnyBaseCol): DataFrame<T> =
+    df.replace(columns).with { columnConverter(df, it) }
+
+public inline fun <reified C> AnyCol.convertTo(): DataColumn<C> = convertTo(typeOf<C>()) as DataColumn<C>
+public fun AnyCol.convertTo(newType: KType): AnyCol {
+    if (this.type() == typeOf<String>() && newType == typeOf<Double>()) return (this as DataColumn<String>).convertToDouble()
+    if (this.type() == typeOf<String?>() && newType == typeOf<Double?>()) return (this as DataColumn<String?>).convertToDouble()
+    return convertToTypeImpl(newType)
+}
+
+@JvmName("convertToLocalDateTimeFromT")
+public fun <T : Any> DataColumn<T>.convertToLocalDateTime(): DataColumn<LocalDateTime> = convertTo()
+public fun <T : Any> DataColumn<T?>.convertToLocalDateTime(): DataColumn<LocalDateTime?> = convertTo()
+
+@JvmName("convertToLocalDateFromT")
+public fun <T : Any> DataColumn<T>.convertToLocalDate(): DataColumn<LocalDate> = convertTo()
+public fun <T : Any> DataColumn<T?>.convertToLocalDate(): DataColumn<LocalDate?> = convertTo()
+
+@JvmName("convertToLocalTimeFromT")
+public fun <T : Any> DataColumn<T>.convertToLocalTime(): DataColumn<LocalTime> = convertTo()
+public fun <T : Any> DataColumn<T?>.convertToLocalTime(): DataColumn<LocalTime?> = convertTo()
+
+@JvmName("convertToByteFromT")
+public fun <T : Any> DataColumn<T>.convertToByte(): DataColumn<Byte> = convertTo()
+public fun <T : Any> DataColumn<T?>.convertToByte(): DataColumn<Byte?> = convertTo()
+
+@JvmName("convertToShortFromT")
+public fun <T : Any> DataColumn<T>.convertToShort(): DataColumn<Short> = convertTo()
+public fun <T : Any> DataColumn<T?>.convertToShort(): DataColumn<Short?> = convertTo()
+
+@JvmName("convertToIntFromT")
+public fun <T : Any> DataColumn<T>.convertToInt(): DataColumn<Int> = convertTo()
+public fun <T : Any> DataColumn<T?>.convertToInt(): DataColumn<Int?> = convertTo()
+
+@JvmName("convertToLongFromT")
+public fun <T : Any> DataColumn<T>.convertToLong(): DataColumn<Long> = convertTo()
+public fun <T : Any> DataColumn<T?>.convertToLong(): DataColumn<Long?> = convertTo()
+
+@JvmName("convertToStringFromT")
+public fun <T : Any> DataColumn<T>.convertToString(): DataColumn<String> = convertTo()
+public fun <T : Any> DataColumn<T?>.convertToString(): DataColumn<String?> = convertTo()
+
+@JvmName("convertToDoubleFromT")
+public fun <T : Any> DataColumn<T>.convertToDouble(): DataColumn<Double> = convertTo()
+public fun <T : Any> DataColumn<T?>.convertToDouble(): DataColumn<Double?> = convertTo()
+
+/**
+ * Parse String column to Double considering locale (number format).
+ * If [locale] parameter is defined, it's number format is used for parsing.
+ * If [locale] parameter is null, the current system locale is used. If column can not be parsed, then POSIX format is used.
+ */
+@JvmName("convertToDoubleFromString")
+public fun DataColumn<String>.convertToDouble(locale: Locale? = null): DataColumn<Double> {
+    return this.castToNullable().convertToDouble(locale).castToNotNullable()
+}
+
+/**
+ * Parse String column to Double considering locale (number format).
+ * If [locale] parameter is defined, it's number format is used for parsing.
+ * If [locale] parameter is null, the current system locale is used. If column can not be parsed, then POSIX format is used.
+ */
+@JvmName("convertToDoubleFromStringNullable")
+public fun DataColumn<String?>.convertToDouble(locale: Locale? = null): DataColumn<Double?> {
+    fun applyParser(parser: (String) -> Double?): DataColumn<Double?> {
+        var currentRow = 0
+        try {
+            return mapIndexed { row, value ->
+                currentRow = row
+                value?.let { parser(value.trim()) ?: throw TypeConversionException(value, typeOf<String>(), typeOf<Double>(), path) }
+            }
+        } catch (e: TypeConversionException) {
+            throw CellConversionException(e.value, e.from, e.to, path, currentRow, e)
+        }
+    }
+
+    return if (locale != null) {
+        val explicitParser = Parsers.getDoubleParser(locale)
+        applyParser(explicitParser)
+    } else {
+        try {
+            val defaultParser = Parsers.getDoubleParser()
+            applyParser(defaultParser)
+        } catch (e: TypeConversionException) {
+            val posixParser = Parsers.getDoubleParser(Locale.forLanguageTag("C.UTF-8"))
+            applyParser(posixParser)
+        }
+    }
+}
+
+@JvmName("convertToFloatFromT")
+public fun <T : Any> DataColumn<T>.convertToFloat(): DataColumn<Float> = convertTo()
+public fun <T : Any> DataColumn<T?>.convertToFloat(): DataColumn<Float?> = convertTo()
+
+@JvmName("convertToBigDecimalFromT")
+public fun <T : Any> DataColumn<T>.convertToBigDecimal(): DataColumn<BigDecimal> = convertTo()
+public fun <T : Any> DataColumn<T?>.convertToBigDecimal(): DataColumn<BigDecimal?> = convertTo()
+
+@JvmName("convertToBooleanFromT")
+public fun <T : Any> DataColumn<T>.convertToBoolean(): DataColumn<Boolean> = convertTo()
+public fun <T : Any> DataColumn<T?>.convertToBoolean(): DataColumn<Boolean?> = convertTo()
+
+// region convert URL
+
+public fun <T, R : URL?> Convert<T, R>.toIFrame(border: Boolean = false, width: Int? = null, height: Int? = null): DataFrame<T> = to { it.map { IFRAME(it.toString(), border, width, height) } }
+public fun <T, R : URL?> Convert<T, R>.toImg(width: Int? = null, height: Int? = null): DataFrame<T> = to { it.map { IMG(it.toString(), width, height) } }
+
+// endregion
+
+// region toURL
+
+public fun DataColumn<String>.convertToURL(): DataColumn<URL> {
+    return map { URL(it) }
+}
+
+@JvmName("convertToURLFromStringNullable")
+public fun DataColumn<String?>.convertToURL(): DataColumn<URL?> {
+    return map { it?.let { URL(it) } }
+}
+
+public fun <T, R : String?> Convert<T, R>.toURL(): DataFrame<T> = to { it.convertToURL() }
+
+// endregion
+
+// region toInstant
+
+public fun DataColumn<String>.convertToInstant(): DataColumn<Instant> {
+    return map { Instant.parse(it) }
+}
+
+@JvmName("convertToInstantFromStringNullable")
+public fun DataColumn<String?>.convertToInstant(): DataColumn<Instant?> {
+    return map { it?.let { Instant.parse(it) } }
+}
+
+public fun <T, R : String?> Convert<T, R>.toInstant(): DataFrame<T> = to { it.convertToInstant() }
+
+// endregion
+
+// region toLocalDate
+
+@JvmName("convertToLocalDateFromLong")
+public fun DataColumn<Long>.convertToLocalDate(zone: TimeZone = defaultTimeZone): DataColumn<LocalDate> = map { it.toLocalDate(zone) }
+public fun DataColumn<Long?>.convertToLocalDate(zone: TimeZone = defaultTimeZone): DataColumn<LocalDate?> = map { it?.toLocalDate(zone) }
+
+@JvmName("convertToLocalDateFromInt")
+public fun DataColumn<Int>.convertToLocalDate(zone: TimeZone = defaultTimeZone): DataColumn<LocalDate> =
+    map { it.toLong().toLocalDate(zone) }
+@JvmName("convertToLocalDateFromIntNullable")
+public fun DataColumn<Int?>.convertToLocalDate(zone: TimeZone = defaultTimeZone): DataColumn<LocalDate?> =
+    map { it?.toLong()?.toLocalDate(zone) }
+
+@JvmName("convertToLocalDateFromString")
+public fun DataColumn<String>.convertToLocalDate(pattern: String? = null, locale: Locale? = null): DataColumn<LocalDate> {
+    val converter = Parsers.getDateTimeConverter(LocalDate::class, pattern, locale)
+    return map { converter(it.trim()) ?: error("Can't convert `$it` to LocalDate") }
+}
+@JvmName("convertToLocalDateFromStringNullable")
+public fun DataColumn<String?>.convertToLocalDate(pattern: String? = null, locale: Locale? = null): DataColumn<LocalDate?> {
+    val converter = Parsers.getDateTimeConverter(LocalDate::class, pattern, locale)
+    return map { it?.let { converter(it.trim()) ?: error("Can't convert `$it` to LocalDate") } }
+}
+
+@JvmName("toLocalDateFromTLong")
+public fun <T, R : Long?> Convert<T, R>.toLocalDate(zone: TimeZone = defaultTimeZone): DataFrame<T> = to { it.convertToLocalDate(zone) }
+@JvmName("toLocalDateFromTInt")
+public fun <T, R : Int?> Convert<T, R>.toLocalDate(zone: TimeZone = defaultTimeZone): DataFrame<T> = to { it.convertToLocalDate(zone) }
+
+public fun <T, R : String?> Convert<T, R>.toLocalDate(pattern: String? = null, locale: Locale? = null): DataFrame<T> = to { it.convertToLocalDate(pattern, locale) }
+
+public fun <T> Convert<T, *>.toLocalDate(): DataFrame<T> = to { it.convertTo<LocalDate>() }
+
+// endregion
+
+// region toLocalTime
+
+@JvmName("convertToLocalTimeFromLong")
+public fun DataColumn<Long>.convertToLocalTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalTime> = map { it.toLocalTime(zone) }
+public fun DataColumn<Long?>.convertToLocalTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalTime?> = map { it?.toLocalTime(zone) }
+
+@JvmName("convertToLocalTimeFromInt")
+public fun DataColumn<Int>.convertToLocalTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalTime> =
+    map { it.toLong().toLocalTime(zone) }
+@JvmName("convertToLocalTimeIntNullable")
+public fun DataColumn<Int?>.convertToLocalTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalTime?> =
+    map { it?.toLong()?.toLocalTime(zone) }
+
+@JvmName("convertToLocalTimeFromString")
+public fun DataColumn<String>.convertToLocalTime(pattern: String? = null, locale: Locale? = null): DataColumn<LocalTime> {
+    val converter = Parsers.getDateTimeConverter(LocalTime::class, pattern, locale)
+    return map { converter(it.trim()) ?: error("Can't convert `$it` to LocalTime") }
+}
+@JvmName("convertToLocalTimeFromStringNullable")
+public fun DataColumn<String?>.convertToLocalTime(pattern: String? = null, locale: Locale? = null): DataColumn<LocalTime?> {
+    val converter = Parsers.getDateTimeConverter(LocalTime::class, pattern, locale)
+    return map { it?.let { converter(it.trim()) ?: error("Can't convert `$it` to LocalTime") } }
+}
+
+@JvmName("toLocalTimeFromTLong")
+public fun <T, R : Long?> Convert<T, R>.toLocalTime(zone: TimeZone = defaultTimeZone): DataFrame<T> = to { it.convertToLocalTime(zone) }
+@JvmName("toLocalTimeFromTInt")
+public fun <T, R : Int?> Convert<T, R>.toLocalTime(zone: TimeZone = defaultTimeZone): DataFrame<T> = to { it.convertToLocalTime(zone) }
+
+public fun <T, R : String?> Convert<T, R>.toLocalTime(pattern: String? = null, locale: Locale? = null): DataFrame<T> = to { it.convertToLocalTime(pattern, locale) }
+
+public fun <T> Convert<T, *>.toLocalTime(): DataFrame<T> = to { it.convertTo<LocalTime>() }
+
+// endregion
+
+// region toLocalDateTime
+
+@JvmName("convertToLocalDateTimeFromLong")
+public fun DataColumn<Long>.convertToLocalDateTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalDateTime> = map { it.toLocalDateTime(zone) }
+public fun DataColumn<Long?>.convertToLocalDateTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalDateTime?> = map { it?.toLocalDateTime(zone) }
+
+@JvmName("convertToLocalDateTimeFromInstant")
+public fun DataColumn<Instant>.convertToLocalDateTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalDateTime> =
+    map { it.toLocalDateTime(zone) }
+@JvmName("convertToLocalDateTimeFromInstantNullable")
+public fun DataColumn<Instant?>.convertToLocalDateTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalDateTime?> =
+    map { it?.toLocalDateTime(zone) }
+
+@JvmName("convertToLocalDateTimeFromInt")
+public fun DataColumn<Int>.convertToLocalDateTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalDateTime> =
+    map { it.toLong().toLocalDateTime(zone) }
+@JvmName("convertToLocalDateTimeFromIntNullable")
+public fun DataColumn<Int?>.convertToLocalDateTime(zone: TimeZone = defaultTimeZone): DataColumn<LocalDateTime?> =
+    map { it?.toLong()?.toLocalDateTime(zone) }
+
+@JvmName("convertToLocalDateTimeFromString")
+public fun DataColumn<String>.convertToLocalDateTime(pattern: String? = null, locale: Locale? = null): DataColumn<LocalDateTime> {
+    val converter = Parsers.getDateTimeConverter(LocalDateTime::class, pattern, locale)
+    return map { converter(it.trim()) ?: error("Can't convert `$it` to LocalDateTime") }
+}
+@JvmName("convertToLocalDateTimeFromStringNullable")
+public fun DataColumn<String?>.convertToLocalDateTime(pattern: String? = null, locale: Locale? = null): DataColumn<LocalDateTime?> {
+    val converter = Parsers.getDateTimeConverter(LocalDateTime::class, pattern, locale)
+    return map { it?.let { converter(it.trim()) ?: error("Can't convert `$it` to LocalDateTime") } }
+}
+
+@JvmName("toLocalDateTimeFromTLong")
+public fun <T, R : Long?> Convert<T, R>.toLocalDateTime(zone: TimeZone = defaultTimeZone): DataFrame<T> = to { it.convertToLocalDateTime(zone) }
+
+@JvmName("toLocalDateTimeFromTInstant")
+public fun <T, R : Instant?> Convert<T, R>.toLocalDateTime(zone: TimeZone = defaultTimeZone): DataFrame<T> = to { it.convertToLocalDateTime(zone) }
+
+@JvmName("toLocalDateTimeFromTInt")
+public fun <T, R : Int?> Convert<T, R>.toLocalDateTime(zone: TimeZone = defaultTimeZone): DataFrame<T> = to { it.convertToLocalDateTime(zone) }
+
+public fun <T, R : String?> Convert<T, R>.toLocalDateTime(pattern: String? = null, locale: Locale? = null): DataFrame<T> = to { it.convertToLocalDateTime(pattern, locale) }
+
+public fun <T> Convert<T, *>.toLocalDateTime(): DataFrame<T> = to { it.convertTo<LocalDateTime>() }
+
+// endregion
+
+@JvmName("toIntTAny")
+public fun <T> Convert<T, Any>.toInt(): DataFrame<T> = to<Int>()
+public fun <T> Convert<T, Any?>.toInt(): DataFrame<T> = to<Int?>()
+
+@JvmName("toLongTAny")
+public fun <T> Convert<T, Any>.toLong(): DataFrame<T> = to<Long>()
+public fun <T> Convert<T, Any?>.toLong(): DataFrame<T> = to<Long?>()
+
+@JvmName("toStrTAny")
+public fun <T> Convert<T, Any>.toStr(): DataFrame<T> = to<String>()
+public fun <T> Convert<T, Any?>.toStr(): DataFrame<T> = to<String?>()
+
+@JvmName("toDoubleTAny")
+public fun <T> Convert<T, Any>.toDouble(): DataFrame<T> = to<Double>()
+public fun <T> Convert<T, Any?>.toDouble(): DataFrame<T> = to<Double?>()
+
+@JvmName("toFloatTAny")
+public fun <T> Convert<T, Any>.toFloat(): DataFrame<T> = to<Float>()
+public fun <T> Convert<T, Any?>.toFloat(): DataFrame<T> = to<Float?>()
+
+@JvmName("toBigDecimalTAny")
+public fun <T> Convert<T, Any>.toBigDecimal(): DataFrame<T> = to<BigDecimal>()
+public fun <T> Convert<T, Any?>.toBigDecimal(): DataFrame<T> = to<BigDecimal?>()
+
+@JvmName("toBooleanTAny")
+public fun <T> Convert<T, Any>.toBoolean(): DataFrame<T> = to<Boolean>()
+public fun <T> Convert<T, Any?>.toBoolean(): DataFrame<T> = to<Boolean?>()
+
+public fun <T, C> Convert<T, List<List<C>>>.toDataFrames(containsColumns: Boolean = false): DataFrame<T> =
+    to { it.toDataFrames(containsColumns) }
+
+public fun <T> DataColumn<List<List<T>>>.toDataFrames(containsColumns: Boolean = false): DataColumn<AnyFrame> =
+    map { it.toDataFrame(containsColumns) }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convertTo.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convertTo.kt
new file mode 100644
index 000000000..99f64b4d7
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convertTo.kt
@@ -0,0 +1,200 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.exceptions.ColumnNotFoundException
+import org.jetbrains.kotlinx.dataframe.exceptions.ExcessiveColumnsException
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConversionException
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConverterNotFoundException
+import org.jetbrains.kotlinx.dataframe.impl.api.ConvertSchemaDslInternal
+import org.jetbrains.kotlinx.dataframe.impl.api.convertToImpl
+import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+/**
+ * Specifies how to handle columns in original dataframe that were not mathced to any column in destination dataframe schema.
+ */
+public enum class ExcessiveColumns {
+    /**
+     * Remove excessive columns from resulting dataframe
+     */
+    Remove,
+
+    /**
+     * Keep excessive columns in resulting dataframe
+     */
+    Keep,
+
+    /**
+     * Throw [ExcessiveColumnsException] if any excessive columns were found in the original dataframe
+     */
+    Fail
+}
+
+/**
+ * Holds data context for [fill] operation
+ */
+public data class ConvertToFill<T, C>(
+    internal val dsl: ConvertSchemaDsl<T>,
+    val columns: ColumnsSelector<T, C>
+)
+
+/** Provides access to [fromType] and [toSchema] in the flexible [ConvertSchemaDsl.convertIf] method. */
+public class ConverterScope(public val fromType: KType, public val toSchema: ColumnSchema)
+
+/**
+ * Dsl to customize column conversion
+ *
+ * Example:
+ * ```kotlin
+ * df.convertTo<SomeSchema> {
+ *     // defines how to convert Int? -> String
+ *     convert<Int?>().with { it?.toString() ?: "No input given" }
+ *     // defines how to convert String -> SomeType
+ *     parser { SomeType(it) }
+ *     // fill missing column `sum` with expression `a+b`
+ *     fill { sum }.with { a + b }
+ * }
+ * ```
+ */
+public interface ConvertSchemaDsl<in T> {
+
+    /**
+     * Defines how to convert [from]: [A] to [to]: [B].
+     *
+     * Note: In most cases using `convert<Type>().with { }` is more convenient, however
+     * if you only have [KType], this method can be used.
+     */
+    public fun <A, B> convert(from: KType, to: KType, converter: (A) -> B)
+
+    /**
+     * Advanced version of [convert].
+     * If you want to define a common conversion for multiple types (or any type), or
+     * you need extra information about the target, such as its schema, use this method.
+     *
+     * The exact type conversion does have higher priority. After that, this flexible conversions will be checked
+     * in order.
+     *
+     * @param condition a function that should return `true` if the conversion should be applied from the given `fromType`
+     *   to the given `toSchema`.
+     * @param converter a function that performs the conversion with access to a [ConverterScope].
+     */
+    public fun convertIf(
+        condition: (fromType: KType, toSchema: ColumnSchema) -> Boolean,
+        converter: ConverterScope.(Any?) -> Any?,
+    )
+}
+
+/**
+ * Defines how to fill specified columns in destination schema that were not found in original dataframe.
+ * All [fill] operations for missing columns are executed after successful conversion of matched columns, so converted values of matched columns can be safely used in [with] expression.
+ * @param columns target columns in destination dataframe schema to be filled
+ */
+public inline fun <T, reified C> ConvertSchemaDsl<T>.fill(noinline columns: ColumnsSelector<T, C>): ConvertToFill<T, C> = ConvertToFill(this, columns)
+
+public fun <T, C> ConvertToFill<T, C>.with(expr: RowExpression<T, C>) {
+    (dsl as ConvertSchemaDslInternal<T>).fill(columns as ColumnsSelector<*, C>, expr as RowExpression<*, C>)
+}
+
+/**
+ * Defines how to convert `String` values into given type [C].
+ */
+public inline fun <reified C> ConvertSchemaDsl<*>.parser(noinline parser: (String) -> C): Unit =
+    convert<String>().with(parser)
+
+/**
+ * Defines how to convert values of given type [C]
+ */
+public inline fun <reified C> ConvertSchemaDsl<*>.convert(): ConvertType<C> = ConvertType(this, typeOf<C>())
+
+/**
+ * Defines how to convert values of type [C] into type [R]
+ */
+public inline fun <C, reified R> ConvertType<C>.with(noinline converter: (C) -> R): Unit =
+    dsl.convert(from, typeOf<R>(), converter)
+
+public class ConvertType<T>(
+    @PublishedApi internal val dsl: ConvertSchemaDsl<*>,
+    @PublishedApi internal val from: KType,
+    internal val property: KProperty<T>? = null,
+)
+
+// region DataFrame
+
+/**
+ * Converts values in [DataFrame] to match given column schema [T].
+ *
+ * Original columns are mapped to destination columns by column [path][DataColumn.path].
+ *
+ * Type converters for every column are selected automatically. See [convert] operation for details.
+ *
+ * To specify custom type converters for the particular types use [ConvertSchemaDsl].
+ *
+ * Example of Dsl:
+ * ```kotlin
+ * df.convertTo<SomeSchema> {
+ *     // defines how to convert Int? -> String
+ *     convert<Int?>().with { it?.toString() ?: "No input given" }
+ *     // defines how to convert String -> SomeType
+ *     parser { SomeType(it) }
+ *     // fill missing column `sum` with expression `a + b`
+ *     fill { sum }.with { a + b }
+ * }
+ * ```
+ *
+ * @param [T] class that defines target schema for conversion.
+ * @param [excessiveColumnsBehavior] how to handle excessive columns in the original [DataFrame].
+ * @param [body] optional dsl to define custom type converters.
+ * @throws [ColumnNotFoundException] if [DataFrame] doesn't contain columns that are required by destination schema.
+ * @throws [ExcessiveColumnsException] if [DataFrame] contains columns that are not required by destination schema and [excessiveColumnsBehavior] is set to [ExcessiveColumns.Fail].
+ * @throws [TypeConverterNotFoundException] if suitable type converter for some column was not found.
+ * @throws [TypeConversionException] if type converter failed to convert column values.
+ * @return converted [DataFrame].
+ */
+public inline fun <reified T : Any> AnyFrame.convertTo(
+    excessiveColumnsBehavior: ExcessiveColumns = ExcessiveColumns.Keep,
+    noinline body: ConvertSchemaDsl<T>.() -> Unit = {}
+): DataFrame<T> = convertToImpl(typeOf<T>(), true, excessiveColumnsBehavior, body).cast()
+
+/**
+ * Converts values in [DataFrame] to match given column schema [schemaType].
+ *
+ * Original columns are mapped to destination columns by column [path][DataColumn.path].
+ *
+ * Type converters for every column are selected automatically. See [convert] operation for details.
+ *
+ * To specify custom type converters for the particular types use [ConvertSchemaDsl].
+ *
+ * Example of Dsl:
+ * ```kotlin
+ * df.convertTo<SomeSchema> {
+ *     // defines how to convert Int? -> String
+ *     convert<Int?>().with { it?.toString() ?: "No input given" }
+ *     // defines how to convert String -> SomeType
+ *     parser { SomeType(it) }
+ *     // fill missing column `sum` with expression `a+b`
+ *     fill { sum }.with { a + b }
+ * }
+ * ```
+ *
+ * @param [schemaType] defines target schema for conversion.
+ * @param [excessiveColumnsBehavior] how to handle excessive columns in the original [DataFrame].
+ * @param [body] optional dsl to define custom type converters.
+ * @throws [ColumnNotFoundException] if [DataFrame] doesn't contain columns that are required by destination schema.
+ * @throws [ExcessiveColumnsException] if [DataFrame] contains columns that are not required by destination schema and [excessiveColumnsBehavior] is set to [ExcessiveColumns.Fail].
+ * @throws [TypeConverterNotFoundException] if suitable type converter for some column was not found.
+ * @throws [TypeConversionException] if type converter failed to convert column values.
+ * @return converted [DataFrame].
+ */
+public fun AnyFrame.convertTo(
+    schemaType: KType,
+    excessiveColumnsBehavior: ExcessiveColumns = ExcessiveColumns.Keep,
+    body: ConvertSchemaDsl<Any>.() -> Unit = {},
+): AnyFrame = convertToImpl(schemaType, true, excessiveColumnsBehavior, body)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/copy.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/copy.kt
new file mode 100644
index 000000000..c0c930a03
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/copy.kt
@@ -0,0 +1,9 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.copy(): DataFrame<T> = columns().toDataFrame().cast()
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt
new file mode 100644
index 000000000..85126780c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt
@@ -0,0 +1,35 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.api.corrImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import kotlin.reflect.KProperty
+import kotlin.reflect.typeOf
+
+internal fun AnyCol.isSuitableForCorr() = isSubtypeOf<Number>() || type() == typeOf<Boolean>()
+
+// region DataFrame
+
+public data class Corr<T, C>(
+    internal val df: DataFrame<T>,
+    internal val columns: ColumnsSelector<T, C>
+)
+
+public fun <T> DataFrame<T>.corr(): DataFrame<T> = corr { dfs { it.isSuitableForCorr() } }.withItself()
+
+public fun <T, C> DataFrame<T>.corr(columns: ColumnsSelector<T, C>): Corr<T, C> = Corr(this, columns)
+public fun <T> DataFrame<T>.corr(vararg columns: String): Corr<T, Any?> = corr { columns.toColumns() }
+public fun <T, C> DataFrame<T>.corr(vararg columns: KProperty<C>): Corr<T, C> = corr { columns.toColumns() }
+public fun <T, C> DataFrame<T>.corr(vararg columns: ColumnReference<C>): Corr<T, C> = corr { columns.toColumns() }
+
+public fun <T, C, R> Corr<T, C>.with(otherColumns: ColumnsSelector<T, R>): DataFrame<T> = corrImpl(otherColumns)
+public fun <T, C> Corr<T, C>.with(vararg otherColumns: String): DataFrame<T> = with { otherColumns.toColumns() }
+public fun <T, C, R> Corr<T, C>.with(vararg otherColumns: KProperty<R>): DataFrame<T> = with { otherColumns.toColumns() }
+public fun <T, C, R> Corr<T, C>.with(vararg otherColumns: ColumnReference<R>): DataFrame<T> = with { otherColumns.toColumns() }
+
+public fun <T, C> Corr<T, C>.withItself(): DataFrame<T> = with(columns)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/count.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/count.kt
new file mode 100644
index 000000000..55a5fb0a1
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/count.kt
@@ -0,0 +1,54 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.Predicate
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateValue
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.count(predicate: Predicate<T>? = null): Int = if (predicate == null) size() else values().count(predicate)
+
+// endregion
+
+// region DataRow
+
+public fun AnyRow.count(): Int = columnsCount()
+public fun AnyRow.count(predicate: Predicate<Any?>): Int = values().count(predicate)
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.count(): Int = rowsCount()
+
+public fun <T> DataFrame<T>.count(predicate: RowFilter<T>): Int = rows().count { predicate(it, it) }
+
+// endregion
+
+// region GroupBy
+
+public fun <T> Grouped<T>.count(resultName: String = "count"): DataFrame<T> =
+    aggregateValue(resultName) { count() default 0 }
+
+public fun <T> Grouped<T>.count(resultName: String = "count", predicate: RowFilter<T>): DataFrame<T> =
+    aggregateValue(resultName) { count(predicate) default 0 }
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.count(): DataRow<T> = delegate { count() }
+public fun <T> Pivot<T>.count(predicate: RowFilter<T>): DataRow<T> = delegate { count(predicate) }
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.count(): DataFrame<T> = aggregate { count() default 0 }
+public fun <T> PivotGroupBy<T>.count(predicate: RowFilter<T>): DataFrame<T> = aggregate { count(predicate) default 0 }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
new file mode 100644
index 000000000..37cfdb6c9
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
@@ -0,0 +1,24 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.indices
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+public fun AnyFrame.countDistinct(): Int = countDistinct { all() }
+
+public fun <T, C> DataFrame<T>.countDistinct(columns: ColumnsSelector<T, C>): Int {
+    val cols = get(columns)
+    return indices.distinctBy { i -> cols.map { it[i] } }.size
+}
+
+public fun <T> DataFrame<T>.countDistinct(vararg columns: String): Int = countDistinct { columns.toColumns() }
+public fun <T, C> DataFrame<T>.countDistinct(vararg columns: KProperty<C>): Int = countDistinct { columns.toColumns() }
+public fun <T> DataFrame<T>.countDistinct(vararg columns: Column): Int = countDistinct { columns.toColumns() }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt
new file mode 100644
index 000000000..be60508cd
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt
@@ -0,0 +1,57 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.math.cumSum
+import org.jetbrains.kotlinx.dataframe.math.defaultCumSumSkipNA
+import org.jetbrains.kotlinx.dataframe.typeClass
+import java.math.BigDecimal
+import kotlin.reflect.KProperty
+import kotlin.reflect.typeOf
+
+// region DataColumn
+
+public fun <T : Number?> DataColumn<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<T> = when (type()) {
+    typeOf<Double>() -> cast<Double>().cumSum(skipNA).cast()
+    typeOf<Double?>() -> cast<Double?>().cumSum(skipNA).cast()
+    typeOf<Float>() -> cast<Float>().cumSum(skipNA).cast()
+    typeOf<Float?>() -> cast<Float?>().cumSum(skipNA).cast()
+    typeOf<Int>() -> cast<Int>().cumSum().cast()
+    typeOf<Int?>() -> cast<Int?>().cumSum(skipNA).cast()
+    typeOf<Long>() -> cast<Long>().cumSum().cast()
+    typeOf<Long?>() -> cast<Long?>().cumSum(skipNA).cast()
+    typeOf<BigDecimal>() -> cast<BigDecimal>().cumSum().cast()
+    typeOf<BigDecimal?>() -> cast<BigDecimal?>().cumSum(skipNA).cast()
+    typeOf<Number?>(), typeOf<Number>() -> convertToDouble().cumSum(skipNA).cast()
+    else -> error("Cumsum for type ${type()} is not supported")
+}
+
+private val supportedClasses = setOf(Double::class, Float::class, Int::class, Long::class, BigDecimal::class)
+
+// endregion
+
+// region DataFrame
+
+public fun <T, C> DataFrame<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA, columns: ColumnsSelector<T, C>): DataFrame<T> =
+    convert(columns).to { if (it.typeClass in supportedClasses) it.cast<Number?>().cumSum(skipNA) else it }
+public fun <T> DataFrame<T>.cumSum(vararg columns: String, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) { columns.toColumns() }
+public fun <T> DataFrame<T>.cumSum(vararg columns: Column, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) { columns.toColumns() }
+public fun <T> DataFrame<T>.cumSum(vararg columns: KProperty<*>, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) { columns.toColumns() }
+
+public fun <T> DataFrame<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) { allDfs() }
+
+// endregion
+
+// region GroupBy
+
+public fun <T, G, C> GroupBy<T, G>.cumSum(skipNA: Boolean = defaultCumSumSkipNA, columns: ColumnsSelector<G, C>): GroupBy<T, G> =
+    updateGroups { cumSum(skipNA, columns) }
+public fun <T, G> GroupBy<T, G>.cumSum(vararg columns: String, skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> = cumSum(skipNA) { columns.toColumns() }
+public fun <T, G> GroupBy<T, G>.cumSum(vararg columns: Column, skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> = cumSum(skipNA) { columns.toColumns() }
+public fun <T, G> GroupBy<T, G>.cumSum(vararg columns: KProperty<*>, skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> = cumSum(skipNA) { columns.toColumns() }
+public fun <T, G> GroupBy<T, G>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> = cumSum(skipNA) { allDfs() }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt
new file mode 100644
index 000000000..9c236c02d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt
@@ -0,0 +1,48 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.api.describeImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+
+// region DataSchema
+@DataSchema
+public interface ColumnDescription {
+    public val name: String
+    public val path: ColumnPath
+    public val type: KType
+    public val count: Int
+    public val unique: Int
+    public val nulls: Int
+    public val top: Any
+    public val freq: Int
+    public val mean: Double
+    public val std: Double
+    public val min: Any
+    public val median: Any
+    public val max: Any
+}
+
+// endregion
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.describe(): DataFrame<ColumnDescription> = describeImpl(listOf(this))
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.describe(): DataFrame<ColumnDescription> = describe { allDfs() }
+public fun <T> DataFrame<T>.describe(columns: ColumnsSelector<T, *>): DataFrame<ColumnDescription> = describeImpl(getColumnsWithPaths(columns))
+public fun <T> DataFrame<T>.describe(vararg columns: String): DataFrame<ColumnDescription> = describe { columns.toColumns() }
+public fun <T, C : Number?> DataFrame<T>.describe(vararg columns: ColumnReference<C>): DataFrame<ColumnDescription> = describe { columns.toColumns() }
+public fun <T, C : Number?> DataFrame<T>.describe(vararg columns: KProperty<C>): DataFrame<ColumnDescription> = describe { columns.toColumns() }
+
+// endregion
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
new file mode 100644
index 000000000..4d7834af6
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/digitize.kt
@@ -0,0 +1,29 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import kotlin.reflect.KClass
+
+// region DataColumn
+
+public fun DataColumn<Double>.digitize(vararg bins: Int, right: Boolean = false): DataColumn<Int> = digitize(bins.toList(), Double::class, right)
+
+public fun <T : Comparable<T>> DataColumn<T>.digitize(vararg bins: T, right: Boolean = false): DataColumn<Int> = digitize(bins.toList(), right)
+
+public fun <T : Comparable<T>> DataColumn<T>.digitize(bins: List<Int>, kclass: KClass<T>, right: Boolean = false): DataColumn<Int> = digitize(
+    bins.toList().map { org.jetbrains.kotlinx.dataframe.impl.convert(it, kclass) },
+    right
+)
+
+public fun <T : Comparable<T>> DataColumn<T>.digitize(bins: List<T>, right: Boolean = false): DataColumn<Int> {
+    // TODO: use binary search
+    // TODO: support descending order of bins
+    val predicate: (T, T) -> Boolean = if (right) { value, bin -> value <= bin } else { value, bin -> value < bin }
+
+    return map { value ->
+        val index = bins.indexOfFirst { predicate(value, it) }
+        if (index == -1) bins.size
+        else index
+    }
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt
new file mode 100644
index 000000000..c0c072c33
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt
@@ -0,0 +1,41 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.indices
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.distinct(): DataFrame<T> = distinctBy { all() }
+
+public fun <T, C> DataFrame<T>.distinct(columns: ColumnsSelector<T, C>): DataFrame<T> = select(columns).distinct()
+public fun <T> DataFrame<T>.distinct(vararg columns: KProperty<*>): DataFrame<T> = distinct {
+    val set = columns.toColumns()
+    set
+}
+public fun <T> DataFrame<T>.distinct(vararg columns: String): DataFrame<T> = distinct { columns.toColumns() }
+public fun <T> DataFrame<T>.distinct(vararg columns: Column): DataFrame<T> = distinct { columns.toColumns() }
+
+@JvmName("distinctT")
+public fun <T> DataFrame<T>.distinct(columns: Iterable<String>): DataFrame<T> = distinct { columns.toColumns() }
+public fun <T> DataFrame<T>.distinct(columns: Iterable<Column>): DataFrame<T> = distinct { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.distinctBy(vararg columns: KProperty<*>): DataFrame<T> = distinctBy { columns.toColumns() }
+public fun <T> DataFrame<T>.distinctBy(vararg columns: String): DataFrame<T> = distinctBy { columns.toColumns() }
+public fun <T> DataFrame<T>.distinctBy(vararg columns: Column): DataFrame<T> = distinctBy { columns.toColumns() }
+
+@JvmName("distinctByT")
+public fun <T> DataFrame<T>.distinctBy(columns: Iterable<String>): DataFrame<T> = distinctBy { columns.toColumns() }
+public fun <T> DataFrame<T>.distinctBy(columns: Iterable<Column>): DataFrame<T> = distinctBy { columns.toColumnSet() }
+
+public fun <T, C> DataFrame<T>.distinctBy(columns: ColumnsSelector<T, C>): DataFrame<T> {
+    val cols = get(columns)
+    val distinctIndices = indices.distinctBy { i -> cols.map { it[i] } }
+    return this[distinctIndices]
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/drop.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/drop.kt
new file mode 100644
index 000000000..24791cf2b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/drop.kt
@@ -0,0 +1,57 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.Predicate
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.nrow
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.drop(predicate: Predicate<T>): DataColumn<T> = filter { !predicate(it) }
+
+public fun <T> DataColumn<T>.drop(n: Int): DataColumn<T> = when {
+    n == 0 -> this
+    n >= size -> get(emptyList())
+    else -> get(n until size)
+}
+
+public fun <T> DataColumn<T>.dropLast(n: Int = 1): DataColumn<T> = take(size - n)
+
+// endregion
+
+// region DataFrame
+
+/**
+ * Returns a DataFrame containing all rows except first [n] rows.
+ *
+ * @throws IllegalArgumentException if [n] is negative.
+ */
+public fun <T> DataFrame<T>.drop(n: Int): DataFrame<T> {
+    require(n >= 0) { "Requested rows count $n is less than zero." }
+    return getRows(n.coerceAtMost(nrow) until nrow)
+}
+
+/**
+ * Returns a DataFrame containing all rows except last [n] rows.
+ *
+ * @throws IllegalArgumentException if [n] is negative.
+ */
+public fun <T> DataFrame<T>.dropLast(n: Int = 1): DataFrame<T> {
+    require(n >= 0) { "Requested rows count $n is less than zero." }
+    return take((nrow - n).coerceAtLeast(0))
+}
+
+/**
+ * Returns a DataFrame containing all rows except rows that satisfy the given [predicate].
+ */
+public fun <T> DataFrame<T>.drop(predicate: RowFilter<T>): DataFrame<T> = filter { !predicate(it, it) }
+
+/**
+ * Returns a DataFrame containing all rows except first rows that satisfy the given [predicate].
+ */
+public fun <T> DataFrame<T>.dropWhile(predicate: RowFilter<T>): DataFrame<T> = firstOrNull { !predicate(it, it) }?.let { drop(it.index) } ?: this
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/duplicate.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/duplicate.kt
new file mode 100644
index 000000000..ab7bbda51
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/duplicate.kt
@@ -0,0 +1,18 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.api.duplicateImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.duplicateRowsImpl
+
+public fun <T> DataFrame<T>.duplicate(n: Int): FrameColumn<T> = List(n) { this }.toFrameColumn()
+
+public fun <T> DataFrame<T>.duplicateRows(n: Int): DataFrame<T> =
+    duplicateRowsImpl(n)
+
+public fun <T> DataFrame<T>.duplicateRows(n: Int, filter: RowFilter<T>): DataFrame<T> =
+    duplicateRowsImpl(n, rows().filter { filter(it, it) }.map { it.index() })
+
+public fun <T> DataRow<T>.duplicate(n: Int): DataFrame<T> = duplicateImpl(n)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/enum.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/enum.kt
new file mode 100644
index 000000000..76fbe6ca7
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/enum.kt
@@ -0,0 +1,11 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+/**
+ * Make your enum class inherit [DataSchemaEnum] to
+ * make String -> Enum and Enum -> String conversions work
+ * using [value] instead of the enum name.
+ * (Fallback to enum name if the value cannot be found is implemented)
+ */
+public interface DataSchemaEnum {
+    public val value: String
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt
new file mode 100644
index 000000000..b7f9514d5
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt
@@ -0,0 +1,59 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.api.explodeImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import kotlin.reflect.KProperty
+
+private val defaultExplodeColumns: ColumnsSelector<*, *> = { dfs { it.isList() || it.isFrameColumn() } }
+
+// region explode DataFrame
+
+public fun <T> DataFrame<T>.explode(
+    dropEmpty: Boolean = true,
+    selector: ColumnsSelector<T, *> = defaultExplodeColumns
+): DataFrame<T> = explodeImpl(dropEmpty, selector)
+
+public fun <T> DataFrame<T>.explode(vararg columns: String, dropEmpty: Boolean = true): DataFrame<T> =
+    explode(dropEmpty) { columns.toColumns() }
+
+public fun <T, C> DataFrame<T>.explode(vararg columns: ColumnReference<C>, dropEmpty: Boolean = true): DataFrame<T> =
+    explode(dropEmpty) { columns.toColumns() }
+
+public fun <T, C> DataFrame<T>.explode(vararg columns: KProperty<C>, dropEmpty: Boolean = true): DataFrame<T> =
+    explode(dropEmpty) { columns.toColumns() }
+
+// endregion
+
+// region explode DataRow
+
+public fun <T> DataRow<T>.explode(
+    dropEmpty: Boolean = true,
+    selector: ColumnsSelector<T, *> = defaultExplodeColumns
+): DataFrame<T> = toDataFrame().explode(dropEmpty, selector)
+
+public fun <T> DataRow<T>.explode(vararg columns: String, dropEmpty: Boolean = true): DataFrame<T> =
+    explode(dropEmpty) { columns.toColumns() }
+
+public fun <T, C> DataRow<T>.explode(vararg columns: ColumnReference<C>, dropEmpty: Boolean = true): DataFrame<T> =
+    explode(dropEmpty) { columns.toColumns() }
+
+public fun <T, C> DataRow<T>.explode(vararg columns: KProperty<C>, dropEmpty: Boolean = true): DataFrame<T> =
+    explode(dropEmpty) { columns.toColumns() }
+
+// endregion
+
+// region explode DataColumn
+
+@JvmName("explodeList")
+public fun <T> DataColumn<Collection<T>>.explode(): DataColumn<T> = explodeImpl() as DataColumn<T>
+
+@JvmName("explodeFrames")
+public fun <T> DataColumn<DataFrame<T>>.explode(): ColumnGroup<T> = concat().asColumnGroup(name())
+
+// endregion
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
new file mode 100644
index 000000000..ccf2e653e
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/filter.kt
@@ -0,0 +1,34 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.Predicate
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.toIndices
+import org.jetbrains.kotlinx.dataframe.indices
+import kotlin.reflect.KProperty
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.filter(predicate: Predicate<T>): DataColumn<T> = indices.filter {
+    predicate(get(it))
+}.let { get(it) }
+
+// endregion
+
+// 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) }
+
+public fun <T> DataFrame<T>.filterBy(column: ColumnSelector<T, Boolean>): DataFrame<T> = getRows(getColumn(column).toList().toIndices())
+public fun <T> DataFrame<T>.filterBy(column: ColumnReference<Boolean>): DataFrame<T> = filterBy { column }
+public fun <T> DataFrame<T>.filterBy(column: String): DataFrame<T> = filterBy { column.toColumnOf() }
+public fun <T> DataFrame<T>.filterBy(column: KProperty<Boolean>): DataFrame<T> = filterBy { column.toColumnAccessor() }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/first.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/first.kt
new file mode 100644
index 000000000..7c5154ff5
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/first.kt
@@ -0,0 +1,57 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.nrow
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.first(): T = get(0)
+public fun <T> DataColumn<T>.firstOrNull(): T? = if (size > 0) first() else null
+public fun <T> DataColumn<T>.first(predicate: (T) -> Boolean): T = values.first(predicate)
+public fun <T> DataColumn<T>.firstOrNull(predicate: (T) -> Boolean): T? = values.firstOrNull(predicate)
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.first(): DataRow<T> {
+    if (nrow == 0) {
+        throw NoSuchElementException("DataFrame has no rows. Use `firstOrNull`.")
+    }
+    return get(0)
+}
+public fun <T> DataFrame<T>.firstOrNull(): DataRow<T>? = if (nrow > 0) first() else null
+
+public fun <T> DataFrame<T>.first(predicate: RowFilter<T>): DataRow<T> = rows().first { predicate(it, it) }
+public fun <T> DataFrame<T>.firstOrNull(predicate: RowFilter<T>): DataRow<T>? = rows().firstOrNull { predicate(it, it) }
+
+// endregion
+
+// region GroupBy
+
+public fun <T, G> GroupBy<T, G>.first(): ReducedGroupBy<T, G> = reduce { firstOrNull() }
+
+public fun <T, G> GroupBy<T, G>.first(predicate: RowFilter<G>): ReducedGroupBy<T, G> = reduce { firstOrNull(predicate) }
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.first(): ReducedPivot<T> = reduce { firstOrNull() }
+
+public fun <T> Pivot<T>.first(predicate: RowFilter<T>): ReducedPivot<T> = reduce { firstOrNull(predicate) }
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.first(): ReducedPivotGroupBy<T> = reduce { firstOrNull() }
+
+public fun <T> PivotGroupBy<T>.first(predicate: RowFilter<T>): ReducedPivotGroupBy<T> = reduce { firstOrNull(predicate) }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/flatten.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/flatten.kt
new file mode 100644
index 000000000..7d83957bb
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/flatten.kt
@@ -0,0 +1,15 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.impl.api.flattenImpl
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.flatten(): DataFrame<T> = flatten { all() }
+
+public fun <T, C> DataFrame<T>.flatten(
+    columns: ColumnsSelector<T, C>
+): DataFrame<T> = flattenImpl(columns)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/forEach.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/forEach.kt
new file mode 100644
index 000000000..9e5ec62a7
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/forEach.kt
@@ -0,0 +1,29 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.columns.values
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.forEach(action: (T) -> Unit): Unit = values.forEach(action)
+
+public fun <T> DataColumn<T>.forEachIndexed(action: (Int, T) -> Unit): Unit = values.forEachIndexed(action)
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.forEach(action: RowExpression<T, Unit>): Unit = rows().forEach { action(it, it) }
+
+// endregion
+
+// region GroupBy
+
+public fun <T, G> GroupBy<T, G>.forEach(body: (GroupBy.Entry<T, G>) -> Unit): Unit = keys.forEach { key ->
+    val group = groups[key.index()]
+    body(GroupBy.Entry(key, group))
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/format.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/format.kt
new file mode 100644
index 000000000..316fc7872
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/format.kt
@@ -0,0 +1,118 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowValueFilter
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.api.MergedAttributes
+import org.jetbrains.kotlinx.dataframe.impl.api.SingleAttribute
+import org.jetbrains.kotlinx.dataframe.impl.api.encode
+import org.jetbrains.kotlinx.dataframe.impl.api.formatImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.linearGradient
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+import org.jetbrains.kotlinx.dataframe.io.toHTML
+import org.jetbrains.kotlinx.jupyter.api.HtmlData
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+public fun <T, C> DataFrame<T>.format(columns: ColumnsSelector<T, C>): FormatClause<T, C> = FormatClause(this, columns)
+public fun <T> DataFrame<T>.format(vararg columns: String): FormatClause<T, Any?> = format { columns.toColumns() }
+public fun <T, C> DataFrame<T>.format(vararg columns: ColumnReference<C>): FormatClause<T, C> = format { columns.toColumns() }
+public fun <T, C> DataFrame<T>.format(vararg columns: KProperty<C>): FormatClause<T, C> = format { columns.toColumns() }
+
+public fun <T, C> FormatClause<T, C>.perRowCol(formatter: RowColFormatter<T, C>): FormattedFrame<T> = formatImpl(formatter)
+
+public fun <T, C> FormatClause<T, C>.with(formatter: CellFormatter<C>): FormattedFrame<T> = formatImpl { row, col -> formatter(row[col]) }
+public fun <T, C> FormatClause<T, C>.where(filter: RowValueFilter<T, C>): FormatClause<T, C> = copy(filter = filter)
+
+public fun <T> DataFrame<T>.format(): FormatClause<T, Any?> = FormatClause(this)
+public fun <T> FormattedFrame<T>.format(): FormatClause<T, Any?> = FormatClause(df, null, formatter)
+
+// endregion
+
+public data class RGBColor(val r: Short, val g: Short, val b: Short)
+
+public interface CellAttributes {
+
+    public fun attributes(): List<Pair<String, String>>
+}
+
+public infix fun CellAttributes?.and(other: CellAttributes?): CellAttributes? = when {
+    other == null -> this
+    this == null -> other
+    else -> MergedAttributes(listOf(this, other))
+}
+
+public object FormattingDSL {
+
+    public fun rgb(r: Short, g: Short, b: Short): RGBColor = RGBColor(r, g, b)
+
+    public val black: RGBColor = rgb(0, 0, 0)
+    public val white: RGBColor = rgb(255, 255, 255)
+    public val green: RGBColor = rgb(0, 255, 0)
+    public val red: RGBColor = rgb(255, 0, 0)
+    public val blue: RGBColor = rgb(0, 0, 255)
+    public val gray: RGBColor = rgb(128, 128, 128)
+    public val darkGray: RGBColor = rgb(169, 169, 169)
+    public val lightGray: RGBColor = rgb(211, 211, 211)
+
+    public fun attr(name: String, value: String): CellAttributes = SingleAttribute(name, value)
+
+    public fun background(color: RGBColor): CellAttributes = attr("background-color", color.encode())
+    public fun background(r: Short, g: Short, b: Short): CellAttributes = background(RGBColor(r, g, b))
+
+    public fun textColor(color: RGBColor): CellAttributes = attr("color", color.encode())
+    public fun textColor(r: Short, g: Short, b: Short): CellAttributes = textColor(RGBColor(r, g, b))
+
+    public val italic: CellAttributes = attr("font-style", "italic")
+
+    public val bold: CellAttributes = attr("font-weight", "bold")
+
+    public val underline: CellAttributes = attr("text-decoration", "underline")
+
+    public fun linearBg(value: Number, from: Pair<Number, RGBColor>, to: Pair<Number, RGBColor>): CellAttributes = background(
+        linear(value, from, to)
+    )
+
+    public fun linear(value: Number, from: Pair<Number, RGBColor>, to: Pair<Number, RGBColor>): RGBColor {
+        val a = from.first.toDouble()
+        val b = to.first.toDouble()
+        if (a < b) return linearGradient(value.toDouble(), a, from.second, b, to.second)
+        return linearGradient(value.toDouble(), b, to.second, a, from.second)
+    }
+}
+
+public typealias RowColFormatter<T, C> = FormattingDSL.(DataRow<T>, DataColumn<C>) -> CellAttributes?
+
+public class FormattedFrame<T>(
+    internal val df: DataFrame<T>,
+    internal val formatter: RowColFormatter<T, *>? = null,
+) {
+    public fun toHTML(configuration: DisplayConfiguration): HtmlData = df.toHTML(getDisplayConfiguration(configuration))
+
+    public fun getDisplayConfiguration(configuration: DisplayConfiguration): DisplayConfiguration {
+        return configuration.copy(cellFormatter = formatter as RowColFormatter<*, *>?)
+    }
+}
+
+public data class FormatClause<T, C>(
+    val df: DataFrame<T>,
+    val columns: ColumnsSelector<T, C>? = null,
+    val oldFormatter: RowColFormatter<T, C>? = null,
+    val filter: RowValueFilter<T, C> = { true },
+)
+
+public fun <T, C> FormattedFrame<T>.format(columns: ColumnsSelector<T, C>): FormatClause<T, C> = FormatClause(df, columns, formatter)
+
+public typealias CellFormatter<V> = FormattingDSL.(V) -> CellAttributes?
+
+public fun <T, C : Number?> FormatClause<T, C>.linearBg(from: Pair<Number, RGBColor>, to: Pair<Number, RGBColor>): FormattedFrame<T> =
+    with {
+        if (it != null) {
+            background(linear(it, from, to))
+        } else null
+    }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frames.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frames.kt
new file mode 100644
index 000000000..7f82f8fc5
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frames.kt
@@ -0,0 +1,16 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+
+// region Pivot
+
+public fun <T> Pivot<T>.frames(): DataRow<T> = aggregate { this }
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.frames(): DataFrame<T> = aggregate { this }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt
new file mode 100644
index 000000000..119ab658a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt
@@ -0,0 +1,102 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.RowValueFilter
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.api.gatherImpl
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+public fun <T, C> DataFrame<T>.gather(selector: ColumnsSelector<T, C>): Gather<T, C, String, C> =
+    Gather(
+        df = this,
+        columns = selector,
+        filter = null,
+        keyType = typeOf<String>(),
+        keyTransform = { it },
+        valueTransform = null,
+    )
+
+public fun <T> DataFrame<T>.gather(vararg columns: String): Gather<T, Any?, String, Any?> =
+    gather { columns.toColumns() }
+
+public fun <T, C> DataFrame<T>.gather(vararg columns: ColumnReference<C>): Gather<T, C, String, C> =
+    gather { columns.toColumns() }
+
+public fun <T, C> DataFrame<T>.gather(vararg columns: KProperty<C>): Gather<T, C, String, C> =
+    gather { columns.toColumns() }
+
+public fun <T, C, K, R> Gather<T, C, K, R>.where(filter: RowValueFilter<T, C>): Gather<T, C, K, R> =
+    copy(filter = this.filter and filter)
+
+public fun <T, C, K, R> Gather<T, C?, K, R>.notNull(): Gather<T, C, K, R> =
+    where { it != null } as Gather<T, C, K, R>
+
+public fun <T, C, K, R> Gather<T, C, K, R>.explodeLists(): Gather<T, C, K, R> =
+    copy(explode = true)
+
+public inline fun <T, C, reified K, R> Gather<T, C, *, R>.mapKeys(noinline transform: (String) -> K): Gather<T, C, K, R> =
+    copy(keyTransform = transform as ((String) -> Nothing), keyType = typeOf<K>()) as Gather<T, C, K, R>
+
+public fun <T, C, K, R> Gather<T, C, K, *>.mapValues(transform: (C) -> R): Gather<T, C, K, R> =
+    copy(valueTransform = transform as ((C) -> Nothing)) as Gather<T, C, K, R>
+
+public data class Gather<T, C, K, R>(
+    internal val df: DataFrame<T>,
+    internal val columns: ColumnsSelector<T, C>,
+    internal val filter: RowValueFilter<T, C>? = null,
+    internal val keyType: KType? = null,
+    internal val keyTransform: ((String) -> K),
+    internal val valueTransform: ((C) -> R)? = null,
+    internal val explode: Boolean = false
+) {
+    public fun <P> cast(): Gather<T, P, K, P> {
+        // TODO: introduce GatherWithTransform to avoid this error
+        require(valueTransform == null) { "Cast is not allowed to be called after `mapValues`" }
+        return this as Gather<T, P, K, P>
+    }
+}
+
+public fun <T, C, K, R> Gather<T, C, K, R>.into(
+    keyColumn: String,
+    valueColumn: String
+): DataFrame<T> = gatherImpl(keyColumn, valueColumn)
+
+public fun <T, C, K, R> Gather<T, C, K, R>.into(
+    keyColumn: ColumnAccessor<K>,
+    valueColumn: ColumnAccessor<R>
+): DataFrame<T> = into(keyColumn.name(), valueColumn.name)
+
+public fun <T, C, K, R> Gather<T, C, K, R>.into(
+    keyColumn: KProperty<K>,
+    valueColumn: KProperty<R>
+): DataFrame<T> = into(keyColumn.columnName, valueColumn.columnName)
+
+public fun <T, C, K, R> Gather<T, C, K, R>.keysInto(
+    keyColumn: String
+): DataFrame<T> = gatherImpl(keyColumn, null)
+
+public fun <T, C, K, R> Gather<T, C, K, R>.keysInto(
+    keyColumn: ColumnAccessor<K>
+): DataFrame<T> = keysInto(keyColumn.name())
+
+public fun <T, C, K, R> Gather<T, C, K, R>.keysInto(
+    keyColumn: KProperty<K>
+): DataFrame<T> = keysInto(keyColumn.columnName)
+
+public fun <T, C, K, R> Gather<T, C, K, R>.valuesInto(
+    valueColumn: String
+): DataFrame<T> = gatherImpl(null, valueColumn)
+
+public fun <T, C, K, R> Gather<T, C, K, R>.valuesInto(
+    valueColumn: ColumnAccessor<K>
+): DataFrame<T> = valuesInto(valueColumn.name())
+
+public fun <T, C, K, R> Gather<T, C, K, R>.valuesInto(
+    valueColumn: KProperty<K>
+): DataFrame<T> = valuesInto(valueColumn.columnName)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt
new file mode 100644
index 000000000..2c75681d3
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt
@@ -0,0 +1,33 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnGroupAccessor
+import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import kotlin.experimental.ExperimentalTypeInference
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+public data class GroupClause<T, C>(val df: DataFrame<T>, val columns: ColumnsSelector<T, C>)
+
+public fun <T, C> DataFrame<T>.group(columns: ColumnsSelector<T, C>): GroupClause<T, C> = GroupClause(this, columns)
+public fun <T> DataFrame<T>.group(vararg columns: String): GroupClause<T, Any?> = group { columns.toColumns() }
+public fun <T> DataFrame<T>.group(vararg columns: Column): GroupClause<T, Any?> = group { columns.toColumns() }
+public fun <T> DataFrame<T>.group(vararg columns: KProperty<*>): GroupClause<T, Any?> = group { columns.toColumns() }
+
+@JvmName("intoString")
+@OverloadResolutionByLambdaReturnType
+@OptIn(ExperimentalTypeInference::class)
+public infix fun <T, C> GroupClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> String): DataFrame<T> = df.move(columns).under { column(it).toColumnAccessor() }
+
+@JvmName("intoColumn")
+public infix fun <T, C> GroupClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> Column): DataFrame<T> = df.move(columns).under(column)
+public infix fun <T, C> GroupClause<T, C>.into(column: String): DataFrame<T> = into(columnGroup().named(column))
+public infix fun <T, C> GroupClause<T, C>.into(column: AnyColumnGroupAccessor): DataFrame<T> = df.move(columns).under(column)
+public infix fun <T, C> GroupClause<T, C>.into(column: KProperty<*>): DataFrame<T> = into(column.columnName)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
new file mode 100644
index 000000000..b02c37e7b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
@@ -0,0 +1,91 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.aggregation.Aggregatable
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedBody
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.PivotImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.getPivotColumnPaths
+import org.jetbrains.kotlinx.dataframe.impl.api.groupByImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.groupBy(moveToTop: Boolean = true, cols: ColumnsSelector<T, *>): GroupBy<T, T> =
+    groupByImpl(moveToTop, cols)
+
+public fun <T> DataFrame<T>.groupBy(cols: Iterable<Column>): GroupBy<T, T> = groupBy { cols.toColumnSet() }
+public fun <T> DataFrame<T>.groupBy(vararg cols: KProperty<*>): GroupBy<T, T> = groupBy { cols.toColumns() }
+public fun <T> DataFrame<T>.groupBy(vararg cols: String): GroupBy<T, T> = groupBy { cols.toColumns() }
+public fun <T> DataFrame<T>.groupBy(vararg cols: Column, moveToTop: Boolean = true): GroupBy<T, T> =
+    groupBy(moveToTop) { cols.toColumns() }
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.groupBy(moveToTop: Boolean = true, columns: ColumnsSelector<T, *>): PivotGroupBy<T> =
+    (this as PivotImpl<T>).toGroupedPivot(moveToTop, columns)
+
+public fun <T> Pivot<T>.groupBy(vararg columns: Column): PivotGroupBy<T> = groupBy { columns.toColumns() }
+public fun <T> Pivot<T>.groupBy(vararg columns: String): PivotGroupBy<T> = groupBy { columns.toColumns() }
+public fun <T> Pivot<T>.groupBy(vararg columns: KProperty<*>): PivotGroupBy<T> = groupBy { columns.toColumns() }
+
+public fun <T> Pivot<T>.groupByOther(): PivotGroupBy<T> {
+    val impl = this as PivotImpl<T>
+    val pivotColumns = df.getPivotColumnPaths(columns).toColumnSet()
+    return impl.toGroupedPivot(moveToTop = false) { except(pivotColumns) }
+}
+
+// endregion
+
+public typealias GroupedRowSelector<T, G, R> = GroupedDataRow<T, G>.(GroupedDataRow<T, G>) -> R
+
+public typealias GroupedRowFilter<T, G> = GroupedRowSelector<T, G, Boolean>
+
+public interface GroupedDataRow<out T, out G> : DataRow<T> {
+
+    public fun group(): DataFrame<G>
+}
+
+public val <T, G> GroupedDataRow<T, G>.group: DataFrame<G> get() = group()
+
+public data class GroupWithKey<T, G>(val key: DataRow<T>, val group: DataFrame<G>)
+
+public interface GroupBy<out T, out G> : Grouped<G> {
+
+    public val groups: FrameColumn<G>
+
+    public val keys: DataFrame<T>
+
+    public fun toDataFrame(groupedColumnName: String? = null): DataFrame<T>
+
+    public fun <R> updateGroups(transform: Selector<DataFrame<G>, DataFrame<R>>): GroupBy<T, R>
+
+    public fun filter(predicate: GroupedRowFilter<T, G>): GroupBy<T, G>
+
+    public data class Entry<T, G>(val key: DataRow<T>, val group: DataFrame<G>)
+
+    public companion object {
+        internal val groupedColumnAccessor = column<AnyFrame>("group")
+    }
+}
+
+public interface Grouped<out T> : Aggregatable<T> {
+
+    public fun <R> aggregate(body: AggregateGroupedBody<T, R>): DataFrame<T>
+}
+
+public data class ReducedGroupBy<T, G>(
+    @PublishedApi internal val groupBy: GroupBy<T, G>,
+    @PublishedApi internal val reducer: Selector<DataFrame<G>, DataRow<G>?>
+)
+
+internal fun <T, G> GroupBy<T, G>.reduce(reducer: Selector<DataFrame<G>, DataRow<G>?>) = ReducedGroupBy(this, reducer)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/head.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/head.kt
new file mode 100644
index 000000000..3c23f050a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/head.kt
@@ -0,0 +1,9 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.head(numRows: Int = 5): DataFrame<T> = take(numRows)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/implode.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/implode.kt
new file mode 100644
index 000000000..50bbd9ad5
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/implode.kt
@@ -0,0 +1,24 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.api.implodeImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import kotlin.reflect.KProperty
+
+public fun <T> DataFrame<T>.implode(dropNA: Boolean = false): DataRow<T> =
+    implode(dropNA) { all() }[0]
+
+public fun <T, C> DataFrame<T>.implode(dropNA: Boolean = false, columns: ColumnsSelector<T, C>): DataFrame<T> =
+    implodeImpl(dropNA, columns)
+
+public fun <T> DataFrame<T>.implode(vararg columns: String, dropNA: Boolean = false): DataFrame<T> =
+    implode(dropNA) { columns.toColumns() }
+
+public fun <T, C> DataFrame<T>.implode(vararg columns: ColumnReference<C>, dropNA: Boolean = false): DataFrame<T> =
+    implode(dropNA) { columns.toColumns() }
+
+public fun <T, C> DataFrame<T>.implode(vararg columns: KProperty<C>, dropNA: Boolean = false): DataFrame<T> =
+    implode(dropNA) { columns.toColumns() }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/indices.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/indices.kt
new file mode 100644
index 000000000..5ffaf0f3a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/indices.kt
@@ -0,0 +1,17 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.indices
+
+// region DataFrame
+
+public fun AnyFrame.indices(): IntRange = 0 until rowsCount()
+
+public fun <T> DataFrame<T>.indices(filter: RowFilter<T>): List<Int> = indices.filter {
+    val row = get(it)
+    filter(row, row)
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt
new file mode 100644
index 000000000..cb1fe0463
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt
@@ -0,0 +1,19 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.columns.guessColumnType
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.type
+import kotlin.reflect.KProperty
+
+public fun AnyCol.inferType(): DataColumn<*> = guessColumnType(name, toList(), type, true)
+
+public fun <T> DataFrame<T>.inferType(): DataFrame<T> = inferType { allDfs() }
+public fun <T> DataFrame<T>.inferType(columns: ColumnsSelector<T, *>): DataFrame<T> = replace(columns).with { it.inferType() }
+public fun <T> DataFrame<T>.inferType(vararg columns: String): DataFrame<T> = inferType { columns.toColumns() }
+public fun <T> DataFrame<T>.inferType(vararg columns: ColumnReference<*>): DataFrame<T> = inferType { columns.toColumns() }
+public fun <T> DataFrame<T>.inferType(vararg columns: KProperty<*>): DataFrame<T> = inferType { columns.toColumns() }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/insert.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/insert.kt
new file mode 100644
index 000000000..3cad76444
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/insert.kt
@@ -0,0 +1,51 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.impl.api.insertImpl
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.removeAt
+import kotlin.reflect.KProperty
+
+public fun <T> DataFrame<T>.insert(column: AnyCol): InsertClause<T> = InsertClause(this, column)
+
+public inline fun <T, reified R> DataFrame<T>.insert(
+    name: String,
+    infer: Infer = Infer.Nulls,
+    noinline expression: RowExpression<T, R>
+): InsertClause<T> = insert(mapToColumn(name, infer, expression))
+
+public inline fun <T, reified R> DataFrame<T>.insert(
+    column: ColumnAccessor<R>,
+    infer: Infer = Infer.Nulls,
+    noinline expression: RowExpression<T, R>
+): InsertClause<T> = insert(column.name(), infer, expression)
+
+public inline fun <T, reified R> DataFrame<T>.insert(
+    column: KProperty<R>,
+    infer: Infer = Infer.Nulls,
+    noinline expression: RowExpression<T, R>
+): InsertClause<T> = insert(column.columnName, infer, expression)
+
+public data class InsertClause<T>(val df: DataFrame<T>, val column: AnyCol)
+
+public fun <T> InsertClause<T>.under(column: ColumnSelector<T, *>): DataFrame<T> = under(df.getColumnPath(column))
+public fun <T> InsertClause<T>.under(columnPath: ColumnPath): DataFrame<T> = df.insertImpl(columnPath + column.name, column)
+public fun <T> InsertClause<T>.under(column: ColumnAccessor<*>): DataFrame<T> = under(column.path())
+public fun <T> InsertClause<T>.under(column: KProperty<*>): DataFrame<T> = under(column.columnName)
+public fun <T> InsertClause<T>.under(column: String): DataFrame<T> = under(pathOf(column))
+
+public fun <T> InsertClause<T>.after(column: ColumnSelector<T, *>): DataFrame<T> = after(df.getColumnPath(column))
+public fun <T> InsertClause<T>.after(column: String): DataFrame<T> = df.add(this.column).move(this.column).after(column)
+public fun <T> InsertClause<T>.after(column: ColumnAccessor<*>): DataFrame<T> = after(column.path())
+public fun <T> InsertClause<T>.after(column: KProperty<*>): DataFrame<T> = after(column.columnName)
+public fun <T> InsertClause<T>.after(columnPath: ColumnPath): DataFrame<T> {
+    val dstPath = ColumnPath(columnPath.removeAt(columnPath.size - 1) + column.name())
+    return df.insertImpl(dstPath, column).move { dstPath }.after { columnPath }
+}
+
+public fun <T> InsertClause<T>.at(position: Int): DataFrame<T> = df.add(column).move(column).to(position)
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
new file mode 100644
index 000000000..9b9e2b177
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/into.kt
@@ -0,0 +1,68 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.internal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.withExpr
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import kotlin.reflect.KProperty
+import kotlin.reflect.typeOf
+
+// region GroupBy
+
+public fun <T, G> GroupBy<T, G>.into(column: String): DataFrame<T> = toDataFrame(column)
+public fun <T> GroupBy<T, *>.into(column: ColumnAccessor<AnyFrame>): DataFrame<T> = toDataFrame(column.name())
+public fun <T> GroupBy<T, *>.into(column: KProperty<AnyFrame>): DataFrame<T> = toDataFrame(column.columnName)
+
+public inline fun <T, G, reified V> GroupBy<T, G>.into(
+    columnName: String? = null,
+    noinline expression: RowExpression<G, V>
+): DataFrame<G> = into(pathOf(columnName ?: groups.name()).cast(), expression)
+public inline fun <T, G, reified V> GroupBy<T, G>.into(
+    column: ColumnAccessor<V>,
+    noinline expression: RowExpression<G, V>
+): DataFrame<G> {
+    val type = typeOf<V>()
+    val path = column.path()
+    return aggregate {
+        internal().withExpr(type, path, expression)
+    }
+}
+public inline fun <T, G, reified V> GroupBy<T, G>.into(column: KProperty<V>, noinline expression: RowExpression<G, V>): DataFrame<G> = into(column.columnName, expression)
+
+// endregion
+
+// region ReducedGroupBy
+
+public inline fun <T, G, reified V> ReducedGroupBy<T, G>.into(
+    columnName: String? = null,
+    noinline expression: RowExpression<G, V>
+): DataFrame<G> {
+    val type = typeOf<V>()
+    val name = columnName ?: groupBy.groups.name()
+    return groupBy.aggregate {
+        val row = reducer(it, it)
+        if (row != null) {
+            internal().yield(pathOf(name), expression(row, row), type)
+        }
+    }
+}
+public inline fun <T, G, reified V> ReducedGroupBy<T, G>.into(
+    column: ColumnAccessor<V>,
+    noinline expression: RowExpression<G, V>
+): DataFrame<G> = into(column.name(), expression)
+public inline fun <T, G, reified V> ReducedGroupBy<T, G>.into(
+    column: KProperty<V>,
+    noinline expression: RowExpression<G, V>
+): DataFrame<G> = into(column.columnName, expression)
+
+public fun <T, G> ReducedGroupBy<T, G>.into(columnName: String): DataFrame<G> = into(columnName) { this }
+public fun <T, G> ReducedGroupBy<T, G>.into(column: ColumnAccessor<AnyRow>): DataFrame<G> = into(column) { this }
+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().map { reducer(it, it) }.concat()
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/isEmpty.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/isEmpty.kt
new file mode 100644
index 000000000..e55186ee1
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/isEmpty.kt
@@ -0,0 +1,12 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+
+// region DataFrame
+
+public fun AnyFrame.isEmpty(): Boolean = ncol == 0 || nrow == 0
+public fun AnyFrame.isNotEmpty(): Boolean = !isEmpty()
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt
new file mode 100644
index 000000000..f1d6ff56a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt
@@ -0,0 +1,128 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.impl.api.joinImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import kotlin.reflect.KProperty
+
+public fun <A, B> DataFrame<A>.join(
+    other: DataFrame<B>,
+    type: JoinType = JoinType.Inner,
+    selector: JoinColumnsSelector<A, B>? = null
+): DataFrame<A> = joinImpl(other, type, true, selector)
+
+public fun <A, B> DataFrame<A>.join(
+    other: DataFrame<B>,
+    vararg columns: String,
+    type: JoinType = JoinType.Inner
+): DataFrame<A> = join(other, type) { columns.toColumns() }
+
+public fun <A, B> DataFrame<A>.innerJoin(
+    other: DataFrame<B>,
+    selector: JoinColumnsSelector<A, B>? = null
+): DataFrame<A> = join(other, JoinType.Inner, selector = selector)
+
+public fun <A, B> DataFrame<A>.innerJoin(
+    other: DataFrame<B>,
+    vararg columns: String
+): DataFrame<A> = innerJoin(other) { columns.toColumns() }
+
+public fun <A, B> DataFrame<A>.leftJoin(
+    other: DataFrame<B>,
+    selector: JoinColumnsSelector<A, B>? = null
+): DataFrame<A> = join(other, JoinType.Left, selector = selector)
+
+public fun <A, B> DataFrame<A>.leftJoin(
+    other: DataFrame<B>,
+    vararg columns: String
+): DataFrame<A> = leftJoin(other) { columns.toColumns() }
+
+public fun <A, B> DataFrame<A>.rightJoin(
+    other: DataFrame<B>,
+    selector: JoinColumnsSelector<A, B>? = null
+): DataFrame<A> = join(other, JoinType.Right, selector = selector)
+
+public fun <A, B> DataFrame<A>.rightJoin(
+    other: DataFrame<B>,
+    vararg columns: String
+): DataFrame<A> = rightJoin(other) { columns.toColumns() }
+
+public fun <A, B> DataFrame<A>.fullJoin(
+    other: DataFrame<B>,
+    selector: JoinColumnsSelector<A, B>? = null
+): DataFrame<A> = join(other, JoinType.Full, selector = selector)
+
+public fun <A, B> DataFrame<A>.fullJoin(
+    other: DataFrame<B>,
+    vararg columns: String
+): DataFrame<A> = fullJoin(other) { columns.toColumns() }
+
+public fun <A, B> DataFrame<A>.filterJoin(
+    other: DataFrame<B>,
+    selector: JoinColumnsSelector<A, B>? = null
+): DataFrame<A> = joinImpl(other, JoinType.Inner, addNewColumns = false, selector = selector)
+
+public fun <A, B> DataFrame<A>.filterJoin(
+    other: DataFrame<B>,
+    vararg columns: String
+): DataFrame<A> = filterJoin(other) { columns.toColumns() }
+
+public fun <A, B> DataFrame<A>.excludeJoin(
+    other: DataFrame<B>,
+    selector: JoinColumnsSelector<A, B>? = null
+): DataFrame<A> = joinImpl(other, JoinType.Exclude, addNewColumns = false, selector = selector)
+
+public fun <A, B> DataFrame<A>.excludeJoin(
+    other: DataFrame<B>,
+    vararg columns: String
+): DataFrame<A> = excludeJoin(other) { columns.toColumns() }
+
+public fun <T> Iterable<DataFrame<T>>.joinOrNull(
+    joinType: JoinType = JoinType.Inner,
+    selector: JoinColumnsSelector<T, T>? = null
+): DataFrame<T>? =
+    fold<DataFrame<T>, DataFrame<T>?>(null) { joined, new -> joined?.join(new, joinType, selector = selector) ?: new }
+
+public interface JoinDsl<out A, out B> : ColumnsSelectionDsl<A> {
+
+    public val right: DataFrame<B>
+
+    public infix fun <C> ColumnReference<C>.match(other: ColumnReference<C>): ColumnMatch<C> = ColumnMatch(this, other)
+
+    public infix fun <C> String.match(other: ColumnReference<C>): ColumnMatch<C> = ColumnMatch(toColumnOf(), other)
+
+    public infix fun <C> ColumnReference<C>.match(other: String): ColumnMatch<C> = ColumnMatch(this, other.toColumnOf())
+
+    public infix fun String.match(other: String): ColumnMatch<Any?> = ColumnMatch(toColumnAccessor(), other.toColumnAccessor())
+
+    public infix fun <C> KProperty<C>.match(other: KProperty<C>): ColumnMatch<C> = ColumnMatch(toColumnAccessor(), other.toColumnAccessor())
+
+    public infix fun <C> ColumnReference<C>.match(other: KProperty<C>): ColumnMatch<C> = ColumnMatch(this, other.toColumnAccessor())
+
+    public infix fun <C> KProperty<C>.match(other: ColumnReference<C>): ColumnMatch<C> = ColumnMatch(toColumnAccessor(), other)
+}
+
+public class ColumnMatch<C>(public val left: ColumnReference<C>, public val right: ColumnReference<C>) : ColumnSet<C> {
+
+    override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> {
+        throw UnsupportedOperationException()
+    }
+}
+
+public typealias JoinColumnsSelector<A, B> = JoinDsl<A, B>.(ColumnsContainer<A>) -> ColumnSet<*>
+
+public enum class JoinType {
+    Left, // all data from left data frame, nulls for mismatches in right data frame
+    Right, // all data from right data frame, nulls for mismatches in left data frame
+    Inner, // only matched data from right and left data frame
+    Full, // all data from left and from right data frame, nulls for any mismatches
+    Exclude // mismatched rows from left data frame
+}
+
+public val JoinType.allowLeftNulls: Boolean get() = this == JoinType.Right || this == JoinType.Full
+public val JoinType.allowRightNulls: Boolean get() = this == JoinType.Left || this == JoinType.Full || this == JoinType.Exclude
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/last.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/last.kt
new file mode 100644
index 000000000..c1ebe1d27
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/last.kt
@@ -0,0 +1,58 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.nrow
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.last(): T = get(size - 1)
+public fun <T> DataColumn<T>.lastOrNull(): T? = if (size > 0) last() else null
+public fun <T> DataColumn<T>.last(predicate: (T) -> Boolean): T = values.last(predicate)
+public fun <T> DataColumn<T>.lastOrNull(predicate: (T) -> Boolean): T? = values.lastOrNull(predicate)
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.lastOrNull(predicate: RowFilter<T>): DataRow<T>? =
+    rowsReversed().firstOrNull { predicate(it, it) }
+
+public fun <T> DataFrame<T>.last(predicate: RowFilter<T>): DataRow<T> = rowsReversed().first { predicate(it, it) }
+public fun <T> DataFrame<T>.lastOrNull(): DataRow<T>? = if (nrow > 0) get(nrow - 1) else null
+public fun <T> DataFrame<T>.last(): DataRow<T> {
+    if (nrow == 0) {
+        throw NoSuchElementException("DataFrame has no rows. Use `lastOrNull`.")
+    }
+    return get(nrow - 1)
+}
+
+// endregion
+
+// region GroupBy
+
+public fun <T, G> GroupBy<T, G>.last(): ReducedGroupBy<T, G> = reduce { lastOrNull() }
+
+public fun <T, G> GroupBy<T, G>.last(predicate: RowFilter<G>): ReducedGroupBy<T, G> = reduce { lastOrNull(predicate) }
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.last(): ReducedPivot<T> = reduce { lastOrNull() }
+
+public fun <T> Pivot<T>.last(predicate: RowFilter<T>): ReducedPivot<T> = reduce { lastOrNull(predicate) }
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.last(): ReducedPivotGroupBy<T> = reduce { lastOrNull() }
+
+public fun <T> PivotGroupBy<T>.last(predicate: RowFilter<T>): ReducedPivotGroupBy<T> = reduce { lastOrNull(predicate) }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/length.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/length.kt
new file mode 100644
index 000000000..3c9eb65af
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/length.kt
@@ -0,0 +1,10 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.StringCol
+
+// region StringCol
+
+public fun StringCol.length(): DataColumn<Int> = map { it?.length ?: 0 }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/lowercase.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/lowercase.kt
new file mode 100644
index 000000000..1f10f5991
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/lowercase.kt
@@ -0,0 +1,9 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.StringCol
+
+// region StringCol
+
+public fun StringCol.lowercase(): StringCol = map { it?.lowercase() }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/map.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/map.kt
new file mode 100644
index 000000000..becac2ab0
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/map.kt
@@ -0,0 +1,130 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.createComputedColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.columns.newColumn
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+// region ColumnReference
+
+public inline fun <C, reified R> ColumnReference<C>.map(infer: Infer = Infer.Nulls, noinline transform: (C) -> R): ColumnReference<R> =
+    createComputedColumnReference(name(), typeOf<R>(), infer) { transform(this@map()) }
+
+// endregion
+
+// region DataColumn
+
+public inline fun <T, reified R> DataColumn<T>.map(
+    infer: Infer = Infer.Nulls,
+    crossinline transform: (T) -> R
+): DataColumn<R> {
+    val newValues = Array(size()) { transform(get(it)) }.asList()
+    return DataColumn.create(name(), newValues, typeOf<R>(), infer)
+}
+
+public fun <T, R> DataColumn<T>.map(
+    type: KType,
+    infer: Infer = Infer.Nulls,
+    transform: (T) -> R
+): DataColumn<R> {
+    val values = Array<Any?>(size()) { transform(get(it)) }.asList()
+    return DataColumn.create(name(), values, type, infer).cast()
+}
+
+public inline fun <T, reified R> DataColumn<T>.mapIndexed(
+    infer: Infer = Infer.Nulls,
+    crossinline transform: (Int, T) -> R
+): DataColumn<R> {
+    val newValues = Array(size()) { transform(it, get(it)) }.asList()
+    return DataColumn.create(name(), newValues, typeOf<R>(), infer)
+}
+
+public fun <T, R> DataColumn<T>.mapIndexed(
+    type: KType,
+    infer: Infer = Infer.Nulls,
+    transform: (Int, T) -> R
+): DataColumn<R> {
+    val values = Array<Any?>(size()) { transform(it, get(it)) }.asList()
+    return DataColumn.create(name(), values, type, infer).cast()
+}
+
+// endregion
+
+// region DataFrame
+
+public fun <T, R> DataFrame<T>.map(transform: RowExpression<T, R>): List<R> = rows().map { transform(it, it) }
+
+public inline fun <T, reified R> ColumnsContainer<T>.mapToColumn(
+    name: String,
+    infer: Infer = Infer.Nulls,
+    noinline body: AddExpression<T, R>
+): DataColumn<R> = mapToColumn(name, typeOf<R>(), infer, body)
+
+public inline fun <T, reified R> ColumnsContainer<T>.mapToColumn(
+    column: ColumnAccessor<R>,
+    infer: Infer = Infer.Nulls,
+    noinline body: AddExpression<T, R>
+): DataColumn<R> = mapToColumn(column, typeOf<R>(), infer, body)
+
+public inline fun <T, reified R> ColumnsContainer<T>.mapToColumn(
+    column: KProperty<R>,
+    infer: Infer = Infer.Nulls,
+    noinline body: AddExpression<T, R>
+): DataColumn<R> = mapToColumn(column, typeOf<R>(), infer, body)
+
+public fun <T, R> ColumnsContainer<T>.mapToColumn(
+    name: String,
+    type: KType,
+    infer: Infer = Infer.Nulls,
+    body: AddExpression<T, R>
+): DataColumn<R> = newColumn(type, name, infer, body)
+
+public fun <T, R> ColumnsContainer<T>.mapToColumn(
+    column: ColumnAccessor<R>,
+    type: KType,
+    infer: Infer = Infer.Nulls,
+    body: AddExpression<T, R>
+): DataColumn<R> = mapToColumn(column.name(), type, infer, body)
+
+public fun <T, R> ColumnsContainer<T>.mapToColumn(
+    column: KProperty<R>,
+    type: KType,
+    infer: Infer = Infer.Nulls,
+    body: AddExpression<T, R>
+): DataColumn<R> = mapToColumn(column.columnName, type, infer, body)
+
+public fun <T> DataFrame<T>.mapToFrame(body: AddDsl<T>.() -> Unit): AnyFrame {
+    val dsl = AddDsl(this)
+    body(dsl)
+    return dataFrameOf(dsl.columns)
+}
+
+// endregion
+
+// region GroupBy
+
+public fun <T, G, R> GroupBy<T, G>.map(body: Selector<GroupWithKey<T, G>, R>): List<R> = keys.rows().mapIndexedNotNull { index, row ->
+    val group = groups[index]
+    val g = GroupWithKey(row, group)
+    body(g, g)
+}
+
+public fun <T, G> GroupBy<T, G>.mapToRows(body: Selector<GroupWithKey<T, G>, DataRow<G>?>): DataFrame<G> =
+    map(body).concat()
+
+public fun <T, G> GroupBy<T, G>.mapToFrames(body: Selector<GroupWithKey<T, G>, DataFrame<G>>): FrameColumn<G> =
+    DataColumn.createFrameColumn(groups.name, map(body))
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/matches.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/matches.kt
new file mode 100644
index 000000000..0409cda9a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/matches.kt
@@ -0,0 +1,10 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.matches(): DataFrame<T> = matches(yes = true, no = false)
+public fun <T, R> PivotGroupBy<T>.matches(yes: R, no: R): DataFrame<T> = aggregate { yes default no }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt
new file mode 100644
index 000000000..ccbb97ca1
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt
@@ -0,0 +1,170 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelector
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.comparableColumns
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateFor
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOfDelegated
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.impl.columns.toComparableColumns
+import org.jetbrains.kotlinx.dataframe.impl.indexOfMax
+import org.jetbrains.kotlinx.dataframe.impl.suggestIfNull
+import kotlin.reflect.KProperty
+
+// region DataColumn
+
+public fun <T : Comparable<T>> DataColumn<T?>.max(): T = maxOrNull().suggestIfNull("max")
+public fun <T : Comparable<T>> DataColumn<T?>.maxOrNull(): T? = asSequence().filterNotNull().maxOrNull()
+
+public fun <T, R : Comparable<R>> DataColumn<T>.maxBy(selector: (T) -> R): T = maxByOrNull(selector).suggestIfNull("maxBy")
+public fun <T, R : Comparable<R>> DataColumn<T>.maxByOrNull(selector: (T) -> R): T? = values.maxByOrNull(selector)
+
+public fun <T, R : Comparable<R>> DataColumn<T>.maxOf(selector: (T) -> R): R = maxOfOrNull(selector).suggestIfNull("maxOf")
+public fun <T, R : Comparable<R>> DataColumn<T>.maxOfOrNull(selector: (T) -> R): R? = values.maxOfOrNull(selector)
+
+// endregion
+
+// region DataRow
+
+public fun AnyRow.rowMaxOrNull(): Any? = values().filterIsInstance<Comparable<*>>().maxWithOrNull(compareBy { it })
+public fun AnyRow.rowMax(): Any = rowMaxOrNull().suggestIfNull("rowMax")
+public inline fun <reified T : Comparable<T>> AnyRow.rowMaxOfOrNull(): T? = values().filterIsInstance<T>().maxOrNull()
+public inline fun <reified T : Comparable<T>> AnyRow.rowMaxOf(): T = rowMaxOfOrNull<T>().suggestIfNull("rowMaxOf")
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.max(): DataRow<T> = maxFor(comparableColumns())
+
+public fun <T, C : Comparable<C>> DataFrame<T>.maxFor(columns: ColumnsForAggregateSelector<T, C?>): DataRow<T> = Aggregators.max.aggregateFor(this, columns)
+public fun <T> DataFrame<T>.maxFor(vararg columns: String): DataRow<T> = maxFor { columns.toComparableColumns() }
+public fun <T, C : Comparable<C>> DataFrame<T>.maxFor(vararg columns: ColumnReference<C?>): DataRow<T> = maxFor { columns.toColumns() }
+public fun <T, C : Comparable<C>> DataFrame<T>.maxFor(vararg columns: KProperty<C?>): DataRow<T> = maxFor { columns.toColumns() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.max(columns: ColumnsSelector<T, C?>): C = maxOrNull(columns).suggestIfNull("max")
+public fun <T> DataFrame<T>.max(vararg columns: String): Comparable<Any?> = maxOrNull(*columns).suggestIfNull("max")
+public fun <T, C : Comparable<C>> DataFrame<T>.max(vararg columns: ColumnReference<C?>): C = maxOrNull(*columns).suggestIfNull("max")
+public fun <T, C : Comparable<C>> DataFrame<T>.max(vararg columns: KProperty<C?>): C = maxOrNull(*columns).suggestIfNull("max")
+
+public fun <T, C : Comparable<C>> DataFrame<T>.maxOrNull(columns: ColumnsSelector<T, C?>): C? = Aggregators.max.aggregateAll(this, columns) as C?
+public fun <T> DataFrame<T>.maxOrNull(vararg columns: String): Comparable<Any?>? = maxOrNull { columns.toComparableColumns() }
+public fun <T, C : Comparable<C>> DataFrame<T>.maxOrNull(vararg columns: ColumnReference<C?>): C? = maxOrNull { columns.toColumns() }
+public fun <T, C : Comparable<C>> DataFrame<T>.maxOrNull(vararg columns: KProperty<C?>): C? = maxOrNull { columns.toColumns() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.maxOf(expression: RowExpression<T, C>): C = maxOfOrNull(expression).suggestIfNull("maxOf")
+public fun <T, C : Comparable<C>> DataFrame<T>.maxOfOrNull(expression: RowExpression<T, C>): C? = rows().maxOfOrNull { expression(it, it) }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.maxBy(expression: RowExpression<T, C?>): DataRow<T> = maxByOrNull(expression).suggestIfNull("maxBy")
+public fun <T> DataFrame<T>.maxBy(column: String): DataRow<T> = maxByOrNull(column).suggestIfNull("maxBy")
+public fun <T, C : Comparable<C>> DataFrame<T>.maxBy(column: ColumnReference<C?>): DataRow<T> = maxByOrNull(column).suggestIfNull("maxBy")
+public fun <T, C : Comparable<C>> DataFrame<T>.maxBy(column: KProperty<C?>): DataRow<T> = maxByOrNull(column).suggestIfNull("maxBy")
+
+public fun <T, C : Comparable<C>> DataFrame<T>.maxByOrNull(expression: RowExpression<T, C?>): DataRow<T>? = getOrNull(rows().asSequence().map { expression(it, it) }.indexOfMax())
+public fun <T> DataFrame<T>.maxByOrNull(column: String): DataRow<T>? = maxByOrNull(column.toColumnOf<Comparable<Any?>?>())
+public fun <T, C : Comparable<C>> DataFrame<T>.maxByOrNull(column: ColumnReference<C?>): DataRow<T>? = getOrNull(get(column).asSequence().indexOfMax())
+public fun <T, C : Comparable<C>> DataFrame<T>.maxByOrNull(column: KProperty<C?>): DataRow<T>? = maxByOrNull(column.toColumnAccessor())
+
+// endregion
+
+// region GroupBy
+
+public fun <T> Grouped<T>.max(): DataFrame<T> = maxFor(comparableColumns())
+
+public fun <T, C : Comparable<C>> Grouped<T>.maxFor(columns: ColumnsForAggregateSelector<T, C?>): DataFrame<T> = Aggregators.max.aggregateFor(this, columns)
+public fun <T> Grouped<T>.maxFor(vararg columns: String): DataFrame<T> = maxFor { columns.toComparableColumns() }
+public fun <T, C : Comparable<C>> Grouped<T>.maxFor(vararg columns: ColumnReference<C?>): DataFrame<T> = maxFor { columns.toColumns() }
+public fun <T, C : Comparable<C>> Grouped<T>.maxFor(vararg columns: KProperty<C?>): DataFrame<T> = maxFor { columns.toColumns() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.max(
+    name: String? = null,
+    columns: ColumnsSelector<T, C?>
+): DataFrame<T> =
+    Aggregators.max.aggregateAll(this, name, columns)
+public fun <T> Grouped<T>.max(vararg columns: String, name: String? = null): DataFrame<T> = max(name) { columns.toComparableColumns() }
+public fun <T, C : Comparable<C>> Grouped<T>.max(vararg columns: ColumnReference<C?>, name: String? = null): DataFrame<T> = max(name) { columns.toColumns() }
+public fun <T, C : Comparable<C>> Grouped<T>.max(vararg columns: KProperty<C?>, name: String? = null): DataFrame<T> = max(name) { columns.toColumns() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.maxOf(name: String? = null, expression: RowExpression<T, C>): DataFrame<T> =
+    Aggregators.max.aggregateOfDelegated(this, name) { maxOfOrNull(expression) }
+
+public fun <T, G, R : Comparable<R>> GroupBy<T, G>.maxBy(rowExpression: RowExpression<G, R?>): ReducedGroupBy<T, G> = reduce { maxByOrNull(rowExpression) }
+public fun <T, G, C : Comparable<C>> GroupBy<T, G>.maxBy(column: ColumnReference<C?>): ReducedGroupBy<T, G> = reduce { maxByOrNull(column) }
+public fun <T, G> GroupBy<T, G>.maxBy(column: String): ReducedGroupBy<T, G> = maxBy(column.toColumnAccessor().cast<Comparable<Any?>>())
+public fun <T, G, C : Comparable<C>> GroupBy<T, G>.maxBy(column: KProperty<C?>): ReducedGroupBy<T, G> = maxBy(column.toColumnAccessor())
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.max(separate: Boolean = false): DataRow<T> = delegate { max(separate) }
+
+public fun <T, R : Comparable<R>> Pivot<T>.maxFor(
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, R?>
+): DataRow<T> = delegate { maxFor(separate, columns) }
+public fun <T> Pivot<T>.maxFor(vararg columns: String, separate: Boolean = false): DataRow<T> = maxFor(separate) { columns.toComparableColumns() }
+public fun <T, R : Comparable<R>> Pivot<T>.maxFor(
+    vararg columns: ColumnReference<R?>,
+    separate: Boolean = false
+): DataRow<T> = maxFor(separate) { columns.toColumns() }
+public fun <T, R : Comparable<R>> Pivot<T>.maxFor(
+    vararg columns: KProperty<R?>,
+    separate: Boolean = false
+): DataRow<T> = maxFor(separate) { columns.toColumns() }
+
+public fun <T, R : Comparable<R>> Pivot<T>.max(columns: ColumnsSelector<T, R?>): DataRow<T> = delegate { max(columns) }
+public fun <T> Pivot<T>.max(vararg columns: String): DataRow<T> = max { columns.toComparableColumns() }
+public fun <T, R : Comparable<R>> Pivot<T>.max(vararg columns: ColumnReference<R?>): DataRow<T> = max { columns.toColumns() }
+public fun <T, R : Comparable<R>> Pivot<T>.max(vararg columns: KProperty<R?>): DataRow<T> = max { columns.toColumns() }
+
+public fun <T, R : Comparable<R>> Pivot<T>.maxOf(rowExpression: RowExpression<T, R>): DataRow<T> = delegate { maxOf(rowExpression) }
+
+public fun <T, R : Comparable<R>> Pivot<T>.maxBy(rowExpression: RowExpression<T, R>): ReducedPivot<T> = reduce { maxByOrNull(rowExpression) }
+public fun <T, C : Comparable<C>> Pivot<T>.maxBy(column: ColumnReference<C?>): ReducedPivot<T> = reduce { maxByOrNull(column) }
+public fun <T> Pivot<T>.maxBy(column: String): ReducedPivot<T> = maxBy(column.toColumnAccessor().cast<Comparable<Any?>>())
+public fun <T, C : Comparable<C>> Pivot<T>.maxBy(column: KProperty<C?>): ReducedPivot<T> = maxBy(column.toColumnAccessor())
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.max(separate: Boolean = false): DataFrame<T> = maxFor(separate, comparableColumns())
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.maxFor(
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, R?>
+): DataFrame<T> =
+    Aggregators.max.aggregateFor(this, separate, columns)
+public fun <T> PivotGroupBy<T>.maxFor(vararg columns: String, separate: Boolean = false): DataFrame<T> = maxFor(separate) { columns.toComparableColumns() }
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.maxFor(
+    vararg columns: ColumnReference<R?>,
+    separate: Boolean = false
+): DataFrame<T> = maxFor(separate) { columns.toColumns() }
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.maxFor(
+    vararg columns: KProperty<R?>,
+    separate: Boolean = false
+): DataFrame<T> = maxFor(separate) { columns.toColumns() }
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.max(columns: ColumnsSelector<T, R?>): DataFrame<T> = Aggregators.max.aggregateAll(this, columns)
+public fun <T> PivotGroupBy<T>.max(vararg columns: String): DataFrame<T> = max { columns.toComparableColumns() }
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.max(vararg columns: ColumnReference<R?>): DataFrame<T> = max { columns.toColumns() }
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.max(vararg columns: KProperty<R?>): DataFrame<T> = max { columns.toColumns() }
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.maxOf(rowExpression: RowExpression<T, R>): DataFrame<T> = aggregate { maxOf(rowExpression) }
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.maxBy(rowExpression: RowExpression<T, R>): ReducedPivotGroupBy<T> = reduce { maxByOrNull(rowExpression) }
+public fun <T, C : Comparable<C>> PivotGroupBy<T>.maxBy(column: ColumnReference<C?>): ReducedPivotGroupBy<T> = reduce { maxByOrNull(column) }
+public fun <T> PivotGroupBy<T>.maxBy(column: String): ReducedPivotGroupBy<T> = maxBy(column.toColumnAccessor().cast<Comparable<Any?>>())
+public fun <T, C : Comparable<C>> PivotGroupBy<T>.maxBy(column: KProperty<C?>): ReducedPivotGroupBy<T> = maxBy(column.toColumnAccessor())
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/mean.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/mean.kt
new file mode 100644
index 000000000..7bcb4ceff
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/mean.kt
@@ -0,0 +1,183 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelector
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast2
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateFor
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOf
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.of
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.numberColumns
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnsOf
+import org.jetbrains.kotlinx.dataframe.impl.columns.toNumberColumns
+import org.jetbrains.kotlinx.dataframe.impl.suggestIfNull
+import org.jetbrains.kotlinx.dataframe.math.mean
+import kotlin.reflect.KProperty
+import kotlin.reflect.typeOf
+
+// region DataColumn
+
+public fun <T : Number> DataColumn<T?>.mean(skipNA: Boolean = skipNA_default): Double = meanOrNull(skipNA).suggestIfNull("mean")
+public fun <T : Number> DataColumn<T?>.meanOrNull(skipNA: Boolean = skipNA_default): Double? = Aggregators.mean(skipNA).aggregate(this)
+
+public inline fun <T, reified R : Number> DataColumn<T>.meanOf(
+    skipNA: Boolean = skipNA_default,
+    noinline expression: (T) -> R?
+): Double = Aggregators.mean(skipNA).cast2<R?, Double>().aggregateOf(this, expression) ?: Double.NaN
+
+// endregion
+
+// region DataRow
+
+public fun AnyRow.rowMean(skipNA: Boolean = org.jetbrains.kotlinx.dataframe.api.skipNA_default): Double = values().filterIsInstance<Number>().map { it.toDouble() }.mean(skipNA)
+public inline fun <reified T : Number> AnyRow.rowMeanOf(): Double = values().filterIsInstance<T>().mean(typeOf<T>())
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.mean(skipNA: Boolean = skipNA_default): DataRow<T> = meanFor(skipNA, numberColumns())
+
+public fun <T, C : Number> DataFrame<T>.meanFor(
+    skipNA: Boolean = skipNA_default,
+    columns: ColumnsForAggregateSelector<T, C?>
+): DataRow<T> = Aggregators.mean(skipNA).aggregateFor(this, columns)
+public fun <T> DataFrame<T>.meanFor(vararg columns: String, skipNA: Boolean = skipNA_default): DataRow<T> = meanFor(skipNA) { columns.toNumberColumns() }
+public fun <T, C : Number> DataFrame<T>.meanFor(vararg columns: ColumnReference<C?>, skipNA: Boolean = skipNA_default): DataRow<T> = meanFor(skipNA) { columns.toColumns() }
+public fun <T, C : Number> DataFrame<T>.meanFor(vararg columns: KProperty<C?>, skipNA: Boolean = skipNA_default): DataRow<T> = meanFor(skipNA) { columns.toColumns() }
+
+public fun <T, C : Number> DataFrame<T>.mean(skipNA: Boolean = skipNA_default, columns: ColumnsSelector<T, C?>): Double = Aggregators.mean(skipNA).aggregateAll(this, columns) as Double? ?: Double.NaN
+public fun <T> DataFrame<T>.mean(vararg columns: String, skipNA: Boolean = skipNA_default): Double = mean(skipNA) { columns.toNumberColumns() }
+public fun <T, C : Number> DataFrame<T>.mean(vararg columns: ColumnReference<C?>, skipNA: Boolean = skipNA_default): Double = mean(skipNA) { columns.toColumns() }
+public fun <T, C : Number> DataFrame<T>.mean(vararg columns: KProperty<C?>, skipNA: Boolean = skipNA_default): Double = mean(skipNA) { columns.toColumns() }
+
+public inline fun <T, reified D : Number> DataFrame<T>.meanOf(
+    skipNA: Boolean = skipNA_default,
+    noinline expression: RowExpression<T, D?>
+): Double = Aggregators.mean(skipNA).of(this, expression) ?: Double.NaN
+
+// endregion
+
+// region GroupBy
+
+public fun <T> Grouped<T>.mean(skipNA: Boolean = skipNA_default): DataFrame<T> = meanFor(skipNA, numberColumns())
+
+public fun <T, C : Number> Grouped<T>.meanFor(
+    skipNA: Boolean = skipNA_default,
+    columns: ColumnsForAggregateSelector<T, C?>
+): DataFrame<T> = Aggregators.mean(skipNA).aggregateFor(this, columns)
+public fun <T> Grouped<T>.meanFor(vararg columns: String, skipNA: Boolean = skipNA_default): DataFrame<T> = meanFor(skipNA) { columns.toNumberColumns() }
+public fun <T, C : Number> Grouped<T>.meanFor(vararg columns: ColumnReference<C?>, skipNA: Boolean = skipNA_default): DataFrame<T> = meanFor(skipNA) { columns.toColumns() }
+public fun <T, C : Number> Grouped<T>.meanFor(vararg columns: KProperty<C?>, skipNA: Boolean = skipNA_default): DataFrame<T> = meanFor(skipNA) { columns.toColumns() }
+
+public fun <T, C : Number> Grouped<T>.mean(
+    name: String? = null,
+    skipNA: Boolean = skipNA_default,
+    columns: ColumnsSelector<T, C?>
+): DataFrame<T> = Aggregators.mean(skipNA).aggregateAll(this, name, columns)
+
+public fun <T> Grouped<T>.mean(vararg columns: String, name: String? = null, skipNA: Boolean = skipNA_default): DataFrame<T> = mean(name, skipNA) { columns.toNumberColumns() }
+
+public fun <T, C : Number> Grouped<T>.mean(
+    vararg columns: ColumnReference<C?>,
+    name: String? = null,
+    skipNA: Boolean = skipNA_default
+): DataFrame<T> = mean(name, skipNA) { columns.toColumns() }
+
+public fun <T, C : Number> Grouped<T>.mean(
+    vararg columns: KProperty<C?>,
+    name: String? = null,
+    skipNA: Boolean = skipNA_default
+): DataFrame<T> = mean(name, skipNA) { columns.toColumns() }
+
+public inline fun <T, reified R : Number> Grouped<T>.meanOf(
+    name: String? = null,
+    skipNA: Boolean = skipNA_default,
+    crossinline expression: RowExpression<T, R?>
+): DataFrame<T> =
+    Aggregators.mean(skipNA).aggregateOf(this, name, expression)
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.mean(skipNA: Boolean = skipNA_default, separate: Boolean = false): DataRow<T> = meanFor(skipNA, separate, numberColumns())
+
+public fun <T, C : Number> Pivot<T>.meanFor(
+    skipNA: Boolean = skipNA_default,
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, C?>
+): DataRow<T> = delegate { meanFor(skipNA, separate, columns) }
+public fun <T> Pivot<T>.meanFor(
+    vararg columns: String,
+    skipNA: Boolean = skipNA_default,
+    separate: Boolean = false
+): DataRow<T> = meanFor(skipNA, separate) { columns.toNumberColumns() }
+public fun <T, C : Number> Pivot<T>.meanFor(
+    vararg columns: ColumnReference<C?>,
+    skipNA: Boolean = skipNA_default,
+    separate: Boolean = false
+): DataRow<T> = meanFor(skipNA, separate) { columns.toColumns() }
+public fun <T, C : Number> Pivot<T>.meanFor(
+    vararg columns: KProperty<C?>,
+    skipNA: Boolean = skipNA_default,
+    separate: Boolean = false
+): DataRow<T> = meanFor(skipNA, separate) { columns.toColumns() }
+
+public fun <T, R : Number> Pivot<T>.mean(skipNA: Boolean = skipNA_default, columns: ColumnsSelector<T, R?>): DataRow<T> =
+    delegate { mean(skipNA, columns) }
+
+public inline fun <T, reified R : Number> Pivot<T>.meanOf(
+    skipNA: Boolean = skipNA_default,
+    crossinline expression: RowExpression<T, R?>
+): DataRow<T> =
+    delegate { meanOf(skipNA, expression) }
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.mean(separate: Boolean = false, skipNA: Boolean = skipNA_default): DataFrame<T> = meanFor(skipNA, separate, numberColumns())
+
+public fun <T, C : Number> PivotGroupBy<T>.meanFor(
+    skipNA: Boolean = skipNA_default,
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, C?>
+): DataFrame<T> = Aggregators.mean(skipNA).aggregateFor(this, separate, columns)
+public fun <T> PivotGroupBy<T>.meanFor(
+    vararg columns: String,
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default
+): DataFrame<T> = meanFor(skipNA, separate) { columns.toNumberColumns() }
+public fun <T, C : Number> PivotGroupBy<T>.meanFor(
+    vararg columns: ColumnReference<C?>,
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+): DataFrame<T> = meanFor(skipNA, separate) { columns.toColumns() }
+public fun <T, C : Number> PivotGroupBy<T>.meanFor(
+    vararg columns: KProperty<C?>,
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+): DataFrame<T> = meanFor(skipNA, separate) { columns.toColumns() }
+
+public fun <T, R : Number> PivotGroupBy<T>.mean(skipNA: Boolean = skipNA_default, columns: ColumnsSelector<T, R?>): DataFrame<T> =
+    Aggregators.mean(skipNA).aggregateAll(this, columns)
+public fun <T> PivotGroupBy<T>.mean(vararg columns: String, skipNA: Boolean = skipNA_default): DataFrame<T> = mean(skipNA) { columns.toColumnsOf() }
+public fun <T, R : Number> PivotGroupBy<T>.mean(vararg columns: ColumnReference<R?>, skipNA: Boolean = skipNA_default): DataFrame<T> = mean(skipNA) { columns.toColumns() }
+public fun <T, R : Number> PivotGroupBy<T>.mean(vararg columns: KProperty<R?>, skipNA: Boolean = skipNA_default): DataFrame<T> = mean(skipNA) { columns.toColumns() }
+
+public inline fun <T, reified R : Number> PivotGroupBy<T>.meanOf(
+    skipNA: Boolean = skipNA_default,
+    crossinline expression: RowExpression<T, R?>
+): DataFrame<T> =
+    Aggregators.mean(skipNA).aggregateOf(this, expression)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt
new file mode 100644
index 000000000..81fcd39db
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt
@@ -0,0 +1,150 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelector
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.comparableColumns
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateFor
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOf
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.of
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.impl.columns.toComparableColumns
+import org.jetbrains.kotlinx.dataframe.impl.suggestIfNull
+import org.jetbrains.kotlinx.dataframe.math.medianOrNull
+import kotlin.reflect.KProperty
+
+// region DataColumn
+
+public fun <T : Comparable<T>> DataColumn<T?>.median(): T = medianOrNull().suggestIfNull("median")
+public fun <T : Comparable<T>> DataColumn<T?>.medianOrNull(): T? = Aggregators.median.cast<T>().aggregate(this)
+
+public inline fun <T, reified R : Comparable<R>> DataColumn<T>.medianOfOrNull(noinline expression: (T) -> R?): R? = Aggregators.median.cast<R?>().aggregateOf(this, expression)
+public inline fun <T, reified R : Comparable<R>> DataColumn<T>.medianOf(noinline expression: (T) -> R?): R = medianOfOrNull(expression).suggestIfNull("medianOf")
+
+// endregion
+
+// region DataRow
+
+public fun AnyRow.rowMedianOrNull(): Any? = org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators.median.aggregateMixed(values().filterIsInstance<Comparable<Any?>>().asIterable())
+public fun AnyRow.rowMedian(): Any = rowMedianOrNull().suggestIfNull("rowMedian")
+public inline fun <reified T : Comparable<T>> AnyRow.rowMedianOfOrNull(): T? = valuesOf<T>().medianOrNull()
+public inline fun <reified T : Comparable<T>> AnyRow.rowMedianOf(): T = rowMedianOfOrNull<T>().suggestIfNull("rowMedianOf")
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.median(): DataRow<T> = medianFor(comparableColumns())
+
+public fun <T, C : Comparable<C>> DataFrame<T>.medianFor(columns: ColumnsForAggregateSelector<T, C?>): DataRow<T> = Aggregators.median.aggregateFor(this, columns)
+public fun <T> DataFrame<T>.medianFor(vararg columns: String): DataRow<T> = medianFor { columns.toComparableColumns() }
+public fun <T, C : Comparable<C>> DataFrame<T>.medianFor(vararg columns: ColumnReference<C?>): DataRow<T> = medianFor { columns.toColumns() }
+public fun <T, C : Comparable<C>> DataFrame<T>.medianFor(vararg columns: KProperty<C?>): DataRow<T> = medianFor { columns.toColumns() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.median(columns: ColumnsSelector<T, C?>): C = medianOrNull(columns).suggestIfNull("median")
+public fun <T> DataFrame<T>.median(vararg columns: String): Any = median { columns.toComparableColumns() }
+public fun <T, C : Comparable<C>> DataFrame<T>.median(vararg columns: ColumnReference<C?>): C = median { columns.toColumns() }
+public fun <T, C : Comparable<C>> DataFrame<T>.median(vararg columns: KProperty<C?>): C = median { columns.toColumns() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.medianOrNull(columns: ColumnsSelector<T, C?>): C? = Aggregators.median.aggregateAll(this, columns) as C?
+public fun <T> DataFrame<T>.medianOrNull(vararg columns: String): Any? = medianOrNull { columns.toComparableColumns() }
+public fun <T, C : Comparable<C>> DataFrame<T>.medianOrNull(vararg columns: ColumnReference<C?>): C? = medianOrNull { columns.toColumns() }
+public fun <T, C : Comparable<C>> DataFrame<T>.medianOrNull(vararg columns: KProperty<C?>): C? = medianOrNull { columns.toColumns() }
+
+public inline fun <T, reified R : Comparable<R>> DataFrame<T>.medianOf(crossinline expression: RowExpression<T, R?>): R? = Aggregators.median.of(this, expression) as R?
+
+// endregion
+
+// region GroupBy
+
+public fun <T> Grouped<T>.median(): DataFrame<T> = medianFor(comparableColumns())
+
+public fun <T, C : Comparable<C>> Grouped<T>.medianFor(columns: ColumnsForAggregateSelector<T, C?>): DataFrame<T> = Aggregators.median.aggregateFor(this, columns)
+public fun <T> Grouped<T>.medianFor(vararg columns: String): DataFrame<T> = medianFor { columns.toComparableColumns() }
+public fun <T, C : Comparable<C>> Grouped<T>.medianFor(vararg columns: ColumnReference<C?>): DataFrame<T> = medianFor { columns.toColumns() }
+public fun <T, C : Comparable<C>> Grouped<T>.medianFor(vararg columns: KProperty<C?>): DataFrame<T> = medianFor { columns.toColumns() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.median(name: String? = null, columns: ColumnsSelector<T, C?>): DataFrame<T> = Aggregators.median.aggregateAll(this, name, columns)
+public fun <T> Grouped<T>.median(vararg columns: String, name: String? = null): DataFrame<T> = median(name) { columns.toComparableColumns() }
+public fun <T, C : Comparable<C>> Grouped<T>.median(
+    vararg columns: ColumnReference<C?>,
+    name: String? = null
+): DataFrame<T> = median(name) { columns.toColumns() }
+public fun <T, C : Comparable<C>> Grouped<T>.median(vararg columns: KProperty<C?>, name: String? = null): DataFrame<T> = median(name) { columns.toColumns() }
+
+public inline fun <T, reified R : Comparable<R>> Grouped<T>.medianOf(
+    name: String? = null,
+    crossinline expression: RowExpression<T, R?>
+): DataFrame<T> = Aggregators.median.aggregateOf(this, name, expression)
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.median(separate: Boolean = false): DataRow<T> = medianFor(separate, comparableColumns())
+
+public fun <T, C : Comparable<C>> Pivot<T>.medianFor(
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, C?>
+): DataRow<T> = delegate { medianFor(separate, columns) }
+public fun <T> Pivot<T>.medianFor(vararg columns: String, separate: Boolean = false): DataRow<T> = medianFor(separate) { columns.toComparableColumns() }
+public fun <T, C : Comparable<C>> Pivot<T>.medianFor(
+    vararg columns: ColumnReference<C?>,
+    separate: Boolean = false
+): DataRow<T> = medianFor(separate) { columns.toColumns() }
+public fun <T, C : Comparable<C>> Pivot<T>.medianFor(
+    vararg columns: KProperty<C?>,
+    separate: Boolean = false
+): DataRow<T> = medianFor(separate) { columns.toColumns() }
+
+public fun <T, C : Comparable<C>> Pivot<T>.median(columns: ColumnsSelector<T, C?>): DataRow<T> = delegate { median(columns) }
+public fun <T> Pivot<T>.median(vararg columns: String): DataRow<T> = median { columns.toComparableColumns() }
+public fun <T, C : Comparable<C>> Pivot<T>.median(
+    vararg columns: ColumnReference<C?>
+): DataRow<T> = median { columns.toColumns() }
+public fun <T, C : Comparable<C>> Pivot<T>.median(vararg columns: KProperty<C?>): DataRow<T> = median { columns.toColumns() }
+
+public inline fun <T, reified R : Comparable<R>> Pivot<T>.medianOf(
+    crossinline expression: RowExpression<T, R?>
+): DataRow<T> = delegate { medianOf(expression) }
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.median(separate: Boolean = false): DataFrame<T> = medianFor(separate, comparableColumns())
+
+public fun <T, C : Comparable<C>> PivotGroupBy<T>.medianFor(
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, C?>
+): DataFrame<T> = Aggregators.median.aggregateFor(this, separate, columns)
+public fun <T> PivotGroupBy<T>.medianFor(vararg columns: String, separate: Boolean = false): DataFrame<T> = medianFor(separate) { columns.toComparableColumns() }
+public fun <T, C : Comparable<C>> PivotGroupBy<T>.medianFor(
+    vararg columns: ColumnReference<C?>,
+    separate: Boolean = false
+): DataFrame<T> = medianFor(separate) { columns.toColumns() }
+public fun <T, C : Comparable<C>> PivotGroupBy<T>.medianFor(
+    vararg columns: KProperty<C?>,
+    separate: Boolean = false
+): DataFrame<T> = medianFor(separate) { columns.toColumns() }
+
+public fun <T, C : Comparable<C>> PivotGroupBy<T>.median(columns: ColumnsSelector<T, C?>): DataFrame<T> = Aggregators.median.aggregateAll(this, columns)
+public fun <T> PivotGroupBy<T>.median(vararg columns: String): DataFrame<T> = median { columns.toComparableColumns() }
+public fun <T, C : Comparable<C>> PivotGroupBy<T>.median(
+    vararg columns: ColumnReference<C?>
+): DataFrame<T> = median { columns.toColumns() }
+public fun <T, C : Comparable<C>> PivotGroupBy<T>.median(vararg columns: KProperty<C?>): DataFrame<T> = median { columns.toColumns() }
+
+public inline fun <T, reified R : Comparable<R>> PivotGroupBy<T>.medianOf(
+    crossinline expression: RowExpression<T, R?>
+): DataFrame<T> = Aggregators.median.aggregateOf(this, expression)
+
+// endregion
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
new file mode 100644
index 000000000..29cc85521
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/merge.kt
@@ -0,0 +1,104 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.api.removeImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.withRowCellImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.impl.nameGenerator
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+public fun <T, C> DataFrame<T>.merge(selector: ColumnsSelector<T, C>): Merge<T, C, List<C>> =
+    Merge(this, selector, false, { it }, typeOf<Any?>(), Infer.Type)
+
+public fun <T> DataFrame<T>.merge(vararg columns: String): Merge<T, Any?, List<Any?>> =
+    merge { columns.toColumns() }
+
+public inline fun <T, reified C> DataFrame<T>.merge(vararg columns: ColumnReference<C>): Merge<T, C, List<C>> =
+    merge { columns.toColumns() }
+
+public inline fun <T, reified C> DataFrame<T>.merge(vararg columns: KProperty<C>): Merge<T, C, List<C>> =
+    merge { columns.toColumns() }
+
+public data class Merge<T, C, R>(
+    @PublishedApi
+    internal val df: DataFrame<T>,
+    @PublishedApi
+    internal val selector: ColumnsSelector<T, C>,
+    @PublishedApi
+    internal val notNull: Boolean,
+    @PublishedApi
+    internal val transform: DataRow<T>.(List<C>) -> R,
+    @PublishedApi
+    internal val resultType: KType,
+    @PublishedApi
+    internal val infer: Infer,
+)
+
+public fun <T, C, R> Merge<T, C, R>.notNull(): Merge<T, C, R> = copy(notNull = true)
+
+public fun <T, C, R> Merge<T, C, R>.into(columnName: String): DataFrame<T> = into(pathOf(columnName))
+public fun <T, C, R> Merge<T, C, R>.into(column: ColumnAccessor<*>): DataFrame<T> = into(column.path())
+
+public fun <T, C, R> Merge<T, C, R>.intoList(): List<R> =
+    df.select(selector).rows().map { transform(it, it.values() as List<C>) }
+
+public fun <T, C, R> Merge<T, C, R>.into(path: ColumnPath): DataFrame<T> {
+    // If target path exists, merge into temp path
+    val mergePath = if (df.getColumnOrNull(path) != null) pathOf(nameGenerator().addUnique("temp")) else path
+
+    // move columns into group
+    val grouped = df.move(selector).under { mergePath }
+
+    var res = grouped.convert { getColumnGroup(mergePath) }.withRowCellImpl(resultType, infer) {
+        val srcRow = df[index()]
+        var values = it.values() as List<C>
+        if (notNull) {
+            values = values.filter {
+                it != null && (it !is AnyRow || !it.isEmpty())
+            }
+        }
+        transform(srcRow, values)
+    }
+    if (mergePath != path) {
+        // target path existed before merge, but
+        // it may have already been removed
+        res = res.removeImpl(allowMissingColumns = true) { path }.df.move(mergePath).into { path }
+    }
+    return res
+}
+
+public fun <T, C, R> Merge<T, C, R>.asStrings(): Merge<T, C, String> = by(", ")
+public fun <T, C, R> Merge<T, C, R>.by(
+    separator: CharSequence = ", ",
+    prefix: CharSequence = "",
+    postfix: CharSequence = "",
+    limit: Int = -1,
+    truncated: CharSequence = "..."
+): Merge<T, C, String> =
+    Merge(
+        df, selector, notNull,
+        transform = {
+            it.joinToString(
+                separator = separator,
+                prefix = prefix,
+                postfix = postfix,
+                limit = limit,
+                truncated = truncated
+            )
+        },
+        typeOf<String>(), Infer.Nulls
+    )
+
+public inline fun <T, C, R, reified V> Merge<T, C, R>.by(
+    infer: Infer = Infer.Nulls,
+    crossinline transform: DataRow<T>.(R) -> V
+): Merge<T, C, V> =
+    Merge(df, selector, notNull, { transform(this@by.transform(this, it)) }, typeOf<V>(), infer)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt
new file mode 100644
index 000000000..7cc69e6c8
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt
@@ -0,0 +1,170 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelector
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.comparableColumns
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateFor
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOfDelegated
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.impl.columns.toComparableColumns
+import org.jetbrains.kotlinx.dataframe.impl.indexOfMin
+import org.jetbrains.kotlinx.dataframe.impl.suggestIfNull
+import kotlin.reflect.KProperty
+
+// region DataColumn
+
+public fun <T : Comparable<T>> DataColumn<T?>.min(): T = minOrNull().suggestIfNull("min")
+public fun <T : Comparable<T>> DataColumn<T?>.minOrNull(): T? = asSequence().filterNotNull().minOrNull()
+
+public fun <T, R : Comparable<R>> DataColumn<T>.minBy(selector: (T) -> R): T = minByOrNull(selector).suggestIfNull("minBy")
+public fun <T, R : Comparable<R>> DataColumn<T>.minByOrNull(selector: (T) -> R): T? = values.minByOrNull(selector)
+
+public fun <T, R : Comparable<R>> DataColumn<T>.minOf(selector: (T) -> R): R = minOfOrNull(selector).suggestIfNull("minOf")
+public fun <T, R : Comparable<R>> DataColumn<T>.minOfOrNull(selector: (T) -> R): R? = values.minOfOrNull(selector)
+
+// endregion
+
+// region DataRow
+
+public fun AnyRow.rowMinOrNull(): Any? = values().filterIsInstance<Comparable<*>>().minWithOrNull(compareBy { it })
+public fun AnyRow.rowMin(): Any = rowMinOrNull().suggestIfNull("rowMin")
+public inline fun <reified T : Comparable<T>> AnyRow.rowMinOfOrNull(): T? = values().filterIsInstance<T>().minOrNull()
+public inline fun <reified T : Comparable<T>> AnyRow.rowMinOf(): T = rowMinOfOrNull<T>().suggestIfNull("rowMinOf")
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.min(): DataRow<T> = minFor(comparableColumns())
+
+public fun <T, C : Comparable<C>> DataFrame<T>.minFor(columns: ColumnsForAggregateSelector<T, C?>): DataRow<T> = Aggregators.min.aggregateFor(this, columns)
+public fun <T> DataFrame<T>.minFor(vararg columns: String): DataRow<T> = minFor { columns.toComparableColumns() }
+public fun <T, C : Comparable<C>> DataFrame<T>.minFor(vararg columns: ColumnReference<C?>): DataRow<T> = minFor { columns.toColumns() }
+public fun <T, C : Comparable<C>> DataFrame<T>.minFor(vararg columns: KProperty<C?>): DataRow<T> = minFor { columns.toColumns() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.min(columns: ColumnsSelector<T, C?>): C = minOrNull(columns).suggestIfNull("min")
+public fun <T> DataFrame<T>.min(vararg columns: String): Comparable<Any> = minOrNull(*columns).suggestIfNull("min")
+public fun <T, C : Comparable<C>> DataFrame<T>.min(vararg columns: ColumnReference<C?>): C = minOrNull(*columns).suggestIfNull("min")
+public fun <T, C : Comparable<C>> DataFrame<T>.min(vararg columns: KProperty<C?>): C = minOrNull(*columns).suggestIfNull("min")
+
+public fun <T, C : Comparable<C>> DataFrame<T>.minOrNull(columns: ColumnsSelector<T, C?>): C? = Aggregators.min.aggregateAll(this, columns) as C?
+public fun <T> DataFrame<T>.minOrNull(vararg columns: String): Comparable<Any?>? = minOrNull { columns.toComparableColumns() }
+public fun <T, C : Comparable<C>> DataFrame<T>.minOrNull(vararg columns: ColumnReference<C?>): C? = minOrNull { columns.toColumns() }
+public fun <T, C : Comparable<C>> DataFrame<T>.minOrNull(vararg columns: KProperty<C?>): C? = minOrNull { columns.toColumns() }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.minOf(expression: RowExpression<T, C>): C = minOfOrNull(expression).suggestIfNull("minOf")
+public fun <T, C : Comparable<C>> DataFrame<T>.minOfOrNull(expression: RowExpression<T, C>): C? = rows().minOfOrNull { expression(it, it) }
+
+public fun <T, C : Comparable<C>> DataFrame<T>.minBy(expression: RowExpression<T, C?>): DataRow<T> = minByOrNull(expression).suggestIfNull("minBy")
+public fun <T> DataFrame<T>.minBy(column: String): DataRow<T> = minByOrNull(column).suggestIfNull("minBy")
+public fun <T, C : Comparable<C>> DataFrame<T>.minBy(column: ColumnReference<C?>): DataRow<T> = minByOrNull(column).suggestIfNull("minBy")
+public fun <T, C : Comparable<C>> DataFrame<T>.minBy(column: KProperty<C?>): DataRow<T> = minByOrNull(column).suggestIfNull("minBy")
+
+public fun <T, C : Comparable<C>> DataFrame<T>.minByOrNull(expression: RowExpression<T, C?>): DataRow<T>? = getOrNull(rows().asSequence().map { expression(it, it) }.indexOfMin())
+public fun <T> DataFrame<T>.minByOrNull(column: String): DataRow<T>? = minByOrNull(column.toColumnOf<Comparable<Any?>?>())
+public fun <T, C : Comparable<C>> DataFrame<T>.minByOrNull(column: ColumnReference<C?>): DataRow<T>? = getOrNull(get(column).asSequence().indexOfMin())
+public fun <T, C : Comparable<C>> DataFrame<T>.minByOrNull(column: KProperty<C?>): DataRow<T>? = minByOrNull(column.toColumnAccessor())
+
+// endregion
+
+// region GroupBy
+
+public fun <T> Grouped<T>.min(): DataFrame<T> = minFor(comparableColumns())
+
+public fun <T, C : Comparable<C>> Grouped<T>.minFor(columns: ColumnsForAggregateSelector<T, C?>): DataFrame<T> = Aggregators.min.aggregateFor(this, columns)
+public fun <T> Grouped<T>.minFor(vararg columns: String): DataFrame<T> = minFor { columns.toComparableColumns() }
+public fun <T, C : Comparable<C>> Grouped<T>.minFor(vararg columns: ColumnReference<C?>): DataFrame<T> = minFor { columns.toColumns() }
+public fun <T, C : Comparable<C>> Grouped<T>.minFor(vararg columns: KProperty<C?>): DataFrame<T> = minFor { columns.toColumns() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.min(
+    name: String? = null,
+    columns: ColumnsSelector<T, C?>
+): DataFrame<T> =
+    Aggregators.min.aggregateAll(this, name, columns)
+public fun <T> Grouped<T>.min(vararg columns: String, name: String? = null): DataFrame<T> = min(name) { columns.toComparableColumns() }
+public fun <T, C : Comparable<C>> Grouped<T>.min(vararg columns: ColumnReference<C?>, name: String? = null): DataFrame<T> = min(name) { columns.toColumns() }
+public fun <T, C : Comparable<C>> Grouped<T>.min(vararg columns: KProperty<C?>, name: String? = null): DataFrame<T> = min(name) { columns.toColumns() }
+
+public fun <T, C : Comparable<C>> Grouped<T>.minOf(name: String? = null, expression: RowExpression<T, C>): DataFrame<T> =
+    Aggregators.min.aggregateOfDelegated(this, name) { minOfOrNull(expression) }
+
+public fun <T, G, R : Comparable<R>> GroupBy<T, G>.minBy(rowExpression: RowExpression<G, R?>): ReducedGroupBy<T, G> = reduce { minByOrNull(rowExpression) }
+public fun <T, G, C : Comparable<C>> GroupBy<T, G>.minBy(column: ColumnReference<C?>): ReducedGroupBy<T, G> = reduce { minByOrNull(column) }
+public fun <T, G> GroupBy<T, G>.minBy(column: String): ReducedGroupBy<T, G> = minBy(column.toColumnAccessor().cast<Comparable<Any?>>())
+public fun <T, G, C : Comparable<C>> GroupBy<T, G>.minBy(column: KProperty<C?>): ReducedGroupBy<T, G> = minBy(column.toColumnAccessor())
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.min(separate: Boolean = false): DataRow<T> = delegate { min(separate) }
+
+public fun <T, R : Comparable<R>> Pivot<T>.minFor(
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, R?>
+): DataRow<T> = delegate { minFor(separate, columns) }
+public fun <T> Pivot<T>.minFor(vararg columns: String, separate: Boolean = false): DataRow<T> = minFor(separate) { columns.toComparableColumns() }
+public fun <T, R : Comparable<R>> Pivot<T>.minFor(
+    vararg columns: ColumnReference<R?>,
+    separate: Boolean = false
+): DataRow<T> = minFor(separate) { columns.toColumns() }
+public fun <T, R : Comparable<R>> Pivot<T>.minFor(
+    vararg columns: KProperty<R?>,
+    separate: Boolean = false
+): DataRow<T> = minFor(separate) { columns.toColumns() }
+
+public fun <T, R : Comparable<R>> Pivot<T>.min(columns: ColumnsSelector<T, R?>): DataRow<T> = delegate { min(columns) }
+public fun <T, R : Comparable<R>> Pivot<T>.min(vararg columns: String): DataRow<T> = min { columns.toComparableColumns() }
+public fun <T, R : Comparable<R>> Pivot<T>.min(vararg columns: ColumnReference<R?>): DataRow<T> = min { columns.toColumns() }
+public fun <T, R : Comparable<R>> Pivot<T>.min(vararg columns: KProperty<R?>): DataRow<T> = min { columns.toColumns() }
+
+public fun <T, R : Comparable<R>> Pivot<T>.minOf(rowExpression: RowExpression<T, R>): DataRow<T> = delegate { minOf(rowExpression) }
+
+public fun <T, R : Comparable<R>> Pivot<T>.minBy(rowExpression: RowExpression<T, R>): ReducedPivot<T> = reduce { minByOrNull(rowExpression) }
+public fun <T, C : Comparable<C>> Pivot<T>.minBy(column: ColumnReference<C?>): ReducedPivot<T> = reduce { minByOrNull(column) }
+public fun <T> Pivot<T>.minBy(column: String): ReducedPivot<T> = minBy(column.toColumnAccessor().cast<Comparable<Any?>>())
+public fun <T, C : Comparable<C>> Pivot<T>.minBy(column: KProperty<C?>): ReducedPivot<T> = minBy(column.toColumnAccessor())
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.min(separate: Boolean = false): DataFrame<T> = minFor(separate, comparableColumns())
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.minFor(
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, R?>
+): DataFrame<T> =
+    Aggregators.min.aggregateFor(this, separate, columns)
+public fun <T> PivotGroupBy<T>.minFor(vararg columns: String, separate: Boolean = false): DataFrame<T> = minFor(separate) { columns.toComparableColumns() }
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.minFor(
+    vararg columns: ColumnReference<R?>,
+    separate: Boolean = false
+): DataFrame<T> = minFor(separate) { columns.toColumns() }
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.minFor(
+    vararg columns: KProperty<R?>,
+    separate: Boolean = false
+): DataFrame<T> = minFor(separate) { columns.toColumns() }
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.min(columns: ColumnsSelector<T, R?>): DataFrame<T> = Aggregators.min.aggregateAll(this, columns)
+public fun <T> PivotGroupBy<T>.min(vararg columns: String): DataFrame<T> = min { columns.toComparableColumns() }
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.min(vararg columns: ColumnReference<R?>): DataFrame<T> = min { columns.toColumns() }
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.min(vararg columns: KProperty<R?>): DataFrame<T> = min { columns.toColumns() }
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.minOf(rowExpression: RowExpression<T, R>): DataFrame<T> = aggregate { minOf(rowExpression) }
+
+public fun <T, R : Comparable<R>> PivotGroupBy<T>.minBy(rowExpression: RowExpression<T, R>): ReducedPivotGroupBy<T> = reduce { minByOrNull(rowExpression) }
+public fun <T, C : Comparable<C>> PivotGroupBy<T>.minBy(column: ColumnReference<C?>): ReducedPivotGroupBy<T> = reduce { minByOrNull(column) }
+public fun <T> PivotGroupBy<T>.minBy(column: String): ReducedPivotGroupBy<T> = minBy(column.toColumnAccessor().cast<Comparable<Any?>>())
+public fun <T, C : Comparable<C>> PivotGroupBy<T>.minBy(column: KProperty<C?>): ReducedPivotGroupBy<T> = minBy(column.toColumnAccessor())
+
+// endregion
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
new file mode 100644
index 000000000..5a01944c5
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
@@ -0,0 +1,84 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyColumnGroupAccessor
+import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.impl.api.afterOrBefore
+import org.jetbrains.kotlinx.dataframe.impl.api.moveImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.moveTo
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.ncol
+import kotlin.reflect.KProperty
+
+public fun <T, C> DataFrame<T>.move(columns: ColumnsSelector<T, C>): MoveClause<T, C> = MoveClause(this, columns)
+public fun <T> DataFrame<T>.move(vararg cols: String): MoveClause<T, Any?> = move { cols.toColumns() }
+public fun <T, C> DataFrame<T>.move(vararg cols: ColumnReference<C>): MoveClause<T, C> = move { cols.toColumns() }
+public fun <T, C> DataFrame<T>.move(vararg cols: KProperty<C>): MoveClause<T, C> = move { cols.toColumns() }
+
+public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, columns: ColumnsSelector<T, *>): DataFrame<T> = move(columns).to(newColumnIndex)
+public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, vararg columns: String): DataFrame<T> = moveTo(newColumnIndex) { columns.toColumns() }
+public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, vararg columns: Column): DataFrame<T> = moveTo(newColumnIndex) { columns.toColumns() }
+public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, vararg columns: KProperty<*>): DataFrame<T> = moveTo(newColumnIndex) { columns.toColumns() }
+
+public fun <T> DataFrame<T>.moveToLeft(columns: ColumnsSelector<T, *>): DataFrame<T> = move(columns).toLeft()
+public fun <T> DataFrame<T>.moveToLeft(vararg columns: String): DataFrame<T> = moveToLeft { columns.toColumns() }
+public fun <T> DataFrame<T>.moveToLeft(vararg columns: Column): DataFrame<T> = moveToLeft { columns.toColumns() }
+public fun <T> DataFrame<T>.moveToLeft(vararg columns: KProperty<*>): DataFrame<T> = moveToLeft { columns.toColumns() }
+
+public fun <T> DataFrame<T>.moveToRight(columns: ColumnsSelector<T, *>): DataFrame<T> = move(columns).toRight()
+public fun <T> DataFrame<T>.moveToRight(vararg columns: String): DataFrame<T> = moveToRight { columns.toColumns() }
+public fun <T> DataFrame<T>.moveToRight(vararg columns: Column): DataFrame<T> = moveToRight { columns.toColumns() }
+public fun <T> DataFrame<T>.moveToRight(vararg columns: KProperty<*>): DataFrame<T> = moveToRight { columns.toColumns() }
+
+public fun <T, C> MoveClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> Column): DataFrame<T> = moveImpl(
+    under = false,
+    column
+)
+
+public fun <T, C> MoveClause<T, C>.into(column: String): DataFrame<T> = pathOf(column).let { path -> into { path } }
+
+public fun <T, C> MoveClause<T, C>.intoIndexed(
+    newPathExpression: ColumnsSelectionDsl<T>.(ColumnWithPath<C>, Int) -> Column
+): DataFrame<T> {
+    var counter = 0
+    return into { col ->
+        newPathExpression(this, col, counter++)
+    }
+}
+
+public fun <T, C> MoveClause<T, C>.under(column: String): DataFrame<T> = pathOf(column).let { path -> under { path } }
+public fun <T, C> MoveClause<T, C>.under(column: AnyColumnGroupAccessor): DataFrame<T> = column.path().let { path -> under { path } }
+public fun <T, C> MoveClause<T, C>.under(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> Column): DataFrame<T> = moveImpl(
+    under = true,
+    column
+)
+
+public fun <T, C> MoveClause<T, C>.to(columnIndex: Int): DataFrame<T> = moveTo(columnIndex)
+
+public fun <T, C> MoveClause<T, C>.toTop(
+    newColumnName: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> String = { it.name() }
+): DataFrame<T> =
+    into { newColumnName(it).toColumnAccessor() }
+
+public fun <T, C> MoveClause<T, C>.after(column: ColumnSelector<T, *>): DataFrame<T> = afterOrBefore(column, true)
+public fun <T, C> MoveClause<T, C>.after(column: String): DataFrame<T> = after { column.toColumnAccessor() }
+public fun <T, C> MoveClause<T, C>.after(column: Column): DataFrame<T> = after { column }
+public fun <T, C> MoveClause<T, C>.after(column: KProperty<*>): DataFrame<T> = after { column.toColumnAccessor() }
+
+// TODO: implement 'before'
+/*
+fun <T, C> MoveColsClause<T, C>.before(columnPath: ColumnPath) = before { columnPath.toColumnDef() }
+fun <T, C> MoveColsClause<T, C>.before(column: Column) = before { column }
+fun <T, C> MoveColsClause<T, C>.before(column: KProperty<*>) = before { column.toColumnDef() }
+fun <T, C> MoveColsClause<T, C>.before(column: String) = before { column.toColumnDef() }
+fun <T, C> MoveColsClause<T, C>.before(column: ColumnSelector<T, *>) = afterOrBefore(column, false)
+*/
+
+public fun <T, C> MoveClause<T, C>.toLeft(): DataFrame<T> = to(0)
+public fun <T, C> MoveClause<T, C>.toRight(): DataFrame<T> = to(df.ncol)
+
+public class MoveClause<T, C>(internal val df: DataFrame<T>, internal val columns: ColumnsSelector<T, C>)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/parse.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/parse.kt
new file mode 100644
index 000000000..309da276d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/parse.kt
@@ -0,0 +1,65 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.api.Parsers
+import org.jetbrains.kotlinx.dataframe.impl.api.parseImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.tryParseImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.typeClass
+import java.time.format.DateTimeFormatter
+import java.util.Locale
+import kotlin.reflect.KProperty
+
+public val DataFrame.Companion.parser: GlobalParserOptions get() = Parsers
+
+public fun <T> DataFrame<T>.parse(options: ParserOptions? = null, columns: ColumnsSelector<T, Any?>): DataFrame<T> =
+    parseImpl(options, columns)
+
+public fun <T> DataFrame<T>.parse(vararg columns: String, options: ParserOptions? = null): DataFrame<T> =
+    parse(options) { columns.toColumns() }
+
+public fun <T, C> DataFrame<T>.parse(vararg columns: ColumnReference<C>, options: ParserOptions? = null): DataFrame<T> =
+    parse(options) { columns.toColumns() }
+
+public fun <T, C> DataFrame<T>.parse(vararg columns: KProperty<C>, options: ParserOptions? = null): DataFrame<T> =
+    parse(options) { columns.toColumns() }
+
+public interface GlobalParserOptions {
+
+    public fun addDateTimePattern(pattern: String)
+
+    public fun addNullString(str: String)
+
+    public fun resetToDefault()
+
+    public var locale: Locale
+}
+
+public data class ParserOptions(
+    val locale: Locale? = null,
+    val dateTimeFormatter: DateTimeFormatter? = null,
+    val dateTimePattern: String? = null,
+    val nullStrings: Set<String>? = null
+) {
+    internal fun getDateTimeFormatter(): DateTimeFormatter? = when {
+        dateTimeFormatter != null -> dateTimeFormatter
+        dateTimePattern != null && locale != null -> DateTimeFormatter.ofPattern(dateTimePattern, locale)
+        dateTimePattern != null -> DateTimeFormatter.ofPattern(dateTimePattern)
+        else -> null
+    }
+}
+
+public fun DataColumn<String?>.tryParse(options: ParserOptions? = null): DataColumn<*> = tryParseImpl(options)
+
+public fun <T> DataFrame<T>.parse(options: ParserOptions? = null): DataFrame<T> = parse(options) { allDfs() }
+
+public fun DataColumn<String?>.parse(options: ParserOptions? = null): DataColumn<*> =
+    tryParse(options).also { if (it.typeClass == String::class) error("Can't guess column type") }
+
+@JvmName("parseAnyFrameNullable")
+public fun DataColumn<AnyFrame?>.parse(options: ParserOptions? = null): DataColumn<AnyFrame?> =
+    map { it?.parse(options) }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
new file mode 100644
index 000000000..c4023430c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
@@ -0,0 +1,125 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.aggregation.Aggregatable
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateBody
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedDsl
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.PivotGroupByImpl
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.PivotImpl
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.PivotInAggregateImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.PivotChainColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import kotlin.reflect.KProperty
+
+public interface PivotDsl<out T> : ColumnsSelectionDsl<T> {
+
+    public infix fun <C> ColumnSet<C>.then(other: ColumnSet<C>): ColumnSet<C> = PivotChainColumnSet(this, other)
+
+    public infix fun <C> String.then(other: ColumnSet<C>): ColumnSet<C> = toColumnOf<C>() then other
+
+    public infix fun <C> ColumnSet<C>.then(other: String): ColumnSet<C> = this then other.toColumnOf()
+
+    public infix fun String.then(other: String): ColumnSet<Any?> = toColumnAccessor() then other.toColumnAccessor()
+
+    public infix fun <C> KProperty<C>.then(other: ColumnSet<C>): ColumnSet<C> = toColumnAccessor() then other
+
+    public infix fun <C> ColumnSet<C>.then(other: KProperty<C>): ColumnSet<C> = this then other.toColumnAccessor()
+
+    public infix fun <C> KProperty<C>.then(other: KProperty<C>): ColumnSet<C> = toColumnAccessor() then other.toColumnAccessor()
+
+    public infix fun <C> KProperty<C>.then(other: String): ColumnSet<C> = toColumnAccessor() then other.toColumnOf()
+
+    public infix fun <C> String.then(other: KProperty<C>): ColumnSet<C> = toColumnOf<C>() then other.toColumnAccessor()
+}
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.pivot(inward: Boolean? = null, columns: PivotColumnsSelector<T, *>): Pivot<T> = PivotImpl(this, columns, inward)
+public fun <T> DataFrame<T>.pivot(vararg columns: String, inward: Boolean? = null): Pivot<T> = pivot(inward) { columns.toColumns() }
+public fun <T> DataFrame<T>.pivot(vararg columns: Column, inward: Boolean? = null): Pivot<T> = pivot(inward) { columns.toColumns() }
+public fun <T> DataFrame<T>.pivot(vararg columns: KProperty<*>, inward: Boolean? = null): Pivot<T> = pivot(inward) { columns.toColumns() }
+
+public fun <T> DataFrame<T>.pivotMatches(inward: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T> = pivot(inward, columns).groupByOther().matches()
+public fun <T> DataFrame<T>.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
+public fun <T> DataFrame<T>.pivotMatches(vararg columns: Column, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
+public fun <T> DataFrame<T>.pivotMatches(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
+
+public fun <T> DataFrame<T>.pivotCounts(inward: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T> = pivot(inward, columns).groupByOther().count()
+public fun <T> DataFrame<T>.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
+public fun <T> DataFrame<T>.pivotCounts(vararg columns: Column, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
+public fun <T> DataFrame<T>.pivotCounts(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
+
+// endregion
+
+// region GroupBy
+
+public fun <G> GroupBy<*, G>.pivot(inward: Boolean = true, columns: ColumnsSelector<G, *>): PivotGroupBy<G> = PivotGroupByImpl(this, columns, inward)
+public fun <G> GroupBy<*, G>.pivot(vararg columns: Column, inward: Boolean = true): PivotGroupBy<G> = pivot(inward) { columns.toColumns() }
+public fun <G> GroupBy<*, G>.pivot(vararg columns: String, inward: Boolean = true): PivotGroupBy<G> = pivot(inward) { columns.toColumns() }
+public fun <G> GroupBy<*, G>.pivot(vararg columns: KProperty<*>, inward: Boolean = true): PivotGroupBy<G> = pivot(inward) { columns.toColumns() }
+
+public fun <G> GroupBy<*, G>.pivotMatches(inward: Boolean = true, columns: ColumnsSelector<G, *>): DataFrame<G> = pivot(inward, columns).matches()
+public fun <G> GroupBy<*, G>.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame<G> = pivotMatches(inward) { columns.toColumns() }
+public fun <G> GroupBy<*, G>.pivotMatches(vararg columns: Column, inward: Boolean = true): DataFrame<G> = pivotMatches(inward) { columns.toColumns() }
+public fun <G> GroupBy<*, G>.pivotMatches(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<G> = pivotMatches(inward) { columns.toColumns() }
+
+public fun <G> GroupBy<*, G>.pivotCounts(inward: Boolean = true, columns: ColumnsSelector<G, *>): DataFrame<G> = pivot(inward, columns).count()
+public fun <G> GroupBy<*, G>.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame<G> = pivotCounts(inward) { columns.toColumns() }
+public fun <G> GroupBy<*, G>.pivotCounts(vararg columns: Column, inward: Boolean = true): DataFrame<G> = pivotCounts(inward) { columns.toColumns() }
+public fun <G> GroupBy<*, G>.pivotCounts(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<G> = pivotCounts(inward) { columns.toColumns() }
+
+// endregion
+
+// region GroupBy.aggregate
+
+public fun <T> AggregateGroupedDsl<T>.pivot(inward: Boolean = true, columns: ColumnsSelector<T, *>): PivotGroupBy<T> =
+    PivotInAggregateImpl(this, columns, inward)
+public fun <T> AggregateGroupedDsl<T>.pivot(vararg columns: String, inward: Boolean = true): PivotGroupBy<T> = pivot(inward) { columns.toColumns() }
+public fun <T> AggregateGroupedDsl<T>.pivot(vararg columns: Column, inward: Boolean = true): PivotGroupBy<T> = pivot(inward) { columns.toColumns() }
+public fun <T> AggregateGroupedDsl<T>.pivot(vararg columns: KProperty<*>, inward: Boolean = true): PivotGroupBy<T> = pivot(inward) { columns.toColumns() }
+
+public fun <T> AggregateGroupedDsl<T>.pivotMatches(inward: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T> = pivot(inward, columns).matches()
+public fun <T> AggregateGroupedDsl<T>.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
+public fun <T> AggregateGroupedDsl<T>.pivotMatches(vararg columns: Column, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
+public fun <T> AggregateGroupedDsl<T>.pivotMatches(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
+
+public fun <T> AggregateGroupedDsl<T>.pivotCounts(inward: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T> = pivot(inward, columns).matches()
+public fun <T> AggregateGroupedDsl<T>.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
+public fun <T> AggregateGroupedDsl<T>.pivotCounts(vararg columns: Column, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
+public fun <T> AggregateGroupedDsl<T>.pivotCounts(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
+
+// endregion
+
+public interface Pivot<T> : Aggregatable<T>
+
+public typealias PivotColumnsSelector<T, C> = Selector<PivotDsl<T>, ColumnSet<C>>
+
+public data class ReducedPivot<T>(
+    @PublishedApi internal val pivot: Pivot<T>,
+    @PublishedApi internal val reducer: Selector<DataFrame<T>, DataRow<T>?>
+)
+
+internal fun <T> Pivot<T>.reduce(reducer: Selector<DataFrame<T>, DataRow<T>?>) = ReducedPivot(this, reducer)
+
+@PublishedApi
+internal inline fun <T> Pivot<T>.delegate(crossinline body: PivotGroupBy<T>.() -> DataFrame<T>): DataRow<T> = body(groupBy { none() })[0]
+
+public interface PivotGroupBy<out T> : Aggregatable<T> {
+
+    public fun <R> aggregate(separate: Boolean = false, body: AggregateBody<T, R>): DataFrame<T>
+
+    public fun default(value: Any?): PivotGroupBy<T>
+}
+
+public data class ReducedPivotGroupBy<T>(
+    @PublishedApi internal val pivot: PivotGroupBy<T>,
+    @PublishedApi internal val reducer: Selector<DataFrame<T>, DataRow<T>?>
+)
+
+@PublishedApi
+internal fun <T> PivotGroupBy<T>.reduce(reducer: Selector<DataFrame<T>, DataRow<T>?>): ReducedPivotGroupBy<T> = ReducedPivotGroupBy(this, reducer)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/print.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/print.kt
new file mode 100644
index 000000000..08350d782
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/print.kt
@@ -0,0 +1,44 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.io.renderToString
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.print(): Unit = println(this)
+
+// endregion
+
+// region DataRow
+
+public fun <T> DataRow<T>.print(): Unit = println(this)
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.print(
+    rowsLimit: Int = 20,
+    valueLimit: Int = 40,
+    borders: Boolean = false,
+    alignLeft: Boolean = false,
+    columnTypes: Boolean = false,
+    title: Boolean = false
+): Unit = println(renderToString(rowsLimit, valueLimit, borders, alignLeft, columnTypes, title))
+
+// endregion
+
+// region GroupBy
+
+public fun <T, G> GroupBy<T, G>.print(): Unit = println(this)
+
+// endregion
+
+// region DataFrameSchema
+
+public fun DataFrameSchema.print(): Unit = println(this)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt
new file mode 100644
index 000000000..b252b7ed0
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt
@@ -0,0 +1,24 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.impl.api.removeImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.remove(columns: ColumnsSelector<T, *>): DataFrame<T> = removeImpl(allowMissingColumns = true, columns = columns).df
+public fun <T> DataFrame<T>.remove(vararg columns: KProperty<*>): DataFrame<T> = remove { columns.toColumns() }
+public fun <T> DataFrame<T>.remove(vararg columns: String): DataFrame<T> = remove { columns.toColumns() }
+public fun <T> DataFrame<T>.remove(vararg columns: Column): DataFrame<T> = remove { columns.toColumns() }
+public fun <T> DataFrame<T>.remove(columns: Iterable<Column>): DataFrame<T> = remove { columns.toColumnSet() }
+
+public infix operator fun <T> DataFrame<T>.minus(columns: ColumnsSelector<T, *>): DataFrame<T> = remove(columns)
+public infix operator fun <T> DataFrame<T>.minus(column: String): DataFrame<T> = remove(column)
+public infix operator fun <T> DataFrame<T>.minus(column: Column): DataFrame<T> = remove(column)
+public infix operator fun <T> DataFrame<T>.minus(columns: Iterable<Column>): DataFrame<T> = remove(columns)
+
+// 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
new file mode 100644
index 000000000..797df20d1
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt
@@ -0,0 +1,77 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.impl.DELIMITED_STRING_REGEX
+import org.jetbrains.kotlinx.dataframe.impl.DELIMITERS_REGEX
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.impl.toCamelCaseByDelimiters
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.rename(vararg mappings: Pair<String, String>): DataFrame<T> =
+    rename { mappings.map { it.first.toColumnAccessor() }.toColumnSet() }
+        .into(*mappings.map { it.second }.toTypedArray())
+
+public fun <T, C> DataFrame<T>.rename(columns: ColumnsSelector<T, C>): RenameClause<T, C> = RenameClause(this, columns)
+public fun <T, C> DataFrame<T>.rename(vararg cols: ColumnReference<C>): RenameClause<T, C> = rename { cols.toColumns() }
+public fun <T, C> DataFrame<T>.rename(vararg cols: KProperty<C>): RenameClause<T, C> = rename { cols.toColumns() }
+public fun <T> DataFrame<T>.rename(vararg cols: String): RenameClause<T, Any?> = rename { cols.toColumns() }
+public fun <T, C> DataFrame<T>.rename(cols: Iterable<ColumnReference<C>>): RenameClause<T, C> =
+    rename { cols.toColumnSet() }
+
+public data class RenameClause<T, C>(val df: DataFrame<T>, val columns: ColumnsSelector<T, C>)
+
+public fun <T> DataFrame<T>.renameToCamelCase(): DataFrame<T> {
+    return rename {
+        dfs { it.isColumnGroup() && it.name() matches DELIMITED_STRING_REGEX }
+    }.toCamelCase()
+        .rename {
+            dfs { !it.isColumnGroup() && it.name() matches DELIMITED_STRING_REGEX }
+        }.toCamelCase()
+        .update {
+            dfsOf<AnyFrame>()
+        }.with { it.renameToCamelCase() }
+}
+
+public fun <T, C> RenameClause<T, C>.into(vararg newColumns: ColumnReference<*>): DataFrame<T> =
+    into(*newColumns.map { it.name() }.toTypedArray())
+
+public fun <T, C> RenameClause<T, C>.into(vararg newNames: String): DataFrame<T> =
+    df.move(columns).intoIndexed { col, index ->
+        col.path.dropLast(1) + newNames[index]
+    }
+public fun <T, C> RenameClause<T, C>.into(vararg newNames: KProperty<*>): DataFrame<T> =
+    into(*newNames.map { it.name }.toTypedArray())
+
+public fun <T, C> RenameClause<T, C>.into(transform: (ColumnWithPath<C>) -> String): DataFrame<T> =
+    df.move(columns).into {
+        it.path.dropLast(1) + transform(it)
+    }
+
+public fun <T, C> RenameClause<T, C>.toCamelCase(): DataFrame<T> =
+    into { it.name().toCamelCaseByDelimiters(DELIMITERS_REGEX) }
+
+// endregion
+
+// region DataColumn
+
+public fun <T, C : ColumnReference<T>> C.rename(column: KProperty<T>): C = rename(column.columnName) as C
+public fun <T, C : ColumnReference<T>> C.rename(column: ColumnAccessor<T>): C = rename(column.name()) as C
+
+// endregion
+
+// region named
+
+public infix fun <T, C : ColumnReference<T>> C.named(name: String): C = rename(name) as C
+public infix fun <T, C : ColumnReference<T>> C.named(name: KProperty<*>): C = rename(name)
+public infix fun <T, C : ColumnReference<T>> C.named(name: ColumnAccessor<*>): C = rename(name)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
new file mode 100644
index 000000000..f6eb6cdfd
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
@@ -0,0 +1,48 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.ColumnExpression
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.api.reorderImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+public data class Reorder<T, C>(
+    internal val df: DataFrame<T>,
+    internal val columns: ColumnsSelector<T, C>,
+    internal val inFrameColumns: Boolean
+) {
+    public fun <R> cast(): Reorder<T, R> = this as Reorder<T, R>
+}
+
+public fun <T, C> DataFrame<T>.reorder(selector: ColumnsSelector<T, C>): Reorder<T, C> = Reorder(this, selector, false)
+public fun <T, C> DataFrame<T>.reorder(vararg columns: ColumnReference<C>): Reorder<T, C> =
+    reorder { columns.toColumns() }
+
+public fun <T, C> DataFrame<T>.reorder(vararg columns: KProperty<C>): Reorder<T, C> = reorder { columns.toColumns() }
+public fun <T> DataFrame<T>.reorder(vararg columns: String): Reorder<T, *> = reorder { columns.toColumns() }
+
+public fun <T, C, V : Comparable<V>> Reorder<T, C>.by(expression: ColumnExpression<C, V>): DataFrame<T> =
+    reorderImpl(false, expression)
+
+public fun <T, C> Reorder<T, C>.byName(desc: Boolean = false): DataFrame<T> =
+    if (desc) byDesc { it.name } else by { it.name }
+
+public fun <T, C, V : Comparable<V>> Reorder<T, C>.byDesc(expression: ColumnExpression<C, V>): DataFrame<T> =
+    reorderImpl(true, expression)
+
+public fun <T, V : Comparable<V>> DataFrame<T>.reorderColumnsBy(
+    dfs: Boolean = true,
+    desc: Boolean = false,
+    expression: Selector<AnyCol, V>
+): DataFrame<T> = Reorder(this, { if (dfs) allDfs(true) else all() }, dfs).reorderImpl(desc, expression)
+
+public fun <T> DataFrame<T>.reorderColumnsByName(dfs: Boolean = true, desc: Boolean = false): DataFrame<T> =
+    reorderColumnsBy(dfs, desc) { name() }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt
new file mode 100644
index 000000000..1b529aead
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt
@@ -0,0 +1,50 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.api.ColumnToInsert
+import org.jetbrains.kotlinx.dataframe.impl.api.insertImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.removeImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import kotlin.reflect.KProperty
+
+public fun <T, C> DataFrame<T>.replace(columns: ColumnsSelector<T, C>): ReplaceClause<T, C> = ReplaceClause(this, columns)
+public fun <T> DataFrame<T>.replace(vararg columns: String): ReplaceClause<T, Any?> = replace { columns.toColumns() }
+public fun <T, C> DataFrame<T>.replace(vararg columns: ColumnReference<C>): ReplaceClause<T, C> = replace { columns.toColumns() }
+public fun <T, C> DataFrame<T>.replace(vararg columns: KProperty<C>): ReplaceClause<T, C> = replace { columns.toColumns() }
+public fun <T, C> DataFrame<T>.replace(columns: Iterable<ColumnReference<C>>): ReplaceClause<T, C> = replace { columns.toColumnSet() }
+
+public fun <T> DataFrame<T>.replaceAll(
+    vararg valuePairs: Pair<Any?, Any?>,
+    columns: ColumnsSelector<T, *> = { allDfs() }
+): DataFrame<T> {
+    val map = valuePairs.toMap()
+    return update(columns).with { map[it] ?: it }
+}
+
+public data class ReplaceClause<T, C>(val df: DataFrame<T>, val columns: ColumnsSelector<T, C>)
+
+public fun <T, C> ReplaceClause<T, C>.with(vararg columns: AnyCol): DataFrame<T> = with(columns.toList())
+
+public fun <T, C> ReplaceClause<T, C>.with(newColumns: List<AnyCol>): DataFrame<T> {
+    var index = 0
+    return with {
+        require(index < newColumns.size) { "Insufficient number of new columns in 'replace': ${newColumns.size} instead of ${df[columns].size}" }
+        newColumns[index++]
+    }
+}
+
+public fun <T, C> ReplaceClause<T, C>.with(transform: ColumnsContainer<T>.(DataColumn<C>) -> AnyBaseCol): DataFrame<T> {
+    val removeResult = df.removeImpl(columns = columns)
+    val toInsert = removeResult.removedColumns.map {
+        val newCol = transform(df, it.data.column as DataColumn<C>)
+        ColumnToInsert(it.pathFromRoot().dropLast(1) + newCol.name, newCol, it)
+    }
+    return removeResult.df.insertImpl(toInsert)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reverse.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reverse.kt
new file mode 100644
index 000000000..3e3f66325
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reverse.kt
@@ -0,0 +1,18 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.indices
+
+public fun <T> DataFrame<T>.reverse(): DataFrame<T> = get(indices.reversed())
+
+public fun <T> DataColumn<T>.reverse(): DataColumn<T> = get(indices.reversed())
+
+public fun <T> ColumnGroup<T>.reverse(): ColumnGroup<T> = get(indices.reversed())
+
+public fun <T> FrameColumn<T>.reverse(): FrameColumn<T> = get(indices.reversed())
+
+public fun <T> ValueColumn<T>.reverse(): ValueColumn<T> = get(indices.reversed())
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/schema.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/schema.kt
new file mode 100644
index 000000000..2c61d85b9
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/schema.kt
@@ -0,0 +1,25 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.impl.owner
+import org.jetbrains.kotlinx.dataframe.impl.schema.extractSchema
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+
+// region DataRow
+
+public fun AnyRow.schema(): DataFrameSchema = owner.schema()
+
+// endregion
+
+// region DataFrame
+
+public fun AnyFrame.schema(): DataFrameSchema = extractSchema()
+
+// endregion
+
+// region GroupBy
+
+public fun GroupBy<*, *>.schema(): DataFrameSchema = toDataFrame().schema()
+
+// endregion
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
new file mode 100644
index 000000000..3277ec595
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt
@@ -0,0 +1,37 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.select(columns: ColumnsSelector<T, *>): DataFrame<T> =
+    get(columns).toDataFrame().cast()
+
+public fun <T> DataFrame<T>.select(vararg columns: KProperty<*>): DataFrame<T> =
+    select(columns.asIterable())
+
+@JvmName("selectKPropertyIterable")
+public fun <T> DataFrame<T>.select(columns: Iterable<KProperty<*>>): DataFrame<T> =
+    select(columns.map { it.columnName })
+
+public fun <T> DataFrame<T>.select(vararg columns: String): DataFrame<T> =
+    select(columns.asIterable())
+
+@JvmName("selectStringIterable")
+public fun <T> DataFrame<T>.select(columns: Iterable<String>): DataFrame<T> =
+    columns.map { get(it) }.toDataFrame().cast()
+
+public fun <T> DataFrame<T>.select(vararg columns: Column): DataFrame<T> =
+    select { columns.toColumns() }
+
+@JvmName("selectAnyColumnReferenceIterable")
+public fun <T> DataFrame<T>.select(columns: Iterable<Column>): DataFrame<T> =
+    select { columns.toColumnSet() }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/shuffle.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/shuffle.kt
new file mode 100644
index 000000000..ed5c0bccb
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/shuffle.kt
@@ -0,0 +1,17 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.indices
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.shuffle(): DataColumn<T> = get(indices.shuffled())
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.shuffle(): DataFrame<T> = getRows(indices.shuffled())
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/single.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/single.kt
new file mode 100644
index 000000000..8f8b95125
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/single.kt
@@ -0,0 +1,31 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.nrow
+
+// region DataColumn
+
+public fun <C> DataColumn<C>.single(): C = values.single()
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.single(): DataRow<T> =
+    when (nrow) {
+        0 -> throw NoSuchElementException("DataFrame has no rows. Use `singleOrNull`.")
+        1 -> get(0)
+        else -> throw IllegalArgumentException("DataFrame has more than one row.")
+    }
+
+public fun <T> DataFrame<T>.singleOrNull(): DataRow<T>? = rows().singleOrNull()
+
+public fun <T> DataFrame<T>.single(predicate: RowExpression<T, Boolean>): DataRow<T> = rows().single { predicate(it, it) }
+public fun <T> DataFrame<T>.singleOrNull(predicate: RowExpression<T, Boolean>): DataRow<T>? =
+    rows().singleOrNull { predicate(it, it) }
+
+// endregion
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
new file mode 100644
index 000000000..cdafcc1da
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sort.kt
@@ -0,0 +1,141 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataFrameExpression
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.impl.api.SortFlag
+import org.jetbrains.kotlinx.dataframe.impl.api.addFlag
+import org.jetbrains.kotlinx.dataframe.impl.api.sortByImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.newColumnWithActualType
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.type
+import kotlin.reflect.KProperty
+
+public interface SortDsl<out T> : ColumnsSelectionDsl<T> {
+
+    public fun <C> ColumnSet<C>.desc(): ColumnSet<C> = addFlag(SortFlag.Reversed)
+    public fun String.desc(): ColumnSet<Comparable<*>?> = invoke<Comparable<*>>().desc()
+    public fun <C> KProperty<C>.desc(): ColumnSet<C> = toColumnAccessor().desc()
+
+    public fun <C> ColumnSet<C?>.nullsLast(flag: Boolean = true): ColumnSet<C?> =
+        if (flag) addFlag(SortFlag.NullsLast) else this
+
+    public fun String.nullsLast(flag: Boolean = true): ColumnSet<Comparable<*>?> = invoke<Comparable<*>>().nullsLast(flag)
+    public fun <C> KProperty<C?>.nullsLast(flag: Boolean = true): ColumnSet<C?> = toColumnAccessor().nullsLast(flag)
+}
+
+/**
+ * [SortColumnsSelector] is used to express or select multiple columns to sort by, represented by [ColumnSet]`<C>`,
+ * using the context of [SortDsl]`<T>` as `this` and `it`.
+ *
+ * So:
+ * ```kotlin
+ * SortDsl<T>.(it: SortDsl<T>) -> ColumnSet<C>
+ * ```
+ */
+public typealias SortColumnsSelector<T, C> = Selector<SortDsl<T>, ColumnSet<C>>
+
+// region DataColumn
+
+public fun <T : Comparable<T>> DataColumn<T>.sort(): ValueColumn<T> = DataColumn.createValueColumn(name, values().sorted(), type, defaultValue = defaultValue())
+public fun <T : Comparable<T>> DataColumn<T>.sortDesc(): ValueColumn<T> = DataColumn.createValueColumn(name, values().sortedDescending(), type, defaultValue = defaultValue())
+
+// endregion
+
+// region DataFrame
+
+public fun <T, C> DataFrame<T>.sortBy(columns: SortColumnsSelector<T, C>): DataFrame<T> = sortByImpl(
+    UnresolvedColumnsPolicy.Fail, columns
+)
+
+public fun <T> DataFrame<T>.sortBy(cols: Iterable<ColumnReference<Comparable<*>?>>): DataFrame<T> =
+    sortBy { cols.toColumnSet() }
+
+public fun <T> DataFrame<T>.sortBy(vararg cols: ColumnReference<Comparable<*>?>): DataFrame<T> =
+    sortBy { cols.toColumns() }
+
+public fun <T> DataFrame<T>.sortBy(vararg cols: String): DataFrame<T> = sortBy { cols.toColumns() }
+public fun <T> DataFrame<T>.sortBy(vararg cols: KProperty<Comparable<*>?>): DataFrame<T> = sortBy { cols.toColumns() }
+
+public fun <T> DataFrame<T>.sortWith(comparator: Comparator<DataRow<T>>): DataFrame<T> {
+    val permutation = rows().sortedWith(comparator).map { it.index }
+    return this[permutation]
+}
+
+public fun <T> DataFrame<T>.sortWith(comparator: (DataRow<T>, DataRow<T>) -> Int): DataFrame<T> =
+    sortWith(Comparator(comparator))
+
+public fun <T, C> DataFrame<T>.sortByDesc(columns: SortColumnsSelector<T, C>): DataFrame<T> {
+    val set = columns.toColumns()
+    return sortByImpl { set.desc() }
+}
+
+public fun <T, C> DataFrame<T>.sortByDesc(vararg columns: KProperty<Comparable<C>?>): DataFrame<T> =
+    sortByDesc { columns.toColumns() }
+
+public fun <T> DataFrame<T>.sortByDesc(vararg columns: String): DataFrame<T> = sortByDesc { columns.toColumns() }
+public fun <T, C> DataFrame<T>.sortByDesc(vararg columns: ColumnReference<Comparable<C>?>): DataFrame<T> =
+    sortByDesc { columns.toColumns() }
+
+public fun <T, C> DataFrame<T>.sortByDesc(columns: Iterable<ColumnReference<Comparable<C>?>>): DataFrame<T> =
+    sortByDesc { columns.toColumnSet() }
+
+// endregion
+
+// region GroupBy
+
+public fun <T, G> GroupBy<T, G>.sortBy(vararg cols: String): GroupBy<T, G> = sortBy { cols.toColumns() }
+public fun <T, G> GroupBy<T, G>.sortBy(vararg cols: ColumnReference<Comparable<*>?>): GroupBy<T, G> = sortBy { cols.toColumns() }
+public fun <T, G> GroupBy<T, G>.sortBy(vararg cols: KProperty<Comparable<*>?>): GroupBy<T, G> = sortBy { cols.toColumns() }
+public fun <T, G, C> GroupBy<T, G>.sortBy(selector: SortColumnsSelector<G, C>): GroupBy<T, G> = sortByImpl(selector)
+
+public fun <T, G> GroupBy<T, G>.sortByDesc(vararg cols: String): GroupBy<T, G> = sortByDesc { cols.toColumns() }
+public fun <T, G> GroupBy<T, G>.sortByDesc(vararg cols: ColumnReference<Comparable<*>?>): GroupBy<T, G> = sortByDesc { cols.toColumns() }
+public fun <T, G> GroupBy<T, G>.sortByDesc(vararg cols: KProperty<Comparable<*>?>): GroupBy<T, G> = sortByDesc { cols.toColumns() }
+public fun <T, G, C> GroupBy<T, G>.sortByDesc(selector: SortColumnsSelector<G, C>): GroupBy<T, G> {
+    val set = selector.toColumns()
+    return sortByImpl { set.desc() }
+}
+
+private fun <T, G, C> GroupBy<T, G>.createColumnFromGroupExpression(
+    receiver: ColumnsSelectionDsl<T>,
+    expression: DataFrameExpression<G, C>
+): DataColumn<C?> {
+    return 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)
+
+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)
+
+public fun <T, G> GroupBy<T, G>.sortByCountAsc(): GroupBy<T, G> = sortByGroup { nrow }
+public fun <T, G> GroupBy<T, G>.sortByCount(): GroupBy<T, G> = sortByGroupDesc { nrow }
+
+public fun <T, G> GroupBy<T, G>.sortByKeyDesc(nullsLast: Boolean = false): GroupBy<T, G> = toDataFrame()
+    .sortBy { keys.columns().toColumnSet().desc().nullsLast(nullsLast) }.asGroupBy(groups)
+public fun <T, G> GroupBy<T, G>.sortByKey(nullsLast: Boolean = false): GroupBy<T, G> = toDataFrame()
+    .sortBy { keys.columns().toColumnSet().nullsLast(nullsLast) }.asGroupBy(groups)
+
+// endregion
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
new file mode 100644
index 000000000..682750d65
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/split.kt
@@ -0,0 +1,300 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.impl.api.splitDefault
+import org.jetbrains.kotlinx.dataframe.impl.api.splitImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.withRowCellImpl
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.impl.getListType
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+public fun <T, C> DataFrame<T>.split(columns: ColumnsSelector<T, C?>): Split<T, C> =
+    Split(this, columns)
+
+public fun <T> DataFrame<T>.split(vararg columns: String): Split<T, Any> = split { columns.toColumns() }
+public fun <T, C> DataFrame<T>.split(vararg columns: ColumnReference<C?>): Split<T, C> = split { columns.toColumns() }
+public fun <T, C> DataFrame<T>.split(vararg columns: KProperty<C?>): Split<T, C> = split { columns.toColumns() }
+
+public data class Split<T, C>(
+    internal val df: DataFrame<T>,
+    internal val columns: ColumnsSelector<T, C?>,
+) {
+    public fun <P> cast(): Split<T, P> = this as Split<T, P>
+}
+
+public data class SplitWithTransform<T, C, R>(
+    internal val df: DataFrame<T>,
+    internal val columns: ColumnsSelector<T, C?>,
+    internal val inward: Boolean,
+    internal val tartypeOf: KType,
+    internal val default: R? = null,
+    internal val transform: DataRow<T>.(C) -> Iterable<R>
+)
+
+public typealias ColumnNamesGenerator<C> = ColumnWithPath<C>.(extraColumnIndex: Int) -> String
+
+// region default
+
+public inline fun <T, C : Iterable<R>, reified R> Split<T, C>.default(value: R?): SplitWithTransform<T, C, R> =
+    by { it }.default(value)
+
+public fun <T> Split<T, String>.default(value: String?): SplitWithTransform<T, String, String> =
+    by { it.splitDefault() }.default(value)
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.default(value: R?): SplitWithTransform<T, C, R> = copy(default = value)
+
+// endregion
+
+// region by
+
+public inline fun <T, C, reified R> Split<T, C>.by(noinline splitter: DataRow<T>.(C) -> Iterable<R>): SplitWithTransform<T, C, R> =
+    by(typeOf<R>(), splitter)
+
+public fun <T, C> Split<T, C>.by(
+    vararg delimiters: Char,
+    trim: Boolean = true,
+    ignoreCase: Boolean = false,
+    limit: Int = 0
+): SplitWithTransform<T, C, String> = by {
+    it.toString().split(*delimiters, ignoreCase = ignoreCase, limit = limit).let {
+        if (trim) it.map { it.trim() }
+        else it
+    }
+}
+
+public fun <T, C> Split<T, C>.by(
+    regex: Regex,
+    trim: Boolean = true,
+    limit: Int = 0
+): SplitWithTransform<T, C, String> = by {
+    it.toString().split(regex, limit = limit).let {
+        if (trim) it.map { it.trim() }
+        else it
+    }
+}
+
+public fun <T, C> Split<T, C>.by(
+    vararg delimiters: String,
+    trim: Boolean = true,
+    ignoreCase: Boolean = false,
+    limit: Int = 0
+): SplitWithTransform<T, C, String> = by {
+    it.toString().split(*delimiters, ignoreCase = ignoreCase, limit = limit).let {
+        if (trim) it.map { it.trim() }
+        else it
+    }
+}
+
+@PublishedApi
+internal fun <T, C, R> Split<T, C>.by(
+    type: KType,
+    splitter: DataRow<T>.(C) -> Iterable<R>
+): SplitWithTransform<T, C, R> {
+    return SplitWithTransform(df, columns, false, type) {
+        if (it == null) emptyList() else splitter(it).asList()
+    }
+}
+
+// endregion
+
+// region match
+
+public fun <T, C : String?> Split<T, C>.match(regex: String): SplitWithTransform<T, C, String?> = match(regex.toRegex())
+
+public fun <T, C : String?> Split<T, C>.match(regex: Regex): SplitWithTransform<T, C, String?> = by {
+    it?.let { regex.matchEntire(it)?.groups?.drop(1)?.map { it?.value } } ?: emptyList<String>()
+}
+
+// endregion
+
+internal fun <T, C> Split<T, C>.toDataFrame(): DataFrame<T> = by {
+    when (it) {
+        is List<*> -> it
+        is AnyFrame -> it.rows()
+        else -> listOf(it)
+    }
+}.into()
+
+// region into
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.into(
+    firstName: ColumnAccessor<*>,
+    vararg otherNames: ColumnAccessor<*>
+): DataFrame<T> =
+    into(listOf(firstName.name()) + otherNames.map { it.name() })
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.into(
+    firstName: KProperty<*>,
+    vararg otherNames: KProperty<*>
+): DataFrame<T> =
+    into(listOf(firstName.columnName) + otherNames.map { it.columnName })
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.into(
+    vararg names: String,
+    extraNamesGenerator: (ColumnWithPath<C>.(extraColumnIndex: Int) -> String)? = null
+): DataFrame<T> = into(names.toList(), extraNamesGenerator)
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.into(
+    names: List<String>,
+    extraNamesGenerator: (ColumnWithPath<C>.(extraColumnIndex: Int) -> String)? = null
+): DataFrame<T> = splitImpl(this) { numberOfNewCols ->
+    if (extraNamesGenerator != null && names.size < numberOfNewCols) {
+        names + (1..(numberOfNewCols - names.size)).map { extraNamesGenerator(this, it) }
+    } else names
+}
+
+public fun <T, C : Iterable<*>> Split<T, C>.into(
+    vararg names: String,
+    extraNamesGenerator: ColumnNamesGenerator<C>? = null
+): DataFrame<T> =
+    by { it }.into(names.toList(), extraNamesGenerator)
+
+@JvmName("splitDataFrameInto")
+public fun <T, C> Split<T, DataFrame<C>>.into(
+    vararg names: String,
+    extraNamesGenerator: ColumnNamesGenerator<DataFrame<C>>? = null
+): DataFrame<T> =
+    by { it.rows() }.into(names.toList(), extraNamesGenerator)
+
+public fun <T, A, B> Split<T, Pair<A, B>>.into(
+    firstCol: String,
+    secondCol: String
+): DataFrame<T> =
+    by { listOf(it.first, it.second) }.into(firstCol, secondCol)
+
+public inline fun <T, reified A, reified B> Split<T, Pair<A, B>>.into(
+    firstCol: ColumnAccessor<A>,
+    secondCol: ColumnAccessor<B>
+): DataFrame<T> =
+    by { listOf(it.first, it.second) }.into(firstCol, secondCol)
+
+@JvmName("intoTC")
+public fun <T> Split<T, String>.into(
+    vararg names: String,
+    extraNamesGenerator: (ColumnWithPath<String>.(extraColumnIndex: Int) -> String)? = null
+): DataFrame<T> =
+    by { it.splitDefault() }.into(names.toList(), extraNamesGenerator)
+
+// endregion
+
+// region inward
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.inward(
+    names: Iterable<String>,
+    extraNamesGenerator: ColumnNamesGenerator<C>? = null
+): DataFrame<T> =
+    copy(inward = true).into(names.toList(), extraNamesGenerator)
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.inward(
+    vararg names: String,
+    extraNamesGenerator: ColumnNamesGenerator<C>? = null
+): DataFrame<T> = inward(names.toList(), extraNamesGenerator)
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.inward(
+    firstName: ColumnAccessor<*>,
+    vararg otherNames: ColumnAccessor<*>
+): DataFrame<T> =
+    inward(listOf(firstName.name()) + otherNames.map { it.name() })
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.inward(
+    firstName: KProperty<*>,
+    vararg otherNames: KProperty<*>
+): DataFrame<T> =
+    inward(listOf(firstName.columnName) + otherNames.map { it.columnName })
+
+public inline fun <T, C : Iterable<R>, reified R> Split<T, C>.inward(
+    vararg names: String,
+    noinline extraNamesGenerator: ColumnNamesGenerator<C>? = null
+): DataFrame<T> =
+    by { it }.inward(names.toList(), extraNamesGenerator)
+
+@JvmName("splitDataFrameInward")
+public fun <T, C : DataFrame<R>, R> Split<T, C>.inward(
+    vararg names: String,
+    extraNamesGenerator: ColumnNamesGenerator<C>? = null
+): DataFrame<T> =
+    by { it.rows() }.inward(names.toList(), extraNamesGenerator)
+
+public fun <T, A, B> Split<T, Pair<A, B>>.inward(
+    firstCol: String,
+    secondCol: String
+): DataFrame<T> =
+    by { listOf(it.first, it.second) }.inward(firstCol, secondCol)
+
+public inline fun <T, reified A, reified B> Split<T, Pair<A, B>>.inward(
+    firstCol: ColumnAccessor<A>,
+    secondCol: ColumnAccessor<B>
+): DataFrame<T> =
+    by { listOf(it.first, it.second) }.inward(firstCol, secondCol)
+
+@JvmName("inwardTC")
+public fun <T> Split<T, String>.inward(
+    vararg names: String,
+    extraNamesGenerator: (ColumnWithPath<String>.(extraColumnIndex: Int) -> String)? = null
+): DataFrame<T> =
+    by { it.splitDefault() }.inward(names.toList(), extraNamesGenerator)
+
+// endregion
+
+// region intoColumns
+
+public fun <T, C : AnyFrame> Split<T, C>.intoColumns(): DataFrame<T> {
+    return df.convert(columns).with {
+        when {
+            it == null -> null
+            it.isEmpty() -> DataRow.empty
+            else -> it.implode { all() }.single()
+        }
+    }
+}
+
+// endregion
+
+// region intoRows
+
+@JvmName("intoRowsTC")
+public inline fun <T, C : Iterable<R>, reified R> Split<T, C>.intoRows(dropEmpty: Boolean = true): DataFrame<T> =
+    by { it }
+        .intoRows(dropEmpty)
+
+@JvmName("intoRowsFrame")
+public fun <T, C : AnyFrame> Split<T, C>.intoRows(dropEmpty: Boolean = true): DataFrame<T> =
+    by { it.rows() }.intoRows(dropEmpty)
+
+internal fun <T, C, R> Convert<T, C?>.splitInplace(type: KType, transform: DataRow<T>.(C) -> Iterable<R>) =
+    withRowCellImpl(getListType(type), Infer.None) { if (it == null) emptyList() else transform(it).asList() }
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.intoRows(dropEmpty: Boolean = true): DataFrame<T> {
+    val paths = df.getColumnPaths(columns).toColumnSet()
+    return df.convert { paths as ColumnSet<C?> }.splitInplace(tartypeOf, transform).explode(dropEmpty) { paths }
+}
+
+// endregion
+
+// region inplace
+
+@JvmName("inplaceTC")
+public inline fun <T, C : Iterable<R>, reified R> Split<T, C>.inplace(): DataFrame<T> = by { it }.inplace()
+
+public fun <T, C, R> SplitWithTransform<T, C, R>.inplace(): DataFrame<T> = df.convert(columns).splitInplace(tartypeOf, transform)
+
+// endregion
+
+// region DataColumn
+
+public fun DataColumn<Iterable<*>>.splitInto(vararg names: String): AnyFrame = toDataFrame().split { this@splitInto }.into(*names)
+
+// endregion
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
new file mode 100644
index 000000000..092120000
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/std.kt
@@ -0,0 +1,252 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelector
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast2
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateFor
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOf
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.of
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.numberColumns
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnsOf
+import org.jetbrains.kotlinx.dataframe.math.std
+import kotlin.reflect.KProperty
+import kotlin.reflect.typeOf
+
+// region DataColumn
+
+public fun <T : Number> DataColumn<T?>.std(skipNA: Boolean = skipNA_default, ddof: Int = ddof_default): Double = Aggregators.std(skipNA, ddof).aggregate(this) ?: .0
+
+public inline fun <T, reified R : Number> DataColumn<T>.stdOf(
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    noinline expression: (T) -> R?
+): Double = Aggregators.std(skipNA, ddof).cast2<R?, Double>().aggregateOf(this, expression) ?: .0
+
+// endregion
+
+// region DataRow
+
+public fun AnyRow.rowStd(
+    skipNA: Boolean = org.jetbrains.kotlinx.dataframe.api.skipNA_default,
+    ddof: Int = org.jetbrains.kotlinx.dataframe.api.ddof_default
+): Double = values().filterIsInstance<Number>().map { it.toDouble() }.std(skipNA, ddof)
+public inline fun <reified T : Number> AnyRow.rowStdOf(ddof: Int = org.jetbrains.kotlinx.dataframe.api.ddof_default): Double = values().filterIsInstance<T>().std(
+    typeOf<T>(), ddof = ddof
+)
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.std(skipNA: Boolean = skipNA_default, ddof: Int = ddof_default): DataRow<T> = stdFor(skipNA, ddof, numberColumns())
+
+public fun <T> DataFrame<T>.stdFor(
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    columns: ColumnsForAggregateSelector<T, Number?>
+): DataRow<T> = Aggregators.std(skipNA, ddof).aggregateFor(this, columns)
+public fun <T> DataFrame<T>.stdFor(vararg columns: String, skipNA: Boolean = skipNA_default, ddof: Int = ddof_default): DataRow<T> = stdFor(skipNA, ddof) { columns.toColumnsOf() }
+public fun <T, C : Number> DataFrame<T>.stdFor(
+    vararg columns: ColumnReference<C?>,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default
+): DataRow<T> = stdFor(skipNA, ddof) { columns.toColumns() }
+public fun <T, C : Number> DataFrame<T>.stdFor(
+    vararg columns: KProperty<C?>,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default
+): DataRow<T> = stdFor(skipNA, ddof) { columns.toColumns() }
+
+public fun <T> DataFrame<T>.std(
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    columns: ColumnsSelector<T, Number?>
+): Double = Aggregators.std(skipNA, ddof).aggregateAll(this, columns) ?: .0
+public fun <T> DataFrame<T>.std(vararg columns: ColumnReference<Number?>): Double = std { columns.toColumns() }
+public fun <T> DataFrame<T>.std(vararg columns: String): Double = std { columns.toColumnsOf() }
+public fun <T> DataFrame<T>.std(vararg columns: KProperty<Number?>): Double = std { columns.toColumns() }
+
+public inline fun <T, reified R : Number> DataFrame<T>.stdOf(
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    crossinline expression: RowExpression<T, R?>
+): Double = Aggregators.std(skipNA, ddof).of(this, expression) ?: .0
+
+// endregion
+
+// region GroupBy
+
+public fun <T> Grouped<T>.std(skipNA: Boolean = skipNA_default, ddof: Int = ddof_default): DataFrame<T> = stdFor(skipNA, ddof, numberColumns())
+
+public fun <T> Grouped<T>.stdFor(
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    columns: ColumnsForAggregateSelector<T, Number?>
+): DataFrame<T> = Aggregators.std(skipNA, ddof).aggregateFor(this, columns)
+public fun <T> Grouped<T>.stdFor(vararg columns: String, skipNA: Boolean = skipNA_default, ddof: Int = ddof_default): DataFrame<T> = stdFor(skipNA, ddof) { columns.toColumnsOf() }
+public fun <T, C : Number> Grouped<T>.stdFor(
+    vararg columns: ColumnReference<C?>,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default
+): DataFrame<T> = stdFor(skipNA, ddof) { columns.toColumns() }
+public fun <T, C : Number> Grouped<T>.stdFor(
+    vararg columns: KProperty<C?>,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default
+): DataFrame<T> = stdFor(skipNA, ddof) { columns.toColumns() }
+
+public fun <T> Grouped<T>.std(
+    name: String? = null,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    columns: ColumnsSelector<T, Number?>
+): DataFrame<T> = Aggregators.std(skipNA, ddof).aggregateAll(this, name, columns)
+public fun <T> Grouped<T>.std(
+    vararg columns: ColumnReference<Number?>,
+    name: String? = null,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default
+): DataFrame<T> = std(name, skipNA, ddof) { columns.toColumns() }
+public fun <T> Grouped<T>.std(
+    vararg columns: String,
+    name: String? = null,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default
+): DataFrame<T> = std(name, skipNA, ddof) { columns.toColumnsOf() }
+public fun <T> Grouped<T>.std(
+    vararg columns: KProperty<Number?>,
+    name: String? = null,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default
+): DataFrame<T> = std(name, skipNA, ddof) { columns.toColumns() }
+
+public inline fun <T, reified R : Number> Grouped<T>.stdOf(
+    name: String? = null,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    crossinline expression: RowExpression<T, R?>
+): DataFrame<T> = Aggregators.std(skipNA, ddof).aggregateOf(this, name, expression)
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.std(separate: Boolean = false, skipNA: Boolean = skipNA_default, ddof: Int = ddof_default): DataRow<T> = stdFor(separate, skipNA, ddof, numberColumns())
+
+public fun <T, R : Number> Pivot<T>.stdFor(
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    columns: ColumnsForAggregateSelector<T, R?>
+): DataRow<T> = delegate { stdFor(separate, skipNA, ddof, columns) }
+public fun <T> Pivot<T>.stdFor(
+    vararg columns: String,
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default
+): DataRow<T> = stdFor(separate, skipNA, ddof) { columns.toColumnsOf() }
+public fun <T, C : Number> Pivot<T>.stdFor(
+    vararg columns: ColumnReference<C?>,
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default
+): DataRow<T> = stdFor(separate, skipNA, ddof) { columns.toColumns() }
+public fun <T, C : Number> Pivot<T>.stdFor(
+    vararg columns: KProperty<C?>,
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default
+): DataRow<T> = stdFor(separate, skipNA, ddof) { columns.toColumns() }
+
+public fun <T> Pivot<T>.std(
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    columns: ColumnsSelector<T, Number?>
+): DataRow<T> = delegate { std(skipNA, ddof, columns) }
+public fun <T> Pivot<T>.std(
+    vararg columns: ColumnReference<Number?>,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default
+): DataRow<T> = std(skipNA, ddof) { columns.toColumns() }
+public fun <T> Pivot<T>.std(vararg columns: String, skipNA: Boolean = skipNA_default, ddof: Int = ddof_default): DataRow<T> = std(skipNA, ddof) { columns.toColumnsOf() }
+public fun <T> Pivot<T>.std(
+    vararg columns: KProperty<Number?>,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default
+): DataRow<T> = std(skipNA, ddof) { columns.toColumns() }
+
+public inline fun <reified T : Number> Pivot<T>.stdOf(
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    crossinline expression: RowExpression<T, T?>
+): DataRow<T> = delegate { stdOf(skipNA, ddof, expression) }
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.std(
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default
+): DataFrame<T> = stdFor(separate, skipNA, ddof, numberColumns())
+
+public fun <T, R : Number> PivotGroupBy<T>.stdFor(
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    columns: ColumnsForAggregateSelector<T, R?>
+): DataFrame<T> =
+    Aggregators.std(skipNA, ddof).aggregateFor(this, separate, columns)
+public fun <T> PivotGroupBy<T>.stdFor(
+    vararg columns: String,
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default
+): DataFrame<T> = stdFor(separate, skipNA, ddof) { columns.toColumnsOf() }
+public fun <T, C : Number> PivotGroupBy<T>.stdFor(
+    vararg columns: ColumnReference<C?>,
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default
+): DataFrame<T> = stdFor(separate, skipNA, ddof) { columns.toColumns() }
+public fun <T, C : Number> PivotGroupBy<T>.stdFor(
+    vararg columns: KProperty<C?>,
+    separate: Boolean = false,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default
+): DataFrame<T> = stdFor(separate, skipNA, ddof) { columns.toColumns() }
+
+public fun <T> PivotGroupBy<T>.std(
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    columns: ColumnsSelector<T, Number?>
+): DataFrame<T> = Aggregators.std(skipNA, ddof).aggregateAll(this, columns)
+public fun <T> PivotGroupBy<T>.std(
+    vararg columns: ColumnReference<Number?>,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default
+): DataFrame<T> = std(skipNA, ddof) { columns.toColumns() }
+public fun <T> PivotGroupBy<T>.std(vararg columns: String, skipNA: Boolean = skipNA_default, ddof: Int = ddof_default): DataFrame<T> = std(skipNA, ddof) { columns.toColumnsOf() }
+public fun <T> PivotGroupBy<T>.std(
+    vararg columns: KProperty<Number?>,
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default
+): DataFrame<T> = std(skipNA, ddof) { columns.toColumns() }
+
+public inline fun <T, reified R : Number> PivotGroupBy<T>.stdOf(
+    skipNA: Boolean = skipNA_default,
+    ddof: Int = ddof_default,
+    crossinline expression: RowExpression<T, R?>
+): DataFrame<T> = Aggregators.std(skipNA, ddof).aggregateOf(this, expression)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sum.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sum.kt
new file mode 100644
index 000000000..de13d32e3
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sum.kt
@@ -0,0 +1,143 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelector
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregator
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateFor
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOf
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.of
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.numberColumns
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnsOf
+import org.jetbrains.kotlinx.dataframe.impl.columns.toNumberColumns
+import org.jetbrains.kotlinx.dataframe.impl.zero
+import org.jetbrains.kotlinx.dataframe.math.sum
+import org.jetbrains.kotlinx.dataframe.math.sumOf
+import kotlin.reflect.KProperty
+import kotlin.reflect.typeOf
+
+// region DataColumn
+
+@JvmName("sumT")
+public fun <T : Number> DataColumn<T>.sum(): T = values.sum(type())
+
+@JvmName("sumTNullable")
+public fun <T : Number> DataColumn<T?>.sum(): T = values.sum(type())
+
+public inline fun <T, reified R : Number> DataColumn<T>.sumOf(crossinline expression: (T) -> R): R? =
+    (Aggregators.sum as Aggregator<*, *>).cast<R>().of(this, expression)
+
+// endregion
+
+// region DataRow
+
+public fun AnyRow.rowSum(): Number = org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators.sum.aggregateMixed(values().filterIsInstance<Number>()) ?: 0
+public inline fun <reified T : Number> AnyRow.rowSumOf(): T = values().filterIsInstance<T>().sum(typeOf<T>())
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.sum(): DataRow<T> = sumFor(numberColumns())
+
+public fun <T, C : Number> DataFrame<T>.sumFor(columns: ColumnsForAggregateSelector<T, C?>): DataRow<T> = Aggregators.sum.aggregateFor(this, columns)
+public fun <T> DataFrame<T>.sumFor(vararg columns: String): DataRow<T> = sumFor { columns.toColumnsOf() }
+public fun <T, C : Number> DataFrame<T>.sumFor(vararg columns: ColumnReference<C?>): DataRow<T> = sumFor { columns.toColumns() }
+public fun <T, C : Number> DataFrame<T>.sumFor(vararg columns: KProperty<C?>): DataRow<T> = sumFor { columns.toColumns() }
+
+public inline fun <T, reified C : Number> DataFrame<T>.sum(noinline columns: ColumnsSelector<T, C?>): C = (Aggregators.sum.aggregateAll(this, columns) as C?) ?: C::class.zero()
+public inline fun <T, reified C : Number> DataFrame<T>.sum(vararg columns: ColumnReference<C?>): C = sum { columns.toColumns() }
+public fun <T> DataFrame<T>.sum(vararg columns: String): Number = sum { columns.toColumnsOf() }
+public inline fun <T, reified C : Number> DataFrame<T>.sum(vararg columns: KProperty<C?>): C = sum { columns.toColumns() }
+
+public inline fun <T, reified C : Number?> DataFrame<T>.sumOf(crossinline expression: RowExpression<T, C>): C = rows().sumOf(
+    typeOf<C>()
+) { expression(it, it) }
+
+// endregion
+
+// region GroupBy
+
+public fun <T> Grouped<T>.sum(): DataFrame<T> = sumFor(numberColumns())
+
+public fun <T, C : Number> Grouped<T>.sumFor(columns: ColumnsForAggregateSelector<T, C?>): DataFrame<T> = Aggregators.sum.aggregateFor(this, columns)
+public fun <T> Grouped<T>.sumFor(vararg columns: String): DataFrame<T> = sumFor { columns.toNumberColumns() }
+public fun <T, C : Number> Grouped<T>.sumFor(vararg columns: ColumnReference<C?>): DataFrame<T> = sumFor { columns.toColumns() }
+public fun <T, C : Number> Grouped<T>.sumFor(vararg columns: KProperty<C?>): DataFrame<T> = sumFor { columns.toColumns() }
+
+public fun <T, C : Number> Grouped<T>.sum(name: String? = null, columns: ColumnsSelector<T, C?>): DataFrame<T> =
+    Aggregators.sum.aggregateAll(this, name, columns)
+public fun <T> Grouped<T>.sum(vararg columns: String, name: String? = null): DataFrame<T> = sum(name) { columns.toNumberColumns() }
+public fun <T, C : Number> Grouped<T>.sum(vararg columns: ColumnReference<C?>, name: String? = null): DataFrame<T> = sum(name) { columns.toColumns() }
+public fun <T, C : Number> Grouped<T>.sum(vararg columns: KProperty<C?>, name: String? = null): DataFrame<T> = sum(name) { columns.toColumns() }
+
+public inline fun <T, reified R : Number> Grouped<T>.sumOf(
+    resultName: String? = null,
+    crossinline expression: RowExpression<T, R?>
+): DataFrame<T> = Aggregators.sum.aggregateOf(this, resultName, expression)
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.sum(separate: Boolean = false): DataRow<T> = sumFor(separate, numberColumns())
+
+public fun <T, R : Number> Pivot<T>.sumFor(
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, R?>
+): DataRow<T> =
+    delegate { sumFor(separate, columns) }
+public fun <T> Pivot<T>.sumFor(vararg columns: String, separate: Boolean = false): DataRow<T> = sumFor(separate) { columns.toNumberColumns() }
+public fun <T, C : Number> Pivot<T>.sumFor(
+    vararg columns: ColumnReference<C?>,
+    separate: Boolean = false
+): DataRow<T> = sumFor(separate) { columns.toColumns() }
+public fun <T, C : Number> Pivot<T>.sumFor(vararg columns: KProperty<C?>, separate: Boolean = false): DataRow<T> = sumFor(separate) { columns.toColumns() }
+
+public fun <T, C : Number> Pivot<T>.sum(columns: ColumnsSelector<T, C?>): DataRow<T> =
+    delegate { sum(columns) }
+public fun <T> Pivot<T>.sum(vararg columns: String): DataRow<T> = sum { columns.toNumberColumns() }
+public fun <T, C : Number> Pivot<T>.sum(vararg columns: ColumnReference<C?>): DataRow<T> = sum { columns.toColumns() }
+public fun <T, C : Number> Pivot<T>.sum(vararg columns: KProperty<C?>): DataRow<T> = sum { columns.toColumns() }
+
+public inline fun <T, reified R : Number> Pivot<T>.sumOf(crossinline expression: RowExpression<T, R>): DataRow<T> =
+    delegate { sumOf(expression) }
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.sum(separate: Boolean = false): DataFrame<T> = sumFor(separate, numberColumns())
+
+public fun <T, R : Number> PivotGroupBy<T>.sumFor(
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, R?>
+): DataFrame<T> =
+    Aggregators.sum.aggregateFor(this, separate, columns)
+public fun <T> PivotGroupBy<T>.sumFor(vararg columns: String, separate: Boolean = false): DataFrame<T> = sumFor(separate) { columns.toNumberColumns() }
+public fun <T, C : Number> PivotGroupBy<T>.sumFor(
+    vararg columns: ColumnReference<C?>,
+    separate: Boolean = false
+): DataFrame<T> = sumFor(separate) { columns.toColumns() }
+public fun <T, C : Number> PivotGroupBy<T>.sumFor(vararg columns: KProperty<C?>, separate: Boolean = false): DataFrame<T> = sumFor(separate) { columns.toColumns() }
+
+public fun <T, C : Number> PivotGroupBy<T>.sum(columns: ColumnsSelector<T, C?>): DataFrame<T> =
+    Aggregators.sum.aggregateAll(this, columns)
+public fun <T> PivotGroupBy<T>.sum(vararg columns: String): DataFrame<T> = sum { columns.toNumberColumns() }
+public fun <T, C : Number> PivotGroupBy<T>.sum(vararg columns: ColumnReference<C?>): DataFrame<T> = sum { columns.toColumns() }
+public fun <T, C : Number> PivotGroupBy<T>.sum(vararg columns: KProperty<C?>): DataFrame<T> = sum { columns.toColumns() }
+
+public inline fun <T, reified R : Number> PivotGroupBy<T>.sumOf(crossinline expression: RowExpression<T, R>): DataFrame<T> =
+    Aggregators.sum.aggregateOf(this, expression)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/tail.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/tail.kt
new file mode 100644
index 000000000..1228924f4
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/tail.kt
@@ -0,0 +1,9 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.tail(numRows: Int = 5): DataFrame<T> = takeLast(numRows)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/take.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/take.kt
new file mode 100644
index 000000000..1cd68ca17
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/take.kt
@@ -0,0 +1,49 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.nrow
+
+// region DataColumn
+
+public fun <T> DataColumn<T>.take(n: Int): DataColumn<T> = when {
+    n == 0 -> get(emptyList())
+    n >= size -> this
+    else -> get(0 until n)
+}
+
+public fun <T> DataColumn<T>.takeLast(n: Int): DataColumn<T> = drop(size - n)
+
+// endregion
+
+// region DataFrame
+
+/**
+ * Returns a DataFrame containing first [n] rows.
+ *
+ * @throws IllegalArgumentException if [n] is negative.
+ */
+public fun <T> DataFrame<T>.take(n: Int): DataFrame<T> {
+    require(n >= 0) { "Requested rows count $n is less than zero." }
+    return getRows(0 until n.coerceAtMost(nrow))
+}
+
+/**
+ * Returns a DataFrame containing last [n] rows.
+ *
+ * @throws IllegalArgumentException if [n] is negative.
+ */
+public fun <T> DataFrame<T>.takeLast(n: Int): DataFrame<T> {
+    require(n >= 0) { "Requested rows count $n is less than zero." }
+    return drop((nrow - n).coerceAtLeast(0))
+}
+
+/**
+ * Returns a DataFrame containing first rows that satisfy the given [predicate].
+ */
+public fun <T> DataFrame<T>.takeWhile(predicate: RowFilter<T>): DataFrame<T> = firstOrNull { !predicate(it, it) }?.let { take(it.index) } ?: this
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
new file mode 100644
index 000000000..3bf5ec6d9
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
@@ -0,0 +1,209 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.impl.ColumnNameGenerator
+import org.jetbrains.kotlinx.dataframe.impl.api.createDataFrameImpl
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.guessColumnType
+import org.jetbrains.kotlinx.dataframe.index
+import kotlin.reflect.KClass
+import kotlin.reflect.KProperty
+
+// region read DataFrame from objects
+
+public inline fun <reified T> Iterable<T>.toDataFrame(): DataFrame<T> = toDataFrame {
+    properties()
+}
+
+public inline fun <reified T> Iterable<T>.toDataFrame(noinline body: CreateDataFrameDsl<T>.() -> Unit): DataFrame<T> =
+    createDataFrameImpl(T::class, body)
+
+public inline fun <reified T> Iterable<T>.toDataFrame(vararg props: KProperty<*>, maxDepth: Int = 0): DataFrame<T> =
+    toDataFrame {
+        properties(roots = props, maxDepth = maxDepth)
+    }
+
+@Deprecated("Replaced with `unfold` operation.", ReplaceWith("this.unfold(columns)"), DeprecationLevel.ERROR)
+public fun <T> DataFrame<T>.read(columns: ColumnsSelector<T, *>): DataFrame<T> = unfold(columns)
+
+@Deprecated("Replaced with `unfold` operation.", ReplaceWith("this.unfold(*columns)"), DeprecationLevel.ERROR)
+public fun <T> DataFrame<T>.read(vararg columns: String): DataFrame<T> = unfold(*columns)
+
+@Deprecated("Replaced with `unfold` operation.", ReplaceWith("this.unfold(*columns)"), DeprecationLevel.ERROR)
+public fun <T> DataFrame<T>.read(vararg columns: KProperty<*>): DataFrame<T> = unfold(*columns)
+
+@Deprecated("Replaced with `unfold` operation.", ReplaceWith("this.unfold(*columns)"), DeprecationLevel.ERROR)
+public fun <T> DataFrame<T>.read(vararg columns: Column): DataFrame<T> = unfold(*columns)
+
+@JvmName("toDataFrameT")
+public fun <T> Iterable<DataRow<T>>.toDataFrame(): DataFrame<T> {
+    var uniqueDf: DataFrame<T>? = null
+    for (row in this) {
+        if (uniqueDf == null) uniqueDf = row.df()
+        else {
+            if (uniqueDf !== row.df()) {
+                uniqueDf = null
+                break
+            }
+        }
+    }
+    return if (uniqueDf != null) {
+        val permutation = map { it.index }
+        uniqueDf[permutation]
+    } else map { it.toDataFrame() }.concat()
+}
+
+@JvmName("toDataFrameAnyColumn")
+public fun Iterable<AnyBaseCol>.toDataFrame(): AnyFrame = dataFrameOf(this)
+
+@JvmName("toDataFramePairColumnPathAnyCol")
+public fun <T> Iterable<Pair<ColumnPath, AnyBaseCol>>.toDataFrameFromPairs(): DataFrame<T> {
+    val nameGenerator = ColumnNameGenerator()
+    val columnNames = mutableListOf<String>()
+    val columnGroups = mutableListOf<MutableList<Pair<ColumnPath, AnyBaseCol>>?>()
+    val columns = mutableListOf<AnyBaseCol?>()
+    val columnIndices = mutableMapOf<String, Int>()
+    val columnGroupName = mutableMapOf<String, String>()
+
+    forEach { (path, col) ->
+        when (path.size) {
+            0 -> {
+            }
+
+            1 -> {
+                val name = path[0]
+                val uniqueName = nameGenerator.addUnique(name)
+                val index = columns.size
+                columnNames.add(uniqueName)
+                columnGroups.add(null)
+                columns.add(col.rename(uniqueName))
+                columnIndices[uniqueName] = index
+            }
+
+            else -> {
+                val name = path[0]
+                val uniqueName = columnGroupName.getOrPut(name) {
+                    nameGenerator.addUnique(name)
+                }
+                val index = columnIndices.getOrPut(uniqueName) {
+                    columnNames.add(uniqueName)
+                    columnGroups.add(mutableListOf())
+                    columns.add(null)
+                    columns.size - 1
+                }
+                val list = columnGroups[index]!!
+                list.add(path.drop(1) to col)
+            }
+        }
+    }
+    columns.indices.forEach { index ->
+        val group = columnGroups[index]
+        if (group != null) {
+            val nestedDf = group.toDataFrameFromPairs<Unit>()
+            val col = DataColumn.createColumnGroup(columnNames[index], nestedDf)
+            assert(columns[index] == null)
+            columns[index] = col
+        } else assert(columns[index] != null)
+    }
+    return columns.map { it!! }.toDataFrame().cast()
+}
+
+@JvmName("toDataFrameColumnPathAnyNullable")
+public fun Iterable<Pair<ColumnPath, Iterable<Any?>>>.toDataFrameFromPairs(): AnyFrame {
+    return map { it.first to guessColumnType(it.first.last(), it.second.asList()) }.toDataFrameFromPairs<Unit>()
+}
+
+public fun Iterable<Pair<String, Iterable<Any?>>>.toDataFrameFromPairs(): AnyFrame {
+    return map { ColumnPath(it.first) to guessColumnType(it.first, it.second.asList()) }.toDataFrameFromPairs<Unit>()
+}
+
+public interface TraversePropertiesDsl {
+
+    /**
+     * Skip given [classes] during dfs traversal
+     */
+    public fun exclude(vararg classes: KClass<*>)
+
+    /**
+     * Skip given [properties] during dfs traversal
+     */
+    public fun exclude(vararg properties: KProperty<*>)
+
+    /**
+     * Store given [classes] in ValueColumns without transformation into ColumnGroups or FrameColumns
+     */
+    public fun preserve(vararg classes: KClass<*>)
+
+    /**
+     * Store given [properties] in ValueColumns without transformation into ColumnGroups or FrameColumns
+     */
+    public fun preserve(vararg properties: KProperty<*>)
+}
+
+public inline fun <reified T> TraversePropertiesDsl.preserve(): Unit = preserve(T::class)
+
+public abstract class CreateDataFrameDsl<T> : TraversePropertiesDsl {
+
+    public abstract val source: Iterable<T>
+
+    public abstract fun add(column: AnyBaseCol, path: ColumnPath? = null)
+
+    public infix fun AnyBaseCol.into(name: String): Unit = add(this, pathOf(name))
+
+    public infix fun AnyBaseCol.into(path: ColumnPath): Unit = add(this, path)
+
+    public abstract fun properties(
+        vararg roots: KProperty<*>,
+        maxDepth: Int = 0,
+        body: (TraversePropertiesDsl.() -> Unit)? = null
+    )
+
+    public inline fun <reified R> expr(noinline expression: (T) -> R): DataColumn<R> =
+        source.map { expression(it) }.toColumn()
+
+    public inline fun <reified R> add(name: String, noinline expression: (T) -> R): Unit =
+        add(source.map { expression(it) }.toColumn(name, Infer.Nulls))
+
+    public inline infix fun <reified R> String.from(noinline expression: (T) -> R): Unit =
+        add(this, expression)
+
+    public inline infix fun <reified R> KProperty<R>.from(noinline expression: (T) -> R): Unit =
+        add(columnName, expression)
+
+    public inline infix fun <reified R> KProperty<R>.from(inferType: InferType<T, R>): Unit =
+        add(DataColumn.createWithTypeInference(columnName, source.map { inferType.expression(it) }))
+
+    public data class InferType<T, R>(val expression: (T) -> R)
+
+    public inline fun <reified R> inferType(noinline expression: (T) -> R): InferType<T, R> = InferType(expression)
+
+    public abstract operator fun String.invoke(builder: CreateDataFrameDsl<T>.() -> Unit)
+}
+
+// endregion
+
+// region Create DataFrame from Map
+
+public fun Map<String, Iterable<Any?>>.toDataFrame(): AnyFrame {
+    return map { DataColumn.createWithTypeInference(it.key, it.value.asList()) }.toDataFrame()
+}
+
+@JvmName("toDataFrameColumnPathAnyNullable")
+public fun Map<ColumnPath, Iterable<Any?>>.toDataFrame(): AnyFrame {
+    return map {
+        it.key to DataColumn.createWithTypeInference(
+            it.key.last(),
+            it.value.asList()
+        )
+    }.toDataFrameFromPairs<Unit>()
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toList.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toList.kt
new file mode 100644
index 000000000..b9eb5a873
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toList.kt
@@ -0,0 +1,14 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.impl.api.toListImpl
+import kotlin.reflect.typeOf
+
+// region DataFrame
+
+public inline fun <reified T> DataFrame<T>.toList(): List<T> = toListImpl(typeOf<T>()) as List<T>
+
+public inline fun <reified T> AnyFrame.toListOf(): List<T> = toListImpl(typeOf<T>()) as List<T>
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/transpose.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/transpose.kt
new file mode 100644
index 000000000..60147825f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/transpose.kt
@@ -0,0 +1,29 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.impl.api.convertTo
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.owner
+import org.jetbrains.kotlinx.dataframe.values
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+// region DataRow
+
+public fun <T> DataRow<T>.transpose(): DataFrame<NameValuePair<*>> {
+    val valueColumn = DataColumn.createWithTypeInference(NameValuePair<*>::value.columnName, values)
+    val nameColumn = owner.columnNames().toValueColumn(NameValuePair<*>::name)
+    return dataFrameOf(nameColumn, valueColumn).cast()
+}
+
+public inline fun <reified T> AnyRow.transposeTo(): DataFrame<NameValuePair<T>> = transposeTo(typeOf<T>())
+
+@PublishedApi
+internal fun <T> AnyRow.transposeTo(type: KType): DataFrame<NameValuePair<T>> {
+    val convertedValues = values.map { it?.convertTo(type) as T? }
+    val valueColumn = DataColumn.createWithTypeInference(NameValuePair<T>::value.columnName, convertedValues)
+    val nameColumn = owner.columnNames().toValueColumn(NameValuePair<T>::name)
+    return dataFrameOf(nameColumn, valueColumn).cast()
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/unfold.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/unfold.kt
new file mode 100644
index 000000000..54f59bf95
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/unfold.kt
@@ -0,0 +1,28 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.impl.api.createDataFrameImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.typeClass
+import kotlin.reflect.KProperty
+
+public inline fun <reified T> DataColumn<T>.unfold(): AnyCol =
+    when (kind()) {
+        ColumnKind.Group, ColumnKind.Frame -> this
+        else -> when {
+            isPrimitive() -> this
+            else -> values().createDataFrameImpl(typeClass) {
+                (this as CreateDataFrameDsl<T>).properties()
+            }.asColumnGroup(name()).asDataColumn()
+        }
+    }
+
+public fun <T> DataFrame<T>.unfold(columns: ColumnsSelector<T, *>): DataFrame<T> = replace(columns).with { it.unfold() }
+public fun <T> DataFrame<T>.unfold(vararg columns: String): DataFrame<T> = unfold { columns.toColumns() }
+public fun <T> DataFrame<T>.unfold(vararg columns: KProperty<*>): DataFrame<T> = unfold { columns.toColumns() }
+public fun <T> DataFrame<T>.unfold(vararg columns: Column): DataFrame<T> = unfold { columns.toColumns() }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt
new file mode 100644
index 000000000..65e0f820c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt
@@ -0,0 +1,21 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.impl.removeAt
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+public fun <T, C> DataFrame<T>.ungroup(columns: ColumnsSelector<T, C>): DataFrame<T> {
+    return move { columns.toColumns().children() }
+        .into { it.path.removeAt(it.path.size - 2).toPath() }
+}
+
+public fun <T> DataFrame<T>.ungroup(vararg columns: String): DataFrame<T> = ungroup { columns.toColumns() }
+public fun <T> DataFrame<T>.ungroup(vararg columns: Column): DataFrame<T> = ungroup { columns.toColumns() }
+public fun <T> DataFrame<T>.ungroup(vararg columns: KProperty<*>): DataFrame<T> = ungroup { columns.toColumns() }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
new file mode 100644
index 000000000..12fe97a00
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -0,0 +1,778 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.api.Update.Usage
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.documentation.*
+import org.jetbrains.kotlinx.dataframe.impl.api.updateImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.updateWithValuePerColumnImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.impl.headPlusArray
+import kotlin.reflect.KProperty
+
+/**
+ * ## The Update Operation
+ * 
+ * Returns the [DataFrame] with changed values in some cells
+ * (column types can not be changed).
+ * 
+ * Check out the [`update` Operation Usage][Usage].
+ * 
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html)
+ */
+public data class Update<T, C>(
+    val df: DataFrame<T>,
+    val filter: RowValueFilter<T, C>?,
+    val columns: ColumnsSelector<T, C>,
+) {
+    public fun <R : C> cast(): Update<T, R> =
+        Update(df, filter as RowValueFilter<T, R>?, columns as ColumnsSelector<T, R>)
+
+    /** This argument providing the (clickable) name of the update-like function.
+     * Note: If clickable, make sure to [alias][your type].
+     */
+    internal interface UpdateOperationArg
+
+    /**
+     * ## [update][update] Operation Usage
+     * 
+     * [update][update] `{ `[columns][SelectingColumns]` }`
+     * 
+     * - `[.`[where][Update.where]` { `[rowValueCondition][SelectingRows.RowValueCondition.WithExample]` } ]`
+     * 
+     * - `[.`[at][Update.at]` (`[rowIndices][CommonUpdateAtFunctionDoc.RowIndicesParam]`) ]`
+     * 
+     * - `.`[with][Update.with]` { `[rowExpression][ExpressionsGivenRow.RowValueExpression.WithExample]` }
+     *   | .`[notNull][Update.notNull]` { `[rowExpression][ExpressionsGivenRow.RowValueExpression.WithExample]` }
+     *   | .`[perCol][Update.perCol]` { `[colExpression][ExpressionsGivenColumn.ColumnExpression.WithExample]` }
+     *   | .`[perRowCol][Update.perRowCol]` { `[rowColExpression][ExpressionsGivenColumn.RowColumnExpression.WithExample]` }
+     *   | .`[withValue][Update.withValue]`(value)
+     *   | .`[withNull][Update.withNull]`()
+     *   | .`[withZero][Update.withZero]`()
+     *   | .`[asFrame][Update.asFrame]` { `[dataFrameExpression][ExpressionsGivenDataFrame.DataFrameExpression.WithExample]` }`
+     */
+    public interface Usage
+
+    /** The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. */
+    public interface Columns
+
+    /** @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame] to update. */
+    internal interface DslParam
+
+    /** @param columns The [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample] of this [DataFrame] to update. */
+    internal interface ColumnAccessorsParam
+
+    /** @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] corresponding to columns of this [DataFrame] to update. */
+    internal interface KPropertiesParam
+
+    /** @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] belonging to this [DataFrame] to update. */
+    internal interface ColumnNamesParam
+}
+
+// region update
+
+
+private interface SetSelectingColumnsOperationArg
+
+/**
+ * ## The Update Operation
+ * 
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types can not be changed).
+ * 
+ * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
+ * 
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Update Overload
+ */
+private interface CommonUpdateFunctionDoc
+
+/**
+ * ## Optional
+ * Combine `df.`[update][update]`(...).`[with][Update.with]` { ... }`
+ * into `df.`[update][update]`(...) { ... }`
+ */
+private interface UpdateWithNote
+
+/**
+ * ## The Update Operation
+ * 
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types can not be changed).
+ * 
+ * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
+ * 
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Update Overload
+ * Select or express columns using the Column(s) Selection DSL.
+ * (Any [Access Api][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ * 
+ * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
+ * 
+ * For example:
+ * 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { length `[and][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.and]` age }`
+ * 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ * 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<Double>() }`
+ *  
+ * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.update(columns: ColumnsSelector<T, C>): Update<T, C> =
+    Update(this, null, columns)
+
+/**
+ * ## The Update Operation
+ * 
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types can not be changed).
+ * 
+ * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
+ * 
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Update Overload
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ * 
+ * For example:
+ * 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`("length", "age")`
+ *  
+ * 
+ * ## Optional
+ * Combine `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...).`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { ... }`
+ * into `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...) { ... }`
+ * @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] belonging to this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T> DataFrame<T>.update(vararg columns: String): Update<T, Any?> = update { columns.toColumns() }
+
+/**
+ * ## The Update Operation
+ * 
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types can not be changed).
+ * 
+ * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
+ * 
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Update Overload
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ * 
+ * For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ * 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(Person::length, Person::age)`
+ *  
+ * 
+ * ## Optional
+ * Combine `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...).`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { ... }`
+ * into `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...) { ... }`
+ * @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] corresponding to columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.update(vararg columns: KProperty<C>): Update<T, C> = update { columns.toColumns() }
+
+/**
+ * ## The Update Operation
+ * 
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types can not be changed).
+ * 
+ * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
+ * 
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Update Overload
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ * 
+ * For example:
+ * 
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
+ * 
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
+ * 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(length, age)`
+ *  
+ * 
+ * ## Optional
+ * Combine `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...).`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { ... }`
+ * into `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...) { ... }`
+ * @param columns The [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample] of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.update(vararg columns: ColumnReference<C>): Update<T, C> =
+    update { columns.toColumns() }
+
+/**
+ * TODO this will be deprecated
+ */
+public fun <T, C> DataFrame<T>.update(columns: Iterable<ColumnReference<C>>): Update<T, C> =
+    update { columns.toColumnSet() }
+
+// endregion
+
+/**
+ * ## Where
+ * 
+ * Filter or find rows to operate on after [selecting columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] using a
+ * [row value filter][org.jetbrains.kotlinx.dataframe.RowValueFilter].
+ * 
+ * For example:
+ * 
+ * `df.`[update][update]` { length }.`[where][where]` { it > 10.0 }`
+ * 
+ * `df.`[update][update]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }.`[where][where]` { `[index][org.jetbrains.kotlinx.dataframe.index]`() > 4 && city != "Paris" }`
+ * 
+ * 
+ * 
+ * 
+ * @param predicate The [row value filter][RowValueFilter] to select the rows to update.
+ */
+public fun <T, C> Update<T, C>.where(predicate: RowValueFilter<T, C>): Update<T, C> =
+    copy(filter = filter and predicate)
+
+/** ## At
+ * Only update the columns at certain given [row indices][CommonUpdateAtFunctionDoc.RowIndicesParam]:
+ *
+ * Either a [Collection]<[Int]>, an [IntRange], or just `vararg` indices.
+ *
+ * For example:
+ *
+ * `df.`[update][update]` { city }.`[at][at]`(5..10).`[with][with]` { "Paris" }`
+ *
+ * `df.`[update][update]` { name }.`[at][at]`(1, 2, 3, 4).`[with][with]` { "Empty" }`
+ *
+ * ## This At Overload
+ */
+private interface CommonUpdateAtFunctionDoc {
+
+    /** The indices of the rows to update. Either a [Collection]<[Int]>, an [IntRange], or just `vararg` indices. */
+    interface RowIndicesParam
+}
+
+/**
+ * ## At
+ * Only update the columns at certain given [row indices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]:
+ * 
+ * Either a [Collection][Collection]< [Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
+ * 
+ * For example:
+ * 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { city }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(5..10).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Paris" }`
+ * 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(1, 2, 3, 4).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Empty" }`
+ * 
+ * ## This At Overload
+ * 
+ * Provide a [Collection]<[Int]> of row indices to update.
+ * 
+ * @param rowIndices The indices of the rows to update. Either a [Collection][Collection]< [Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
+ */
+public fun <T, C> Update<T, C>.at(rowIndices: Collection<Int>): Update<T, C> = where { index in rowIndices }
+
+/**
+ * ## At
+ * Only update the columns at certain given [row indices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]:
+ * 
+ * Either a [Collection][Collection]< [Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
+ * 
+ * For example:
+ * 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { city }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(5..10).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Paris" }`
+ * 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(1, 2, 3, 4).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Empty" }`
+ * 
+ * ## This At Overload
+ * 
+ * Provide a `vararg` of [Ints][Int] of row indices to update.
+ * 
+ * @param rowIndices The indices of the rows to update. Either a [Collection][Collection]< [Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
+ */
+public fun <T, C> Update<T, C>.at(vararg rowIndices: Int): Update<T, C> = at(rowIndices.toSet())
+
+/**
+ * ## At
+ * Only update the columns at certain given [row indices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]:
+ * 
+ * Either a [Collection][Collection]< [Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
+ * 
+ * For example:
+ * 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { city }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(5..10).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Paris" }`
+ * 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(1, 2, 3, 4).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Empty" }`
+ * 
+ * ## This At Overload
+ * 
+ * Provide an [IntRange] of row indices to update.
+ * 
+ * @param rowRange The indices of the rows to update. Either a [Collection][Collection]< [Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
+ */
+public fun <T, C> Update<T, C>.at(rowRange: IntRange): Update<T, C> = where { index in rowRange }
+
+/**
+ * ## Per Row Col
+ * 
+ * Provide a new value for every selected cell given both its row and column using a [row-column expression][org.jetbrains.kotlinx.dataframe.RowColumnExpression].
+ * 
+ * For example:
+ * 
+ * `df.`[update][update]` { age }.`[perRowCol][perRowCol]` { row, col ->`
+ * 
+ * `row.age / col.`[mean][org.jetbrains.kotlinx.dataframe.DataColumn.mean]`(skipNA = true)`
+ * 
+ * `}`
+ * 
+ * 
+ * 
+ * 
+ * ## See Also
+ *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
+ *  - [Update per col][org.jetbrains.kotlinx.dataframe.api.Update.perCol] to provide a new value for every selected cell giving its column.
+ * @param expression The [Row Column Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.RowColumnExpression] to provide a new value for every selected cell giving its row and column.
+ */
+public infix fun <T, C> Update<T, C>.perRowCol(expression: RowColumnExpression<T, C, C>): DataFrame<T> =
+    updateImpl { row, column, _ -> expression(row, column) }
+
+/** [Update per row col][Update.perRowCol] to provide a new value for every selected cell giving its row and column. */
+private interface SeeAlsoPerRowCol
+
+/** ## Update Expression
+ * @see ExpressionsGivenRow.RowValueExpression.WithExample
+ * @see ExpressionsGivenRow.AddDataRowNote
+ */ // doc processor plugin does not work with type aliases yet
+public typealias UpdateExpression<T, C, R> = AddDataRow<T>.(C) -> R
+
+/**
+ * ## With
+ * 
+ * Provide a new value for every selected cell given its row and its previous value using a
+ * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
+ * 
+ * For example:
+ * 
+ * `df.`[update][update]` { city }.`[with][with]` { name.firstName + " from " + it }`
+ * 
+ * `df.`[update][update]` { city }.`[with][with]` { it.uppercase() }`
+ * 
+ * 
+ * 
+ * ## Note
+ * 
+ * [update with][org.jetbrains.kotlinx.dataframe.api.Update.with]- and [add][org.jetbrains.kotlinx.dataframe.api.add]-like expressions use [AddDataRow][org.jetbrains.kotlinx.dataframe.api.AddDataRow] instead of [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as the DSL's receiver type.
+ * This is an extension to [RowValueExpression][org.jetbrains.kotlinx.dataframe.RowValueExpression] and
+ * [RowExpression][org.jetbrains.kotlinx.dataframe.RowExpression] that provides access to
+ * the modified/generated value of the preceding row ([AddDataRow.newValue][org.jetbrains.kotlinx.dataframe.api.AddDataRow.newValue]).
+ * ## See Also
+ * - [Update per col][org.jetbrains.kotlinx.dataframe.api.Update.perCol] to provide a new value for every selected cell giving its column.
+ * - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
+ * @param expression The [Row Value Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample] to update the rows with.
+ */
+public infix fun <T, C> Update<T, C>.with(expression: UpdateExpression<T, C, C?>): DataFrame<T> =
+    updateImpl { row, _, value ->
+        expression(row, value)
+    }
+
+/** [Update with][Update.with] to provide a new value for every selected cell giving its row. */
+private interface SeeAlsoWith
+
+/**
+ * ## As Frame
+ * 
+ * Updates selected [column group][ColumnGroup] as a [DataFrame] with the given [expression].
+ * 
+ * 
+ * Provide a new value for every selected data frame using a [dataframe expression][org.jetbrains.kotlinx.dataframe.DataFrameExpression].
+ * 
+ * For example:
+ * 
+ * `df.`[update][update]` { name }.`[asFrame][asFrame]` { `[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { lastName } }`
+ * 
+ * @param expression The [Data Frame Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.DataFrameExpression] to replace the selected column group with.
+ */
+public infix fun <T, C, R> Update<T, DataRow<C>>.asFrame(expression: DataFrameExpression<C, DataFrame<R>>): DataFrame<T> =
+    df.replace(columns).with { it.asColumnGroup().let { expression(it, it) }.asColumnGroup(it.name()) }
+
+@Deprecated(
+    "Useless unless in combination with `withValue(null)`, but then users can just use `with { null }`...",
+    ReplaceWith("this as Update<T, C?>")
+)
+public fun <T, C> Update<T, C>.asNullable(): Update<T, C?> = this as Update<T, C?>
+
+/**
+ * ## Per Col
+ * 
+ * Per Col can be used for two different types of operations:
+ *  - Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
+ *  - Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ * 
+ * ## See Also
+ *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
+ *  - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
+ * ## This Per Col Overload
+ */
+private interface CommonUpdatePerColDoc
+
+/** Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][DataRow] as Map. */
+private interface UpdatePerColMap
+
+/**
+ * ## Per Col
+ * 
+ * Per Col can be used for two different types of operations:
+ *  - Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
+ *  - Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ * 
+ * ## See Also
+ *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
+ *  - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
+ * ## This Per Col Overload
+ * Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ * 
+ * For example:
+ * 
+ * `val defaults = {@includeArg [CommonUpdatePerColMapDoc]}`
+ * 
+ * `df.`[update][update]` { name and age }.`[where][Update.where]` { ... }.`[perCol][perCol]`(defaults)`
+ * 
+ * @throws IllegalArgumentException if a value for a selected cell's column is not defined in [values\].
+ */
+private interface CommonUpdatePerColMapDoc
+
+/**
+ * ## Per Col
+ * 
+ * Per Col can be used for two different types of operations:
+ *  - Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
+ *  - Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ * 
+ * ## See Also
+ *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
+ *  - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
+ * ## This Per Col Overload
+ * Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ * 
+ * For example:
+ * 
+ * `val defaults = `[mapOf][mapOf]`("name" to "Empty", "age" to 0)`
+ * 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name and age }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { ... }.`[perCol][org.jetbrains.kotlinx.dataframe.api.perCol]`(defaults)`
+ * 
+ * @throws IllegalArgumentException if a value for a selected cell's column is not defined in [values][values].
+ * 
+ * 
+ * @param values The [Map]<[String], Value> to provide a new value for every selected cell.
+ *   For each selected column, there must be a value in the map with the same name.
+ */
+public fun <T, C> Update<T, C>.perCol(values: Map<String, C>): DataFrame<T> = updateWithValuePerColumnImpl {
+    values[it.name()] ?: throw IllegalArgumentException("Update value for column ${it.name()} is not defined")
+}
+
+/**
+ * ## Per Col
+ * 
+ * Per Col can be used for two different types of operations:
+ *  - Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
+ *  - Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ * 
+ * ## See Also
+ *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
+ *  - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
+ * ## This Per Col Overload
+ * Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ * 
+ * For example:
+ * 
+ * `val defaults = df.`[getRows][DataFrame.getRows]`(`[listOf][listOf]`(0))`
+ * 
+ *   `.`[update][update]` { name }.`[with][Update.with]` { "Empty" }`
+ * 
+ *   `.`[update][update]` { age }.`[with][Update.with]` { 0 }`
+ * 
+ *   `.first()`
+ * 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name and age }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { ... }.`[perCol][org.jetbrains.kotlinx.dataframe.api.perCol]`(defaults)`
+ * 
+ * @throws IllegalArgumentException if a value for a selected cell's column is not defined in [values][values].
+ * 
+ * 
+ * @param values The [DataRow] to provide a new value for every selected cell.
+ */
+public fun <T, C> Update<T, C>.perCol(values: AnyRow): DataFrame<T> = perCol(values.toMap() as Map<String, C>)
+
+/**
+ * ## Per Col
+ * 
+ * Per Col can be used for two different types of operations:
+ *  - Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
+ *  - Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ * 
+ * ## See Also
+ *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
+ *  - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
+ * ## This Per Col Overload
+ * 
+ * Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
+ * 
+ * For example:
+ * 
+ * `df.`[update][update]` { age }.`[perCol][perCol]` { `[mean][org.jetbrains.kotlinx.dataframe.DataColumn.mean]`(skipNA = true) }`
+ * 
+ * `df.`[update][update]` { age }.`[perCol][perCol]` { `[count][org.jetbrains.kotlinx.dataframe.DataColumn.count]` { it > 10 } }`
+ * 
+ * 
+ * 
+ * @param valueSelector The [Column Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpression] to provide a new value for every selected cell giving its column.
+ */
+public fun <T, C> Update<T, C>.perCol(valueSelector: ColumnExpression<C, C>): DataFrame<T> =
+    updateWithValuePerColumnImpl(valueSelector)
+
+/** [Update per col][Update.perCol] to provide a new value for every selected cell giving its column. */
+private interface SeeAlsoPerCol
+
+/** Chains up two row value filters together. */
+internal infix fun <T, C> RowValueFilter<T, C>?.and(other: RowValueFilter<T, C>): RowValueFilter<T, C> {
+    if (this == null) return other
+    val thisExp = this
+    return { thisExp(this, it) && other(this, it) }
+}
+
+/**
+ * ## Not Null
+ * 
+ * Selects only the rows where the values in the selected columns are not null.
+ * 
+ * Shorthand for: [update][org.jetbrains.kotlinx.dataframe.api.update]` { ... }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it != null }`
+ * 
+ * For example:
+ * 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Number][Number]`?>() }.`[notNull][org.jetbrains.kotlinx.dataframe.api.notNull]`()`.[perCol][org.jetbrains.kotlinx.dataframe.api.Update.perCol] `{ `[mean][org.jetbrains.kotlinx.dataframe.api.mean]`() }`
+ * 
+ * ### Optional
+ * Provide an [expression][expression] to update the rows with.
+ * This combines [with][org.jetbrains.kotlinx.dataframe.api.Update.with] with [notNull][org.jetbrains.kotlinx.dataframe.api.notNull].
+ * 
+ * For example:
+ * 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { city }.`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { it.`[toUpperCase][String.toUpperCase]`() }`
+ * 
+ * @param expression Optional [Row Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowExpression.WithExample] to update the rows with.
+ */
+public fun <T, C> Update<T, C?>.notNull(): Update<T, C> =
+    where { it != null } as Update<T, C>
+
+/**
+ * ## Not Null
+ * 
+ * Selects only the rows where the values in the selected columns are not null.
+ * 
+ * Shorthand for: [update][update]` { ... }.`[where][Update.where]` { it != null }`
+ * 
+ * For example:
+ * 
+ * `df.`[update][update]` { `[colsOf][colsOf]`<`[Number][Number]`?>() }.`[notNull][notNull]`()`.[perCol][Update.perCol] `{ `[mean][mean]`() }`
+ * 
+ * ### Optional
+ * Provide an [expression] to update the rows with.
+ * This combines [with][Update.with] with [notNull].
+ * 
+ * For example:
+ * 
+ * `df.`[update][update]` { city }.`[notNull][Update.notNull]` { it.`[toUpperCase][String.toUpperCase]`() }`
+ * 
+ * @param expression Optional [Row Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowExpression.WithExample] to update the rows with.
+ */
+public fun <T, C> Update<T, C?>.notNull(expression: UpdateExpression<T, C, C>): DataFrame<T> =
+    notNull().with(expression)
+
+/**
+ * ## The Update Operation
+ * 
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types can not be changed).
+ * 
+ * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
+ * 
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Update Overload
+ * ### This overload is a combination of [update] and [with][Update.with].
+ * 
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ * 
+ * 
+ * Provide a new value for every selected cell given its row and its previous value using a
+ * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
+ * 
+ * For example:
+ * 
+ * `df.`[update][update]`("city")` ` { name.firstName + " from " + it }`
+ * 
+ * `df.`[update][update]`("city")` ` { it.uppercase() }`
+ * 
+ * 
+ * 
+ * @param columns The [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample] of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ * @param expression The [Row Value Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample] to update the rows with.
+ */
+public fun <T, C> DataFrame<T>.update(
+    firstCol: ColumnReference<C>,
+    vararg cols: ColumnReference<C>,
+    expression: UpdateExpression<T, C, C>
+): DataFrame<T> =
+    update(*headPlusArray(firstCol, cols)).with(expression)
+
+/**
+ * ## The Update Operation
+ * 
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types can not be changed).
+ * 
+ * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
+ * 
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Update Overload
+ * ### This overload is a combination of [update] and [with][Update.with].
+ * 
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ * 
+ * 
+ * Provide a new value for every selected cell given its row and its previous value using a
+ * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
+ * 
+ * For example:
+ * 
+ * `df.`[update][update]`("city")` ` { name.firstName + " from " + it }`
+ * 
+ * `df.`[update][update]`("city")` ` { it.uppercase() }`
+ * 
+ * 
+ * 
+ * @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] corresponding to columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ * @param expression The [Row Value Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample] to update the rows with.
+ */
+public fun <T, C> DataFrame<T>.update(
+    firstCol: KProperty<C>,
+    vararg cols: KProperty<C>,
+    expression: UpdateExpression<T, C, C>
+): DataFrame<T> =
+    update(*headPlusArray(firstCol, cols)).with(expression)
+
+/**
+ * ## The Update Operation
+ * 
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types can not be changed).
+ * 
+ * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
+ * 
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Update Overload
+ * ### This overload is a combination of [update] and [with][Update.with].
+ * 
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ * 
+ * 
+ * Provide a new value for every selected cell given its row and its previous value using a
+ * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
+ * 
+ * For example:
+ * 
+ * `df.`[update][update]`("city")` ` { name.firstName + " from " + it }`
+ * 
+ * `df.`[update][update]`("city")` ` { it.uppercase() }`
+ * 
+ * 
+ * 
+ * @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] belonging to this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ * @param expression The [Row Value Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample] to update the rows with.
+ */
+public fun <T> DataFrame<T>.update(
+    firstCol: String,
+    vararg cols: String,
+    expression: UpdateExpression<T, Any?, Any?>
+): DataFrame<T> =
+    update(*headPlusArray(firstCol, cols)).with(expression)
+
+/**
+ * Specific version of [with] that simply sets the value of each selected row to {@includeArg [CommonSpecificWithDocFirstArg]}.
+ * 
+ * For example:
+ * 
+ * `df.`[update][update]` { id }.`[where][Update.where]` { it < 0 }.`{@includeArg [CommonSpecificWithDocSecondArg]}`
+ */
+private interface CommonSpecificWithDoc
+
+/** Arg for the resulting value */
+private interface CommonSpecificWithDocFirstArg
+
+/** Arg for the function call */
+private interface CommonSpecificWithDocSecondArg
+
+/**
+ * ## With Null
+ * 
+ * Specific version of [with][org.jetbrains.kotlinx.dataframe.api.with] that simply sets the value of each selected row to `null`.
+ * 
+ * For example:
+ * 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { id }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it < 0 }.`[withNull][withNull]`()`
+ */
+public fun <T, C> Update<T, C>.withNull(): DataFrame<T> = with { null }
+
+/**
+ * ## With Zero
+ * 
+ * Specific version of [with][org.jetbrains.kotlinx.dataframe.api.with] that simply sets the value of each selected row to `0`.
+ * 
+ * For example:
+ * 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { id }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it < 0 }.`[withZero][withZero]`()`
+ */
+public fun <T, C> Update<T, C>.withZero(): DataFrame<T> = updateWithValuePerColumnImpl { 0 as C }
+
+/**
+ * ## With Value
+ * 
+ * Specific version of [with][org.jetbrains.kotlinx.dataframe.api.with] that simply sets the value of each selected row to [value].
+ * 
+ * For example:
+ * 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { id }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it < 0 }.`[withValue][withValue]`(-1)`
+ * 
+ * 
+ * 
+ * @param value The value to set the selected rows to. In contrast to [with][Update.with], this must be the same exact type.
+ */
+public infix fun <T, C> Update<T, C>.withValue(value: C): DataFrame<T> = with { value }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/uppercase.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/uppercase.kt
new file mode 100644
index 000000000..e2595534a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/uppercase.kt
@@ -0,0 +1,9 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.StringCol
+
+// region StringCol
+
+public fun StringCol.uppercase(): StringCol = map { it?.uppercase() }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt
new file mode 100644
index 000000000..7de0675a8
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt
@@ -0,0 +1,87 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.impl.nameGenerator
+import kotlin.reflect.KProperty
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.typeOf
+
+// region DataSchema
+
+@DataSchema
+public interface ValueCount {
+    public val count: Int
+}
+
+// endregion
+
+// region DataColumn
+
+internal val defaultCountColumnName: String = ValueCount::count.name
+
+public fun <T> DataColumn<T>.valueCounts(
+    sort: Boolean = true,
+    ascending: Boolean = false,
+    dropNA: Boolean = true,
+    resultColumn: String = defaultCountColumnName
+): DataFrame<ValueCount> {
+    var grouped = toList().groupBy { it }.map { it.key to it.value.size }
+    if (sort) {
+        grouped = if (ascending) grouped.sortedBy { it.second }
+        else grouped.sortedByDescending { it.second }
+    }
+    if (dropNA) grouped = grouped.filter { !it.first.isNA }
+    val nulls = if (dropNA) false else hasNulls()
+    val values = DataColumn.create(name(), grouped.map { it.first }, type().withNullability(nulls))
+    val countName = if (resultColumn == name()) resultColumn + "1" else resultColumn
+    val counts = DataColumn.create(countName, grouped.map { it.second }, typeOf<Int>())
+    return dataFrameOf(values, counts).cast()
+}
+
+// endregion
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.valueCounts(
+    sort: Boolean = true,
+    ascending: Boolean = false,
+    dropNA: Boolean = true,
+    resultColumn: String = defaultCountColumnName,
+    columns: ColumnsSelector<T, *>? = null
+): DataFrame<T> {
+    var df = if (columns != null) select(columns) else this
+    if (dropNA) df = df.dropNA()
+
+    val rows by columnGroup()
+    val countName = nameGenerator().addUnique(resultColumn)
+    return df.asColumnGroup(rows).asDataColumn().valueCounts(sort, ascending, dropNA, countName).ungroup(rows).cast()
+}
+
+public fun <T> DataFrame<T>.valueCounts(
+    vararg columns: String,
+    sort: Boolean = true,
+    ascending: Boolean = false,
+    dropNA: Boolean = true,
+    resultColumn: String = defaultCountColumnName
+): DataFrame<T> = valueCounts(sort, ascending, dropNA, resultColumn) { columns.toColumns() }
+public fun <T> DataFrame<T>.valueCounts(
+    vararg columns: Column,
+    sort: Boolean = true,
+    ascending: Boolean = false,
+    dropNA: Boolean = true,
+    resultColumn: String = defaultCountColumnName
+): DataFrame<T> = valueCounts(sort, ascending, dropNA, resultColumn) { columns.toColumns() }
+public fun <T> DataFrame<T>.valueCounts(
+    vararg columns: KProperty<*>,
+    sort: Boolean = true,
+    ascending: Boolean = false,
+    dropNA: Boolean = true,
+    resultColumn: String = defaultCountColumnName
+): DataFrame<T> = valueCounts(sort, ascending, dropNA, resultColumn) { columns.toColumns() }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/values.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/values.kt
new file mode 100644
index 000000000..417487f73
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/values.kt
@@ -0,0 +1,177 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelector
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.columnValues
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.internal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.remainingColumnsSelector
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.impl.valuesImpl
+import kotlin.reflect.KProperty
+
+// region DataFrame
+
+public fun <T, C> DataFrame<T>.values(byRow: Boolean = false, columns: ColumnsSelector<T, C>): Sequence<C> = valuesImpl(byRow, columns)
+public fun <T> DataFrame<T>.values(byRows: Boolean = false): Sequence<Any?> = values(byRows) { all() }
+
+public fun <T, C> DataFrame<T>.valuesNotNull(byRow: Boolean = false, columns: ColumnsSelector<T, C?>): Sequence<C> = values(byRow, columns).filterNotNull()
+public fun <T> DataFrame<T>.valuesNotNull(byRow: Boolean = false): Sequence<Any> = valuesNotNull(byRow) { all() }
+
+// endregion
+
+// region GroupBy
+
+public fun <T> Grouped<T>.values(vararg columns: Column, dropNA: Boolean = false, distinct: Boolean = false): DataFrame<T> = values(dropNA, distinct) { columns.toColumns() }
+public fun <T> Grouped<T>.values(vararg columns: String, dropNA: Boolean = false, distinct: Boolean = false): DataFrame<T> = values(dropNA, distinct) { columns.toColumns() }
+public fun <T> Grouped<T>.values(
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, *>
+): DataFrame<T> = aggregate { internal().columnValues(columns, true, dropNA, distinct) }
+public fun <T> Grouped<T>.values(dropNA: Boolean = false, distinct: Boolean = false): DataFrame<T> = values(dropNA, distinct, remainingColumnsSelector())
+
+// endregion
+
+// region ReducedGroupBy
+
+public fun <T, G> ReducedGroupBy<T, G>.values(): DataFrame<G> = values(groupBy.remainingColumnsSelector())
+
+public fun <T, G> ReducedGroupBy<T, G>.values(
+    vararg columns: Column
+): DataFrame<G> = values { columns.toColumns() }
+
+public fun <T, G> ReducedGroupBy<T, G>.values(
+    vararg columns: String
+): DataFrame<G> = values { columns.toColumns() }
+
+public fun <T, G> ReducedGroupBy<T, G>.values(
+    vararg columns: KProperty<*>
+): DataFrame<G> = values { columns.toColumns() }
+
+public fun <T, G> ReducedGroupBy<T, G>.values(
+    columns: ColumnsForAggregateSelector<G, *>
+): DataFrame<G> = groupBy.aggregate { internal().columnValues(columns, reducer) }
+
+// endregion
+
+// region Pivot
+
+public fun <T> Pivot<T>.values(
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, *>
+): DataRow<T> = delegate { values(dropNA, distinct, separate, columns) }
+public fun <T> Pivot<T>.values(
+    vararg columns: Column,
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+    separate: Boolean = false
+): DataRow<T> = values(dropNA, distinct, separate) { columns.toColumns() }
+public fun <T> Pivot<T>.values(
+    vararg columns: String,
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+    separate: Boolean = false
+): DataRow<T> = values(dropNA, distinct, separate) { columns.toColumns() }
+public fun <T> Pivot<T>.values(
+    vararg columns: KProperty<*>,
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+    separate: Boolean = false
+): DataRow<T> = values(dropNA, distinct, separate) { columns.toColumns() }
+
+public fun <T> Pivot<T>.values(dropNA: Boolean = false, distinct: Boolean = false, separate: Boolean = false): DataRow<T> = delegate { values(dropNA, distinct, separate) }
+
+// endregion
+
+// region ReducedPivot
+
+public fun <T> ReducedPivot<T>.values(
+    separate: Boolean = false
+): DataRow<T> = pivot.delegate { reduce(reducer).values(separate = separate) }
+
+public fun <T> ReducedPivot<T>.values(
+    vararg columns: Column,
+    separate: Boolean = false
+): DataRow<T> = values(separate) { columns.toColumns() }
+
+public fun <T> ReducedPivot<T>.values(
+    vararg columns: String,
+    separate: Boolean = false
+): DataRow<T> = values(separate) { columns.toColumns() }
+
+public fun <T> ReducedPivot<T>.values(
+    vararg columns: KProperty<*>,
+    separate: Boolean = false
+): DataRow<T> = values(separate) { columns.toColumns() }
+
+public fun <T> ReducedPivot<T>.values(
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, *>
+): DataRow<T> = pivot.delegate { reduce(reducer).values(separate = separate, columns = columns) }
+
+// endregion
+
+// region PivotGroupBy
+
+public fun <T> PivotGroupBy<T>.values(dropNA: Boolean = false, distinct: Boolean = false, separate: Boolean = false): DataFrame<T> = values(dropNA, distinct, separate, remainingColumnsSelector())
+
+public fun <T> PivotGroupBy<T>.values(
+    vararg columns: Column,
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+    separate: Boolean = false
+): DataFrame<T> = values(dropNA, distinct, separate) { columns.toColumns() }
+public fun <T> PivotGroupBy<T>.values(
+    vararg columns: String,
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+    separate: Boolean = false
+): DataFrame<T> = values(dropNA, distinct, separate) { columns.toColumns() }
+public fun <T> PivotGroupBy<T>.values(
+    vararg columns: KProperty<*>,
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+    separate: Boolean = false
+): DataFrame<T> = values(dropNA, distinct, separate) { columns.toColumns() }
+public fun <T> PivotGroupBy<T>.values(
+    dropNA: Boolean = false,
+    distinct: Boolean = false,
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, *>
+): DataFrame<T> =
+    aggregate(separate = separate) { internal().columnValues(columns, false, dropNA, distinct) }
+
+// endregion
+
+// region ReducedPivotGroupBy
+
+public fun <T> ReducedPivotGroupBy<T>.values(
+    separate: Boolean = false
+): DataFrame<T> = values(separate, pivot.remainingColumnsSelector())
+
+public fun <T> ReducedPivotGroupBy<T>.values(
+    vararg columns: Column,
+    separate: Boolean = false
+): DataFrame<T> = values(separate) { columns.toColumns() }
+
+public fun <T> ReducedPivotGroupBy<T>.values(
+    vararg columns: String,
+    separate: Boolean = false
+): DataFrame<T> = values(separate) { columns.toColumns() }
+
+public fun <T> ReducedPivotGroupBy<T>.values(
+    vararg columns: KProperty<*>,
+    separate: Boolean = false
+): DataFrame<T> = values(separate) { columns.toColumns() }
+
+public fun <T> ReducedPivotGroupBy<T>.values(
+    separate: Boolean = false,
+    columns: ColumnsForAggregateSelector<T, *>
+): DataFrame<T> = pivot.aggregate(separate = separate) { internal().columnValues(columns, reducer) }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/with.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/with.kt
new file mode 100644
index 000000000..7b5942b83
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/with.kt
@@ -0,0 +1,47 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.internal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.withExpr
+import org.jetbrains.kotlinx.dataframe.impl.emptyPath
+import kotlin.reflect.typeOf
+
+// region Pivot
+
+public inline fun <T, reified V> Pivot<T>.with(noinline expression: RowExpression<T, V>): DataRow<T> = delegate { with(expression) }
+
+// endregion
+
+// region ReducedPivot
+
+public inline fun <T, reified V> ReducedPivot<T>.with(noinline expression: RowExpression<T, V>): DataRow<T> = pivot.delegate { reduce(reducer).with(expression) }
+
+// endregion
+
+// region PivotGroupBy
+
+public inline fun <T, reified V> PivotGroupBy<T>.with(noinline expression: RowExpression<T, V>): DataFrame<T> {
+    val type = typeOf<V>()
+    return aggregate { internal().withExpr(type, emptyPath(), expression) }
+}
+
+// endregion
+
+// region ReducedPivotGroupBy
+
+public inline fun <T, reified V> ReducedPivotGroupBy<T>.with(noinline expression: RowExpression<T, V>): DataFrame<T> {
+    val type = typeOf<V>()
+    return pivot.aggregate {
+        val value = reducer(this)?.let {
+            val value = expression(it, it)
+            if (value is Column) it[value]
+            else value
+        }
+        internal().yield(emptyPath(), value, type)
+    }
+}
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/xs.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/xs.kt
new file mode 100644
index 000000000..3706590e7
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/xs.kt
@@ -0,0 +1,21 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.impl.api.xsImpl
+
+// region DataFrame
+
+public fun <T> DataFrame<T>.xs(vararg keyValues: Any?): DataFrame<T> = xs(*keyValues) { allDfs().take(keyValues.size) }
+
+public fun <T, C> DataFrame<T>.xs(vararg keyValues: C, keyColumns: ColumnsSelector<T, C>): DataFrame<T> = xsImpl(keyColumns, false, *keyValues)
+
+// endregion
+
+// region GroupBy
+
+public fun <T, G> GroupBy<T, G>.xs(vararg keyValues: Any?): GroupBy<T, G> = xs(*keyValues) { allDfs().take(keyValues.size) }
+
+public fun <T, G, C> GroupBy<T, G>.xs(vararg keyValues: C, keyColumns: ColumnsSelector<T, C>): GroupBy<T, G> = xsImpl(*keyValues, keyColumns = keyColumns)
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeGenerator.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeGenerator.kt
new file mode 100644
index 000000000..4ec420258
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeGenerator.kt
@@ -0,0 +1,73 @@
+package org.jetbrains.dataframe.impl.codeGen
+
+import org.jetbrains.kotlinx.dataframe.codeGen.CodeWithConverter
+import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadDfMethod
+import org.jetbrains.kotlinx.dataframe.codeGen.ExtensionsCodeGenerator
+import org.jetbrains.kotlinx.dataframe.codeGen.Marker
+import org.jetbrains.kotlinx.dataframe.codeGen.MarkerVisibility
+import org.jetbrains.kotlinx.dataframe.codeGen.MarkersExtractor
+import org.jetbrains.kotlinx.dataframe.codeGen.NameNormalizer
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.CodeGeneratorImpl
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.FullyQualifiedNames
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.ShortNames
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.id
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import kotlin.reflect.KClass
+
+public enum class InterfaceGenerationMode {
+    NoFields,
+    WithFields,
+    Enum,
+    TypeAlias,
+    None;
+}
+
+public data class CodeGenResult(val code: CodeWithConverter, val newMarkers: List<Marker>)
+
+public interface CodeGenerator : ExtensionsCodeGenerator {
+
+    public fun generate(
+        schema: DataFrameSchema,
+        name: String,
+        fields: Boolean,
+        extensionProperties: Boolean,
+        isOpen: Boolean,
+        visibility: MarkerVisibility = MarkerVisibility.IMPLICIT_PUBLIC,
+        knownMarkers: Iterable<Marker> = emptyList(),
+        readDfMethod: DefaultReadDfMethod? = null,
+        fieldNameNormalizer: NameNormalizer = NameNormalizer.id(),
+    ): CodeGenResult
+
+    public fun generate(
+        marker: Marker,
+        interfaceMode: InterfaceGenerationMode,
+        extensionProperties: Boolean,
+        readDfMethod: DefaultReadDfMethod? = null,
+    ): CodeWithConverter
+
+    public companion object {
+        public fun create(useFqNames: Boolean = true): CodeGenerator {
+            return if (useFqNames) {
+                CodeGeneratorImpl(FullyQualifiedNames)
+            } else {
+                CodeGeneratorImpl(ShortNames)
+            }
+        }
+    }
+}
+
+@PublishedApi
+internal fun CodeGenerator.generate(
+    markerClass: KClass<*>,
+    interfaceMode: InterfaceGenerationMode,
+    extensionProperties: Boolean,
+): CodeWithConverter = generate(
+    MarkersExtractor.get(markerClass),
+    interfaceMode,
+    extensionProperties
+)
+
+public inline fun <reified T> CodeGenerator.generate(
+    interfaceMode: InterfaceGenerationMode,
+    extensionProperties: Boolean,
+): CodeWithConverter = generate(T::class, interfaceMode, extensionProperties)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeWithConverter.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeWithConverter.kt
new file mode 100644
index 000000000..dd48b739f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeWithConverter.kt
@@ -0,0 +1,29 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import org.jetbrains.kotlinx.jupyter.api.Code
+import org.jetbrains.kotlinx.jupyter.api.VariableName
+
+/**
+ * Class representing generated code declarations for a [Marker].
+ *
+ * @param declarations The generated code.
+ * @param converter Optional converter for the [Marker], such as a [org.jetbrains.kotlinx.dataframe.api.cast], often used for Jupyter.
+ */
+public data class CodeWithConverter(val declarations: Code, val converter: (VariableName) -> Code = EmptyConverter) {
+
+    public companion object {
+        public const val EmptyDeclarations: Code = ""
+        public val EmptyConverter: (VariableName) -> Code = { it }
+        public val Empty: CodeWithConverter = CodeWithConverter(EmptyDeclarations, EmptyConverter)
+    }
+
+    val hasDeclarations: Boolean get() = declarations.isNotBlank()
+
+    val hasConverter: Boolean get() = converter("it").trim() != "it"
+
+    public fun with(name: VariableName): Code = when {
+        !hasConverter -> declarations
+        !hasDeclarations -> converter(name)
+        else -> declarations + "\n" + converter(name)
+    }
+}
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
new file mode 100644
index 000000000..5f93bc31a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/DefaultReadDfMethods.kt
@@ -0,0 +1,103 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import com.squareup.kotlinpoet.ClassName
+import com.squareup.kotlinpoet.FunSpec
+import com.squareup.kotlinpoet.KModifier
+import com.squareup.kotlinpoet.ParameterSpec
+import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
+import com.squareup.kotlinpoet.PropertySpec
+import com.squareup.kotlinpoet.TypeSpec
+import com.squareup.kotlinpoet.asClassName
+import com.squareup.kotlinpoet.typeNameOf
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.io.MethodArguments
+
+public interface DefaultReadDfMethod {
+    public fun toDeclaration(marker: Marker, visibility: String): String
+
+    public val additionalImports: List<String>
+}
+
+// Used APIs
+private const val cast = "cast"
+private const val verify = "verify" // cast(true) is obscure, i think it's better to use named argument here
+private const val readCSV = "readCSV"
+private const val readTSV = "readTSV"
+private const val readJson = "readJson"
+
+public abstract class AbstractDefaultReadMethod(
+    private val path: String?,
+    private val arguments: MethodArguments,
+    private val methodName: String,
+) : DefaultReadDfMethod {
+    override fun toDeclaration(marker: Marker, visibility: String): String {
+        val parameters = arguments.defaultValues.map {
+            ParameterSpec.builder(it.name, it.property.type)
+                .defaultValue("%N", it.property)
+                .build()
+        }
+
+        val defaultPath = path?.let {
+            PropertySpec.builder("defaultPath", typeNameOf<String>(), KModifier.CONST)
+                .initializer("%S", path)
+                .build()
+        }
+
+        val type = DataFrame::class.asClassName().parameterizedBy(ClassName("", listOf(marker.shortName)))
+
+        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 })
+            .addFunction(
+                FunSpec.builder(methodName)
+                    .returns(type)
+                    .addParameter(
+                        ParameterSpec.builder("path", typeNameOf<String>())
+                            .apply {
+                                if (defaultPath != null) {
+                                    defaultValue("%N", defaultPath)
+                                }
+                            }
+                            .build()
+
+                    )
+                    .addParameters(parameters)
+                    .addParameter(
+                        ParameterSpec.builder("verify", typeNameOf<Boolean?>())
+                            .defaultValue("null")
+                            .build()
+                    )
+                    .addCode(
+                        """
+                        val df = DataFrame.$methodName(path, $arguments)
+                        return if ($verify != null) df.$cast($verify = $verify) else df.$cast()
+                        """.trimIndent()
+                    )
+                    .build()
+            )
+            .build()
+
+        return typeSpec.toString()
+    }
+
+    override val additionalImports: List<String> = listOf("import org.jetbrains.kotlinx.dataframe.io.$methodName")
+}
+
+internal class DefaultReadJsonMethod(path: String?, arguments: MethodArguments) : AbstractDefaultReadMethod(
+    path = path,
+    arguments = arguments,
+    methodName = readJson,
+)
+
+internal class DefaultReadCsvMethod(
+    path: String?,
+    arguments: MethodArguments,
+) : AbstractDefaultReadMethod(path, arguments, readCSV)
+
+internal class DefaultReadTsvMethod(path: String?) : AbstractDefaultReadMethod(path, MethodArguments.EMPTY, readTSV)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ExtensionsCodeGenerator.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ExtensionsCodeGenerator.kt
new file mode 100644
index 000000000..de874282f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ExtensionsCodeGenerator.kt
@@ -0,0 +1,12 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.ExtensionsCodeGeneratorImpl
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.ShortNames
+
+public interface ExtensionsCodeGenerator {
+    public fun generate(marker: IsolatedMarker): CodeWithConverter
+
+    public companion object {
+        public fun create(): ExtensionsCodeGenerator = ExtensionsCodeGeneratorImpl(ShortNames)
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/GeneratedField.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/GeneratedField.kt
new file mode 100644
index 000000000..d82ca0d78
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/GeneratedField.kt
@@ -0,0 +1,145 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.needsQuoting
+import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
+
+public sealed interface FieldType {
+    public class ValueFieldType(public val typeFqName: String) : FieldType
+    public class FrameFieldType(public val markerName: String, public val nullable: Boolean) : FieldType
+    public class GroupFieldType(public val markerName: String) : FieldType
+}
+
+/**
+ * Returns whether the column type ends with `?` or not.
+ * NOTE: for [FieldType.FrameFieldType], the `nullable` property indicates the nullability of the frame itself, not the type of the column.
+ */
+public fun FieldType.isNullable(): Boolean =
+    when (this) {
+        is FieldType.FrameFieldType -> markerName.endsWith("?") || markerName == "*"
+        is FieldType.GroupFieldType -> markerName.endsWith("?") || markerName == "*"
+        is FieldType.ValueFieldType -> typeFqName.endsWith("?") || typeFqName == "*"
+    }
+
+/**
+ * Returns whether the column type doesn't end with `?` or whether it does.
+ * NOTE: for [FieldType.FrameFieldType], the `nullable` property indicates the nullability of the frame itself, not the type of the column.
+ */
+public fun FieldType.isNotNullable(): Boolean = !isNullable()
+
+private fun String.toNullable() = if (this.last() == '?' || this == "*") this else "$this?"
+
+/**
+ * Returns a new fieldType with the same type but with nullability in the column type.
+ * NOTE: for [FieldType.FrameFieldType], the `nullable` property indicates the nullability of the frame itself, not the type of the column.
+ */
+public fun FieldType.toNullable(): FieldType =
+    if (isNotNullable()) {
+        when (this) {
+            is FieldType.FrameFieldType -> FieldType.FrameFieldType(markerName.toNullable(), nullable)
+            is FieldType.GroupFieldType -> FieldType.GroupFieldType(markerName.toNullable())
+            is FieldType.ValueFieldType -> FieldType.ValueFieldType(typeFqName.toNullable())
+        }
+    } else this
+
+/**
+ * Returns a new fieldType with the same type but with nullability disabled in the column type.
+ * NOTE: for [FieldType.FrameFieldType], the `nullable` property indicates the nullability of the frame itself, not the type of the column.
+ */
+public fun FieldType.toNotNullable(): FieldType =
+    if (isNullable()) {
+        when (this) {
+            is FieldType.FrameFieldType -> FieldType.FrameFieldType(
+                markerName = markerName.let {
+                    if (it == "*") "Any"
+                    else it.removeSuffix("?")
+                },
+                nullable = nullable,
+            )
+
+            is FieldType.GroupFieldType -> FieldType.GroupFieldType(
+                markerName = markerName.let {
+                    if (it == "*") "Any"
+                    else it.removeSuffix("?")
+                },
+            )
+
+            is FieldType.ValueFieldType -> FieldType.ValueFieldType(
+                typeFqName = typeFqName.let {
+                    if (it == "*") "Any"
+                    else it.removeSuffix("?")
+                },
+            )
+        }
+    } else this
+
+public val FieldType.name: String
+    get() = when (this) {
+        is FieldType.FrameFieldType -> markerName
+        is FieldType.GroupFieldType -> markerName
+        is FieldType.ValueFieldType -> typeFqName
+    }
+
+public class ValidFieldName private constructor(private val identifier: String, public val needsQuote: Boolean) {
+    public val unquoted: String get() = identifier
+    public val quotedIfNeeded: String get() = if (needsQuote) "`$identifier`" else identifier
+
+    public operator fun plus(other: ValidFieldName): ValidFieldName {
+        return ValidFieldName(identifier = identifier + other.identifier, needsQuote = needsQuote || other.needsQuote)
+    }
+
+    public companion object {
+        public fun of(name: String): ValidFieldName {
+            val needsQuote = name.needsQuoting()
+            var result = name
+            if (needsQuote) {
+                result = name.replace("<", "{")
+                    .replace(">", "}")
+                    .replace("::", " - ")
+                    .replace(": ", " - ")
+                    .replace(":", " - ")
+                    .replace(".", " ")
+                    .replace("/", "-")
+                    .replace("[", "{")
+                    .replace("]", "}")
+                    .replace("`", "'")
+                    .replace(";", " ")
+                    .replace("\\", " ")
+            }
+
+            return ValidFieldName(result, needsQuote)
+        }
+    }
+}
+
+public interface BaseField {
+    public val fieldName: ValidFieldName
+    public val columnName: String
+    public val fieldType: FieldType
+}
+
+public fun BaseField.toNullable(): BaseField =
+    if (fieldType.isNullable()) this
+    else object : BaseField {
+        override val fieldName: ValidFieldName = this@toNullable.fieldName
+        override val columnName: String = this@toNullable.columnName
+        override val fieldType: FieldType = this@toNullable.fieldType.toNullable()
+    }
+
+public fun BaseField.toNotNullable(): BaseField =
+    if (fieldType.isNotNullable()) this
+    else object : BaseField {
+        override val fieldName: ValidFieldName = this@toNotNullable.fieldName
+        override val columnName: String = this@toNotNullable.columnName
+        override val fieldType: FieldType = this@toNotNullable.fieldType.toNotNullable()
+    }
+
+public data class GeneratedField(
+    override val fieldName: ValidFieldName,
+    override val columnName: String,
+    val overrides: Boolean,
+    val columnSchema: ColumnSchema,
+    override val fieldType: FieldType,
+) : BaseField {
+    val columnKind: ColumnKind get() = columnSchema.kind
+}
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
new file mode 100644
index 000000000..7d11defeb
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/Marker.kt
@@ -0,0 +1,119 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import org.jetbrains.kotlinx.dataframe.impl.schema.DataFrameSchemaImpl
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import kotlin.reflect.KClass
+
+public enum class MarkerVisibility {
+    INTERNAL, IMPLICIT_PUBLIC, EXPLICIT_PUBLIC
+}
+
+public interface IsolatedMarker {
+    public val name: String
+    public val fields: List<BaseField>
+    public val visibility: MarkerVisibility
+
+    /**
+     * Type parameters for in front of the function or getter/setter.
+     * Like `<T : Int>` in `val <T : Int> MyType<T>.something get() = ...`.
+     */
+    public val typeParameters: String
+
+    /**
+     * Type arguments belonging to this marker.
+     * Like `<MyType>` in `MyMarker<MyType>`.
+     */
+    public val typeArguments: String
+}
+
+public abstract class AbstractMarker(
+    typeParameters: List<String>,
+    typeArguments: List<String>,
+) : IsolatedMarker {
+    override val typeParameters: String = typeParameters.join()
+    override val typeArguments: String = typeArguments.join()
+
+    private fun List<String>.join() = if (isEmpty()) {
+        ""
+    } else {
+        joinToString(", ", "<", ">")
+    }
+}
+
+public open class Marker(
+    override val name: String,
+    public val isOpen: Boolean,
+    override val fields: List<GeneratedField>,
+    superMarkers: List<Marker>,
+    override val visibility: MarkerVisibility,
+    typeParameters: List<String>,
+    typeArguments: List<String>,
+) : AbstractMarker(typeParameters, typeArguments) {
+
+    public val shortName: String
+        get() = name.substringAfterLast(".")
+
+    public val superMarkers: Map<String, Marker> = superMarkers.associateBy { it.name }
+
+    public val allSuperMarkers: Map<String, Marker> by lazy {
+        val result = this.superMarkers.toMutableMap()
+        this.superMarkers.forEach {
+            result.putAll(it.value.allSuperMarkers)
+        }
+        result
+    }
+
+    public val allFields: List<GeneratedField> by lazy {
+
+        val fieldsMap = mutableMapOf<String, GeneratedField>()
+        this.superMarkers.values.forEach {
+            it.allFields.forEach {
+                fieldsMap[it.fieldName.quotedIfNeeded] = it
+            }
+        }
+        fields.forEach {
+            fieldsMap[it.fieldName.quotedIfNeeded] = it
+        }
+        fieldsMap.values.toList()
+    }
+
+    public val allFieldsByColumn: Map<String, GeneratedField> by lazy {
+        allFields.associateBy { it.columnName }
+    }
+
+    public fun getField(columnName: String): GeneratedField? = allFieldsByColumn[columnName]
+
+    public fun containsColumn(columnName: String): Boolean = allFieldsByColumn.containsKey(columnName)
+
+    public val columnNames: List<String> get() = allFields.map { it.columnName }
+
+    public val schema: DataFrameSchema by lazy { DataFrameSchemaImpl(allFields.associate { it.columnName to it.columnSchema }) }
+
+    public fun implements(schema: Marker): Boolean =
+        if (schema.name == name) true else allSuperMarkers[schema.name]?.let { it === schema } ?: false
+
+    public fun implementsAll(schemas: Iterable<Marker>): Boolean = schemas.all { implements(it) }
+
+    internal companion object {
+        operator fun invoke(
+            name: String,
+            isOpen: Boolean,
+            fields: List<GeneratedField>,
+            superMarkers: List<Marker>,
+            visibility: MarkerVisibility,
+            klass: KClass<*>,
+        ): Marker {
+            val typeParameters = klass.typeParameters.map {
+                buildString {
+                    append(it.name)
+                    if (it.upperBounds.isNotEmpty()) {
+                        append(" : ")
+                        append(it.upperBounds.joinToString(",") { it.toString() })
+                    }
+                }
+            }
+            val typeArguments = klass.typeParameters.map { it.name }
+            return Marker(name, isOpen, fields, superMarkers, visibility, typeParameters, typeArguments)
+        }
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/MarkersExtractor.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/MarkersExtractor.kt
new file mode 100644
index 000000000..ef883a33e
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/MarkersExtractor.kt
@@ -0,0 +1,91 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.ColumnName
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.impl.schema.getPropertiesOrder
+import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+import kotlin.reflect.full.findAnnotation
+import kotlin.reflect.full.hasAnnotation
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.full.superclasses
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.jvm.jvmErasure
+import kotlin.reflect.typeOf
+
+internal fun KType.shouldBeConvertedToFrameColumn(): Boolean = when (jvmErasure) {
+    DataFrame::class -> true
+    List::class -> arguments[0].type?.jvmErasure?.hasAnnotation<DataSchema>() == true
+    else -> false
+}
+
+internal fun KType.shouldBeConvertedToColumnGroup(): Boolean = jvmErasure.let {
+    it == DataRow::class || it.hasAnnotation<DataSchema>()
+}
+
+private fun String.toNullable(): String = if (endsWith("?")) this else "$this?"
+
+internal object MarkersExtractor {
+
+    private val cache = mutableMapOf<Pair<KClass<*>, Boolean>, Marker>()
+
+    inline fun <reified T> get() = get(T::class)
+
+    fun get(markerClass: KClass<*>, nullableProperties: Boolean = false): Marker =
+        cache.getOrPut(Pair(markerClass, nullableProperties)) {
+            val fields = getFields(markerClass, nullableProperties)
+            val isOpen = !markerClass.isSealed &&
+                markerClass.java.isInterface &&
+                markerClass.findAnnotation<DataSchema>()?.isOpen == true
+
+            val baseSchemas = markerClass.superclasses.filter { it != Any::class }.map { get(it, nullableProperties) }
+            Marker(
+                name = markerClass.qualifiedName ?: markerClass.simpleName!!,
+                isOpen = isOpen,
+                fields = fields,
+                superMarkers = baseSchemas,
+                visibility = MarkerVisibility.IMPLICIT_PUBLIC,
+                klass = markerClass,
+            )
+        }
+
+    private fun getFields(markerClass: KClass<*>, nullableProperties: Boolean): List<GeneratedField> {
+        val order = getPropertiesOrder(markerClass)
+        return markerClass.memberProperties.sortedBy { order[it.name] ?: Int.MAX_VALUE }.mapIndexed { _, it ->
+            val fieldName = ValidFieldName.of(it.name)
+            val columnName = it.findAnnotation<ColumnName>()?.name ?: fieldName.unquoted
+            val type = it.returnType
+            val fieldType: FieldType
+            val clazz = type.jvmErasure
+            val columnSchema = when {
+                type.shouldBeConvertedToColumnGroup() -> {
+                    val nestedType = if (clazz == DataRow::class) type.arguments[0].type ?: typeOf<Any?>() else type
+                    val marker = get(nestedType.jvmErasure, nullableProperties || type.isMarkedNullable)
+                    fieldType = FieldType.GroupFieldType(marker.name)
+                    ColumnSchema.Group(marker.schema, nestedType)
+                }
+
+                type.shouldBeConvertedToFrameColumn() -> {
+                    val frameType = type.arguments[0].type ?: typeOf<Any?>()
+                    val marker = get(frameType.jvmErasure, nullableProperties || type.isMarkedNullable)
+                    fieldType = FieldType.FrameFieldType(marker.name, type.isMarkedNullable || nullableProperties)
+                    ColumnSchema.Frame(marker.schema, type.isMarkedNullable, frameType)
+                }
+
+                else -> {
+                    fieldType = FieldType.ValueFieldType(
+                        if (nullableProperties) type.toString().toNullable() else type.toString()
+                    )
+                    ColumnSchema.Value(
+                        if (nullableProperties) type.withNullability(true) else type
+                    )
+                }
+            }
+
+            GeneratedField(fieldName, columnName, false, columnSchema, fieldType)
+        }
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/NameNormalizer.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/NameNormalizer.kt
new file mode 100644
index 000000000..78ba98a3c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/NameNormalizer.kt
@@ -0,0 +1,5 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+public class NameNormalizer(private val f: (String) -> String) : (String) -> String by f {
+    public companion object
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ReplCodeGenerator.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ReplCodeGenerator.kt
new file mode 100644
index 000000000..63ceb4ffd
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ReplCodeGenerator.kt
@@ -0,0 +1,30 @@
+package org.jetbrains.dataframe.impl.codeGen
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.codeGen.CodeWithConverter
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.ReplCodeGeneratorImpl
+import org.jetbrains.kotlinx.jupyter.api.Code
+import kotlin.reflect.KClass
+import kotlin.reflect.KProperty
+
+internal interface ReplCodeGenerator {
+
+    fun process(
+        df: AnyFrame,
+        property: KProperty<*>? = null,
+    ): CodeWithConverter
+
+    fun process(
+        row: AnyRow,
+        property: KProperty<*>? = null,
+    ): CodeWithConverter
+
+    fun process(markerClass: KClass<*>): Code
+
+    companion object {
+        fun create(): ReplCodeGenerator = ReplCodeGeneratorImpl()
+    }
+}
+
+internal inline fun <reified T> ReplCodeGenerator.process(): Code = process(T::class)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/SchemaProcessor.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/SchemaProcessor.kt
new file mode 100644
index 000000000..23d57898e
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/SchemaProcessor.kt
@@ -0,0 +1,27 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.SchemaProcessorImpl
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+
+internal interface SchemaProcessor {
+
+    val generatedMarkers: List<Marker>
+
+    val namePrefix: String
+
+    fun process(
+        schema: DataFrameSchema,
+        isOpen: Boolean,
+        visibility: MarkerVisibility = MarkerVisibility.IMPLICIT_PUBLIC
+    ): Marker
+
+    companion object {
+        fun create(
+            namePrefix: String,
+            existingMarkers: Iterable<Marker> = emptyList(),
+            fieldNameNormalizer: (String) -> String = { it }
+        ): SchemaProcessorImpl {
+            return SchemaProcessorImpl(existingMarkers, namePrefix, fieldNameNormalizer)
+        }
+    }
+}
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
new file mode 100644
index 000000000..578be837a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/generateCode.kt
@@ -0,0 +1,43 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import org.jetbrains.dataframe.impl.codeGen.CodeGenerator
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.schema
+
+public inline fun <reified T> DataFrame<T>.generateCode(
+    fields: Boolean = true,
+    extensionProperties: Boolean = true,
+): String {
+    val name = if (T::class.isAbstract) {
+        T::class.simpleName!!
+    } else "DataEntry"
+    return generateCode(name, fields, extensionProperties)
+}
+
+public fun <T> DataFrame<T>.generateCode(
+    markerName: String,
+    fields: Boolean = true,
+    extensionProperties: Boolean = true,
+    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
+}
+
+public inline fun <reified T> DataFrame<T>.generateInterfaces(): String = generateCode(
+    fields = true,
+    extensionProperties = false
+)
+
+public fun <T> DataFrame<T>.generateInterfaces(markerName: String): String = generateCode(
+    markerName = markerName,
+    fields = true,
+    extensionProperties = false
+)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/BaseColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/BaseColumn.kt
new file mode 100644
index 000000000..2c5d1838f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/BaseColumn.kt
@@ -0,0 +1,72 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.DataColumnInternal
+import org.jetbrains.kotlinx.dataframe.impl.headPlusIterable
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+
+/**
+ * Column with [type], [name]/[path] and [values]
+ * Base interface for all three kinds of columns: [ValueColumn], [ColumnGroup] and [FrameColumn].
+ * Column operations that doesn't clash by signature with [DataFrame] operations can be defined for [BaseColumn]
+ *
+ * @param T type of values contained in column.
+ */
+public interface BaseColumn<out T> : ColumnReference<T> {
+
+    // region info
+
+    public fun size(): Int
+    public fun kind(): ColumnKind
+    public fun type(): KType
+
+    // TODO: remove
+    public fun defaultValue(): T?
+
+    // endregion
+
+    // region get
+
+    public operator fun get(index: Int): T
+    public operator fun get(firstIndex: Int, vararg otherIndices: Int): BaseColumn<T> = get(
+        headPlusIterable(
+            firstIndex,
+            otherIndices.asIterable()
+        )
+    )
+    public operator fun get(row: AnyRow): T = get(row.index())
+
+    public operator fun get(range: IntRange): BaseColumn<T>
+
+    public operator fun get(indices: Iterable<Int>): BaseColumn<T>
+
+    public operator fun get(columnName: String): AnyCol
+
+    // endregion
+
+    // region values
+
+    public fun values(): Iterable<T>
+
+    public fun toList(): List<T> = values().asList()
+    public fun toSet(): Set<T>
+
+    public fun distinct(): BaseColumn<T>
+    public fun countDistinct(): Int
+
+    public operator fun contains(value: @UnsafeVariance T): Boolean
+
+    // endregion
+
+    override fun rename(newName: String): BaseColumn<T>
+
+    public override operator fun getValue(thisRef: Any?, property: KProperty<*>): BaseColumn<T> = (this as DataColumnInternal<*>).rename(property.columnName).forceResolve() as BaseColumn<T>
+}
+
+internal val <T> BaseColumn<T>.values: Iterable<T> get() = values()
+internal val AnyBaseCol.size: Int get() = size()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnAccessor.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnAccessor.kt
new file mode 100644
index 000000000..4536755c6
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnAccessor.kt
@@ -0,0 +1,27 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnGroup
+import org.jetbrains.kotlinx.dataframe.api.frameColumn
+import kotlin.reflect.KProperty
+
+/**
+ * Combination of [column path][path] and [column type][T].
+ *
+ * Used to retrieve [DataColumn] from [DataFrame] or value from [DataRow].
+ *
+ * Can be created by [column], [columnGroup] or [frameColumn] delegates.
+ *
+ * @param T Expected [type][DataColumn.type] of values in the column
+ */
+public interface ColumnAccessor<out T> : ColumnReference<T> {
+
+    public override operator fun getValue(thisRef: Any?, property: KProperty<*>): ColumnAccessor<T> = this
+
+    public operator fun <C> get(column: ColumnReference<C>): ColumnAccessor<C>
+
+    override fun rename(newName: String): ColumnAccessor<T>
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnGroup.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnGroup.kt
new file mode 100644
index 000000000..bce661df7
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnGroup.kt
@@ -0,0 +1,42 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.columnGroup
+import kotlin.reflect.KProperty
+
+/**
+ * Group of columns. Used to create column hierarchy in [DataFrame].
+ *
+ * ColumnGroup is a mix of [DataFrame] and [DataColumn] that supports all [DataFrame] operations but also has [column name][name] and [column type][type].
+ * It derives not from [DataColumn], but from [BaseColumn] to avoid API clashes between [DataFrame] and [DataColumn].
+ *
+ * ColumnGroup interface can be returned by:
+ * - extension property generated for [DataSchema]
+ * - [ColumnAccessor] created by [columnGroup] delegate
+ * - explicit cast using [asColumnGroup]
+ *
+ * @param T Schema marker. See [DataFrame] for details.
+ */
+public interface ColumnGroup<out T> : BaseColumn<DataRow<T>>, DataFrame<T> {
+
+    override fun get(indices: Iterable<Int>): ColumnGroup<T>
+
+    override fun get(columnName: String): AnyCol
+
+    override fun kind(): ColumnKind = ColumnKind.Group
+
+    override fun distinct(): ColumnGroup<T>
+
+    override fun get(firstIndex: Int, vararg otherIndices: Int): ColumnGroup<T>
+
+    override fun get(range: IntRange): ColumnGroup<T>
+
+    override fun rename(newName: String): ColumnGroup<T>
+
+    override operator fun getValue(thisRef: Any?, property: KProperty<*>): ColumnGroup<T> = super.getValue(thisRef, property) as ColumnGroup<T>
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnKind.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnKind.kt
new file mode 100644
index 000000000..a4dff8b68
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnKind.kt
@@ -0,0 +1,13 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+public enum class ColumnKind {
+    Value {
+        override fun toString(): String = "ValueColumn"
+    },
+    Group {
+        override fun toString(): String = "ColumnGroup"
+    },
+    Frame {
+        override fun toString(): String = "FrameColumn"
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnPath.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnPath.kt
new file mode 100644
index 000000000..78269d6bf
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnPath.kt
@@ -0,0 +1,57 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnAccessorImpl
+import org.jetbrains.kotlinx.dataframe.impl.owner
+
+/**
+ * Path to a [column][DataColumn] in [DataFrame].
+ *
+ * Stores a list of [column names][DataColumn.name] that are used to retrieve columns through a chain of [column groups][ColumnGroup].
+ */
+public data class ColumnPath(val path: List<String>) : List<String> by path, ColumnAccessor<Any?> {
+
+    public constructor(name: String) : this(listOf(name))
+
+    public fun drop(size: Int): ColumnPath = ColumnPath(path.drop(size))
+
+    public fun parent(): ColumnPath? = if (path.isEmpty()) null else dropLast(1)
+
+    public fun dropLast(size: Int = 1): ColumnPath = ColumnPath(path.dropLast(size))
+
+    public fun dropFirst(size: Int = 1): ColumnPath = ColumnPath(path.drop(size))
+
+    public operator fun plus(name: String): ColumnPath = ColumnPath(path + name)
+
+    public operator fun plus(otherPath: ColumnPath): ColumnPath = ColumnPath(path + otherPath)
+
+    public operator fun plus(otherPath: Iterable<String>): ColumnPath = ColumnPath(path + otherPath)
+
+    public fun take(first: Int): ColumnPath = ColumnPath(path.take(first))
+
+    public fun replaceLast(name: String): ColumnPath = ColumnPath(if (size < 2) listOf(name) else dropLast(1) + name)
+
+    public fun takeLast(first: Int): ColumnPath = ColumnPath(path.takeLast(first))
+
+    override fun path(): ColumnPath = this
+
+    override fun name(): String = path.last()
+
+    val columnName: String get() = name()
+
+    val parentName: String? get() = if (path.size > 1) path[path.size - 2] else null
+
+    override fun rename(newName: String): ColumnPath = ColumnPath(path.dropLast(1) + newName)
+
+    override fun getValue(row: AnyRow): Any? = row.owner[this][row.index()]
+
+    override fun getValueOrNull(row: AnyRow): Any? = row.owner.getColumnOrNull(this)?.get(row.index())
+
+    override fun toString(): String = path.toString()
+
+    public fun joinToString(separator: String = "/"): String = path.joinToString(separator)
+
+    override fun <C> get(column: ColumnReference<C>): ColumnAccessor<C> = ColumnAccessorImpl(this + column.path())
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnReference.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnReference.kt
new file mode 100644
index 000000000..e65d38476
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnReference.kt
@@ -0,0 +1,44 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.RenamedColumnReference
+import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.getColumn
+import kotlin.reflect.KProperty
+
+/**
+ * Entity that can retrieve [DataColumn] from [DataFrame] or value from [DataRow].
+ *
+ * Base interface for [DataColumn] and [ColumnAccessor].
+ * @param C Expected [type][DataColumn.type] of values in the column
+ */
+public interface ColumnReference<out C> : SingleColumn<C> {
+
+    public operator fun getValue(thisRef: Any?, property: KProperty<*>): ColumnReference<C> = renamedReference(property.columnName)
+
+    public fun name(): String
+
+    public fun rename(newName: String): ColumnReference<C>
+
+    public fun path(): ColumnPath = ColumnPath(name)
+
+    public fun getValue(row: AnyRow): C = resolveFor(row.df())!![row.index()]
+
+    public fun getValueOrNull(row: AnyRow): C? = resolveFor(row.df())?.get(row.index())
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>? {
+        return context.df.getColumn<C>(path(), context.unresolvedColumnsPolicy)?.addPath(path())
+    }
+}
+
+internal fun <C> ColumnReference<C>.renamedReference(newName: String): ColumnReference<C> = RenamedColumnReference(this, newName)
+
+internal fun ColumnReference<*>.shortPath() = ColumnPath(name)
+
+internal fun <C> ColumnReference<C>.resolveFor(df: AnyFrame): ColumnWithPath<C>? = resolveSingle(ColumnResolutionContext(df, UnresolvedColumnsPolicy.Skip))
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnSet.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnSet.kt
new file mode 100644
index 000000000..794f94aab
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnSet.kt
@@ -0,0 +1,26 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+
+/**
+ * Entity that can be resolved into a list of [columns][DataColumn].
+ *
+ * Used as a return type of [ColumnsSelector].
+ * @param C common type of resolved columns
+ */
+public interface ColumnSet<out C> {
+
+    public fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>>
+}
+
+public class ColumnResolutionContext internal constructor (
+    internal val df: DataFrame<*>,
+    internal val unresolvedColumnsPolicy: UnresolvedColumnsPolicy
+) {
+
+    public val allowMissingColumns: Boolean = unresolvedColumnsPolicy != UnresolvedColumnsPolicy.Fail
+}
+
+internal enum class UnresolvedColumnsPolicy { Fail, Skip, Create }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnWithPath.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnWithPath.kt
new file mode 100644
index 000000000..d14595add
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnWithPath.kt
@@ -0,0 +1,27 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.impl.columns.addParentPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.depth
+
+public interface ColumnWithPath<out T> : DataColumn<T> {
+
+    public val data: DataColumn<T>
+    public val path: ColumnPath
+    public val name: String get() = name()
+    public val parentName: String? get() = path.parentName
+    public fun depth(): Int = path.depth()
+    public fun <C> getChild(accessor: ColumnReference<C>): ColumnWithPath<C>? = asColumnGroup().getColumnOrNull(accessor)?.addPath(path + accessor.path())
+    public fun getChild(name: String): ColumnWithPath<Any?>? = asColumnGroup().getColumnOrNull(name)?.addParentPath(path)
+    public fun getChild(index: Int): ColumnWithPath<Any?>? = asColumnGroup().getColumnOrNull(index)?.addParentPath(path)
+    public fun children(): List<ColumnWithPath<Any?>> = if (isColumnGroup()) data.asColumnGroup().columns().map { it.addParentPath(path) } else emptyList()
+
+    override fun path(): ColumnPath = path
+
+    override fun rename(newName: String): ColumnWithPath<T>
+}
+
+public val <T> ColumnWithPath<T>.depth: Int get() = path.depth()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/FrameColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/FrameColumn.kt
new file mode 100644
index 000000000..70b988740
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/FrameColumn.kt
@@ -0,0 +1,23 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+
+/**
+ * Column that stores values of type [DataFrame]
+ *
+ * @param T schema marker of contained dataframes. See [DataFrame] for details.
+ */
+public interface FrameColumn<out T> : DataColumn<DataFrame<T>> {
+
+    public val schema: Lazy<DataFrameSchema>
+
+    override fun distinct(): FrameColumn<T>
+
+    override fun kind(): ColumnKind = ColumnKind.Frame
+
+    override fun rename(newName: String): FrameColumn<T>
+
+    override fun get(indices: Iterable<Int>): FrameColumn<T>
+}
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
new file mode 100644
index 000000000..f822f9774
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/SingleColumn.kt
@@ -0,0 +1,15 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+
+/**
+ * Entity that can be [resolved][resolveSingle] into [DataColumn].
+ *
+ * @param C Column [type][BaseColumn.type] of resolved column.
+ */
+public interface SingleColumn<out C> : ColumnSet<C> {
+
+    override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> = 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/columns/ValueColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ValueColumn.kt
new file mode 100644
index 000000000..12470fefc
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ValueColumn.kt
@@ -0,0 +1,24 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import kotlin.reflect.KProperty
+
+/**
+ * Column that stores values.
+ *
+ * @param T - type of values
+ */
+public interface ValueColumn<out T> : DataColumn<T> {
+
+    override fun kind(): ColumnKind = ColumnKind.Value
+
+    override fun distinct(): ValueColumn<T>
+
+    override fun get(indices: Iterable<Int>): ValueColumn<T>
+
+    override fun rename(newName: String): ValueColumn<T>
+
+    override operator fun getValue(thisRef: Any?, property: KProperty<*>): ValueColumn<T> = super.getValue(thisRef, property) as ValueColumn<T>
+
+    public override operator fun get(range: IntRange): ValueColumn<T>
+}
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
new file mode 100644
index 000000000..65c7b5a1f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/dataTypes/IFRAME.kt
@@ -0,0 +1,16 @@
+package org.jetbrains.kotlinx.dataframe.dataTypes
+
+import java.net.URL
+
+public data class IFRAME(
+    val src: String,
+    val border: Boolean = false,
+    val width: Int? = null,
+    val height: Int? = null
+) {
+    public constructor(src: URL, border: Boolean = false, width: Int? = null, height: Int? = null) : this(src.toString(), border, width, height)
+
+    override fun toString(): String {
+        return """<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/dataTypes/IMG.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/dataTypes/IMG.kt
new file mode 100644
index 000000000..df91eb4d0
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/dataTypes/IMG.kt
@@ -0,0 +1,22 @@
+package org.jetbrains.kotlinx.dataframe.dataTypes
+
+import java.net.URL
+
+public data class IMG(
+    val src: String,
+    val width: Int? = null,
+    val height: Int? = null,
+    val maxWidth: Int? = null,
+    val maxHeight: Int? = null
+) {
+    public constructor(src: URL, width: Int? = null, height: Int? = null, maxWidth: Int? = null, maxHeight: Int? = null) : this(src.toString(), width, height, maxWidth, maxHeight)
+
+    override fun toString(): String {
+        val style = StringBuilder()
+        if (width != null) style.append("width:${width}px;")
+        if (height != null) style.append("height:${height}px;")
+        if (maxWidth != null) style.append("max-width:${maxWidth}px;")
+        if (maxHeight != null) style.append("max-height:${maxHeight}px;")
+        return """<img src="$src" style="$style"}/>"""
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
new file mode 100644
index 000000000..c3ab1880c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
@@ -0,0 +1,135 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.documentation.samples.ApiLevels as ApiLevelsSample
+
+/**
+ * By nature data frames are dynamic objects, column labels depend on the input source and also new columns could be added
+ * or deleted while wrangling. Kotlin, in contrast, is a statically typed language and all types are defined and verified
+ * ahead of execution. That's why creating a flexible, handy, and, at the same time, safe API to a data frame is tricky.
+ * 
+ * In `Kotlin DataFrame` we provide four different ways to access columns, and, while they are essentially different, they
+ * look pretty similar in the data wrangling DSL. These include:
+ *  - [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi]
+ *  - [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+ *  - [Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]
+ *  - [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]
+ * 
+ * For more information: [See Access APIs on the documentation website.](https://kotlin.github.io/dataframe/apilevels.html)
+ */
+internal interface AccessApi {
+
+    /**
+     * API:
+     * - [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi]
+     * - [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
+     * - [Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]
+     * - [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]
+     */
+    interface AnyApiLinks
+
+    /**
+     * String API.
+     * In this [AccessApi], columns are accessed by a [String] representing their name.
+     * Type-checking is done at runtime, name-checking too.
+     * 
+     * For more information: [See String API on the documentation website.](https://kotlin.github.io/dataframe/stringapi.html)
+     * 
+     * For example:
+     * ```kotlin
+     * DataFrame.read("titanic.csv")
+     *     .add("lastName") { "name"<String>().split(",").last() }
+     *     .dropNulls("age")
+     *     .filter {
+     *         "survived"<Boolean>() &&
+     *             "home"<String>().endsWith("NY") &&
+     *             "age"<Int>() in 10..20
+     *     }
+     * ```
+     */
+    interface StringApi
+
+    /** [String API][StringApi] */
+    interface StringApiLink
+
+    /**
+     * Column Accessors API.
+     * In this [AccessApi], every column has a descriptor;
+     * a variable that represents its name and type.
+     * 
+     * For more information: [See Column Accessors API on the documentation website.](https://kotlin.github.io/dataframe/columnaccessorsapi.html)
+     * 
+     * For example:
+     * ```kotlin
+     * val survived by column<Boolean>()
+     * val home by column<String>()
+     * val age by column<Int?>()
+     * val name by column<String>()
+     * val lastName by column<String>()
+     * 
+     * DataFrame.read("titanic.csv")
+     *     .add(lastName) { name().split(",").last() }
+     *     .dropNulls { age }
+     *     .filter { survived() && home().endsWith("NY") && age()!! in 10..20 }
+     * ```
+     */
+    interface ColumnAccessorsApi
+
+    /** [Column Accessors API][AccessApi.ColumnAccessorsApi] */
+    interface ColumnAccessorsApiLink
+
+    /**
+     * KProperties API.
+     * In this [AccessApi], columns accessed by the
+     * [`KProperty`](https://kotlinlang.org/docs/reflection.html#property-references)
+     * of some class.
+     * The name and type of column should match the name and type of property, respectively.
+     * 
+     * For more information: [See KProperties API on the documentation website.](https://kotlin.github.io/dataframe/kpropertiesapi.html)
+     * 
+     * For example:
+     * ```kotlin
+     * data class Passenger(
+     *     val survived: Boolean,
+     *     val home: String,
+     *     val age: Int,
+     *     val lastName: String
+     * )
+     * 
+     * val passengers = DataFrame.read("titanic.csv")
+     *     .add(Passenger::lastName) { "name"<String>().split(",").last() }
+     *     .dropNulls(Passenger::age)
+     *     .filter {
+     *         it[Passenger::survived] &&
+     *             it[Passenger::home].endsWith("NY") &&
+     *             it[Passenger::age] in 10..20
+     *     }
+     *     .toListOf<Passenger>()
+     * ```
+     */
+    interface KPropertiesApi
+
+    /** [KProperties API][KPropertiesApi] */
+    interface KPropertiesApiLink
+
+    /**
+     * Extension Properties API.
+     * In this [AccessApi], extension access properties are generated based on the dataframe schema.
+     * The name and type of properties are inferred from the name and type of the corresponding columns.
+     * 
+     * For more information: [See Extension Properties API on the documentation website.](https://kotlin.github.io/dataframe/extensionpropertiesapi.html)
+     * 
+     * For example:
+     * ```kotlin
+     * fun extensionProperties1() {
+     *      val df = DataFrame.read("titanic.csv")
+     *  }
+     * ```
+     */
+    interface ExtensionPropertiesApi
+
+    /** [Extension Properties API][ExtensionPropertiesApi] */
+    interface ExtensionPropertiesApiLink
+}
+
+/** [Access Api][AccessApi] */
+internal interface AccessApiLink
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
new file mode 100644
index 000000000..2508e858a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
@@ -0,0 +1,53 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+private interface DocumentationUrls {
+
+    interface NameArg
+
+    /** See {@includeArg [NameArg]} on the documentation website. */
+    interface Text
+
+    /** https://kotlin.github.io/dataframe */
+    interface Url
+
+    interface DataRow {
+
+        /** [See Row Expressions on the documentation website.](https://kotlin.github.io/dataframe/datarow.html#row-expressions) */
+        interface RowExpressions
+
+        /** [See Row Conditions on the documentation website.](https://kotlin.github.io/dataframe/datarow.html#row-conditions) */
+        interface RowConditions
+    }
+
+    /** [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) */
+    interface Update
+
+    /** [See `fill` on the documentation website.](https://kotlin.github.io/dataframe/fill.html) */
+    interface Fill {
+
+        /** [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls) */
+        interface FillNulls
+
+        /** [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans) */
+        interface FillNaNs
+
+        /** [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna) */
+        interface FillNA
+    }
+
+    /** [See Access APIs on the documentation website.](https://kotlin.github.io/dataframe/apilevels.html) */
+    interface AccessApis {
+
+        /** [See String API on the documentation website.](https://kotlin.github.io/dataframe/stringapi.html) */
+        interface StringApi
+
+        /** [See Column Accessors API on the documentation website.](https://kotlin.github.io/dataframe/columnaccessorsapi.html) */
+        interface ColumnAccessorsApi
+
+        /** [See KProperties API on the documentation website.](https://kotlin.github.io/dataframe/kpropertiesapi.html) */
+        interface KPropertiesApi
+
+        /** [See Extension Properties API on the documentation website.](https://kotlin.github.io/dataframe/extensionpropertiesapi.html) */
+        interface ExtensionPropertiesApi
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt
new file mode 100644
index 000000000..eaef2bb9e
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt
@@ -0,0 +1,61 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.ColumnExpression as DfColumnExpression
+import org.jetbrains.kotlinx.dataframe.RowColumnExpression as DfRowColumnExpression
+
+/**
+ * ## Expressions Given Column
+ *
+ * TODO
+ */
+internal interface ExpressionsGivenColumn {
+
+    /**
+     * The key for an @arg that will define the operation name for the examples below.
+     * Make sure to [alias][your examples].
+     */
+    interface OperationArg
+
+    
+    interface SetDefaultOperationArg
+
+    /** Provide a new value for every selected cell given its column using a [column expression][DfColumnExpression]. */
+    interface ColumnExpression {
+
+        /**
+         * Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
+         * 
+         * For example:
+         * 
+         * `df.`operation` { `[mean][DataColumn.mean]`(skipNA = true) }`
+         * 
+         * `df.`operation` { `[count][DataColumn.count]` { it > 10 } }`
+         */
+        interface WithExample
+    }
+
+    /** [Column Expression][ColumnExpression] */
+    interface ColumnExpressionLink
+
+    /** Provide a new value for every selected cell given both its row and column using a [row-column expression][DfRowColumnExpression]. */
+    interface RowColumnExpression {
+
+        /**
+         * Provide a new value for every selected cell given both its row and column using a [row-column expression][org.jetbrains.kotlinx.dataframe.RowColumnExpression].
+         * 
+         * For example:
+         * 
+         * `df.`operation` { row, col ->`
+         * 
+         * `row.age / col.`[mean][DataColumn.mean]`(skipNA = true)`
+         * 
+         * `}`
+         */
+        interface WithExample
+    }
+
+    /** [Row Column Expression][RowColumnExpression] */
+    interface RowColumnExpressionLink
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenDataFrame.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenDataFrame.kt
new file mode 100644
index 000000000..09d9d12d5
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenDataFrame.kt
@@ -0,0 +1,32 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.DataFrameExpressionLink
+import org.jetbrains.kotlinx.dataframe.DataFrameExpression as DfDataFrameExpression
+
+/**
+ * ## Expressions Given DataFrame
+ * Expressing values using a "Data Frame Expression" can occur exclusively in a
+ * [Data Frame Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.DataFrameExpression].
+ */
+internal interface ExpressionsGivenDataFrame {
+
+    interface OperationArg
+
+    /** Provide a new value for every selected data frame using a [dataframe expression][DfDataFrameExpression]. */
+    interface DataFrameExpression {
+
+        /**
+         * Provide a new value for every selected data frame using a [dataframe expression][org.jetbrains.kotlinx.dataframe.DataFrameExpression].
+         * 
+         * For example:
+         * 
+         * {@includeArg [OperationArg]}` { `[select][DataFrame.select]` { lastName } }`
+         */
+        interface WithExample
+    }
+
+    /** [Data Frame Expression][DataFrameExpression] */
+    interface DataFrameExpressionLink
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
new file mode 100644
index 000000000..b196ca35c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
@@ -0,0 +1,109 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.AddDataRowNote
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowExpressionLink
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpressionLink
+import org.jetbrains.kotlinx.dataframe.RowExpression as DfRowExpression
+import org.jetbrains.kotlinx.dataframe.RowValueExpression as DfRowValueExpression
+
+/**
+ * ## Expressions Given Row
+ * Expressing values using a "Row Expression" ([See Row Expressions on the documentation website.](https://kotlin.github.io/dataframe/datarow.html#row-expressions))
+ * can occur in the following two types of operations:
+ * 
+ * - Providing a new value for every selected cell given the row of that cell ([Row Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowExpression.WithExample]),
+ * for instance in [map][DataFrame.map], [add][DataFrame.add], and [insert][DataFrame.insert]
+ * (using [RowExpression][DfRowExpression]).
+ * 
+ * - Providing a new value for every selected cell given the row of that cell and its previous value ([Row Value Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]),
+ * for instance in [update.with][Update.with], and [convert.notNull][Convert.notNull]
+ * (using [RowValueExpression][DfRowValueExpression]).
+ * 
+ * Note:
+ * 
+ * [update with][org.jetbrains.kotlinx.dataframe.api.Update.with]- and [add][org.jetbrains.kotlinx.dataframe.api.add]-like expressions use [AddDataRow][org.jetbrains.kotlinx.dataframe.api.AddDataRow] instead of [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as the DSL's receiver type.
+ * This is an extension to [RowValueExpression][org.jetbrains.kotlinx.dataframe.RowValueExpression] and
+ * [RowExpression][org.jetbrains.kotlinx.dataframe.RowExpression] that provides access to
+ * the modified/generated value of the preceding row ([AddDataRow.newValue][org.jetbrains.kotlinx.dataframe.api.AddDataRow.newValue]).
+ * 
+ * A Row Expression is similar to a [Row Condition][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows] but that expects a [Boolean] as result.
+ */
+internal interface ExpressionsGivenRow {
+
+    /**
+     * The key for an @arg that will define the operation name for the examples below.
+     * Make sure to [alias][your examples].
+     */
+    interface OperationArg
+
+    
+    interface SetDefaultOperationArg
+
+    /**
+     * [update with][org.jetbrains.kotlinx.dataframe.api.Update.with]- and [add][org.jetbrains.kotlinx.dataframe.api.add]-like expressions use [AddDataRow] instead of [DataRow] as the DSL's receiver type.
+     * This is an extension to [RowValueExpression][DfRowValueExpression] and
+     * [RowExpression][DfRowExpression] that provides access to
+     * the modified/generated value of the preceding row ([AddDataRow.newValue]).
+     */
+    interface AddDataRowNote
+
+    /** Provide a new value for every selected cell given its row using a [row expression][DfRowExpression]. */
+    interface RowExpression {
+
+        /**
+         * Provide a new value for every selected cell given its row using a [row expression][org.jetbrains.kotlinx.dataframe.RowExpression].
+         * 
+         * For example:
+         * 
+         * `df.`operation` { name.firstName + " " + name.lastName }`
+         * 
+         * `df.`operation` { 2021 - age }`
+         */
+        interface WithExample
+    }
+
+    /** [Row Expression][RowExpression.WithExample] */
+    interface RowExpressionLink
+
+    /** Provide a new value for every selected cell given its row and its previous value using a
+     * [row value expression][DfRowValueExpression].
+     */
+    interface RowValueExpression {
+
+        /**
+         * Provide a new value for every selected cell given its row and its previous value using a
+         * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
+         * 
+         * For example:
+         * 
+         * `df.`operation` { name.firstName + " from " + it }`
+         * 
+         * `df.`operation` { it.uppercase() }`
+         */
+        interface WithExample
+    }
+
+    /** [Row Value Expression][RowValueExpression.WithExample] */
+    interface RowValueExpressionLink
+
+//    @Deprecated(
+//        "This is located in another file",
+//        ReplaceWith("ExpressionsGivenColumn.RowColumnExpression"),
+//        DeprecationLevel.ERROR,
+//    )
+//    interface RowColumnExpression {
+//
+//        @Deprecated(
+//            "This is located in another file",
+//            ReplaceWith("ExpressionsGivenColumn.RowColumnExpression.WithExample"),
+//            DeprecationLevel.ERROR,
+//        )
+//        interface WithExample
+//    }
+}
+
+/** [Row Expression][ExpressionsGivenRow] */
+internal interface RowExpressionsLink
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
new file mode 100644
index 000000000..7e26fea86
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
@@ -0,0 +1,169 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.columns.*
+import kotlin.reflect.KProperty
+
+/** {@comment
+ * In this file we provide documentation for high-level operations such as
+ * the operation of selecting columns.
+ * }
+ */
+
+/** [Selecting Columns][SelectingColumns] */
+internal interface SelectingColumnsLink
+
+/**
+ * ## Selecting Columns
+ * Selecting columns for various operations (including but not limited to
+ * [DataFrame.select], [DataFrame.update], [DataFrame.gather], and [DataFrame.fillNulls])
+ * can be done in the following ways:
+ * - Select or express columns using the Column(s) Selection DSL.
+ * (Any [Access Api][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ * 
+ * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
+ * 
+ * For example:
+ * 
+ * `df.`operation` { length `[and][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.and]` age }`
+ * 
+ * `df.`operation` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ * 
+ * `df.`operation` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<Double>() }`
+ * 
+ * - Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ * 
+ * For example:
+ * 
+ * `df.`operation`("length", "age")`
+ * 
+ * - Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ * 
+ * For example:
+ * 
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
+ * 
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
+ * 
+ * `df.`operation`(length, age)`
+ * 
+ * - Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ * 
+ * For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ * 
+ * `df.`operation`(Person::length, Person::age)`
+ */
+internal interface SelectingColumns {
+
+    /**
+     * The key for an @arg that will define the operation name for the examples below.
+     * Make sure to [alias][your examples].
+     */
+    interface OperationArg
+
+    
+    interface SetDefaultOperationArg
+
+    /**
+     * Select or express columns using the Column(s) Selection DSL.
+     * (Any [Access Api][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     * 
+     * This DSL comes in the form of either a [Column Selector][ColumnSelector]- or [Columns Selector][ColumnsSelector] lambda,
+     * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+     * expect you to return a [SingleColumn] or [ColumnSet], respectively.
+     */
+    interface Dsl {
+
+        /**
+         * Select or express columns using the Column(s) Selection DSL.
+         * (Any [Access Api][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+         * 
+         * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+         * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+         * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
+         * 
+         * For example:
+         * 
+         * `df.`operation` { length `[and][ColumnsSelectionDsl.and]` age }`
+         * 
+         * `df.`operation` { `[cols][ColumnsSelectionDsl.cols]`(1..5) }`
+         * 
+         * `df.`operation` { `[colsOf][colsOf]`<Double>() }`
+         */
+        interface WithExample
+    }
+
+    /** [Columns selector DSL][Dsl.WithExample] */
+    interface DslLink
+
+    /**
+     * Select columns using their [column names][String]
+     * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+     */
+    interface ColumnNames {
+
+        /**
+         * Select columns using their [column names][String]
+         * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+         * 
+         * For example:
+         * 
+         * `df.`operation`("length", "age")`
+         */
+        interface WithExample
+    }
+
+    /** [Column names][ColumnNames.WithExample] */
+    interface ColumnNamesLink
+
+    /**
+     * Select columns using [column accessors][ColumnReference]
+     * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+     */
+    interface ColumnAccessors {
+
+        /**
+         * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+         * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+         * 
+         * For example:
+         * 
+         * `val length by `[column]`<Double>()`
+         * 
+         * `val age by `[column]`<Double>()`
+         * 
+         * `df.`operation`(length, age)`
+         */
+        interface WithExample
+    }
+
+    /** [Column references][ColumnAccessors.WithExample] */
+    interface ColumnAccessorsLink
+
+    /** Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]). */
+    interface KProperties {
+
+        /**
+         * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+         * 
+         * For example:
+         * ```kotlin
+         * data class Person(val length: Double, val age: Double)
+         * ```
+         * 
+         * `df.`operation`(Person::length, Person::age)`
+         */
+        interface WithExample
+    }
+
+    /** [KProperties][KProperties.WithExample] */
+    interface KPropertiesLink
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
new file mode 100644
index 000000000..6a976ee34
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
@@ -0,0 +1,76 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.api.*
+
+/**
+ * ## Selecting Rows
+ * Selecting rows that satisfy a "Row Condition" ([See Row Conditions on the documentation website.](https://kotlin.github.io/dataframe/datarow.html#row-conditions))
+ * can occur in the following two types of operations:
+ * - Selecting entire rows ([Entire-Row Condition][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows.EntireRowCondition.WithExample]), for instance in [filter], [drop], [first], and [count]
+ * (using [RowFilter]).
+ * - Selecting parts of rows using a `where` operation after selecting columns ([Row-Value Condition][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows.RowValueCondition.WithExample]),
+ * such as with [update], [gather], and [format]
+ * (using [RowValueFilter]).
+ * 
+ * A Row Condition is similar to a [Row Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow] but expects a [Boolean] as result.
+ */
+internal interface SelectingRows {
+
+    /**
+     * The key for an @arg that will define the operation name for the examples below.
+     * Make sure to [alias][your examples].
+     */
+    interface FirstOperationArg
+
+    /**
+     * The key for an @arg that will define the operation name for the examples below.
+     * Make sure to [alias][your examples].
+     */
+    interface SecondOperationArg
+
+    
+    interface SetDefaultOperationArg
+
+    /** [Entire-Row Condition][EntireRowCondition.WithExample] */
+    interface RowConditionLink
+
+    /** Filter or find rows to operate on using a [row filter][RowFilter]. */
+    interface EntireRowCondition {
+
+        /**
+         * Filter or find rows to operate on using a [row filter][org.jetbrains.kotlinx.dataframe.RowFilter].
+         * 
+         * For example:
+         * 
+         * `df.`operation` { `[index][index]`() % 2 == 0 }`
+         * 
+         * `df.`operation` { `[diff][diff]` { age } == 0 }`
+         */
+        interface WithExample
+    }
+
+    /** [Row-Value Condition][RowValueCondition.WithExample] */
+    interface RowValueConditionLink
+
+    /** Filter or find rows to operate on after [selecting columns][SelectingColumns] using a
+     * [row value filter][RowValueFilter].
+     */
+    interface RowValueCondition {
+
+        /**
+         * Filter or find rows to operate on after [selecting columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] using a
+         * [row value filter][org.jetbrains.kotlinx.dataframe.RowValueFilter].
+         * 
+         * For example:
+         * 
+         * `df.`operation` { length }.`where` { it > 10.0 }`
+         * 
+         * `df.`operation` { `[cols][ColumnsSelectionDsl.cols]`(1..5) }.`where` { `[index][index]`() > 4 && city != "Paris" }`
+         */
+        interface WithExample
+    }
+}
+
+/** [Row Condition][SelectingRows] */
+internal interface RowConditionLink
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/samples/ApiLevels.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/samples/ApiLevels.kt
new file mode 100644
index 000000000..81c553b0c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/samples/ApiLevels.kt
@@ -0,0 +1,146 @@
+@file:Suppress("RemoveExplicitTypeArguments")
+
+package org.jetbrains.kotlinx.dataframe.documentation.samples
+
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.ColumnName
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.dropNulls
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.toListOf
+import org.jetbrains.kotlinx.dataframe.io.read
+
+internal interface ApiLevels {
+
+    fun strings() {
+        // SampleStart
+        DataFrame.read("titanic.csv")
+            .add("lastName") { "name"<String>().split(",").last() }
+            .dropNulls("age")
+            .filter {
+                "survived"<Boolean>() &&
+                    "home"<String>().endsWith("NY") &&
+                    "age"<Int>() in 10..20
+            }
+        // SampleEnd
+    }
+
+    fun accessors1() {
+        // SampleStart
+        val survived by column<Boolean>() // accessor for Boolean column with name 'survived'
+        val home by column<String>()
+        val age by column<Int?>()
+        val name by column<String>()
+        val lastName by column<String>()
+        // SampleEnd
+    }
+
+    fun accessors2() {
+        // SampleStart
+        val survived by column<Boolean>()
+        val home by column<String>()
+        val age by column<Int?>()
+        val name by column<String>()
+        val lastName by column<String>()
+
+        DataFrame.read("titanic.csv")
+            .add(lastName) { name().split(",").last() }
+            .dropNulls { age }
+            .filter { survived() && home().endsWith("NY") && age()!! in 10..20 }
+        // SampleEnd
+    }
+
+    fun accessors3() {
+        // SampleStart
+        val survived by column<Boolean>()
+        val home by column<String>()
+        val age by column<Int?>()
+        val name by column<String>()
+        val lastName by column<String>()
+
+        DataFrame.read("titanic.csv")
+            .add(lastName) { name().split(",").last() }
+            .dropNulls { age }
+            .filter { survived() && home().endsWith("NY") && age()!! in 10..20 }
+        // SampleEnd
+    }
+
+    fun kproperties1() {
+        // SampleStart
+        data class Passenger(
+            val survived: Boolean,
+            val home: String,
+            val age: Int,
+            val lastName: String
+        )
+
+        val passengers = DataFrame.read("titanic.csv")
+            .add(Passenger::lastName) { "name"<String>().split(",").last() }
+            .dropNulls(Passenger::age)
+            .filter {
+                it[Passenger::survived] &&
+                    it[Passenger::home].endsWith("NY") &&
+                    it[Passenger::age] in 10..20
+            }
+            .toListOf<Passenger>()
+        // SampleEnd
+    }
+
+    fun kproperties2() {
+        // SampleStart
+        data class Passenger(
+            @ColumnName("survived") val isAlive: Boolean,
+            @ColumnName("home") val city: String,
+            val name: String
+        )
+
+        val passengers = DataFrame.read("titanic.csv")
+            .filter { it.get(Passenger::city).endsWith("NY") }
+            .toListOf<Passenger>()
+        // SampleEnd
+    }
+
+    //    @DataSchema
+    interface TitanicPassenger {
+        val survived: Boolean
+        val home: String
+        val age: Int
+        val name: String
+    }
+
+    fun extensionProperties2() {
+        // SampleStart
+        val df = DataFrame.read("titanic.csv").cast<TitanicPassenger>()
+
+        df.add("lastName") { name.split(",").last() }
+            .dropNulls { age }
+            .filter { survived && home.endsWith("NY") && age in 10..20 }
+        // SampleEnd
+    }
+
+    fun extensionProperties1() {
+        val df = DataFrame.read("titanic.csv")
+    }
+}
+
+internal val ColumnsContainer<ApiLevels.TitanicPassenger>.age: DataColumn<Int> @JvmName("TitanicPassenger_age") get() = this["age"] as DataColumn<Int>
+internal val DataRow<ApiLevels.TitanicPassenger>.age: Int @JvmName("TitanicPassenger_age") get() = this["age"] as Int
+internal val ColumnsContainer<ApiLevels.TitanicPassenger?>.age: DataColumn<Int?> @JvmName("NullableTitanicPassenger_age") get() = this["age"] as DataColumn<Int?>
+internal val DataRow<ApiLevels.TitanicPassenger?>.age: Int? @JvmName("NullableTitanicPassenger_age") get() = this["age"] as Int?
+internal val ColumnsContainer<ApiLevels.TitanicPassenger>.home: DataColumn<String> @JvmName("TitanicPassenger_home") get() = this["home"] as DataColumn<String>
+internal val DataRow<ApiLevels.TitanicPassenger>.home: String @JvmName("TitanicPassenger_home") get() = this["home"] as String
+internal val ColumnsContainer<ApiLevels.TitanicPassenger?>.home: DataColumn<String?> @JvmName("NullableTitanicPassenger_home") get() = this["home"] as DataColumn<String?>
+internal val DataRow<ApiLevels.TitanicPassenger?>.home: String? @JvmName("NullableTitanicPassenger_home") get() = this["home"] as String?
+internal val ColumnsContainer<ApiLevels.TitanicPassenger>.name: DataColumn<String> @JvmName("TitanicPassenger_name") get() = this["name"] as DataColumn<String>
+internal val DataRow<ApiLevels.TitanicPassenger>.name: String @JvmName("TitanicPassenger_name") get() = this["name"] as String
+internal val ColumnsContainer<ApiLevels.TitanicPassenger?>.name: DataColumn<String?> @JvmName("NullableTitanicPassenger_name") get() = this["name"] as DataColumn<String?>
+internal val DataRow<ApiLevels.TitanicPassenger?>.name: String? @JvmName("NullableTitanicPassenger_name") get() = this["name"] as String?
+internal val ColumnsContainer<ApiLevels.TitanicPassenger>.survived: DataColumn<Boolean> @JvmName("TitanicPassenger_survived") get() = this["survived"] as DataColumn<Boolean>
+internal val DataRow<ApiLevels.TitanicPassenger>.survived: Boolean @JvmName("TitanicPassenger_survived") get() = this["survived"] as Boolean
+internal val ColumnsContainer<ApiLevels.TitanicPassenger?>.survived: DataColumn<Boolean?> @JvmName("NullableTitanicPassenger_survived") get() = this["survived"] as DataColumn<Boolean?>
+internal val DataRow<ApiLevels.TitanicPassenger?>.survived: Boolean? @JvmName("NullableTitanicPassenger_survived") get() = this["survived"] as Boolean?
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/utils.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/utils.kt
new file mode 100644
index 000000000..3660dd539
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/utils.kt
@@ -0,0 +1,4 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+/** ## ‎ */
+internal interface LineBreak
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/CellConversionException.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/CellConversionException.kt
new file mode 100644
index 000000000..900ab5f20
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/CellConversionException.kt
@@ -0,0 +1,16 @@
+package org.jetbrains.kotlinx.dataframe.exceptions
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import kotlin.reflect.KType
+
+public class CellConversionException(
+    value: Any?,
+    from: KType,
+    to: KType,
+    column: ColumnPath,
+    public val row: Int?,
+    override val cause: Throwable?
+) : TypeConversionException(value, from, to, column) {
+    override val message: String
+        get() = "${super.message} in column $column, row $row"
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/ColumnNotFoundException.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/ColumnNotFoundException.kt
new file mode 100644
index 000000000..9a192188b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/ColumnNotFoundException.kt
@@ -0,0 +1,3 @@
+package org.jetbrains.kotlinx.dataframe.exceptions
+
+public class ColumnNotFoundException(public val columnName: String, public override val message: String) : RuntimeException()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/DuplicateColumnNamesException.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/DuplicateColumnNamesException.kt
new file mode 100644
index 000000000..4bc6d442a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/DuplicateColumnNamesException.kt
@@ -0,0 +1,9 @@
+package org.jetbrains.kotlinx.dataframe.exceptions
+
+public class DuplicateColumnNamesException(public val allColumnNames: List<String>) : IllegalArgumentException() {
+
+    public val duplicatedNames: List<String> = allColumnNames.groupBy { it }.filter { it.key != "" && it.value.size > 1 }.map { it.key }
+
+    override val message: String
+        get() = "Duplicate column names: $duplicatedNames\nAll column names: $allColumnNames"
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/ExcessiveColumnsException.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/ExcessiveColumnsException.kt
new file mode 100644
index 000000000..ae5f6f449
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/ExcessiveColumnsException.kt
@@ -0,0 +1,7 @@
+package org.jetbrains.kotlinx.dataframe.exceptions
+
+public class ExcessiveColumnsException(public val columns: List<String>) : RuntimeException() {
+
+    override val message: String
+        get() = "Excess columns in DataFrame: $columns"
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/TypeConversionException.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/TypeConversionException.kt
new file mode 100644
index 000000000..e307dcc64
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/TypeConversionException.kt
@@ -0,0 +1,16 @@
+package org.jetbrains.kotlinx.dataframe.exceptions
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import kotlin.reflect.*
+import kotlin.reflect.KType
+
+public open class TypeConversionException(
+    public val value: Any?,
+    public val from: KType,
+    public val to: KType,
+    public val column: ColumnPath?
+) : RuntimeException() {
+
+    override val message: String
+        get() = "Failed to convert '$value' from $from to $to" + (column?.let { " in column ${it.joinToString()}" } ?: "")
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/TypeConverterNotFoundException.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/TypeConverterNotFoundException.kt
new file mode 100644
index 000000000..d73310900
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/TypeConverterNotFoundException.kt
@@ -0,0 +1,15 @@
+package org.jetbrains.kotlinx.dataframe.exceptions
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import kotlin.reflect.*
+import kotlin.reflect.KType
+
+public class TypeConverterNotFoundException(
+    public val from: KType,
+    public val to: KType,
+    public val column: ColumnPath?
+) : IllegalArgumentException() {
+
+    override val message: String
+        get() = "Type converter from $from to $to is not found" + (column?.let { " for column ${it.joinToString()}" } ?: "")
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/UnequalColumnSizesException.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/UnequalColumnSizesException.kt
new file mode 100644
index 000000000..078c20dbc
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/exceptions/UnequalColumnSizesException.kt
@@ -0,0 +1,10 @@
+package org.jetbrains.kotlinx.dataframe.exceptions
+
+public class UnequalColumnSizesException(
+    public val expectedRowsCount: Int,
+    public val columnSizes: List<Pair<String, Int>>
+) : IllegalArgumentException() {
+
+    override val message: String
+        get() = "Unequal column sizes. Expected rows count: $expectedRowsCount. Actual column sizes:\n${columnSizes.joinToString("\n") { it.first + ": " + it.second }}"
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Cache.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Cache.kt
new file mode 100644
index 000000000..b4fd8246a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Cache.kt
@@ -0,0 +1,8 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import kotlin.reflect.KType
+
+private val listTypes = mutableMapOf<KType, KType>()
+
+@PublishedApi
+internal fun getListType(valueType: KType): KType = listTypes.getOrPut(valueType) { List::class.createTypeWithArgument(valueType) }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ColumnAccessTracker.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ColumnAccessTracker.kt
new file mode 100644
index 000000000..b2d79256f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ColumnAccessTracker.kt
@@ -0,0 +1,33 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import kotlin.concurrent.getOrSet
+
+internal class ColumnAccessTracker {
+
+    var isEnabled = false
+
+    val accessedColumns = mutableSetOf<String>()
+
+    fun <T> track(body: () -> T): List<String> {
+        accessedColumns.clear()
+        isEnabled = true
+        body()
+        isEnabled = false
+        return accessedColumns.toList()
+    }
+
+    fun registerAccess(columnName: String) {
+        if (isEnabled) accessedColumns.add(columnName)
+    }
+
+    companion object {
+
+        fun registerColumnAccess(name: String) = get().registerAccess(name)
+
+        fun get() = columnAccessTracker.getOrSet { ColumnAccessTracker() }
+    }
+}
+
+internal val columnAccessTracker = ThreadLocal<ColumnAccessTracker>()
+
+public fun trackColumnAccess(body: () -> Unit): List<String> = ColumnAccessTracker.get().track(body)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ColumnDataCollector.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ColumnDataCollector.kt
new file mode 100644
index 000000000..da714ad7b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ColumnDataCollector.kt
@@ -0,0 +1,75 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.impl.columns.guessColumnType
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+import kotlin.reflect.full.isSubclassOf
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.jvm.jvmErasure
+
+internal interface DataCollector<T> {
+
+    public fun add(value: T)
+    public val data: List<T?>
+    public val hasNulls: Boolean
+    public fun toColumn(name: String): DataColumn<T>
+}
+
+internal abstract class DataCollectorBase<T>(initCapacity: Int) : DataCollector<T> {
+
+    override var hasNulls = false
+
+    override val data = ArrayList<T?>(initCapacity)
+
+    val values: List<T?>
+        get() = data
+
+    override fun add(value: T) {
+        if (value == null) hasNulls = true
+        data.add(value)
+    }
+
+    protected fun createColumn(name: String, type: KType): DataColumn<T> {
+        val classifier = type.classifier as KClass<*>
+        if (classifier.isSubclassOf(DataFrame::class) && !hasNulls) {
+            return DataColumn.createFrameColumn(name, data as List<AnyFrame>) as DataColumn<T>
+        }
+        if (classifier.isSubclassOf(DataRow::class) && !hasNulls) {
+            val mergedDf = (data as List<AnyRow>).map { it.toDataFrame() }.concat()
+            return DataColumn.createColumnGroup(name, mergedDf) as DataColumn<T>
+        }
+        return DataColumn.createValueColumn(name, data, type.withNullability(hasNulls)) as DataColumn<T>
+    }
+}
+
+internal open class ColumnDataCollector(initCapacity: Int = 0, val typeOf: (KClass<*>) -> KType) : DataCollectorBase<Any?>(initCapacity) {
+
+    override fun toColumn(name: String) = guessColumnType(name, values)
+}
+
+internal class TypedColumnDataCollector<T>(initCapacity: Int = 0, val type: KType, val checkTypes: Boolean = true) : DataCollectorBase<T?>(initCapacity) {
+
+    internal val kclass = type.jvmErasure
+
+    override fun add(value: T?) {
+        if (checkTypes && value != null && !value.javaClass.kotlin.isSubclassOf(kclass)) {
+            throw IllegalArgumentException("Can not add value of class ${value.javaClass.kotlin.qualifiedName} to column of type $type. Value = $value")
+        }
+        super.add(value)
+    }
+
+    override fun toColumn(name: String) = createColumn(name, type)
+}
+
+internal fun createDataCollector(initCapacity: Int = 0) = createDataCollector(initCapacity) { it.createStarProjectedType(false) }
+
+internal fun createDataCollector(initCapacity: Int = 0, typeOf: (KClass<*>) -> KType) = ColumnDataCollector(initCapacity, typeOf)
+
+internal fun <T> createDataCollector(initCapacity: Int = 0, type: KType) = TypedColumnDataCollector<T>(initCapacity, type)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ColumnNameGenerator.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ColumnNameGenerator.kt
new file mode 100644
index 000000000..c6549d26f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ColumnNameGenerator.kt
@@ -0,0 +1,37 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+
+internal class ColumnNameGenerator(columnNames: List<String> = emptyList()) {
+
+    private val usedNames = columnNames.toMutableSet()
+
+    private val colNames = columnNames.toMutableList()
+
+    fun addUnique(preferredName: String): String {
+        var name = preferredName
+        var k = 1
+        while (usedNames.contains(name)) {
+            name = "${preferredName}${k++}"
+        }
+        usedNames.add(name)
+        colNames.add(name)
+        return name
+    }
+
+    fun addIfAbsent(name: String) {
+        if (!usedNames.contains(name)) {
+            usedNames.add(name)
+            colNames.add(name)
+        }
+    }
+
+    val names: List<String>
+        get() = colNames
+
+    fun contains(name: String) = usedNames.contains(name)
+}
+
+internal fun AnyFrame.nameGenerator() = ColumnNameGenerator(columnNames())
+
+internal fun nameGenerator(vararg usedNames: String) = ColumnNameGenerator(usedNames.asList())
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
new file mode 100644
index 000000000..2a3babe7f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameImpl.kt
@@ -0,0 +1,149 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedBody
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.asDataColumn
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.api.indices
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.exceptions.DuplicateColumnNamesException
+import org.jetbrains.kotlinx.dataframe.exceptions.UnequalColumnSizesException
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.AggregatableInternal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.GroupByReceiverImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.resolveSingle
+import org.jetbrains.kotlinx.dataframe.io.renderToString
+
+private const val unnamedColumnPrefix = "untitled"
+
+internal open class DataFrameImpl<T>(cols: List<AnyCol>, val nrow: Int) : DataFrame<T>, AggregatableInternal<T> {
+
+    private val columnsMap: Map<String, Int>
+
+    protected val columns: List<AnyCol>
+
+    init {
+        columnsMap = mutableMapOf()
+
+        // check that column sizes are equal
+        if (cols.any { it.size != nrow }) {
+            throw UnequalColumnSizesException(nrow, cols.map { it.name to it.size })
+        }
+
+        // check that column names are unique
+        var hasUnnamedColumns = false
+        cols.forEachIndexed { i, col ->
+            val name = col.name
+            if (name.isEmpty()) hasUnnamedColumns = true
+            else {
+                if (columnsMap.containsKey(name)) {
+                    throw DuplicateColumnNamesException(cols.map { it.name })
+                }
+                columnsMap[name] = i
+            }
+        }
+
+        // generate unique names for unnamed columns
+        if (hasUnnamedColumns) {
+            val nameGenerator = ColumnNameGenerator(cols.map { it.name })
+            columns = cols.mapIndexed { i, col ->
+                val name = col.name
+                if (name.isEmpty()) {
+                    val uniqueName = nameGenerator.addUnique(unnamedColumnPrefix)
+                    val renamed = col.rename(uniqueName)
+                    columnsMap[uniqueName] = i
+                    renamed
+                } else col
+            }
+        } else columns = cols
+    }
+
+    override fun rowsCount() = nrow
+
+    override fun getColumnIndex(name: String) = columnsMap[name] ?: -1
+
+    override fun equals(other: Any?): Boolean {
+        val df = other as? AnyFrame ?: return false
+        return columns == df.columns()
+    }
+
+    override fun hashCode() = columns.hashCode()
+
+    override fun toString() = renderToString()
+
+    override fun columns() = columns
+
+    override fun columnNames() = columns.map { it.name() }
+
+    override fun columnTypes() = columns.map { it.type() }
+
+    override fun columnsCount(): Int = columns.size
+
+    override operator fun get(index: Int): DataRow<T> {
+        if (index < 0 || index >= nrow) {
+            throw IndexOutOfBoundsException("index: $index, rowsCount: $nrow")
+        }
+        return DataRowImpl(index, this)
+    }
+
+    override fun remainingColumnsSelector(): ColumnsSelector<*, *> = { all() }
+
+    override fun <R> aggregate(body: AggregateGroupedBody<T, R>): DataRow<T> {
+        val receiver = GroupByReceiverImpl(this, false)
+        body(receiver, receiver)
+        val row = receiver.compute() ?: DataFrame.empty(1)[0]
+        return row.cast()
+    }
+
+    override fun getColumnOrNull(name: String): AnyCol? =
+        getColumnIndex(name).let { if (it != -1) getColumn(it) else null }
+
+    override fun getColumnOrNull(index: Int) = if (index >= 0 && index < columns.size) columns[index] else null
+
+    override fun <R> getColumnOrNull(column: ColumnSelector<T, R>): DataColumn<R>? = getColumnsImpl(
+        UnresolvedColumnsPolicy.Skip, column
+    ).singleOrNull()
+
+    override fun <R> getColumnOrNull(column: ColumnReference<R>): DataColumn<R>? = column.resolveSingle(this, UnresolvedColumnsPolicy.Skip)?.data
+
+    override fun getColumnOrNull(path: ColumnPath): AnyCol? =
+        when (path.size) {
+            0 -> asColumnGroup().asDataColumn()
+            1 -> getColumnOrNull(path[0])
+            else -> path.dropLast(1).fold(this as AnyFrame?) { df, name -> df?.getColumnOrNull(name) as? AnyFrame? }
+                ?.getColumnOrNull(path.last())
+        }
+
+    override fun containsColumn(name: String): Boolean = columnsMap.containsKey(name)
+
+    override fun containsColumn(path: ColumnPath): Boolean = getColumnOrNull(path) != null
+}
+
+internal fun <T, C> DataFrame<T>.valuesImpl(byRow: Boolean, columns: ColumnsSelector<T, C>): Sequence<C> {
+    val cols = get(columns)
+    return if (byRow) sequence {
+        indices().forEach { row ->
+            cols.forEach {
+                yield(it[row])
+            }
+        }
+    }
+    else sequence {
+        cols.forEach { col ->
+            col.values().forEach {
+                yield(it)
+            }
+        }
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameReceiver.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameReceiver.kt
new file mode 100644
index 000000000..3345f87fe
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameReceiver.kt
@@ -0,0 +1,73 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.asDataColumn
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnGroupWithParent
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnGroupWithPathImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.missing.MissingColumnGroup
+import org.jetbrains.kotlinx.dataframe.impl.columns.missing.MissingDataColumn
+import org.jetbrains.kotlinx.dataframe.nrow
+
+private fun <T> DataFrame<T>.unbox(): DataFrame<T> = when (this) {
+    is ColumnGroupWithParent -> source.unbox()
+    is ColumnGroupWithPathImpl -> column.unbox()
+    else -> this
+}
+
+internal abstract class DataFrameReceiverBase<T>(protected val df: DataFrame<T>) : DataFrameImpl<T>(df.columns(), df.nrow)
+
+internal open class DataFrameReceiver<T>(
+    source: DataFrame<T>,
+    private val unresolvedColumnsPolicy: UnresolvedColumnsPolicy
+) : DataFrameReceiverBase<T>(source.unbox()), SingleColumn<DataRow<T>> {
+
+    private fun <R> DataColumn<R>?.check(path: ColumnPath): DataColumn<R> =
+        when (this) {
+            null -> when (unresolvedColumnsPolicy) {
+                UnresolvedColumnsPolicy.Create, UnresolvedColumnsPolicy.Skip -> MissingColumnGroup<Any>(
+                    path,
+                    this@DataFrameReceiver
+                ).asDataColumn().cast()
+
+                UnresolvedColumnsPolicy.Fail -> error("Column $path not found")
+            }
+
+            is MissingDataColumn -> this
+            is ColumnGroup<*> -> ColumnGroupWithParent(null, this).asDataColumn().cast()
+            else -> this
+        }
+
+    override fun getColumnOrNull(name: String) = df.getColumnOrNull(name).check(pathOf(name))
+    override fun getColumnOrNull(index: Int) = df.getColumnOrNull(index).check(pathOf(""))
+
+    override fun <R> getColumnOrNull(column: ColumnReference<R>): DataColumn<R>? {
+        val context = ColumnResolutionContext(this, unresolvedColumnsPolicy)
+        return column.resolveSingle(context).check(column.path())
+    }
+
+    override fun getColumnOrNull(path: ColumnPath) = super.getColumnOrNull(path).check(path)
+    override fun <R> getColumnOrNull(column: ColumnSelector<T, R>) = getColumnsImpl(unresolvedColumnsPolicy, column).singleOrNull()
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<DataRow<T>>? = DataColumn.createColumnGroup("", df).addPath(emptyPath())
+
+    override fun columns() = df.columns().map { if (it.isColumnGroup()) ColumnGroupWithParent(null, it.asColumnGroup()) else it }
+
+    override fun columnNames() = df.columnNames()
+
+    override fun columnTypes() = df.columnTypes()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameSize.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameSize.kt
new file mode 100644
index 000000000..a51cc421e
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataFrameSize.kt
@@ -0,0 +1,5 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+public data class DataFrameSize(val ncol: Int, val nrow: Int) {
+    override fun toString(): String = "$nrow x $ncol"
+}
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
new file mode 100644
index 000000000..3d9e46a9a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/DataRowImpl.kt
@@ -0,0 +1,62 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.aggregation.NamedValue
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.shortPath
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.io.renderToString
+
+internal open class DataRowImpl<T>(private val index: Int, private val df: DataFrame<T>) : DataRow<T> {
+
+    override fun df() = df
+
+    override operator fun get(name: String): Any? {
+        ColumnAccessTracker.registerColumnAccess(name)
+        return df[name][index]
+    }
+
+    override operator fun <R> get(column: ColumnReference<R>): R {
+        ColumnAccessTracker.registerColumnAccess(column.name())
+        return column.getValue(this)
+    }
+
+    override fun <R> getValueOrNull(column: ColumnReference<R>): R? {
+        ColumnAccessTracker.registerColumnAccess(column.name())
+        return column.getValueOrNull(this)
+    }
+
+    override fun index() = index
+
+    private val values by lazy { df.columns().map { it[index] } }
+
+    override fun values() = values
+
+    override fun get(columnIndex: Int): Any? {
+        val column = df.getColumn(columnIndex)
+        ColumnAccessTracker.registerColumnAccess(column.name())
+        return column[index]
+    }
+
+    override fun toString() = renderToString()
+
+    override fun equals(other: Any?): Boolean {
+        val o = other as? DataRowImpl<*> ?: return false
+        return values.equals(o.values)
+    }
+
+    override fun hashCode() = values.hashCode()
+
+    override fun getOrNull(name: String): Any? {
+        ColumnAccessTracker.registerColumnAccess(name)
+        return df.getColumnOrNull(name)?.get(index)
+    }
+}
+
+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)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ExceptionUtils.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ExceptionUtils.kt
new file mode 100644
index 000000000..eca65f0dc
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/ExceptionUtils.kt
@@ -0,0 +1,6 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+internal fun <T> T?.throwIfNull(message: String): T = this ?: throw NoSuchElementException(message)
+
+@PublishedApi
+internal fun <T> T?.suggestIfNull(operation: String): T = throwIfNull("No elements for `$operation` operation. Use `${operation}OrNull` instead.")
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
new file mode 100644
index 000000000..bd2b0c105
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/GroupByImpl.kt
@@ -0,0 +1,102 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedBody
+import org.jetbrains.kotlinx.dataframe.aggregation.NamedValue
+import org.jetbrains.kotlinx.dataframe.api.GroupBy
+import org.jetbrains.kotlinx.dataframe.api.GroupedRowFilter
+import org.jetbrains.kotlinx.dataframe.api.asGroupBy
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.minus
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.api.rename
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.AggregatableInternal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.GroupByReceiverImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.AggregatedPivot
+import org.jetbrains.kotlinx.dataframe.impl.api.ColumnToInsert
+import org.jetbrains.kotlinx.dataframe.impl.api.GroupedDataRowImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.insertImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.removeImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.values
+
+internal class GroupByImpl<T, G>(
+    val df: DataFrame<T>,
+    override val groups: FrameColumn<G>,
+    internal val keyColumnsInGroups: ColumnsSelector<G, *>
+) :
+    GroupBy<T, G>,
+    AggregatableInternal<G> {
+
+    override val keys by lazy { df - groups }
+
+    override fun <R> updateGroups(transform: Selector<DataFrame<G>, DataFrame<R>>) =
+        df.convert(groups) { transform(it, it) }.asGroupBy(groups.name()) as GroupBy<T, R>
+
+    override fun toDataFrame(groupedColumnName: String?) = if (groupedColumnName == null || groupedColumnName == groups.name()) df else df.rename(groups).into(groupedColumnName)
+
+    override fun toString() = df.toString()
+
+    override fun remainingColumnsSelector(): ColumnsSelector<*, *> = keyColumnsInGroups.toColumns().let { groupCols -> { all().except(groupCols) } }
+
+    override fun <R> aggregate(body: AggregateGroupedBody<G, R>) = aggregateGroupBy(toDataFrame(), { groups }, removeColumns = true, body).cast<G>()
+
+    override fun filter(predicate: GroupedRowFilter<T, G>): GroupBy<T, G> {
+        val indices = (0 until df.nrow).filter {
+            val row = GroupedDataRowImpl(df.get(it), groups)
+            predicate(row, row)
+        }
+        return df[indices].asGroupBy(groups)
+    }
+}
+
+internal fun <T, G, R> aggregateGroupBy(
+    df: DataFrame<T>,
+    selector: ColumnSelector<T, DataFrame<G>?>,
+    removeColumns: Boolean,
+    body: AggregateGroupedBody<G, R>
+): DataFrame<T> {
+    val defaultAggregateName = "aggregated"
+
+    val column = df.getColumn(selector)
+
+    val removed = df.removeImpl(columns = selector)
+
+    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(
+                    pathOf(defaultAggregateName), result, null, null, true
+                )
+            )
+            builder.compute()
+        }
+    }.concat()
+
+    val removedNode = removed.removedColumns.single()
+    val insertPath = removedNode.pathFromRoot().dropLast(1)
+
+    if (!removeColumns) removedNode.data.wasRemoved = false
+
+    val columnsToInsert = groupedFrame.getColumnsWithPaths { allDfs() }.map {
+        ColumnToInsert(insertPath + it.path, it, removedNode)
+    }
+    val src = if (removeColumns) removed.df else df
+    return src.insertImpl(columnsToInsert)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/MathUtils.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/MathUtils.kt
new file mode 100644
index 000000000..52a90d914
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/MathUtils.kt
@@ -0,0 +1,28 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.io.defaultPrecision
+import org.jetbrains.kotlinx.dataframe.typeClass
+import java.math.BigDecimal
+
+internal fun <T : Number> DataColumn<T?>.scale(): Int {
+    if (size() == 0) return 0
+    return when (typeClass) {
+        Double::class -> values().maxOf { (it as? Double)?.scale() ?: 1 }
+        Float::class -> values().maxOf { (it as? Float)?.scale() ?: 1 }
+        BigDecimal::class -> values().maxOf { (it as? BigDecimal)?.scale() ?: 1 }
+        Number::class -> values().maxOf { (it as? Number)?.scale() ?: 0 }
+        else -> 0
+    }.coerceAtMost(defaultPrecision)
+}
+
+internal fun Double.scale() = if (isFinite()) toBigDecimal().scale() else 0
+internal fun Float.scale() = if (isFinite()) toBigDecimal().scale() else 0
+
+internal fun Number.scale(): Int = when (this) {
+    is Double -> scale()
+    is Float -> scale()
+    is Int, is Long -> 0
+    is BigDecimal -> scale()
+    else -> 0
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Rendering.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Rendering.kt
new file mode 100644
index 000000000..5861558e4
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Rendering.kt
@@ -0,0 +1,90 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.asDataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.jetbrains.kotlinx.dataframe.io.escapeHTML
+import org.jetbrains.kotlinx.dataframe.jupyter.RenderedContent
+import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import org.jetbrains.kotlinx.dataframe.size
+import org.jetbrains.kotlinx.dataframe.type
+import java.net.URL
+import java.time.LocalDateTime
+import java.time.LocalTime
+import kotlin.reflect.KType
+import kotlin.reflect.jvm.jvmErasure
+
+internal fun String.truncate(limit: Int): RenderedContent = if (limit in 1 until length) {
+    if (limit < 4) RenderedContent.truncatedText("...", this)
+    else RenderedContent.truncatedText(substring(0, (limit - 3).coerceAtLeast(1)) + "...", this)
+} else {
+    RenderedContent.text(this)
+}
+
+internal fun renderSchema(df: AnyFrame): String =
+    df.columns().joinToString { "${it.name()}:${renderType(it)}" }
+
+internal fun renderSchema(schema: DataFrameSchema): String =
+    schema.columns.map { "${it.key}:${renderType(it.value)}" }.joinToString()
+
+internal fun renderType(column: ColumnSchema) =
+    when (column) {
+        is ColumnSchema.Value -> {
+            renderType(column.type)
+        }
+
+        is ColumnSchema.Frame -> {
+            "[${renderSchema(column.schema)}]"
+        }
+
+        is ColumnSchema.Group -> {
+            "{${renderSchema(column.schema)}}"
+        }
+
+        else -> throw NotImplementedError()
+    }
+
+internal val classesToBeRenderedShort = setOf(URL::class, LocalDateTime::class, LocalTime::class)
+
+internal fun renderType(type: KType): String =
+    when (type.classifier) {
+        Nothing::class -> "Nothing" + if (type.isMarkedNullable) "?" else ""
+        List::class -> {
+            val argument = type.arguments[0].type?.let { renderType(it) } ?: "*"
+            "List<$argument>"
+        }
+
+        else -> {
+            val result = type.toString()
+            if (classesToBeRenderedShort.contains(type.classifier) ||
+                result.startsWith("kotlin.") ||
+                result.startsWith("org.jetbrains.kotlinx.dataframe.")
+            ) {
+                (type.jvmErasure.simpleName?.let { if (type.isMarkedNullable) "$it?" else it }) ?: result
+            } else result
+        }
+    }
+
+internal fun renderType(column: AnyCol) =
+    when (column.kind()) {
+        ColumnKind.Value -> renderType(column.type)
+        ColumnKind.Frame -> {
+            val table = column.asAnyFrameColumn()
+            "[${renderSchema(table.schema.value)}]"
+        }
+
+        ColumnKind.Group -> {
+            val group = column.asColumnGroup()
+            "{${renderSchema(group)}}"
+        }
+    }
+
+internal fun AnyCol.renderShort() = when (kind()) {
+    ColumnKind.Value -> "ValueColumn<${renderType(type)}>: $size entries".escapeHTML()
+    ColumnKind.Frame -> "FrameColumn: $size entries"
+    ColumnKind.Group -> "ColumnGroup ${asColumnGroup().asDataFrame().size}}"
+}
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
new file mode 100644
index 000000000..c3dbacaee
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/TypeUtils.kt
@@ -0,0 +1,430 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.Infer
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+import kotlin.reflect.KTypeParameter
+import kotlin.reflect.KTypeProjection
+import kotlin.reflect.KVisibility
+import kotlin.reflect.full.allSuperclasses
+import kotlin.reflect.full.createType
+import kotlin.reflect.full.isSubclassOf
+import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.full.isSuperclassOf
+import kotlin.reflect.full.superclasses
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.jvm.jvmErasure
+import kotlin.reflect.typeOf
+
+internal inline fun <reified T> KClass<*>.createTypeUsing() = typeOf<T>().projectTo(this)
+
+internal fun KType.projectTo(targetClass: KClass<*>): KType {
+    val currentClass = classifier as? KClass<*>
+    return when {
+        targetClass.typeParameters.isEmpty() || currentClass == null -> targetClass.createStarProjectedType(
+            isMarkedNullable
+        )
+
+        currentClass == targetClass -> this
+        targetClass.isSubclassOf(currentClass) -> projectDownTo(targetClass)
+        targetClass.isSuperclassOf(currentClass) -> projectUpTo(targetClass)
+        else -> targetClass.createStarProjectedType(isMarkedNullable)
+    }
+}
+
+internal fun KType.projectUpTo(superClass: KClass<*>): KType {
+    if (this == nothingType(false)) return superClass.createStarProjectedType(false)
+    if (this == nothingType(true)) return superClass.createStarProjectedType(true)
+
+    val chain = inheritanceChain(jvmErasure, superClass)
+    var current = this
+    chain.forEach { (clazz, declaredBaseType) ->
+        val substitution = clazz.typeParameters.zip(current.arguments.map { it.type }).toMap()
+        current = declaredBaseType.replace(substitution)
+    }
+    return current.withNullability(isMarkedNullable)
+}
+
+/**
+ * Changes generic type parameters to `Any?`, like `List<T> -> List<Any?>`.
+ * Works recursively as well.
+ */
+@PublishedApi
+internal fun KType.eraseGenericTypeParameters(): KType {
+    fun KType.eraseRecursively(): Pair<Boolean, KType> {
+        var replaced = false
+        val arguments = arguments.map {
+            val type = it.type
+            val (replacedDownwards, newType) = when {
+                type == null -> typeOf<Any?>()
+
+                type.classifier is KTypeParameter -> {
+                    replaced = true
+                    (type.classifier as KTypeParameter).upperBounds.firstOrNull() ?: typeOf<Any?>()
+                }
+
+                else -> type
+            }.eraseRecursively()
+
+            if (replacedDownwards) replaced = true
+
+            KTypeProjection.invariant(newType)
+        }
+        return Pair(
+            first = replaced,
+            second = if (replaced) jvmErasure.createType(arguments, isMarkedNullable) else this,
+        )
+    }
+
+    return eraseRecursively().second
+}
+
+internal fun inheritanceChain(subClass: KClass<*>, superClass: KClass<*>): List<Pair<KClass<*>, KType>> {
+    val inheritanceChain = mutableListOf<Pair<KClass<*>, KType>>()
+    var current = subClass
+    while (current != superClass) {
+        val baseType = current.supertypes.first { (it.classifier as? KClass<*>)?.isSubclassOf(superClass) ?: false }
+        inheritanceChain.add(current to baseType)
+        current = baseType.classifier as KClass<*>
+    }
+    return inheritanceChain
+}
+
+internal fun KType.projectDownTo(subClass: KClass<*>): KType {
+    val chain = inheritanceChain(subClass, classifier as KClass<*>)
+    var type = this
+
+    chain.reversed().forEach { (clazz, declaredBaseType) ->
+        val substitution = resolve(type, declaredBaseType)
+        val projection = clazz.typeParameters.map {
+            substitution[it]?.let { KTypeProjection.invariant(it) } ?: KTypeProjection.STAR
+        }
+        type = clazz.createType(projection, isMarkedNullable)
+    }
+    return type
+}
+
+internal fun KType.replace(substitution: Map<KTypeParameter, KType?>): KType {
+    return when (val clazz = classifier) {
+        is KTypeParameter -> substitution[clazz] ?: this
+        is KClass<*> -> clazz.createType(arguments.map { KTypeProjection(it.variance, it.type?.replace(substitution)) })
+        else -> this
+    }
+}
+
+internal fun resolve(actualType: KType, declaredType: KType): Map<KTypeParameter, KType?> {
+    val map = mutableMapOf<KTypeParameter, KType?>()
+
+    fun resolveRec(actualType: KType, declaredType: KType) {
+        require(actualType.classifier == declaredType.classifier)
+        actualType.arguments.zip(declaredType.arguments).forEach { (actualArgument, declaredArgument) ->
+            val declared = declaredArgument.type
+            val actual = actualArgument.type
+            if (declared?.classifier is KTypeParameter) {
+                val parameter = declared.classifier as KTypeParameter
+                val currentResolution = map[parameter]
+                if (currentResolution == null || (actual != null && actual.isSubtypeOf(currentResolution))) {
+                    map[parameter] = actual
+                }
+            } else if (declared != null && actual != null) {
+                val declaredClass = declared.classifier as? KClass<*>
+                val actualClass = actual.classifier as? KClass<*>
+                if (declaredClass != null && actualClass != null && declaredClass.isSubclassOf(actualClass)) {
+                    val projected = actual.projectTo(declaredClass)
+                    resolveRec(projected, declared)
+                }
+            }
+        }
+    }
+    resolveRec(actualType, declaredType)
+    return map
+}
+
+internal val numberTypeExtensions: Map<Pair<KClass<*>, KClass<*>>, KClass<*>> by lazy {
+    val map = mutableMapOf<Pair<KClass<*>, KClass<*>>, KClass<*>>()
+    fun add(from: KClass<*>, to: KClass<*>) {
+        map[from to to] = to
+        map[to to from] = to
+    }
+
+    val intTypes = listOf(Byte::class, Short::class, Int::class, Long::class)
+    for (i in intTypes.indices) {
+        for (j in i + 1 until intTypes.size)
+            add(intTypes[i], intTypes[j])
+        add(intTypes[i], Double::class)
+    }
+    add(Float::class, Double::class)
+    map
+}
+
+internal fun getCommonNumberType(first: KClass<*>?, second: KClass<*>): KClass<*> =
+    when {
+        first == null -> second
+        first == second -> first
+        else -> numberTypeExtensions[first to second] ?: error("Can not find common number type for $first and $second")
+    }
+
+internal fun Iterable<KClass<*>>.commonNumberClass(): KClass<*> =
+    fold(null as KClass<*>?, ::getCommonNumberType) ?: Number::class
+
+internal fun commonParent(classes: Iterable<KClass<*>>): KClass<*>? = commonParents(classes).withMostSuperclasses()
+internal fun commonParent(vararg classes: KClass<*>): KClass<*>? = commonParent(classes.toList())
+internal fun Iterable<KClass<*>>.withMostSuperclasses(): KClass<*>? = maxByOrNull { it.allSuperclasses.size }
+internal fun Iterable<KClass<*>>.createType(nullable: Boolean, upperBound: KType? = null): KType =
+    if (upperBound == null) (withMostSuperclasses() ?: Any::class).createStarProjectedType(nullable)
+    else {
+        val upperClass = upperBound.classifier as KClass<*>
+        val baseClass = filter { it.isSubclassOf(upperClass) }.withMostSuperclasses() ?: withMostSuperclasses()
+        if (baseClass == null) upperBound.withNullability(nullable)
+        else upperBound.projectTo(baseClass).withNullability(nullable)
+    }
+
+internal fun commonParents(vararg classes: KClass<*>): List<KClass<*>> = commonParents(classes.toList())
+internal fun commonParents(classes: Iterable<KClass<*>>): List<KClass<*>> =
+    when {
+        !classes.any() -> emptyList()
+        classes.all { it == Nothing::class } -> listOf(Nothing::class)
+        else -> {
+            classes
+                .distinct()
+                .filterNot { it == Nothing::class } // Nothing is a subtype of everything
+                .let {
+                    when {
+                        it.size == 1 && it[0].visibility == KVisibility.PUBLIC -> { // if there is only one class - return it
+                            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 {
+                            it - it.flatMap { it.superclasses }
+                                .toSet() // leave only 'leaf' classes, that are not super to some other class in a set
+                        }.toList()
+                    }
+                }
+        }
+    }.sortedBy { it.simpleName } // make sure the order is stable to avoid bugs
+
+/**
+ * Returns the common type of the given types including "listify" behaviour.
+ * Values and nulls will be wrapped in a list if they appear among other lists.
+ * For example: `[Int, Nothing?, List<Int>]` will become `List<Int>` instead of `Any?`. If there is another collection
+ * in there, it will become `Any?` anyway.
+ *
+ * @receiver the types to find the common type for
+ * @return the common type including listify behaviour
+ *
+ * @see commonType
+ */
+internal fun Iterable<KType>.commonTypeListifyValues(): KType {
+    val distinct = distinct()
+    return when {
+        distinct.isEmpty() -> Any::class.createStarProjectedType(distinct.any { it.isMarkedNullable })
+        distinct.size == 1 -> distinct.single()
+        else -> {
+            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 ->
+                        val arguments = distinct.map { it.arguments[index].type }.toSet()
+                        if (arguments.contains(null)) {
+                            KTypeProjection.STAR
+                        } else {
+                            val type = arguments.filterNotNull().commonTypeListifyValues()
+                            KTypeProjection(parameter.variance, type)
+                        }
+                    }
+
+                    if (classes.single() == Nothing::class) nothingType(distinct.any { it.isMarkedNullable })
+                    else classes[0].createType(typeProjections, distinct.any { it.isMarkedNullable })
+                }
+
+                classes.any { it == List::class } && classes.all { it == List::class || !it.isSubclassOf(Collection::class) } -> {
+                    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 type = listTypes
+                        .filterNotNull()
+                        .commonTypeListifyValues()
+                        .withNullability(listTypes.any { it?.isMarkedNullable ?: true })
+
+                    List::class.createType(
+                        arguments = listOf(KTypeProjection.invariant(type)),
+                        nullable = distinctNoNothing.any { it.isMarkedNullable },
+                    )
+                }
+
+                else -> {
+                    val kclass = commonParent(distinct.map { it.jvmErasure }) ?: return typeOf<Any>()
+                    val projections = distinct.map { it.projectUpTo(kclass).eraseGenericTypeParameters() }
+                    require(projections.all { it.jvmErasure == kclass })
+                    val arguments = List(kclass.typeParameters.size) { i ->
+                        val projectionTypes = projections
+                            .map { it.arguments[i].type }
+                            .filterNot { it in distinct } // avoid infinite recursion
+
+                        val type = projectionTypes.filterNotNull().commonTypeListifyValues()
+                        KTypeProjection.invariant(type)
+                    }
+
+                    if (kclass == Nothing::class) nothingType(nullable = distinct.any { it.isMarkedNullable })
+                    else kclass.createType(arguments, distinct.any { it.isMarkedNullable })
+                }
+            }
+        }
+    }
+}
+
+internal fun KClass<*>.createTypeWithArgument(argument: KType? = null, nullable: Boolean = false): KType {
+    require(typeParameters.size == 1)
+    return if (argument != null) createType(listOf(KTypeProjection.invariant(argument)), nullable)
+    else createStarProjectedType(nullable)
+}
+
+internal inline fun <reified T> createTypeWithArgument(typeArgument: KType? = null) =
+    T::class.createTypeWithArgument(typeArgument)
+
+@PublishedApi
+internal fun <T> getValuesType(values: List<T>, type: KType, infer: Infer): KType = when (infer) {
+    Infer.Nulls -> type.withNullability(values.anyNull())
+    Infer.Type -> guessValueType(values.asSequence(), type)
+    Infer.None -> type
+}
+
+/**
+ * Returns the value type of the given [values] sequence.
+ *
+ * @param values the values to guess the type from
+ * @param upperBound the upper bound of the type to guess
+ * @param listifyValues if true, then values and nulls will be wrapped in a list if they appear among other lists.
+ *   For example: `[1, null, listOf(1, 2, 3)]` will become `List<Int>` instead of `Any?`
+ *   Note: this parameter is ignored if another [Collection] is present in the values.
+ */
+@PublishedApi
+internal fun guessValueType(values: Sequence<Any?>, upperBound: KType? = null, listifyValues: Boolean = false): KType {
+    val classes = mutableSetOf<KClass<*>>()
+    val collectionClasses = mutableSetOf<KClass<out Collection<*>>>()
+    var hasNulls = false
+    var hasFrames = false
+    var hasRows = false
+    var hasList = false
+    var allListsAreEmpty = true
+    val classesInCollection = mutableSetOf<KClass<*>>()
+    var nullsInCollection = false
+    var listifyValues = listifyValues
+    values.forEach {
+        when (it) {
+            null -> hasNulls = true
+            is AnyRow -> hasRows = true
+            is AnyFrame -> hasFrames = true
+            is List<*> -> {
+                hasList = true
+                if (it.isNotEmpty()) allListsAreEmpty = false
+                it.forEach {
+                    if (it == null) nullsInCollection = true
+                    else classesInCollection.add(it.javaClass.kotlin)
+                }
+            }
+
+            is Collection<*> -> {
+                listifyValues = false // turn it off for when another collection is present
+                it.forEach {
+                    if (it == null) nullsInCollection = true
+                    else classesInCollection.add(it.javaClass.kotlin)
+                }
+                collectionClasses.add(it.javaClass.kotlin)
+            }
+
+            else -> classes.add(it.javaClass.kotlin)
+        }
+    }
+    val allListsWithRows = classesInCollection.isNotEmpty() &&
+        classesInCollection.all { it.isSubclassOf(DataRow::class) } &&
+        !nullsInCollection
+
+    return when {
+        classes.isNotEmpty() -> {
+            if (hasRows) classes.add(DataRow::class)
+            if (hasFrames) classes.add(DataFrame::class)
+            if (hasList) {
+                if (listifyValues) {
+                    val typeInLists = classesInCollection.commonType(
+                        nullable = nullsInCollection || allListsAreEmpty,
+                        upperBound = nothingType(nullable = false), // for when the list is empty, make it Nothing instead of Any?
+                    )
+                    val typeOfOthers = classes.commonType(nullable = nullsInCollection, upperBound = upperBound)
+                    val commonType = listOf(typeInLists, typeOfOthers).commonTypeListifyValues()
+                    return List::class.createTypeWithArgument(argument = commonType, nullable = false)
+                }
+                classes.add(List::class)
+            }
+            if (collectionClasses.isNotEmpty()) classes.addAll(collectionClasses)
+            return classes.commonType(hasNulls, upperBound)
+        }
+
+        hasNulls && !hasFrames && !hasRows && !hasList -> nothingType(nullable = true)
+
+        (hasFrames && (!hasList || allListsWithRows)) || (!hasFrames && allListsWithRows) ->
+            DataFrame::class.createStarProjectedType(hasNulls)
+
+        hasRows && !hasFrames && !hasList ->
+            DataRow::class.createStarProjectedType(false)
+
+        collectionClasses.isNotEmpty() && !hasFrames && !hasRows -> {
+            val elementType = upperBound?.let {
+                if (it.jvmErasure.isSubclassOf(Collection::class)) {
+                    it.projectUpTo(Collection::class).arguments[0].type
+                } else {
+                    null
+                }
+            }
+            if (hasList) collectionClasses.add(List::class)
+            (commonParent(collectionClasses) ?: Collection::class)
+                .createTypeWithArgument(
+                    classesInCollection.commonType(
+                        nullable = nullsInCollection,
+                        upperBound = elementType ?: nothingType(nullable = nullsInCollection),
+                    )
+                ).withNullability(hasNulls)
+        }
+
+        hasList && collectionClasses.isEmpty() && !hasFrames && !hasRows -> {
+            val elementType = upperBound?.let { if (it.jvmErasure == List::class) it.arguments[0].type else null }
+            List::class.createTypeWithArgument(
+                classesInCollection.commonType(
+                    nullable = nullsInCollection,
+                    upperBound = elementType ?: nothingType(nullable = nullsInCollection),
+                )
+            ).withNullability(hasNulls && !listifyValues)
+        }
+
+        else -> {
+            if (hasRows) classes.add(DataRow::class)
+            if (hasFrames) classes.add(DataFrame::class)
+            if (hasList) classes.add(List::class)
+            if (collectionClasses.isNotEmpty()) classes.addAll(collectionClasses)
+            return classes.commonType(hasNulls, upperBound)
+        }
+    }
+}
+
+internal fun nothingType(nullable: Boolean): KType =
+    if (nullable) {
+        typeOf<List<Nothing?>>()
+    } else {
+        typeOf<List<Nothing>>()
+    }.arguments.first().type!!
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
new file mode 100644
index 000000000..c1e933a33
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Utils.kt
@@ -0,0 +1,288 @@
+package org.jetbrains.kotlinx.dataframe.impl
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.Predicate
+import org.jetbrains.kotlinx.dataframe.annotations.ColumnName
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.impl.columns.resolve
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.nrow
+import java.math.BigDecimal
+import java.math.BigInteger
+import kotlin.reflect.KClass
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.KTypeProjection
+import kotlin.reflect.full.createType
+import kotlin.reflect.full.findAnnotation
+import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.full.starProjectedType
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.jvm.jvmErasure
+import kotlin.reflect.typeOf
+
+internal infix fun <T> (Predicate<T>?).and(other: Predicate<T>): Predicate<T> =
+    if (this == null) other else { it: T -> this(it) && other(it) }
+
+internal fun <T> T.toIterable(getNext: (T) -> T?) = Iterable<T> {
+    object : Iterator<T> {
+
+        var current: T? = null
+        var beforeStart = true
+        var next: T? = null
+
+        override fun hasNext(): Boolean {
+            if (beforeStart) return true
+            if (next == null) next = getNext(current!!)
+            return next != null
+        }
+
+        override fun next(): T {
+            if (beforeStart) {
+                current = this@toIterable
+                beforeStart = false
+                return current!!
+            }
+            current = next ?: getNext(current!!)
+            next = null
+            return current!!
+        }
+    }
+}
+
+internal fun <T> List<T>.removeAt(index: Int) = subList(0, index) + subList(index + 1, size)
+
+internal inline fun <reified T : Any> Int.cast() = convert(this, T::class)
+
+internal fun <T : Any> convert(src: Int, tartypeOf: KClass<T>): T = when (tartypeOf) {
+    Double::class -> src.toDouble() as T
+    Long::class -> src.toLong() as T
+    Float::class -> src.toFloat() as T
+    BigDecimal::class -> src.toBigDecimal() as T
+    else -> throw NotImplementedError("Casting int to $tartypeOf is not supported")
+}
+
+internal fun BooleanArray.toIndices(): List<Int> {
+    val res = ArrayList<Int>(size)
+    for (i in 0 until size)
+        if (this[i]) res.add(i)
+    return res
+}
+
+internal fun List<Boolean>.toIndices(): List<Int> {
+    val res = ArrayList<Int>(size)
+    for (i in 0 until size)
+        if (this[i]) res.add(i)
+    return res
+}
+
+internal fun <T> Iterable<T>.equalsByElement(other: Iterable<T>): Boolean {
+    val iterator1 = iterator()
+    val iterator2 = other.iterator()
+    while (iterator1.hasNext() && iterator2.hasNext()) {
+        if (iterator1.next() != iterator2.next()) return false
+    }
+    if (iterator1.hasNext() || iterator2.hasNext()) return false
+    return true
+}
+
+internal fun <T> Iterable<T>.rollingHash(): Int {
+    val i = iterator()
+    var hash = 0
+    while (i.hasNext())
+        hash = 31 * hash + (i.next()?.hashCode() ?: 5)
+    return hash
+}
+
+public fun <T> Iterable<T>.asList(): List<T> = when (this) {
+    is List<T> -> this
+    else -> this.toList()
+}
+
+@PublishedApi
+internal fun <T> Iterable<T>.anyNull(): Boolean = any { it == null }
+
+@PublishedApi
+internal fun emptyPath(): ColumnPath = ColumnPath(emptyList())
+
+@PublishedApi
+internal fun <T : Number> KClass<T>.zero(): T = when (this) {
+    Int::class -> 0 as T
+    Byte::class -> 0.toByte() as T
+    Short::class -> 0.toShort() as T
+    Long::class -> 0.toLong() as T
+    Double::class -> 0.toDouble() as T
+    Float::class -> 0.toFloat() as T
+    BigDecimal::class -> BigDecimal.ZERO as T
+    BigInteger::class -> BigInteger.ZERO as T
+    Number::class -> 0 as T
+    else -> TODO()
+}
+
+internal fun <T> catchSilent(body: () -> T): T? = try {
+    body()
+} catch (_: Throwable) {
+    null
+}
+
+internal fun Iterable<KClass<*>>.commonType(nullable: Boolean, upperBound: KType? = null) =
+    commonParents(this).createType(nullable, upperBound)
+
+/**
+ * Returns the common supertype of the given types.
+ *
+ * @see commonTypeListifyValues
+ */
+internal fun Iterable<KType?>.commonType(): KType {
+    val distinct = distinct()
+    val nullable = distinct.any { it?.isMarkedNullable ?: true }
+    return when {
+        distinct.isEmpty() || distinct.contains(null) -> Any::class.createStarProjectedType(nullable)
+        distinct.size == 1 -> distinct.single()!!
+        else -> {
+            val kclass = commonParent(distinct.map { it!!.jvmErasure }) ?: return typeOf<Any>()
+            val projections = distinct.map { it!!.projectUpTo(kclass).eraseGenericTypeParameters() }
+            require(projections.all { it.jvmErasure == kclass })
+            val arguments = List(kclass.typeParameters.size) { i ->
+                val projectionTypes = projections
+                    .map { it.arguments[i].type }
+                    .filterNot { it in distinct } // avoid infinite recursion
+
+                val type = projectionTypes.commonType()
+                KTypeProjection.invariant(type)
+            }
+            kclass.createType(arguments, nullable)
+        }
+    }
+}
+
+internal fun <T, C> DataFrame<T>.getColumnsImpl(
+    unresolvedColumnsPolicy: UnresolvedColumnsPolicy,
+    selector: ColumnsSelector<T, C>,
+): List<DataColumn<C>> = getColumnsWithPaths(unresolvedColumnsPolicy, selector).map { it.data }
+
+internal fun <T, C> DataFrame<T>.getColumnsWithPaths(
+    unresolvedColumnsPolicy: UnresolvedColumnsPolicy,
+    selector: ColumnsSelector<T, C>,
+): List<ColumnWithPath<C>> = selector.toColumns().resolve(this, unresolvedColumnsPolicy)
+
+internal fun <T, C> DataFrame<T>.getColumnPaths(
+    unresolvedColumnsPolicy: UnresolvedColumnsPolicy,
+    selector: ColumnsSelector<T, C>,
+): List<ColumnPath> = getColumnsWithPaths(unresolvedColumnsPolicy, selector).map { it.path }
+
+internal fun <C : Comparable<C>> Sequence<C?>.indexOfMin(): Int {
+    val iterator = iterator()
+    if (!iterator.hasNext()) return -1
+    var value = iterator.next()
+    var index = 0
+    while (value == null) {
+        if (!iterator.hasNext()) return -1
+        value = iterator.next()
+        index++
+    }
+    var min: C = value
+    var minIndex = index
+    if (!iterator.hasNext()) return minIndex
+    do {
+        val v = iterator.next()
+        index++
+        if (v != null && min > v) {
+            min = v
+            minIndex = index
+        }
+    } while (iterator.hasNext())
+    return minIndex
+}
+
+internal fun <C : Comparable<C>> Sequence<C?>.indexOfMax(): Int {
+    val iterator = iterator()
+    if (!iterator.hasNext()) return -1
+    var value = iterator.next()
+    var index = 0
+    while (value == null) {
+        if (!iterator.hasNext()) return -1
+        value = iterator.next()
+        index++
+    }
+    var max: C = value
+    var maxIndex = index
+    if (!iterator.hasNext()) return maxIndex
+    do {
+        val v = iterator.next()
+        index++
+        if (v != null && max < v) {
+            max = v
+            maxIndex = index
+        }
+    } while (iterator.hasNext())
+    return maxIndex
+}
+
+internal fun KClass<*>.createStarProjectedType(nullable: Boolean): KType =
+    if (this == Nothing::class) nothingType(nullable) // would be Void otherwise
+    else this.starProjectedType.let { if (nullable) it.withNullability(true) else it }
+
+internal fun KType.isSubtypeWithNullabilityOf(type: KType) =
+    this.isSubtypeOf(type) && (!this.isMarkedNullable || type.isMarkedNullable)
+
+@PublishedApi
+internal inline fun <reified C> headPlusArray(head: C, cols: Array<out C>): Array<C> =
+    (listOf(head) + cols.toList()).toTypedArray()
+
+@PublishedApi
+internal inline fun <reified C> headPlusIterable(head: C, cols: Iterable<C>): Iterable<C> =
+    (listOf(head) + cols.asIterable())
+
+internal fun <T> DataFrame<T>.splitByIndices(
+    startIndices: Sequence<Int>,
+): Sequence<DataFrame<T>> {
+    return (startIndices + nrow).zipWithNext { start, endExclusive ->
+        if (start == endExclusive) DataFrame.empty().cast()
+        else get(start until endExclusive)
+    }
+}
+
+internal fun <T> List<T>.splitByIndices(startIndices: Sequence<Int>): Sequence<List<T>> {
+    return (startIndices + size).zipWithNext { start, endExclusive ->
+        subList(start, endExclusive)
+    }
+}
+
+internal fun <T> T.asNullable() = this as T?
+internal fun <T> List<T>.last(count: Int) = subList(size - count, size)
+internal fun <T : Comparable<T>> T.between(left: T, right: T, includeBoundaries: Boolean = true): Boolean =
+    if (includeBoundaries) this in left..right
+    else this > left && this < right
+
+private const val DELIMITERS = "[_\\s]"
+public val DELIMITERS_REGEX: Regex = DELIMITERS.toRegex()
+public val DELIMITED_STRING_REGEX: Regex = ".+$DELIMITERS.+".toRegex()
+
+internal val CAMEL_REGEX = "(?<=[a-zA-Z])[A-Z]".toRegex()
+
+public fun String.toCamelCaseByDelimiters(delimiters: Regex): String =
+    split(delimiters).joinToCamelCaseString()
+
+internal fun String.toSnakeCase(): String =
+    if ("[A-Z_]+".toRegex().matches(this)) {
+        this
+    } else {
+        CAMEL_REGEX
+            .replace(this) { "_${it.value}" }
+            .replace(" ", "_")
+            .lowercase()
+    }
+
+internal fun List<String>.joinToCamelCaseString(): String {
+    return joinToString(separator = "") { it.replaceFirstChar { it.uppercaseChar() } }
+        .replaceFirstChar { it.lowercaseChar() }
+}
+
+@PublishedApi
+internal val <T> KProperty<T>.columnName: String get() = findAnnotation<ColumnName>()?.name ?: name
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/AggregatableInternal.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/AggregatableInternal.kt
new file mode 100644
index 000000000..5a888213c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/AggregatableInternal.kt
@@ -0,0 +1,21 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.aggregation.Aggregatable
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedBody
+import org.jetbrains.kotlinx.dataframe.api.Grouped
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.AggregateBodyInternal
+
+internal interface AggregatableInternal<out T> : Aggregatable<T> {
+
+    fun remainingColumnsSelector(): ColumnsSelector<*, *>
+}
+
+internal fun <T> Aggregatable<T>.remainingColumnsSelector() = internal().remainingColumnsSelector()
+
+@PublishedApi
+internal fun <T> Aggregatable<T>.internal(): AggregatableInternal<T> = this as AggregatableInternal<T>
+
+@PublishedApi
+internal fun <T, R> Grouped<T>.aggregateInternal(body: AggregateBodyInternal<T, R>): DataFrame<T> = aggregate(body as AggregateGroupedBody<T, R>)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/AggregateColumnDescriptor.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/AggregateColumnDescriptor.kt
new file mode 100644
index 000000000..edd8c24e7
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/AggregateColumnDescriptor.kt
@@ -0,0 +1,32 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelector
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.columns.shortPath
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.AggregateInternalDsl
+import org.jetbrains.kotlinx.dataframe.impl.columns.resolve
+
+internal class AggregateColumnDescriptor<C>(
+    val column: ColumnWithPath<C>,
+    val default: C? = null,
+    val newPath: ColumnPath? = null
+) : ColumnWithPath<C> by column
+
+internal fun <T, C> DataFrame<T>.getAggregateColumn(selector: ColumnsForAggregateSelector<T, C>) =
+    getAggregateColumns(selector).single()
+
+internal fun <T, C> DataFrame<T>.getAggregateColumns(selector: ColumnsForAggregateSelector<T, C>): List<AggregateColumnDescriptor<C>> {
+    val columns = selector.toColumns().resolve(this, UnresolvedColumnsPolicy.Create)
+    return columns.map {
+        when (val col = it) {
+            is AggregateColumnDescriptor<*> -> col as AggregateColumnDescriptor<C>
+            else -> AggregateColumnDescriptor(it, null, null)
+        }
+    }
+}
+
+internal fun <T, C> AggregateInternalDsl<T>.getPath(col: AggregateColumnDescriptor<C>, isSingle: Boolean) =
+    col.newPath ?: if (isSingle) pathForSingleColumn(col.data) else col.data.shortPath()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ConfiguredAggregateColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ConfiguredAggregateColumn.kt
new file mode 100644
index 000000000..daae75d99
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ConfiguredAggregateColumn.kt
@@ -0,0 +1,45 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation
+
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.shortPath
+
+internal class ConfiguredAggregateColumn<C> private constructor(
+    val columns: ColumnSet<C>,
+    private val default: C? = null,
+    private val newPath: ColumnPath? = null
+) : ColumnSet<C> {
+
+    private fun ColumnWithPath<C>.toDescriptor(keepName: Boolean) = when (val col = this) {
+        is AggregateColumnDescriptor<C> -> {
+            val path = if (keepName) newPath?.plus(col.newPath ?: col.column.shortPath()) ?: col.newPath
+            else newPath ?: col.newPath
+            AggregateColumnDescriptor(col.column, default ?: col.default, path)
+        }
+        else -> AggregateColumnDescriptor(col, default, if (keepName) newPath?.plus(col.name) else newPath)
+    }
+
+    override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> {
+        val resolved = columns.resolve(context)
+        if (resolved.size == 1) return listOf(resolved[0].toDescriptor(false))
+        else return resolved.map {
+            it.toDescriptor(true)
+        }
+    }
+
+    companion object {
+
+        fun <C> withDefault(src: ColumnSet<C>, default: C?): ColumnSet<C> = when (src) {
+            is ConfiguredAggregateColumn<C> -> ConfiguredAggregateColumn(src.columns, default, src.newPath)
+            else -> ConfiguredAggregateColumn(src, default, null)
+        }
+
+        fun <C> withPath(src: ColumnSet<C>, newPath: ColumnPath): ColumnSet<C> = when (src) {
+            is ConfiguredAggregateColumn<C> -> ConfiguredAggregateColumn(src.columns, src.default, newPath)
+            else -> ConfiguredAggregateColumn(src, null, newPath)
+        }
+    }
+}
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
new file mode 100644
index 000000000..9b857c254
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/GroupByReceiverImpl.kt
@@ -0,0 +1,88 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedDsl
+import org.jetbrains.kotlinx.dataframe.aggregation.NamedValue
+import org.jetbrains.kotlinx.dataframe.api.asDataFrame
+import org.jetbrains.kotlinx.dataframe.api.toDataFrameFromPairs
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.columns.shortPath
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.AggregateInternalDsl
+import org.jetbrains.kotlinx.dataframe.impl.api.AggregatedPivot
+import org.jetbrains.kotlinx.dataframe.impl.createTypeWithArgument
+import org.jetbrains.kotlinx.dataframe.impl.getListType
+import kotlin.reflect.KType
+
+internal class GroupByReceiverImpl<T>(override val df: DataFrame<T>, override val hasGroupingKeys: Boolean) :
+    AggregateGroupedDsl<T>(),
+    AggregateInternalDsl<T>,
+    AggregatableInternal<T> by df as AggregatableInternal<T>,
+    DataFrame<T> by df {
+
+    private val values = mutableListOf<NamedValue>()
+
+    internal fun child(): GroupByReceiverImpl<T> {
+        val child = GroupByReceiverImpl(df, true)
+        values.add(NamedValue.aggregator(child))
+        return child
+    }
+
+    internal fun compute(): AnyRow? {
+        val allValues = mutableListOf<NamedValue>()
+        values.forEach {
+            when (it.value) {
+                is GroupByReceiverImpl<*> -> {
+                    it.value.values.forEach {
+                        allValues.add(it)
+                    }
+                }
+                is ValueColumn<*> -> {
+                    allValues.add(NamedValue.create(it.path, it.value.toList(), getListType(it.value.type()), emptyList<Unit>()))
+                }
+                is ColumnGroup<*> -> {
+                    val frameType = it.value.type().arguments.singleOrNull()?.type
+                    allValues.add(NamedValue.create(it.path, it.value.asDataFrame(), DataFrame::class.createTypeWithArgument(frameType), DataFrame.Empty))
+                }
+                is FrameColumn<*> -> {
+                    allValues.add(NamedValue.create(it.path, it.value.toList(), getListType(it.value.type()), emptyList<Unit>()))
+                }
+                else -> {
+                    allValues.add(it)
+                }
+            }
+        }
+        val columns = allValues.map { it.toColumnWithPath() }
+        return if (columns.isEmpty()) null
+        else columns.toDataFrameFromPairs<T>()[0]
+    }
+
+    override fun pathForSingleColumn(column: AnyCol) = column.shortPath()
+
+    override fun <R> yield(path: ColumnPath, value: R, type: KType?, default: R?) =
+        yield(path, value, type, default, false)
+
+    override fun yield(value: NamedValue): NamedValue {
+        when (value.value) {
+            is AggregatedPivot<*> -> {
+                val pivot = value.value
+                val dropFirstNameInPath = pivot.inward == true && value.path.isNotEmpty() && pivot.aggregator.values.distinctBy { it.path.firstOrNull() }.count() == 1
+                pivot.aggregator.values.forEach {
+                    val targetPath =
+                        if (dropFirstNameInPath && it.path.size > 0) value.path + it.path.dropFirst()
+                        else value.path + it.path
+
+                    yield(targetPath, it.value, it.type, it.default, it.guessType)
+                }
+                pivot.aggregator.values.clear()
+            }
+            is AggregateInternalDsl<*> -> yield(value.copy(value = value.value.df))
+            else -> values.add(value)
+        }
+        return value
+    }
+}
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
new file mode 100644
index 000000000..341d2a002
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotGroupByImpl.kt
@@ -0,0 +1,32 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateBody
+import org.jetbrains.kotlinx.dataframe.api.GroupBy
+import org.jetbrains.kotlinx.dataframe.api.PivotColumnsSelector
+import org.jetbrains.kotlinx.dataframe.api.PivotGroupBy
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.firstOrNull
+import org.jetbrains.kotlinx.dataframe.impl.GroupByImpl
+import org.jetbrains.kotlinx.dataframe.impl.api.aggregatePivot
+import org.jetbrains.kotlinx.dataframe.impl.api.getPivotColumnPaths
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+
+internal data class PivotGroupByImpl<T>(
+    val df: GroupBy<*, T>,
+    val columns: PivotColumnsSelector<T, *>,
+    val inward: Boolean?,
+    val default: Any? = null
+) : PivotGroupBy<T>, AggregatableInternal<T> {
+    override fun <R> aggregate(separate: Boolean, body: AggregateBody<T, R>): DataFrame<T> {
+        return 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().let { pivotPaths -> { all().except(pivotPaths.toColumnSet() and (df as GroupByImpl).keyColumnsInGroups.toColumns()) } }
+}
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
new file mode 100644
index 000000000..ee6fd1351
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotImpl.kt
@@ -0,0 +1,21 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+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.impl.columns.toColumns
+
+internal data class PivotImpl<T>(
+    val df: DataFrame<T>,
+    val columns: PivotColumnsSelector<T, *>,
+    val inward: Boolean?
+) : Pivot<T>, AggregatableInternal<T> {
+
+    fun toGroupedPivot(moveToTop: Boolean, columns: ColumnsSelector<T, *>): PivotGroupBy<T> =
+        PivotGroupByImpl(df.groupBy(moveToTop, columns), this.columns, inward)
+
+    override fun remainingColumnsSelector(): ColumnsSelector<*, *> = columns.toColumns().let { pivotCols -> { all().except(pivotCols) } }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotInAggregateImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotInAggregateImpl.kt
new file mode 100644
index 000000000..7ebe3f93b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/PivotInAggregateImpl.kt
@@ -0,0 +1,30 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateBody
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedDsl
+import org.jetbrains.kotlinx.dataframe.api.PivotGroupBy
+import org.jetbrains.kotlinx.dataframe.impl.api.AggregatedPivot
+import org.jetbrains.kotlinx.dataframe.impl.api.aggregatePivot
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+
+internal data class PivotInAggregateImpl<T>(
+    val aggregator: AggregateGroupedDsl<T>,
+    val columns: ColumnsSelector<T, *>,
+    val inward: Boolean?,
+    val default: Any? = null
+) : PivotGroupBy<T>, AggregatableInternal<T> {
+
+    override fun default(value: Any?) = copy(default = value)
+
+    override fun <R> aggregate(separate: Boolean, body: AggregateBody<T, R>): DataFrame<T> {
+        require(aggregator is GroupByReceiverImpl<T>)
+
+        val childAggregator = aggregator.child()
+        aggregatePivot(childAggregator, columns, separate, inward, default, body)
+        return AggregatedPivot(aggregator.df, inward, childAggregator)
+    }
+
+    override fun remainingColumnsSelector(): ColumnsSelector<*, *> = { all().except(columns.toColumns()) }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ValueWithDefault.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ValueWithDefault.kt
new file mode 100644
index 000000000..30353b226
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/ValueWithDefault.kt
@@ -0,0 +1,3 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation
+
+internal class ValueWithDefault<T>(val value: T, val default: T)
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
new file mode 100644
index 000000000..925a70fdd
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregations.kt
@@ -0,0 +1,97 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation
+
+import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateDsl
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelectionDsl
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelector
+import org.jetbrains.kotlinx.dataframe.api.asSequence
+import org.jetbrains.kotlinx.dataframe.api.canHaveNA
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.isNA
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameReceiver
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.AggregateInternalDsl
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.impl.getListType
+import org.jetbrains.kotlinx.dataframe.type
+import org.jetbrains.kotlinx.dataframe.values
+import kotlin.reflect.KType
+import kotlin.reflect.full.withNullability
+
+@PublishedApi
+internal fun <T, V> AggregateInternalDsl<T>.yieldOneOrMany(
+    path: ColumnPath,
+    values: List<V>,
+    type: KType,
+    default: V? = null
+) {
+    when (values.size) {
+        0 -> yield(path, null, type.withNullability(true), default)
+        1 -> yield(path, values[0], type, default)
+        else -> yield(path, values, getListType(type), default)
+    }
+}
+
+@JvmName("toColumnSetForAggregate")
+internal fun <T, C> ColumnsForAggregateSelector<T, C>.toColumns(): ColumnSet<C> = toColumns {
+    object : DataFrameReceiver<T>(it.df.cast(), UnresolvedColumnsPolicy.Fail), ColumnsForAggregateSelectionDsl<T> {}
+}
+
+@PublishedApi
+internal fun <T> AggregateDsl<T>.internal(): AggregateInternalDsl<T> = this as AggregateInternalDsl<T>
+
+internal fun <T, C> AggregateInternalDsl<T>.columnValues(
+    columns: ColumnsForAggregateSelector<T, C>,
+    forceYieldLists: Boolean,
+    dropNA: Boolean,
+    distinct: Boolean
+) {
+    val cols = df.getAggregateColumns(columns)
+    val isSingle = cols.size == 1
+    cols.forEach { col ->
+        val path = getPath(col, isSingle)
+
+        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.values.filter { !it.isNA }
+            distinct -> col.values().distinct()
+            else -> col.toList()
+        }
+
+        if (forceYieldLists) yield(path, values, getListType(col.type), col.default)
+        else yieldOneOrMany(path, values, col.type, col.default)
+    }
+}
+
+internal fun <T, C> AggregateInternalDsl<T>.columnValues(
+    columns: ColumnsForAggregateSelector<T, C>,
+    reducer: Selector<DataFrame<T>, DataRow<T>?>
+) {
+    val row = reducer(df, df)
+    val cols = df.getAggregateColumns(columns)
+    val isSingle = cols.size == 1
+    cols.forEach { col ->
+        val path = getPath(col, isSingle)
+        val value = if (row != null) col[row] else null
+        yield(path, value, col.type, col.default)
+    }
+}
+
+@PublishedApi
+internal fun <T, V> AggregateInternalDsl<T>.withExpr(type: KType, path: ColumnPath, expression: RowExpression<T, V>) {
+    val values = df.rows().map {
+        val value = expression(it, it)
+        if (value is Column) it[value]
+        else value
+    }
+    yieldOneOrMany(path, values, type)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregator.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregator.kt
new file mode 100644
index 000000000..dcd88a15a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregator.kt
@@ -0,0 +1,24 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import kotlin.reflect.KType
+
+@PublishedApi
+internal interface Aggregator<C, R> {
+
+    val name: String
+
+    fun aggregate(column: DataColumn<C?>): R?
+
+    val preservesType: Boolean
+
+    fun aggregate(columns: Iterable<DataColumn<C?>>): R?
+
+    fun aggregate(values: Iterable<C>, type: KType): R?
+}
+
+@PublishedApi
+internal fun <T> Aggregator<*, *>.cast(): Aggregator<T, T> = this as Aggregator<T, T>
+
+@PublishedApi
+internal fun <T, P> Aggregator<*, *>.cast2(): Aggregator<T, P> = this as Aggregator<T, P>
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorBase.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorBase.kt
new file mode 100644
index 000000000..836e26d8b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorBase.kt
@@ -0,0 +1,18 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.asIterable
+import org.jetbrains.kotlinx.dataframe.api.asSequence
+import kotlin.reflect.KType
+
+internal abstract class AggregatorBase<C, R>(
+    override val name: String,
+    protected val aggregator: (Iterable<C>, KType) -> R?
+) : Aggregator<C, R> {
+
+    override fun aggregate(column: DataColumn<C?>): R? = if (column.hasNulls()) {
+        aggregate(column.asSequence().filterNotNull().asIterable(), column.type())
+    } else aggregate(column.asIterable() as Iterable<C>, column.type())
+
+    override fun aggregate(values: Iterable<C>, type: KType): R? = aggregator(values, type)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorOptionSwitch.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorOptionSwitch.kt
new file mode 100644
index 000000000..6d0ca62fe
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorOptionSwitch.kt
@@ -0,0 +1,30 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators
+
+import kotlin.reflect.KProperty
+
+@PublishedApi
+internal class AggregatorOptionSwitch<P, C, R>(val name: String, val getAggregator: (P) -> AggregatorProvider<C, R>) {
+
+    private val cache = mutableMapOf<P, Aggregator<C, R>>()
+
+    operator fun invoke(option: P) = cache.getOrPut(option) { getAggregator(option).create(name) }
+
+    class Factory<P, C, R>(val getAggregator: (P) -> AggregatorProvider<C, R>) {
+        operator fun getValue(obj: Any?, property: KProperty<*>) = AggregatorOptionSwitch(property.name, getAggregator)
+    }
+}
+
+@PublishedApi
+internal class AggregatorOptionSwitch2<P1, P2, C, R>(
+    val name: String,
+    val getAggregator: (P1, P2) -> AggregatorProvider<C, R>
+) {
+
+    private val cache = mutableMapOf<Pair<P1, P2>, Aggregator<C, R>>()
+
+    operator fun invoke(option1: P1, option2: P2) = cache.getOrPut(option1 to option2) { getAggregator(option1, option2).create(name) }
+
+    class Factory<P1, P2, C, R>(val getAggregator: (P1, P2) -> AggregatorProvider<C, R>) {
+        operator fun getValue(obj: Any?, property: KProperty<*>) = AggregatorOptionSwitch2(property.name, getAggregator)
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorProvider.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorProvider.kt
new file mode 100644
index 000000000..a8265a817
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorProvider.kt
@@ -0,0 +1,10 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators
+
+import kotlin.reflect.KProperty
+
+internal interface AggregatorProvider<C, R> {
+
+    operator fun getValue(obj: Any?, property: KProperty<*>): Aggregator<C, R> = create(property.name)
+
+    fun create(name: String): Aggregator<C, R>
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregators.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregators.kt
new file mode 100644
index 000000000..151de25d2
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregators.kt
@@ -0,0 +1,41 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators
+
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators.std
+import org.jetbrains.kotlinx.dataframe.math.mean
+import org.jetbrains.kotlinx.dataframe.math.median
+import org.jetbrains.kotlinx.dataframe.math.std
+import org.jetbrains.kotlinx.dataframe.math.sum
+import kotlin.reflect.KType
+
+@PublishedApi
+internal object Aggregators {
+
+    private fun <C> preservesType(aggregate: Iterable<C>.(KType) -> C?) =
+        TwoStepAggregator.Factory(aggregate, aggregate, true)
+
+    private fun <C : Any, R> mergedValues(aggregate: Iterable<C?>.(KType) -> R?) =
+        MergedValuesAggregator.Factory(aggregate, true)
+
+    private fun <C, R> changesType(aggregate1: Iterable<C>.(KType) -> R, aggregate2: Iterable<R>.(KType) -> R) =
+        TwoStepAggregator.Factory(aggregate1, aggregate2, false)
+
+    private fun extendsNumbers(aggregate: Iterable<Number>.(KType) -> Number?) =
+        NumbersAggregator.Factory(aggregate)
+
+    private fun <P, C, R> withOption(getAggregator: (P) -> AggregatorProvider<C, R>) =
+        AggregatorOptionSwitch.Factory(getAggregator)
+
+    private fun <P1, P2, C, R> withOption2(getAggregator: (P1, P2) -> AggregatorProvider<C, R>) =
+        AggregatorOptionSwitch2.Factory(getAggregator)
+
+    val min by preservesType<Comparable<Any?>> { minOrNull() }
+    val max by preservesType<Comparable<Any?>> { maxOrNull() }
+    val std by withOption2<Boolean, Int, Number, Double> { skipNA, ddof ->
+        mergedValues { std(it, skipNA, ddof) }
+    }
+    val mean by withOption<Boolean, Number, Double> { skipNA ->
+        changesType({ mean(it, skipNA) }) { mean(skipNA) }
+    }
+    val median by mergedValues<Comparable<Any?>, Comparable<Any?>> { median(it) }
+    val sum by extendsNumbers { sum(it) }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/MergedValuesAggregator.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/MergedValuesAggregator.kt
new file mode 100644
index 000000000..dca860620
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/MergedValuesAggregator.kt
@@ -0,0 +1,41 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.impl.commonType
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+
+internal class MergedValuesAggregator<C : Any, R>(
+    name: String,
+    val aggregateWithType: (Iterable<C?>, KType) -> R?,
+    override val preservesType: Boolean
+) : AggregatorBase<C, R>(name, aggregateWithType) {
+
+    override fun aggregate(columns: Iterable<DataColumn<C?>>): R? {
+        val commonType = columns.map { it.type() }.commonType()
+        val allValues = columns.flatMap { it.values() }
+        return aggregateWithType(allValues, commonType)
+    }
+
+    fun aggregateMixed(values: Iterable<C?>): R? {
+        var hasNulls = false
+        val classes = values.mapNotNull {
+            if (it == null) {
+                hasNulls = true
+                null
+            } else {
+                it.javaClass.kotlin
+            }
+        }
+        return aggregateWithType(values, classes.commonType(hasNulls))
+    }
+
+    class Factory<C : Any, R>(
+        private val aggregateWithType: (Iterable<C?>, KType) -> R?,
+        private val preservesType: Boolean
+    ) : AggregatorProvider<C, R> {
+        override fun create(name: String) = MergedValuesAggregator(name, aggregateWithType, preservesType)
+
+        override operator fun getValue(obj: Any?, property: KProperty<*>): MergedValuesAggregator<C, R> = create(property.name)
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/NumbersAggregator.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/NumbersAggregator.kt
new file mode 100644
index 000000000..c7bbe4120
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/NumbersAggregator.kt
@@ -0,0 +1,28 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.impl.commonNumberClass
+import org.jetbrains.kotlinx.dataframe.impl.createStarProjectedType
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+
+internal class NumbersAggregator<C : Number>(name: String, aggregate: (Iterable<C>, KType) -> C?) :
+    AggregatorBase<C, C>(name, aggregate) {
+
+    override fun aggregate(columns: Iterable<DataColumn<C?>>): C? {
+        return aggregateMixed(columns.mapNotNull { aggregate(it) })
+    }
+
+    class Factory(private val aggregate: Iterable<Number>.(KType) -> Number?) : AggregatorProvider<Number, Number> {
+        override fun create(name: String) = NumbersAggregator(name, aggregate)
+
+        override operator fun getValue(obj: Any?, property: KProperty<*>): NumbersAggregator<Number> = create(property.name)
+    }
+
+    fun aggregateMixed(values: Iterable<C>): C? {
+        val classes = values.map { it.javaClass.kotlin }
+        return aggregate(values, classes.commonNumberClass().createStarProjectedType(false))
+    }
+
+    override val preservesType = false
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/TwoStepAggregator.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/TwoStepAggregator.kt
new file mode 100644
index 000000000..8ca4787be
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/TwoStepAggregator.kt
@@ -0,0 +1,27 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.impl.commonType
+import kotlin.reflect.KType
+
+internal class TwoStepAggregator<C, R>(
+    name: String,
+    aggregateWithType: (Iterable<C>, KType) -> R?,
+    private val aggregateValues: (Iterable<R>, KType) -> R?,
+    override val preservesType: Boolean
+) : AggregatorBase<C, R>(name, aggregateWithType) {
+
+    override fun aggregate(columns: Iterable<DataColumn<C?>>): R? {
+        val columnValues = columns.mapNotNull { aggregate(it) }
+        val commonType = columnValues.map { it.javaClass.kotlin }.commonType(false)
+        return aggregateValues(columnValues, commonType)
+    }
+
+    class Factory<C, R>(
+        private val aggregateWithType: (Iterable<C>, KType) -> R?,
+        private val aggregateValues: (Iterable<R>, KType) -> R?,
+        private val preservesType: Boolean
+    ) : AggregatorProvider<C, R> {
+        override fun create(name: String) = TwoStepAggregator(name, aggregateWithType, aggregateValues, preservesType)
+    }
+}
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
new file mode 100644
index 000000000..c24866120
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/getColumns.kt
@@ -0,0 +1,25 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.aggregation.Aggregatable
+import org.jetbrains.kotlinx.dataframe.aggregation.NamedValue
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.isComparable
+import org.jetbrains.kotlinx.dataframe.api.isNumber
+import org.jetbrains.kotlinx.dataframe.impl.columns.guessColumnType
+
+internal inline fun <T> Aggregatable<T>.remainingColumns(crossinline predicate: (AnyCol) -> Boolean): ColumnsSelector<T, Any?> =
+    remainingColumnsSelector().filter { predicate(it.data) }
+
+internal fun <T> Aggregatable<T>.comparableColumns() = remainingColumns { it.isComparable() } as ColumnsSelector<T, Comparable<Any?>>
+
+internal fun <T> Aggregatable<T>.numberColumns() = remainingColumns { it.isNumber() } as ColumnsSelector<T, Number?>
+
+internal fun NamedValue.toColumnWithPath() = path to guessColumnType(
+    path.last(),
+    listOf(value),
+    type,
+    guessType,
+    default
+)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/aggregateBy.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/aggregateBy.kt
new file mode 100644
index 000000000..3344b2121
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/aggregateBy.kt
@@ -0,0 +1,23 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.modes
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataFrameExpression
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.GroupBy
+import org.jetbrains.kotlinx.dataframe.api.Grouped
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregateInternal
+import org.jetbrains.kotlinx.dataframe.impl.namedValues
+
+internal fun <T> Grouped<T>.aggregateBy(
+    body: DataFrameExpression<T, DataRow<T>?>
+): DataFrame<T> {
+    require(this is GroupBy<*, T>)
+    val keyColumns = keys.columnNames().toSet()
+    return aggregateInternal {
+        val row = body(df, df)
+        row?.namedValues()?.forEach {
+            if (!keyColumns.contains(it.name)) yield(it)
+        }
+    }.cast()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/forEveryColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/forEveryColumn.kt
new file mode 100644
index 000000000..a49509083
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/forEveryColumn.kt
@@ -0,0 +1,51 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.modes
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.aggregation.ColumnsForAggregateSelector
+import org.jetbrains.kotlinx.dataframe.api.Grouped
+import org.jetbrains.kotlinx.dataframe.api.PivotGroupBy
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregateInternal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregator
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.getAggregateColumns
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.getPath
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.internal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.AggregateInternalDsl
+import org.jetbrains.kotlinx.dataframe.type
+
+internal fun <T, C, R> Aggregator<*, R>.aggregateFor(
+    data: Grouped<T>,
+    columns: ColumnsForAggregateSelector<T, C?>
+): DataFrame<T> = data.aggregateInternal {
+    aggregateFor(columns, cast())
+}
+
+internal fun <T, C, R> Aggregator<*, R>.aggregateFor(
+    data: PivotGroupBy<T>,
+    separate: Boolean,
+    columns: ColumnsForAggregateSelector<T, C?>
+): DataFrame<T> = data.aggregate(separate) {
+    internal().aggregateFor(columns, cast())
+}
+
+internal fun <T, C, R> Aggregator<*, R>.aggregateFor(
+    data: DataFrame<T>,
+    columns: ColumnsForAggregateSelector<T, C?>
+): DataRow<T> = data.aggregate {
+    internal().aggregateFor(columns, cast())
+}
+
+internal fun <T, C, R> AggregateInternalDsl<T>.aggregateFor(
+    columns: ColumnsForAggregateSelector<T, C>,
+    aggregator: Aggregator<C, R>
+) {
+    val cols = df.getAggregateColumns(columns)
+    val isSingle = cols.size == 1
+    cols.forEach { col ->
+        val path = getPath(col, isSingle)
+        val value = aggregator.aggregate(col.data)
+        val inferType = !aggregator.preservesType
+        yield(path, value, col.type, col.default, inferType)
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/noAggregation.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/noAggregation.kt
new file mode 100644
index 000000000..71c0fe5c2
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/noAggregation.kt
@@ -0,0 +1,17 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.modes
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateBody
+import org.jetbrains.kotlinx.dataframe.api.Grouped
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregateInternal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.internal
+
+@PublishedApi
+internal fun <T, R> Grouped<T>.aggregateValue(
+    resultName: String,
+    body: AggregateBody<T, R>
+): DataFrame<T> = aggregateInternal {
+    val value = body.internal()(this)
+    yield(pathOf(resultName), value)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/ofRowExpression.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/ofRowExpression.kt
new file mode 100644
index 000000000..0a0c88b72
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/ofRowExpression.kt
@@ -0,0 +1,89 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.modes
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateBody
+import org.jetbrains.kotlinx.dataframe.api.Grouped
+import org.jetbrains.kotlinx.dataframe.api.PivotGroupBy
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregateInternal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregator
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.internal
+import org.jetbrains.kotlinx.dataframe.impl.emptyPath
+import kotlin.reflect.typeOf
+
+@PublishedApi
+internal inline fun <C, reified V, R> Aggregator<V, R>.aggregateOf(
+    values: Iterable<C>,
+    noinline transform: (C) -> V
+): R? = aggregate(values.asSequence().map(transform).asIterable(), typeOf<V>())
+
+@PublishedApi
+internal inline fun <C, reified V, R> Aggregator<V, R>.aggregateOf(
+    column: DataColumn<C>,
+    noinline transform: (C) -> V
+): R? = aggregateOf(column.values(), transform)
+
+@PublishedApi
+internal inline fun <T, reified C, R> Aggregator<*, R>.aggregateOf(
+    frame: DataFrame<T>,
+    crossinline expression: RowExpression<T, C>
+): R? = (this as Aggregator<C, R>).aggregateOf(frame.rows()) { expression(it, it) } // TODO: inline
+
+@PublishedApi
+internal fun <T, C, R> Aggregator<*, R>.aggregateOfDelegated(
+    frame: Grouped<T>,
+    name: String?,
+    body: AggregateBody<T, C>
+): DataFrame<T> = frame.aggregateValue(name ?: this.name) {
+    body(this, this)
+}
+
+@PublishedApi
+internal inline fun <T, reified C, R> Aggregator<*, R>.of(
+    data: DataFrame<T>,
+    crossinline expression: RowExpression<T, C>
+): R? = aggregateOf(data as DataFrame<T>, expression)
+
+@PublishedApi
+internal inline fun <C, reified V, R> Aggregator<V, R>.of(
+    data: DataColumn<C>,
+    crossinline expression: (C) -> V
+): R? = aggregateOf(data.values()) { expression(it) } // TODO: inline
+
+@PublishedApi
+internal inline fun <T, reified C, reified R> Aggregator<*, R>.aggregateOf(
+    data: Grouped<T>,
+    resultName: String? = null,
+    crossinline expression: RowExpression<T, C>
+): DataFrame<T> = data.aggregateOf(resultName, expression, this as Aggregator<C, R>)
+
+@PublishedApi
+internal inline fun <T, reified C, reified R> Aggregator<*, R>.aggregateOf(
+    data: PivotGroupBy<T>,
+    crossinline expression: RowExpression<T, C>
+): DataFrame<T> = data.aggregateOf(expression, this as Aggregator<C, R>)
+
+@PublishedApi
+internal inline fun <T, reified C, reified R> Grouped<T>.aggregateOf(
+    resultName: String?,
+    crossinline expression: RowExpression<T, C>,
+    aggregator: Aggregator<C, R>
+): DataFrame<T> {
+    val path = pathOf(resultName ?: aggregator.name)
+    val type = typeOf<R>()
+    return aggregateInternal {
+        val value = aggregator.aggregateOf(df, expression)
+        yield(path, value, type, null, false)
+    }
+}
+
+@PublishedApi
+internal inline fun <T, reified C, R> PivotGroupBy<T>.aggregateOf(
+    crossinline expression: RowExpression<T, C>,
+    aggregator: Aggregator<C, R>
+): DataFrame<T> = aggregate {
+    internal().yield(emptyPath(), aggregator.aggregateOf(this, expression))
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/withinAllColumns.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/withinAllColumns.kt
new file mode 100644
index 000000000..ac3d6de42
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/withinAllColumns.kt
@@ -0,0 +1,60 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.modes
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.Grouped
+import org.jetbrains.kotlinx.dataframe.api.PivotGroupBy
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregateInternal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregator
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast2
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.internal
+import org.jetbrains.kotlinx.dataframe.impl.emptyPath
+
+@PublishedApi
+internal fun <T, C, R> Aggregator<*, R>.aggregateAll(
+    data: DataFrame<T>,
+    columns: ColumnsSelector<T, C>
+): R? = data.aggregateAll(cast2(), columns)
+
+internal fun <T, R, C> Aggregator<*, R>.aggregateAll(
+    data: Grouped<T>,
+    name: String?,
+    columns: ColumnsSelector<T, C>
+): DataFrame<T> = data.aggregateAll(cast(), columns, name)
+
+internal fun <T, R, C> Aggregator<*, R>.aggregateAll(
+    data: PivotGroupBy<T>,
+    columns: ColumnsSelector<T, C>
+): DataFrame<T> = data.aggregateAll(cast(), columns)
+
+internal fun <T, C, R> DataFrame<T>.aggregateAll(
+    aggregator: Aggregator<C, R>,
+    columns: ColumnsSelector<T, C?>
+): R? = aggregator.aggregate(get(columns))
+
+internal fun <T, C, R> Grouped<T>.aggregateAll(
+    aggregator: Aggregator<C, R>,
+    columns: ColumnsSelector<T, C>,
+    name: String?
+): DataFrame<T> = aggregateInternal {
+    val cols = df[columns]
+    if (cols.size == 1) {
+        yield(pathOf(name ?: cols[0].name()), aggregator.aggregate(cols[0]))
+    } else {
+        yield(pathOf(name ?: aggregator.name), aggregator.aggregate(cols))
+    }
+}
+
+internal fun <T, C, R> PivotGroupBy<T>.aggregateAll(
+    aggregator: Aggregator<C, R>,
+    columns: ColumnsSelector<T, C>
+): DataFrame<T> = aggregate {
+    val cols = get(columns)
+    if (cols.size == 1) {
+        internal().yield(emptyPath(), aggregator.aggregate(cols[0]))
+    } else {
+        internal().yield(emptyPath(), aggregator.aggregate(cols))
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/receivers/AggregateInternalDsl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/receivers/AggregateInternalDsl.kt
new file mode 100644
index 000000000..2f5a4d3fc
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/receivers/AggregateInternalDsl.kt
@@ -0,0 +1,36 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateBody
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateDsl
+import org.jetbrains.kotlinx.dataframe.aggregation.NamedValue
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import kotlin.reflect.KType
+
+@PublishedApi
+internal interface AggregateInternalDsl<out T> {
+
+    val df: DataFrame<T>
+
+    val hasGroupingKeys: Boolean
+
+    fun yield(value: NamedValue): NamedValue
+
+    fun <R> yield(path: ColumnPath, value: R, type: KType?, default: R?, guessType: Boolean) =
+        yield(NamedValue.create(path, value, type, default, guessType))
+
+    fun <R> yield(path: ColumnPath, value: R, type: KType? = null, default: R? = null): NamedValue
+
+    fun pathForSingleColumn(column: AnyCol): ColumnPath
+}
+
+@PublishedApi
+internal fun <T> AggregateDsl<T>.internal(): AggregateInternalDsl<T> = this as AggregateInternalDsl<T>
+
+internal fun <T, R> AggregateBodyInternal<T, R>.public() = this as AggregateBody<T, R>
+
+internal fun <T, R> AggregateBody<T, R>.internal() = this as AggregateBodyInternal<T, R>
+
+internal typealias AggregateBodyInternal<T, R> = Selector<AggregateInternalDsl<T>, R>
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/receivers/AggregatePivotDslImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/receivers/AggregatePivotDslImpl.kt
new file mode 100644
index 000000000..1ce0b7dd7
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/receivers/AggregatePivotDslImpl.kt
@@ -0,0 +1,24 @@
+package org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateDsl
+import org.jetbrains.kotlinx.dataframe.aggregation.NamedValue
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.AggregatableInternal
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.internal
+import org.jetbrains.kotlinx.dataframe.impl.emptyPath
+import kotlin.reflect.KType
+
+internal class AggregatePivotDslImpl<T>(override val df: DataFrame<T>) : AggregateDsl<T>(), AggregateInternalDsl<T>, DataFrame<T> by df, AggregatableInternal<T> by df.internal() {
+
+    internal val values = mutableListOf<NamedValue>()
+
+    override fun yield(value: NamedValue) = value.also { values.add(it) }
+
+    override fun pathForSingleColumn(column: AnyCol) = emptyPath()
+
+    override fun <R> yield(path: ColumnPath, value: R, type: KType?, default: R?) = yield(path, value, type, default, true)
+
+    override val hasGroupingKeys: Boolean get() = false
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/concat.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/concat.kt
new file mode 100644
index 000000000..ec03eb887
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/concat.kt
@@ -0,0 +1,91 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import com.beust.klaxon.internal.firstNotNullResult
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.asDataColumn
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.emptyDataFrame
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.hasNulls
+import org.jetbrains.kotlinx.dataframe.impl.columns.guessColumnType
+import org.jetbrains.kotlinx.dataframe.impl.commonType
+import org.jetbrains.kotlinx.dataframe.impl.getListType
+import org.jetbrains.kotlinx.dataframe.nrow
+import kotlin.reflect.KType
+import kotlin.reflect.full.withNullability
+
+internal fun <T> concatImpl(name: String, columns: List<DataColumn<T>>): DataColumn<T> =
+    concatImpl(name, columns, columns.map { it.size() })
+
+internal fun <T> concatImpl(name: String, columns: List<DataColumn<T>?>, columnSizes: List<Int>): DataColumn<T> {
+    when (columns.size) {
+        0 -> return DataColumn.empty(name).cast()
+        1 -> return columns[0] ?: DataColumn.empty(name).cast()
+    }
+
+    if (columns.all { it == null || it.isColumnGroup() }) {
+        val frames = columns.mapIndexed { index, col ->
+            col?.asColumnGroup() ?: DataFrame.empty(columnSizes[index])
+        }
+        val merged = concatImpl(frames)
+        return DataColumn.createColumnGroup(name, merged).asDataColumn().cast()
+    } else {
+        var nulls = false
+        val types = mutableSetOf<KType>()
+        var listOfNullable = false
+        val defaultValue = columns.firstNotNullResult { it?.defaultValue() }
+        var hasList = false
+        val list = columns.flatMapIndexed { index, col ->
+            if (col != null) {
+                val type = col.type()
+                if (type.classifier == List::class) {
+                    val typeArgument = type.arguments[0].type
+                    if (typeArgument != null) {
+                        types.add(typeArgument)
+                        if (!listOfNullable) listOfNullable = typeArgument.isMarkedNullable
+                        hasList = true
+                    }
+                } else {
+                    types.add(type)
+                    if (!nulls) nulls = col.hasNulls
+                }
+                col.toList()
+            } else {
+                val nrow = columnSizes[index]
+                if (!nulls && nrow > 0 && defaultValue == null) nulls = true
+                List(nrow) { defaultValue }
+            }
+        }
+
+        val guessType = types.size > 1
+        val baseType = types.commonType()
+        val tartypeOf = if (guessType || !hasList) baseType.withNullability(nulls)
+        else getListType(baseType.withNullability(listOfNullable))
+        return guessColumnType(name, list, tartypeOf, guessType, defaultValue).cast()
+    }
+}
+
+internal fun <T> concatImpl(dataFrames: List<DataFrame<T>>): DataFrame<T> {
+    when (dataFrames.size) {
+        0 -> return emptyDataFrame()
+        1 -> return dataFrames[0]
+    }
+
+    // collect column names preserving original order
+    val columnNames = dataFrames
+        .fold(emptyList<String>()) { acc, df -> acc + (df.columnNames() - acc) }
+
+    val sizes = dataFrames.map { it.nrow }
+    val columns = columnNames.map { name ->
+        concatImpl(name, dataFrames.map { it.getColumnOrNull(name) }, sizes)
+    }
+    return if (columns.isEmpty()) {
+        // make sure the number of rows translate correctly if there are no columns
+        DataFrame.empty(nrow = sizes.sum())
+    } else {
+        dataFrameOf(columns)
+    }.cast()
+}
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
new file mode 100644
index 000000000..6c304bde8
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convert.kt
@@ -0,0 +1,446 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import kotlinx.datetime.Instant
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.atTime
+import kotlinx.datetime.toInstant
+import kotlinx.datetime.toJavaInstant
+import kotlinx.datetime.toJavaLocalDate
+import kotlinx.datetime.toJavaLocalDateTime
+import kotlinx.datetime.toKotlinInstant
+import kotlinx.datetime.toKotlinLocalDate
+import kotlinx.datetime.toKotlinLocalDateTime
+import kotlinx.datetime.toLocalDateTime
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.RowColumnExpression
+import org.jetbrains.kotlinx.dataframe.RowValueExpression
+import org.jetbrains.kotlinx.dataframe.api.Convert
+import org.jetbrains.kotlinx.dataframe.api.DataSchemaEnum
+import org.jetbrains.kotlinx.dataframe.api.Infer
+import org.jetbrains.kotlinx.dataframe.api.ParserOptions
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.to
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.dataTypes.IFRAME
+import org.jetbrains.kotlinx.dataframe.dataTypes.IMG
+import org.jetbrains.kotlinx.dataframe.exceptions.CellConversionException
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConversionException
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConverterNotFoundException
+import org.jetbrains.kotlinx.dataframe.impl.columns.DataColumnInternal
+import org.jetbrains.kotlinx.dataframe.impl.columns.newColumn
+import org.jetbrains.kotlinx.dataframe.impl.createStarProjectedType
+import org.jetbrains.kotlinx.dataframe.path
+import org.jetbrains.kotlinx.dataframe.type
+import java.math.BigDecimal
+import java.net.URL
+import java.time.LocalTime
+import java.util.Locale
+import kotlin.math.roundToInt
+import kotlin.math.roundToLong
+import kotlin.reflect.KType
+import kotlin.reflect.full.isSubclassOf
+import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.full.primaryConstructor
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.jvm.jvmErasure
+
+@PublishedApi
+internal fun <T, C, R> Convert<T, C>.withRowCellImpl(
+    type: KType,
+    infer: Infer,
+    rowConverter: RowValueExpression<T, C, R>,
+): DataFrame<T> =
+    to { col -> df.newColumn(type, col.name, infer) { rowConverter(it, it[col]) } }
+
+@PublishedApi
+internal fun <T, C, R> Convert<T, C>.convertRowColumnImpl(
+    type: KType,
+    infer: Infer,
+    rowConverter: RowColumnExpression<T, C, R>,
+): DataFrame<T> =
+    to { col -> df.newColumn(type, col.name, infer) { rowConverter(it, col) } }
+
+internal fun AnyCol.convertToTypeImpl(to: KType): AnyCol {
+    val from = type
+
+    val nullsAreAllowed = to.isMarkedNullable
+
+    var nullsFound = false
+
+    fun Any?.checkNulls() = when {
+        this != null -> this
+        nullsAreAllowed -> {
+            nullsFound = true
+            null
+        }
+        else -> throw TypeConversionException(null, from, to, path)
+    }
+
+    fun applyConverter(converter: TypeConverter): AnyCol {
+        var currentRow = 0
+        try {
+            val values = values.mapIndexed { row, value ->
+                currentRow = row
+                value?.let { converter(value) }.checkNulls()
+            }
+            return DataColumn.createValueColumn(name, values, to.withNullability(nullsFound))
+        } catch (e: TypeConversionException) {
+            throw CellConversionException(e.value, e.from, e.to, path, currentRow, e)
+        }
+    }
+
+    fun convertPerCell(): AnyCol {
+        var currentRow = 0
+        try {
+            return when (from.classifier) {
+                Any::class, Comparable::class, Number::class, java.io.Serializable::class -> {
+                    // 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()
+                    }
+                    DataColumn.createValueColumn(name, values, to.withNullability(nullsFound))
+                }
+                else -> throw TypeConverterNotFoundException(from, to, path)
+            }
+        } catch (e: TypeConversionException) {
+            throw CellConversionException(e.value, e.from, e.to, path, currentRow, e)
+        }
+    }
+
+    if (from == to) return this
+
+    // catch for ColumnGroup and FrameColumn since they don't have changeType,
+    // but user converters can still exist
+    if (from.isSubtypeOf(to)) try {
+        return (this as DataColumnInternal<*>).changeType(to.withNullability(hasNulls()))
+    } catch (_: UnsupportedOperationException) { /* */
+    }
+
+    return when (val converter = getConverter(from, to, ParserOptions(locale = Locale.getDefault()))) {
+        null -> convertPerCell()
+        else -> applyConverter(converter)
+    }
+}
+
+internal val convertersCache = mutableMapOf<Triple<KType, KType, ParserOptions?>, TypeConverter?>()
+
+internal fun getConverter(from: KType, to: KType, options: ParserOptions? = null): TypeConverter? =
+    convertersCache.getOrPut(Triple(from, to, options)) { createConverter(from, to, options) }
+
+internal typealias TypeConverter = (Any) -> Any?
+
+internal fun Any.convertTo(type: KType): Any? {
+    val clazz = javaClass.kotlin
+    if (clazz.isSubclassOf(type.jvmErasure)) return this
+    val from = clazz.createStarProjectedType(false)
+    val converter = getConverter(from, type) ?: throw TypeConverterNotFoundException(from, type, null)
+    return converter(this)
+}
+
+internal inline fun <T> convert(crossinline converter: (T) -> Any?): TypeConverter = { converter(it as T) }
+
+private enum class DummyEnum
+
+internal fun createConverter(from: KType, to: KType, options: ParserOptions? = null): TypeConverter? {
+    if (from.arguments.isNotEmpty() || to.arguments.isNotEmpty()) return null
+    if (from.isMarkedNullable) {
+        val res = createConverter(from.withNullability(false), to, options) ?: return null
+        return { res(it) }
+    }
+    val fromClass = from.jvmErasure
+    val toClass = to.jvmErasure
+
+    if (fromClass == toClass) return { it }
+
+    if (toClass.isValue) {
+        val constructor =
+            toClass.primaryConstructor ?: error("Value type $toClass doesn't have primary constructor")
+        val underlyingType = constructor.parameters.single().type
+        val converter = getConverter(from, underlyingType)
+            ?: throw TypeConverterNotFoundException(from, underlyingType, null)
+        return convert<Any> {
+            val converted = converter(it)
+            if (converted == null && !underlyingType.isMarkedNullable) {
+                throw TypeConversionException(it, from, underlyingType, null)
+            }
+            constructor.call(converted)
+        }
+    }
+
+    return when {
+        fromClass == String::class -> {
+            val parser = Parsers[to.withNullability(false)]
+            when {
+                parser != null -> parser.toConverter(options)
+
+                // convert enums by name (or by `value` if they implement DataSchemaEnum)
+                toClass.isSubclassOf(Enum::class) -> convert<String> { string ->
+                    if (toClass.isSubclassOf(DataSchemaEnum::class)) {
+                        val enumValues = toClass.java.enumConstants as Array<out DataSchemaEnum>
+                        enumValues.firstOrNull { it.value == string }
+                            ?: java.lang.Enum.valueOf(toClass.java as Class<DummyEnum>, string)
+                    } else {
+                        java.lang.Enum.valueOf(toClass.java as Class<DummyEnum>, string)
+                    }
+                }
+
+                else -> null
+            }
+        }
+
+        toClass == String::class -> convert<Any> {
+            when {
+                // convert enums to String by `value` if they implement DataSchemaEnum
+                fromClass.isSubclassOf(DataSchemaEnum::class) ->
+                    (it as? DataSchemaEnum?)?.value ?: it.toString()
+
+                else -> it.toString()
+            }
+        }
+
+        fromClass.isValue -> {
+            val constructor =
+                fromClass.primaryConstructor ?: error("Value type $fromClass doesn't have primary constructor")
+            val constructorParameter = constructor.parameters.single()
+            val underlyingType = constructorParameter.type
+            val converter = getConverter(underlyingType, to)
+                ?: throw TypeConverterNotFoundException(underlyingType, to, null)
+            val property =
+                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",
+                    from,
+                    to,
+                    null
+                )
+            }
+
+            convert<Any> {
+                property.get(it)?.let {
+                    converter(it)
+                }
+            }
+        }
+
+        else -> when (fromClass) {
+            Boolean::class -> when (toClass) {
+                Float::class -> convert<Boolean> { if (it) 1.0f else 0.0f }
+                Double::class -> convert<Boolean> { if (it) 1.0 else 0.0 }
+                Int::class -> convert<Boolean> { if (it) 1 else 0 }
+                Long::class -> convert<Boolean> { if (it) 1L else 0L }
+                Short::class -> convert<Boolean> {
+                    val one: Short = 1
+                    val zero: Short = 0
+                    if (it) one else zero
+                }
+
+                Byte::class -> convert<Boolean> {
+                    val one: Byte = 1
+                    val zero: Byte = 0
+                    if (it) one else zero
+                }
+
+                BigDecimal::class -> convert<Boolean> { if (it) BigDecimal.ONE else BigDecimal.ZERO }
+                else -> null
+            }
+
+            Number::class -> when (toClass) {
+                Double::class -> convert<Number> { it.toDouble() }
+                Int::class -> convert<Number> { it.toInt() }
+                Float::class -> convert<Number> { it.toFloat() }
+                Byte::class -> convert<Number> { it.toByte() }
+                Short::class -> convert<Number> { it.toShort() }
+                Long::class -> convert<Number> { it.toLong() }
+                Boolean::class -> convert<Number> { it.toDouble() != 0.0 }
+                else -> null
+            }
+
+            Int::class -> when (toClass) {
+                Double::class -> convert<Int> { it.toDouble() }
+                Float::class -> convert<Int> { it.toFloat() }
+                Byte::class -> convert<Int> { it.toByte() }
+                Short::class -> convert<Int> { it.toShort() }
+                Long::class -> convert<Int> { it.toLong() }
+                BigDecimal::class -> convert<Int> { it.toBigDecimal() }
+                Boolean::class -> convert<Int> { it != 0 }
+                LocalDateTime::class -> convert<Int> { it.toLong().toLocalDateTime(defaultTimeZone) }
+                LocalDate::class -> convert<Int> { it.toLong().toLocalDate(defaultTimeZone) }
+                java.time.LocalDateTime::class -> convert<Long> {
+                    it.toLocalDateTime(defaultTimeZone).toJavaLocalDateTime()
+                }
+
+                java.time.LocalDate::class -> convert<Long> { it.toLocalDate(defaultTimeZone).toJavaLocalDate() }
+                LocalTime::class -> convert<Int> { it.toLong().toLocalTime(defaultTimeZone) }
+                else -> null
+            }
+
+            Double::class -> when (toClass) {
+                Int::class -> convert<Double> { it.roundToInt() }
+                Float::class -> convert<Double> { it.toFloat() }
+                Long::class -> convert<Double> { it.roundToLong() }
+                Short::class -> convert<Double> { it.roundToInt().toShort() }
+                BigDecimal::class -> convert<Double> { it.toBigDecimal() }
+                Boolean::class -> convert<Double> { it != 0.0 }
+                else -> null
+            }
+
+            Long::class -> when (toClass) {
+                Double::class -> convert<Long> { it.toDouble() }
+                Float::class -> convert<Long> { it.toFloat() }
+                Byte::class -> convert<Long> { it.toByte() }
+                Short::class -> convert<Long> { it.toShort() }
+                Int::class -> convert<Long> { it.toInt() }
+                BigDecimal::class -> convert<Long> { it.toBigDecimal() }
+                Boolean::class -> convert<Long> { it != 0L }
+                LocalDateTime::class -> convert<Long> { it.toLocalDateTime(defaultTimeZone) }
+                LocalDate::class -> convert<Long> { it.toLocalDate(defaultTimeZone) }
+                Instant::class -> convert<Long> { Instant.fromEpochMilliseconds(it) }
+                java.time.LocalDateTime::class -> convert<Long> {
+                    it.toLocalDateTime(defaultTimeZone).toJavaLocalDateTime()
+                }
+
+                java.time.LocalDate::class -> convert<Long> { it.toLocalDate(defaultTimeZone).toJavaLocalDate() }
+                LocalTime::class -> convert<Long> { it.toLocalTime(defaultTimeZone) }
+                else -> null
+            }
+
+            Instant::class -> when (toClass) {
+                Long::class -> convert<Instant> { it.toEpochMilliseconds() }
+                LocalDateTime::class -> convert<Instant> { it.toLocalDateTime(defaultTimeZone) }
+                LocalDate::class -> convert<Instant> { it.toLocalDate(defaultTimeZone) }
+                java.time.LocalDateTime::class -> convert<Instant> {
+                    it.toLocalDateTime(defaultTimeZone).toJavaLocalDateTime()
+                }
+
+                java.time.LocalDate::class -> convert<Instant> { it.toLocalDate(defaultTimeZone).toJavaLocalDate() }
+                java.time.Instant::class -> convert<Instant> { it.toJavaInstant() }
+                LocalTime::class -> convert<Instant> { it.toLocalTime(defaultTimeZone) }
+                else -> null
+            }
+
+            java.time.Instant::class -> when (toClass) {
+                Long::class -> convert<java.time.Instant> { it.toEpochMilli() }
+                LocalDateTime::class -> convert<java.time.Instant> {
+                    it.toKotlinInstant().toLocalDateTime(defaultTimeZone)
+                }
+
+                LocalDate::class -> convert<java.time.Instant> { it.toKotlinInstant().toLocalDate(defaultTimeZone) }
+                java.time.LocalDateTime::class -> convert<java.time.Instant> {
+                    it.toKotlinInstant().toLocalDateTime(defaultTimeZone).toJavaLocalDateTime()
+                }
+
+                java.time.LocalDate::class -> convert<java.time.Instant> {
+                    it.toKotlinInstant().toLocalDate(defaultTimeZone).toJavaLocalDate()
+                }
+
+                Instant::class -> convert<java.time.Instant> { it.toKotlinInstant() }
+                LocalTime::class -> convert<java.time.Instant> { it.toKotlinInstant().toLocalTime(defaultTimeZone) }
+                else -> null
+            }
+
+            Float::class -> when (toClass) {
+                Double::class -> convert<Float> { it.toDouble() }
+                Long::class -> convert<Float> { it.roundToLong() }
+                Int::class -> convert<Float> { it.roundToInt() }
+                Short::class -> convert<Float> { it.roundToInt().toShort() }
+                BigDecimal::class -> convert<Float> { it.toBigDecimal() }
+                Boolean::class -> convert<Float> { it != 0.0F }
+                else -> null
+            }
+
+            BigDecimal::class -> when (toClass) {
+                Double::class -> convert<BigDecimal> { it.toDouble() }
+                Int::class -> convert<BigDecimal> { it.toInt() }
+                Float::class -> convert<BigDecimal> { it.toFloat() }
+                Long::class -> convert<BigDecimal> { it.toLong() }
+                Boolean::class -> convert<BigDecimal> { it != BigDecimal.ZERO }
+                else -> null
+            }
+
+            LocalDateTime::class -> when (toClass) {
+                LocalDate::class -> convert<LocalDateTime> { it.date }
+                Instant::class -> convert<LocalDateTime> { it.toInstant(defaultTimeZone) }
+                Long::class -> convert<LocalDateTime> { it.toInstant(defaultTimeZone).toEpochMilliseconds() }
+                java.time.LocalDateTime::class -> convert<LocalDateTime> { it.toJavaLocalDateTime() }
+                java.time.LocalDate::class -> convert<LocalDateTime> { it.date.toJavaLocalDate() }
+                java.time.LocalTime::class -> convert<LocalDateTime> { it.toJavaLocalDateTime().toLocalTime() }
+                else -> null
+            }
+
+            java.time.LocalDateTime::class -> when (toClass) {
+                LocalDate::class -> convert<java.time.LocalDateTime> { it.toKotlinLocalDateTime().date }
+                LocalDateTime::class -> convert<java.time.LocalDateTime> { it.toKotlinLocalDateTime() }
+                Instant::class -> convert<java.time.LocalDateTime> {
+                    it.toKotlinLocalDateTime().toInstant(defaultTimeZone)
+                }
+
+                Long::class -> convert<java.time.LocalDateTime> {
+                    it.toKotlinLocalDateTime().toInstant(defaultTimeZone).toEpochMilliseconds()
+                }
+
+                java.time.LocalDate::class -> convert<java.time.LocalDateTime> { it.toLocalDate() }
+                java.time.LocalTime::class -> convert<java.time.LocalDateTime> { it.toLocalTime() }
+                else -> null
+            }
+
+            LocalDate::class -> when (toClass) {
+                LocalDateTime::class -> convert<LocalDate> { it.atTime(0, 0) }
+                Instant::class -> convert<LocalDate> { it.atStartOfDayIn(defaultTimeZone) }
+                Long::class -> convert<LocalDate> { it.atStartOfDayIn(defaultTimeZone).toEpochMilliseconds() }
+                java.time.LocalDate::class -> convert<LocalDate> { it.toJavaLocalDate() }
+                java.time.LocalDateTime::class -> convert<LocalDate> { it.atTime(0, 0).toJavaLocalDateTime() }
+                else -> null
+            }
+
+            java.time.LocalDate::class -> when (toClass) {
+                LocalDate::class -> convert<java.time.LocalDate> { it.toKotlinLocalDate() }
+                LocalDateTime::class -> convert<java.time.LocalDate> { it.atTime(0, 0).toKotlinLocalDateTime() }
+                Instant::class -> convert<java.time.LocalDate> {
+                    it.toKotlinLocalDate().atStartOfDayIn(defaultTimeZone)
+                }
+
+                Long::class -> convert<java.time.LocalDate> {
+                    it.toKotlinLocalDate().atStartOfDayIn(defaultTimeZone).toEpochMilliseconds()
+                }
+
+                java.time.LocalDateTime::class -> convert<java.time.LocalDate> { it.atStartOfDay() }
+                else -> null
+            }
+
+            URL::class -> when (toClass) {
+                IMG::class -> convert<URL> { IMG(it.toString()) }
+                IFRAME::class -> convert<URL> { IFRAME(it.toString()) }
+                else -> null
+            }
+
+            else -> null
+        }
+    }
+}
+
+internal fun Long.toLocalDateTime(zone: TimeZone = defaultTimeZone) =
+    Instant.fromEpochMilliseconds(this).toLocalDateTime(zone)
+
+internal fun Long.toLocalDate(zone: TimeZone = defaultTimeZone) = toLocalDateTime(zone).date
+internal fun Long.toLocalTime(zone: TimeZone = defaultTimeZone) =
+    toLocalDateTime(zone).toJavaLocalDateTime().toLocalTime()
+
+internal fun Instant.toLocalDate(zone: TimeZone = defaultTimeZone) = toLocalDateTime(zone).date
+internal fun Instant.toLocalTime(zone: TimeZone = defaultTimeZone) =
+    toLocalDateTime(zone).toJavaLocalDateTime().toLocalTime()
+
+internal val defaultTimeZone = TimeZone.currentSystemDefault()
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
new file mode 100644
index 000000000..e11e8bc0b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/convertTo.kt
@@ -0,0 +1,280 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.api.ConvertSchemaDsl
+import org.jetbrains.kotlinx.dataframe.api.ConverterScope
+import org.jetbrains.kotlinx.dataframe.api.ExcessiveColumns
+import org.jetbrains.kotlinx.dataframe.api.Infer
+import org.jetbrains.kotlinx.dataframe.api.all
+import org.jetbrains.kotlinx.dataframe.api.allNulls
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.convertTo
+import org.jetbrains.kotlinx.dataframe.api.emptyDataFrame
+import org.jetbrains.kotlinx.dataframe.api.getColumnPaths
+import org.jetbrains.kotlinx.dataframe.api.isEmpty
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.codeGen.MarkersExtractor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.exceptions.ExcessiveColumnsException
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConversionException
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.emptyPath
+import org.jetbrains.kotlinx.dataframe.impl.schema.createEmptyColumn
+import org.jetbrains.kotlinx.dataframe.impl.schema.createEmptyDataFrame
+import org.jetbrains.kotlinx.dataframe.impl.schema.extractSchema
+import org.jetbrains.kotlinx.dataframe.impl.schema.render
+import org.jetbrains.kotlinx.dataframe.kind
+import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import org.jetbrains.kotlinx.dataframe.size
+import kotlin.reflect.KType
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.jvm.jvmErasure
+
+private open class Converter(val transform: ConverterScope.(Any?) -> Any?, val skipNulls: Boolean)
+
+private class Filler(val columns: ColumnsSelector<*, *>, val expr: RowExpression<*, *>)
+
+internal interface ConvertSchemaDslInternal<T> : ConvertSchemaDsl<T> {
+    public fun <C> fill(columns: ColumnsSelector<*, C>, expr: RowExpression<*, C>)
+}
+
+private class ConvertSchemaDslImpl<T> : ConvertSchemaDslInternal<T> {
+    private val converters: MutableMap<Pair<KType, KType>, Converter> = mutableMapOf<Pair<KType, KType>, Converter>()
+
+    val fillers = mutableListOf<Filler>()
+
+    private val flexibleConverters: MutableMap<(KType, ColumnSchema) -> Boolean, Converter> = mutableMapOf()
+
+    @Suppress("UNCHECKED_CAST")
+    override fun <A, B> convert(from: KType, to: KType, converter: (A) -> B) {
+        converters[from.withNullability(false) to to.withNullability(false)] =
+            Converter({ converter(it as A) }, !from.isMarkedNullable)
+    }
+
+    override fun <C> fill(columns: ColumnsSelector<*, C>, expr: RowExpression<*, C>) {
+        fillers.add(Filler(columns, expr))
+    }
+
+    override fun convertIf(
+        condition: (KType, ColumnSchema) -> Boolean,
+        converter: ConverterScope.(Any?) -> Any?,
+    ) {
+        flexibleConverters[condition] = Converter(converter, false)
+    }
+
+    /**
+     * Attempts to find a converter for the given types. First it tries to find an exact match,
+     * then it tries to find a flexible match where the first one will be used.
+     */
+    fun getConverter(fromType: KType, toSchema: ColumnSchema): Converter? =
+        converters[fromType.withNullability(false) to toSchema.type.withNullability(false)]
+            ?: flexibleConverters
+                .entries
+                .firstOrNull { (predicate, _) ->
+                    predicate(fromType, toSchema)
+                }?.value
+}
+
+@PublishedApi
+internal fun AnyFrame.convertToImpl(
+    type: KType,
+    allowConversion: Boolean,
+    excessiveColumns: ExcessiveColumns,
+    body: ConvertSchemaDsl<Any>.() -> Unit = {},
+): AnyFrame {
+    val dsl = ConvertSchemaDslImpl<Any>()
+    dsl.body()
+
+    val missingPaths = mutableSetOf<ColumnPath>()
+
+    fun AnyFrame.convertToSchema(schema: DataFrameSchema, path: ColumnPath): AnyFrame {
+        // if current frame is empty
+        if (this.isEmpty()) {
+            return schema.createEmptyDataFrame()
+        }
+
+        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
+                }
+            } 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(
+                                    it,
+                                    from,
+                                    to,
+                                    originalColumn.path()
+                                )
+
+                                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,
+                                    ),
+                                )
+                            }
+
+                            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() }
+                                    }
+                                }
+
+                                val convertedFrames = frames.map { it.convertToSchema(frameSchema, columnPath)}
+
+                                DataColumn.createFrameColumn(
+                                    name = column.name(),
+                                    groups = convertedFrames,
+                                    schema = lazy { frameSchema },
+                                )
+                            }
+                        }
+                    }
+                }
+            }
+        }.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 =
+                targetColumn.nullable || // like value column of type Int?
+                    targetColumn.type.isMarkedNullable || // like value column of type Int? (backup check)
+                    targetColumn.contentType?.isMarkedNullable == true || // 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
+
+            if (name !in visited) {
+                newColumns += targetColumn.createEmptyColumn(name, size)
+                if (!isNullable) {
+                    missingPaths.add(path + name)
+                }
+            }
+        }
+        return newColumns.toDataFrame()
+    }
+
+    val clazz = type.jvmErasure
+    val marker = MarkersExtractor.get(clazz)
+    var result = convertToSchema(marker.schema, emptyPath())
+
+    dsl.fillers.forEach { filler ->
+        val paths = result.getColumnPaths(filler.columns)
+        missingPaths.removeAll(paths.toSet())
+        result = result.update { paths.toColumnSet() }.with {
+            filler.expr(this, this)
+        }
+    }
+
+    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")
+    }
+
+    return result
+}
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
new file mode 100644
index 000000000..2a3143be9
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/corr.kt
@@ -0,0 +1,75 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.Corr
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.castToNotNullable
+import org.jetbrains.kotlinx.dataframe.api.convertToDouble
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.isSuitableForCorr
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.toValueColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.math.varianceAndMean
+import org.jetbrains.kotlinx.dataframe.nrow
+import kotlin.math.sqrt
+
+internal fun <T, C, R> Corr<T, C>.corrImpl(otherColumns: ColumnsSelector<T, R>): DataFrame<T> {
+    val len = df.nrow
+
+    fun <P> List<ColumnWithPath<P>>.unpackColumnGroups() = flatMap {
+        // extract nested number columns from ColumnGroups
+        if (it.isColumnGroup()) {
+            val groupPath = it.path
+            df.getColumnsWithPaths { groupPath.dfs { it.isSuitableForCorr() } }.map { it.cast() }
+        } else listOf(it)
+    }
+
+    var cols1 = df.getColumnsWithPaths(columns)
+        .filter { it.isColumnGroup() || it.isSuitableForCorr() }
+
+    val cols2 = df.getColumnsWithPaths(otherColumns)
+        .filter { it.isColumnGroup() || it.isSuitableForCorr() }
+        .unpackColumnGroups()
+
+    val indexColumnName = if (cols1.size == 1 && cols1[0].isColumnGroup()) cols1[0].name else "column"
+    cols1 = cols1.unpackColumnGroups()
+
+    val index = cols1.map { it.name }.toValueColumn(indexColumnName)
+
+    val cols = cols1.associateTo(mutableMapOf()) { it.path to it.data.convertToDouble().castToNotNullable() }
+    cols2.forEach {
+        if (!cols.containsKey(it.path)) {
+            cols[it.path] = it.data.convertToDouble().castToNotNullable()
+        }
+    }
+
+    val stdMeans = cols.mapValues {
+        it.value.toList().varianceAndMean()
+    }
+
+    val cache = mutableMapOf<Pair<ColumnPath, ColumnPath>, Double>()
+
+    val newColumns = cols2.map { c2 ->
+        val values = cols1.map { c1 ->
+            val cachedValue = cache[c2.path to c1.path]
+            if (cachedValue != null) cachedValue
+            else {
+                val s1 = stdMeans[c1.path]!!
+                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)
+                cache[c1.path to c2.path] = res
+                res
+            }
+        }
+        values.toValueColumn(c2.name)
+    }
+
+    return dataFrameOf(listOf(index) + newColumns).cast()
+}
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
new file mode 100644
index 000000000..671480716
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/describe.kt
@@ -0,0 +1,76 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.ColumnDescription
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.after
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.asComparable
+import org.jetbrains.kotlinx.dataframe.api.asNumbers
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.isComparable
+import org.jetbrains.kotlinx.dataframe.api.isNumber
+import org.jetbrains.kotlinx.dataframe.api.maxOrNull
+import org.jetbrains.kotlinx.dataframe.api.mean
+import org.jetbrains.kotlinx.dataframe.api.medianOrNull
+import org.jetbrains.kotlinx.dataframe.api.minOrNull
+import org.jetbrains.kotlinx.dataframe.api.move
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.std
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.kind
+import org.jetbrains.kotlinx.dataframe.type
+import kotlin.reflect.jvm.jvmErasure
+
+internal fun describeImpl(cols: List<AnyCol>): DataFrame<ColumnDescription> {
+    fun List<AnyCol>.collectAll(dfs: Boolean): List<AnyCol> = flatMap { col ->
+        when (col.kind) {
+            ColumnKind.Frame -> col.asAnyFrameColumn().concat().columns().map {
+                it.addPath(col.path() + it.name)
+            }.collectAll(true)
+            ColumnKind.Group -> if (dfs) col.asColumnGroup().columns().map { it.addPath(col.path() + it.name) }.collectAll(true) else listOf(col)
+            ColumnKind.Value -> listOf(col)
+        }
+    }
+
+    val all = cols.collectAll(false)
+
+    val hasNumeric = all.any { it.isNumber() }
+    val hasComparable = all.any { it.isComparable() }
+    val hasLongPaths = all.any { it.path().size > 1 }
+    var df = all.toDataFrame {
+        ColumnDescription::name from { it.name() }
+        if (hasLongPaths) {
+            ColumnDescription::path from { it.path() }
+        }
+        ColumnDescription::type from { it.type.jvmErasure.simpleName }
+        ColumnDescription::count from { it.size }
+        ColumnDescription::unique from { it.countDistinct() }
+        ColumnDescription::nulls from { it.values.count { it == null } }
+        ColumnDescription::top from inferType { it.values.filterNotNull().groupBy { it }.maxByOrNull { it.value.size }?.key }
+        if (hasNumeric) {
+            ColumnDescription::mean from { if (it.isNumber()) it.asNumbers().mean() else null }
+            ColumnDescription::std from { if (it.isNumber()) it.asNumbers().std() else null }
+        }
+        if (hasComparable) {
+            ColumnDescription::min from inferType { if (it.isComparable()) it.asComparable().minOrNull() else null }
+            ColumnDescription::median from inferType { if (it.isComparable()) it.asComparable().medianOrNull() else null }
+            ColumnDescription::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)
+
+    return df.cast()
+}
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
new file mode 100644
index 000000000..a8b83b493
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/duplicate.kt
@@ -0,0 +1,73 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.asDataColumn
+import org.jetbrains.kotlinx.dataframe.api.asDataFrame
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.forEachIndexed
+import org.jetbrains.kotlinx.dataframe.api.isFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.impl.owner
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.type
+import kotlin.reflect.full.withNullability
+
+internal fun <T> DataFrame<T>.duplicateRowsImpl(n: Int): DataFrame<T> = columns().map { it.duplicateValuesImpl(n) }.toDataFrame().cast()
+
+internal fun <T> DataColumn<T>.duplicateValuesImpl(n: Int): DataColumn<T> {
+    require(n > 0)
+    return when (this) {
+        is ColumnGroup<*> -> DataColumn.createColumnGroup(
+            name,
+            asDataFrame().duplicateRowsImpl(n)
+        ).asDataColumn()
+        else -> {
+            val list = List(size() * n) { get(it / n) }
+            if (isFrameColumn()) DataColumn.createFrameColumn(name, list as List<AnyFrame>)
+            else DataColumn.createValueColumn(name, list, type, defaultValue = defaultValue())
+        }
+    }.cast()
+}
+
+internal fun <T> DataColumn<T>.duplicateValuesImpl(n: Int, indicesSorted: Iterable<Int>): DataColumn<T> = when (this) {
+    is ColumnGroup<*> -> DataColumn.createColumnGroup(
+        name,
+        asDataFrame().duplicateRowsImpl(n, indicesSorted)
+    ).asDataColumn()
+    else -> {
+        val list = mutableListOf<Any?>()
+        val iterator = indicesSorted.iterator()
+        var next = if (iterator.hasNext()) iterator.next() else -1
+        forEachIndexed { i, value ->
+            if (i == next) {
+                repeat(n) { list.add(value) }
+                next = if (iterator.hasNext()) iterator.next() else -1
+            } else list.add(value)
+        }
+        if (isFrameColumn()) DataColumn.createFrameColumn(name, list as List<AnyFrame>)
+        else DataColumn.createValueColumn(name, list, type, defaultValue = defaultValue())
+    }
+}.cast()
+
+internal fun <T> DataFrame<T>.duplicateRowsImpl(n: Int, indicesSorted: Iterable<Int>): DataFrame<T> = columns().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))
+        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()
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
new file mode 100644
index 000000000..9a5879de3
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/explode.kt
@@ -0,0 +1,110 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.appendNulls
+import org.jetbrains.kotlinx.dataframe.api.asSequence
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.api.isFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.createDataCollector
+import org.jetbrains.kotlinx.dataframe.indices
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.type
+
+internal fun AnyCol.explodeImpl(): AnyCol = dataFrameOf(this).explodeImpl(true) { all() }.getColumn(0)
+
+internal fun <T> DataFrame<T>.explodeImpl(dropEmpty: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T> {
+    val columns = getColumnsWithPaths(columns)
+    if (columns.isEmpty()) return this
+
+    val rowExpandSizes = indices.map { row ->
+        columns.maxOf {
+            val n = when (val value = it.data[row]) {
+                is AnyFrame -> value.nrow
+                is List<*> -> value.size
+                else -> 1
+            }
+            if (!dropEmpty && n == 0) 1
+            else n
+        }
+    }
+
+    val outputRowsCount = rowExpandSizes.sum()
+
+    fun splitIntoRows(df: AnyFrame, data: Map<ColumnPath, AnyCol>): AnyFrame {
+        val newColumns: List<AnyBaseCol> = df.columns().map { srcCol ->
+
+            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 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()
+
+                        DataColumn.createColumnGroup(dstCol.name, newDf)
+                    }
+                    is ValueColumn<*> -> {
+                        val collector = createDataCollector(outputRowsCount)
+                        dstCol.asSequence().forEachIndexed { rowIndex, value ->
+                            val list = valueToList(value, splitStrings = false)
+                            val expectedSize = rowExpandSizes[rowIndex]
+                            list.forEach { collector.add(it) }
+                            repeat(expectedSize - list.size) {
+                                collector.add(null)
+                            }
+                        }
+                        collector.toColumn(dstCol.name)
+                    }
+                    else -> error("")
+                }
+            } else { // values in current column will be duplicated
+                val collector = createDataCollector<Any?>(outputRowsCount, srcCol.type)
+                for (row in 0 until srcCol.size) {
+                    val expandSize = rowExpandSizes[row]
+                    if (expandSize > 0) {
+                        val value = srcCol[row]
+                        repeat(expandSize) {
+                            collector.add(value)
+                        }
+                    }
+                }
+                if (srcCol.isFrameColumn()) DataColumn.createFrameColumn(
+                    srcCol.name,
+                    collector.values as List<AnyFrame>,
+                    srcCol.asAnyFrameColumn().schema // keep original schema
+                )
+                else collector.toColumn(srcCol.name)
+            }
+        }
+        return newColumns.toDataFrame()
+    }
+
+    return splitIntoRows(this, columns.associate { it.path to it.data }).cast()
+}
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
new file mode 100644
index 000000000..4d0340e98
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/flatten.kt
@@ -0,0 +1,36 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.move
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.impl.ColumnNameGenerator
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+
+internal fun <T, C> DataFrame<T>.flattenImpl(
+    columns: ColumnsSelector<T, C>
+): DataFrame<T> {
+    val rootColumns = getColumnsWithPaths { columns.toColumns().filter { it.isColumnGroup() }.top() }
+    val rootPrefixes = rootColumns.map { it.path }.toSet()
+    val nameGenerators = rootPrefixes.map { it.dropLast() }.distinct().associate { path ->
+        val usedNames = get(path).asColumnGroup().columns().filter { path + it.name() !in rootPrefixes }.map { it.name() }
+        path to ColumnNameGenerator(usedNames)
+    }
+
+    fun getRootPrefix(path: ColumnPath) =
+        (1 until path.size).asSequence().map { path.take(it) }.first { rootPrefixes.contains(it) }
+
+    val result = move { rootPrefixes.toColumnSet().allDfs() }
+        .into {
+            val targetPath = getRootPrefix(it.path).dropLast(1)
+            val nameGen = nameGenerators[targetPath]!!
+            val name = nameGen.addUnique(it.name())
+            targetPath + name
+        }
+    return result
+}
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
new file mode 100644
index 000000000..72a51182f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/format.kt
@@ -0,0 +1,63 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.api.CellAttributes
+import org.jetbrains.kotlinx.dataframe.api.FormatClause
+import org.jetbrains.kotlinx.dataframe.api.FormattedFrame
+import org.jetbrains.kotlinx.dataframe.api.FormattingDSL
+import org.jetbrains.kotlinx.dataframe.api.RGBColor
+import org.jetbrains.kotlinx.dataframe.api.RowColFormatter
+import org.jetbrains.kotlinx.dataframe.api.and
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.columns.depth
+
+internal class SingleAttribute(val key: String, val value: String) : CellAttributes {
+    override fun attributes() = listOf(key to value)
+}
+
+internal class MergedAttributes(private val attributes: List<CellAttributes>) : CellAttributes {
+    override fun attributes() = attributes.flatMap { it.attributes() }.toMap().toList()
+}
+
+internal fun encRgb(r: Short, g: Short, b: Short): String = "#${encHex(r)}${encHex(g)}${encHex(b)}"
+
+internal fun encHex(v: Short): String = "${(v / 16).toString(16)}${(v % 16).toString(16)}"
+
+internal fun RGBColor.encode() = encRgb(r, g, b)
+
+internal fun componentWise(color1: RGBColor, color2: RGBColor, f: (Short, Short) -> Short) = RGBColor(
+    f(color1.r, color2.r),
+    f(color1.g, color2.g),
+    f(color1.b, color2.b)
+)
+
+internal fun linearGradient(
+    x: Double,
+    minValue: Double,
+    minColor: RGBColor,
+    maxValue: Double,
+    maxColor: RGBColor
+): RGBColor {
+    if (x < minValue) return minColor
+    if (x > maxValue) return maxColor
+    val t = (x - minValue) / (maxValue - minValue)
+    return componentWise(minColor, maxColor) { cmin, cmax ->
+        (cmin + t * (cmax - cmin)).toInt().toShort()
+    }
+}
+
+internal fun <T, C> FormatClause<T, C>.formatImpl(formatter: RowColFormatter<T, C>): FormattedFrame<T> {
+    val columns =
+        if (columns != null) df.getColumnsWithPaths(columns).mapNotNull { if (it.depth == 0) it.name else null }
+            .toSet() else null
+    return FormattedFrame(df) { row, col ->
+        val oldAttributes = oldFormatter?.invoke(FormattingDSL, row, col.cast())
+        if (columns == null || columns.contains(col.name())) {
+            val value = row[col] as C
+            if (filter == null || filter(row, value)) {
+                oldAttributes and formatter(FormattingDSL, row.cast(), col.cast())
+            } else oldAttributes
+        } else oldAttributes
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/gather.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/gather.kt
new file mode 100644
index 000000000..4844853dd
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/gather.kt
@@ -0,0 +1,118 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.Gather
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.explode
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.isEmpty
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.named
+import org.jetbrains.kotlinx.dataframe.api.replace
+import org.jetbrains.kotlinx.dataframe.api.split
+import org.jetbrains.kotlinx.dataframe.api.to
+import org.jetbrains.kotlinx.dataframe.api.with
+
+internal fun <T, C, K, R> Gather<T, C, K, R>.gatherImpl(
+    namesTo: String? = null,
+    valuesTo: String? = null,
+): DataFrame<T> {
+    require(namesTo != null || valuesTo != null)
+
+    val removed = df.removeImpl(columns = columns)
+
+    val columnsToGather = removed.removedColumns.map { it.data.column as DataColumn<C> }
+
+    val keys = columnsToGather.map { keyTransform(it.name()) }
+
+    val keysColumn = namesTo?.let { column<List<K>>(it) }
+    val valuesColumn = valuesTo?.let { column<List<Any?>>(it) }
+
+    var df = removed.df
+
+    val filter = filter
+    val valueTransform = valueTransform
+
+    // optimization when no filter is applied
+    if (filter == null) {
+        // add key and value columns
+        df = df.add { // add columns for names and values
+            if (keysColumn != null) {
+                keysColumn from { keys }
+            }
+            if (valuesColumn != null) {
+                valuesColumn from { row ->
+                    columnsToGather.map { col ->
+                        val value = col[row]
+                        if (valueTransform != null) {
+                            when {
+                                explode && value is List<*> -> (value as List<C>).map(valueTransform)
+                                else -> valueTransform(value)
+                            }
+                        } else value
+                    }
+                }
+            }
+        }
+
+        // explode keys and values
+        df = when {
+            keysColumn != null && valuesColumn != null -> df.explode(keysColumn, valuesColumn)
+            else -> df.explode(keysColumn ?: valuesColumn!!)
+        }
+
+        // explode values in lists
+        if (explode && valuesColumn != null) {
+            df = df.explode(valuesColumn)
+        }
+    } else {
+        val nameAndValue = column<List<Pair<K, Any?>>>("nameAndValue")
+        df = df.add(nameAndValue) { row ->
+            columnsToGather.mapIndexedNotNull { colIndex, col ->
+                val value = col[row]
+                when {
+                    explode && value is List<*> -> {
+                        val filtered = (value as List<C>).filter { filter(it) }
+                        val transformed = valueTransform?.let { filtered.map(it) } ?: filtered
+                        keys[colIndex] to transformed
+                    }
+                    filter(value) -> {
+                        val transformed = valueTransform?.invoke(value) ?: value
+                        keys[colIndex] to transformed
+                    }
+                    else -> null
+                }
+            }
+        }
+
+        df = df.explode { nameAndValue }
+
+        if (df.isEmpty()) return df
+
+        val nameAndValuePairs = nameAndValue.cast<Pair<*, *>>()
+
+        when {
+            keysColumn != null && valuesColumn != null -> {
+                df = df.split { nameAndValuePairs }
+                    .into(keysColumn.name(), valuesColumn.name())
+                    .explode(valuesColumn)
+            }
+            keysColumn != null -> {
+                df = df.replace { nameAndValuePairs }.with { it.map { it.first } named keysColumn.name() }
+            }
+            valuesColumn != null -> {
+                df = df.replace { nameAndValuePairs }.with { it.map { it.second } named valuesColumn.name() }
+            }
+        }
+    }
+
+    if (keysColumn != null && keyType != null) {
+        df = df.convert(keysColumn.name()).to(keyType)
+    }
+
+    return df
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/groupBy.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/groupBy.kt
new file mode 100644
index 000000000..ef4cb8aad
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/groupBy.kt
@@ -0,0 +1,61 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.GroupBy
+import org.jetbrains.kotlinx.dataframe.api.GroupedDataRow
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.api.getRows
+import org.jetbrains.kotlinx.dataframe.api.indices
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.GroupByImpl
+import org.jetbrains.kotlinx.dataframe.impl.nameGenerator
+
+internal class GroupedDataRowImpl<T, G>(private val row: DataRow<T>, private val frameCol: FrameColumn<G>) : GroupedDataRow<T, G>, DataRow<T> by row {
+
+    override fun group() = frameCol[row.index()]
+}
+
+internal fun <T> DataFrame<T>.groupByImpl(moveToTop: Boolean, columns: ColumnsSelector<T, *>): GroupBy<T, T> {
+    val nameGenerator = nameGenerator(GroupBy.groupedColumnAccessor.name())
+    var keyColumns = getColumnsWithPaths(columns)
+    if (!moveToTop) keyColumns = keyColumns.map {
+        val currentName = it.name()
+        val uniqueName = nameGenerator.addUnique(currentName)
+        if (uniqueName != currentName) it.rename(uniqueName)
+        else it
+    }
+    val groups = indices()
+        .map { index -> keyColumns.map { it[index] } to index }
+        .groupBy({ it.first }) { it.second }.toList()
+
+    val keyIndices = groups.map { it.second[0] }
+
+    val keyColumnsToInsert = keyColumns.map {
+        val column = it[keyIndices]
+        val path = if (moveToTop) pathOf(it.name()) else it.path()
+        ColumnToInsert(path, column, null)
+    }
+
+    val keyColumnsDf = dataFrameOf(keyColumnsToInsert).cast<T>()
+
+    val permutation = groups.flatMap { it.second }
+    val sorted = getRows(permutation)
+
+    var lastIndex = 0
+    val startIndices = groups.asSequence().map {
+        val start = lastIndex
+        lastIndex += it.second.size
+        start
+    }
+
+    val groupedColumnName = keyColumnsDf.nameGenerator().addUnique(GroupBy.groupedColumnAccessor.name())
+    val groupedColumn = DataColumn.createFrameColumn(groupedColumnName, sorted, startIndices.asIterable())
+
+    val df = keyColumnsDf + groupedColumn
+    return GroupByImpl(df, groupedColumn, columns)
+}
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
new file mode 100644
index 000000000..290cba84b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/implode.kt
@@ -0,0 +1,36 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.dropNA
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.replace
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.extractDataFrame
+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> {
+    return groupBy { except(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
+            }
+        }[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
new file mode 100644
index 000000000..51ac509c2
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/insert.kt
@@ -0,0 +1,135 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.ReadonlyTreeNode
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.ReferenceData
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.getAncestor
+import org.jetbrains.kotlinx.dataframe.impl.columns.withDf
+
+internal data class ColumnToInsert(
+    val insertionPath: ColumnPath,
+    val column: AnyBaseCol,
+    val referenceNode: ReadonlyTreeNode<ReferenceData>? = null
+)
+
+@PublishedApi
+internal fun <T> DataFrame<T>.insertImpl(path: ColumnPath, column: AnyCol): DataFrame<T> =
+    insertImpl(this, listOf(ColumnToInsert(path, column)))
+
+@JvmName("insertImplT")
+internal fun <T> DataFrame<T>.insertImpl(columns: List<ColumnToInsert>) =
+    insertImpl(this, columns)
+
+internal fun <T> insertImpl(df: DataFrame<T>?, columns: List<ColumnToInsert>) =
+    insertImpl(df, columns, columns.firstOrNull()?.referenceNode?.getRoot(), 0)
+
+internal fun dataFrameOf(columns: List<ColumnToInsert>) =
+    insertImpl<Unit>(null, columns, columns.firstOrNull()?.referenceNode?.getRoot(), 0)
+
+internal fun <T> insertImpl(
+    df: DataFrame<T>?,
+    columns: List<ColumnToInsert>,
+    treeNode: ReadonlyTreeNode<ReferenceData>?,
+    depth: Int
+): DataFrame<T> {
+    if (columns.isEmpty()) return df ?: DataFrame.empty().cast()
+
+    val childDepth = depth + 1
+
+    val columnsMap = columns.groupBy { it.insertionPath[depth] }.toMutableMap() // map: columnName -> columnsToAdd
+
+    val newColumns = mutableListOf<AnyBaseCol>()
+
+    // insert new columns under existing
+    df?.columns()?.forEach {
+        val subTree = columnsMap[it.name()]
+        if (subTree != null) {
+            // 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" }
+            val group = it as? ColumnGroup<*>
+            check(group != null) { "Can not insert columns under a column '${it.name()}', because it is not a column group" }
+            val newDf = insertImpl(group, subTree, treeNode?.get(it.name()), childDepth)
+            val newCol = group.withDf(newDf)
+            newColumns.add(newCol)
+            columnsMap.remove(it.name())
+        } else newColumns.add(it)
+    }
+
+    // collect new columns to insert
+    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
+                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
+                }
+            }
+
+            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
+    var insertionIndexOffset = 0
+
+    columnsToAdd.forEach { (insertionIndex, pair) ->
+        val (name, columns) = pair
+
+        // adjust insertion index by number of columns that were removed before current index
+        if (removedSiblings != null) {
+            while (k < removedSiblings.size && removedSiblings[k].data.originalIndex < insertionIndex) {
+                if (removedSiblings[k].data.wasRemoved) insertionIndexOffset--
+                k++
+            }
+        }
+
+        val nodeToInsert =
+            columns.firstOrNull { it.insertionPath.size == childDepth } // try to find existing node to insert
+        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(column is ColumnGroup<*>)
+                val newDf = insertImpl(
+                    column,
+                    columns.filter { it.insertionPath.size > childDepth },
+                    treeNode?.get(name),
+                    childDepth
+                )
+                column.withDf(newDf)
+            } else column.rename(name)
+        } else {
+            val newDf =
+                insertImpl<Unit>(null, columns, treeNode?.get(name), childDepth)
+            DataColumn.createColumnGroup(name, newDf) // new node needs to be created
+        }
+        if (insertionIndex == Int.MAX_VALUE) {
+            newColumns.add(newCol)
+        } else {
+            newColumns.add(insertionIndex + insertionIndexOffset, newCol)
+            insertionIndexOffset++
+        }
+    }
+
+    return newColumns.toDataFrame().cast()
+}
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
new file mode 100644
index 000000000..1448e4024
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/join.kt
@@ -0,0 +1,229 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.ColumnMatch
+import org.jetbrains.kotlinx.dataframe.api.JoinColumnsSelector
+import org.jetbrains.kotlinx.dataframe.api.JoinDsl
+import org.jetbrains.kotlinx.dataframe.api.JoinType
+import org.jetbrains.kotlinx.dataframe.api.allowLeftNulls
+import org.jetbrains.kotlinx.dataframe.api.allowRightNulls
+import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.api.indices
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.toColumnAccessor
+import org.jetbrains.kotlinx.dataframe.api.toDataFrameFromPairs
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameReceiver
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnsList
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.indices
+import org.jetbrains.kotlinx.dataframe.kind
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.type
+import kotlin.reflect.full.withNullability
+
+internal fun <A, B> defaultJoinColumns(left: DataFrame<A>, right: DataFrame<B>): JoinColumnsSelector<A, B> =
+    { left.columnNames().intersect(right.columnNames()).map { it.toColumnAccessor() }.let { ColumnsList(it) } }
+
+internal fun <T> defaultJoinColumns(dataFrames: Iterable<DataFrame<T>>): JoinColumnsSelector<T, T> =
+    {
+        dataFrames.map { it.columnNames() }.fold<List<String>, Set<String>?>(null) { set, names ->
+            set?.intersect(names) ?: names.toSet()
+        }.orEmpty().map { it.toColumnAccessor() }.let { ColumnsList(it) }
+    }
+
+internal fun <C> ColumnSet<C>.extractJoinColumns(): List<ColumnMatch<C>> = when (this) {
+    is ColumnsList -> columns.flatMap { it.extractJoinColumns() }
+    is ColumnReference<C> -> listOf(ColumnMatch(this, path().toColumnAccessor() as ColumnReference<C>))
+    is ColumnMatch -> listOf(this)
+    else -> throw Exception()
+}
+
+internal fun <A, B> DataFrame<A>.getColumns(other: DataFrame<B>, selector: JoinColumnsSelector<A, B>): List<ColumnMatch<Any?>> {
+    val receiver = object : DataFrameReceiver<A>(this, UnresolvedColumnsPolicy.Fail), JoinDsl<A, B> {
+        override val right: DataFrame<B> = DataFrameReceiver(other, UnresolvedColumnsPolicy.Fail)
+    }
+    val columns = selector(receiver, this)
+    return columns.extractJoinColumns()
+}
+
+internal fun <A, B> DataFrame<A>.joinImpl(
+    other: DataFrame<B>,
+    joinType: JoinType = JoinType.Inner,
+    addNewColumns: Boolean = true,
+    selector: JoinColumnsSelector<A, B>?
+): DataFrame<A> {
+    val joinColumns = getColumns(other, selector ?: defaultJoinColumns(this, other))
+
+    val leftJoinColumns = getColumnsWithPaths { joinColumns.map { it.left }.toColumnSet() }
+    val rightJoinColumns = other.getColumnsWithPaths { joinColumns.map { it.right }.toColumnSet() }
+
+    require(leftJoinColumns.size == rightJoinColumns.size)
+
+    // replace all ColumnGroups in join with nested columns, matching by column path
+    val allLeftJoinColumns = mutableListOf<ColumnWithPath<*>>()
+    val allRightJoinColumns = mutableListOf<ColumnWithPath<*>>()
+
+    leftJoinColumns.indices.forEach { i ->
+        val leftCol = leftJoinColumns[i]
+        val rightCol = rightJoinColumns[i]
+        if (leftCol.isColumnGroup() && rightCol.isColumnGroup()) {
+            val leftColumns = getColumnsWithPaths { leftCol.allDfs() }
+            val rightColumns = other.getColumnsWithPaths { rightCol.allDfs() }
+
+            val leftPrefixLength = leftCol.path.size
+            val rightPrefixLength = rightCol.path.size
+            val leftMap = leftColumns.associateBy { it.path.drop(leftPrefixLength) }.toMutableMap()
+
+            rightColumns.forEach { right ->
+                val relativePath = right.path.drop(rightPrefixLength)
+                val left = leftMap[relativePath]
+                if (left == null) {
+                    require(selector == null) {
+                        "Unable to perform join by column groups `${leftCol.name}` to `${rightCol.name}, because `$relativePath` was not found under `${leftCol.name}` in left DataFrame"
+                    }
+                } else {
+                    allLeftJoinColumns.add(left)
+                    allRightJoinColumns.add(right)
+                    leftMap.remove(relativePath)
+                }
+            }
+            require(leftMap.isEmpty() || selector == null) {
+                "Unable to perform join by column groups `${leftCol.name}` to `${rightCol.name}, because `${leftMap.values.first()}` was not found under `${rightCol.name}` in right DataFrame"
+            }
+        } else {
+            allLeftJoinColumns.add(leftCol)
+            allRightJoinColumns.add(rightCol)
+        }
+    }
+
+    // compute left to right column path mappings
+    val pathMapping = allLeftJoinColumns.mapIndexed { colNumber, leftCol ->
+        leftCol.path to allRightJoinColumns[colNumber].path
+    }.toMap()
+
+    // compute pairs of join key to row index from right data frame
+    val rightJoinKeyToIndex = other.indices()
+        .map { index -> allRightJoinColumns.map { it.data[index] } to index }
+
+    // group row indices by key from right data frame
+    val groupedRight = when (joinType) {
+        JoinType.Exclude -> rightJoinKeyToIndex.map { it.first to emptyList<Int>() }.toMap()
+        else -> rightJoinKeyToIndex.groupBy({ it.first }) { it.second }
+    }
+
+    var outputRowsCount = 0
+
+    // for every row index from left data frame compute a list of matched indices from right data frame
+    val leftToRightMapping = indices.map { leftIndex ->
+        val leftKey = allLeftJoinColumns.map { it.data[leftIndex] }
+        val rightIndices = groupedRight[leftKey]
+        outputRowsCount += rightIndices?.size ?: if (joinType.allowRightNulls) 1 else 0
+        rightIndices
+    }
+
+    // for every row index in right data frame store a flag indicating whether this row was matched by some row in left data frame
+    val rightMatched = Array(other.nrow) { false }
+
+    // number of rows in right data frame that were not matched by any row in left data frame. Used for correct allocation of an output array
+    var rightUnmatchedCount = other.nrow
+
+    // compute matched indices from right data frame and number of rows in output data frame
+    if (joinType.allowLeftNulls) {
+        leftToRightMapping.forEach { rightIndices ->
+            rightIndices?.forEach { i ->
+                if (!rightMatched[i]) {
+                    rightUnmatchedCount--
+                    rightMatched[i] = true
+                }
+            }
+        }
+        outputRowsCount += rightUnmatchedCount
+    }
+
+    val leftColumns = getColumnsWithPaths { allDfs() }
+
+    val rightJoinColumnPaths = allRightJoinColumns.map { it.path to it.data }.toMap()
+
+    val newRightColumns =
+        if (addNewColumns) other.getColumnsWithPaths { dfs { !it.isColumnGroup() && !rightJoinColumnPaths.contains(it.path) } } else emptyList()
+
+    // for every column index from the left dataframe store matching column from the right dataframe
+    val leftToRightColumns = leftColumns.map { rightJoinColumnPaths[pathMapping[it.path()]] }
+
+    val leftColumnsCount = leftColumns.size
+    val newRightColumnsCount = newRightColumns.size
+    val outputColumnsCount = leftColumnsCount + newRightColumnsCount
+
+    val outputData = Array<Array<Any?>>(outputColumnsCount) { arrayOfNulls(outputRowsCount) }
+    val hasNulls = Array(outputColumnsCount) { false }
+
+    var row = 0
+
+    leftToRightMapping.forEachIndexed { leftRow, rightRows ->
+        if (rightRows == null) {
+            if (joinType.allowRightNulls) {
+                for (col in 0 until leftColumnsCount) {
+                    val leftColumn = leftColumns[col].data
+                    outputData[col][row] = leftColumn[leftRow].also { if (it == null) hasNulls[col] = true }
+                }
+                for (col in 0 until newRightColumnsCount) {
+                    outputData[leftColumnsCount + col][row] = null
+                    hasNulls[leftColumnsCount + col] = true
+                }
+                row++
+            }
+        } else {
+            for (rightRow in rightRows) {
+                for (col in 0 until leftColumnsCount) {
+                    val leftColumn = leftColumns[col].data
+                    outputData[col][row] = leftColumn[leftRow].also { if (it == null) hasNulls[col] = true }
+                }
+                for (col in 0 until newRightColumnsCount) {
+                    val rightColumn = newRightColumns[col].data
+                    outputData[leftColumnsCount + col][row] =
+                        rightColumn[rightRow].also { if (it == null) hasNulls[leftColumnsCount + col] = true }
+                }
+                row++
+            }
+        }
+    }
+
+    if (joinType.allowLeftNulls) {
+        for (rightRow in rightMatched.indices) {
+            if (!rightMatched[rightRow]) {
+                for (col in 0 until leftColumnsCount) {
+                    val rightColumn = leftToRightColumns[col]
+                    outputData[col][row] = rightColumn?.get(rightRow).also { if (it == null) hasNulls[col] = true }
+                }
+                for (col in 0 until newRightColumnsCount) {
+                    val rightColumn = newRightColumns[col].data
+                    outputData[leftColumnsCount + col][row] =
+                        rightColumn[rightRow].also { if (it == null) hasNulls[leftColumnsCount + col] = true }
+                }
+                row++
+            }
+        }
+    }
+
+    val columns = outputData.mapIndexed { columnIndex, columnValues ->
+        val srcColumn =
+            if (columnIndex < leftColumnsCount) leftColumns[columnIndex] else newRightColumns[columnIndex - leftColumnsCount]
+        val hasNulls = hasNulls[columnIndex]
+        val newColumn = when (srcColumn.kind) {
+            ColumnKind.Value -> DataColumn.createValueColumn(srcColumn.name, columnValues.asList(), srcColumn.type.withNullability(hasNulls))
+            ColumnKind.Frame -> DataColumn.createFrameColumn(srcColumn.name, columnValues.asList() as List<AnyFrame>)
+            ColumnKind.Group -> error("Unexpected ColumnGroup at path ${srcColumn.path}")
+        }
+        srcColumn.path to newColumn
+    }
+
+    return columns.toDataFrameFromPairs()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/map.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/map.kt
new file mode 100644
index 000000000..addb79377
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/map.kt
@@ -0,0 +1,18 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.createDataCollector
+
+@PublishedApi
+internal fun <T, R> DataColumn<T?>.mapNotNullValues(transform: (T) -> R): DataColumn<R?> {
+    val collector = createDataCollector(size)
+    values.forEach {
+        if (it == null) collector.add(null)
+        else collector.add(transform(it))
+    }
+    return collector.toColumn(name).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
new file mode 100644
index 000000000..0e51a7362
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/move.kt
@@ -0,0 +1,65 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl
+import org.jetbrains.kotlinx.dataframe.api.MoveClause
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.getColumnWithPath
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameReceiver
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnWithPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.ColumnPosition
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.getOrPut
+
+// TODO: support 'before' mode
+internal fun <T, C> MoveClause<T, C>.afterOrBefore(column: ColumnSelector<T, *>, isAfter: Boolean): DataFrame<T> {
+    val removeResult = df.removeImpl(columns = columns)
+
+    val targetPath = df.getColumnWithPath(column).path
+    val removeRoot = removeResult.removedColumns.first().getRoot()
+
+    val refNode = removeRoot.getOrPut(targetPath) {
+        val parentPath = it.dropLast(1)
+        val parent = if (parentPath.isEmpty()) df else df.getColumnGroup(parentPath)
+        val index = parent.getColumnIndex(it.last())
+        val col = df.getColumn(index)
+        ColumnPosition(index, false, col)
+    }
+
+    val parentPath = targetPath.dropLast(1)
+    val toInsert = removeResult.removedColumns.map {
+        val path = parentPath + it.name
+        ColumnToInsert(path, it.toColumnWithPath<C>().data, refNode)
+    }
+    return removeResult.df.insertImpl(toInsert)
+}
+
+internal fun <T, C> MoveClause<T, C>.moveImpl(
+    under: Boolean = false,
+    newPathExpression: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> Column
+): DataFrame<T> {
+    val receiver = object : DataFrameReceiver<T>(df, UnresolvedColumnsPolicy.Fail), ColumnsSelectionDsl<T> {}
+    val removeResult = df.removeImpl(columns = columns)
+    val columnsToInsert = removeResult.removedColumns.map {
+        val col = it.toColumnWithPath<C>()
+        var path = newPathExpression(receiver, col).path()
+        if (under) path += col.name()
+        ColumnToInsert(path, col.data, it)
+    }
+    return removeResult.df.insertImpl(columnsToInsert)
+}
+
+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()
+    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
new file mode 100644
index 000000000..0e09bb20b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/parse.kt
@@ -0,0 +1,383 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import kotlinx.datetime.Instant
+import kotlinx.datetime.toKotlinLocalDate
+import kotlinx.datetime.toKotlinLocalDateTime
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.GlobalParserOptions
+import org.jetbrains.kotlinx.dataframe.api.ParserOptions
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.asDataColumn
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.isFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.parse
+import org.jetbrains.kotlinx.dataframe.api.single
+import org.jetbrains.kotlinx.dataframe.api.to
+import org.jetbrains.kotlinx.dataframe.api.tryParse
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConversionException
+import org.jetbrains.kotlinx.dataframe.hasNulls
+import org.jetbrains.kotlinx.dataframe.impl.catchSilent
+import org.jetbrains.kotlinx.dataframe.impl.createStarProjectedType
+import org.jetbrains.kotlinx.dataframe.io.isURL
+import org.jetbrains.kotlinx.dataframe.io.readJsonStr
+import org.jetbrains.kotlinx.dataframe.typeClass
+import java.net.URL
+import java.text.NumberFormat
+import java.text.ParsePosition
+import java.time.LocalDate
+import java.time.LocalDateTime
+import java.time.LocalTime
+import java.time.format.DateTimeFormatter
+import java.time.format.DateTimeFormatterBuilder
+import java.util.Locale
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.jvm.jvmErasure
+import kotlin.reflect.typeOf
+import kotlin.time.Duration
+
+internal interface StringParser<T> {
+    fun toConverter(options: ParserOptions?): TypeConverter
+    fun applyOptions(options: ParserOptions?): (String) -> T?
+    val type: KType
+}
+
+internal open class DelegatedStringParser<T>(override val type: KType, val handle: (String) -> T?) : StringParser<T> {
+    override fun toConverter(options: ParserOptions?): TypeConverter {
+        val nulls = options?.nullStrings ?: Parsers.nulls
+        return {
+            val str = it as String
+            if (str in nulls) null
+            else handle(str) ?: throw TypeConversionException(it, typeOf<String>(), type, null)
+        }
+    }
+
+    override fun applyOptions(options: ParserOptions?): (String) -> T? = handle
+}
+
+internal class StringParserWithFormat<T>(override val type: KType, val getParser: (ParserOptions?) -> ((String) -> T?)) :
+    StringParser<T> {
+    override fun toConverter(options: ParserOptions?): TypeConverter {
+        val handler = getParser(options)
+        val nulls = options?.nullStrings ?: Parsers.nulls
+        return {
+            val str = it as String
+            if (str in nulls) null
+            else handler(str) ?: throw TypeConversionException(it, typeOf<String>(), type, null)
+        }
+    }
+
+    override fun applyOptions(options: ParserOptions?): (String) -> T? {
+        val handler = getParser(options)
+        return { handler(it) }
+    }
+}
+
+internal object Parsers : GlobalParserOptions {
+
+    private val formatters: MutableList<DateTimeFormatter> = mutableListOf()
+
+    private val nullStrings: MutableSet<String> = mutableSetOf()
+
+    public val nulls: Set<String> get() = nullStrings
+
+    override fun addDateTimePattern(pattern: String) {
+        formatters.add(DateTimeFormatter.ofPattern(pattern))
+    }
+
+    override fun addNullString(str: String) {
+        nullStrings.add(str)
+    }
+
+    override var locale: Locale = Locale.getDefault()
+
+    override fun resetToDefault() {
+        formatters.clear()
+        nullStrings.clear()
+        formatters.add(DateTimeFormatter.ISO_LOCAL_DATE_TIME)
+        formatters.add(DateTimeFormatter.ISO_DATE_TIME)
+
+        DateTimeFormatterBuilder()
+            .parseCaseInsensitive()
+            .append(DateTimeFormatter.ISO_LOCAL_DATE)
+            .appendLiteral(' ')
+            .append(DateTimeFormatter.ISO_LOCAL_TIME).toFormatter()
+            .let { formatters.add(it) }
+
+        locale = Locale.getDefault()
+
+        nullStrings.addAll(listOf("null", "NULL", "NA", "N/A"))
+    }
+
+    init {
+        resetToDefault()
+    }
+
+    private fun String.toLocalDateTimeOrNull(formatter: DateTimeFormatter?): LocalDateTime? {
+        if (formatter != null) {
+            return catchSilent { java.time.LocalDateTime.parse(this, formatter) }
+        } else {
+            catchSilent { LocalDateTime.parse(this) }?.let { return it }
+            for (format in formatters) {
+                catchSilent { java.time.LocalDateTime.parse(this, format) }?.let { return it }
+            }
+        }
+        return null
+    }
+
+    private fun String.toUrlOrNull(): URL? {
+        return if (isURL(this)) catchSilent { URL(this) } else null
+    }
+
+    private fun String.toBooleanOrNull() =
+        when (uppercase(Locale.getDefault())) {
+            "T" -> true
+            "TRUE" -> true
+            "YES" -> true
+            "F" -> false
+            "FALSE" -> false
+            "NO" -> false
+            else -> null
+        }
+
+    private fun String.toLocalDateOrNull(formatter: DateTimeFormatter?): LocalDate? {
+        if (formatter != null) {
+            return catchSilent { java.time.LocalDate.parse(this, formatter) }
+        } else {
+            catchSilent { LocalDate.parse(this) }?.let { return it }
+            for (format in formatters) {
+                catchSilent { java.time.LocalDate.parse(this, format) }?.let { return it }
+            }
+        }
+        return null
+    }
+
+    private fun String.toLocalTimeOrNull(formatter: DateTimeFormatter?): LocalTime? {
+        if (formatter != null) {
+            return catchSilent { LocalTime.parse(this, formatter) }
+        } else {
+            catchSilent { LocalTime.parse(this) }?.let { return it }
+            for (format in formatters) {
+                catchSilent { LocalTime.parse(this, format) }?.let { return it }
+            }
+        }
+        return null
+    }
+
+    private fun String.parseDouble(format: NumberFormat) =
+        when (uppercase(Locale.getDefault())) {
+            "NAN" -> Double.NaN
+            "INF" -> Double.POSITIVE_INFINITY
+            "-INF" -> Double.NEGATIVE_INFINITY
+            "INFINITY" -> Double.POSITIVE_INFINITY
+            "-INFINITY" -> Double.NEGATIVE_INFINITY
+            else -> {
+                val parsePosition = ParsePosition(0)
+                val result: Double? = format.parse(this, parsePosition)?.toDouble()
+                if (parsePosition.index != this.length) null
+                else result
+            }
+        }
+
+    inline fun <reified T : Any> stringParser(catch: Boolean = false, noinline body: (String) -> T?): StringParser<T> {
+        return if (catch) DelegatedStringParser(typeOf<T>()) {
+            try {
+                body(it)
+            } catch (e: Throwable) {
+                null
+            }
+        }
+        else DelegatedStringParser(typeOf<T>(), body)
+    }
+
+    inline fun <reified T : Any> stringParserWithOptions(noinline body: (ParserOptions?) -> ((String) -> T?)) =
+        StringParserWithFormat(typeOf<T>(), body)
+
+    private val parserToDoubleWithOptions = stringParserWithOptions { options ->
+        val numberFormat = NumberFormat.getInstance(options?.locale ?: Locale.getDefault())
+        val parser = { it: String -> it.parseDouble(numberFormat) }
+        parser
+    }
+
+    private val parsersOrder = listOf(
+        // Int
+        stringParser { it.toIntOrNull() },
+
+        // Long
+        stringParser { it.toLongOrNull() },
+
+        // kotlinx.datetime.Instant
+        stringParser { catchSilent { Instant.parse(it) } },
+
+        // java.time.Instant
+        stringParser { catchSilent { java.time.Instant.parse(it) } },
+
+        // kotlinx.datetime.LocalDateTime
+        stringParserWithOptions { options ->
+            val formatter = options?.getDateTimeFormatter()
+            val parser = { it: String -> it.toLocalDateTimeOrNull(formatter)?.toKotlinLocalDateTime() }
+            parser
+        },
+
+        // java.time.LocalDateTime
+        stringParserWithOptions { options ->
+            val formatter = options?.getDateTimeFormatter()
+            val parser = { it: String -> it.toLocalDateTimeOrNull(formatter) }
+            parser
+        },
+
+        // kotlinx.datetime.LocalDate
+        stringParserWithOptions { options ->
+            val formatter = options?.getDateTimeFormatter()
+            val parser = { it: String -> it.toLocalDateOrNull(formatter)?.toKotlinLocalDate() }
+            parser
+        },
+
+        // java.time.LocalDate
+        stringParserWithOptions { options ->
+            val formatter = options?.getDateTimeFormatter()
+            val parser = { it: String -> it.toLocalDateOrNull(formatter) }
+            parser
+        },
+
+        // kotlin.time.duration
+        stringParser { catchSilent { Duration.parse(it) } },
+
+        // java.time.duration
+        stringParser { catchSilent { java.time.Duration.parse(it) } },
+
+        // java.time.LocalTime
+        stringParserWithOptions { options ->
+            val formatter = options?.getDateTimeFormatter()
+            val parser = { it: String -> it.toLocalTimeOrNull(formatter) }
+            parser
+        },
+
+        // java.net.URL
+        stringParser { it.toUrlOrNull() },
+
+        // Double, with explicit number format or taken from current locale
+        parserToDoubleWithOptions,
+
+        // Double, with POSIX format
+        stringParser { it.parseDouble(NumberFormat.getInstance(Locale.forLanguageTag("C.UTF-8"))) },
+
+        // Boolean
+        stringParser { it.toBooleanOrNull() },
+
+        // BigDecimal
+        stringParser { it.toBigDecimalOrNull() },
+
+        stringParser(catch = true) { if (it.startsWith("[")) DataFrame.readJsonStr(it) else null },
+        stringParser(catch = true) { if (it.startsWith("{")) DataFrame.readJsonStr(it).single() else null },
+
+        stringParser { it } // must be last in the list of parsers to return original unparsed string
+    )
+
+    private val parsersMap = parsersOrder.associateBy { it.type }
+
+    val size: Int = parsersOrder.size
+
+    operator fun get(index: Int): StringParser<*> = parsersOrder[index]
+
+    operator fun get(type: KType): StringParser<*>? = parsersMap[type]
+
+    operator fun <T : Any> get(type: KClass<T>): StringParser<T>? = parsersMap.get(type.createStarProjectedType(false)) as? StringParser<T>
+
+    inline fun <reified T : Any> get(): StringParser<T>? = get(typeOf<T>()) as? StringParser<T>
+
+    internal fun <R : Any> getDateTimeConverter(clazz: KClass<R>, pattern: String? = null, locale: Locale? = null):
+        (String) -> R? {
+        val parser = get(clazz) ?: error("Can not convert String to $clazz")
+        val formatter = pattern?.let {
+            if (locale == null) DateTimeFormatter.ofPattern(it)
+            else DateTimeFormatter.ofPattern(it, locale)
+        }
+        val options = if (formatter != null || locale != null) ParserOptions(
+            dateTimeFormatter = formatter,
+            locale = locale
+        ) else null
+        return parser.applyOptions(options)
+    }
+
+    internal fun getDoubleParser(locale: Locale? = null): (String) -> Double? {
+        val options = if (locale != null) ParserOptions(
+            locale = locale
+        ) else null
+        return parserToDoubleWithOptions.applyOptions(options)
+    }
+}
+
+internal fun DataColumn<String?>.tryParseImpl(options: ParserOptions?): DataColumn<*> {
+    var parserId = 0
+    val parsedValues = mutableListOf<Any?>()
+    var hasNulls: Boolean
+    var hasNotNulls: Boolean
+    var nullStringParsed: Boolean
+    val nulls = options?.nullStrings ?: Parsers.nulls
+    do {
+        val parser = Parsers[parserId].applyOptions(options)
+        parsedValues.clear()
+        hasNulls = false
+        hasNotNulls = false
+        nullStringParsed = false
+        for (str in values) {
+            when {
+                str == null -> {
+                    parsedValues.add(null)
+                    hasNulls = true
+                }
+
+                nulls.contains(str) -> {
+                    parsedValues.add(null)
+                    hasNulls = true
+                    nullStringParsed = true
+                }
+
+                else -> {
+                    val trimmed = str.trim()
+                    val res = parser(trimmed)
+                    if (res == null) {
+                        parserId++
+                        break
+                    }
+                    parsedValues.add(res)
+                    hasNotNulls = true
+                }
+            }
+        }
+    } while (parserId < Parsers.size && parsedValues.size != size)
+    check(parserId < Parsers.size) { "Valid parser not found" }
+
+    val type = (if (hasNotNulls) Parsers[parserId].type else this.type()).withNullability(hasNulls)
+    if (type.jvmErasure == String::class && !nullStringParsed) return this // nothing parsed
+    return DataColumn.create(name(), parsedValues, type)
+}
+
+internal fun <T> DataColumn<String?>.parse(parser: StringParser<T>, options: ParserOptions?): DataColumn<T?> {
+    val handler = parser.applyOptions(options)
+    val parsedValues = values.map {
+        it?.let {
+            handler(it.trim()) ?: throw IllegalStateException("Couldn't parse '$it' into type ${parser.type}")
+        }
+    }
+    return DataColumn.createValueColumn(name(), parsedValues, parser.type.withNullability(hasNulls)) as DataColumn<T?>
+}
+
+internal fun <T> DataFrame<T>.parseImpl(options: ParserOptions?, columns: ColumnsSelector<T, Any?>) =
+    convert(columns).to {
+        when {
+            it.isFrameColumn() -> it.cast<AnyFrame?>().parse(options)
+            it.isColumnGroup() -> it.asColumnGroup().parse { all() }.asColumnGroup(it.name()).asDataColumn()
+            it.typeClass == String::class -> it.cast<String?>().tryParse(options)
+            else -> it
+        }
+    }
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
new file mode 100644
index 000000000..18d9a5ea0
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/pivot.kt
@@ -0,0 +1,123 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateDsl
+import org.jetbrains.kotlinx.dataframe.aggregation.NamedValue
+import org.jetbrains.kotlinx.dataframe.api.PivotColumnsSelector
+import org.jetbrains.kotlinx.dataframe.api.forEach
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.toPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.GroupByReceiverImpl
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.AggregateInternalDsl
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.receivers.AggregatePivotDslImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.resolve
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+
+internal class AggregatedPivot<T>(
+    private val df: DataFrame<T>,
+    val inward: Boolean?,
+    internal var aggregator: GroupByReceiverImpl<T>,
+) :
+    DataFrame<T> by df
+
+internal data class PivotChainElement(val column: ColumnWithPath<Any?>, val includeColumnName: Boolean)
+
+internal class PivotChain<C>(val columns: List<PivotChainElement>, lastColumn: ColumnWithPath<C>) :
+    ColumnWithPath<C> by lastColumn
+
+internal class PivotChainColumnSet<C>(val first: ColumnSet<C>, val second: ColumnSet<C>) : ColumnSet<C> {
+
+    override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> {
+        val firstCols = first.resolve(context)
+        val secondCols = second.resolve(context)
+        val result = mutableListOf<PivotChain<C>>()
+        firstCols.forEach { a ->
+            secondCols.forEach { b ->
+                val firstPart = ((a as? PivotChain<*>)?.columns ?: listOf(PivotChainElement(a, false)))
+                var secondPart = ((b as? PivotChain<*>)?.columns ?: listOf(PivotChainElement(b, false)))
+                if (secondCols.size > 1) {
+                    secondPart = listOf(PivotChainElement(secondPart[0].column, true)) + secondPart.drop(1)
+                }
+                result.add(PivotChain(firstPart + secondPart, b))
+            }
+        }
+        return result
+    }
+}
+
+internal fun <T, C> DataFrame<T>.getPivotSequences(
+    columns: PivotColumnsSelector<T, C>,
+): List<List<PivotChainElement>> {
+    return columns.toColumns().resolve(this, UnresolvedColumnsPolicy.Fail)
+        .map {
+            when (val col = it) {
+                is PivotChain<*> -> col.columns as List<PivotChainElement>
+                else -> listOf(PivotChainElement(it, false))
+            }
+        }
+}
+
+internal fun <T> DataFrame<T>.getPivotColumnPaths(
+    columns: PivotColumnsSelector<T, *>,
+): List<ColumnPath> {
+    return getPivotSequences(columns).flatten().map { it.column.path }.distinct()
+}
+
+internal fun <T, R> aggregatePivot(
+    aggregator: AggregateInternalDsl<T>,
+    columns: PivotColumnsSelector<T, *>,
+    separate: Boolean,
+    inward: Boolean? = null,
+    globalDefault: Any? = null,
+    body: Selector<AggregateDsl<T>, R>,
+) {
+    val pivotSequences = aggregator.df.getPivotSequences(columns)
+    val effectiveInward = inward ?: if (aggregator.hasGroupingKeys) {
+        true
+    } else {
+        pivotSequences.distinctBy { it.first().column.path }.count() > 1
+    }
+    pivotSequences.forEach { pivotColumns ->
+        aggregator.df.groupBy(pivotColumns.map { it.column }).forEach { (key, group) ->
+
+            val pathNames = mutableListOf<String>()
+            key.values().forEachIndexed { i, v ->
+                if (i == 0 && effectiveInward) pathNames.addAll(pivotColumns[i].column.path)
+                else if (pivotColumns[i].includeColumnName) pathNames.add(pivotColumns[i].column.name)
+                pathNames.add(v.toString())
+            }
+            val path = pathNames.toPath()
+            val builder = AggregatePivotDslImpl(group)
+            val result = body(builder, builder)
+            val hasResult = result != null && result != Unit
+
+            fun NamedValue.apply(path: ColumnPath) =
+                copy(path = path, value = this.value ?: default ?: globalDefault, default = default ?: globalDefault)
+
+            val values = builder.values
+            when {
+                values.size == 1 && values[0].path.isEmpty() -> aggregator.yield(values[0].apply(path))
+                values.isEmpty() -> aggregator.yield(
+                    path,
+                    if (hasResult) result else globalDefault,
+                    null,
+                    globalDefault,
+                    true
+                )
+
+                else -> {
+                    values.forEach {
+                        val targetPath = if (separate) it.path + path else path + it.path
+                        aggregator.yield(it.apply(targetPath))
+                    }
+                }
+            }
+        }
+    }
+}
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
new file mode 100644
index 000000000..c79c6d37d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/remove.kt
@@ -0,0 +1,65 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.ColumnPosition
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.TreeNode
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.allRemovedColumns
+import org.jetbrains.kotlinx.dataframe.impl.columns.withDf
+import org.jetbrains.kotlinx.dataframe.impl.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.nrow
+
+internal data class RemoveResult<T>(val df: DataFrame<T>, val removedColumns: List<TreeNode<ColumnPosition>>)
+
+internal fun <T> DataFrame<T>.removeImpl(allowMissingColumns: Boolean = false, columns: ColumnsSelector<T, *>): RemoveResult<T> {
+    val colWithPaths = getColumnsWithPaths(if (allowMissingColumns) UnresolvedColumnsPolicy.Skip else UnresolvedColumnsPolicy.Fail, columns)
+    val colPaths = colWithPaths.map { it.path }
+    val originalOrder = colPaths.mapIndexed { index, path -> path to index }.toMap()
+
+    val root = TreeNode.createRoot(ColumnPosition(-1, false, null))
+
+    if (colPaths.isEmpty()) return RemoveResult(this, emptyList())
+
+    fun dfs(cols: Iterable<AnyBaseCol>, removePaths: List<ColumnWithPath<*>>, node: TreeNode<ColumnPosition>): AnyFrame? {
+        if (removePaths.isEmpty()) return null
+
+        val depth = node.depth
+        val childrenToRemove = removePaths.groupBy { it.path[depth] }
+        val newCols = mutableListOf<AnyBaseCol>()
+
+        cols.forEachIndexed { index, column ->
+            val toRemove = childrenToRemove[column.name()]
+            if (toRemove != null) {
+                val node = node.addChild(column.name, ColumnPosition(index, true, null))
+                if (toRemove.all { it.path.size > depth + 1 }) {
+                    val groupCol = (column as ColumnGroup<*>)
+                    val newDf = dfs(groupCol.columns(), toRemove, node)
+                    if (newDf != null) {
+                        val newCol = groupCol.withDf(newDf)
+                        newCols.add(newCol)
+                        node.data.wasRemoved = false
+                    }
+                } else {
+                    val removedChild = toRemove.single { it.path.size == depth + 1 }
+                    node.data.column = removedChild.data
+                }
+            } else newCols.add(column)
+        }
+        if (newCols.isEmpty()) return null
+        return newCols.toDataFrame()
+    }
+
+    val newDf = dfs(columns(), colWithPaths, root) ?: DataFrame.empty(nrow)
+
+    val removedColumns = root.allRemovedColumns().map { it.pathFromRoot() to it }.sortedBy { originalOrder[it.first] }.map { it.second }
+
+    return RemoveResult(newDf.cast(), removedColumns)
+}
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
new file mode 100644
index 000000000..2ce9f4db8
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/reorder.kt
@@ -0,0 +1,73 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnExpression
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.Reorder
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.isFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.reorder
+import org.jetbrains.kotlinx.dataframe.api.replace
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.ColumnPosition
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.TreeNode
+import kotlin.reflect.typeOf
+
+internal fun <T, C, V : Comparable<V>> Reorder<T, C>.reorderImpl(
+    desc: Boolean,
+    expression: ColumnExpression<C, V>
+): DataFrame<T> {
+    data class ColumnInfo(
+        val treeNode: TreeNode<ColumnPosition>,
+        val column: DataColumn<C>,
+        val value: V,
+        val index: Int
+    )
+
+    val columnsWithPaths = df.getColumnsWithPaths(columns)
+    if (columnsWithPaths.size == 1 && columnsWithPaths[0].isColumnGroup()) {
+        val path = columnsWithPaths[0].path
+        return df.reorder { path.all().cast<C>() }.reorderImpl(desc, expression)
+    }
+
+    var df = df
+
+    columnsWithPaths
+        .groupBy({ it.path.parent()!! }) { it.name() }
+        .forEach { (parentPath, names) ->
+            val group = if (parentPath.isEmpty()) df else df.getColumnGroup(parentPath)
+
+            val removed = group.removeImpl(false) { names.toColumns() }
+
+            val mapped = removed.removedColumns
+                .sortedBy { group.getColumnIndex(it.name) }
+                .mapIndexed { i, treeNode ->
+                    val column = treeNode.data.column!!.cast<C>()
+                    ColumnInfo(treeNode, column, expression(column, column), i)
+                }
+
+            val sorted = if (desc) mapped.sortedByDescending { it.value } else mapped.sortedBy { it.value }
+
+            val toInsert = sorted.mapIndexed { i, c ->
+                val src = mapped[i]
+                val path = src.treeNode.pathFromRoot().rename(c.column.name())
+                var column = c.column
+                if (inFrameColumns && column.isFrameColumn()) {
+                    column = column.asAnyFrameColumn().map(typeOf<AnyFrame>()) { it.cast<T>().reorder(columns).reorderImpl(desc, expression) }.cast()
+                }
+                ColumnToInsert(path, column, src.treeNode)
+            }
+            val newGroup = removed.df.insertImpl(toInsert)
+            df = if (parentPath.isEmpty()) newGroup.cast()
+            else df.replace(parentPath).with { newGroup.asColumnGroup(it.name()) }
+        }
+    return df
+}
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
new file mode 100644
index 000000000..c0a7ae71d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/sort.kt
@@ -0,0 +1,123 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.GroupBy
+import org.jetbrains.kotlinx.dataframe.api.SortColumnsSelector
+import org.jetbrains.kotlinx.dataframe.api.asGroupBy
+import org.jetbrains.kotlinx.dataframe.api.castFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.getFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.assertIsComparable
+import org.jetbrains.kotlinx.dataframe.impl.columns.missing.MissingColumnGroup
+import org.jetbrains.kotlinx.dataframe.impl.columns.resolve
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import org.jetbrains.kotlinx.dataframe.kind
+import org.jetbrains.kotlinx.dataframe.nrow
+
+@Suppress("UNCHECKED_CAST", "RemoveExplicitTypeArguments")
+internal fun <T, G> GroupBy<T, G>.sortByImpl(columns: SortColumnsSelector<G, *>): GroupBy<T, G> =
+    toDataFrame()
+
+        // sort the individual groups by the columns specified
+        .update { groups }
+        .with { it.sortByImpl(UnresolvedColumnsPolicy.Skip, columns) }
+
+        // sort the groups by the columns specified (must be either be the keys column or "groups")
+        // will do nothing if the columns specified are not the keys column or "groups"
+        .sortByImpl(UnresolvedColumnsPolicy.Skip, columns as SortColumnsSelector<T, *>)
+
+        .asGroupBy { it.getFrameColumn(groups.name()).castFrameColumn<G>() }
+
+internal fun <T, C> DataFrame<T>.sortByImpl(
+    unresolvedColumnsPolicy: UnresolvedColumnsPolicy = UnresolvedColumnsPolicy.Fail,
+    columns: SortColumnsSelector<T, C>,
+): DataFrame<T> {
+    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 permutation = (0 until nrow).sortedWith(compChain)
+
+    return this[permutation]
+}
+
+internal fun AnyCol.createComparator(nullsLast: Boolean): java.util.Comparator<Int> {
+    assertIsComparable()
+
+    val valueComparator = Comparator<Any?> { left, right ->
+        (left as Comparable<Any?>).compareTo(right)
+    }
+
+    val comparatorWithNulls = if (nullsLast) nullsLast(valueComparator) else nullsFirst(valueComparator)
+    return Comparator { left, right -> comparatorWithNulls.compare(get(left), get(right)) }
+}
+
+internal fun <T, C> DataFrame<T>.getSortColumns(
+    columns: SortColumnsSelector<T, C>,
+    unresolvedColumnsPolicy: UnresolvedColumnsPolicy,
+): List<SortColumnDescriptor<*>> =
+    columns.toColumns().resolve(this, unresolvedColumnsPolicy)
+        .filterNot { it.data is MissingColumnGroup<*> } // can appear using [DataColumn<R>?.check] with UnresolvedColumnsPolicy.Skip
+        .map {
+            when (val col = it.data) {
+                is SortColumnDescriptor<*> -> col
+                is ValueColumn<*> -> SortColumnDescriptor(col)
+                else -> throw IllegalStateException("Can not use ${col.kind} as sort column")
+            }
+        }
+
+internal enum class SortFlag { Reversed, NullsLast }
+
+internal fun <C> ColumnSet<C>.addFlag(flag: SortFlag) = ColumnsWithSortFlag(this, flag)
+
+internal fun <C> ColumnWithPath<C>.addFlag(flag: SortFlag): ColumnWithPath<C> {
+    val col = data
+    return when (col) {
+        is SortColumnDescriptor -> {
+            when (flag) {
+                SortFlag.Reversed -> SortColumnDescriptor(col.column, col.direction.reversed(), col.nullsLast)
+                SortFlag.NullsLast -> SortColumnDescriptor(col.column, col.direction, true)
+            }
+        }
+
+        is ValueColumn -> {
+            when (flag) {
+                SortFlag.Reversed -> SortColumnDescriptor(col, SortDirection.Desc)
+                SortFlag.NullsLast -> SortColumnDescriptor(col, SortDirection.Asc, true)
+            }
+        }
+
+        else -> throw IllegalArgumentException("Can not apply sort flag to column kind ${col.kind}")
+    }.addPath(path)
+}
+
+internal class ColumnsWithSortFlag<C>(val column: ColumnSet<C>, val flag: SortFlag) : ColumnSet<C> {
+    override fun resolve(context: ColumnResolutionContext) = column.resolve(context).map { it.addFlag(flag) }
+}
+
+internal class SortColumnDescriptor<C>(
+    val column: ValueColumn<C>,
+    val direction: SortDirection = SortDirection.Asc,
+    val nullsLast: Boolean = false,
+) : ValueColumn<C> by column
+
+internal enum class SortDirection { Asc, Desc }
+
+internal fun SortDirection.reversed(): SortDirection = when (this) {
+    SortDirection.Asc -> SortDirection.Desc
+    SortDirection.Desc -> SortDirection.Asc
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/split.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/split.kt
new file mode 100644
index 000000000..2d9fa64dd
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/split.kt
@@ -0,0 +1,67 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.SplitWithTransform
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.impl.ColumnDataCollector
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnWithPath
+import org.jetbrains.kotlinx.dataframe.impl.createDataCollector
+import org.jetbrains.kotlinx.dataframe.impl.nameGenerator
+import org.jetbrains.kotlinx.dataframe.nrow
+
+internal fun valueToList(value: Any?, splitStrings: Boolean = true): List<Any?> = when (value) {
+    null -> emptyList()
+    is List<*> -> value
+    is AnyFrame -> value.rows().toList()
+    else -> if (splitStrings) value.toString().split(",").map { it.trim() } else listOf(value)
+}
+
+internal fun <T, C, R> splitImpl(
+    clause: SplitWithTransform<T, C, R>,
+    columnNamesGenerator: ColumnWithPath<C>.(Int) -> List<String>
+): DataFrame<T> {
+    val nrow = clause.df.nrow
+
+    val removeResult = clause.df.removeImpl(columns = clause.columns)
+    val nameGenerator = removeResult.df.nameGenerator()
+
+    val toInsert = removeResult.removedColumns.flatMap { node ->
+
+        val column = node.toColumnWithPath<C>()
+        val columnCollectors = mutableListOf<ColumnDataCollector>()
+        for (row in 0 until nrow) {
+            val value = clause.transform(clause.df[row], column.data[row])
+            val list = valueToList(value)
+            for (j in list.indices) {
+                if (columnCollectors.size <= j) {
+                    val collector = createDataCollector(nrow)
+                    repeat(row) { collector.add(clause.default) }
+                    columnCollectors.add(collector)
+                }
+                columnCollectors[j].add(list[j])
+            }
+            for (j in list.size until columnCollectors.size)
+                columnCollectors[j].add(clause.default)
+        }
+
+        var names = columnNamesGenerator(column, columnCollectors.size)
+        if (names.size < columnCollectors.size) {
+            names = names + (1..(columnCollectors.size - names.size)).map { "split$it" }
+        }
+
+        columnCollectors.mapIndexed { i, col ->
+
+            val name = nameGenerator.addUnique(names[i])
+            val sourcePath = node.pathFromRoot()
+            val path = if (clause.inward) sourcePath + name else sourcePath.dropLast(1) + name
+            val data = col.toColumn(name)
+            ColumnToInsert(path, data, node)
+        }
+    }
+
+    return removeResult.df.insertImpl(toInsert)
+}
+
+internal fun String.splitDefault() = split(",").map { it.trim() }
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
new file mode 100644
index 000000000..93ecd6682
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/toDataFrame.kt
@@ -0,0 +1,229 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.CreateDataFrameDsl
+import org.jetbrains.kotlinx.dataframe.api.TraversePropertiesDsl
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.toDataFrameFromPairs
+import org.jetbrains.kotlinx.dataframe.codeGen.shouldBeConvertedToColumnGroup
+import org.jetbrains.kotlinx.dataframe.codeGen.shouldBeConvertedToFrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.emptyPath
+import org.jetbrains.kotlinx.dataframe.impl.getListType
+import org.jetbrains.kotlinx.dataframe.impl.projectUpTo
+import org.jetbrains.kotlinx.dataframe.impl.schema.getPropertiesOrder
+import java.lang.reflect.InvocationTargetException
+import java.time.temporal.Temporal
+import kotlin.reflect.KClass
+import kotlin.reflect.KProperty
+import kotlin.reflect.KVisibility
+import kotlin.reflect.full.isSubclassOf
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.jvm.javaField
+import kotlin.reflect.typeOf
+
+internal val valueTypes = setOf(
+    String::class,
+    Boolean::class,
+    kotlin.time.Duration::class,
+    kotlinx.datetime.LocalDate::class,
+    kotlinx.datetime.LocalDateTime::class,
+    kotlinx.datetime.Instant::class,
+)
+
+internal val KClass<*>.isValueType: Boolean get() =
+    this in valueTypes ||
+        this.isSubclassOf(Number::class) ||
+        this.isSubclassOf(Enum::class) ||
+        this.isSubclassOf(Temporal::class)
+
+internal class CreateDataFrameDslImpl<T>(
+    override val source: Iterable<T>,
+    private val clazz: KClass<*>,
+    private val prefix: ColumnPath = emptyPath(),
+    private val configuration: TraverseConfiguration = TraverseConfiguration()
+) : CreateDataFrameDsl<T>(), TraversePropertiesDsl by configuration {
+
+    internal val columns = mutableListOf<Pair<ColumnPath, AnyBaseCol>>()
+
+    override fun add(column: AnyBaseCol, path: ColumnPath?) {
+        val col = if (path != null) column.rename(path.last()) else column
+        val targetPath = if (path != null) prefix + path else prefix + column.name()
+        columns.add(targetPath to col)
+    }
+
+    override operator fun String.invoke(builder: CreateDataFrameDsl<T>.() -> Unit) {
+        val child = CreateDataFrameDslImpl(source, clazz, prefix + this)
+        builder(child)
+        columns.addAll(child.columns)
+    }
+
+    internal class TraverseConfiguration : TraversePropertiesDsl {
+
+        val excludeProperties = mutableSetOf<KProperty<*>>()
+
+        val excludeClasses = mutableSetOf<KClass<*>>()
+
+        val preserveClasses = mutableSetOf<KClass<*>>()
+
+        val preserveProperties = mutableSetOf<KProperty<*>>()
+
+        fun clone(): TraverseConfiguration = TraverseConfiguration().also {
+            it.excludeClasses.addAll(excludeClasses)
+            it.excludeProperties.addAll(excludeProperties)
+            it.preserveProperties.addAll(preserveProperties)
+            it.preserveClasses.addAll(preserveClasses)
+        }
+
+        override fun exclude(vararg properties: KProperty<*>) {
+            excludeProperties.addAll(properties)
+        }
+
+        override fun exclude(vararg classes: KClass<*>) {
+            excludeClasses.addAll(classes)
+        }
+
+        override fun preserve(vararg classes: KClass<*>) {
+            preserveClasses.addAll(classes)
+        }
+
+        override fun preserve(vararg properties: KProperty<*>) {
+            preserveProperties.addAll(properties)
+        }
+    }
+
+    override fun properties(vararg roots: KProperty<*>, maxDepth: Int, body: (TraversePropertiesDsl.() -> Unit)?) {
+        val dsl = configuration.clone()
+        if (body != null) {
+            body(dsl)
+        }
+        val df = convertToDataFrame(source, clazz, roots.toList(), dsl.excludeProperties, dsl.preserveClasses, dsl.preserveProperties, maxDepth)
+        df.columns().forEach {
+            add(it)
+        }
+    }
+}
+
+@PublishedApi
+internal fun <T> Iterable<T>.createDataFrameImpl(clazz: KClass<*>, body: CreateDataFrameDslImpl<T>.() -> Unit): DataFrame<T> {
+    val builder = CreateDataFrameDslImpl(this, clazz)
+    builder.body()
+    return builder.columns.toDataFrameFromPairs()
+}
+
+@PublishedApi
+internal fun convertToDataFrame(
+    data: Iterable<*>,
+    clazz: KClass<*>,
+    roots: List<KProperty<*>>,
+    excludes: Set<KProperty<*>>,
+    preserveClasses: Set<KClass<*>>,
+    preserveProperties: Set<KProperty<*>>,
+    maxDepth: Int
+): AnyFrame {
+    val order = getPropertiesOrder(clazz)
+
+    val properties = roots.ifEmpty {
+        clazz.memberProperties
+            .filter { it.visibility == KVisibility.PUBLIC && it.parameters.toList().size == 1 }
+    }.sortedBy { order[it.name] ?: Int.MAX_VALUE }
+
+    val columns = properties.mapNotNull {
+        val property = it
+        if (excludes.contains(property)) return@mapNotNull null
+
+        property.javaField?.isAccessible = true
+
+        var nullable = false
+        var hasExceptions = false
+        val values = data.map { obj ->
+            if (obj == null) {
+                nullable = true
+                null
+            } else {
+                val value = try {
+                    it.call(obj)
+                } catch (e: InvocationTargetException) {
+                    hasExceptions = true
+                    e.targetException
+                } catch (e: Throwable) {
+                    hasExceptions = true
+                    e
+                }
+                if (value == null) nullable = true
+                value
+            }
+        }
+
+        val returnType = property.returnType.let { type ->
+            if (type.classifier is KClass<*>) {
+                type
+            } else {
+                typeOf<Any>()
+            }
+        }
+        val kclass = (returnType.classifier as KClass<*>)
+        when {
+            hasExceptions -> DataColumn.createWithTypeInference(it.columnName, values, nullable)
+            kclass == Any::class || preserveClasses.contains(kclass) || preserveProperties.contains(property) || (maxDepth <= 0 && !returnType.shouldBeConvertedToFrameColumn() && !returnType.shouldBeConvertedToColumnGroup()) || kclass.isValueType ->
+                DataColumn.createValueColumn(it.columnName, values, returnType.withNullability(nullable))
+            kclass == DataFrame::class && !nullable -> DataColumn.createFrameColumn(it.columnName, values as List<AnyFrame>)
+            kclass == DataRow::class -> DataColumn.createColumnGroup(it.columnName, (values as List<AnyRow>).concat())
+            kclass.isSubclassOf(Iterable::class) -> {
+                val elementType = returnType.projectUpTo(Iterable::class).arguments.firstOrNull()?.type
+                if (elementType == null) {
+                    DataColumn.createValueColumn(
+                        it.columnName,
+                        values,
+                        returnType.withNullability(nullable)
+                    )
+                } else {
+                    val elementClass = (elementType.classifier as? KClass<*>)
+
+                    when {
+                        elementClass == null -> {
+                            val listValues = values.map {
+                                (it as? Iterable<*>)?.asList()
+                            }
+
+                            DataColumn.createWithTypeInference(it.columnName, listValues)
+                        }
+                        elementClass.isValueType -> {
+                            val listType = getListType(elementType).withNullability(nullable)
+                            val listValues = values.map {
+                                (it as? Iterable<*>)?.asList()
+                            }
+                            DataColumn.createValueColumn(it.columnName, listValues, listType)
+                        }
+                        else -> {
+                            val frames = values.map {
+                                if (it == null) DataFrame.empty()
+                                else {
+                                    require(it is Iterable<*>)
+                                    convertToDataFrame(it, elementClass, emptyList(), excludes, preserveClasses, preserveProperties, maxDepth - 1)
+                                }
+                            }
+                            DataColumn.createFrameColumn(it.columnName, frames)
+                        }
+                    }
+                }
+            }
+            else -> {
+                val df = convertToDataFrame(values, kclass, emptyList(), excludes, preserveClasses, preserveProperties, maxDepth - 1)
+                DataColumn.createColumnGroup(it.columnName, df)
+            }
+        }
+    }
+    return if (columns.isEmpty()) {
+        DataFrame.empty(data.count())
+    } else dataFrameOf(columns)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/toList.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/toList.kt
new file mode 100644
index 000000000..5f0eede4d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/toList.kt
@@ -0,0 +1,75 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.convertTo
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.jetbrains.kotlinx.dataframe.kind
+import org.jetbrains.kotlinx.dataframe.type
+import kotlin.reflect.KType
+import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.full.primaryConstructor
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.jvm.jvmErasure
+
+@PublishedApi
+internal fun AnyFrame.toListImpl(type: KType): List<Any> {
+    val clazz = type.jvmErasure
+    require(clazz.isData) { "`$clazz` is not a data class. `toList` is supported only for data classes." }
+
+    val constructor = clazz.primaryConstructor
+    require(constructor != null) { "Class `$clazz` doesn't have a primary constructor" }
+
+    val columnNames = clazz.memberProperties.map {
+        it.name to it.columnName
+    }.toMap()
+
+    val convertedColumns = constructor.parameters.map {
+        require(it.name != null) { "Parameter name can not be null. Parameter = $it" }
+        val columnName = columnNames[it.name]
+
+        check(columnName != null) { "Can not find member property for parameter ${it.name}" }
+        val index = getColumnIndex(columnName)
+
+        check(index >= 0) { "Can not find column `$columnName` in DataFrame" }
+
+        val column = getColumn(index)
+        val convertedColumn = if (column.type != it.type) {
+            when (column.kind) {
+                ColumnKind.Frame -> {
+                    val col: AnyCol = if (it.type.jvmErasure == List::class) {
+                        val elementType = it.type.arguments[0].type
+                        require(elementType != null) { "FrameColumn can not be converted to type `List<*>`" }
+                        column.asAnyFrameColumn().map { it.toListImpl(elementType) }
+                    } else error("FrameColumn can not be converted to type `${it.type}`")
+                    col
+                }
+                ColumnKind.Group -> {
+                    DataColumn.createValueColumn(column.name(), column.asColumnGroup().toListImpl(it.type))
+                }
+                ColumnKind.Value -> {
+                    require(!column.hasNulls() || it.type.isMarkedNullable) { "Can not set `null` in non-nullable property `${it.name}: ${it.type}`" }
+                    val converted = column.convertTo(it.type)
+                    require(converted.type.withNullability(false).isSubtypeOf(it.type)) { "Can not convert ${column.type()} to ${it.type} for column `${column.name()}`" }
+                    converted
+                }
+            }
+        } else column
+        convertedColumn
+    }
+
+    return rows().map { row ->
+        val parameters = convertedColumns.map {
+            row[it]
+        }.toTypedArray()
+        constructor.call(*parameters)
+    }
+}
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
new file mode 100644
index 000000000..b3fca01b3
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/update.kt
@@ -0,0 +1,104 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnExpression
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.RowValueFilter
+import org.jetbrains.kotlinx.dataframe.api.AddDataRow
+import org.jetbrains.kotlinx.dataframe.api.Update
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.indices
+import org.jetbrains.kotlinx.dataframe.api.isEmpty
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.replace
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.size
+import org.jetbrains.kotlinx.dataframe.impl.columns.AddDataRowImpl
+import org.jetbrains.kotlinx.dataframe.impl.createDataCollector
+import org.jetbrains.kotlinx.dataframe.type
+import kotlin.reflect.full.isSubclassOf
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.jvm.jvmErasure
+
+@PublishedApi
+internal fun <T, C> Update<T, C>.updateImpl(expression: (AddDataRow<T>, DataColumn<C>, C) -> C?): DataFrame<T> =
+    if (df.isEmpty()) df
+    else df.replace(columns).with { it.updateImpl(df, filter, expression) }
+
+internal fun <T, C> Update<T, C>.updateWithValuePerColumnImpl(selector: ColumnExpression<C, C>) =
+    if (df.isEmpty()) df
+    else {
+        df.replace(columns).with {
+            val value = selector(it, it)
+            val convertedValue = value?.convertTo(it.type()) as C
+            it.updateImpl(df, filter) { _, _, _ -> convertedValue }
+        }
+    }
+
+internal fun <T, C> DataColumn<C>.updateImpl(
+    df: DataFrame<T>,
+    filter: RowValueFilter<T, C>?,
+    expression: (AddDataRow<T>, DataColumn<C>, C) -> C?
+): DataColumn<C> {
+    val collector = createDataCollector<C>(size, type)
+    val src = this
+    if (filter == null) {
+        df.indices().forEach { rowIndex ->
+            val row = AddDataRowImpl(rowIndex, df, collector.values)
+            collector.add(expression(row, src, src[rowIndex]))
+        }
+    } else {
+        df.indices().forEach { rowIndex ->
+            val row = AddDataRowImpl(rowIndex, df, collector.values)
+            val currentValue = row[src]
+            val newValue =
+                if (filter.invoke(row, currentValue)) expression(row, src, currentValue) else currentValue
+            collector.add(newValue)
+        }
+    }
+    return collector.toColumn(src.name).cast()
+}
+
+/**
+ * Replaces all values in column asserting that new values are compatible with current column kind
+ */
+internal fun <T> DataColumn<T>.updateWith(values: List<T>): DataColumn<T> = when (this) {
+    is FrameColumn<*> -> {
+        values.forEach {
+            require(it is AnyFrame) { "Can not add value '$it' to FrameColumn" }
+        }
+        val groups = (values as List<AnyFrame>)
+        DataColumn.createFrameColumn(name, groups) as DataColumn<T>
+    }
+    is ColumnGroup<*> -> {
+        this.columns().mapIndexed { colIndex, col ->
+            val newValues = values.map {
+                when (it) {
+                    null -> null
+                    is List<*> -> it[colIndex]
+                    is AnyRow -> it.getOrNull(col.name)
+                    else -> require(false) { "Can not add value '$it' to ColumnGroup" }
+                }
+            }
+            col.updateWith(newValues)
+        }.toDataFrame().let { DataColumn.createColumnGroup(name, it) } as DataColumn<T>
+    }
+    else -> {
+        var nulls = false
+        val kclass = type.jvmErasure
+        values.forEach {
+            when (it) {
+                null -> nulls = true
+                else -> {
+                    require(it.javaClass.kotlin.isSubclassOf(kclass)) { "Can not add value '$it' to column '$name' of type $type" }
+                }
+            }
+        }
+        DataColumn.createValueColumn(name, values, type.withNullability(nulls))
+    }
+}
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
new file mode 100644
index 000000000..7e105d6a5
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/xs.kt
@@ -0,0 +1,42 @@
+package org.jetbrains.kotlinx.dataframe.impl.api
+
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.GroupBy
+import org.jetbrains.kotlinx.dataframe.api.asGroupBy
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.impl.columns.isMissingColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.getColumnPaths
+import org.jetbrains.kotlinx.dataframe.impl.getColumnsImpl
+
+internal fun <T, C> DataFrame<T>.xsImpl(
+    keyColumns: ColumnsSelector<T, C>,
+    allowMissingColumns: Boolean,
+    vararg keyValues: C
+): DataFrame<T> {
+    val cols = getColumnsImpl(if (allowMissingColumns) UnresolvedColumnsPolicy.Create else UnresolvedColumnsPolicy.Fail, keyColumns)
+    val n = keyValues.count()
+    require(cols.size == n) { "Number of key values $n doesn't equal to number of key columns ${cols.size}" }
+    val pairs = cols.zip(keyValues).filter { !it.first.isMissingColumn() }
+    return filter {
+        val rowIndex = index()
+        var include = true
+        for ((col, value) in pairs) {
+            if (col[rowIndex] != value) {
+                include = false
+                break
+            }
+        }
+        include
+    }.removeImpl(allowMissingColumns, keyColumns).df
+}
+
+internal fun <T, G, C> GroupBy<T, G>.xsImpl(vararg keyValues: C, keyColumns: ColumnsSelector<T, C>): GroupBy<T, G> {
+    val df = toDataFrame()
+    val paths = df.getColumnPaths(UnresolvedColumnsPolicy.Create, keyColumns).toColumnSet()
+    val d1 = df.xsImpl({ paths }, true, *keyValues).asGroupBy(groups)
+    val d2 = d1.updateGroups { it.xsImpl({ paths }, true, *keyValues) }
+    return d2
+}
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
new file mode 100644
index 000000000..a803e316f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/CodeGeneratorImpl.kt
@@ -0,0 +1,518 @@
+package org.jetbrains.kotlinx.dataframe.impl.codeGen
+
+import com.squareup.kotlinpoet.buildCodeBlock
+import org.jetbrains.dataframe.impl.codeGen.CodeGenResult
+import org.jetbrains.dataframe.impl.codeGen.CodeGenerator
+import org.jetbrains.dataframe.impl.codeGen.InterfaceGenerationMode
+import org.jetbrains.dataframe.impl.codeGen.InterfaceGenerationMode.Enum
+import org.jetbrains.dataframe.impl.codeGen.InterfaceGenerationMode.NoFields
+import org.jetbrains.dataframe.impl.codeGen.InterfaceGenerationMode.None
+import org.jetbrains.dataframe.impl.codeGen.InterfaceGenerationMode.TypeAlias
+import org.jetbrains.dataframe.impl.codeGen.InterfaceGenerationMode.WithFields
+import org.jetbrains.dataframe.keywords.HardKeywords
+import org.jetbrains.dataframe.keywords.ModifierKeywords
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl
+import org.jetbrains.kotlinx.dataframe.api.DataSchemaEnum
+import org.jetbrains.kotlinx.dataframe.codeGen.BaseField
+import org.jetbrains.kotlinx.dataframe.codeGen.CodeWithConverter
+import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadDfMethod
+import org.jetbrains.kotlinx.dataframe.codeGen.ExtensionsCodeGenerator
+import org.jetbrains.kotlinx.dataframe.codeGen.FieldType
+import org.jetbrains.kotlinx.dataframe.codeGen.IsolatedMarker
+import org.jetbrains.kotlinx.dataframe.codeGen.Marker
+import org.jetbrains.kotlinx.dataframe.codeGen.MarkerVisibility
+import org.jetbrains.kotlinx.dataframe.codeGen.NameNormalizer
+import org.jetbrains.kotlinx.dataframe.codeGen.SchemaProcessor
+import org.jetbrains.kotlinx.dataframe.codeGen.ValidFieldName
+import org.jetbrains.kotlinx.dataframe.codeGen.toNullable
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.impl.toSnakeCase
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import org.jetbrains.kotlinx.jupyter.api.Code
+
+private fun renderNullability(nullable: Boolean) = if (nullable) "?" else ""
+
+internal fun Iterable<Marker>.filterRequiredForSchema(schema: DataFrameSchema) =
+    filter { it.isOpen && it.schema.compare(schema).isSuperOrEqual() }
+
+internal val charsToQuote = """[ `(){}\[\].<>'"/|\\!?@:;%^&*#$-]""".toRegex()
+
+internal fun createCodeWithConverter(code: String, markerName: String) =
+    CodeWithConverter(code) { "$it.cast<$markerName>()" }
+
+private val letterCategories = setOf(
+    CharCategory.UPPERCASE_LETTER,
+    CharCategory.TITLECASE_LETTER,
+    CharCategory.MODIFIER_LETTER,
+    CharCategory.LOWERCASE_LETTER,
+    CharCategory.DECIMAL_DIGIT_NUMBER
+)
+
+internal fun String.needsQuoting(): Boolean =
+    if (isQuoted()) false
+    else isBlank() ||
+        first().isDigit() ||
+        contains(charsToQuote) ||
+        HardKeywords.VALUES.contains(this) ||
+        ModifierKeywords.VALUES.contains(this) ||
+        all { it == '_' } ||
+        any { it != '_' && it.category !in letterCategories }
+
+public fun String.isQuoted(): Boolean = startsWith("`") && endsWith("`")
+
+public fun String.quoteIfNeeded(): String = if (needsQuoting()) "`$this`" else this
+
+internal fun List<Code>.join() = joinToString("\n")
+
+/** Strategy to render types. Instances include [FullyQualifiedNames] and [ShortNames]. */
+internal interface TypeRenderingStrategy {
+
+    /**
+     * How to render a row type. Used as receiver type for column accessors for DSLs.
+     * E.g.: `DataRow<Marker>`
+     */
+    fun renderRowTypeName(markerName: String): String
+
+    /**
+     * How to render a columns-container (base type for [DataFrame] and [ColumnSelectionDsl]).
+     * Used as receiver type for column accessors.
+     * E.g.: `ColumnsContainer<Marker>`
+     */
+    fun renderColumnsContainerTypeName(markerName: String): String
+
+    /**
+     * How to render a column type from a [BaseField]. Used as return type for column accessors.
+     * Result will be a [DataColumn] (or [ColumnGroup], which can be seen as a [DataColumn]).
+     * E.g.: `DataColumn<DataFrame<Marker>>`
+     */
+    fun BaseField.renderColumnType(): Code
+
+    /**
+     * How to render the field type of [BaseField]. Used as return type for column accessors for DSLs.
+     * Result will be either the value type name, a [DataRow] or [DataFrame].
+     */
+    fun BaseField.renderAccessorFieldType(): Code
+
+    /**
+     * How to render the field type of [BaseField]. Used as property type in generated interfaces.
+     * Result will be either the value type name, the group field type name or [DataFrame].
+     */
+    fun BaseField.renderFieldType(): Code
+}
+
+internal object FullyQualifiedNames : TypeRenderingStrategy {
+
+    private val DataRow = DataRow::class.qualifiedName!!
+    private val ColumnsContainer = ColumnsContainer::class.qualifiedName!!
+    private val DataFrame = DataFrame::class.qualifiedName!!
+    private val DataColumn = DataColumn::class.qualifiedName!!
+    private val ColumnGroup = ColumnGroup::class.qualifiedName!!
+
+    override fun renderRowTypeName(markerName: String) = "$DataRow<$markerName>"
+
+    override fun renderColumnsContainerTypeName(markerName: String) = "$ColumnsContainer<$markerName>"
+
+    override fun BaseField.renderColumnType(): Code =
+        when (val fieldType = fieldType) {
+            is FieldType.ValueFieldType ->
+                "$DataColumn<${fieldType.typeFqName}>"
+
+            is FieldType.GroupFieldType ->
+                "$ColumnGroup<${fieldType.markerName}>"
+
+            is FieldType.FrameFieldType ->
+                "$DataColumn<$DataFrame<${fieldType.markerName}>${renderNullability(fieldType.nullable)}>"
+        }
+
+    override fun BaseField.renderAccessorFieldType(): Code =
+        when (val fieldType = fieldType) {
+            is FieldType.ValueFieldType ->
+                fieldType.typeFqName
+
+            is FieldType.GroupFieldType ->
+                "$DataRow<${fieldType.markerName}>"
+
+            is FieldType.FrameFieldType ->
+                "$DataFrame<${fieldType.markerName}>${renderNullability(fieldType.nullable)}"
+        }
+
+    override fun BaseField.renderFieldType(): Code =
+        when (val fieldType = fieldType) {
+            is FieldType.ValueFieldType ->
+                fieldType.typeFqName
+
+            is FieldType.GroupFieldType ->
+                fieldType.markerName
+
+            is FieldType.FrameFieldType ->
+                "$DataFrame<${fieldType.markerName}>${renderNullability(fieldType.nullable)}"
+        }
+}
+
+internal object ShortNames : TypeRenderingStrategy {
+
+    private val DataRow = DataRow::class.simpleName!!
+    private val ColumnsContainer = ColumnsContainer::class.simpleName!!
+    private val DataFrame = DataFrame::class.simpleName!!
+    private val DataColumn = DataColumn::class.simpleName!!
+    private val ColumnGroup = ColumnGroup::class.simpleName!!
+
+    override fun renderRowTypeName(markerName: String): String = "$DataRow<${markerName.shorten()}>"
+
+    override fun renderColumnsContainerTypeName(markerName: String): String =
+        "$ColumnsContainer<${markerName.shorten()}>"
+
+    override fun BaseField.renderColumnType(): Code =
+        when (val fieldType = fieldType) {
+            is FieldType.ValueFieldType ->
+                "$DataColumn<${fieldType.typeFqName.shorten()}>"
+
+            is FieldType.GroupFieldType ->
+                "$ColumnGroup<${fieldType.markerName}>"
+
+            is FieldType.FrameFieldType ->
+                "$DataColumn<$DataFrame<${fieldType.markerName}>${renderNullability(fieldType.nullable)}>"
+        }
+
+    override fun BaseField.renderAccessorFieldType(): Code =
+        when (val fieldType = fieldType) {
+            is FieldType.ValueFieldType ->
+                fieldType.typeFqName.shorten()
+
+            is FieldType.GroupFieldType ->
+                "$DataRow<${fieldType.markerName}>"
+
+            is FieldType.FrameFieldType ->
+                "$DataFrame<${fieldType.markerName}>${renderNullability(fieldType.nullable)}"
+        }
+
+    override fun BaseField.renderFieldType(): Code =
+        when (val fieldType = fieldType) {
+            is FieldType.ValueFieldType ->
+                fieldType.typeFqName.shorten()
+
+            is FieldType.GroupFieldType ->
+                fieldType.markerName
+
+            is FieldType.FrameFieldType ->
+                "$DataFrame<${fieldType.markerName}>${renderNullability(fieldType.nullable)}"
+        }
+
+    private fun String.shorten() = removeRedundantQualifier(this)
+
+    private fun removeRedundantQualifier(markerName: String): String {
+        val parts = markerName.split('.')
+        return if (parts.size == 2 && parts[0] == "kotlin") {
+            parts[1]
+        } else {
+            markerName
+        }
+    }
+}
+
+internal open class ExtensionsCodeGeneratorImpl(
+    private val typeRendering: TypeRenderingStrategy,
+) : ExtensionsCodeGenerator, TypeRenderingStrategy by typeRendering {
+
+    fun renderStringLiteral(name: String) = name
+        .replace("\\", "\\\\")
+        .replace("$", "\\\$")
+        .replace("\"", "\\\"")
+
+    private fun String.removeQuotes() = this.removeSurrounding("`")
+
+    private fun generateExtensionProperties(markers: List<Marker>) = markers.map { generateExtensionProperties(it) }
+
+    private fun generatePropertyCode(
+        marker: IsolatedMarker,
+        shortMarkerName: String,
+        typeName: String,
+        name: String,
+        propertyType: String,
+        getter: String,
+        visibility: String,
+    ): String {
+        // jvm name is required to prevent signature clash like this:
+        // val DataRow<Type>.name: String
+        // val DataRow<Repo>.name: String
+        val jvmName = "${shortMarkerName}_${name.removeQuotes()}"
+        val typeParameters = marker.typeParameters.let {
+            if (it.isNotEmpty() && !it.startsWith(" ")) {
+                " $it"
+            } else {
+                it
+            }
+        }
+        return "${visibility}val$typeParameters $typeName.$name: $propertyType @JvmName(\"${renderStringLiteral(jvmName)}\") get() = $getter as $propertyType"
+    }
+
+    protected fun generateExtensionProperties(marker: IsolatedMarker): Code {
+        val markerName = marker.name
+        val markerType = "$markerName${marker.typeArguments}"
+        val visibility = renderTopLevelDeclarationVisibility(marker)
+        val shortMarkerName = markerName.substring(markerName.lastIndexOf('.') + 1).removeQuotes()
+        val nullableShortMarkerName = "Nullable$shortMarkerName"
+
+        fun String.toNullable() = if (this.last() == '?' || this == "*") this else "$this?"
+
+        val declarations = mutableListOf<String>()
+        val dfTypename = renderColumnsContainerTypeName(markerType)
+        val nullableDfTypename = renderColumnsContainerTypeName(markerType.toNullable())
+        val rowTypename = renderRowTypeName(markerType)
+        val nullableRowTypename = renderRowTypeName(markerType.toNullable())
+
+        val nullableFields = marker.fields.map {
+            it.toNullable()
+        }.associateBy { it.columnName }
+
+        marker.fields.sortedBy { it.fieldName.quotedIfNeeded }.forEach {
+            val getter = "this[\"${renderStringLiteral(it.columnName)}\"]"
+            val name = it.fieldName
+            val fieldType = it.renderAccessorFieldType()
+            val nullableFieldType = nullableFields[it.columnName]!!.renderAccessorFieldType()
+            val columnType = it.renderColumnType()
+            val nullableColumnType = nullableFields[it.columnName]!!.renderColumnType()
+
+            declarations.addAll(
+                listOf(
+                    // non nullable
+                    generatePropertyCode(
+                        marker = marker,
+                        shortMarkerName = shortMarkerName,
+                        typeName = dfTypename,
+                        name = name.quotedIfNeeded,
+                        propertyType = columnType,
+                        getter = getter,
+                        visibility = visibility,
+                    ),
+                    generatePropertyCode(
+                        marker = marker,
+                        shortMarkerName = shortMarkerName,
+                        typeName = rowTypename,
+                        name = name.quotedIfNeeded,
+                        propertyType = fieldType,
+                        getter = getter,
+                        visibility = visibility,
+                    ),
+
+                    // nullable
+                    generatePropertyCode(
+                        marker = marker,
+                        shortMarkerName = nullableShortMarkerName,
+                        typeName = nullableDfTypename,
+                        name = name.quotedIfNeeded,
+                        propertyType = nullableColumnType,
+                        getter = getter,
+                        visibility = visibility,
+                    ),
+                    generatePropertyCode(
+                        marker = marker,
+                        shortMarkerName = nullableShortMarkerName,
+                        typeName = nullableRowTypename,
+                        name = name.quotedIfNeeded,
+                        propertyType = nullableFieldType,
+                        getter = getter,
+                        visibility = visibility,
+                    ),
+                )
+            )
+        }
+        return declarations.joinToString("\n")
+    }
+
+    override fun generate(marker: IsolatedMarker): CodeWithConverter {
+        val code = generateExtensionProperties(marker)
+        return createCodeWithConverter(code, marker.name)
+    }
+
+    protected fun renderTopLevelDeclarationVisibility(marker: IsolatedMarker) = when (marker.visibility) {
+        MarkerVisibility.INTERNAL -> "internal "
+        MarkerVisibility.IMPLICIT_PUBLIC -> ""
+        MarkerVisibility.EXPLICIT_PUBLIC -> "public "
+    }
+
+    protected fun renderInternalDeclarationVisibility(marker: IsolatedMarker) = when (marker.visibility) {
+        MarkerVisibility.INTERNAL -> ""
+        MarkerVisibility.IMPLICIT_PUBLIC -> ""
+        MarkerVisibility.EXPLICIT_PUBLIC -> "public "
+    }
+}
+
+internal class CodeGeneratorImpl(typeRendering: TypeRenderingStrategy = FullyQualifiedNames) :
+    ExtensionsCodeGeneratorImpl(typeRendering), CodeGenerator {
+    override fun generate(
+        marker: Marker,
+        interfaceMode: InterfaceGenerationMode,
+        extensionProperties: Boolean,
+        readDfMethod: DefaultReadDfMethod?,
+    ): CodeWithConverter {
+        val code = when (interfaceMode) {
+            NoFields, WithFields ->
+                generateInterface(
+                    marker = marker,
+                    fields = interfaceMode == WithFields,
+                    readDfMethod = readDfMethod,
+                ) + if (extensionProperties) "\n" + generateExtensionProperties(marker) else ""
+
+            Enum -> generateEnum(marker)
+
+            TypeAlias -> generateTypeAlias(marker)
+
+            None -> if (extensionProperties) generateExtensionProperties(marker) else ""
+        }
+
+        return createCodeWithConverter(code, marker.name)
+    }
+
+    private fun generateTypeAlias(marker: Marker): Code {
+        val visibility = renderTopLevelDeclarationVisibility(marker)
+
+        return "${visibility}typealias ${marker.name} = ${marker.superMarkers.keys.single()}"
+    }
+
+    private fun generateEnum(marker: Marker): Code {
+        val visibility = renderTopLevelDeclarationVisibility(marker)
+
+        val header =
+            "${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 valueName = it.fieldName.unquoted
+            val isLast = i == marker.fields.size - 1
+
+            "    ${ValidFieldName.of(fieldName).quotedIfNeeded}(\"$valueName\")${if (isLast) ";" else ","}"
+        }.join()
+
+        val body = if (fieldsDeclaration.isNotBlank()) buildString {
+            append(" {\n")
+            append(fieldsDeclaration)
+            append("\n}")
+        } else ""
+
+        return listOf(header + body).join()
+    }
+
+    override fun generate(
+        schema: DataFrameSchema,
+        name: String,
+        fields: Boolean,
+        extensionProperties: Boolean,
+        isOpen: Boolean,
+        visibility: MarkerVisibility,
+        knownMarkers: Iterable<Marker>,
+        readDfMethod: DefaultReadDfMethod?,
+        fieldNameNormalizer: NameNormalizer,
+    ): CodeGenResult {
+        val context = SchemaProcessor.create(name, knownMarkers, fieldNameNormalizer)
+        val marker = context.process(schema, isOpen, visibility)
+        val declarations = mutableListOf<Code>()
+        context.generatedMarkers.forEach { itMarker ->
+            declarations.add(generateInterface(itMarker, fields, readDfMethod.takeIf { marker == itMarker }))
+            if (extensionProperties) {
+                declarations.add(generateExtensionProperties(itMarker))
+            }
+        }
+        val code = createCodeWithConverter(declarations.joinToString("\n\n"), marker.name)
+        return CodeGenResult(code, context.generatedMarkers)
+    }
+
+    private fun generateInterfaces(
+        schemas: List<Marker>,
+        fields: Boolean,
+    ) = schemas.map { generateInterface(it, fields) }
+
+    private fun generateInterface(
+        marker: Marker,
+        fields: Boolean,
+        readDfMethod: DefaultReadDfMethod? = null,
+    ): Code {
+        val annotationName = DataSchema::class.simpleName
+
+        val visibility = renderTopLevelDeclarationVisibility(marker)
+        val propertyVisibility = renderInternalDeclarationVisibility(marker)
+
+        val header =
+            "@$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() 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 {
+                ""
+            }
+
+            val fieldType = it.renderFieldType()
+            "$columnNameAnnotation    ${propertyVisibility}${override}val ${it.fieldName.quotedIfNeeded}: $fieldType"
+        }.join() else ""
+
+        val readDfMethodDeclaration = readDfMethod?.toDeclaration(marker, propertyVisibility)
+
+        val body = if (fieldsDeclaration.isNotBlank() || readDfMethodDeclaration?.isNotBlank() == true) {
+            buildString {
+                append(" {\n")
+                append(fieldsDeclaration)
+                if (readDfMethodDeclaration != null) {
+                    append("\n")
+                    val companionObject = buildCodeBlock {
+                        add("    ")
+                        indent()
+                        indent()
+                        add(readDfMethodDeclaration)
+                    }
+                    append(companionObject.toString())
+                }
+                append("\n}")
+            }
+        } else {
+            ""
+        }
+        resultDeclarations.add(header + baseInterfacesDeclaration + body)
+        return resultDeclarations.join()
+    }
+}
+
+public fun CodeWithConverter.toStandaloneSnippet(packageName: String, additionalImports: List<String>): String =
+    declarations.toStandaloneSnippet(packageName, additionalImports)
+
+public fun Code.toStandaloneSnippet(packageName: String, additionalImports: List<String>): String =
+    buildString {
+        if (packageName.isNotEmpty()) {
+            appendLine("package $packageName")
+            appendLine()
+        }
+        appendLine("import org.jetbrains.kotlinx.dataframe.ColumnsContainer")
+        appendLine("import org.jetbrains.kotlinx.dataframe.DataColumn")
+        appendLine("import org.jetbrains.kotlinx.dataframe.DataFrame")
+        appendLine("import org.jetbrains.kotlinx.dataframe.DataRow")
+        appendLine("import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup")
+        appendLine("import org.jetbrains.kotlinx.dataframe.annotations.ColumnName")
+        appendLine("import org.jetbrains.kotlinx.dataframe.annotations.DataSchema")
+        appendLine("import org.jetbrains.kotlinx.dataframe.api.cast")
+        additionalImports.forEach {
+            appendLine(it)
+        }
+        appendLine()
+        appendLine(this@toStandaloneSnippet)
+    }
+
+public fun CodeGenResult.toStandaloneSnippet(packageName: String, additionalImports: List<String>): String =
+    code.toStandaloneSnippet(packageName, additionalImports)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/NameNormalizerImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/NameNormalizerImpl.kt
new file mode 100644
index 000000000..8face7af3
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/NameNormalizerImpl.kt
@@ -0,0 +1,23 @@
+package org.jetbrains.kotlinx.dataframe.impl.codeGen
+
+import org.jetbrains.kotlinx.dataframe.codeGen.NameNormalizer
+import org.jetbrains.kotlinx.dataframe.impl.toCamelCaseByDelimiters
+import java.util.*
+
+public fun NameNormalizer.Companion.from(normalizationDelimiters: Set<Char>): NameNormalizer {
+    val delimitersSet = normalizationDelimiters.joinToString("", "[", "]")
+    val delimitedStringRegex by lazy {
+        ".+$delimitersSet.+".toRegex()
+    }
+    return NameNormalizer {
+        when {
+            normalizationDelimiters.isEmpty() -> it
+            it matches delimitedStringRegex -> {
+                it.lowercase(Locale.getDefault()).toCamelCaseByDelimiters(delimitersSet.toRegex())
+            }
+            else -> it
+        }
+    }
+}
+
+public fun NameNormalizer.Companion.id(): NameNormalizer = NameNormalizer { it }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/ReplCodeGeneratorImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/ReplCodeGeneratorImpl.kt
new file mode 100644
index 000000000..ee32c8e23
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/ReplCodeGeneratorImpl.kt
@@ -0,0 +1,144 @@
+package org.jetbrains.kotlinx.dataframe.impl.codeGen
+
+import org.jetbrains.dataframe.impl.codeGen.CodeGenerator
+import org.jetbrains.dataframe.impl.codeGen.InterfaceGenerationMode
+import org.jetbrains.dataframe.impl.codeGen.ReplCodeGenerator
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.codeGen.CodeWithConverter
+import org.jetbrains.kotlinx.dataframe.codeGen.Marker
+import org.jetbrains.kotlinx.dataframe.codeGen.MarkerVisibility
+import org.jetbrains.kotlinx.dataframe.codeGen.MarkersExtractor
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import org.jetbrains.kotlinx.jupyter.api.Code
+import kotlin.reflect.KClass
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.KVisibility
+import kotlin.reflect.full.findAnnotation
+import kotlin.reflect.full.superclasses
+import kotlin.reflect.jvm.jvmErasure
+
+internal class ReplCodeGeneratorImpl : ReplCodeGenerator {
+
+    companion object {
+        internal val markerInterfacePrefix = "_DataFrameType"
+    }
+
+    private val registeredProperties = mutableSetOf<KProperty<*>>()
+
+    private val registeredMarkers = mutableMapOf<KClass<*>, Marker>()
+
+    private val generatedMarkers = mutableMapOf<String, Marker>()
+
+    private val generator: CodeGenerator = CodeGenerator.create(useFqNames = false)
+
+    private fun getMarkerClass(type: KType): KClass<*>? =
+        when (type.classifier) {
+            DataFrame::class -> type.arguments[0].type?.jvmErasure
+            DataRow::class -> type.arguments[0].type?.jvmErasure
+            else -> null
+        }
+
+    override fun process(row: AnyRow, property: KProperty<*>?): CodeWithConverter = process(row.df(), property)
+
+    override fun process(df: AnyFrame, property: KProperty<*>?): CodeWithConverter {
+        var targetSchema = df.schema()
+
+        if (property != null) {
+            val wasProcessedBefore = property in registeredProperties
+            registeredProperties.add(property)
+
+            // maybe property is already properly typed, let's do some checks
+            val currentMarker = getMarkerClass(property.returnType)
+                ?.takeIf { it.findAnnotation<DataSchema>() != null }
+                ?.let { registeredMarkers[it] ?: MarkersExtractor.get(it) }
+            if (currentMarker != null) {
+                // we need to make sure that the property's marker type is open in order to let derived data frames be assignable to it
+                if (currentMarker.isOpen) {
+                    val columnSchema = currentMarker.schema
+                    // for mutable properties we do strong typing only at the first processing, after that we allow its type to be more general than actual data frame type
+                    if (wasProcessedBefore || columnSchema == targetSchema) {
+                        // property scheme is valid for current data frame, but we should also check that all compatible open markers are implemented by it
+                        val requiredBaseMarkers = registeredMarkers.values.filterRequiredForSchema(columnSchema)
+                        if (requiredBaseMarkers.any() && requiredBaseMarkers.all { currentMarker.implements(it) }) {
+                            return CodeWithConverter.Empty
+                        }
+                        // use current marker scheme as a target for generation of new marker interface, so that available properties won't change
+                        targetSchema = columnSchema
+                    }
+                }
+            }
+        }
+
+        return generate(schema = targetSchema, name = markerInterfacePrefix, isOpen = true)
+    }
+
+    fun generate(
+        schema: DataFrameSchema,
+        name: String,
+        isOpen: Boolean,
+    ): CodeWithConverter {
+        val result = generator.generate(
+            schema = schema,
+            name = name,
+            fields = false,
+            extensionProperties = true,
+            isOpen = isOpen,
+            visibility = MarkerVisibility.IMPLICIT_PUBLIC,
+            knownMarkers = registeredMarkers
+                .filterKeys { it.visibility != KVisibility.PRIVATE }
+                .values,
+        )
+
+        result.newMarkers.forEach {
+            generatedMarkers[it.name] = it
+        }
+        return result.code
+    }
+
+    override fun process(markerClass: KClass<*>): Code {
+        val newMarkers = mutableListOf<Marker>()
+
+        fun resolve(clazz: KClass<*>): Marker {
+            val processed = registeredMarkers[clazz]
+            if (processed != null) return processed
+            val temp = generatedMarkers[clazz.simpleName!!]
+            if (temp != null) {
+                val baseClasses = clazz.superclasses.filter { it != Any::class }
+
+                val baseClassNames = baseClasses.map {
+                    it.simpleName!!
+                }.sorted()
+
+                val tempBaseClassNames = temp.superMarkers.map { it.value.shortName }.sorted()
+
+                if (baseClassNames == tempBaseClassNames) {
+                    val newBaseMarkers = baseClasses.map { resolve(it) }
+                    val newMarker = Marker(
+                        name = clazz.qualifiedName!!,
+                        isOpen = temp.isOpen,
+                        fields = temp.fields,
+                        superMarkers = newBaseMarkers,
+                        visibility = MarkerVisibility.IMPLICIT_PUBLIC,
+                        klass = clazz,
+                    )
+                    registeredMarkers[markerClass] = newMarker
+                    generatedMarkers.remove(temp.name)
+                    return newMarker
+                }
+            }
+            val marker = MarkersExtractor.get(markerClass)
+            registeredMarkers[markerClass] = marker
+            newMarkers.add(marker)
+            return marker
+        }
+
+        val marker = resolve(markerClass)
+        return newMarkers.map { generator.generate(marker, InterfaceGenerationMode.None, true).declarations }.join()
+    }
+}
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
new file mode 100644
index 000000000..2d82865a8
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaProcessorImpl.kt
@@ -0,0 +1,159 @@
+package org.jetbrains.kotlinx.dataframe.impl.codeGen
+
+import org.jetbrains.kotlinx.dataframe.codeGen.FieldType
+import org.jetbrains.kotlinx.dataframe.codeGen.GeneratedField
+import org.jetbrains.kotlinx.dataframe.codeGen.Marker
+import org.jetbrains.kotlinx.dataframe.codeGen.MarkerVisibility
+import org.jetbrains.kotlinx.dataframe.codeGen.SchemaProcessor
+import org.jetbrains.kotlinx.dataframe.codeGen.ValidFieldName
+import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+
+internal class SchemaProcessorImpl(
+    existingMarkers: Iterable<Marker>,
+    override val namePrefix: String,
+    private val fieldNameNormalizer: (String) -> String = { it },
+) : SchemaProcessor {
+
+    private val registeredMarkers = existingMarkers.toMutableList()
+
+    private val usedMarkerNames = existingMarkers.map { it.shortName }.toMutableSet()
+
+    override val generatedMarkers = mutableListOf<Marker>()
+
+    private fun DataFrameSchema.getAllSuperMarkers() = registeredMarkers
+        .filter { it.isOpen && it.schema.compare(this).isSuperOrEqual() }
+
+    private fun List<Marker>.onlyLeafs(): List<Marker> {
+        val skip = flatMap { it.allSuperMarkers.keys }.toSet()
+        return filter { !skip.contains(it.name) }
+    }
+
+    private fun generateValidFieldName(columnName: String, index: Int, usedNames: Collection<String>): ValidFieldName {
+        var result = ValidFieldName.of(columnName)
+        result = ValidFieldName.of(fieldNameNormalizer(result.unquoted))
+        if (result.unquoted.isEmpty()) result = ValidFieldName.of("_$index")
+        val baseName = result
+        var attempt = 2
+        while (usedNames.contains(result.quotedIfNeeded)) {
+            result =
+                if (result.needsQuote) baseName + ValidFieldName.of(" ($attempt)") else baseName + ValidFieldName.of("$attempt")
+            attempt++
+        }
+        return result
+    }
+
+    private fun generateUniqueMarkerClassName(prefix: String): String {
+        if (!usedMarkerNames.contains(prefix)) return prefix
+        var id = 1
+        while (usedMarkerNames.contains("$prefix$id"))
+            id++
+        return "$prefix$id"
+    }
+
+    private fun generateFields(
+        schema: DataFrameSchema,
+        visibility: MarkerVisibility,
+        requiredSuperMarkers: List<Marker> = emptyList(),
+    ): List<GeneratedField> {
+        val usedFieldNames =
+            requiredSuperMarkers.flatMap { it.allFields.map { it.fieldName.quotedIfNeeded } }.toMutableSet()
+
+        fun getFieldType(columnSchema: ColumnSchema): FieldType = when (columnSchema) {
+            is ColumnSchema.Value -> FieldType.ValueFieldType(columnSchema.type.toString())
+            is ColumnSchema.Group -> FieldType.GroupFieldType(process(columnSchema.schema, false, visibility).name)
+            is ColumnSchema.Frame -> FieldType.FrameFieldType(
+                process(columnSchema.schema, false, visibility).name,
+                columnSchema.nullable
+            )
+
+            else -> throw NotImplementedError()
+        }
+
+        return schema.columns.asIterable().sortedBy { it.key }.flatMapIndexed { index, column ->
+            val (columnName, columnSchema) = column
+            val fieldType = getFieldType(columnSchema)
+            // find all fields that were already generated for this column name in base interfaces
+            val superFields = requiredSuperMarkers.mapNotNull { it.getField(columnName) }
+
+            val fieldsToOverride = superFields
+                .filter { it.columnSchema != columnSchema }
+                .map { it.fieldName }
+                .distinctBy { it.unquoted }
+
+            val newFields = when {
+                fieldsToOverride.isNotEmpty() -> fieldsToOverride.map {
+                    GeneratedField(it, columnName, true, columnSchema, fieldType)
+                }
+
+                superFields.isNotEmpty() -> emptyList()
+                else -> {
+                    val fieldName = generateValidFieldName(columnName, index, usedFieldNames)
+                    usedFieldNames.add(fieldName.quotedIfNeeded)
+                    listOf(GeneratedField(fieldName, columnName, false, columnSchema, fieldType))
+                }
+            }
+            newFields
+        }
+    }
+
+    private fun createMarkerSchema(
+        scheme: DataFrameSchema,
+        name: String,
+        withBaseInterfaces: Boolean,
+        isOpen: Boolean,
+        visibility: MarkerVisibility,
+    ): Marker {
+        val baseMarkers = mutableListOf<Marker>()
+        val fields = if (withBaseInterfaces) {
+            baseMarkers += scheme.getRequiredMarkers().onlyLeafs()
+
+            val columnNames = scheme.columns.keys
+            val superColumns = baseMarkers.flatMap { it.allFields.map { it.columnName } }.toSet()
+
+            val newColumns = (columnNames - superColumns).toMutableSet()
+
+            if (newColumns.isNotEmpty()) {
+                val availableMarkers = scheme.getAllSuperMarkers().toMutableList()
+                availableMarkers -= baseMarkers.toSet()
+
+                while (newColumns.size > 0) {
+                    val bestMarker = availableMarkers
+                        .map { marker -> marker to newColumns.count { marker.containsColumn(it) } }
+                        .maxByOrNull { it.second }
+                    if (bestMarker != null && bestMarker.second > 0) {
+                        newColumns.removeAll(bestMarker.first.columnNames.toSet())
+                        baseMarkers += bestMarker.first
+                        availableMarkers -= bestMarker.first
+                    } else break
+                }
+            }
+            generateFields(scheme, visibility, baseMarkers)
+        } else generateFields(scheme, visibility)
+        return Marker(name, isOpen, fields, baseMarkers.onlyLeafs(), visibility, emptyList(), emptyList())
+    }
+
+    private fun DataFrameSchema.getRequiredMarkers() = registeredMarkers.filterRequiredForSchema(this)
+
+    override fun process(
+        schema: DataFrameSchema,
+        isOpen: Boolean,
+        visibility: MarkerVisibility,
+    ): Marker {
+        val markerName: String
+        val required = schema.getRequiredMarkers()
+        val existingMarker = registeredMarkers.firstOrNull {
+            (!isOpen || it.isOpen) && it.schema == schema && it.implementsAll(required)
+        }
+        if (existingMarker != null) {
+            return existingMarker
+        } else {
+            markerName = generateUniqueMarkerClassName(namePrefix)
+            usedMarkerNames.add(markerName)
+            val marker = createMarkerSchema(schema, markerName, true, isOpen, visibility)
+            registeredMarkers.add(marker)
+            generatedMarkers.add(marker)
+            return marker
+        }
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaReader.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaReader.kt
new file mode 100644
index 000000000..b5ed79216
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaReader.kt
@@ -0,0 +1,94 @@
+package org.jetbrains.kotlinx.dataframe.impl.codeGen
+
+import org.jetbrains.dataframe.impl.codeGen.CodeGenerator
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadDfMethod
+import org.jetbrains.kotlinx.dataframe.io.SupportedCodeGenerationFormat
+import org.jetbrains.kotlinx.dataframe.io.SupportedDataFrameFormat
+import org.jetbrains.kotlinx.dataframe.io.SupportedFormat
+import org.jetbrains.kotlinx.dataframe.io.guessFormat
+import org.jetbrains.kotlinx.dataframe.io.read
+import org.jetbrains.kotlinx.dataframe.io.readCodeForGeneration
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import org.jetbrains.kotlinx.jupyter.api.Code
+import java.net.URL
+
+/**
+ * Reader that can read a data frame from a URL. It tries to guess the format based on the given [formats] and returns
+ * [DfReadResult.Success], or returns [DfReadResult.Error] if it fails.
+ */
+public val CodeGenerator.Companion.urlDfReader: (url: URL, formats: List<SupportedFormat>) -> DfReadResult
+    get() = { url, formats ->
+        try {
+            val (format, df) = url.openStream().use {
+                DataFrame.read(
+                    stream = it,
+                    format = guessFormat(url, formats) as? SupportedDataFrameFormat?,
+                    formats = formats.filterIsInstance<SupportedDataFrameFormat>(),
+                )
+            }
+            DfReadResult.Success(df, format)
+        } catch (e: Throwable) {
+            DfReadResult.Error(e)
+        }
+    }
+
+public sealed interface DfReadResult {
+
+    public class Success(
+        private val df: AnyFrame,
+        public val format: SupportedDataFrameFormat,
+    ) : DfReadResult {
+        public fun getReadDfMethod(pathRepresentation: String?): DefaultReadDfMethod {
+            return format.createDefaultReadMethod(pathRepresentation)
+        }
+
+        public val schema: DataFrameSchema = df.schema()
+    }
+
+    public class Error(public val reason: Throwable) : DfReadResult
+}
+
+/**
+ * Reader that can read data from a URL and generate code (type schema representations) for it.
+ * It tries to guess the format based on the given [formats] and returns [CodeGenerationReadResult.Success],
+ * or returns [CodeGenerationReadResult.Error] if it fails.
+ */
+public val CodeGenerator.Companion.urlCodeGenReader: (
+    url: URL,
+    name: String,
+    formats: List<SupportedFormat>,
+    generateHelperCompanionObject: Boolean,
+) -> CodeGenerationReadResult
+    get() = { url, name, formats, generateHelperCompanionObject ->
+        try {
+            val (format, code) = url.openStream().use {
+                readCodeForGeneration(
+                    stream = it,
+                    name = name,
+                    format = guessFormat(url, formats) as? SupportedCodeGenerationFormat?,
+                    generateHelperCompanionObject = generateHelperCompanionObject,
+                    formats = formats.filterIsInstance<SupportedCodeGenerationFormat>(),
+                )
+            }
+            CodeGenerationReadResult.Success(code, format)
+        } catch (e: Throwable) {
+            CodeGenerationReadResult.Error(e)
+        }
+    }
+
+public sealed interface CodeGenerationReadResult {
+
+    public class Success(
+        public val code: Code,
+        public val format: SupportedCodeGenerationFormat,
+    ) : CodeGenerationReadResult {
+        public fun getReadDfMethod(pathRepresentation: String?): DefaultReadDfMethod {
+            return format.createDefaultReadMethod(pathRepresentation)
+        }
+    }
+
+    public class Error(public val reason: Throwable) : CodeGenerationReadResult
+}
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
new file mode 100644
index 000000000..3f6e14e82
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnAccessorImpl.kt
@@ -0,0 +1,42 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.toPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+
+internal class ColumnAccessorImpl<T>(val path: ColumnPath) : ColumnAccessor<T> {
+
+    override fun name() = path.last()
+
+    override fun path() = path
+
+    constructor(vararg path: String) : this(path.toPath())
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? {
+        var df = context.df
+        var col: AnyCol? = null
+        for (colName in path) {
+            col = df.getColumn<Any?>(colName, context.unresolvedColumnsPolicy) ?: return null
+            if (col.isColumnGroup()) {
+                df = col.asColumnGroup()
+            }
+        }
+        return col?.cast<T>()?.addPath(path)
+    }
+
+    override fun rename(newName: String) = ColumnAccessorImpl<T>(path.dropLast(1) + newName)
+
+    override fun <C> get(column: ColumnReference<C>) = ColumnAccessorImpl<C>(path + column.path())
+
+    override fun getValue(row: AnyRow) = path.getValue(row) as T
+
+    override fun getValueOrNull(row: AnyRow) = path.getValueOrNull(row) as T
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupImpl.kt
new file mode 100644
index 000000000..0ba672198
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupImpl.kt
@@ -0,0 +1,105 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.firstOrNull
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameImpl
+import org.jetbrains.kotlinx.dataframe.impl.createTypeWithArgument
+import org.jetbrains.kotlinx.dataframe.impl.renderSchema
+import org.jetbrains.kotlinx.dataframe.nrow
+import kotlin.reflect.KType
+
+internal val anyRowType = createTypeWithArgument<AnyRow>()
+
+internal open class ColumnGroupImpl<T>(private val name: String, df: DataFrame<T>) :
+    DataFrameImpl<T>(df.columns(), df.nrow),
+    DataColumnInternal<DataRow<T>>,
+    DataColumnGroup<T> {
+
+    override fun values() = rows()
+
+    override fun countDistinct() = distinct.value.size
+
+    override fun type() = anyRowType
+
+    private val distinct = lazy { df.rows().toSet() }
+
+    override fun toSet() = distinct.value
+
+    override fun size() = rowsCount()
+
+    override fun get(index: Int) = super<DataFrameImpl>.get(index)
+
+    override fun get(firstIndex: Int, vararg otherIndices: Int) = ColumnGroupImpl(name, super<DataFrameImpl>.get(firstIndex, *otherIndices))
+
+    override fun rename(newName: String) = if (newName == name) this else ColumnGroupImpl(newName, this)
+
+    override fun defaultValue() = null
+
+    override fun get(indices: Iterable<Int>) = ColumnGroupImpl(name, super<DataFrameImpl>.get(indices))
+
+    override fun addParent(parent: ColumnGroup<*>): DataColumn<DataRow<T>> = ColumnGroupWithParent(parent, this)
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        val g = other as? ColumnGroup<*> ?: return false
+        return name == g.name() && columns == other.columns()
+    }
+
+    private fun computeHashCode() = name.hashCode() * 31 + super.hashCode()
+
+    private val hashCode by lazy { computeHashCode() }
+
+    override fun hashCode() = hashCode
+
+    override fun toString() = "$name: {${renderSchema(this)}}"
+
+    override fun changeType(type: KType) = throw UnsupportedOperationException()
+
+    override fun name() = name
+
+    override fun distinct() = ColumnGroupImpl(name, get(distinct.value.map { it.index() }))
+
+    override fun resolve(context: ColumnResolutionContext) = super<DataColumnInternal>.resolve(context)
+
+    override fun resolveSingle(context: ColumnResolutionContext) = super<DataColumnInternal>.resolveSingle(context)
+
+    override fun iterator() = super<DataFrameImpl>.iterator()
+
+    override fun forceResolve() = ResolvingColumnGroup(this)
+
+    override fun get(range: IntRange) = ColumnGroupImpl(name, super<DataFrameImpl>.get(range))
+
+    override fun get(columnName: String): AnyCol = getColumn(columnName)
+
+    override fun contains(value: DataRow<T>) = if (distinct.isInitialized()) distinct.value.contains(value) else asColumnGroup().firstOrNull { it == value } != null
+}
+
+internal class ResolvingColumnGroup<T>(
+    override val source: ColumnGroupImpl<T>
+) : DataColumnGroup<T> by source, ForceResolvedColumn<DataRow<T>> {
+
+    override fun resolve(context: ColumnResolutionContext) = super<DataColumnGroup>.resolve(context)
+
+    override fun resolveSingle(context: ColumnResolutionContext) = context.df.getColumn<DataRow<T>>(source.name(), context.unresolvedColumnsPolicy)?.addPath()
+
+    override fun getValue(row: AnyRow) = super<DataColumnGroup>.getValue(row)
+
+    override fun getValueOrNull(row: AnyRow) = super<DataColumnGroup>.getValueOrNull(row)
+
+    override fun rename(newName: String) = ResolvingColumnGroup(source.rename(newName))
+
+    override fun toString(): String = source.toString()
+
+    override fun equals(other: Any?) = source.checkEquals(other)
+
+    override fun hashCode(): Int = source.hashCode()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupWithParent.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupWithParent.kt
new file mode 100644
index 000000000..b05de6090
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupWithParent.kt
@@ -0,0 +1,60 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.ColumnGroupReference
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.castFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.api.getColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.columnName
+import kotlin.reflect.KProperty
+
+internal class ColumnGroupWithParent<T>(override val parent: ColumnGroupReference?, override val source: ColumnGroup<T>) : ColumnGroupImpl<T>(source.name(), source), ColumnWithParent<DataRow<T>> {
+
+    override fun path() = super<ColumnWithParent>.path()
+
+    override fun getValue(thisRef: Any?, property: KProperty<*>): DataColumnGroup<T> = source.getValue(thisRef, property) as DataColumnGroup<T>
+
+    override fun equals(other: Any?) = source.checkEquals(other)
+
+    override fun hashCode() = source.hashCode()
+
+    override fun resolveSingle(context: ColumnResolutionContext) = super<ColumnWithParent>.resolveSingle(context)
+
+    override fun resolve(context: ColumnResolutionContext) = super<ColumnWithParent>.resolve(context)
+
+    // region get column
+
+    override fun columns() = super.columns().map { it.addParent(this) }
+
+    override fun getColumnOrNull(index: Int) = super.getColumnOrNull(index)?.addParent(this)
+    override fun getColumnOrNull(name: String) = super.getColumnOrNull(name)?.addParent(this)
+    override fun <R> getColumnOrNull(column: ColumnReference<R>) = super.getColumnOrNull(column)?.addParent(this)
+    override fun getColumnOrNull(path: ColumnPath) = path.fold(this as AnyCol?) { col, name -> col?.asColumnGroup()?.getColumnOrNull(name) }
+    override fun <R> getColumnOrNull(column: ColumnSelector<T, R>) = getColumnOrNull(getColumnWithPath(column).path)?.cast<R>()
+
+    override operator fun get(columnName: String): AnyCol = getColumn(columnName)
+    override operator fun get(columnPath: ColumnPath): AnyCol = getColumn(columnPath)
+
+    override operator fun <R> get(column: KProperty<R>): DataColumn<R> = get(column.columnName).cast()
+    override operator fun <R> get(column: KProperty<DataRow<R>>): ColumnGroup<R> = get(column.columnName).asColumnGroup().cast()
+    override operator fun <R> get(column: KProperty<DataFrame<R>>): FrameColumn<R> = get(column.columnName).asAnyFrameColumn().castFrameColumn()
+
+    override operator fun <C> get(columns: ColumnsSelector<T, C>): List<DataColumn<C>> = super.get(columns).map { it.addParent(this) }
+    override operator fun <C> get(column: ColumnSelector<T, C>): DataColumn<C> = get(column as ColumnsSelector<T, C>).single()
+
+    // endregion
+
+    override fun get(firstIndex: Int, vararg otherIndices: Int) = ColumnGroupWithParent(parent, super.get(firstIndex, *otherIndices))
+}
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
new file mode 100644
index 000000000..f18478ba9
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnGroupWithPathImpl.kt
@@ -0,0 +1,26 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+
+internal class ColumnGroupWithPathImpl<T> internal constructor(
+    val column: ColumnGroup<T>,
+    override val path: ColumnPath
+) : ColumnWithPath<DataRow<T>>, ColumnGroupImpl<T>(column.name, column) {
+
+    override fun rename(newName: String) = if (newName == name()) this else ColumnGroupWithPathImpl(
+        column.rename(
+            newName
+        ),
+        path.dropLast(1) + newName
+    )
+
+    override val data: DataColumn<DataRow<T>>
+        get() = column as DataColumn<DataRow<T>>
+
+    override fun path() = path
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnWithParent.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnWithParent.kt
new file mode 100644
index 000000000..d7b00b3c8
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnWithParent.kt
@@ -0,0 +1,34 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.ColumnGroupReference
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.columns.BaseColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.impl.emptyPath
+
+internal interface ColumnWithParent<out C> : ColumnReference<C> {
+
+    val parent: ColumnGroupReference?
+
+    val source: BaseColumn<C>
+
+    override fun path() = parent?.path()?.plus(name()) ?: pathOf(name())
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>? {
+        val parentDef = parent
+        val (targetDf, pathPrefix) = when (parentDef) {
+            null -> context.df to emptyPath()
+            else -> {
+                val parentCol = parentDef.resolveSingle(context) ?: return null
+                val group = parentCol.data.asColumnGroup()
+                group to parentCol.path
+            }
+        }
+
+        val data = targetDf.getColumn<C>(name(), context.unresolvedColumnsPolicy)
+        return data?.addPath(pathPrefix + name())
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnsList.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnsList.kt
new file mode 100644
index 000000000..4fe7c9885
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnsList.kt
@@ -0,0 +1,10 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+
+internal class ColumnsList<C>(val columns: List<ColumnSet<C>>) : ColumnSet<C> {
+    constructor(vararg columns: ColumnSet<C>) : this(columns.toList())
+
+    override fun resolve(context: ColumnResolutionContext) = columns.flatMap { it.resolve(context) }
+}
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
new file mode 100644
index 000000000..a4b39041a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ComputedColumnReference.kt
@@ -0,0 +1,33 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.api.Infer
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import kotlin.reflect.KType
+
+internal class ComputedColumnReference<R>(
+    val name: String,
+    val type: KType,
+    val infer: Infer,
+    val compute: RowExpression<Any?, R>
+) :
+    ColumnReference<R> {
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<R> {
+        return context.df.newColumn(type, name, infer) { compute(it, it) }.addPath()
+    }
+
+    override fun name() = name
+
+    override fun rename(newName: String) = ComputedColumnReference(newName, type, infer, compute)
+
+    override fun getValue(row: AnyRow) = compute(row, row)
+
+    override fun getValueOrNull(row: AnyRow) = compute(row, row)
+}
+
+@PublishedApi
+internal fun <R> createComputedColumnReference(name: String, type: KType, infer: Infer, compute: RowExpression<Any?, R>): ColumnReference<R> = ComputedColumnReference(name, type, infer, compute)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnGroup.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnGroup.kt
new file mode 100644
index 000000000..db51c8690
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnGroup.kt
@@ -0,0 +1,21 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import kotlin.reflect.KProperty
+
+internal interface DataColumnGroup<out T> : ColumnGroup<T>, DataColumn<DataRow<T>> {
+
+    override operator fun getValue(thisRef: Any?, property: KProperty<*>): DataColumnGroup<T> = super<DataColumn>.getValue(thisRef, property) as DataColumnGroup<T>
+
+    override fun iterator() = super<ColumnGroup>.iterator()
+
+    override fun rename(newName: String): DataColumnGroup<T>
+
+    override fun get(indices: Iterable<Int>): DataColumnGroup<T>
+
+    override fun distinct(): DataColumnGroup<T>
+
+    override fun get(range: IntRange): DataColumnGroup<T>
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnImpl.kt
new file mode 100644
index 000000000..b89dcd649
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnImpl.kt
@@ -0,0 +1,43 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import kotlin.reflect.KType
+
+internal abstract class DataColumnImpl<T>(
+    protected val values: List<T>,
+    val name: String,
+    val type: KType,
+    distinct: Lazy<Set<T>>? = null
+) : DataColumn<T>, DataColumnInternal<T> {
+
+    protected val distinct = distinct ?: lazy { values.toSet() }
+
+    override fun name() = name
+
+    override fun values() = values
+
+    override fun type() = type
+
+    override fun toSet() = distinct.value
+
+    override fun contains(value: T): Boolean = if (distinct.isInitialized()) distinct.value.contains(value) else values.contains(value)
+
+    override fun toString() = dataFrameOf(this).toString() // "${name()}: $type"
+
+    override fun countDistinct() = toSet().size
+
+    override fun get(index: Int) = values[index]
+
+    override fun size() = values.size
+
+    override fun equals(other: Any?) = checkEquals(other)
+
+    private val hashCode by lazy { getHashCode() }
+
+    override fun hashCode() = hashCode
+
+    override operator fun get(range: IntRange) = createWithValues(values.subList(range.start, range.endInclusive + 1))
+
+    protected abstract fun createWithValues(values: List<T>, hasNulls: Boolean? = null): DataColumn<T>
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnInternal.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnInternal.kt
new file mode 100644
index 000000000..d4298c43a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnInternal.kt
@@ -0,0 +1,20 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import kotlin.reflect.KType
+
+internal interface DataColumnInternal<T> : DataColumn<T> {
+
+    override fun rename(newName: String): DataColumnInternal<T>
+    fun forceResolve(): DataColumn<T>
+    fun changeType(type: KType): DataColumn<T>
+    fun addParent(parent: ColumnGroup<*>): DataColumn<T>
+}
+
+internal fun <T> DataColumn<T>.internal() = this as DataColumnInternal<T>
+
+// TODO: replace forced column resolution with column origin tracking
+@PublishedApi
+internal fun <T : AnyCol> T.forceResolve(): T = if (this is ForceResolvedColumn<*>) this else internal().forceResolve() as T
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DistinctColumnSet.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DistinctColumnSet.kt
new file mode 100644
index 000000000..2c5653ff5
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DistinctColumnSet.kt
@@ -0,0 +1,10 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+
+internal class DistinctColumnSet<T>(val src: ColumnSet<T>) : ColumnSet<T> {
+    override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<T>> =
+        src.resolve(context).distinctBy { it.path }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ForceResolvedColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ForceResolvedColumn.kt
new file mode 100644
index 000000000..686a89c84
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ForceResolvedColumn.kt
@@ -0,0 +1,7 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+
+internal interface ForceResolvedColumn<T> : DataColumn<T> {
+    val source: DataColumn<T>
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/FrameColumnImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/FrameColumnImpl.kt
new file mode 100644
index 000000000..ae9300320
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/FrameColumnImpl.kt
@@ -0,0 +1,72 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.createStarProjectedType
+import org.jetbrains.kotlinx.dataframe.impl.schema.intersectSchemas
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import kotlin.reflect.KType
+
+internal open class FrameColumnImpl<T> constructor(
+    name: String,
+    values: List<DataFrame<T>>,
+    columnSchema: Lazy<DataFrameSchema>? = null,
+    distinct: Lazy<Set<DataFrame<T>>>? = null
+) :
+    DataColumnImpl<DataFrame<T>>(
+        values,
+        name,
+        DataFrame::class.createStarProjectedType(false),
+        distinct
+    ),
+    FrameColumn<T> {
+
+    override fun rename(newName: String) = FrameColumnImpl(newName, values, schema, distinct)
+
+    override fun defaultValue() = null
+
+    override fun addParent(parent: ColumnGroup<*>) = FrameColumnWithParent(parent, this)
+
+    override fun createWithValues(values: List<DataFrame<T>>, hasNulls: Boolean?) = DataColumn.createFrameColumn(name, values)
+
+    override fun changeType(type: KType) = throw UnsupportedOperationException()
+
+    override fun distinct() = FrameColumnImpl(name, distinct.value.toList(), schema, distinct)
+
+    override val schema: Lazy<DataFrameSchema> = columnSchema ?: lazy {
+        values.mapNotNull { it.takeIf { it.nrow > 0 }?.schema() }.intersectSchemas()
+    }
+
+    override fun forceResolve() = ResolvingFrameColumn(this)
+
+    override fun get(indices: Iterable<Int>): FrameColumn<T> = DataColumn.createFrameColumn(name, indices.map { values[it] })
+
+    override fun get(columnName: String) = throw UnsupportedOperationException("Can not get nested column '$columnName' from FrameColumn '$name'")
+}
+
+internal class ResolvingFrameColumn<T>(
+    override val source: FrameColumn<T>
+) : FrameColumn<T> by source, ForceResolvedColumn<DataFrame<T>> {
+
+    override fun resolve(context: ColumnResolutionContext) = super<FrameColumn>.resolve(context)
+
+    override fun resolveSingle(context: ColumnResolutionContext) = context.df.getColumn<DataFrame<T>>(source.name(), context.unresolvedColumnsPolicy)?.addPath()
+
+    override fun getValue(row: AnyRow) = super<FrameColumn>.getValue(row)
+
+    override fun getValueOrNull(row: AnyRow) = super<FrameColumn>.getValueOrNull(row)
+
+    override fun rename(newName: String) = ResolvingFrameColumn(source.rename(newName))
+
+    override fun toString(): String = source.toString()
+
+    override fun equals(other: Any?) = source.checkEquals(other)
+
+    override fun hashCode(): Int = source.hashCode()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/FrameColumnWithParent.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/FrameColumnWithParent.kt
new file mode 100644
index 000000000..c7c803323
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/FrameColumnWithParent.kt
@@ -0,0 +1,32 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.asFrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import kotlin.reflect.KType
+
+internal class FrameColumnWithParent<T>(
+    override val parent: ColumnGroup<*>,
+    override val source: FrameColumn<T>
+) : ColumnWithParent<DataFrame<T>>, FrameColumn<T> by source, DataColumnInternal<DataFrame<T>> {
+
+    override fun equals(other: Any?) = source.checkEquals(other)
+
+    override fun hashCode() = source.hashCode()
+
+    override fun path() = super<ColumnWithParent>.path()
+
+    override fun resolve(context: ColumnResolutionContext) = super<ColumnWithParent>.resolve(context)
+
+    override fun resolveSingle(context: ColumnResolutionContext) = super<ColumnWithParent>.resolveSingle(context)
+
+    override fun forceResolve() = ResolvingFrameColumn(this)
+
+    override fun changeType(type: KType) = FrameColumnWithParent(parent, source.internal().changeType(type).asFrameColumn())
+
+    override fun addParent(parent: ColumnGroup<*>) = FrameColumnWithParent(parent, source)
+
+    override fun rename(newName: String) = FrameColumnWithParent(parent, source.rename(newName))
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/FrameColumnWithPathImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/FrameColumnWithPathImpl.kt
new file mode 100644
index 000000000..4ac537b23
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/FrameColumnWithPathImpl.kt
@@ -0,0 +1,19 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+
+internal class FrameColumnWithPathImpl<T> internal constructor(
+    override val data: FrameColumn<T>,
+    override val path: ColumnPath
+) : ColumnWithPath<DataFrame<T>>, FrameColumn<T> by data {
+
+    override fun rename(newName: String) = if (newName == name()) this else FrameColumnWithPathImpl(
+        data.rename(newName),
+        path.dropLast(1) + newName
+    )
+
+    override fun path() = path
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/RenamedColumnReference.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/RenamedColumnReference.kt
new file mode 100644
index 000000000..ec4eea35d
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/RenamedColumnReference.kt
@@ -0,0 +1,21 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+
+internal class RenamedColumnReference<C>(val source: ColumnReference<C>, val name: String) : ColumnReference<C> {
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>? {
+        return source.resolveSingle(context)?.let { it.data.rename(name).addPath(it.path) }
+    }
+
+    override fun name() = name
+
+    override fun rename(newName: String) = RenamedColumnReference(source, newName)
+
+    override fun getValue(row: AnyRow) = source.getValue(row)
+
+    override fun getValueOrNull(row: AnyRow) = source.getValueOrNull(row)
+}
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
new file mode 100644
index 000000000..1c30df9cb
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/Utils.kt
@@ -0,0 +1,191 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.columns.BaseColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.columns.values
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameImpl
+import org.jetbrains.kotlinx.dataframe.impl.asNullable
+import org.jetbrains.kotlinx.dataframe.impl.columns.missing.MissingDataColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.ColumnPosition
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.TreeNode
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.collectTree
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.getOrPut
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.put
+import org.jetbrains.kotlinx.dataframe.impl.columns.tree.topDfs
+import org.jetbrains.kotlinx.dataframe.impl.equalsByElement
+import org.jetbrains.kotlinx.dataframe.impl.rollingHash
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.type
+import kotlin.reflect.KType
+import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.jvm.jvmErasure
+import kotlin.reflect.typeOf
+
+internal fun <T> BaseColumn<T>.checkEquals(other: Any?): Boolean {
+    if (this === other) return true
+
+    if (this !is AnyCol) return false
+    if (other !is AnyCol) return false
+
+    if (name != other.name) return false
+    if (type != other.type) return false
+    return values.equalsByElement(other.values)
+}
+
+internal fun AnyCol.getHashCode(): Int {
+    var result = values.rollingHash()
+    result = 31 * result + name().hashCode()
+    result = 31 * result + type.hashCode()
+    return result
+}
+
+internal fun <C> TreeNode<ColumnPosition>.toColumnWithPath() =
+    (data.column as DataColumn<C>).addPath(pathFromRoot())
+
+internal fun <T> BaseColumn<T>.addPath(path: ColumnPath): ColumnWithPath<T> =
+    when (this) {
+        is ValueColumn<T> -> ValueColumnWithPathImpl(this, path)
+        is FrameColumn<*> -> FrameColumnWithPathImpl(this, path) as ColumnWithPath<T>
+        is ColumnGroup<*> -> ColumnGroupWithPathImpl(this, path) as ColumnWithPath<T>
+        else -> throw IllegalArgumentException("Can't add path to ${this.javaClass}")
+    }
+
+internal fun <T> ColumnWithPath<T>.changePath(path: ColumnPath): ColumnWithPath<T> = data.addPath(path)
+
+internal fun <T> BaseColumn<T>.addParentPath(path: ColumnPath) = addPath(path + name)
+
+internal fun <T> BaseColumn<T>.addPath(): ColumnWithPath<T> = addPath(pathOf(name))
+
+internal fun ColumnPath.depth() = size - 1
+
+internal fun <T> AnyCol.asValues(): ValueColumn<T> = this as ValueColumn<T>
+
+internal fun <T> DataColumn<T>.asValueColumn(): ValueColumn<T> = this as ValueColumn<T>
+
+@PublishedApi
+internal fun AnyCol.asAnyFrameColumn(): FrameColumn<*> = this as FrameColumn<*>
+
+internal fun <T> AnyCol.grouped() = this as ColumnGroup<T>
+internal fun <T> ColumnGroup<*>.withDf(newDf: DataFrame<T>) = DataColumn.createColumnGroup(name, newDf)
+
+internal fun <T> DataColumn<T>.assertIsComparable(): DataColumn<T> {
+    if (!type.isSubtypeOf(typeOf<Comparable<*>?>())) {
+        throw RuntimeException("Column '$name' has type '$type' that is not Comparable")
+    }
+    return this
+}
+
+internal fun <A, B> SingleColumn<A>.transformSingle(converter: (ColumnWithPath<A>) -> List<ColumnWithPath<B>>): ColumnSet<B> =
+    object : ColumnSet<B> {
+        override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<B>> =
+            this@transformSingle.resolveSingle(context)?.let { converter(it) } ?: emptyList()
+    }
+
+internal fun <A, B> ColumnSet<A>.transform(converter: (List<ColumnWithPath<A>>) -> List<ColumnWithPath<B>>): ColumnSet<B> =
+    object : ColumnSet<B> {
+        override fun resolve(context: ColumnResolutionContext) = converter(this@transform.resolve(context))
+    }
+
+internal fun <T> ColumnSet<T>.single() = object : SingleColumn<T> {
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? {
+        return this@single.resolve(context).singleOrNull()
+    }
+}
+
+internal fun <T> ColumnSet<T>.getAt(index: Int) = object : SingleColumn<T> {
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>? {
+        return this@getAt.resolve(context).getOrNull(index)
+    }
+}
+
+internal fun <T> ColumnSet<T>.getChildrenAt(index: Int): ColumnSet<Any?> = transform { it.mapNotNull { it.getChild(index) } }
+
+internal fun <C> ColumnsContainer<*>.getColumn(name: String, policy: UnresolvedColumnsPolicy) =
+    getColumnOrNull(name)?.cast()
+        ?: when (policy) {
+            UnresolvedColumnsPolicy.Fail ->
+                error("Column not found: $name")
+            UnresolvedColumnsPolicy.Skip -> null
+            UnresolvedColumnsPolicy.Create -> DataColumn.empty().cast<C>()
+        }
+
+internal fun <C> ColumnsContainer<*>.getColumn(path: ColumnPath, policy: UnresolvedColumnsPolicy) =
+    getColumnOrNull(path)?.cast()
+        ?: when (policy) {
+            UnresolvedColumnsPolicy.Fail ->
+                error("Column not found: $path")
+            UnresolvedColumnsPolicy.Skip -> null
+            UnresolvedColumnsPolicy.Create -> DataColumn.empty().cast<C>()
+        }
+
+internal fun <T> List<ColumnWithPath<T>>.top(): List<ColumnWithPath<T>> {
+    val root = TreeNode.createRoot<ColumnWithPath<T>?>(null)
+    forEach { root.put(it.path, it) }
+    return root.topDfs { it.data != null }.map { it.data!! }
+}
+
+internal fun List<ColumnWithPath<*>>.allColumnsExcept(columns: Iterable<ColumnWithPath<*>>): List<ColumnWithPath<*>> {
+    if (isEmpty()) return emptyList()
+    val fullTree = collectTree()
+    columns.forEach {
+        var node = fullTree.getOrPut(it.path).asNullable()
+        node?.dfs()?.forEach { it.data = null }
+        while (node != null) {
+            node.data = null
+            node = node.parent
+        }
+    }
+    val dfs = fullTree.topDfs { it.data != null }
+    return dfs.map { it.data!!.addPath(it.pathFromRoot()) }
+}
+
+internal fun KType.toColumnKind(): ColumnKind = jvmErasure.let {
+    when (it) {
+        DataFrame::class -> ColumnKind.Frame
+        DataRow::class -> ColumnKind.Group
+        else -> ColumnKind.Value
+    }
+}
+
+internal fun <C> ColumnSet<C>.resolve(
+    df: DataFrame<*>,
+    unresolvedColumnsPolicy: UnresolvedColumnsPolicy = UnresolvedColumnsPolicy.Fail
+) =
+    resolve(ColumnResolutionContext(df, unresolvedColumnsPolicy))
+
+internal fun <C> SingleColumn<C>.resolveSingle(
+    df: DataFrame<*>,
+    unresolvedColumnsPolicy: UnresolvedColumnsPolicy = UnresolvedColumnsPolicy.Fail
+): ColumnWithPath<C>? =
+    resolveSingle(ColumnResolutionContext(df, unresolvedColumnsPolicy))
+
+internal fun AnyBaseCol.unbox(): AnyCol = when (this) {
+    is ColumnWithPath<*> -> data.unbox()
+    is ColumnWithParent<*> -> source.unbox()
+    is ForceResolvedColumn<*> -> source.unbox()
+    else -> this as AnyCol
+}
+
+internal fun AnyCol.isMissingColumn() = this is MissingDataColumn
+
+internal fun <T> ColumnGroup<T>.extractDataFrame(): DataFrame<T> = DataFrameImpl(columns(), nrow)
+
+internal fun <T> BaseColumn<T>.addParent(parent: ColumnGroup<*>) = (this as DataColumnInternal<T>).addParent(parent)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnImpl.kt
new file mode 100644
index 000000000..b21d8f6f6
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnImpl.kt
@@ -0,0 +1,71 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import kotlin.reflect.KType
+import kotlin.reflect.full.withNullability
+
+internal open class ValueColumnImpl<T>(
+    values: List<T>,
+    name: String,
+    type: KType,
+    val defaultValue: T? = null,
+    distinct: Lazy<Set<T>>? = null
+) :
+    DataColumnImpl<T>(values, name, type, distinct), ValueColumn<T> {
+
+    override fun distinct() = ValueColumnImpl(toSet().toList(), name, type, defaultValue, distinct)
+
+    override fun rename(newName: String) = ValueColumnImpl(values, newName, type, defaultValue, distinct)
+
+    override fun changeType(type: KType) = ValueColumnImpl(values, name, type, defaultValue, distinct)
+
+    override fun addParent(parent: ColumnGroup<*>): DataColumn<T> = ValueColumnWithParent(parent, this)
+
+    override fun createWithValues(values: List<T>, hasNulls: Boolean?): ValueColumn<T> {
+        val nulls = hasNulls ?: values.any { it == null }
+        return DataColumn.createValueColumn(name, values, type.withNullability(nulls))
+    }
+
+    override fun get(indices: Iterable<Int>): ValueColumn<T> {
+        var nullable = false
+        val newValues = indices.map {
+            val value = values[it]
+            if (value == null) nullable = true
+            value
+        }
+        return createWithValues(newValues, nullable)
+    }
+
+    override fun get(columnName: String) = throw UnsupportedOperationException("Can not get nested column '$columnName' from ValueColumn '$name'")
+
+    override operator fun get(range: IntRange): ValueColumn<T> = super<DataColumnImpl>.get(range) as ValueColumn<T>
+
+    override fun defaultValue() = defaultValue
+
+    override fun forceResolve() = ResolvingValueColumn(this)
+}
+
+internal class ResolvingValueColumn<T>(
+    override val source: ValueColumn<T>
+) : ValueColumn<T> by source, ForceResolvedColumn<T> {
+
+    override fun resolve(context: ColumnResolutionContext) = super<ValueColumn>.resolve(context)
+
+    override fun resolveSingle(context: ColumnResolutionContext) = context.df.getColumn<T>(source.name(), context.unresolvedColumnsPolicy)?.addPath()
+
+    override fun getValue(row: AnyRow) = super<ValueColumn>.getValue(row)
+
+    override fun getValueOrNull(row: AnyRow) = super<ValueColumn>.getValueOrNull(row)
+
+    override fun rename(newName: String) = ResolvingValueColumn(source.rename(newName))
+
+    override fun toString(): String = source.toString()
+
+    override fun equals(other: Any?) = source.checkEquals(other)
+
+    override fun hashCode(): Int = source.hashCode()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnWithParent.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnWithParent.kt
new file mode 100644
index 000000000..923788937
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnWithParent.kt
@@ -0,0 +1,27 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import kotlin.reflect.KType
+
+internal class ValueColumnWithParent<T>(override val parent: ColumnGroup<*>, override val source: ValueColumn<T>) : ColumnWithParent<T>, ValueColumn<T> by source, DataColumnInternal<T> {
+
+    override fun equals(other: Any?) = source.checkEquals(other)
+
+    override fun hashCode() = source.hashCode()
+
+    override fun path() = super<ColumnWithParent>.path()
+
+    override fun resolve(context: ColumnResolutionContext) = super<ColumnWithParent>.resolve(context)
+
+    override fun resolveSingle(context: ColumnResolutionContext) = super<ColumnWithParent>.resolveSingle(context)
+
+    override fun rename(newName: String): ValueColumnWithParent<T> = ValueColumnWithParent(parent, source.rename(newName))
+
+    override fun forceResolve() = ResolvingValueColumn(this)
+
+    override fun changeType(type: KType) = ValueColumnWithParent(parent, source.internal().changeType(type).asValueColumn())
+
+    override fun addParent(parent: ColumnGroup<*>) = source.addParent(parent)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnWithPathImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnWithPathImpl.kt
new file mode 100644
index 000000000..58b881b5f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ValueColumnWithPathImpl.kt
@@ -0,0 +1,18 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+
+internal class ValueColumnWithPathImpl<T> internal constructor(
+    override val data: ValueColumn<T>,
+    override val path: ColumnPath
+) : ColumnWithPath<T>, ValueColumn<T> by data {
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T> = this
+
+    override fun rename(newName: String) = if (newName == name()) this else ValueColumnWithPathImpl(data.rename(newName), path.dropLast(1) + newName)
+
+    override fun path() = 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
new file mode 100644
index 000000000..68f50e0e4
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt
@@ -0,0 +1,290 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.api.AddDataRow
+import org.jetbrains.kotlinx.dataframe.api.AddExpression
+import org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl
+import org.jetbrains.kotlinx.dataframe.api.Infer
+import org.jetbrains.kotlinx.dataframe.api.PivotColumnsSelector
+import org.jetbrains.kotlinx.dataframe.api.PivotDsl
+import org.jetbrains.kotlinx.dataframe.api.SortColumnsSelector
+import org.jetbrains.kotlinx.dataframe.api.SortDsl
+import org.jetbrains.kotlinx.dataframe.api.asDataColumn
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.indices
+import org.jetbrains.kotlinx.dataframe.api.toColumnAccessor
+import org.jetbrains.kotlinx.dataframe.api.toColumnOf
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameReceiver
+import org.jetbrains.kotlinx.dataframe.impl.DataRowImpl
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import org.jetbrains.kotlinx.dataframe.impl.eraseGenericTypeParameters
+import org.jetbrains.kotlinx.dataframe.impl.guessValueType
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.nrow
+import kotlin.reflect.KClass
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.full.withNullability
+
+// region create DataColumn
+
+internal class AddDataRowImpl<T>(index: Int, owner: DataFrame<T>, private val container: List<*>) :
+    DataRowImpl<T>(index, owner),
+    AddDataRow<T> {
+
+    override fun <C> AnyRow.newValue() = container[index] as C
+}
+
+@PublishedApi
+internal fun <T, R> ColumnsContainer<T>.newColumn(
+    type: KType,
+    name: String = "",
+    infer: Infer = Infer.Nulls,
+    expression: AddExpression<T, R>,
+): DataColumn<R> {
+    val df = this as? DataFrame<T> ?: dataFrameOf(columns()).cast()
+    val (nullable, values) = computeValues(df, expression)
+    return when (infer) {
+        Infer.Nulls -> DataColumn.create(
+            name = name,
+            values = values,
+            type = type.withNullability(nullable).eraseGenericTypeParameters(),
+            infer = Infer.None,
+        )
+
+        Infer.Type -> DataColumn.createWithTypeInference(
+            name = name,
+            values = values,
+            nullable = nullable,
+        )
+
+        Infer.None -> DataColumn.create(
+            name = name,
+            values = values,
+            type = type.eraseGenericTypeParameters(),
+            infer = Infer.None,
+        )
+    }
+}
+
+@PublishedApi
+internal fun <T, R> ColumnsContainer<T>.newColumnWithActualType(
+    name: String,
+    expression: AddExpression<T, R>,
+): DataColumn<R> {
+    val (_, values) = computeValues(this as DataFrame<T>, expression)
+    return guessColumnType(name, values)
+}
+
+internal fun <T, R> computeValues(df: DataFrame<T>, expression: AddExpression<T, R>): Pair<Boolean, List<R>> {
+    var nullable = false
+    val list = ArrayList<R>(df.nrow)
+    df.indices().forEach {
+        val row = AddDataRowImpl(it, df, list)
+        val value = expression(row, row)
+        if (value == null) nullable = true
+        list.add(value)
+    }
+    return nullable to list
+}
+
+@Suppress("UNCHECKED_CAST")
+@PublishedApi
+internal fun <T> createColumn(values: Iterable<T>, suggestedType: KType, guessType: Boolean = false): DataColumn<T> =
+    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()
+
+        // 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()
+
+        // 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()
+
+        guessType ->
+            guessColumnType(
+                name = "",
+                values = values.asList(),
+                suggestedType = suggestedType,
+                suggestedTypeIsUpperBound = true,
+            ).cast()
+
+        else ->
+            DataColumn.createValueColumn(
+                name = "",
+                values = values.toList(),
+                type = suggestedType,
+            )
+    }
+
+// endregion
+
+// region create Columns
+
+internal fun <C> createColumnSet(resolver: (ColumnResolutionContext) -> List<ColumnWithPath<C>>): ColumnSet<C> =
+    object : ColumnSet<C> {
+        override fun resolve(context: ColumnResolutionContext) = resolver(context)
+    }
+
+// region toColumns
+
+internal fun <TD, T : DataFrame<TD>, C> Selector<T, ColumnSet<C>>.toColumns(
+    createReceiver: (ColumnResolutionContext) -> T,
+): ColumnSet<C> =
+    createColumnSet {
+        val receiver = createReceiver(it)
+        val columnSet = this(receiver, receiver)
+        columnSet.resolve(receiver, it.unresolvedColumnsPolicy)
+    }
+
+@JvmName("toColumnSetForPivot")
+internal fun <T, C> PivotColumnsSelector<T, C>.toColumns(): ColumnSet<C> = toColumns {
+    object : DataFrameReceiver<T>(it.df.cast(), it.unresolvedColumnsPolicy), PivotDsl<T> {}
+}
+
+@JvmName("toColumnSetForSort")
+internal fun <T, C> SortColumnsSelector<T, C>.toColumns(): ColumnSet<C> = toColumns {
+    object : DataFrameReceiver<T>(it.df.cast(), it.unresolvedColumnsPolicy), SortDsl<T> {}
+}
+
+internal fun <T, C> ColumnsSelector<T, C>.toColumns(): ColumnSet<C> = toColumns {
+    object : DataFrameReceiver<T>(it.df.cast(), it.unresolvedColumnsPolicy), ColumnsSelectionDsl<T> {}
+}
+
+internal fun Array<out ColumnSet<*>>.toColumns(): ColumnSet<Any?> = ColumnsList(this.asList())
+internal fun Array<out String>.toColumns(): ColumnSet<Any?> = map { it.toColumnAccessor() }.toColumnSet()
+internal fun Array<out ColumnPath>.toColumns(): ColumnSet<Any?> = map { it.toColumnAccessor() }.toColumnSet()
+
+@PublishedApi
+internal fun <C> Array<out KProperty<C>>.toColumns(): ColumnSet<C> = map { it.toColumnAccessor() }.toColumnSet()
+
+@PublishedApi
+internal fun <T> Array<out ColumnReference<T>>.toColumns(): ColumnSet<T> = asIterable().toColumnSet()
+internal fun Iterable<String>.toColumns(): ColumnSet<Any?> = map { it.toColumnAccessor() }.toColumnSet()
+
+// endregion
+
+internal fun <C> Iterable<ColumnSet<C>>.toColumnSet(): ColumnSet<C> = ColumnsList(asList())
+
+internal fun <C> Array<out String>.toColumnsOf(): ColumnSet<C> = toColumns() as ColumnSet<C>
+internal fun Array<out String>.toComparableColumns() = toColumnsOf<Comparable<Any?>>()
+internal fun String.toComparableColumn() = toColumnOf<Comparable<Any?>>()
+internal fun Array<out String>.toNumberColumns() = toColumnsOf<Number>()
+
+@JvmName("toColumnSetC")
+internal fun <C> Iterable<ColumnReference<C>>.toColumnSet(): ColumnSet<C> = ColumnsList(toList())
+
+// endregion
+
+internal fun <T> guessColumnType(name: String, values: List<T>) = guessColumnType(name, values, null)
+
+@PublishedApi
+internal fun <T> guessColumnType(
+    name: String,
+    values: List<T>,
+    suggestedType: KType? = null,
+    suggestedTypeIsUpperBound: Boolean = false,
+    defaultValue: T? = null,
+    nullable: Boolean? = null,
+): DataColumn<T> {
+    val detectType = suggestedType == null || suggestedTypeIsUpperBound
+    val type = if (detectType) guessValueType(
+        values = values.asSequence(),
+        upperBound = suggestedType,
+        listifyValues = false,
+    ) else suggestedType!!
+
+    return when (type.classifier!! as KClass<*>) {
+        DataRow::class -> {
+            val df = values.map { (it as AnyRow?)?.toDataFrame() ?: DataFrame.empty(1) }.concat()
+            DataColumn.createColumnGroup(name, df).asDataColumn().cast()
+        }
+
+        DataFrame::class -> {
+            val frames = values.map {
+                when (it) {
+                    null -> DataFrame.empty()
+                    is AnyFrame -> it
+                    is AnyRow -> it.toDataFrame()
+                    is List<*> -> (it as List<AnyRow>).toDataFrame()
+                    else -> throw IllegalStateException()
+                }
+            }
+            DataColumn.createFrameColumn(name, frames).asDataColumn().cast()
+        }
+
+        List::class -> {
+            val nullable = type.isMarkedNullable
+            var isListOfRows: Boolean? = null
+            val lists = values.map {
+                when (it) {
+                    null -> if (nullable) null else emptyList()
+                    is List<*> -> {
+                        if (isListOfRows != false && it.isNotEmpty()) isListOfRows = it.all { it is AnyRow }
+                        it
+                    }
+
+                    else -> { // if !detectType and suggestedType is a list, we wrap the values in lists
+                        if (isListOfRows != false) isListOfRows = it is AnyRow
+                        listOf(it)
+                    }
+                }
+            }
+            if (isListOfRows == true) {
+                val frames = lists.map {
+                    if (it == null) DataFrame.empty()
+                    else (it as List<AnyRow>).concat()
+                }
+                DataColumn.createFrameColumn(name, frames).cast()
+            } else {
+                DataColumn.createValueColumn(name, lists, type, defaultValue = defaultValue).cast()
+            }
+        }
+
+        else -> {
+            if (nullable == null) {
+                DataColumn.createValueColumn(
+                    name = name,
+                    values = values,
+                    type = type,
+                    infer = if (detectType) Infer.None else Infer.Nulls,
+                    defaultValue = defaultValue,
+                )
+            } else DataColumn.createValueColumn(
+                name = name,
+                values = values,
+                type = type.withNullability(nullable),
+                defaultValue = defaultValue,
+            )
+        }
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingColumnGroup.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingColumnGroup.kt
new file mode 100644
index 000000000..0b580d78c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingColumnGroup.kt
@@ -0,0 +1,69 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns.missing
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedBody
+import org.jetbrains.kotlinx.dataframe.api.asDataColumn
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.impl.columns.DataColumnGroup
+import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
+import kotlin.reflect.KType
+
+internal class MissingColumnGroup<T>(val path: ColumnPath, val host: ColumnsContainer<*>) : MissingDataColumn<DataRow<T>>(), DataColumnGroup<T> {
+
+    override fun getColumnOrNull(name: String) = MissingColumnGroup<Any?>(path + name, host)
+
+    override fun getColumnOrNull(index: Int) = MissingColumnGroup<Any?>(path + "", host)
+
+    override fun columnsCount(): Int = 0
+
+    override fun get(index: Int) = throw UnsupportedOperationException()
+
+    override fun get(columnName: String) = throw UnsupportedOperationException()
+
+    override fun rowsCount(): Int = 0
+
+    override fun columns(): List<AnyCol> = emptyList()
+
+    override fun columnNames(): List<String> = emptyList()
+
+    override fun columnTypes(): List<KType> = emptyList()
+
+    override fun getColumnIndex(name: String) = -1
+
+    override fun kind() = super.kind()
+
+    override fun get(firstIndex: Int, vararg otherIndices: Int) = throw UnsupportedOperationException()
+
+    override fun distinct() = throw UnsupportedOperationException()
+
+    override fun <R> aggregate(body: AggregateGroupedBody<T, R>) = throw UnsupportedOperationException()
+
+    override fun <R> getColumnOrNull(column: ColumnReference<R>) = MissingColumnGroup<Any>(path + column.name(), host).asDataColumn().cast<R>()
+
+    override fun getColumnOrNull(path: ColumnPath) = MissingColumnGroup<Any?>(this.path + path, host)
+
+    override fun <R> getColumnOrNull(column: ColumnSelector<T, R>) = MissingColumnGroup<Any>(path + "", host).asDataColumn().cast<R>()
+
+    override fun name(): String = path.name
+
+    override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<DataRow<T>>? = when (context.unresolvedColumnsPolicy) {
+        UnresolvedColumnsPolicy.Skip -> null
+        UnresolvedColumnsPolicy.Create -> this.addPath(path)
+        UnresolvedColumnsPolicy.Fail -> error("Failed to resolve column $path")
+    }
+
+    override fun containsColumn(name: String): Boolean = false
+
+    override fun containsColumn(path: ColumnPath): Boolean = false
+
+    override fun contains(value: DataRow<T>) = false
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingDataColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingDataColumn.kt
new file mode 100644
index 000000000..b6cf482c0
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/missing/MissingDataColumn.kt
@@ -0,0 +1,36 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns.missing
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.impl.columns.DataColumnInternal
+import kotlin.reflect.KType
+
+internal abstract class MissingDataColumn<T> : DataColumnInternal<T> {
+
+    override fun values() = throw UnsupportedOperationException()
+
+    override fun type() = throw UnsupportedOperationException()
+
+    override fun countDistinct() = throw UnsupportedOperationException()
+
+    override fun size() = throw UnsupportedOperationException()
+
+    override fun get(index: Int) = throw UnsupportedOperationException()
+
+    override fun defaultValue() = throw UnsupportedOperationException()
+
+    override fun get(columnName: String) = throw UnsupportedOperationException()
+
+    override fun get(indices: Iterable<Int>) = throw UnsupportedOperationException()
+
+    override fun toSet() = throw UnsupportedOperationException()
+
+    override fun changeType(type: KType) = throw UnsupportedOperationException()
+
+    override fun rename(newName: String) = throw UnsupportedOperationException()
+
+    override fun addParent(parent: ColumnGroup<*>) = throw UnsupportedOperationException()
+
+    override fun forceResolve() = throw UnsupportedOperationException()
+
+    override fun get(range: IntRange) = throw UnsupportedOperationException()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/ColumnPosition.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/ColumnPosition.kt
new file mode 100644
index 000000000..8c86b96ab
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/ColumnPosition.kt
@@ -0,0 +1,9 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns.tree
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+
+internal data class ColumnPosition(
+    override val originalIndex: Int,
+    override var wasRemoved: Boolean,
+    var column: AnyCol?
+) : ReferenceData
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/ReadonlyTreeNode.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/ReadonlyTreeNode.kt
new file mode 100644
index 000000000..ffa4aad74
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/ReadonlyTreeNode.kt
@@ -0,0 +1,14 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns.tree
+
+internal interface ReadonlyTreeNode<out T> {
+
+    val name: String
+    val depth: Int
+    val data: T
+    val parent: ReadonlyTreeNode<T>?
+    val children: List<ReadonlyTreeNode<T>>
+
+    fun getRoot(): ReadonlyTreeNode<T>?
+
+    operator fun get(childName: String): ReadonlyTreeNode<T>?
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/ReferenceData.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/ReferenceData.kt
new file mode 100644
index 000000000..24207de5b
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/ReferenceData.kt
@@ -0,0 +1,6 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns.tree
+
+internal interface ReferenceData {
+    val originalIndex: Int
+    val wasRemoved: Boolean
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/TreeNode.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/TreeNode.kt
new file mode 100644
index 000000000..2f35bca69
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/TreeNode.kt
@@ -0,0 +1,66 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns.tree
+
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+
+internal class TreeNode<T>(
+    override val name: String,
+    override val depth: Int,
+    override var data: T,
+    override val parent: TreeNode<T>? = null
+) : ReadonlyTreeNode<T> {
+
+    companion object {
+        fun <T> createRoot(data: T) = TreeNode<T>("", 0, data)
+    }
+
+    private val myChildren = mutableListOf<TreeNode<T>>()
+    private val childrenMap = mutableMapOf<String, TreeNode<T>>()
+
+    override val children: List<TreeNode<T>>
+        get() = myChildren
+
+    override fun getRoot(): TreeNode<T> = parent?.getRoot() ?: this
+
+    fun contains(childName: String) = childrenMap.containsKey(childName)
+
+    override operator fun get(childName: String) = childrenMap[childName]
+
+    fun pathFromRoot(): ColumnPath {
+        val path = mutableListOf<String>()
+        var node: TreeNode<T>? = this
+        while (node != null && node.parent != null) {
+            path.add(node.name)
+            node = node.parent
+        }
+        path.reverse()
+        return ColumnPath(path)
+    }
+
+    fun addChild(childName: String, childData: T): TreeNode<T> {
+        val node = TreeNode(childName, depth + 1, childData, this)
+        myChildren.add(node)
+        childrenMap[childName] = node
+        return node
+    }
+
+    fun getOrPut(childName: String, createData: () -> T): TreeNode<T> {
+        childrenMap[childName]?.let { return it }
+        return addChild(childName, createData())
+    }
+
+    fun dfs(enterCondition: (TreeNode<T>) -> Boolean = { true }, yieldCondition: (TreeNode<T>) -> Boolean = { true }): List<TreeNode<T>> {
+        val result = mutableListOf<TreeNode<T>>()
+        fun doDfs(node: TreeNode<T>) {
+            if (yieldCondition(node)) {
+                result.add(node)
+            }
+            if (enterCondition(node)) {
+                node.children.forEach {
+                    doDfs(it)
+                }
+            }
+        }
+        doDfs(this)
+        return result
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/Utils.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/Utils.kt
new file mode 100644
index 000000000..e74bc75c8
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/tree/Utils.kt
@@ -0,0 +1,132 @@
+package org.jetbrains.kotlinx.dataframe.impl.columns.tree
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
+import org.jetbrains.kotlinx.dataframe.impl.columns.changePath
+
+internal tailrec fun <T> ReadonlyTreeNode<T>.getAncestor(depth: Int): ReadonlyTreeNode<T> {
+    if (depth > this.depth) throw UnsupportedOperationException()
+    if (depth == this.depth) return this
+    val p = parent ?: throw UnsupportedOperationException()
+    return p.getAncestor(depth)
+}
+
+internal fun <T> TreeNode<T?>.getOrPut(path: ColumnPath) = getOrPutEmpty(path, null)
+
+internal fun <T> TreeNode<T>.getOrPutEmpty(path: ColumnPath, emptyData: T): TreeNode<T> = getOrPut(path) { emptyData }
+
+internal fun <T> TreeNode<T?>.put(path: ColumnPath, data: T): TreeNode<T?> = getOrPut(path).also { it.data = data }
+
+internal fun <T> TreeNode<T>.getOrPut(path: ColumnPath, createData: (ColumnPath) -> T): TreeNode<T> {
+    var node = this
+    path.indices.forEach {
+        node = node.getOrPut(path[it]) { createData(path.take(it + 1)) }
+    }
+    return node
+}
+
+internal fun <T> TreeNode<T>.topDfs(yieldCondition: (TreeNode<T>) -> Boolean): List<TreeNode<T>> = dfs(enterCondition = { !yieldCondition(it) }, yieldCondition = yieldCondition)
+
+internal fun <T> TreeNode<T>.topDfsExcluding(excludeRoot: TreeNode<*>): List<TreeNode<T>> {
+    val result = mutableListOf<TreeNode<T>>()
+    fun doDfs(node: TreeNode<T>, exclude: TreeNode<*>) {
+        if (exclude.children.isNotEmpty()) {
+            node.children.filter { !exclude.contains(it.name) }.forEach { result.add(it) }
+            exclude.children.forEach {
+                val srcNode = node[it.name]
+                if (srcNode != null) {
+                    doDfs(srcNode, it)
+                }
+            }
+        }
+    }
+    doDfs(this, excludeRoot)
+    return result
+}
+
+internal fun <T> TreeNode<T?>.dfsNotNull() = dfs { it.data != null }.map { it as TreeNode<T> }
+internal fun <T> TreeNode<T?>.dfsTopNotNull() = dfs(enterCondition = { it.data == null }, yieldCondition = { it.data != null }).map { it as TreeNode<T> }
+
+internal fun TreeNode<ColumnPosition>.allRemovedColumns() = dfs { it.data.wasRemoved && it.data.column != null }
+internal fun TreeNode<ColumnPosition>.allWithColumns() = dfs { it.data.column != null }
+internal fun Iterable<ColumnWithPath<*>>.dfs(): List<ColumnWithPath<*>> {
+    val result = mutableListOf<ColumnWithPath<*>>()
+    fun dfs(cols: Iterable<ColumnWithPath<*>>) {
+        cols.forEach {
+            result.add(it)
+            val path = it.path
+            if (it.data.isColumnGroup()) {
+                dfs(it.data.asColumnGroup().columns().map { it.addPath(path + it.name()) })
+            }
+        }
+    }
+    dfs(this)
+    return result
+}
+
+internal fun List<ColumnWithPath<*>>.collectTree() = collectTree(null) { it }
+internal fun <D> List<ColumnWithPath<*>>.collectTree(emptyData: D, createData: (AnyCol) -> D): TreeNode<D> {
+    val root = TreeNode.createRoot(emptyData)
+
+    fun collectColumns(col: AnyCol, parentNode: TreeNode<D>) {
+        val newNode = parentNode.getOrPut(col.name()) { createData(col) }
+        if (col.isColumnGroup()) {
+            col.asColumnGroup().columns().forEach {
+                collectColumns(it, newNode)
+            }
+        }
+    }
+    forEach {
+        if (it.path.isEmpty()) {
+            it.data.asColumnGroup().columns().forEach {
+                collectColumns(it, root)
+            }
+        } else {
+            val node = root.getOrPutEmpty(it.path.dropLast(1), emptyData)
+            collectColumns(it.data, node)
+        }
+    }
+    return root
+}
+
+/**
+ * Shorten column paths as much as possible to keep them unique
+ */
+internal fun <C> List<ColumnWithPath<C>>.shortenPaths(): List<ColumnWithPath<C>> {
+    // try to use just column name as column path
+    val map = groupBy { it.path.takeLast(1) }.toMutableMap()
+
+    fun add(path: ColumnPath, column: ColumnWithPath<C>) {
+        val list: MutableList<ColumnWithPath<C>> =
+            (map.getOrPut(path) { mutableListOf() } as? MutableList<ColumnWithPath<C>>)
+                ?: let {
+                    val values = map.remove(path)!!
+                    map.put(path, values.toMutableList()) as MutableList<ColumnWithPath<C>>
+                }
+        list.add(column)
+    }
+
+    // resolve name collisions by using more parts of column path
+    var conflicts = map.filter { it.value.size > 1 }
+    while (conflicts.size > 0) {
+        conflicts.forEach {
+            val key = it.key
+            val keyLength = key.size
+            map.remove(key)
+            it.value.forEach {
+                val path = it.path
+                val newPath = if (path.size < keyLength) path.takeLast(keyLength + 1) else path
+                add(newPath, it)
+            }
+        }
+        conflicts = map.filter { it.value.size > 1 }
+    }
+
+    val pathRemapping = map.map { it.value.single().path to it.key }.toMap()
+
+    return map { it.changePath(pathRemapping[it.path]!!) }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/DataFrameSchemaImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/DataFrameSchemaImpl.kt
new file mode 100644
index 000000000..711efda09
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/DataFrameSchemaImpl.kt
@@ -0,0 +1,81 @@
+package org.jetbrains.kotlinx.dataframe.impl.schema
+
+import org.jetbrains.kotlinx.dataframe.impl.renderType
+import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
+import org.jetbrains.kotlinx.dataframe.schema.CompareResult
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+
+internal class DataFrameSchemaImpl(override val columns: Map<String, ColumnSchema>) : DataFrameSchema {
+
+    override fun compare(other: DataFrameSchema): CompareResult {
+        require(other is DataFrameSchemaImpl)
+        if (this === other) return CompareResult.Equals
+        var result = CompareResult.Equals
+        columns.forEach {
+            val otherColumn = other.columns[it.key]
+            if (otherColumn == null) {
+                result = result.combine(CompareResult.IsDerived)
+            } else {
+                result = result.combine(it.value.compare(otherColumn))
+            }
+            if (result == CompareResult.None) return CompareResult.None
+        }
+        other.columns.forEach {
+            val thisField = columns[it.key]
+            if (thisField == null) {
+                result = result.combine(CompareResult.IsSuper)
+                if (result == CompareResult.None) return CompareResult.None
+            }
+        }
+        return result
+    }
+
+    override fun equals(other: Any?): Boolean {
+        return other is DataFrameSchema && compare(other).isEqual()
+    }
+
+    override fun toString(): String {
+        return render()
+    }
+
+    override fun hashCode(): Int {
+        return columns.hashCode()
+    }
+}
+
+internal fun DataFrameSchemaImpl.render(): String {
+    val sb = StringBuilder()
+    val indentSequence = "    "
+    columns.render(0, sb, indentSequence)
+    return sb.toString()
+}
+
+internal fun Map<String, ColumnSchema>.render(indent: Int, sb: StringBuilder, indentSequence: String): String {
+    entries.forEachIndexed { i, (name, columnSchema) ->
+        sb.append(indentSequence.repeat(indent))
+        sb.append("$name:")
+        when (columnSchema) {
+            is ColumnSchema.Group -> {
+                sb.appendLine()
+                columnSchema.schema.columns.render(indent + 1, sb, indentSequence)
+                sb.appendLine()
+            }
+
+            is ColumnSchema.Frame -> {
+                sb.appendLine(" *")
+                columnSchema.schema.columns.render(indent + 1, sb, indentSequence)
+                sb.appendLine()
+            }
+
+            is ColumnSchema.Value -> {
+                sb.append(" ${renderType(columnSchema.type)}")
+                if (i != size - 1) {
+                    sb.appendLine()
+                }
+            }
+
+            else -> throw NotImplementedError(columnSchema::class.toString())
+        }
+    }
+    return sb.toString()
+}
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
new file mode 100644
index 000000000..16acc7aba
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/Utils.kt
@@ -0,0 +1,145 @@
+package org.jetbrains.kotlinx.dataframe.impl.schema
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.emptyDataFrame
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.codeGen.MarkersExtractor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.hasNulls
+import org.jetbrains.kotlinx.dataframe.impl.commonType
+import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
+import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import org.jetbrains.kotlinx.dataframe.type
+import kotlin.reflect.KClass
+import kotlin.reflect.full.primaryConstructor
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.typeOf
+
+internal fun AnyFrame.extractSchema(): DataFrameSchema =
+    DataFrameSchemaImpl(columns().filter { it.name().isNotEmpty() }.associate { it.name() to it.extractSchema() })
+
+internal fun Iterable<DataFrameSchema>.intersectSchemas(): DataFrameSchema {
+    val collectedTypes = mutableMapOf<String, MutableSet<ColumnSchema>>()
+    var first = true
+    val columnsToUpdate = mutableSetOf<String>()
+    forEach { schema ->
+        if (first) {
+            schema.columns.forEach { (name, columnSchema) ->
+                collectedTypes[name] = mutableSetOf(columnSchema)
+            }
+            first = false
+        } else {
+            collectedTypes.forEach { (name, columnSchemas) ->
+                val otherType = schema.columns[name]
+                if (otherType == null) {
+                    columnsToUpdate.add(name)
+                } else columnSchemas.add(otherType)
+            }
+            columnsToUpdate.forEach { collectedTypes.remove(it) }
+            columnsToUpdate.clear()
+        }
+    }
+    val result = collectedTypes.mapValues { (name, columnSchemas) ->
+        val columnKinds = columnSchemas.map { it.kind }.distinct()
+        val kind = columnKinds.first()
+        when {
+            columnKinds.size > 1 -> ColumnSchema.Value(typeOf<Any>().withNullability(columnSchemas.any { it.nullable }))
+
+            kind == ColumnKind.Value -> ColumnSchema.Value(
+                type = columnSchemas
+                    .map { (it as ColumnSchema.Value).type }
+                    .toSet()
+                    .commonType(),
+            )
+
+            kind == ColumnKind.Frame -> ColumnSchema.Frame(
+                // intersect only not empty schemas
+                schema = columnSchemas
+                    .mapNotNull { (it as ColumnSchema.Frame).schema.takeIf { it.columns.isNotEmpty() } }
+                    .intersectSchemas(),
+                nullable = columnSchemas.any { it.nullable },
+                contentType = columnSchemas
+                    .mapNotNull { (it as ColumnSchema.Frame).contentType }
+                    .toSet()
+                    .commonType(),
+            )
+
+            kind == ColumnKind.Group -> ColumnSchema.Group(
+                schema = columnSchemas.map { (it as ColumnSchema.Group).schema }
+                    .intersectSchemas(),
+                contentType = columnSchemas
+                    .mapNotNull { (it as ColumnSchema.Group).contentType }
+                    .toSet()
+                    .commonType(),
+            )
+
+            else -> throw RuntimeException()
+        }
+    }
+    return DataFrameSchemaImpl(result)
+}
+
+internal fun AnyCol.extractSchema(): ColumnSchema = when (this) {
+    is ValueColumn<*> -> ColumnSchema.Value(type)
+    is ColumnGroup<*> -> ColumnSchema.Group(schema(), typeOf<Any?>())
+    is FrameColumn<*> -> ColumnSchema.Frame(schema.value, hasNulls, typeOf<Any?>())
+    else -> throw RuntimeException("Unknown column type: $this")
+}
+
+internal fun ColumnSchema.createEmptyColumn(name: String): AnyCol = when (this) {
+    is ColumnSchema.Value -> DataColumn.createValueColumn<Any?>(name, emptyList(), type)
+    is ColumnSchema.Group -> DataColumn.createColumnGroup(name, schema.createEmptyDataFrame()) as AnyCol
+    is ColumnSchema.Frame -> DataColumn.createFrameColumn<Any?>(name, emptyList(), lazyOf(schema))
+    else -> error("Unexpected ColumnSchema: $this")
+}
+
+/** Create "empty" column, filled with either null or empty dataframes. */
+internal fun ColumnSchema.createEmptyColumn(name: String, numberOfRows: Int): AnyCol =
+    when (this) {
+        is ColumnSchema.Value -> DataColumn.createValueColumn(
+            name = name,
+            values = List(numberOfRows) { null },
+            type = type,
+        )
+
+        is ColumnSchema.Group -> DataColumn.createColumnGroup(
+            name = name,
+            df = schema.createEmptyDataFrame(numberOfRows),
+        ) as AnyCol
+
+        is ColumnSchema.Frame -> DataColumn.createFrameColumn(
+            name = name,
+            groups = List(numberOfRows) { emptyDataFrame<Any?>() },
+            schema = lazyOf(schema),
+        )
+
+        else -> error("Unexpected ColumnSchema: $this")
+    }
+
+internal fun DataFrameSchema.createEmptyDataFrame(): AnyFrame =
+    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()
+    }
+
+@PublishedApi
+internal fun createEmptyDataFrameOf(clazz: KClass<*>): AnyFrame =
+    MarkersExtractor.get(clazz).schema.createEmptyDataFrame()
+
+internal fun getPropertiesOrder(clazz: KClass<*>): Map<String, Int> =
+    clazz.primaryConstructor?.parameters?.mapNotNull { it.name }?.mapIndexed { i, v -> v to i }?.toMap() ?: emptyMap()
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
new file mode 100644
index 000000000..6880396f0
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/common.kt
@@ -0,0 +1,60 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import com.github.kittinunf.fuel.httpGet
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.impl.columns.guessColumnType
+import java.io.File
+import java.io.IOException
+import java.io.InputStream
+import java.net.URL
+
+internal fun catchHttpResponse(url: URL, body: (InputStream) -> AnyFrame): AnyFrame {
+    try {
+        return url.openStream().use(body)
+    } catch (e: IOException) {
+        if (e.message?.startsWith("Server returned HTTP response code") == true) {
+            val (_, response, _) = url.toString().httpGet().responseString()
+            try {
+                return DataFrame.readJsonStr(response.data.decodeToString())
+            } catch (e2: Exception) {
+                throw e
+            }
+        }
+        throw e
+    }
+}
+
+public fun <T> List<List<T>>.toDataFrame(containsColumns: Boolean = false): AnyFrame = when {
+    containsColumns -> {
+        mapNotNull {
+            if (it.isEmpty()) return@mapNotNull null
+            val name = it[0].toString()
+            val values = it.drop(1)
+            guessColumnType(name, values)
+        }.toDataFrame()
+    }
+    isEmpty() -> DataFrame.Empty
+    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]
+            }
+            guessColumnType(name, values)
+        }.toDataFrame()
+    }
+}
+
+public fun isURL(path: String): Boolean = listOf("http:", "https:", "ftp:").any { path.startsWith(it) }
+
+public fun isFile(url: URL): Boolean = url.protocol == "file"
+
+public fun asFileOrNull(url: URL): File? = if (isFile(url)) File(url.path) else null
+
+public fun urlAsFile(url: URL): File = File(url.path)
+
+public fun isProtocolSupported(url: URL): Boolean = url.protocol in setOf("http", "https", "ftp")
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
new file mode 100644
index 000000000..1824c28db
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/csv.kt
@@ -0,0 +1,355 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import org.apache.commons.csv.CSVFormat
+import org.apache.commons.csv.CSVRecord
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadCsvMethod
+import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadDfMethod
+import org.jetbrains.kotlinx.dataframe.impl.ColumnNameGenerator
+import org.jetbrains.kotlinx.dataframe.impl.api.Parsers
+import org.jetbrains.kotlinx.dataframe.impl.api.parse
+import org.jetbrains.kotlinx.dataframe.values
+import java.io.BufferedReader
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileWriter
+import java.io.IOException
+import java.io.InputStream
+import java.io.InputStreamReader
+import java.io.Reader
+import java.io.StringReader
+import java.io.StringWriter
+import java.math.BigDecimal
+import java.net.URL
+import java.nio.charset.Charset
+import java.time.LocalDate
+import java.time.LocalDateTime
+import java.time.LocalTime
+import java.util.zip.GZIPInputStream
+import kotlin.reflect.KClass
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.typeOf
+
+public class CSV(private val delimiter: Char = ',') : SupportedDataFrameFormat {
+    override fun readDataFrame(stream: InputStream, header: List<String>): AnyFrame =
+        DataFrame.readCSV(stream, delimiter = delimiter, header = header)
+
+    override fun readDataFrame(file: File, header: List<String>): AnyFrame =
+        DataFrame.readCSV(file, delimiter = delimiter, header = header)
+
+    override fun acceptsExtension(ext: String): Boolean = ext == "csv"
+
+    override fun acceptsSample(sample: SupportedFormatSample): Boolean = true // Extension is enough
+
+    override val testOrder: Int = 20000
+
+    override fun createDefaultReadMethod(pathRepresentation: String?): DefaultReadDfMethod {
+        val arguments = MethodArguments().add("delimiter", typeOf<Char>(), "'%L'", delimiter)
+        return DefaultReadCsvMethod(pathRepresentation, arguments)
+    }
+}
+
+public enum class CSVType(public val format: CSVFormat) {
+    DEFAULT(CSVFormat.DEFAULT.withAllowMissingColumnNames().withIgnoreSurroundingSpaces()),
+    TDF(CSVFormat.TDF.withAllowMissingColumnNames())
+}
+
+private val defaultCharset = Charsets.UTF_8
+
+internal fun isCompressed(fileOrUrl: String) = listOf("gz", "zip").contains(fileOrUrl.split(".").last())
+
+internal fun isCompressed(file: File) = listOf("gz", "zip").contains(file.extension)
+
+internal fun isCompressed(url: URL) = isCompressed(url.path)
+
+public fun DataFrame.Companion.readDelimStr(
+    text: String,
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+): DataFrame<*> =
+    StringReader(text).use { readDelim(it, CSVType.DEFAULT.format.withHeader(), colTypes, skipLines, readLines) }
+
+public fun DataFrame.Companion.read(
+    fileOrUrl: String,
+    delimiter: Char,
+    header: List<String> = listOf(),
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    duplicate: Boolean = true,
+    charset: Charset = Charsets.UTF_8,
+): DataFrame<*> =
+    catchHttpResponse(asURL(fileOrUrl)) {
+        readDelim(
+            it, delimiter,
+            header, isCompressed(fileOrUrl),
+            getCSVType(fileOrUrl), colTypes,
+            skipLines, readLines,
+            duplicate, charset
+        )
+    }
+
+public fun DataFrame.Companion.readCSV(
+    fileOrUrl: String,
+    delimiter: Char = ',',
+    header: List<String> = listOf(),
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    duplicate: Boolean = true,
+    charset: Charset = Charsets.UTF_8,
+    parserOptions: ParserOptions? = null,
+): DataFrame<*> =
+    catchHttpResponse(asURL(fileOrUrl)) {
+        readDelim(
+            it, delimiter,
+            header, isCompressed(fileOrUrl),
+            CSVType.DEFAULT, colTypes,
+            skipLines, readLines,
+            duplicate, charset,
+            parserOptions
+        )
+    }
+
+public fun DataFrame.Companion.readCSV(
+    file: File,
+    delimiter: Char = ',',
+    header: List<String> = listOf(),
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    duplicate: Boolean = true,
+    charset: Charset = Charsets.UTF_8,
+    parserOptions: ParserOptions? = null,
+): DataFrame<*> =
+    readDelim(
+        FileInputStream(file), delimiter,
+        header, isCompressed(file),
+        CSVType.DEFAULT, colTypes,
+        skipLines, readLines,
+        duplicate, charset,
+        parserOptions
+    )
+
+public fun DataFrame.Companion.readCSV(
+    url: URL,
+    delimiter: Char = ',',
+    header: List<String> = listOf(),
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    duplicate: Boolean = true,
+    charset: Charset = Charsets.UTF_8,
+    parserOptions: ParserOptions? = null,
+): DataFrame<*> =
+    readCSV(
+        url.openStream(), delimiter,
+        header, isCompressed(url),
+        colTypes,
+        skipLines, readLines,
+        duplicate, charset,
+        parserOptions
+    )
+
+public fun DataFrame.Companion.readCSV(
+    stream: InputStream,
+    delimiter: Char = ',',
+    header: List<String> = listOf(),
+    isCompressed: Boolean = false,
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    duplicate: Boolean = true,
+    charset: Charset = Charsets.UTF_8,
+    parserOptions: ParserOptions? = null,
+): DataFrame<*> = readDelim(
+    stream, delimiter,
+    header, isCompressed,
+    CSVType.DEFAULT, colTypes,
+    skipLines, readLines,
+    duplicate, charset,
+    parserOptions
+)
+
+private fun getCSVType(path: String): CSVType =
+    when (path.substringAfterLast('.').lowercase()) {
+        "csv" -> CSVType.DEFAULT
+        "tdf" -> CSVType.TDF
+        else -> throw IOException("Unknown file format")
+    }
+
+private fun asStream(fileOrUrl: String) = (
+    if (isURL(fileOrUrl)) {
+        URL(fileOrUrl).toURI()
+    } else {
+        File(fileOrUrl).toURI()
+    }
+    ).toURL().openStream()
+
+public fun asURL(fileOrUrl: String): URL = (
+    if (isURL(fileOrUrl)) {
+        URL(fileOrUrl).toURI()
+    } else {
+        File(fileOrUrl).toURI()
+    }
+    ).toURL()
+
+private fun getFormat(type: CSVType, delimiter: Char, header: List<String>, duplicate: Boolean): CSVFormat =
+    type.format.withDelimiter(delimiter).withHeader(*header.toTypedArray()).withAllowDuplicateHeaderNames(duplicate)
+
+public fun DataFrame.Companion.readDelim(
+    inStream: InputStream,
+    delimiter: Char = ',',
+    header: List<String> = listOf(),
+    isCompressed: Boolean = false,
+    csvType: CSVType,
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    duplicate: Boolean = true,
+    charset: Charset = defaultCharset,
+    parserOptions: ParserOptions? = null,
+): AnyFrame =
+    if (isCompressed) {
+        InputStreamReader(GZIPInputStream(inStream), charset)
+    } else {
+        BufferedReader(InputStreamReader(inStream, charset))
+    }.run {
+        readDelim(
+            this,
+            getFormat(csvType, delimiter, header, duplicate),
+            colTypes,
+            skipLines,
+            readLines,
+            parserOptions
+        )
+    }
+
+public enum class ColType {
+    Int,
+    Long,
+    Double,
+    Boolean,
+    BigDecimal,
+    LocalDate,
+    LocalTime,
+    LocalDateTime,
+    String,
+}
+
+public fun ColType.toType(): KClass<out Any> = when (this) {
+    ColType.Int -> Int::class
+    ColType.Long -> Long::class
+    ColType.Double -> Double::class
+    ColType.Boolean -> Boolean::class
+    ColType.BigDecimal -> BigDecimal::class
+    ColType.LocalDate -> LocalDate::class
+    ColType.LocalTime -> LocalTime::class
+    ColType.LocalDateTime -> LocalDateTime::class
+    ColType.String -> String::class
+}
+
+public fun DataFrame.Companion.readDelim(
+    reader: Reader,
+    format: CSVFormat = CSVFormat.DEFAULT.withHeader(),
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    parserOptions: ParserOptions? = null,
+): AnyFrame {
+    var reader = reader
+    if (skipLines > 0) {
+        reader = BufferedReader(reader)
+        repeat(skipLines) { reader.readLine() }
+    }
+
+    val csvParser = format.parse(reader)
+    val records = if (readLines == null) {
+        csvParser.records
+    } else {
+        require(readLines >= 0) { "`readLines` must not be negative" }
+        val records = ArrayList<CSVRecord>(readLines)
+        val iter = csvParser.iterator()
+        var count = readLines ?: 0
+        while (iter.hasNext() && 0 < count--) {
+            records.add(iter.next())
+        }
+        records
+    }
+
+    val columnNames = csvParser.headerNames.takeIf { it.isNotEmpty() }
+        ?: (1..records[0].count()).map { index -> "X$index" }
+
+    val generator = ColumnNameGenerator()
+    val uniqueNames = columnNames.map { generator.addUnique(it) }
+
+    val cols = uniqueNames.mapIndexed { colIndex, colName ->
+        val defaultColType = colTypes[".default"]
+        val colType = colTypes[colName] ?: defaultColType
+        var hasNulls = false
+        val values = records.map {
+            if (it.isSet(colIndex)) {
+                it[colIndex].ifEmpty {
+                    hasNulls = true
+                    null
+                }
+            } else {
+                hasNulls = true
+                null
+            }
+        }
+        val column = DataColumn.createValueColumn(colName, values, typeOf<String>().withNullability(hasNulls))
+        when (colType) {
+            null -> column.tryParse(parserOptions)
+            else -> {
+                val parser = Parsers[colType.toType()]!!
+                column.parse(parser, parserOptions)
+            }
+        }
+    }
+    return cols.toDataFrame()
+}
+
+public fun AnyFrame.writeCSV(
+    file: File,
+    format: CSVFormat = CSVFormat.DEFAULT,
+): Unit =
+    writeCSV(FileWriter(file), format)
+
+public fun AnyFrame.writeCSV(
+    path: String,
+    format: CSVFormat = CSVFormat.DEFAULT,
+): Unit =
+    writeCSV(FileWriter(path), format)
+
+public fun AnyFrame.writeCSV(
+    writer: Appendable,
+    format: CSVFormat = CSVFormat.DEFAULT,
+) {
+    format.print(writer).use { printer ->
+        if (!format.skipHeaderRecord) {
+            printer.printRecord(columnNames())
+        }
+        forEach {
+            val values = it.values.map {
+                when (it) {
+                    is AnyRow -> it.toJson()
+                    is AnyFrame -> it.toJson()
+                    else -> it
+                }
+            }
+            printer.printRecord(values)
+        }
+    }
+}
+
+public fun AnyFrame.toCsv(format: CSVFormat = CSVFormat.DEFAULT): String =
+    StringWriter().use {
+        this.writeCSV(it, format)
+        it
+    }.toString()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/guess.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/guess.kt
new file mode 100644
index 000000000..f38aae0e4
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/guess.kt
@@ -0,0 +1,297 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import com.squareup.kotlinpoet.PropertySpec
+import com.squareup.kotlinpoet.asTypeName
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.annotations.ImportDataSchema
+import org.jetbrains.kotlinx.dataframe.api.single
+import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadDfMethod
+import org.jetbrains.kotlinx.jupyter.api.Code
+import java.io.BufferedInputStream
+import java.io.File
+import java.io.FileNotFoundException
+import java.io.InputStream
+import java.net.URL
+import java.util.ServiceLoader
+import kotlin.reflect.KType
+
+public sealed interface SupportedFormat {
+
+    public fun acceptsExtension(ext: String): Boolean
+
+    public fun acceptsSample(sample: SupportedFormatSample): Boolean
+
+    // `DataFrame.Companion.read` methods uses this to sort list of all supported formats in ascending order (-1, 2, 10)
+    // sorted list is used to test if any format can read given input
+    public val testOrder: Int
+
+    public fun createDefaultReadMethod(pathRepresentation: String? = null): DefaultReadDfMethod
+}
+
+public sealed interface SupportedFormatSample {
+
+    @JvmInline
+    public value class File(public val sampleFile: java.io.File) : SupportedFormatSample
+
+    @JvmInline
+    public value class URL(public val sampleUrl: java.net.URL) : SupportedFormatSample
+
+    @JvmInline
+    public value class PathString(public val samplePath: String) : SupportedFormatSample
+
+    @JvmInline
+    public value class DataString(public val sampleData: String) : SupportedFormatSample
+}
+
+/**
+ * Implement this interface to provide additional supported formats for DataFrames (such as JSON, XML, CSV, etc.).
+ * A [SupportedDataFrameFormat] is read directly to a DataFrame. If specified using
+ * [ImportDataSchema] or using the Gradle plugin, the read DataFrame will be used to
+ * generate [DataSchema] interfaces.
+ */
+public interface SupportedDataFrameFormat : SupportedFormat {
+    public fun readDataFrame(stream: InputStream, header: List<String> = emptyList()): DataFrame<*>
+
+    public fun readDataFrame(file: File, header: List<String> = emptyList()): DataFrame<*>
+}
+
+/**
+ * Implement this interface to provide additional [DataSchema] interface generation formats for DataFrames (such as OpenAPI).
+ * Note, this doesn't add functionality to [DataFrame.Companion.read], just [ImportDataSchema] and Gradle plugin.
+ *
+ * Return type will be a [Code] which contains a generated `interface` with the given name containing generated
+ * [DataSchema] interfaces and `enum`s, with `typealias`es (and optional extension functions in some integration)
+ * outside the interface.
+ */
+public interface SupportedCodeGenerationFormat : SupportedFormat {
+
+    /**
+     * @param stream where to read the schema from
+     * @param name the name of the top-level interface to generate
+     * @param generateHelperCompanionObject whether to generate a helper companion object (only needed for Jupyter)
+     */
+    public fun readCodeForGeneration(
+        stream: InputStream,
+        name: String,
+        generateHelperCompanionObject: Boolean = false,
+    ): Code
+
+    /**
+     * @param file where to read the schema from
+     * @param name the name of the top-level interface to generate
+     * @param generateHelperCompanionObject whether to generate a helper companion object (only needed for Jupyter)
+     */
+    public fun readCodeForGeneration(
+        file: File,
+        name: String,
+        generateHelperCompanionObject: Boolean = false,
+    ): Code
+}
+
+public class MethodArguments {
+    internal val defaultValues = mutableListOf<Argument>()
+
+    public fun add(name: String, type: KType, initializerTemplate: String, vararg values: Any?): MethodArguments {
+        val capitalizedName = name.replaceFirstChar { it.uppercaseChar() }
+        val propertyName = "default$capitalizedName"
+
+        val property = PropertySpec
+            .builder(propertyName, type.asTypeName())
+            .initializer(initializerTemplate, args = values)
+            .build()
+
+        defaultValues += Argument(name, property)
+        return this
+    }
+
+    internal class Argument(val name: String, val property: PropertySpec)
+
+    public companion object {
+        public val EMPTY: MethodArguments get() = MethodArguments()
+    }
+}
+
+/**
+ * NOTE: Needs to have fully qualified name in
+ * resources/META-INF/services/org.jetbrains.kotlinx.dataframe.io.SupportedFormat
+ * to be detected here.
+ */
+internal val supportedFormats: List<SupportedFormat> by lazy {
+    (
+        ServiceLoader.load(SupportedDataFrameFormat::class.java).toList() +
+            ServiceLoader.load(SupportedCodeGenerationFormat::class.java).toList() +
+            ServiceLoader.load(SupportedFormat::class.java).toList()
+        ).distinct()
+        .sortedBy { it.testOrder }
+}
+
+internal fun guessFormatForExtension(
+    ext: String,
+    formats: List<SupportedFormat> = supportedFormats,
+    sample: SupportedFormatSample? = null,
+): SupportedFormat? = formats.firstOrNull { it.acceptsExtension(ext) && (sample == null || it.acceptsSample(sample)) }
+
+internal fun guessFormat(
+    file: File,
+    formats: List<SupportedFormat> = supportedFormats,
+    sample: SupportedFormatSample.File? = SupportedFormatSample.File(file),
+): SupportedFormat? = guessFormatForExtension(file.extension.lowercase(), formats, sample = sample)
+
+internal fun guessFormat(
+    url: URL,
+    formats: List<SupportedFormat> = supportedFormats,
+    sample: SupportedFormatSample.URL? = SupportedFormatSample.URL(url),
+): SupportedFormat? = guessFormatForExtension(url.path.substringAfterLast("."), formats, sample = sample)
+
+internal fun guessFormat(
+    path: String,
+    formats: List<SupportedFormat> = supportedFormats,
+    sample: SupportedFormatSample.PathString? = SupportedFormatSample.PathString(path),
+): SupportedFormat? = guessFormatForExtension(path.substringAfterLast("."), formats, sample = sample)
+
+private class NotCloseableStream(val src: InputStream) : InputStream() {
+    override fun read(): Int = src.read()
+
+    fun doClose() = src.close()
+
+    override fun reset() = src.reset()
+    override fun available() = src.available()
+    override fun markSupported() = src.markSupported()
+    override fun mark(readlimit: Int) = src.mark(readlimit)
+}
+
+/**
+ * @param stream where to read the schema from
+ * @param name the name of the top-level interface to generate
+ * @param format the format to use
+ * @param generateHelperCompanionObject whether to generate a helper companion object (only needed for Jupyter)
+ * @param formats Optional list of supported formats to use. If not specified, all formats will be used.
+ *
+ * @return [GeneratedCode] with generated code
+ */
+internal fun readCodeForGeneration(
+    stream: InputStream,
+    name: String,
+    format: SupportedCodeGenerationFormat? = null,
+    generateHelperCompanionObject: Boolean = false,
+    formats: List<SupportedCodeGenerationFormat> = supportedFormats.filterIsInstance<SupportedCodeGenerationFormat>(),
+): GeneratedCode {
+    if (format != null) return format to format.readCodeForGeneration(stream, name, generateHelperCompanionObject)
+    val input = NotCloseableStream(if (stream.markSupported()) stream else BufferedInputStream(stream))
+    try {
+        val readLimit = 10000
+        input.mark(readLimit)
+
+        formats.sortedBy { it.testOrder }.forEach {
+            try {
+                input.reset()
+                return it to it.readCodeForGeneration(input, name, generateHelperCompanionObject)
+            } catch (_: Exception) {
+            }
+        }
+        throw IllegalArgumentException("Unknown stream format")
+    } finally {
+        input.doClose()
+    }
+}
+
+internal fun DataFrame.Companion.read(
+    stream: InputStream,
+    format: SupportedDataFrameFormat? = null,
+    header: List<String> = emptyList(),
+    formats: List<SupportedDataFrameFormat> = supportedFormats.filterIsInstance<SupportedDataFrameFormat>(),
+): ReadAnyFrame {
+    if (format != null) return format to format.readDataFrame(stream, header = header)
+    val input = NotCloseableStream(if (stream.markSupported()) stream else BufferedInputStream(stream))
+    try {
+        val readLimit = 10000
+        input.mark(readLimit)
+
+        formats.sortedBy { it.testOrder }.forEach {
+            try {
+                input.reset()
+                return it to it.readDataFrame(input, header = header)
+            } catch (e: Exception) {
+            }
+        }
+        throw IllegalArgumentException("Unknown stream format")
+    } finally {
+        input.doClose()
+    }
+}
+
+internal fun DataFrame.Companion.read(
+    file: File,
+    format: SupportedDataFrameFormat? = null,
+    header: List<String> = emptyList(),
+    formats: List<SupportedDataFrameFormat> = supportedFormats.filterIsInstance<SupportedDataFrameFormat>(),
+): ReadAnyFrame {
+    if (format != null) return format to format.readDataFrame(file, header = header)
+    formats.sortedBy { it.testOrder }.forEach {
+        try {
+            return it to it.readDataFrame(file, header = header)
+        } catch (e: FileNotFoundException) {
+            throw e
+        } catch (e: Exception) {
+        }
+    }
+    throw IllegalArgumentException("Unknown file format")
+}
+
+internal data class ReadAnyFrame(val format: SupportedDataFrameFormat, val df: AnyFrame)
+
+internal infix fun SupportedDataFrameFormat.to(df: AnyFrame) = ReadAnyFrame(this, df)
+
+internal data class GeneratedCode(
+    val format: SupportedCodeGenerationFormat,
+    val code: Code,
+)
+
+internal infix fun SupportedCodeGenerationFormat.to(code: Code) =
+    GeneratedCode(this, code)
+
+public fun DataFrame.Companion.read(file: File, header: List<String> = emptyList()): AnyFrame =
+    read(
+        file = file,
+        format = guessFormat(file)?.also {
+            if (it !is SupportedDataFrameFormat) error("Format $it does not support reading dataframes")
+        } as SupportedDataFrameFormat?,
+        header = header,
+    ).df
+
+public fun DataRow.Companion.read(file: File, header: List<String> = emptyList()): AnyRow =
+    DataFrame.read(file, header).single()
+
+public fun DataFrame.Companion.read(url: URL, header: List<String> = emptyList()): AnyFrame = when {
+    isFile(url) -> read(urlAsFile(url), header)
+    isProtocolSupported(url) -> catchHttpResponse(url) {
+        read(
+            stream = it,
+            format = guessFormat(url)?.also {
+                if (it !is SupportedDataFrameFormat) error("Format $it does not support reading dataframes")
+            } as SupportedDataFrameFormat?,
+            header = header,
+        ).df
+    }
+
+    else -> throw IllegalArgumentException("Invalid protocol for url $url")
+}
+
+public fun DataRow.Companion.read(url: URL, header: List<String> = emptyList()): AnyRow =
+    DataFrame.read(url, header).single()
+
+public fun DataFrame.Companion.read(path: String, header: List<String> = emptyList()): AnyFrame =
+    read(asURL(path), header)
+
+public fun DataRow.Companion.read(path: String, header: List<String> = emptyList()): AnyRow =
+    DataFrame.read(path, header).single()
+
+public fun URL.readDataFrame(header: List<String> = emptyList()): AnyFrame = DataFrame.read(this, header)
+public fun URL.readDataRow(header: List<String> = emptyList()): AnyRow = DataRow.read(this, header)
+
+public fun File.readDataFrame(header: List<String> = emptyList()): AnyFrame = DataFrame.read(this, header)
+public fun File.readDataRow(header: List<String> = emptyList()): AnyRow = DataRow.read(this, header)
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
new file mode 100644
index 000000000..190998df4
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/html.kt
@@ -0,0 +1,461 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.FormattingDSL
+import org.jetbrains.kotlinx.dataframe.api.RowColFormatter
+import org.jetbrains.kotlinx.dataframe.api.asNumbers
+import org.jetbrains.kotlinx.dataframe.api.isEmpty
+import org.jetbrains.kotlinx.dataframe.api.isNumber
+import org.jetbrains.kotlinx.dataframe.api.isSubtypeOf
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameSize
+import org.jetbrains.kotlinx.dataframe.impl.renderType
+import org.jetbrains.kotlinx.dataframe.impl.scale
+import org.jetbrains.kotlinx.dataframe.impl.truncate
+import org.jetbrains.kotlinx.dataframe.jupyter.CellRenderer
+import org.jetbrains.kotlinx.dataframe.jupyter.RenderedContent
+import org.jetbrains.kotlinx.dataframe.name
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.size
+import org.jetbrains.kotlinx.jupyter.api.HtmlData
+import java.io.InputStreamReader
+import java.net.URL
+import java.util.LinkedList
+import java.util.Random
+
+internal val tooltipLimit = 1000
+
+internal interface CellContent
+
+internal data class DataFrameReference(val dfId: Int, val size: DataFrameSize) : CellContent
+
+internal data class HtmlContent(val html: String, val style: String?) : CellContent
+
+internal data class ColumnDataForJs(
+    val column: AnyCol,
+    val nested: List<ColumnDataForJs>,
+    val rightAlign: Boolean,
+    val values: List<CellContent>,
+)
+
+internal val formatter = DataFrameFormatter(
+    "formatted",
+    "null",
+    "structural",
+    "numbers",
+    "dataFrameCaption",
+)
+
+internal fun getResources(vararg resource: String) = resource.joinToString(separator = "\n") { getResourceText(it) }
+
+internal fun getResourceText(resource: String, vararg replacement: Pair<String, Any>): String {
+    val res = DataFrame::class.java.getResourceAsStream(resource) ?: error("Resource '$resource' not found")
+    var template = InputStreamReader(res).readText()
+    replacement.forEach {
+        template = template.replace(it.first, it.second.toString())
+    }
+    return template
+}
+
+internal fun ColumnDataForJs.renderHeader(): String {
+    val tooltip = "${column.name}: ${renderType(column.type())}"
+    return "<span title=\"$tooltip\">${column.name()}</span>"
+}
+
+internal fun tableJs(columns: List<ColumnDataForJs>, id: Int, rootId: Int, nrow: Int): String {
+    var index = 0
+    val data = buildString {
+        append("[")
+        fun dfs(col: ColumnDataForJs): Int {
+            val children = col.nested.map { dfs(it) }
+            val colIndex = index++
+            val values = col.values.joinToString(",", prefix = "[", postfix = "]") {
+                when (it) {
+                    is HtmlContent -> {
+                        val html = "\"" + it.html.escapeForHtmlInJs() + "\""
+                        if (it.style == null) {
+                            html
+                        } else "{ style: \"${it.style}\", value: $html}"
+                    }
+
+                    is DataFrameReference -> {
+                        val text = "<b>DataFrame ${it.size}</b>"
+                        "{ frameId: ${it.dfId}, value: \"$text\" }"
+                    }
+
+                    else -> error("Unsupported value type: ${it.javaClass}")
+                }
+            }
+
+            val colName = col.renderHeader().escapeForHtmlInJs()
+            append("{ name: \"$colName\", children: $children, rightAlign: ${col.rightAlign}, values: $values }, \n")
+
+            return colIndex
+        }
+        columns.forEach { dfs(it) }
+        append("]")
+    }
+    val js = getResourceText(
+        "/addTable.js",
+        "___COLUMNS___" to data,
+        "___ID___" to id,
+        "___ROOT___" to rootId,
+        "___NROW___" to nrow
+    )
+    return js
+}
+
+internal var tableInSessionId = 0
+internal val sessionId = (Random().nextInt() % 128) shl 24
+internal fun nextTableId() = sessionId + (tableInSessionId++)
+
+internal fun AnyFrame.toHtmlData(
+    configuration: DisplayConfiguration = DisplayConfiguration.DEFAULT,
+    cellRenderer: CellRenderer,
+): HtmlData {
+    val scripts = mutableListOf<String>()
+    val queue = LinkedList<Pair<AnyFrame, Int>>()
+
+    fun AnyFrame.columnToJs(col: AnyCol, rowsLimit: Int?): ColumnDataForJs {
+        val values = if (rowsLimit != null) rows().take(rowsLimit) else rows()
+        val scale = if (col.isNumber()) col.asNumbers().scale() else 1
+        val format = if (scale > 0) {
+            RendererDecimalFormat.fromPrecision(scale)
+        } else {
+            RendererDecimalFormat.of("%e")
+        }
+        val renderConfig = configuration.copy(decimalFormat = format)
+        val contents = values.map {
+            val value = it[col]
+            if (value is AnyFrame) {
+                if (value.isEmpty()) {
+                    HtmlContent("", null)
+                } else {
+                    val id = nextTableId()
+                    queue.add(value to id)
+                    DataFrameReference(id, value.size)
+                }
+            } else {
+                val html = formatter.format(value, cellRenderer, renderConfig)
+                val style = renderConfig.cellFormatter?.invoke(FormattingDSL, it, col)?.attributes()?.ifEmpty { null }
+                    ?.joinToString(";") { "${it.first}:${it.second}" }
+                HtmlContent(html, style)
+            }
+        }
+        return ColumnDataForJs(
+            col,
+            if (col is ColumnGroup<*>) col.columns().map { col.columnToJs(it, rowsLimit) } else emptyList(),
+            col.isSubtypeOf<Number?>(),
+            contents
+        )
+    }
+
+    val rootId = nextTableId()
+    queue.add(this to rootId)
+    while (!queue.isEmpty()) {
+        val (nextDf, nextId) = queue.pop()
+        val rowsLimit = if (nextId == rootId) configuration.rowsLimit else configuration.nestedRowsLimit
+        val preparedColumns = nextDf.columns().map { nextDf.columnToJs(it, rowsLimit) }
+        val js = tableJs(preparedColumns, nextId, rootId, nextDf.nrow)
+        scripts.add(js)
+    }
+    val body = getResourceText("/table.html", "ID" to rootId)
+    val script = scripts.joinToString("\n") + "\n" + getResourceText("/renderTable.js", "___ID___" to rootId)
+    return HtmlData("", body, script)
+}
+
+internal fun HtmlData.print() = println(this)
+
+internal fun initHtml(
+    includeJs: Boolean = true,
+    includeCss: Boolean = true,
+    useDarkColorScheme: Boolean = false,
+): HtmlData =
+    HtmlData(
+        style = if (includeCss) getResources("/table.css") else "",
+        script = if (includeJs) getResourceText("/init.js") else "",
+        body = "",
+    )
+
+public fun <T> DataFrame<T>.html(): String = toHTML(extraHtml = initHtml()).toString()
+
+public fun <T> DataFrame<T>.toHTML(
+    configuration: DisplayConfiguration = DisplayConfiguration.DEFAULT,
+    extraHtml: HtmlData? = null,
+    cellRenderer: CellRenderer = org.jetbrains.kotlinx.dataframe.jupyter.DefaultCellRenderer,
+    getFooter: (DataFrame<T>) -> String = { "DataFrame [${it.size}]" },
+): HtmlData {
+    val limit = configuration.rowsLimit ?: Int.MAX_VALUE
+
+    val footer = getFooter(this)
+    val bodyFooter = buildString {
+        val openPTag = "<p class=\"dataframe_description\">"
+        if (limit < nrow) {
+            append(openPTag)
+            append("... showing only top $limit of $nrow rows</p>")
+        }
+        append(openPTag)
+        append(footer)
+        append("</p>")
+    }
+
+    val tableHtml = toHtmlData(configuration, cellRenderer)
+    val html = tableHtml + HtmlData("", bodyFooter, "")
+
+    return if (extraHtml != null) extraHtml + html else html
+}
+
+public data class DisplayConfiguration(
+    var rowsLimit: Int? = 20,
+    var nestedRowsLimit: Int? = 5,
+    var cellContentLimit: Int = 40,
+    var cellFormatter: RowColFormatter<*, *>? = null,
+    var decimalFormat: RendererDecimalFormat = RendererDecimalFormat.DEFAULT,
+    var isolatedOutputs: Boolean = flagFromEnv("LETS_PLOT_HTML_ISOLATED_FRAME"),
+    internal val localTesting: Boolean = flagFromEnv("KOTLIN_DATAFRAME_LOCAL_TESTING"),
+    var useDarkColorScheme: Boolean = false,
+) {
+    public companion object {
+        public val DEFAULT: DisplayConfiguration = DisplayConfiguration()
+    }
+
+    /** DSL accessor. */
+    public operator fun invoke(block: DisplayConfiguration.() -> Unit): DisplayConfiguration = apply(block)
+}
+
+@JvmInline
+public value class RendererDecimalFormat private constructor(internal val format: String) {
+    public companion object {
+        public fun fromPrecision(precision: Int): RendererDecimalFormat {
+            require(precision >= 0) { "precision must be >= 0. for custom format use RendererDecimalFormat.of" }
+            return RendererDecimalFormat("%.${precision}f")
+        }
+
+        public fun of(format: String): RendererDecimalFormat {
+            return RendererDecimalFormat(format)
+        }
+
+        internal val DEFAULT: RendererDecimalFormat = fromPrecision(defaultPrecision)
+    }
+}
+
+internal const val defaultPrecision = 6
+
+private fun flagFromEnv(envName: String): Boolean {
+    return System.getenv(envName)?.toBooleanStrictOrNull() ?: false
+}
+
+internal fun String.escapeNewLines() = replace("\n", "\\n").replace("\r", "\\r")
+
+internal fun String.escapeForHtmlInJs() = replace("\"", "\\\"").escapeNewLines()
+
+internal fun renderValueForHtml(value: Any?, truncate: Int, format: RendererDecimalFormat): RenderedContent {
+    return formatter.truncate(renderValueToString(value, format), truncate)
+}
+
+internal fun String.escapeHTML(): String {
+    val str = this
+    return buildString {
+        for (c in str) {
+            if (c.code > 127 || c == '"' || c == '\'' || c == '<' || c == '>' || c == '&') {
+                append("&#")
+                append(c.code)
+                append(';')
+            } else {
+                append(c)
+            }
+        }
+    }
+}
+
+internal class DataFrameFormatter(
+    val formattedClass: String,
+    val nullClass: String,
+    val structuralClass: String,
+    val numberClass: String,
+    val dataFrameClass: String,
+) {
+
+    private fun wrap(prefix: String, content: RenderedContent, postfix: String): RenderedContent =
+        content.copy(truncatedContent = prefix + content.truncatedContent + postfix)
+
+    private fun String.addCss(css: String? = null): RenderedContent = RenderedContent.text(this).addCss(css)
+
+    private fun String.ellipsis(fullText: String) = addCss(structuralClass).copy(fullContent = fullText)
+
+    private fun String.structural() = addCss(structuralClass)
+
+    private fun RenderedContent.addCss(css: String? = null): RenderedContent {
+        return if (css != null) {
+            copy(truncatedContent = "<span class=\"$css\">" + truncatedContent + "</span>", isFormatted = true)
+        } else this
+    }
+
+    internal fun truncate(str: String, limit: Int): RenderedContent {
+        return if (limit in 1 until str.length) {
+            val ellipsis = "...".ellipsis(str)
+            if (limit < 4) ellipsis
+            else {
+                val len = Math.max(limit - 3, 1)
+                RenderedContent.textWithLength(str.substring(0, len).escapeHTML(), len) + ellipsis
+            }
+        } else {
+            RenderedContent.textWithLength(str.escapeHTML(), str.length)
+        }
+    }
+
+    fun format(
+        value: Any?,
+        renderer: CellRenderer,
+        configuration: DisplayConfiguration,
+    ): String {
+        val result = render(value, renderer, configuration)
+        return when {
+            result == null -> ""
+            result.isFormatted || result.isTruncated -> {
+                val tooltip = result.fullContent?.escapeHTML() ?: ""
+                return "<span class=\"$formattedClass\" title=\"$tooltip\">${result.truncatedContent}</span>"
+            }
+
+            else -> result.truncatedContent
+        }
+    }
+
+    private class Builder {
+
+        private val sb = StringBuilder()
+
+        private var isFormatted: Boolean = false
+
+        var len: Int = 0
+            private set
+
+        var isTruncated: Boolean = false
+
+        operator fun plusAssign(content: RenderedContent?) {
+            if (content == null) return
+            sb.append(content.truncatedContent)
+            len += content.textLength
+            if (content.isTruncated) isTruncated = true
+            if (content.isFormatted) isFormatted = true
+        }
+
+        fun result() = RenderedContent(sb.toString(), len, if (isTruncated) "" else null, isFormatted)
+    }
+
+    private fun render(value: Any?, renderer: CellRenderer, configuration: DisplayConfiguration): RenderedContent? {
+        val limit = configuration.cellContentLimit
+
+        fun renderList(values: List<*>, prefix: String, postfix: String): RenderedContent {
+            val sb = Builder()
+            sb += prefix.addCss(structuralClass)
+            for (index in values.indices) {
+                if (index > 0) {
+                    sb += ", ".addCss(structuralClass)
+                }
+                fun addEllipsis() {
+                    if (limit == sb.len + "..".length + postfix.length) {
+                        sb += "..".addCss(structuralClass)
+                    } else {
+                        sb += "...".addCss(structuralClass)
+                    }
+                    sb.isTruncated = true
+                }
+
+                if (index < values.size - 1 && limit <= sb.len + "...".length + postfix.length) {
+                    addEllipsis()
+                    break
+                }
+                val valueLimit = when (index) {
+                    values.size - 1 -> limit - sb.len - postfix.length // last
+                    values.size - 2 -> { // prev before last
+                        val sizeOfLast = render(
+                            values.last(),
+                            renderer,
+                            configuration.copy(cellContentLimit = 4)
+                        )?.textLength ?: 3
+                        limit - sb.len - ", ".length - sizeOfLast - postfix.length
+                    }
+
+                    else -> limit - sb.len - ", ...".length - postfix.length
+                }
+
+                val rendered = render(values[index], renderer, configuration.copy(cellContentLimit = valueLimit))
+                if (rendered == null || (rendered.textLength == 3 && rendered.isTruncated)) {
+                    addEllipsis()
+                    break
+                }
+                sb += rendered
+            }
+            sb += postfix.addCss(structuralClass)
+            return sb.result()
+        }
+
+        val result = when (value) {
+            null -> "null".addCss(nullClass)
+            is AnyRow -> {
+                val values = value.getVisibleValues()
+                when {
+                    values.isEmpty() -> "{ }".addCss(nullClass)
+                    else -> {
+                        when (limit) {
+                            3 -> "...".structural()
+                            4 -> "{..}".structural()
+                            5 -> "{...}".structural()
+                            6 -> "{ ...}".structural()
+                            7 -> "{ ... }".structural()
+                            else -> renderList(values, "{ ", " }")
+                        }.let {
+                            it.copy(fullContent = values.joinToString("\n") { it.first + ": " + it.second })
+                        }
+                    }
+                }
+            }
+
+            is AnyFrame -> renderer.content("DataFrame [${value.size}]", configuration).addCss(dataFrameClass)
+            is List<*> ->
+                when {
+                    value.isEmpty() -> "[ ]".addCss(nullClass)
+                    else -> renderList(value, "[", "]").let {
+                        it.copy(fullContent = value.joinToString("\n") { it.toString() })
+                    }
+                }
+
+            is Pair<*, *> -> {
+                val key = value.first.toString() + ": "
+                val shortValue =
+                    render(value.second, renderer, configuration.copy(cellContentLimit = 3)) ?: "...".addCss(
+                        structuralClass
+                    )
+                val sizeOfValue = shortValue.textLength
+                val keyLimit = limit - sizeOfValue
+                if (key.length > keyLimit) {
+                    if (limit > 3) {
+                        (key + "...").truncate(limit).addCss(structuralClass)
+                    } else null
+                } else {
+                    val renderedValue =
+                        render(value.second, renderer, configuration.copy(cellContentLimit = limit - key.length))
+                            ?: "...".addCss(structuralClass)
+                    key.addCss(structuralClass) + renderedValue
+                }
+            }
+
+            is Number -> renderer.content(value, configuration).addCss(numberClass)
+            is URL -> wrap(
+                "<a href='$value' target='_blank'>",
+                renderer.content(value.toString(), configuration),
+                "</a>"
+            )
+
+            is HtmlData -> RenderedContent.text(value.body)
+            else -> renderer.content(value, configuration)
+        }
+        if (result != null && result.textLength > configuration.cellContentLimit) return null
+        return result
+    }
+}
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
new file mode 100644
index 000000000..b464ccdb5
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt
@@ -0,0 +1,971 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import com.beust.klaxon.JsonArray
+import com.beust.klaxon.JsonObject
+import com.beust.klaxon.KlaxonJson
+import com.beust.klaxon.Parser
+import com.beust.klaxon.json
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.JsonPath
+import org.jetbrains.kotlinx.dataframe.api.KeyValueProperty
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.firstOrNull
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.api.indices
+import org.jetbrains.kotlinx.dataframe.api.isList
+import org.jetbrains.kotlinx.dataframe.api.mapIndexed
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.named
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.api.single
+import org.jetbrains.kotlinx.dataframe.api.splitInto
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadDfMethod
+import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadJsonMethod
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.ColumnNameGenerator
+import org.jetbrains.kotlinx.dataframe.impl.DataCollectorBase
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import org.jetbrains.kotlinx.dataframe.impl.columns.createColumn
+import org.jetbrains.kotlinx.dataframe.impl.commonType
+import org.jetbrains.kotlinx.dataframe.impl.createDataCollector
+import org.jetbrains.kotlinx.dataframe.impl.guessValueType
+import org.jetbrains.kotlinx.dataframe.impl.schema.DataFrameSchemaImpl
+import org.jetbrains.kotlinx.dataframe.impl.schema.extractSchema
+import org.jetbrains.kotlinx.dataframe.impl.schema.intersectSchemas
+import org.jetbrains.kotlinx.dataframe.impl.splitByIndices
+import org.jetbrains.kotlinx.dataframe.io.JSON.TypeClashTactic
+import org.jetbrains.kotlinx.dataframe.io.JSON.TypeClashTactic.ANY_COLUMNS
+import org.jetbrains.kotlinx.dataframe.io.JSON.TypeClashTactic.ARRAY_AND_VALUE_COLUMNS
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
+import org.jetbrains.kotlinx.dataframe.type
+import org.jetbrains.kotlinx.dataframe.typeClass
+import org.jetbrains.kotlinx.dataframe.values
+import java.io.File
+import java.io.InputStream
+import java.net.URL
+import kotlin.reflect.KType
+import kotlin.reflect.KTypeProjection
+import kotlin.reflect.full.createType
+import kotlin.reflect.typeOf
+
+public class JSON(
+    private val typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+    private val keyValuePaths: List<JsonPath> = emptyList(),
+) : SupportedDataFrameFormat {
+    override fun readDataFrame(stream: InputStream, header: List<String>): AnyFrame =
+        DataFrame.readJson(
+            stream = stream,
+            header = header,
+            typeClashTactic = typeClashTactic,
+            keyValuePaths = keyValuePaths,
+        )
+
+    override fun readDataFrame(file: File, header: List<String>): AnyFrame =
+        DataFrame.readJson(
+            file = file,
+            header = header,
+            typeClashTactic = typeClashTactic,
+            keyValuePaths = keyValuePaths,
+        )
+
+    override fun acceptsExtension(ext: String): Boolean = ext == "json"
+    override fun acceptsSample(sample: SupportedFormatSample): Boolean = true // Extension is enough
+
+    override val testOrder: Int = 10_000
+
+    override fun createDefaultReadMethod(pathRepresentation: String?): DefaultReadDfMethod =
+        DefaultReadJsonMethod(
+            path = pathRepresentation,
+            arguments = MethodArguments()
+                .add(
+                    "keyValuePaths",
+                    typeOf<List<JsonPath>>(),
+                    "listOf(${keyValuePaths.joinToString { "org.jetbrains.kotlinx.dataframe.api.JsonPath(\"\"\"${it.path}\"\"\")" }})",
+                )
+                .add(
+                    "typeClashTactic",
+                    typeOf<TypeClashTactic>(),
+                    "org.jetbrains.kotlinx.dataframe.io.JSON.TypeClashTactic.${typeClashTactic.name}",
+                ),
+        )
+
+    /**
+     * Allows the choice of how to handle type clashes when reading a JSON file.
+     * Such as:
+     * ```json
+     * [
+     *     { "a": "text" },
+     *     { "a": { "b": 2 } },
+     *     { "a": [6, 7, 8] }
+     *  ]
+     * ```
+     *
+     * [ARRAY_AND_VALUE_COLUMNS] (default) will create a [DataFrame] looking like (including `null` and `[]` values):
+     * ```
+     * ⌌----------------------------------------------⌍
+     * |  | a:{b:Int?, value:String?, array:List<Int>}|
+     * |--|-------------------------------------------|
+     * | 0|         { b:null, value:"text", array:[] }|
+     * | 1|              { b:2, value:null, array:[] }|
+     * | 2|    { b:null, value:null, array:[6, 7, 8] }|
+     * ⌎----------------------------------------------⌏
+     * ```
+     * So, for the type clashing argument it will create a [ColumnGroup] with the properties `value`, `array`,
+     * and the unwrapped properties of the objects the property can be.
+     *
+     * [ANY_COLUMNS] will create a [DataFrame] looking like:
+     * ```
+     * ⌌-------------⌍
+     * |  |     a:Any|
+     * |--|----------|
+     * | 0|    "text"|
+     * | 1|   { b:2 }|
+     * | 2| [6, 7, 8]|
+     * ⌎-------------⌏
+     * ```
+     */
+    public enum class TypeClashTactic {
+        ARRAY_AND_VALUE_COLUMNS,
+        ANY_COLUMNS,
+    }
+}
+
+/**
+ * @param file Where to fetch the Json as [InputStream] to be converted to a [DataFrame].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param typeClashTactic How to handle type clashes when reading a JSON file.
+ * @param header Optional list of column names. If given, the file will be read like an object with [header] being the keys.
+ * @return [DataFrame] from the given [file].
+ */
+public fun DataFrame.Companion.readJson(
+    file: File,
+    header: List<String> = emptyList(),
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): AnyFrame = readJson(file.toURI().toURL(), header, keyValuePaths, typeClashTactic)
+
+/**
+ * @param file Where to fetch the Json as [InputStream] to be converted to a [DataRow].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param typeClashTactic How to handle type clashes when reading a JSON file.
+ * @param header Optional list of column names. If given, the file will be read like an object with [header] being the keys.
+ * @return [DataRow] from the given [file].
+ */
+public fun DataRow.Companion.readJson(
+    file: File,
+    header: List<String> = emptyList(),
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): AnyRow = DataFrame.readJson(file, header, keyValuePaths, typeClashTactic).single()
+
+/**
+ * @param path URL or file path from where to fetch the Json as [InputStream] to be converted to a [DataFrame].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param typeClashTactic How to handle type clashes when reading a JSON file.
+ * @param header Optional list of column names. If given, the stream will be read like an object with [header] being the keys.
+ * @return [DataFrame] from the given [path].
+ */
+public fun DataFrame.Companion.readJson(
+    path: String,
+    header: List<String> = emptyList(),
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): AnyFrame = readJson(asURL(path), header, keyValuePaths, typeClashTactic)
+
+/**
+ * @param path URL or file path from where to fetch the Json as [InputStream] to be converted to a [DataRow].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param typeClashTactic How to handle type clashes when reading a JSON file.
+ * @param header Optional list of column names. If given, the stream will be read like an object with [header] being the keys.
+ * @return [DataRow] from the given [path].
+ */
+public fun DataRow.Companion.readJson(
+    path: String,
+    header: List<String> = emptyList(),
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): AnyRow = DataFrame.readJson(path, header, keyValuePaths, typeClashTactic).single()
+
+/**
+ * @param url Where to fetch the Json as [InputStream] to be converted to a [DataFrame].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param typeClashTactic How to handle type clashes when reading a JSON file.
+ * @param header Optional list of column names. If given, the stream will be read like an object with [header] being the keys.
+ * @return [DataFrame] from the given [url].
+ */
+public fun DataFrame.Companion.readJson(
+    url: URL,
+    header: List<String> = emptyList(),
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): AnyFrame = catchHttpResponse(url) { readJson(it, header, keyValuePaths, typeClashTactic) }
+
+/**
+ * @param url Where to fetch the Json as [InputStream] to be converted to a [DataRow].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param typeClashTactic How to handle type clashes when reading a JSON file.
+ * @param header Optional list of column names. If given, the stream will be read like an object with [header] being the keys.
+ * @return [DataRow] from the given [url].
+ */
+public fun DataRow.Companion.readJson(
+    url: URL,
+    header: List<String> = emptyList(),
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): AnyRow = DataFrame.readJson(url, header, keyValuePaths, typeClashTactic).single()
+
+/**
+ * @param stream Json as [InputStream] to be converted to a [DataFrame].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param typeClashTactic How to handle type clashes when reading a JSON file.
+ * @param header Optional list of column names. If given, [stream] will be read like an object with [header] being the keys.
+ * @return [DataFrame] from the given [stream].
+ */
+public fun DataFrame.Companion.readJson(
+    stream: InputStream,
+    header: List<String> = emptyList(),
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): AnyFrame = readJson(Parser.default().parse(stream), header, keyValuePaths, typeClashTactic)
+
+/**
+ * @param stream Json as [InputStream] to be converted to a [DataRow].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param typeClashTactic How to handle type clashes when reading a JSON file.
+ * @param header Optional list of column names. If given, [stream] will be read like an object with [header] being the keys.
+ * @return [DataRow] from the given [stream].
+ */
+public fun DataRow.Companion.readJson(
+    stream: InputStream,
+    header: List<String> = emptyList(),
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): AnyRow = DataFrame.readJson(stream, header, keyValuePaths, typeClashTactic).single()
+
+/**
+ * @param text Json as [String] to be converted to a [DataFrame].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param typeClashTactic How to handle type clashes when reading a JSON file.
+ * @param header Optional list of column names. If given, [text] will be read like an object with [header] being the keys.
+ * @return [DataFrame] from the given [text].
+ */
+public fun DataFrame.Companion.readJsonStr(
+    text: String,
+    header: List<String> = emptyList(),
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): AnyFrame = readJson(Parser.default().parse(StringBuilder(text)), header, keyValuePaths, typeClashTactic)
+
+/**
+ * @param text Json as [String] to be converted to a [DataRow].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param typeClashTactic How to handle type clashes when reading a JSON file.
+ * @param header Optional list of column names. If given, [text] will be read like an object with [header] being the keys.
+ * @return [DataRow] from the given [text].
+ */
+public fun DataRow.Companion.readJsonStr(
+    text: String,
+    header: List<String> = emptyList(),
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): AnyRow = DataFrame.readJsonStr(text, header, keyValuePaths, typeClashTactic).single()
+
+private fun readJson(
+    parsed: Any?,
+    header: List<String>,
+    keyValuePaths: List<JsonPath> = emptyList(),
+    typeClashTactic: TypeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+): DataFrame<*> {
+    val df: AnyFrame = when (typeClashTactic) {
+        ARRAY_AND_VALUE_COLUMNS -> {
+            when (parsed) {
+                is JsonArray<*> -> fromJsonListArrayAndValueColumns(
+                    records = parsed.value,
+                    header = header,
+                    keyValuePaths = keyValuePaths,
+                )
+
+                else -> fromJsonListArrayAndValueColumns(
+                    records = listOf(parsed),
+                    keyValuePaths = keyValuePaths,
+                )
+            }
+        }
+
+        ANY_COLUMNS -> {
+            when (parsed) {
+                is JsonArray<*> -> fromJsonListAnyColumns(
+                    records = parsed.value,
+                    header = header,
+                    keyValuePaths = keyValuePaths,
+                )
+
+                else -> fromJsonListAnyColumns(
+                    records = listOf(parsed),
+                    keyValuePaths = keyValuePaths,
+                )
+            }
+        }
+    }
+    return df.unwrapUnnamedColumns()
+}
+
+private fun DataFrame<Any?>.unwrapUnnamedColumns() =
+    dataFrameOf(columns().map { it.unwrapUnnamedColumn() })
+
+private fun AnyCol.unwrapUnnamedColumn() = if (this is UnnamedColumn) col else this
+
+private enum class AnyColType {
+    ANY,
+    ARRAYS,
+    OBJECTS,
+}
+
+internal interface AnyKeyValueProperty : KeyValueProperty<Any?> {
+    override val value: Any?
+}
+
+/**
+ * Json to DataFrame converter that creates [Any] columns.
+ * A.k.a. [TypeClashTactic.ANY_COLUMNS].
+ *
+ * @param records List of json elements to be converted to a [DataFrame].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param header Optional list of column names. If given, [records] will be read like an object with [header] being the keys.
+ * @return [DataFrame] from the given [records].
+ */
+internal fun fromJsonListAnyColumns(
+    records: List<*>,
+    keyValuePaths: List<JsonPath> = emptyList(),
+    header: List<String> = emptyList(),
+    jsonPath: JsonPath = JsonPath(),
+): AnyFrame {
+    var hasPrimitive = false
+    var hasArray = false
+    var hasObject = false
+
+    // list element type can be JsonObject, JsonArray or primitive
+    val nameGenerator = ColumnNameGenerator()
+    records.forEach {
+        when (it) {
+            is JsonObject -> {
+                hasObject = true
+                it.entries.forEach {
+                    nameGenerator.addIfAbsent(it.key)
+                }
+            }
+
+            is JsonArray<*> -> hasArray = true
+            null -> Unit
+            else -> hasPrimitive = true
+        }
+    }
+
+    val colType = when {
+        hasArray && !hasPrimitive && !hasObject -> AnyColType.ARRAYS
+        hasObject && !hasPrimitive && !hasArray -> AnyColType.OBJECTS
+        else -> AnyColType.ANY
+    }
+    val justPrimitives = hasPrimitive && !hasArray && !hasObject
+    val isKeyValue = keyValuePaths.any { jsonPath.matches(it) }
+
+    if (isKeyValue && colType != AnyColType.OBJECTS) {
+        error("Key value path $jsonPath does not match objects.")
+    }
+
+    @Suppress("KotlinConstantConditions")
+    val columns: List<AnyCol> = when {
+        // Create one column of type Any? (or guessed primitive type) from all the records
+        colType == AnyColType.ANY -> {
+            val collector: DataCollectorBase<Any?> =
+                if (justPrimitives) createDataCollector(records.size) // guess the type
+                else createDataCollector(records.size, typeOf<Any?>()) // use Any?
+
+            val nanIndices = mutableListOf<Int>()
+            records.forEachIndexed { i, v ->
+                when (v) {
+                    is JsonObject -> {
+                        val parsed =
+                            fromJsonListAnyColumns(
+                                records = listOf(v),
+                                keyValuePaths = keyValuePaths,
+                                jsonPath = jsonPath.replaceLastWildcardWithIndex(i),
+                            )
+                        collector.add(
+                            if (parsed.isSingleUnnamedColumn()) (parsed.getColumn(0) as UnnamedColumn).col.values.first()
+                            else parsed.firstOrNull() ?: DataRow.empty
+                        )
+                    }
+
+                    is JsonArray<*> -> {
+                        val parsed = fromJsonListAnyColumns(
+                            records = v,
+                            keyValuePaths = keyValuePaths,
+                            jsonPath = jsonPath.replaceLastWildcardWithIndex(i).appendArrayWithWildcard(),
+                        )
+                        collector.add(
+                            if (parsed.isSingleUnnamedColumn()) (parsed.getColumn(0) as UnnamedColumn).col.values.asList()
+                            else parsed.unwrapUnnamedColumns()
+                        )
+                    }
+
+                    "NaN" -> {
+                        nanIndices.add(i)
+                        collector.add(null)
+                    }
+
+                    else -> collector.add(v)
+                }
+            }
+            val column = collector.toColumn(valueColumnName)
+            val res = if (nanIndices.isNotEmpty()) {
+                fun <C> DataColumn<C>.updateNaNs(nanValue: C): DataColumn<C> {
+                    var j = 0
+                    var nextNanIndex = nanIndices[j]
+                    return mapIndexed(column.type) { i, v ->
+                        if (i == nextNanIndex) {
+                            j++
+                            nextNanIndex = if (j < nanIndices.size) nanIndices[j] else -1
+                            nanValue
+                        } else v
+                    }
+                }
+                when (column.typeClass) {
+                    Double::class -> column.cast<Double?>().updateNaNs(Double.NaN)
+                    Float::class -> column.cast<Float?>().updateNaNs(Float.NaN)
+                    String::class -> column.cast<String?>().updateNaNs("NaN")
+                    else -> column
+                }
+            } else column
+            listOf(UnnamedColumn(res))
+        }
+
+        // Create one column of type FrameColumn, or List<> from all the records if they are all arrays
+        colType == AnyColType.ARRAYS -> {
+            val values = mutableListOf<Any?>()
+            val startIndices = ArrayList<Int>()
+            records.forEach {
+                startIndices.add(values.size)
+                when (it) {
+                    is JsonArray<*> -> values.addAll(it.value)
+                    null -> Unit
+                    else -> error("Expected JsonArray, got $it")
+                }
+            }
+            val parsed = fromJsonListAnyColumns(
+                records = values,
+                keyValuePaths = keyValuePaths,
+                jsonPath = jsonPath.appendArrayWithWildcard(),
+            )
+
+            val res = when {
+                parsed.isSingleUnnamedColumn() -> {
+                    val col = (parsed.getColumn(0) as UnnamedColumn).col
+                    val elementType = col.type
+                    val values = col.values.asList().splitByIndices(startIndices.asSequence()).toList()
+                    DataColumn.createValueColumn(
+                        name = arrayColumnName,
+                        values = values,
+                        type = List::class.createType(listOf(KTypeProjection.invariant(elementType))),
+                    )
+                }
+
+                else -> DataColumn.createFrameColumn(
+                    name = arrayColumnName, // will be erased
+                    df = parsed.unwrapUnnamedColumns(),
+                    startIndices = startIndices,
+                )
+            }
+            listOf(UnnamedColumn(res))
+        }
+
+        // Create one column of type FrameColumn<KeyValueProperty>
+        colType == AnyColType.OBJECTS && isKeyValue -> {
+            // collect the value types to make sure Value columns with lists and other values aren't all turned into lists
+            val valueTypes = mutableSetOf<KType>()
+            val dataFrames = records.map {
+                when (it) {
+                    is JsonObject -> {
+                        val map = it.map.mapValues { (key, value) ->
+                            val parsed = fromJsonListAnyColumns(
+                                records = listOf(value),
+                                keyValuePaths = keyValuePaths,
+                                jsonPath = jsonPath.append(key),
+                            )
+                            if (parsed.isSingleUnnamedColumn()) (parsed.getColumn(0) as UnnamedColumn).col.values.first()
+                            else parsed.unwrapUnnamedColumns().firstOrNull()
+                        }
+                        val valueType = map.values.map {
+                            guessValueType(sequenceOf(it))
+                        }.commonType()
+
+                        valueTypes += valueType
+
+                        dataFrameOf(
+                            columnOf(*map.keys.toTypedArray()).named(KeyValueProperty<*>::key.name),
+                            createColumn(values = map.values, suggestedType = valueType, guessType = false)
+                                .named(KeyValueProperty<*>::value.name),
+                        )
+                    }
+
+                    null -> DataFrame.emptyOf<AnyKeyValueProperty>()
+                    else -> error("Expected JsonObject, got $it")
+                }
+            }
+
+            val valueColumns = dataFrames.map { it[KeyValueProperty<*>::value.name] }
+            val valueColumnSchema = when {
+                // in these cases we can safely combine the columns to get a single column schema
+                valueColumns.all { it is ColumnGroup<*> } || valueColumns.all { it is FrameColumn<*> } ->
+                    valueColumns.concat().extractSchema()
+                // to avoid listification, we create the value columns schema ourselves (https://github.com/Kotlin/dataframe/issues/184)
+                else -> ColumnSchema.Value(valueTypes.commonType())
+            }
+
+            listOf(
+                UnnamedColumn(
+                    DataColumn.createFrameColumn(
+                        name = valueColumnName, // will be erased unless at top-level
+                        groups = dataFrames,
+                        schema = lazy {
+                            DataFrameSchemaImpl(
+                                columns = mapOf(
+                                    KeyValueProperty<*>::key.name to ColumnSchema.Value(typeOf<String>()),
+                                    KeyValueProperty<*>::value.name to valueColumnSchema,
+                                )
+                            )
+                        },
+                    )
+                )
+            )
+        }
+
+        // Create multiple columns from all the records if they are all objects, merging the objects in essence
+        colType == AnyColType.OBJECTS && !isKeyValue -> {
+            nameGenerator.names.map { colName ->
+                val values = ArrayList<Any?>(records.size)
+
+                records.forEach {
+                    when (it) {
+                        is JsonObject -> values.add(it[colName])
+                        null -> values.add(null)
+                        else -> error("Expected JsonObject, got $it")
+                    }
+                }
+
+                val parsed = fromJsonListAnyColumns(
+                    records = values,
+                    keyValuePaths = keyValuePaths,
+                    jsonPath = jsonPath.append(colName),
+                )
+                when {
+                    parsed.ncol == 0 ->
+                        DataColumn.createValueColumn(
+                            name = colName,
+                            values = arrayOfNulls<Any?>(values.size).toList(),
+                            type = typeOf<Any?>(),
+                        )
+
+                    parsed.isSingleUnnamedColumn() ->
+                        (parsed.getColumn(0) as UnnamedColumn).col.rename(colName)
+
+                    else ->
+                        DataColumn.createColumnGroup(colName, parsed.unwrapUnnamedColumns()) as AnyCol
+                }
+            }
+        }
+
+        else -> error("")
+    }
+
+    return when {
+        columns.isEmpty() -> DataFrame.empty(records.size)
+
+        columns.size == 1 && hasArray && header.isNotEmpty() && columns[0].typeClass == List::class ->
+            columns[0]
+                .cast<List<*>>()
+                .splitInto(*header.toTypedArray())
+
+        else -> columns.toDataFrame()
+    }
+}
+
+public const val arrayColumnName: String = "array"
+public const val valueColumnName: String = "value"
+
+private fun AnyFrame.isSingleUnnamedColumn() = ncol == 1 && getColumn(0) is UnnamedColumn
+
+/**
+ * Json to DataFrame converter that creates allows creates `value` and `array` accessors
+ * instead of [Any] columns.
+ * A.k.a. [TypeClashTactic.ARRAY_AND_VALUE_COLUMNS].
+ *
+ * @param records List of json elements to be converted to a [DataFrame].
+ * @param keyValuePaths List of [JsonPath]s where instead of a [ColumnGroup], a [FrameColumn]<[KeyValueProperty]>
+ *     will be created.
+ * @param header Optional list of column names. If given, [records] will be read like an object with [header] being the keys.
+ * @return [DataFrame] from the given [records].
+ */
+internal fun fromJsonListArrayAndValueColumns(
+    records: List<*>,
+    keyValuePaths: List<JsonPath> = emptyList(),
+    header: List<String> = emptyList(),
+    jsonPath: JsonPath = JsonPath(),
+): AnyFrame {
+    var hasPrimitive = false
+    var hasArray = false
+    val isKeyValue = keyValuePaths.any { jsonPath.matches(it) }
+
+    // list element type can be JsonObject, JsonArray or primitive
+    // So first, we gather all properties of objects to merge including "array" and "value" if needed
+    // so the resulting type of a property with instances 123, ["abc"], and { "a": 1, "b": 2 } will be
+    // { array: List<String>, value: Int?, a: Int?, b: Int? }
+    // and instances will look like
+    // { "array": [], "value": 123, "a": null, "b": null }
+
+    val nameGenerator = ColumnNameGenerator()
+    records.forEach {
+        when (it) {
+            is JsonObject -> it.entries.forEach {
+                nameGenerator.addIfAbsent(it.key)
+            }
+
+            is JsonArray<*> -> hasArray = true
+            null -> Unit
+            else -> hasPrimitive = true
+        }
+    }
+    if (records.all { it == null }) hasPrimitive = true
+
+    // Add a value column to the collected names if needed
+    val valueColumn = if (hasPrimitive || records.isEmpty()) {
+        nameGenerator.addUnique(valueColumnName)
+    } else null
+
+    // Add an array column to the collected names if needed
+    val arrayColumn = if (hasArray) {
+        nameGenerator.addUnique(arrayColumnName)
+    } else null
+
+    // only properties that consist of just objects (or are empty) can be merged to key/value FrameColumns
+    if (isKeyValue && (hasPrimitive || hasArray)) {
+        error("Key value path $jsonPath does not match objects.")
+    }
+
+    // Create columns from the collected names
+    val columns: List<AnyCol> = when {
+        // instead of using the names, generate a single key/value frame column
+        isKeyValue -> {
+            val dataFrames = records.map {
+                when (it) {
+                    is JsonObject -> {
+                        val map = it.map.mapValues { (key, value) ->
+                            val parsed = fromJsonListArrayAndValueColumns(
+                                records = listOf(value),
+                                keyValuePaths = keyValuePaths,
+                                jsonPath = jsonPath.append(key),
+                            )
+                            if (parsed.isSingleUnnamedColumn()) (parsed.getColumn(0) as UnnamedColumn).col.values.first()
+                            else parsed.unwrapUnnamedColumns().firstOrNull()
+                        }
+                        val valueType =
+                            map.values.map { guessValueType(sequenceOf(it)) }
+                                .commonType()
+
+                        dataFrameOf(
+                            columnOf(*map.keys.toTypedArray()).named(KeyValueProperty<*>::key.name),
+                            createColumn(
+                                values = map.values,
+                                suggestedType = valueType,
+                                guessType = false,
+                            ).named(KeyValueProperty<*>::value.name),
+                        )
+                    }
+
+                    null -> DataFrame.emptyOf<AnyKeyValueProperty>()
+                    else -> error("Expected JsonObject, got $it")
+                }
+            }
+
+            listOf(
+                UnnamedColumn(
+                    DataColumn.createFrameColumn(
+                        name = valueColumnName, // will be erased unless at top-level
+                        groups = dataFrames,
+                        schema = lazy {
+                            dataFrames.mapNotNull { it.takeIf { it.nrow > 0 }?.schema() }.intersectSchemas()
+                        },
+                    )
+                )
+            )
+        }
+
+        // generate columns using the collected names
+        else ->
+            nameGenerator.names.map { colName ->
+                when {
+                    // Collect primitive values from records into the `value` column if needed
+                    colName == valueColumn && (hasPrimitive || records.isEmpty()) -> {
+                        val collector = createDataCollector(records.size)
+                        val nanIndices = mutableListOf<Int>()
+                        records.forEachIndexed { i, v ->
+                            when (v) {
+                                is JsonObject -> collector.add(null)
+                                is JsonArray<*> -> collector.add(null)
+                                "NaN" -> {
+                                    nanIndices.add(i)
+                                    collector.add(null)
+                                }
+
+                                else -> collector.add(v)
+                            }
+                        }
+                        val column = collector.toColumn(colName)
+                        val res = if (nanIndices.isNotEmpty()) {
+                            fun <C> DataColumn<C>.updateNaNs(nanValue: C): DataColumn<C> {
+                                var j = 0
+                                var nextNanIndex = nanIndices[j]
+                                return mapIndexed(column.type) { i, v ->
+                                    if (i == nextNanIndex) {
+                                        j++
+                                        nextNanIndex = if (j < nanIndices.size) nanIndices[j] else -1
+                                        nanValue
+                                    } else v
+                                }
+                            }
+                            when (column.typeClass) {
+                                Double::class -> column.cast<Double?>().updateNaNs(Double.NaN)
+                                Float::class -> column.cast<Float?>().updateNaNs(Float.NaN)
+                                String::class -> column.cast<String?>().updateNaNs("NaN")
+                                else -> column
+                            }
+                        } else column
+                        UnnamedColumn(res)
+                    }
+
+                    // Collect arrays from records into the `array` column if needed
+                    colName == arrayColumn && hasArray -> {
+                        val values = mutableListOf<Any?>()
+                        val startIndices = ArrayList<Int>()
+                        records.forEach {
+                            startIndices.add(values.size)
+                            if (it is JsonArray<*>) values.addAll(it.value)
+                        }
+                        val parsed = fromJsonListArrayAndValueColumns(
+                            records = values,
+                            keyValuePaths = keyValuePaths,
+                            jsonPath = jsonPath.appendArrayWithWildcard(),
+                        )
+
+                        val res = when {
+                            parsed.isSingleUnnamedColumn() -> {
+                                val col = (parsed.getColumn(0) as UnnamedColumn).col
+                                val elementType = col.type
+                                val values = col.values.asList().splitByIndices(startIndices.asSequence()).toList()
+                                DataColumn.createValueColumn(
+                                    name = colName,
+                                    values = values,
+                                    type = List::class.createType(listOf(KTypeProjection.invariant(elementType))),
+                                )
+                            }
+
+                            else -> DataColumn.createFrameColumn(colName, parsed.unwrapUnnamedColumns(), startIndices)
+                        }
+                        UnnamedColumn(res)
+                    }
+
+                    // Collect the current column name as property from the objects in records
+                    else -> {
+                        val values = ArrayList<Any?>(records.size)
+                        records.forEach {
+                            when (it) {
+                                is JsonObject -> values.add(it[colName])
+                                else -> values.add(null)
+                            }
+                        }
+
+                        val parsed = fromJsonListArrayAndValueColumns(
+                            records = values,
+                            keyValuePaths = keyValuePaths,
+                            jsonPath = jsonPath.append(colName),
+                        )
+                        when {
+                            parsed.ncol == 0 ->
+                                DataColumn.createValueColumn(
+                                    name = colName,
+                                    values = arrayOfNulls<Any?>(values.size).toList(),
+                                    type = typeOf<Any?>(),
+                                )
+
+                            parsed.isSingleUnnamedColumn() ->
+                                (parsed.getColumn(0) as UnnamedColumn).col.rename(colName)
+
+                            else ->
+                                DataColumn.createColumnGroup(colName, parsed.unwrapUnnamedColumns()) as AnyCol
+                        }
+                    }
+                }
+            }
+    }
+
+    return when {
+        columns.isEmpty() ->
+            DataFrame.empty(records.size)
+
+        columns.size == 1 && hasArray && header.isNotEmpty() && columns[0].typeClass == List::class ->
+            columns[0]
+                .cast<List<*>>()
+                .splitInto(*header.toTypedArray())
+
+        else ->
+            columns.toDataFrame()
+    }
+}
+
+// we need it to check if AnyFrame created by recursive call has single unnamed column,
+// unnamed column means this column is not created from field of a record [{"value": 1}, {"value": 2}],
+// but filtered values [1, { ... }, []] -> [1, null, null]
+// or arrays: [1, { ...}, []] -> [null, null, []]
+private class UnnamedColumn(val col: DataColumn<Any?>) : DataColumn<Any?> by col
+
+private val valueTypes =
+    setOf(Boolean::class, Double::class, Int::class, Float::class, Long::class, Short::class, Byte::class)
+
+internal fun KlaxonJson.encodeRow(frame: ColumnsContainer<*>, index: Int): JsonObject? {
+    val values = frame.columns().map { col ->
+        when {
+            col is ColumnGroup<*> -> encodeRow(col, index)
+            col is FrameColumn<*> -> encodeFrame(col[index])
+            col.isList() -> {
+                col[index]?.let { array(it as List<*>) } ?: array()
+            }
+
+            col.typeClass in valueTypes -> {
+                val v = col[index]
+                if ((v is Double && v.isNaN()) || (v is Float && v.isNaN())) {
+                    v.toString()
+                } else v
+            }
+
+            else -> col[index]?.toString()
+        }.let { col.name to it }
+    }
+    if (values.isEmpty()) return null
+    return obj(values)
+}
+
+internal fun KlaxonJson.encodeFrame(frame: AnyFrame): JsonArray<*> {
+    val allColumns = frame.columns()
+
+    // if there is only 1 column, then `isValidValueColumn` always true.
+    // But at the same time, we shouldn't treat dataFrameOf("value")(1,2,3) like unnamed column
+    // because it was created by user.
+    val isPossibleToFindUnnamedColumns = allColumns.size != 1
+    val valueColumn = allColumns.filter { it.name.startsWith(valueColumnName) }
+        .takeIf { isPossibleToFindUnnamedColumns }
+        ?.maxByOrNull { it.name }?.let { valueCol ->
+            if (valueCol.kind() != ColumnKind.Value) { // check that value in this column is not null only when other values are null
+                null
+            } else {
+                // check that value in this column is not null only when other values are null
+                val isValidValueColumn = frame.rows().all { row ->
+                    if (valueCol[row] != null) {
+                        allColumns.all { col ->
+                            if (col.name != valueCol.name) col[row] == null
+                            else true
+                        }
+                    } else true
+                }
+                if (isValidValueColumn) valueCol
+                else null
+            }
+        }
+
+    val arrayColumn = frame.columns().filter { it.name.startsWith(arrayColumnName) }
+        .takeIf { isPossibleToFindUnnamedColumns }
+        ?.maxByOrNull { it.name }?.let { arrayCol ->
+            if (arrayCol.kind() == ColumnKind.Group) null
+            else {
+                // check that value in this column is not null only when other values are null
+                val isValidArrayColumn = frame.rows().all { row ->
+                    if (arrayCol[row] != null) {
+                        allColumns.all { col ->
+                            if (col.name != arrayCol.name) col[row] == null
+                            else true
+                        }
+                    } else true
+                }
+                if (isValidArrayColumn) arrayCol
+                else null
+            }
+        }
+
+    val arraysAreFrames = arrayColumn?.kind() == ColumnKind.Frame
+
+    val data = frame.indices().map { rowIndex ->
+        valueColumn?.get(rowIndex) ?: arrayColumn?.get(rowIndex)
+            ?.let { if (arraysAreFrames) encodeFrame(it as AnyFrame) else null } ?: encodeRow(frame, rowIndex)
+    }
+    return array(data)
+}
+
+public fun AnyFrame.toJson(prettyPrint: Boolean = false, canonical: Boolean = false): String {
+    return json {
+        encodeFrame(this@toJson)
+    }.toJsonString(prettyPrint, canonical)
+}
+
+public fun AnyRow.toJson(prettyPrint: Boolean = false, canonical: Boolean = false): String {
+    return json {
+        encodeRow(df(), index())
+    }?.toJsonString(prettyPrint, canonical) ?: ""
+}
+
+public fun AnyFrame.writeJson(file: File, prettyPrint: Boolean = false, canonical: Boolean = false) {
+    file.writeText(toJson(prettyPrint, canonical))
+}
+
+public fun AnyFrame.writeJson(path: String, prettyPrint: Boolean = false, canonical: Boolean = false): Unit =
+    writeJson(File(path), prettyPrint, canonical)
+
+public fun AnyFrame.writeJson(writer: Appendable, prettyPrint: Boolean = false, canonical: Boolean = false) {
+    writer.append(toJson(prettyPrint, canonical))
+}
+
+public fun AnyRow.writeJson(file: File, prettyPrint: Boolean = false, canonical: Boolean = false) {
+    file.writeText(toJson(prettyPrint, canonical))
+}
+
+public fun AnyRow.writeJson(path: String, prettyPrint: Boolean = false, canonical: Boolean = false) {
+    writeJson(File(path), prettyPrint, canonical)
+}
+
+public fun AnyRow.writeJson(writer: Appendable, prettyPrint: Boolean = false, canonical: Boolean = false) {
+    writer.append(toJson(prettyPrint, canonical))
+}
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
new file mode 100644
index 000000000..7aacb998c
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/string.kt
@@ -0,0 +1,187 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.api.asNumbers
+import org.jetbrains.kotlinx.dataframe.api.columnsCount
+import org.jetbrains.kotlinx.dataframe.api.isNumber
+import org.jetbrains.kotlinx.dataframe.api.take
+import org.jetbrains.kotlinx.dataframe.api.toColumn
+import org.jetbrains.kotlinx.dataframe.impl.owner
+import org.jetbrains.kotlinx.dataframe.impl.renderType
+import org.jetbrains.kotlinx.dataframe.impl.scale
+import org.jetbrains.kotlinx.dataframe.impl.truncate
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.jupyter.RenderedContent
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.size
+import java.math.BigDecimal
+
+internal fun AnyFrame.renderToString(
+    rowsLimit: Int = 20,
+    valueLimit: Int = 40,
+    borders: Boolean = false,
+    alignLeft: Boolean = false,
+    columnTypes: Boolean = false,
+    title: Boolean = false,
+    rowIndex: Boolean = true,
+): String {
+    val sb = StringBuilder()
+
+    // title
+    if (title) {
+        sb.appendLine("Data Frame [${size()}]")
+        sb.appendLine()
+    }
+
+    // data
+    val rowsCount = rowsLimit.coerceAtMost(nrow)
+    val cols = if (rowIndex) listOf((0 until rowsCount).toColumn()) + columns() else columns()
+    val header = cols.mapIndexed { colIndex, col ->
+        if (columnTypes && (!rowIndex || colIndex > 0)) {
+            "${col.name()}:${renderType(col)}"
+        } else col.name()
+    }
+    val values = cols.map {
+        val top = it.take(rowsLimit)
+        val precision = if (top.isNumber()) top.asNumbers().scale() else 0
+        val decimalFormat =
+            if (precision >= 0) RendererDecimalFormat.fromPrecision(precision) else RendererDecimalFormat.of("%e")
+        top.values().map {
+            renderValueForStdout(it, valueLimit, decimalFormat = decimalFormat).truncatedContent
+        }
+    }
+    val columnLengths = values.mapIndexed { col, vals -> (vals + header[col]).map { it.length }.maxOrNull()!! + 1 }
+
+    // top border
+    if (borders) {
+        sb.append("\u230C")
+        for (i in 1 until columnLengths.sum() + columnLengths.size) sb.append('-')
+        sb.append("\u230D")
+        sb.appendLine()
+        sb.append("|")
+    }
+
+    // header
+    for (col in header.indices) {
+        val len = columnLengths[col]
+        val str = header[col]
+        val padded = if (alignLeft) str.padEnd(len) else str.padStart(len)
+        sb.append(padded)
+        if (borders) sb.append("|")
+    }
+    sb.appendLine()
+
+    // header splitter
+    if (borders) {
+        sb.append("|")
+        for (colLength in columnLengths) {
+            for (i in 1..colLength) sb.append('-')
+            sb.append("|")
+        }
+        sb.appendLine()
+    }
+
+    // data
+    for (row in 0 until rowsCount) {
+        if (borders) sb.append("|")
+        for (col in values.indices) {
+            val len = columnLengths[col]
+            val str = values[col][row]
+            val padded = if (alignLeft) str.padEnd(len) else str.padStart(len)
+            sb.append(padded)
+            if (borders) sb.append("|")
+        }
+        sb.appendLine()
+    }
+
+    // footer
+    if (nrow > rowsLimit) {
+        sb.appendLine("...")
+    } else if (borders) {
+        sb.append("\u230E")
+        for (i in 1 until columnLengths.sum() + columnLengths.size) sb.append('-')
+        sb.append("\u230F")
+        sb.appendLine()
+    }
+    return sb.toString()
+}
+
+internal val valueToStringLimitDefault = 1000
+internal val valueToStringLimitForRowAsTable = 50
+
+internal fun AnyRow.getVisibleValues(): List<Pair<String, Any?>> {
+    fun Any?.skip(): Boolean = when (this) {
+        null -> true
+        is List<*> -> this.isEmpty()
+        is AnyRow -> values().all { it.skip() }
+        else -> false
+    }
+    return owner.columns().map { it.name() to it[index] }.filter { !it.second.skip() }
+}
+
+internal fun AnyRow.renderToString(): String {
+    val values = getVisibleValues()
+    if (values.isEmpty()) return "{ }"
+    return values
+        .map { "${it.first}:${renderValueForStdout(it.second).truncatedContent}" }
+        .joinToString(prefix = "{ ", postfix = " }")
+}
+
+internal fun AnyRow.renderToStringTable(forHtml: Boolean = false): String {
+    if (columnsCount() == 0) return ""
+    val pairs = owner.columns().map { it.name() to renderValueForRowTable(it[index], forHtml) }
+    val width = pairs.map { it.first.length + it.second.textLength }.maxOrNull()!! + 4
+    return pairs.joinToString("\n") {
+        it.first + " ".repeat(width - it.first.length - it.second.textLength) + it.second.truncatedContent
+    }
+}
+
+internal fun renderCollectionName(value: Collection<*>) = when (value) {
+    is List -> "List"
+    is Map<*, *> -> "Map"
+    is Set -> "Set"
+    else -> value.javaClass.simpleName
+}
+
+internal fun renderValueForRowTable(value: Any?, forHtml: Boolean): RenderedContent = when (value) {
+    is AnyFrame -> "DataFrame [${value.nrow} x ${value.ncol}]".let {
+        val content = if (value.nrow == 1) it + " " + value[0].toString() else it
+        RenderedContent.textWithLength(content, "DataFrame".length)
+    }
+
+    is AnyRow -> RenderedContent.textWithLength("DataRow $value", "DataRow".length)
+    is Collection<*> -> renderCollectionName(value).let { RenderedContent.textWithLength("$it $value", it.length) }
+    else -> if (forHtml) renderValueForHtml(value, valueToStringLimitForRowAsTable, RendererDecimalFormat.DEFAULT)
+    else renderValueForStdout(value, valueToStringLimitForRowAsTable)
+}
+
+internal fun renderValueForStdout(
+    value: Any?,
+    limit: Int = valueToStringLimitDefault,
+    decimalFormat: RendererDecimalFormat = RendererDecimalFormat.DEFAULT,
+): RenderedContent =
+    renderValueToString(value, decimalFormat).truncate(limit)
+        .let { it.copy(truncatedContent = it.truncatedContent.escapeNewLines()) }
+
+internal fun renderValueToString(value: Any?, decimalFormat: RendererDecimalFormat) =
+    when (value) {
+        is AnyFrame -> "[${value.size}]".let { if (value.nrow == 1) it + " " + value[0].toString() else it }
+        is Double -> value.format(decimalFormat)
+        is Float -> value.format(decimalFormat)
+        is BigDecimal -> value.format(decimalFormat)
+        is List<*> -> if (value.isEmpty()) "[ ]" else value.toString()
+        else -> value.toString()
+    }
+
+internal fun internallyRenderable(value: Any?): Boolean {
+    return when (value) {
+        is AnyFrame, is Double, is List<*>, null, "" -> true
+        else -> false
+    }
+}
+
+internal fun Double.format(decimalFormat: RendererDecimalFormat): String = decimalFormat.format.format(this)
+internal fun Float.format(decimalFormat: RendererDecimalFormat): String = decimalFormat.format.format(this)
+internal fun BigDecimal.format(decimalFormat: RendererDecimalFormat): String = decimalFormat.format.format(this)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/tsv.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/tsv.kt
new file mode 100644
index 000000000..099a91e28
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/tsv.kt
@@ -0,0 +1,108 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.ParserOptions
+import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadDfMethod
+import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadTsvMethod
+import java.io.File
+import java.io.FileInputStream
+import java.io.InputStream
+import java.net.URL
+import java.nio.charset.Charset
+
+public class TSV : SupportedDataFrameFormat {
+    override fun readDataFrame(stream: InputStream, header: List<String>): AnyFrame =
+        DataFrame.readTSV(stream, header = header)
+
+    override fun readDataFrame(file: File, header: List<String>): AnyFrame = DataFrame.readTSV(file, header = header)
+
+    override fun acceptsExtension(ext: String): Boolean = ext == "tsv"
+
+    override fun acceptsSample(sample: SupportedFormatSample): Boolean = true // Extension is enough
+
+    override val testOrder: Int = 30000
+
+    override fun createDefaultReadMethod(pathRepresentation: String?): DefaultReadDfMethod {
+        return DefaultReadTsvMethod(pathRepresentation)
+    }
+}
+
+private val tabChar = '\t'
+
+public fun DataFrame.Companion.readTSV(
+    fileOrUrl: String,
+    header: List<String> = listOf(),
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    duplicate: Boolean = true,
+    charset: Charset = Charsets.UTF_8,
+    parserOptions: ParserOptions? = null,
+): DataFrame<*> =
+    catchHttpResponse(asURL(fileOrUrl)) {
+        readDelim(
+            it, tabChar,
+            header, isCompressed(fileOrUrl),
+            CSVType.TDF, colTypes,
+            skipLines, readLines,
+            duplicate, charset,
+            parserOptions
+        )
+    }
+
+public fun DataFrame.Companion.readTSV(
+    file: File,
+    header: List<String> = listOf(),
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    duplicate: Boolean = true,
+    charset: Charset = Charsets.UTF_8,
+): DataFrame<*> =
+    readDelim(
+        FileInputStream(file), tabChar,
+        header, isCompressed(file),
+        CSVType.TDF, colTypes,
+        skipLines, readLines,
+        duplicate, charset
+    )
+
+public fun DataFrame.Companion.readTSV(
+    url: URL,
+    header: List<String> = listOf(),
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    duplicate: Boolean = true,
+    charset: Charset = Charsets.UTF_8,
+    parserOptions: ParserOptions? = null,
+): DataFrame<*> =
+    readTSV(
+        url.openStream(),
+        header, isCompressed(url),
+        colTypes,
+        skipLines, readLines,
+        duplicate, charset,
+        parserOptions
+    )
+
+public fun DataFrame.Companion.readTSV(
+    stream: InputStream,
+    header: List<String> = listOf(),
+    isCompressed: Boolean = false,
+    colTypes: Map<String, ColType> = mapOf(),
+    skipLines: Int = 0,
+    readLines: Int? = null,
+    duplicate: Boolean = true,
+    charset: Charset = Charsets.UTF_8,
+    parserOptions: ParserOptions? = null,
+): DataFrame<*> =
+    readDelim(
+        stream, tabChar,
+        header, isCompressed,
+        CSVType.TDF, colTypes,
+        skipLines, readLines,
+        duplicate, charset,
+        parserOptions
+    )
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
new file mode 100644
index 000000000..6bf35a1b1
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/CellRenderer.kt
@@ -0,0 +1,90 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+import org.jetbrains.kotlinx.dataframe.io.internallyRenderable
+import org.jetbrains.kotlinx.dataframe.io.renderValueForHtml
+import org.jetbrains.kotlinx.dataframe.io.tooltipLimit
+import org.jetbrains.kotlinx.jupyter.api.MimeTypedResult
+import org.jetbrains.kotlinx.jupyter.api.Notebook
+import org.jetbrains.kotlinx.jupyter.api.Renderable
+import org.jetbrains.kotlinx.jupyter.api.libraries.ExecutionHost
+
+public data class RenderedContent(
+    val truncatedContent: String,
+    val textLength: Int,
+    val fullContent: String?,
+    val isFormatted: Boolean
+) {
+    public companion object {
+
+        public fun media(html: String): RenderedContent = RenderedContent(html, 0, null, false)
+
+        public fun textWithLength(str: String, len: Int): RenderedContent = RenderedContent(str, len, null, false)
+
+        public fun text(str: String): RenderedContent = RenderedContent(str, str.length, null, false)
+
+        public fun truncatedText(str: String, fullText: String): RenderedContent = RenderedContent(str, str.length, fullText, false)
+    }
+
+    val isTruncated: Boolean
+        get() = fullContent != null
+
+    public operator fun plus(other: RenderedContent): RenderedContent = RenderedContent(truncatedContent + other.truncatedContent, textLength + other.textLength, fullContent?.plus(other.fullContent) ?: other.fullContent, isFormatted || other.isFormatted)
+}
+
+public interface CellRenderer {
+    /**
+     * Returns [value] rendered to HTML text, or null if such rendering is impossible
+     */
+    public fun content(value: Any?, configuration: DisplayConfiguration): RenderedContent
+
+    /**
+     * Returns cell tooltip for this [value]
+     */
+    public fun tooltip(value: Any?, configuration: DisplayConfiguration): String
+}
+
+public abstract class ChainedCellRenderer(
+    private val parent: CellRenderer,
+) : CellRenderer {
+    public abstract fun maybeContent(value: Any?, configuration: DisplayConfiguration): RenderedContent?
+    public abstract fun maybeTooltip(value: Any?, configuration: DisplayConfiguration): String?
+
+    public override fun content(value: Any?, configuration: DisplayConfiguration): RenderedContent {
+        return maybeContent(value, configuration) ?: parent.content(value, configuration)
+    }
+
+    public override fun tooltip(value: Any?, configuration: DisplayConfiguration): String {
+        return maybeTooltip(value, configuration) ?: parent.tooltip(value, configuration)
+    }
+}
+
+public object DefaultCellRenderer : CellRenderer {
+    public override fun content(value: Any?, configuration: DisplayConfiguration): RenderedContent {
+        return renderValueForHtml(value, configuration.cellContentLimit, configuration.decimalFormat)
+    }
+
+    public override fun tooltip(value: Any?, configuration: DisplayConfiguration): String {
+        return renderValueForHtml(value, tooltipLimit, configuration.decimalFormat).truncatedContent
+    }
+}
+
+internal class JupyterCellRenderer(
+    private val notebook: Notebook,
+    private val host: ExecutionHost,
+) : ChainedCellRenderer(DefaultCellRenderer) {
+    override fun maybeContent(value: Any?, configuration: DisplayConfiguration): RenderedContent? {
+        val renderersProcessor = notebook.renderersProcessor
+        if (internallyRenderable(value)) return null
+        val renderedVal = renderersProcessor.renderValue(host, value)
+        val finalVal = if (renderedVal is Renderable) renderedVal.render(notebook) else renderedVal
+        if (finalVal is MimeTypedResult && "text/html" in finalVal) return RenderedContent.media(
+            finalVal["text/html"] ?: ""
+        )
+        return renderValueForHtml(finalVal, configuration.cellContentLimit, configuration.decimalFormat)
+    }
+
+    override fun maybeTooltip(value: Any?, configuration: DisplayConfiguration): String? {
+        return null
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/Integration.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/Integration.kt
new file mode 100644
index 000000000..c475bdbc3
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/Integration.kt
@@ -0,0 +1,267 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.dataframe.impl.codeGen.CodeGenerator
+import org.jetbrains.dataframe.impl.codeGen.ReplCodeGenerator
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.Convert
+import org.jetbrains.kotlinx.dataframe.api.FormattedFrame
+import org.jetbrains.kotlinx.dataframe.api.Gather
+import org.jetbrains.kotlinx.dataframe.api.GroupBy
+import org.jetbrains.kotlinx.dataframe.api.Merge
+import org.jetbrains.kotlinx.dataframe.api.Pivot
+import org.jetbrains.kotlinx.dataframe.api.PivotGroupBy
+import org.jetbrains.kotlinx.dataframe.api.ReducedGroupBy
+import org.jetbrains.kotlinx.dataframe.api.ReducedPivot
+import org.jetbrains.kotlinx.dataframe.api.ReducedPivotGroupBy
+import org.jetbrains.kotlinx.dataframe.api.Split
+import org.jetbrains.kotlinx.dataframe.api.SplitWithTransform
+import org.jetbrains.kotlinx.dataframe.api.Update
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.asDataFrame
+import org.jetbrains.kotlinx.dataframe.api.columnsCount
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.frames
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.api.values
+import org.jetbrains.kotlinx.dataframe.codeGen.CodeWithConverter
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.dataTypes.IFRAME
+import org.jetbrains.kotlinx.dataframe.dataTypes.IMG
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.CodeGenerationReadResult
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.urlCodeGenReader
+import org.jetbrains.kotlinx.dataframe.impl.createStarProjectedType
+import org.jetbrains.kotlinx.dataframe.impl.renderType
+import org.jetbrains.kotlinx.dataframe.io.SupportedCodeGenerationFormat
+import org.jetbrains.kotlinx.dataframe.io.supportedFormats
+import org.jetbrains.kotlinx.jupyter.api.HTML
+import org.jetbrains.kotlinx.jupyter.api.HtmlData
+import org.jetbrains.kotlinx.jupyter.api.JupyterClientType
+import org.jetbrains.kotlinx.jupyter.api.KotlinKernelHost
+import org.jetbrains.kotlinx.jupyter.api.Notebook
+import org.jetbrains.kotlinx.jupyter.api.VariableName
+import org.jetbrains.kotlinx.jupyter.api.declare
+import org.jetbrains.kotlinx.jupyter.api.libraries.ColorScheme
+import org.jetbrains.kotlinx.jupyter.api.libraries.JupyterIntegration
+import org.jetbrains.kotlinx.jupyter.api.libraries.resources
+import org.jetbrains.kotlinx.jupyter.api.renderHtmlAsIFrameIfNeeded
+import kotlin.reflect.KClass
+import kotlin.reflect.KProperty
+import kotlin.reflect.full.isSubtypeOf
+
+/** Users will get an error if their Kotlin Jupyter kernel is older than this version. */
+private const val MIN_KERNEL_VERSION = "0.11.0.198"
+
+internal val newDataSchemas = mutableListOf<KClass<*>>()
+
+internal class Integration(
+    private val notebook: Notebook,
+    private val options: MutableMap<String, String?>,
+) : JupyterIntegration() {
+
+    val version = options["v"]
+
+    override fun Builder.onLoaded() {
+        if (version != null) {
+            dependencies(
+                "org.jetbrains.kotlinx:dataframe-excel:$version",
+                "org.jetbrains.kotlinx:dataframe-arrow:$version",
+                "org.jetbrains.kotlinx:dataframe-openapi:$version",
+            )
+        }
+
+        try {
+            setMinimalKernelVersion(MIN_KERNEL_VERSION)
+        } catch (_: NoSuchMethodError) { // will be thrown on version < 0.11.0.198
+            throw IllegalStateException(
+                getKernelUpdateMessage(notebook.kernelVersion, MIN_KERNEL_VERSION, notebook.jupyterClientType)
+            )
+        }
+        val codeGen = ReplCodeGenerator.create()
+        val config = JupyterConfiguration()
+
+        if (notebook.jupyterClientType == JupyterClientType.KOTLIN_NOTEBOOK) {
+            config.display.isolatedOutputs = true
+        }
+
+        onLoaded {
+            declare("dataFrameConfig" to config)
+        }
+
+        resources {
+            if (!config.display.isolatedOutputs) {
+                js("DataFrame") {
+                    if (config.display.localTesting) {
+                        classPath("init.js")
+                    } else {
+                        // Update this commit when new version of init.js is pushed
+                        val initJsSha = "3db46ccccaa1291c0627307d64133317f545e6ae"
+                        url("https://cdn.jsdelivr.net/gh/Kotlin/dataframe@$initJsSha/core/src/main/resources/init.js")
+                    }
+                }
+
+                css("DataFrameTable") { classPath("table.css") }
+            }
+        }
+
+        with(JupyterHtmlRenderer(config.display, this)) {
+            render<HtmlData> { notebook.renderHtmlAsIFrameIfNeeded(it) }
+            render<AnyRow>(
+                { it.toDataFrame() },
+                { "DataRow: index = ${it.index()}, columnsCount = ${it.columnsCount()}" },
+            )
+            render<ColumnGroup<*>>(
+                { it.asDataFrame() },
+                { """ColumnGroup: name = "${it.name}", rowsCount = ${it.rowsCount()}, columnsCount = ${it.columnsCount()}""" },
+            )
+            render<AnyCol>(
+                { dataFrameOf(it) },
+                { """DataColumn: name = "${it.name}", type = ${renderType(it.type())}, size = ${it.size()}""" },
+            )
+            render<AnyFrame>(
+                { it },
+                { "DataFrame: rowsCount = ${it.rowsCount()}, columnsCount = ${it.columnsCount()}" },
+            )
+            render<FormattedFrame<*>>(
+                { it.df },
+                { "DataFrame: rowsCount = ${it.df.rowsCount()}, columnsCount = ${it.df.columnsCount()}" },
+                modifyConfig = { getDisplayConfiguration(it) },
+            )
+            render<GroupBy<*, *>>({ it.toDataFrame() }, { "GroupBy" })
+            render<ReducedGroupBy<*, *>>({ it.into(it.groupBy.groups.name()) }, { "ReducedGroupBy" })
+            render<Pivot<*>>({ it.frames().toDataFrame() }, { "Pivot" })
+            render<ReducedPivot<*>>({ it.values().toDataFrame() }, { "ReducedPivot" })
+            render<PivotGroupBy<*>>({ it.frames() }, { "PivotGroupBy" })
+            render<ReducedPivotGroupBy<*>>({ it.values() }, { "ReducedPivotGroupBy" })
+            render<SplitWithTransform<*, *, *>>({ it.into() }, { "Split" })
+            render<Split<*, *>>({ it.toDataFrame() }, { "Split" })
+            render<Merge<*, *, *>>({ it.into("merged") }, { "Merge" })
+            render<Gather<*, *, *, *>>({ it.into("key", "value") }, { "Gather" })
+            render<IMG> { HTML(it.toString()) }
+            render<IFRAME> { HTML(it.toString()) }
+            render<Update<*, *>>({ it.df }, { "Update" })
+            render<Convert<*, *>>({ it.df }, { "Convert" })
+        }
+
+        import("org.jetbrains.kotlinx.dataframe.api.*")
+        import("org.jetbrains.kotlinx.dataframe.*")
+        import("org.jetbrains.kotlinx.dataframe.annotations.*")
+        import("org.jetbrains.kotlinx.dataframe.io.*")
+        import("org.jetbrains.kotlinx.dataframe.columns.*")
+        import("org.jetbrains.kotlinx.dataframe.jupyter.ImportDataSchema")
+        import("org.jetbrains.kotlinx.dataframe.jupyter.importDataSchema")
+        import("java.net.URL")
+        import("java.io.File")
+        import("kotlinx.datetime.Instant")
+        import("kotlinx.datetime.LocalDateTime")
+        import("kotlinx.datetime.LocalDate")
+        import("org.jetbrains.kotlinx.dataframe.dataTypes.*")
+        import("org.jetbrains.kotlinx.dataframe.impl.codeGen.urlCodeGenReader")
+
+        fun KotlinKernelHost.execute(codeWithConverter: CodeWithConverter, argument: String): VariableName? {
+            val code = codeWithConverter.with(argument)
+            return if (code.isNotBlank()) {
+                val result = execute(code)
+                if (codeWithConverter.hasConverter) {
+                    result.name
+                } else null
+            } else null
+        }
+
+        fun KotlinKernelHost.execute(codeWithConverter: CodeWithConverter, property: KProperty<*>): VariableName? {
+            val variableName = property.name + if (property.returnType.isMarkedNullable) "!!" else ""
+            return execute(codeWithConverter, variableName)
+        }
+
+        updateVariable<ImportDataSchema> { importDataSchema, property ->
+            val formats = supportedFormats.filterIsInstance<SupportedCodeGenerationFormat>()
+            val name = property.name + "DataSchema"
+            when (val codeGenResult = CodeGenerator.urlCodeGenReader(importDataSchema.url, name, formats, true)) {
+                is CodeGenerationReadResult.Success -> {
+                    val readDfMethod = codeGenResult.getReadDfMethod(importDataSchema.url.toExternalForm())
+                    val code = readDfMethod.additionalImports.joinToString("\n") +
+                        "\n" +
+                        codeGenResult.code
+
+                    execute(code)
+                    execute("""DISPLAY("Data schema successfully imported as ${property.name}: $name")""")
+
+                    name
+                }
+
+                is CodeGenerationReadResult.Error -> {
+                    execute("""DISPLAY("Failed to read data schema from ${importDataSchema.url}: ${codeGenResult.reason}")""")
+                    null
+                }
+            }
+        }
+
+        updateVariable<AnyFrame> { df, property ->
+            execute(codeGen.process(df, property), property)
+        }
+
+        updateVariable<AnyRow> { row, property ->
+            execute(codeGen.process(row, property), property)
+        }
+
+        updateVariable<ColumnGroup<*>> { col, property ->
+            execute(codeGen.process(col.asDataFrame(), property), property)
+        }
+
+        updateVariable<AnyCol> { col, property ->
+            if (col.isColumnGroup()) {
+                val codeWithConverter = codeGen.process(col.asColumnGroup().asDataFrame(), property).let { c ->
+                    CodeWithConverter(c.declarations) { c.converter("$it.asColumnGroup()") }
+                }
+                execute(codeWithConverter, property)
+            } else null
+        }
+
+        fun KotlinKernelHost.addDataSchemas(classes: List<KClass<*>>) {
+            val code = classes.joinToString("\n") {
+                codeGen.process(it)
+            }.trim()
+
+            if (code.isNotEmpty()) {
+                execute(code)
+            }
+        }
+
+        onClassAnnotation<DataSchema> { addDataSchemas(it) }
+
+        beforeCellExecution {
+            if (newDataSchemas.isNotEmpty()) {
+                addDataSchemas(newDataSchemas)
+                newDataSchemas.clear()
+            }
+        }
+
+        val internalTypes = listOf(
+            ColumnReference::class,
+        ).map { it.createStarProjectedType(true) }
+
+        markVariableInternal { property ->
+            // TODO: add more conditions to include all generated properties and other internal stuff
+            //  that should not be shown to user in Jupyter variables view
+            internalTypes.any { property.returnType.isSubtypeOf(it) }
+        }
+
+        onColorSchemeChange {
+            config.display.useDarkColorScheme = (it == ColorScheme.DARK)
+        }
+    }
+}
+
+public fun KotlinKernelHost.useSchemas(schemaClasses: Iterable<KClass<*>>) {
+    newDataSchemas.addAll(schemaClasses)
+}
+
+public fun KotlinKernelHost.useSchemas(vararg schemaClasses: KClass<*>): Unit = useSchemas(schemaClasses.asIterable())
+
+public inline fun <reified T> KotlinKernelHost.useSchema(): Unit = useSchemas(T::class)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterConfiguration.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterConfiguration.kt
new file mode 100644
index 000000000..4376bec73
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterConfiguration.kt
@@ -0,0 +1,10 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+
+public class JupyterConfiguration {
+    public val display: DisplayConfiguration = DisplayConfiguration()
+
+    /** DSL accessor. */
+    public operator fun invoke(block: JupyterConfiguration.() -> Unit): JupyterConfiguration = apply(block)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterHtmlRenderer.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterHtmlRenderer.kt
new file mode 100644
index 000000000..f959451e7
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterHtmlRenderer.kt
@@ -0,0 +1,34 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+import org.jetbrains.kotlinx.dataframe.io.initHtml
+import org.jetbrains.kotlinx.dataframe.io.toHTML
+import org.jetbrains.kotlinx.jupyter.api.libraries.JupyterIntegration
+import org.jetbrains.kotlinx.jupyter.api.renderHtmlAsIFrameIfNeeded
+
+internal class JupyterHtmlRenderer(
+    val display: DisplayConfiguration,
+    val builder: JupyterIntegration.Builder,
+)
+
+internal inline fun <reified T : Any> JupyterHtmlRenderer.render(
+    crossinline getDf: (T) -> DataFrame<*>,
+    noinline getFooter: (T) -> String,
+    crossinline modifyConfig: T.(DisplayConfiguration) -> DisplayConfiguration = { it }
+) = builder.renderWithHost<T> { host, value ->
+    val contextRenderer = JupyterCellRenderer(this.notebook, host)
+    val reifiedDisplayConfiguration = value.modifyConfig(display)
+    val footer = getFooter(value)
+    val html = getDf(value).toHTML(
+        reifiedDisplayConfiguration,
+        extraHtml = initHtml(
+            includeJs = reifiedDisplayConfiguration.isolatedOutputs,
+            includeCss = true,
+            useDarkColorScheme = reifiedDisplayConfiguration.useDarkColorScheme
+        ),
+        contextRenderer
+    ) { footer }
+
+    notebook.renderHtmlAsIFrameIfNeeded(html)
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/importDataSchema.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/importDataSchema.kt
new file mode 100644
index 000000000..95dc3b873
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/importDataSchema.kt
@@ -0,0 +1,46 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.intellij.lang.annotations.Language
+import java.io.File
+import java.net.URL
+
+public class ImportDataSchema(public val url: URL) {
+    public constructor(path: String) : this(URL(path))
+    public constructor(file: File) : this(file.toURI().toURL())
+}
+
+public fun importDataSchema(url: URL): ImportDataSchema = ImportDataSchema(url)
+public fun importDataSchema(path: String): ImportDataSchema = ImportDataSchema(path)
+public fun importDataSchema(file: File): ImportDataSchema = ImportDataSchema(file)
+
+@Language("kts")
+internal val importDataSchema = """
+    /** Import the type-only data schema from [url]. */
+    fun importDataSchema(url: URL, name: String) {
+        val formats = listOf(
+            OpenApi(),
+        )
+        val codeGenResult = org.jetbrains.dataframe.impl.codeGen.CodeGenerator.urlCodeGenReader(url, formats)
+        when (codeGenResult) {
+            is org.jetbrains.kotlinx.dataframe.impl.codeGen.CodeGenerationReadResult.Success -> {
+                val readDfMethod = codeGenResult.getReadDfMethod(url.toExternalForm())
+                val code = readDfMethod.additionalImports.joinToString("\n") + 
+                    "\n" + 
+                    codeGenResult.code.converter(name)
+
+                EXECUTE(code)
+                DISPLAY("Data schema successfully imported as ${'$'}name")
+            }
+
+            is org.jetbrains.kotlinx.dataframe.impl.codeGen.CodeGenerationReadResult.Error -> {
+                DISPLAY("Failed to read data schema from ${'$'}url: ${'$'}{codeGenResult.reason}")
+            }
+        }
+    }
+
+    /** Import the type-only data schema from [path]. */
+    fun importDataSchema(path: String, name: String): Unit = importDataSchema(URL(path), name)
+
+    /** Import the type-only data schema from [file]. */
+    fun importDataSchema(file: File, name: String): Unit = importDataSchema(file.toURI().toURL(), name)
+""".trimIndent()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/kernelUpdateMessages.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/kernelUpdateMessages.kt
new file mode 100644
index 000000000..1950168a2
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/kernelUpdateMessages.kt
@@ -0,0 +1,26 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.kotlinx.jupyter.api.JupyterClientType
+import org.jetbrains.kotlinx.jupyter.api.JupyterClientType.DATALORE
+import org.jetbrains.kotlinx.jupyter.api.JupyterClientType.KOTLIN_NOTEBOOK
+import org.jetbrains.kotlinx.jupyter.api.KotlinKernelVersion
+
+private const val UPDATING_DATALORE_URL = "https://github.com/Kotlin/kotlin-jupyter/tree/master#datalore"
+private const val UPDATING_KOTLIN_NOTEBOOK_URL = "https://github.com/Kotlin/kotlin-jupyter#kotlin-notebook"
+private const val UPDATING = "https://github.com/Kotlin/kotlin-jupyter/tree/master#updating"
+
+internal fun getKernelUpdateMessage(
+    kernelVersion: KotlinKernelVersion,
+    minKernelVersion: String,
+    clientType: JupyterClientType,
+): String = buildString {
+    append("Your Kotlin Jupyter kernel version appears to be out of date (version $kernelVersion). ")
+    appendLine("Please update it to version $minKernelVersion or newer to be able to use DataFrame.")
+    append("Follow the instructions at: ")
+
+    when (clientType) {
+        DATALORE -> appendLine(UPDATING_DATALORE_URL)
+        KOTLIN_NOTEBOOK -> appendLine(UPDATING_KOTLIN_NOTEBOOK_URL)
+        else -> appendLine(UPDATING)
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/cumsum.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/cumsum.kt
new file mode 100644
index 000000000..ddf44b6da
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/cumsum.kt
@@ -0,0 +1,139 @@
+package org.jetbrains.kotlinx.dataframe.math
+
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.api.isNA
+import org.jetbrains.kotlinx.dataframe.api.map
+import java.math.BigDecimal
+
+internal val defaultCumSumSkipNA: Boolean = true
+
+@JvmName("doubleCumsum")
+internal fun DataColumn<Double>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<Double> {
+    var sum = .0
+    return map {
+        if (skipNA && it.isNaN()) it
+        else {
+            sum += it
+            sum
+        }
+    }
+}
+
+@JvmName("cumsumDoubleNullable")
+internal fun DataColumn<Double?>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<Double> {
+    var sum = .0
+    return map {
+        if (skipNA && it.isNA) Double.NaN
+        else {
+            sum += it ?: Double.NaN
+            sum
+        }
+    }
+}
+
+@JvmName("floatCumsum")
+internal fun DataColumn<Float>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<Float> {
+    var sum = .0f
+    return map {
+        if (skipNA && it.isNaN()) it
+        else {
+            sum += it
+            sum
+        }
+    }
+}
+
+internal fun DataColumn<Float?>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<Float> {
+    var sum = .0f
+    return map {
+        if (skipNA && it.isNA) Float.NaN
+        else {
+            sum += it ?: Float.NaN
+            sum
+        }
+    }
+}
+
+@JvmName("intCumsum")
+internal fun DataColumn<Int>.cumSum(): DataColumn<Int> {
+    var sum = 0
+    return map {
+        sum += it
+        sum
+    }
+}
+
+@JvmName("intCumsum")
+internal fun DataColumn<Int?>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<Int?> {
+    var sum = 0
+    var fillNull = false
+    return map {
+        when {
+            it == null -> {
+                if (!skipNA) fillNull = true
+                null
+            }
+            fillNull -> null
+            else -> {
+                sum += it
+                sum
+            }
+        }
+    }
+}
+
+@JvmName("longCumsum")
+internal fun DataColumn<Long>.cumSum(): DataColumn<Long> {
+    var sum = 0L
+    return map {
+        sum += it
+        sum
+    }
+}
+
+@JvmName("cumsumLongNullable")
+internal fun DataColumn<Long?>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<Long?> {
+    var sum = 0L
+    var fillNull = false
+    return map {
+        when {
+            it == null -> {
+                if (!skipNA) fillNull = true
+                null
+            }
+            fillNull -> null
+            else -> {
+                sum += it
+                sum
+            }
+        }
+    }
+}
+
+@JvmName("bigDecimalCumsum")
+internal fun DataColumn<BigDecimal>.cumSum(): DataColumn<BigDecimal> {
+    var sum = BigDecimal.ZERO
+    return map {
+        sum += it
+        sum
+    }
+}
+
+@JvmName("cumsumBigDecimalNullable")
+internal fun DataColumn<BigDecimal?>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataColumn<BigDecimal?> {
+    var sum = BigDecimal.ZERO
+    var fillNull = false
+    return map {
+        when {
+            it == null -> {
+                if (!skipNA) fillNull = true
+                null
+            }
+            fillNull -> null
+            else -> {
+                sum += it
+                sum
+            }
+        }
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/mean.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/mean.kt
new file mode 100644
index 000000000..272efd857
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/mean.kt
@@ -0,0 +1,111 @@
+package org.jetbrains.kotlinx.dataframe.math
+
+import org.jetbrains.kotlinx.dataframe.api.skipNA_default
+import java.math.BigDecimal
+import kotlin.reflect.KType
+import kotlin.reflect.full.withNullability
+
+@PublishedApi
+internal fun <T : Number> Iterable<T>.mean(type: KType, skipNA: Boolean = skipNA_default): Double = asSequence().mean(type, skipNA)
+
+internal fun <T : Number> Sequence<T>.mean(type: KType, skipNA: Boolean = skipNA_default): Double {
+    if (type.isMarkedNullable) {
+        return filterNotNull().mean(type.withNullability(false), skipNA)
+    }
+    return when (type.classifier) {
+        Double::class -> (this as Sequence<Double>).mean(skipNA)
+        Float::class -> (this as Sequence<Float>).mean(skipNA)
+        Int::class -> (this as Sequence<Int>).map { it.toDouble() }.mean(false) // for integer values NA is not possible
+        Short::class -> (this as Sequence<Short>).map { it.toDouble() }.mean(false)
+        Byte::class -> (this as Sequence<Byte>).map { it.toDouble() }.mean(false)
+        Long::class -> (this as Sequence<Long>).map { it.toDouble() }.mean(false)
+        BigDecimal::class -> (this as Sequence<BigDecimal>).map { it.toDouble() }.mean(skipNA)
+        Number::class -> (this as Sequence<Number>).map { it.toDouble() }.mean(skipNA)
+        else -> throw IllegalArgumentException("Unable to compute mean for type $type")
+    }
+}
+
+public fun Sequence<Double>.mean(skipNA: Boolean = skipNA_default): Double {
+    var count = 0
+    var sum: Double = 0.toDouble()
+    for (element in this) {
+        if (element.isNaN()) {
+            if (skipNA) continue
+            else return Double.NaN
+        }
+        sum += element
+        count++
+    }
+    return if (count > 0) sum / count else Double.NaN
+}
+
+@JvmName("meanFloat")
+public fun Sequence<Float>.mean(skipNA: Boolean = skipNA_default): Double {
+    var count = 0
+    var sum: Double = 0.toDouble()
+    for (element in this) {
+        if (element.isNaN()) {
+            if (skipNA) continue
+            else return Double.NaN
+        }
+        sum += element
+        count++
+    }
+    return if (count > 0) sum / count else Double.NaN
+}
+
+@JvmName("doubleMean")
+public fun Iterable<Double>.mean(skipNA: Boolean = skipNA_default): Double = asSequence().mean(skipNA)
+
+@JvmName("floatMean")
+public fun Iterable<Float>.mean(skipNA: Boolean = skipNA_default): Double = asSequence().mean(skipNA)
+
+@JvmName("intMean")
+public fun Iterable<Int>.mean(): Double =
+    if (this is Collection) {
+        if (size > 0) sumOf { it.toDouble() } / size else Double.NaN
+    } else {
+        var count = 0
+        val sum = sumOf { count++; it.toDouble() }
+        if (count > 0) sum / count else Double.NaN
+    }
+
+@JvmName("shortMean")
+public fun Iterable<Short>.mean(): Double =
+    if (this is Collection) {
+        if (size > 0) sumOf { it.toDouble() } / size else Double.NaN
+    } else {
+        var count = 0
+        val sum = sumOf { count++; it.toDouble() }
+        if (count > 0) sum / count else Double.NaN
+    }
+
+@JvmName("byteMean")
+public fun Iterable<Byte>.mean(): Double =
+    if (this is Collection) {
+        if (size > 0) sumOf { it.toDouble() } / size else Double.NaN
+    } else {
+        var count = 0
+        val sum = sumOf { count++; it.toDouble() }
+        if (count > 0) sum / count else Double.NaN
+    }
+
+@JvmName("longMean")
+public fun Iterable<Long>.mean(): Double =
+    if (this is Collection) {
+        if (size > 0) sumOf { it.toDouble() } / size else Double.NaN
+    } else {
+        var count = 0
+        val sum = sumOf { count++; it.toDouble() }
+        if (count > 0) sum / count else Double.NaN
+    }
+
+@JvmName("bigDecimalMean")
+public fun Iterable<BigDecimal>.mean(): Double =
+    if (this is Collection) {
+        if (size > 0) sum().toDouble() / size else Double.NaN
+    } else {
+        var count = 0
+        val sum = sumOf { count++; it.toDouble() }
+        if (count > 0) sum / count else Double.NaN
+    }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/median.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/median.kt
new file mode 100644
index 000000000..b9debca56
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/median.kt
@@ -0,0 +1,68 @@
+package org.jetbrains.kotlinx.dataframe.math
+
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import java.math.BigDecimal
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+public inline fun <reified T : Comparable<T>> Iterable<T>.medianOrNull(): T? = median(typeOf<T>())
+public inline fun <reified T : Comparable<T>> Iterable<T>.median(): T = medianOrNull()!!
+
+@PublishedApi
+internal inline fun <reified T : Comparable<T>> Iterable<T?>.median(type: KType): T? {
+    val list = if (type.isMarkedNullable) filterNotNull() else (this as Iterable<T>).asList()
+    val size = list.size
+    if (size == 0) return null
+    val index = size / 2
+    if (index == 0 || size % 2 == 1) return list.quickSelect(index)
+    return when (type.classifier) {
+        Double::class -> ((list.quickSelect(index - 1) as Double + list.quickSelect(index) as Double) / 2.0) as T
+        Int::class -> ((list.quickSelect(index - 1) as Int + list.quickSelect(index) as Int) / 2) as T
+        Long::class -> ((list.quickSelect(index - 1) as Long + list.quickSelect(index) as Long) / 2L) as T
+        Byte::class -> ((list.quickSelect(index - 1) as Byte + list.quickSelect(index) as Byte) / 2).toByte() as T
+        BigDecimal::class -> ((list.quickSelect(index - 1) as BigDecimal + list.quickSelect(index) as BigDecimal) / BigDecimal(2)) as T
+        else -> list.quickSelect(index - 1)
+    }
+}
+
+@PublishedApi
+internal fun <T : Comparable<T>> List<T>.quickSelect(k: Int): T {
+    if (k < 0 || k >= size) throw IndexOutOfBoundsException("k = $k, size = $size")
+
+    var list = this
+    var temp = mutableListOf<T>()
+    var less = mutableListOf<T>()
+    var k = k
+    var greater = mutableListOf<T>()
+    while (list.size > 1) {
+        var equal = 0
+        val x = list.random()
+        greater.clear()
+        less.clear()
+        for (v in list) {
+            val comp = v.compareTo(x)
+            when {
+                comp < 0 -> less.add(v)
+                comp > 0 -> greater.add(v)
+                else -> equal++
+            }
+        }
+        when {
+            k < less.size -> {
+                list = less
+                less = temp
+                temp = list
+            }
+            k < less.size + equal -> {
+                return x
+            }
+            else -> {
+                list = greater
+                greater = temp
+                temp = list
+                k -= less.size + equal
+            }
+        }
+    }
+    return list[0]
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/minmax.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/minmax.kt
new file mode 100644
index 000000000..26aa9d2b2
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/minmax.kt
@@ -0,0 +1,23 @@
+package org.jetbrains.kotlinx.dataframe.math
+
+import java.math.BigDecimal
+import kotlin.reflect.KType
+import kotlin.reflect.jvm.jvmErasure
+
+internal fun <T : Number> Iterable<T>.min(type: KType) = when (type.jvmErasure) {
+    Double::class -> (this as Iterable<Double>).minOrNull()
+    Float::class -> (this as Iterable<Float>).minOrNull()
+    Int::class, Short::class, Byte::class -> (this as Iterable<Int>).minOrNull()
+    Long::class -> (this as Iterable<Long>).minOrNull()
+    BigDecimal::class -> (this as Iterable<BigDecimal>).minOrNull()
+    else -> throw IllegalArgumentException()
+}
+
+internal fun <T : Number> Iterable<T>.max(type: KType) = when (type.jvmErasure) {
+    Double::class -> (this as Iterable<Double>).maxOrNull()
+    Float::class -> (this as Iterable<Float>).maxOrNull()
+    Int::class, Short::class, Byte::class -> (this as Iterable<Int>).maxOrNull()
+    Long::class -> (this as Iterable<Long>).maxOrNull()
+    BigDecimal::class -> (this as Iterable<BigDecimal>).maxOrNull()
+    else -> throw IllegalArgumentException()
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/std.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/std.kt
new file mode 100644
index 000000000..a4fbcdf8e
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/std.kt
@@ -0,0 +1,42 @@
+package org.jetbrains.kotlinx.dataframe.math
+
+import org.jetbrains.kotlinx.dataframe.api.ddof_default
+import org.jetbrains.kotlinx.dataframe.api.skipNA_default
+import java.math.BigDecimal
+import kotlin.reflect.KType
+import kotlin.reflect.full.withNullability
+
+@PublishedApi
+internal fun <T : Number> Iterable<T?>.std(type: KType, skipNA: Boolean = skipNA_default, ddof: Int = ddof_default): Double {
+    if (type.isMarkedNullable) {
+        if (skipNA) {
+            return filterNotNull().std(type.withNullability(false), true, ddof)
+        } else {
+            if (contains(null)) return Double.NaN
+            return std(type.withNullability(false), skipNA, ddof)
+        }
+    }
+    return when (type.classifier) {
+        Double::class -> (this as Iterable<Double>).std(skipNA, ddof)
+        Float::class -> (this as Iterable<Float>).std(skipNA, ddof)
+        Int::class, Short::class, Byte::class -> (this as Iterable<Int>).std(ddof)
+        Long::class -> (this as Iterable<Long>).std(ddof)
+        BigDecimal::class -> (this as Iterable<BigDecimal>).std(ddof)
+        else -> throw IllegalArgumentException("Unsupported type ${type.classifier}")
+    }
+}
+
+@JvmName("doubleStd")
+public fun Iterable<Double>.std(skipNA: Boolean = skipNA_default, ddof: Int = ddof_default): Double = varianceAndMean(skipNA)?.std(ddof) ?: Double.NaN
+
+@JvmName("floatStd")
+public fun Iterable<Float>.std(skipNA: Boolean = skipNA_default, ddof: Int = ddof_default): Double = varianceAndMean(skipNA)?.std(ddof) ?: Double.NaN
+
+@JvmName("intStd")
+public fun Iterable<Int>.std(ddof: Int = ddof_default): Double = varianceAndMean().std(ddof)
+
+@JvmName("longStd")
+public fun Iterable<Long>.std(ddof: Int = ddof_default): Double = varianceAndMean().std(ddof)
+
+@JvmName("bigDecimalStd")
+public fun Iterable<BigDecimal>.std(ddof: Int = ddof_default): Double = varianceAndMean().std(ddof)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/stdMean.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/stdMean.kt
new file mode 100644
index 000000000..d264023c5
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/stdMean.kt
@@ -0,0 +1,110 @@
+@file:Suppress("DuplicatedCode")
+
+package org.jetbrains.kotlinx.dataframe.math
+
+import org.jetbrains.kotlinx.dataframe.api.skipNA_default
+import java.math.BigDecimal
+import kotlin.math.sqrt
+
+public data class BasicStats(val count: Int, val mean: Double, val variance: Double) {
+
+    public fun std(ddof: Int): Double {
+        if (count <= ddof) return Double.NaN
+        return sqrt(variance / (count - ddof))
+    }
+}
+
+@JvmName("doubleVarianceAndMean")
+public fun Iterable<Double>.varianceAndMean(skipNA: Boolean = skipNA_default): BasicStats? {
+    var count = 0
+    var sum = .0
+    for (element in this) {
+        if (element.isNaN()) {
+            if (skipNA) continue
+            else return null
+        }
+        sum += element
+        count++
+    }
+    val mean = sum / count
+    var variance = .0
+    for (element in this) {
+        if (element.isNaN()) continue
+        val diff = element - mean
+        variance += diff * diff
+    }
+    return BasicStats(count, mean, variance)
+}
+
+@JvmName("floatVarianceAndMean")
+public fun Iterable<Float>.varianceAndMean(skipNA: Boolean = skipNA_default): BasicStats? {
+    var count = 0
+    var sum = .0
+    for (element in this) {
+        if (element.isNaN()) {
+            if (skipNA) continue
+            else return null
+        }
+        sum += element
+        count++
+    }
+    val mean = sum / count
+    var variance = .0
+    for (element in this) {
+        if (element.isNaN()) continue
+        val diff = element - mean
+        variance += diff * diff
+    }
+    return BasicStats(count, mean, variance)
+}
+
+@JvmName("intVarianceAndMean")
+public fun Iterable<Int>.varianceAndMean(): BasicStats {
+    var count = 0
+    var sum = .0
+    for (element in this) {
+        sum += element
+        count++
+    }
+    val mean = sum / count
+    var variance = .0
+    for (element in this) {
+        val diff = element - mean
+        variance += diff * diff
+    }
+    return BasicStats(count, mean, variance)
+}
+
+@JvmName("longVarianceAndMean")
+public fun Iterable<Long>.varianceAndMean(): BasicStats {
+    var count = 0
+    var sum = .0
+    for (element in this) {
+        sum += element
+        count++
+    }
+    val mean = sum / count
+    var variance = .0
+    for (element in this) {
+        val diff = element - mean
+        variance += diff * diff
+    }
+    return BasicStats(count, mean, variance)
+}
+
+@JvmName("bigDecimalVarianceAndMean")
+public fun Iterable<BigDecimal>.varianceAndMean(): BasicStats {
+    var count = 0
+    var sum = BigDecimal.ZERO
+    for (element in this) {
+        sum += element
+        count++
+    }
+    val mean = sum.div(count.toBigDecimal())
+    var variance = BigDecimal.ZERO
+    for (element in this) {
+        val diff = element - mean
+        variance += diff * diff
+    }
+    return BasicStats(count, mean.toDouble(), variance.toDouble())
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/sum.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/sum.kt
new file mode 100644
index 000000000..204c2efe1
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/sum.kt
@@ -0,0 +1,58 @@
+package org.jetbrains.kotlinx.dataframe.math
+
+import java.math.BigDecimal
+import kotlin.reflect.KType
+
+@PublishedApi
+internal fun <T, R : Number> Iterable<T>.sumOf(type: KType, selector: (T) -> R?): R {
+    if (type.isMarkedNullable) {
+        val seq = asSequence().mapNotNull(selector).asIterable()
+        return seq.sum(type)
+    }
+    return when (type.classifier) {
+        Double::class -> sumOf(selector as ((T) -> Double)) as R
+        Int::class -> sumOf(selector as ((T) -> Int)) as R
+        Long::class -> sumOf(selector as ((T) -> Long)) as R
+        BigDecimal::class -> sumOf(selector as ((T) -> BigDecimal)) as R
+        else -> TODO()
+    }
+}
+
+@PublishedApi
+internal fun <T : Number> Iterable<T>.sum(type: KType): T = when (type.classifier) {
+    Double::class -> (this as Iterable<Double>).sum() as T
+    Float::class -> (this as Iterable<Float>).sum() as T
+    Int::class, Short::class, Byte::class -> (this as Iterable<Int>).sum() as T
+    Long::class -> (this as Iterable<Long>).sum() as T
+    BigDecimal::class -> (this as Iterable<BigDecimal>).sum() as T
+    else -> throw IllegalArgumentException("Sum is not supported for $type")
+}
+
+@JvmName("sumNullableT")
+@PublishedApi
+internal fun <T : Number> Iterable<T?>.sum(type: KType): T = when (type.classifier) {
+    Double::class -> (this as Iterable<Double?>).asSequence().filterNotNull().sum() as T
+    Float::class -> (this as Iterable<Float?>).asSequence().filterNotNull().sum() as T
+    Int::class, Short::class, Byte::class -> (this as Iterable<Int?>).asSequence().filterNotNull().sum() as T
+    Long::class -> (this as Iterable<Long?>).asSequence().filterNotNull().sum() as T
+    BigDecimal::class -> (this as Iterable<BigDecimal?>).asSequence().filterNotNull().sum() as T
+    else -> TODO()
+}
+
+@PublishedApi
+internal fun Iterable<BigDecimal>.sum(): BigDecimal {
+    var sum: BigDecimal = BigDecimal.ZERO
+    for (element in this) {
+        sum += element
+    }
+    return sum
+}
+
+@PublishedApi
+internal fun Sequence<BigDecimal>.sum(): BigDecimal {
+    var sum: BigDecimal = BigDecimal.ZERO
+    for (element in this) {
+        sum += element
+    }
+    return sum
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/ColumnSchema.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/ColumnSchema.kt
new file mode 100644
index 000000000..5cd7db0cc
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/ColumnSchema.kt
@@ -0,0 +1,95 @@
+package org.jetbrains.kotlinx.dataframe.schema
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import kotlin.reflect.KType
+import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.full.isSupertypeOf
+import kotlin.reflect.typeOf
+
+public abstract class ColumnSchema {
+
+    /** Either [Value] or [Group] or [Frame]. */
+    public abstract val kind: ColumnKind
+
+    /** Whether the column is nullable. Is always `false` for [Group]. */
+    public abstract val nullable: Boolean
+
+    /**
+     * The type of the column.
+     * For [Value] this is the common base type associated with all the values in the column.
+     * For [Group] this is [AnyRow].
+     * For [Frame] this is [AnyFrame].
+     */
+    public abstract val type: KType
+
+    /**
+     * The type associated with the contents of the column.
+     * For [Value] this is irrelevant and thus `null`. Use [type] instead.
+     * For [Group] this is the common base type associated with all the [DataRow]s in the column.
+     * For [Frame] this is the common base type associated with all the [DataFrame]s in the column.
+     */
+    public abstract val contentType: KType?
+
+    public class Value(public override val type: KType) : ColumnSchema() {
+        override val kind: ColumnKind = ColumnKind.Value
+        override val nullable: Boolean = type.isMarkedNullable
+        override val contentType: KType? = null
+
+        public fun compare(other: Value): CompareResult = when {
+            type == other.type -> CompareResult.Equals
+            type.isSubtypeOf(other.type) -> CompareResult.IsDerived
+            type.isSupertypeOf(other.type) -> CompareResult.IsSuper
+            else -> CompareResult.None
+        }
+    }
+
+    public class Group(public val schema: DataFrameSchema, override val contentType: KType?) : ColumnSchema() {
+        override val kind: ColumnKind = ColumnKind.Group
+
+        /** A column group is never null, instead, make the columns inside nullable. */
+        override val nullable: Boolean = false
+        override val type: KType get() = typeOf<AnyRow>()
+
+        public fun compare(other: Group): CompareResult = schema.compare(other.schema)
+    }
+
+    public class Frame(
+        public val schema: DataFrameSchema,
+        override val nullable: Boolean,
+        override val contentType: KType?,
+    ) : ColumnSchema() {
+        public override val kind: ColumnKind = ColumnKind.Frame
+        override val type: KType get() = typeOf<AnyFrame>()
+
+        public fun compare(other: Frame): CompareResult =
+            schema.compare(other.schema).combine(CompareResult.compareNullability(nullable, other.nullable))
+    }
+
+    /** Checks equality just on kind, type, or schema. */
+    override fun equals(other: Any?): Boolean {
+        val otherType = other as? ColumnSchema ?: return false
+        if (otherType.kind != kind) return false
+        if (otherType.nullable != nullable) return false
+        return when (this) {
+            is Value -> type == (otherType as Value).type
+            is Group -> schema == (otherType as Group).schema
+            is Frame -> schema == (otherType as Frame).schema
+            else -> throw NotImplementedError()
+        }
+    }
+
+    public fun compare(other: ColumnSchema): CompareResult {
+        if (kind != other.kind) return CompareResult.None
+        if (this === other) return CompareResult.Equals
+        return when (this) {
+            is Value -> compare(other as Value)
+            is Group -> compare(other as Group)
+            is Frame -> compare(other as Frame)
+            else -> throw NotImplementedError()
+        }
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/CompareResult.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/CompareResult.kt
new file mode 100644
index 000000000..d30e85348
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/CompareResult.kt
@@ -0,0 +1,28 @@
+package org.jetbrains.kotlinx.dataframe.schema
+
+public enum class CompareResult {
+    Equals,
+    IsSuper,
+    IsDerived,
+    None;
+
+    public fun isSuperOrEqual(): Boolean = this == Equals || this == IsSuper
+
+    public fun isEqual(): Boolean = this == Equals
+
+    public fun combine(other: CompareResult): CompareResult =
+        when (this) {
+            Equals -> other
+            None -> None
+            IsDerived -> if (other == Equals || other == IsDerived) this else None
+            IsSuper -> if (other == Equals || other == IsSuper) this else None
+        }
+
+    public companion object {
+        public fun compareNullability(thisIsNullable: Boolean, otherIsNullable: Boolean): CompareResult = when {
+            thisIsNullable == otherIsNullable -> Equals
+            thisIsNullable -> IsSuper
+            else -> IsDerived
+        }
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/DataFrameSchema.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/DataFrameSchema.kt
new file mode 100644
index 000000000..d364f0448
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/DataFrameSchema.kt
@@ -0,0 +1,8 @@
+package org.jetbrains.kotlinx.dataframe.schema
+
+public interface DataFrameSchema {
+
+    public val columns: Map<String, ColumnSchema>
+
+    public fun compare(other: DataFrameSchema): CompareResult
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/test/sampleExtensions.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/test/sampleExtensions.kt
new file mode 100644
index 000000000..847bfa8d8
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/test/sampleExtensions.kt
@@ -0,0 +1,17 @@
+package samples
+
+public fun String.stringExtension() {
+    println("Hello, world!")
+}
+
+public fun List<Any?>.nullableAnyListExtension() {}
+
+public fun List<Any>.anyListExtension() {}
+
+public fun <T> List<T>.genericListExtension() {}
+
+public fun <T> List<T?>.nullableGenericListExtension() {}
+
+public fun <T : Any?> List<T>.boundGenericListExtension() {}
+
+public fun <T : Any?> List<T?>.boundNullableGenericListExtension() {}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/test/usage.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/test/usage.kt
new file mode 100644
index 000000000..3aec47bde
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/test/usage.kt
@@ -0,0 +1,17 @@
+import samples.*
+
+/**
+ * [String.stringExtension]
+ *
+ * [samples.stringExtension]
+ *
+ * @sampl samples.SampleGroup.mySample
+ * @sampl samples.megasamples.MegaSamplesGroup.megaSample
+ * @sampl samples.notindir.NotInDirSamples.sssample
+ * @sampl smaplez.a.b.c.Samplez.sssample
+ * @sampl samples.stringExtension
+ * @sampl String.stringExtension
+ */
+public fun <caret> some() {}
+
+//INFO: <div class='definition'><pre><span style="color:#000080;font-weight:bold;">public</span> <span style="color:#000080;font-weight:bold;">fun</span> <span style="color:#000000;">some</span>()<span style="">: </span><span style="color:#000000;">Unit</span></pre></div><table class='sections'><tr><td valign='top' class='section'><p>Samples:</td><td valign='top'><p><a href="psi_element://samples.SampleGroup.mySample"><code style='font-size:96%;'><span style="color:#000000;">samples</span><span style="">.</span><span style="color:#000000;">SampleGroup</span><span style="">.</span><span style="color:#0000ff;">mySample</span></code></a><pre><code><span style=""><br><span style="">println(</span><span style="color:#008000;font-weight:bold;">"Hello,&#32;world"</span><span style="">)<br></span></span></code></pre><p><a href="psi_element://samples.megasamples.MegaSamplesGroup.megaSample"><code style='font-size:96%;'><span style="color:#000000;">samples</span><span style="">.</span><span style="color:#000000;">megasamples</span><span style="">.</span><span style="color:#000000;">MegaSamplesGroup</span><span style="">.</span><span style="color:#0000ff;">megaSample</span></code></a><pre><code><span style=""><br><span style="">println(</span><span style="color:#008000;font-weight:bold;">"...---..."</span><span style="">)<br></span></span></code></pre><p><a href="psi_element://samples.notindir.NotInDirSamples.sssample"><code style='font-size:96%;'><span style="color:#000000;">samples</span><span style="">.</span><span style="color:#000000;">notindir</span><span style="">.</span><span style="color:#000000;">NotInDirSamples</span><span style="">.</span><span style="color:#0000ff;">sssample</span></code></a><pre><code><span style=""><br><span style="">println(</span><span style="color:#008000;font-weight:bold;">"location&#32;is&#32;samplesTest/"</span><span style="">)<br></span></span></code></pre><p><a href="psi_element://smaplez.a.b.c.Samplez.sssample"><code style='font-size:96%;'><span style="color:#000000;">smaplez</span><span style="">.</span><span style="color:#000000;">a</span><span style="">.</span><span style="color:#000000;">b</span><span style="">.</span><span style="color:#000000;">c</span><span style="">.</span><span style="color:#000000;">Samplez</span><span style="">.</span><span style="color:#4585be;">sssample</span></code></a><pre><code><span style=""><span style="color:#808080;font-style:italic;">//&#32;Unresolved</span></span></code></pre><p><a href="psi_element://samples.stringExtension"><code style='font-size:96%;'><span style="color:#000000;">samples</span><span style="">.</span><span style="color:#0000ff;">stringExtension</span></code></a><pre><code><span style=""></span></code></pre><p><a href="psi_element://String.stringExtension"><code style='font-size:96%;'><span style="color:#000000;">String</span><span style="">.</span><span style="color:#4585be;">stringExtension</span></code></a><pre><code><span style=""><span style="color:#808080;font-style:italic;">//&#32;Unresolved</span></span></code></pre></td></table><div class='bottom'><icon src="/org/jetbrains/kotlin/idea/icons/kotlin_file.svg"/>&nbsp;usage.kt<br/></div>

From 265c5877b44f4d243fbb7d9ac57b0c7e9892f8b4 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Wed, 1 Mar 2023 12:10:31 +0100
Subject: [PATCH 37/50] removed commented-out code

---
 .../documentation/ExpressionsGivenRow.kt          | 15 ---------------
 1 file changed, 15 deletions(-)

diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
index 74db05625..3bbcbc01c 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
@@ -85,21 +85,6 @@ internal interface ExpressionsGivenRow {
 
     /** [Row Value Expression][RowValueExpression.WithExample] */
     interface RowValueExpressionLink
-
-//    @Deprecated(
-//        "This is located in another file",
-//        ReplaceWith("ExpressionsGivenColumn.RowColumnExpression"),
-//        DeprecationLevel.ERROR,
-//    )
-//    interface RowColumnExpression {
-//
-//        @Deprecated(
-//            "This is located in another file",
-//            ReplaceWith("ExpressionsGivenColumn.RowColumnExpression.WithExample"),
-//            DeprecationLevel.ERROR,
-//        )
-//        interface WithExample
-//    }
 }
 
 /** [Row Expression][ExpressionsGivenRow] */

From 8ed0907f886f79ba92f5646c1990d4198c4c2223 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Thu, 2 Mar 2023 18:45:51 +0100
Subject: [PATCH 38/50] updated plugin

---
 core/build.gradle.kts                           | 10 +++++++---
 .../documentation/ExpressionsGivenRow.kt        | 15 ---------------
 .../kotlinx/dataframe/test/sampleExtensions.kt  | 17 -----------------
 .../jetbrains/kotlinx/dataframe/test/usage.kt   | 17 -----------------
 4 files changed, 7 insertions(+), 52 deletions(-)
 delete mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/test/sampleExtensions.kt
 delete mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/test/usage.kt

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index c37074534..f2f2b9b74 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -1,5 +1,9 @@
-import nl.jolanrensen.docProcessor.*
-import nl.jolanrensen.docProcessor.defaultProcessors.*
+import nl.jolanrensen.docProcessor.defaultProcessors.COMMENT_DOC_PROCESSOR
+import nl.jolanrensen.docProcessor.defaultProcessors.INCLUDE_ARG_DOC_PROCESSOR
+import nl.jolanrensen.docProcessor.defaultProcessors.INCLUDE_DOC_PROCESSOR
+import nl.jolanrensen.docProcessor.defaultProcessors.INCLUDE_FILE_DOC_PROCESSOR
+import nl.jolanrensen.docProcessor.defaultProcessors.SAMPLE_DOC_PROCESSOR
+import nl.jolanrensen.docProcessor.gradle.creatingProcessDocTask
 import org.gradle.jvm.tasks.Jar
 
 @Suppress("DSL_SCOPE_VIOLATION", "UnstableApiUsage")
@@ -14,7 +18,7 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.20"
+    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.22"
 //    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
 }
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
index b196ca35c..701ad5732 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
@@ -88,21 +88,6 @@ internal interface ExpressionsGivenRow {
 
     /** [Row Value Expression][RowValueExpression.WithExample] */
     interface RowValueExpressionLink
-
-//    @Deprecated(
-//        "This is located in another file",
-//        ReplaceWith("ExpressionsGivenColumn.RowColumnExpression"),
-//        DeprecationLevel.ERROR,
-//    )
-//    interface RowColumnExpression {
-//
-//        @Deprecated(
-//            "This is located in another file",
-//            ReplaceWith("ExpressionsGivenColumn.RowColumnExpression.WithExample"),
-//            DeprecationLevel.ERROR,
-//        )
-//        interface WithExample
-//    }
 }
 
 /** [Row Expression][ExpressionsGivenRow] */
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/test/sampleExtensions.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/test/sampleExtensions.kt
deleted file mode 100644
index 847bfa8d8..000000000
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/test/sampleExtensions.kt
+++ /dev/null
@@ -1,17 +0,0 @@
-package samples
-
-public fun String.stringExtension() {
-    println("Hello, world!")
-}
-
-public fun List<Any?>.nullableAnyListExtension() {}
-
-public fun List<Any>.anyListExtension() {}
-
-public fun <T> List<T>.genericListExtension() {}
-
-public fun <T> List<T?>.nullableGenericListExtension() {}
-
-public fun <T : Any?> List<T>.boundGenericListExtension() {}
-
-public fun <T : Any?> List<T?>.boundNullableGenericListExtension() {}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/test/usage.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/test/usage.kt
deleted file mode 100644
index 3aec47bde..000000000
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/test/usage.kt
+++ /dev/null
@@ -1,17 +0,0 @@
-import samples.*
-
-/**
- * [String.stringExtension]
- *
- * [samples.stringExtension]
- *
- * @sampl samples.SampleGroup.mySample
- * @sampl samples.megasamples.MegaSamplesGroup.megaSample
- * @sampl samples.notindir.NotInDirSamples.sssample
- * @sampl smaplez.a.b.c.Samplez.sssample
- * @sampl samples.stringExtension
- * @sampl String.stringExtension
- */
-public fun <caret> some() {}
-
-//INFO: <div class='definition'><pre><span style="color:#000080;font-weight:bold;">public</span> <span style="color:#000080;font-weight:bold;">fun</span> <span style="color:#000000;">some</span>()<span style="">: </span><span style="color:#000000;">Unit</span></pre></div><table class='sections'><tr><td valign='top' class='section'><p>Samples:</td><td valign='top'><p><a href="psi_element://samples.SampleGroup.mySample"><code style='font-size:96%;'><span style="color:#000000;">samples</span><span style="">.</span><span style="color:#000000;">SampleGroup</span><span style="">.</span><span style="color:#0000ff;">mySample</span></code></a><pre><code><span style=""><br><span style="">println(</span><span style="color:#008000;font-weight:bold;">"Hello,&#32;world"</span><span style="">)<br></span></span></code></pre><p><a href="psi_element://samples.megasamples.MegaSamplesGroup.megaSample"><code style='font-size:96%;'><span style="color:#000000;">samples</span><span style="">.</span><span style="color:#000000;">megasamples</span><span style="">.</span><span style="color:#000000;">MegaSamplesGroup</span><span style="">.</span><span style="color:#0000ff;">megaSample</span></code></a><pre><code><span style=""><br><span style="">println(</span><span style="color:#008000;font-weight:bold;">"...---..."</span><span style="">)<br></span></span></code></pre><p><a href="psi_element://samples.notindir.NotInDirSamples.sssample"><code style='font-size:96%;'><span style="color:#000000;">samples</span><span style="">.</span><span style="color:#000000;">notindir</span><span style="">.</span><span style="color:#000000;">NotInDirSamples</span><span style="">.</span><span style="color:#0000ff;">sssample</span></code></a><pre><code><span style=""><br><span style="">println(</span><span style="color:#008000;font-weight:bold;">"location&#32;is&#32;samplesTest/"</span><span style="">)<br></span></span></code></pre><p><a href="psi_element://smaplez.a.b.c.Samplez.sssample"><code style='font-size:96%;'><span style="color:#000000;">smaplez</span><span style="">.</span><span style="color:#000000;">a</span><span style="">.</span><span style="color:#000000;">b</span><span style="">.</span><span style="color:#000000;">c</span><span style="">.</span><span style="color:#000000;">Samplez</span><span style="">.</span><span style="color:#4585be;">sssample</span></code></a><pre><code><span style=""><span style="color:#808080;font-style:italic;">//&#32;Unresolved</span></span></code></pre><p><a href="psi_element://samples.stringExtension"><code style='font-size:96%;'><span style="color:#000000;">samples</span><span style="">.</span><span style="color:#0000ff;">stringExtension</span></code></a><pre><code><span style=""></span></code></pre><p><a href="psi_element://String.stringExtension"><code style='font-size:96%;'><span style="color:#000000;">String</span><span style="">.</span><span style="color:#4585be;">stringExtension</span></code></a><pre><code><span style=""><span style="color:#808080;font-style:italic;">//&#32;Unresolved</span></span></code></pre></td></table><div class='bottom'><icon src="/org/jetbrains/kotlin/idea/icons/kotlin_file.svg"/>&nbsp;usage.kt<br/></div>

From 61e01c870a660ebf1f364847192a45de12e4c6cc Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Fri, 3 Mar 2023 18:17:26 +0100
Subject: [PATCH 39/50] updated plugin, fixes newlines and links in @include

---
 core/build.gradle.kts                         |  2 +-
 .../jetbrains/kotlinx/dataframe/api/update.kt | 27 +++++--------------
 .../documentation/ExpressionsGivenRow.kt      |  9 ++++++-
 .../documentation/ExpressionsGivenRow.kt      | 10 ++++++-
 .../idea-examples/movies/build.gradle.kts     |  1 +
 5 files changed, 25 insertions(+), 24 deletions(-)

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index f2f2b9b74..4ef5fc860 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -18,7 +18,7 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.22"
+    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.24"
 //    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
 }
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index 12fe97a00..696b2bb46 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -149,7 +149,6 @@ public fun <T, C> DataFrame<T>.update(columns: ColumnsSelector<T, C>): Update<T,
  * 
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`("length", "age")`
  *  
- * 
  * ## Optional
  * Combine `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...).`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { ... }`
  * into `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...) { ... }`
@@ -178,7 +177,6 @@ public fun <T> DataFrame<T>.update(vararg columns: String): Update<T, Any?> = up
  * 
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(Person::length, Person::age)`
  *  
- * 
  * ## Optional
  * Combine `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...).`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { ... }`
  * into `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...) { ... }`
@@ -209,7 +207,6 @@ public fun <T, C> DataFrame<T>.update(vararg columns: KProperty<C>): Update<T, C
  * 
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(length, age)`
  *  
- * 
  * ## Optional
  * Combine `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...).`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { ... }`
  * into `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...) { ... }`
@@ -228,7 +225,6 @@ public fun <T, C> DataFrame<T>.update(columns: Iterable<ColumnReference<C>>): Up
 
 /**
  * ## Where
- * 
  * Filter or find rows to operate on after [selecting columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] using a
  * [row value filter][org.jetbrains.kotlinx.dataframe.RowValueFilter].
  * 
@@ -269,7 +265,7 @@ private interface CommonUpdateAtFunctionDoc {
  * ## At
  * Only update the columns at certain given [row indices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]:
  * 
- * Either a [Collection][Collection]< [Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
+ * Either a [Collection][Collection]<[Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
  * 
  * For example:
  * 
@@ -281,7 +277,7 @@ private interface CommonUpdateAtFunctionDoc {
  * 
  * Provide a [Collection]<[Int]> of row indices to update.
  * 
- * @param rowIndices The indices of the rows to update. Either a [Collection][Collection]< [Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
+ * @param rowIndices The indices of the rows to update. Either a [Collection][Collection]<[Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
  */
 public fun <T, C> Update<T, C>.at(rowIndices: Collection<Int>): Update<T, C> = where { index in rowIndices }
 
@@ -289,7 +285,7 @@ public fun <T, C> Update<T, C>.at(rowIndices: Collection<Int>): Update<T, C> = w
  * ## At
  * Only update the columns at certain given [row indices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]:
  * 
- * Either a [Collection][Collection]< [Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
+ * Either a [Collection][Collection]<[Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
  * 
  * For example:
  * 
@@ -301,7 +297,7 @@ public fun <T, C> Update<T, C>.at(rowIndices: Collection<Int>): Update<T, C> = w
  * 
  * Provide a `vararg` of [Ints][Int] of row indices to update.
  * 
- * @param rowIndices The indices of the rows to update. Either a [Collection][Collection]< [Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
+ * @param rowIndices The indices of the rows to update. Either a [Collection][Collection]<[Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
  */
 public fun <T, C> Update<T, C>.at(vararg rowIndices: Int): Update<T, C> = at(rowIndices.toSet())
 
@@ -309,7 +305,7 @@ public fun <T, C> Update<T, C>.at(vararg rowIndices: Int): Update<T, C> = at(row
  * ## At
  * Only update the columns at certain given [row indices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]:
  * 
- * Either a [Collection][Collection]< [Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
+ * Either a [Collection][Collection]<[Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
  * 
  * For example:
  * 
@@ -321,13 +317,12 @@ public fun <T, C> Update<T, C>.at(vararg rowIndices: Int): Update<T, C> = at(row
  * 
  * Provide an [IntRange] of row indices to update.
  * 
- * @param rowRange The indices of the rows to update. Either a [Collection][Collection]< [Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
+ * @param rowRange The indices of the rows to update. Either a [Collection][Collection]<[Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
  */
 public fun <T, C> Update<T, C>.at(rowRange: IntRange): Update<T, C> = where { index in rowRange }
 
 /**
  * ## Per Row Col
- * 
  * Provide a new value for every selected cell given both its row and column using a [row-column expression][org.jetbrains.kotlinx.dataframe.RowColumnExpression].
  * 
  * For example:
@@ -360,7 +355,6 @@ public typealias UpdateExpression<T, C, R> = AddDataRow<T>.(C) -> R
 
 /**
  * ## With
- * 
  * Provide a new value for every selected cell given its row and its previous value using a
  * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
  * 
@@ -373,7 +367,6 @@ public typealias UpdateExpression<T, C, R> = AddDataRow<T>.(C) -> R
  * 
  * 
  * ## Note
- * 
  * [update with][org.jetbrains.kotlinx.dataframe.api.Update.with]- and [add][org.jetbrains.kotlinx.dataframe.api.add]-like expressions use [AddDataRow][org.jetbrains.kotlinx.dataframe.api.AddDataRow] instead of [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as the DSL's receiver type.
  * This is an extension to [RowValueExpression][org.jetbrains.kotlinx.dataframe.RowValueExpression] and
  * [RowExpression][org.jetbrains.kotlinx.dataframe.RowExpression] that provides access to
@@ -396,7 +389,6 @@ private interface SeeAlsoWith
  * 
  * Updates selected [column group][ColumnGroup] as a [DataFrame] with the given [expression].
  * 
- * 
  * Provide a new value for every selected data frame using a [dataframe expression][org.jetbrains.kotlinx.dataframe.DataFrameExpression].
  * 
  * For example:
@@ -535,7 +527,6 @@ public fun <T, C> Update<T, C>.perCol(values: AnyRow): DataFrame<T> = perCol(val
  *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
  *  - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
  * ## This Per Col Overload
- * 
  * Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
  * 
  * For example:
@@ -626,7 +617,6 @@ public fun <T, C> Update<T, C?>.notNull(expression: UpdateExpression<T, C, C>):
  * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
  * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
  * 
- * 
  * Provide a new value for every selected cell given its row and its previous value using a
  * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
  * 
@@ -664,7 +654,6 @@ public fun <T, C> DataFrame<T>.update(
  * 
  * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
  * 
- * 
  * Provide a new value for every selected cell given its row and its previous value using a
  * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
  * 
@@ -703,7 +692,6 @@ public fun <T, C> DataFrame<T>.update(
  * Select columns using their [column names][String]
  * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
  * 
- * 
  * Provide a new value for every selected cell given its row and its previous value using a
  * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
  * 
@@ -742,7 +730,6 @@ private interface CommonSpecificWithDocSecondArg
 
 /**
  * ## With Null
- * 
  * Specific version of [with][org.jetbrains.kotlinx.dataframe.api.with] that simply sets the value of each selected row to `null`.
  * 
  * For example:
@@ -753,7 +740,6 @@ public fun <T, C> Update<T, C>.withNull(): DataFrame<T> = with { null }
 
 /**
  * ## With Zero
- * 
  * Specific version of [with][org.jetbrains.kotlinx.dataframe.api.with] that simply sets the value of each selected row to `0`.
  * 
  * For example:
@@ -764,7 +750,6 @@ public fun <T, C> Update<T, C>.withZero(): DataFrame<T> = updateWithValuePerColu
 
 /**
  * ## With Value
- * 
  * Specific version of [with][org.jetbrains.kotlinx.dataframe.api.with] that simply sets the value of each selected row to [value].
  * 
  * For example:
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
index 701ad5732..89edf6acc 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
@@ -2,7 +2,14 @@ package org.jetbrains.kotlinx.dataframe.documentation
 
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
-import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.api.AddDataRow
+import org.jetbrains.kotlinx.dataframe.api.Convert
+import org.jetbrains.kotlinx.dataframe.api.Update
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.insert
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.notNull
+import org.jetbrains.kotlinx.dataframe.api.with
 import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.AddDataRowNote
 import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowExpressionLink
 import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpressionLink
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
index 3bbcbc01c..48ba1b740 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
@@ -2,7 +2,14 @@ package org.jetbrains.kotlinx.dataframe.documentation
 
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
-import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.api.AddDataRow
+import org.jetbrains.kotlinx.dataframe.api.Convert
+import org.jetbrains.kotlinx.dataframe.api.Update
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.insert
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.notNull
+import org.jetbrains.kotlinx.dataframe.api.with
 import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.AddDataRowNote
 import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowExpressionLink
 import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpressionLink
@@ -23,6 +30,7 @@ import org.jetbrains.kotlinx.dataframe.RowValueExpression as DfRowValueExpressio
  * (using [RowValueExpression][DfRowValueExpression]).
  *
  * Note:
+ *
  * @include [AddDataRowNote]
  *
  * A Row Expression is similar to a {@include [RowConditionLink]} but that expects a [Boolean] as result.
diff --git a/examples/idea-examples/movies/build.gradle.kts b/examples/idea-examples/movies/build.gradle.kts
index fbb2c9e44..2c38f37fa 100644
--- a/examples/idea-examples/movies/build.gradle.kts
+++ b/examples/idea-examples/movies/build.gradle.kts
@@ -16,6 +16,7 @@ application.mainClass.set("org.jetbrains.kotlinx.dataframe.examples.movies.Movie
 
 dependencies {
     implementation(project(":core"))
+    implementation(project(":dataframe-openapi"))
 }
 
 tasks.withType<KotlinCompile> {

From 084930945c9f5745ec4c347211a10df8c53a741f Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Tue, 14 Mar 2023 11:59:31 +0100
Subject: [PATCH 40/50] updating docs plugin

---
 core/build.gradle.kts                         |   2 +-
 .../jetbrains/kotlinx/dataframe/DataFrame.kt  |   2 +-
 .../jetbrains/kotlinx/dataframe/DataRow.kt    |   2 +-
 .../jetbrains/kotlinx/dataframe/aliases.kt    |   2 +-
 .../dataframe/api/ColumnsSelectionDsl.kt      |  18 +-
 .../kotlinx/dataframe/api/DataFrameGet.kt     |   4 +-
 .../kotlinx/dataframe/api/DataRowApi.kt       |   6 +-
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  | 232 +++++-----
 .../jetbrains/kotlinx/dataframe/api/add.kt    |  10 +-
 .../kotlinx/dataframe/api/countDistinct.kt    |   4 +-
 .../jetbrains/kotlinx/dataframe/api/cumSum.kt |   6 +-
 .../kotlinx/dataframe/api/distinct.kt         |  10 +-
 .../jetbrains/kotlinx/dataframe/api/group.kt  |   6 +-
 .../kotlinx/dataframe/api/groupBy.kt          |  17 +-
 .../jetbrains/kotlinx/dataframe/api/move.kt   |  16 +-
 .../jetbrains/kotlinx/dataframe/api/pivot.kt  |  20 +-
 .../jetbrains/kotlinx/dataframe/api/remove.kt |  10 +-
 .../jetbrains/kotlinx/dataframe/api/select.kt |   6 +-
 .../kotlinx/dataframe/api/toDataFrame.kt      |   4 +-
 .../jetbrains/kotlinx/dataframe/api/unfold.kt |   4 +-
 .../kotlinx/dataframe/api/ungroup.kt          |   4 +-
 .../jetbrains/kotlinx/dataframe/api/update.kt | 431 +++++++++---------
 .../kotlinx/dataframe/api/valueCounts.kt      |   4 +-
 .../jetbrains/kotlinx/dataframe/api/values.kt |  14 +-
 .../jetbrains/kotlinx/dataframe/api/with.kt   |   4 +-
 .../dataframe/documentation/AccessApi.kt      |  32 +-
 .../documentation/ExpressionsGivenColumn.kt   |  19 +-
 .../ExpressionsGivenDataFrame.kt              |   5 +-
 .../documentation/ExpressionsGivenRow.kt      |  26 +-
 .../documentation/SelectingColumns.kt         |  90 ++--
 .../dataframe/documentation/SelectingRows.kt  |  18 +-
 .../impl/aggregation/aggregations.kt          |   4 +-
 .../kotlinx/dataframe/impl/api/move.kt        |   4 +-
 .../kotlinx/dataframe/impl/api/split.kt       |  60 ++-
 .../kotlinx/dataframe/impl/api/update.kt      |  48 +-
 .../dataframe/impl/columns/DataColumnImpl.kt  |   2 +-
 .../jupyter/DisableRowsLimitWrapper.kt        |   8 +
 .../kotlinx/dataframe/jupyter/Integration.kt  |  85 ++--
 .../dataframe/jupyter/JupyterHtmlRenderer.kt  |  56 ++-
 .../jupyter/KotlinNotebookPluginUtils.kt      |  33 ++
 40 files changed, 730 insertions(+), 598 deletions(-)
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/DisableRowsLimitWrapper.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/KotlinNotebookPluginUtils.kt

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index e116a9402..04aca2b1a 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -18,7 +18,7 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.24"
+    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.29"
 //    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
 }
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataFrame.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataFrame.kt
index dd1c55636..9698f9630 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataFrame.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataFrame.kt
@@ -57,7 +57,7 @@ public interface DataFrame<out T> : Aggregatable<T>, ColumnsContainer<T> {
     override operator fun <C> get(columns: ColumnsSelector<T, C>): List<DataColumn<C>> =
         getColumnsImpl(UnresolvedColumnsPolicy.Fail, columns)
 
-    public operator fun get(first: Column, vararg other: Column): DataFrame<T> = select(listOf(first) + other)
+    public operator fun get(first: AnyColumnReference, vararg other: AnyColumnReference): DataFrame<T> = select(listOf(first) + other)
     public operator fun get(first: String, vararg other: String): DataFrame<T> = select(listOf(first) + other)
     public operator fun get(columnRange: ClosedRange<String>): DataFrame<T> =
         select { columnRange.start..columnRange.endInclusive }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataRow.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataRow.kt
index 989fb3df2..5a1375436 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataRow.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataRow.kt
@@ -28,7 +28,7 @@ public interface DataRow<out T> {
     public operator fun <R> get(column: ColumnReference<R>): R
     public operator fun <R> get(columns: List<ColumnReference<R>>): List<R> = columns.map { get(it) }
     public operator fun <R> get(property: KProperty<R>): R = get(property.columnName) as R
-    public operator fun get(first: Column, vararg other: Column): DataRow<T> = owner.get(first, *other)[index]
+    public operator fun get(first: AnyColumnReference, vararg other: AnyColumnReference): DataRow<T> = owner.get(first, *other)[index]
     public operator fun get(first: String, vararg other: String): DataRow<T> = owner.get(first, *other)[index]
     public operator fun get(path: ColumnPath): Any? = owner.get(path)[index]
     public operator fun get(name: String): Any?
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt
index de7a58df5..064bbeb02 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt
@@ -149,7 +149,7 @@ public typealias RowValueFilter<T, C> = RowValueExpression<T, C, Boolean>
 
 // region columns
 
-public typealias Column = ColumnReference<*>
+public typealias AnyColumnReference = ColumnReference<*>
 
 public typealias ColumnGroupReference = ColumnReference<AnyRow>
 public typealias ColumnGroupAccessor<T> = ColumnAccessor<DataRow<T>>
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
index 43ffc0908..5525e8d7e 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
@@ -1,10 +1,15 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
+import org.jetbrains.kotlinx.dataframe.AnyRow
 import org.jetbrains.kotlinx.dataframe.ColumnFilter
+import org.jetbrains.kotlinx.dataframe.ColumnGroupReference
 import org.jetbrains.kotlinx.dataframe.ColumnsContainer
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.Predicate
 import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
 import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
@@ -16,6 +21,7 @@ import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
 import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
 import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
 import org.jetbrains.kotlinx.dataframe.columns.renamedReference
+import org.jetbrains.kotlinx.dataframe.hasNulls
 import org.jetbrains.kotlinx.dataframe.impl.columnName
 import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnsList
 import org.jetbrains.kotlinx.dataframe.impl.columns.DistinctColumnSet
@@ -74,7 +80,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     public operator fun String.rangeTo(endInclusive: String): ColumnSet<*> = toColumnAccessor().rangeTo(endInclusive.toColumnAccessor())
 
-    public operator fun Column.rangeTo(endInclusive: Column): ColumnSet<*> = object : ColumnSet<Any?> {
+    public operator fun AnyColumnReference.rangeTo(endInclusive: AnyColumnReference): ColumnSet<*> = object : ColumnSet<Any?> {
         override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<Any?>> {
             val startPath = this@rangeTo.resolveSingle(context)!!.path
             val endPath = endInclusive.resolveSingle(context)!!.path
@@ -168,7 +174,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     }
 
     public fun SingleColumn<*>.allAfter(colName: String): ColumnSet<Any?> = allAfter(pathOf(colName))
-    public fun SingleColumn<*>.allAfter(column: Column): ColumnSet<Any?> = allAfter(column.path())
+    public fun SingleColumn<*>.allAfter(column: AnyColumnReference): ColumnSet<Any?> = allAfter(column.path())
 
     // endregion
 
@@ -187,7 +193,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     }
 
     public fun SingleColumn<*>.allSince(colName: String): ColumnSet<Any?> = allSince(pathOf(colName))
-    public fun SingleColumn<*>.allSince(column: Column): ColumnSet<Any?> = allSince(column.path())
+    public fun SingleColumn<*>.allSince(column: AnyColumnReference): ColumnSet<Any?> = allSince(column.path())
 
     // endregion
 
@@ -206,7 +212,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     }
 
     public fun SingleColumn<*>.allBefore(colName: String): ColumnSet<Any?> = allBefore(pathOf(colName))
-    public fun SingleColumn<*>.allBefore(column: Column): ColumnSet<Any?> = allBefore(column.path())
+    public fun SingleColumn<*>.allBefore(column: AnyColumnReference): ColumnSet<Any?> = allBefore(column.path())
 
     // endregion
 
@@ -225,7 +231,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     }
 
     public fun SingleColumn<*>.allUntil(colName: String): ColumnSet<Any?> = allUntil(pathOf(colName))
-    public fun SingleColumn<*>.allUntil(column: Column): ColumnSet<Any?> = allUntil(column.path())
+    public fun SingleColumn<*>.allUntil(column: AnyColumnReference): ColumnSet<Any?> = allUntil(column.path())
 
     // endregion
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataFrameGet.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataFrameGet.kt
index 63588c4e9..354d5990d 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataFrameGet.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataFrameGet.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyCol
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnSelector
 import org.jetbrains.kotlinx.dataframe.ColumnsContainer
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
@@ -88,7 +88,7 @@ public fun <T> ColumnsContainer<T>.getColumnGroupOrNull(column: KProperty<*>): C
 public fun <C> ColumnsContainer<*>.containsColumn(column: ColumnReference<C>): Boolean = getColumnOrNull(column) != null
 public fun ColumnsContainer<*>.containsColumn(column: KProperty<*>): Boolean = containsColumn(column.columnName)
 
-public operator fun ColumnsContainer<*>.contains(column: Column): Boolean = containsColumn(column)
+public operator fun ColumnsContainer<*>.contains(column: AnyColumnReference): Boolean = containsColumn(column)
 public operator fun ColumnsContainer<*>.contains(column: KProperty<*>): Boolean = containsColumn(column)
 
 // region rows
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 9cdc67e72..d7987f5c4 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
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.AnyRow
-import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsContainer
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -57,10 +57,10 @@ public fun <T> AnyRow.getValueOrNull(column: KProperty<T>): T? = getValueOrNull<
 // region contains
 
 public fun AnyRow.containsKey(columnName: String): Boolean = owner.containsColumn(columnName)
-public fun AnyRow.containsKey(column: Column): Boolean = owner.containsColumn(column)
+public fun AnyRow.containsKey(column: AnyColumnReference): Boolean = owner.containsColumn(column)
 public fun AnyRow.containsKey(column: KProperty<*>): Boolean = owner.containsColumn(column)
 
-public operator fun AnyRow.contains(column: Column): Boolean = containsKey(column)
+public operator fun AnyRow.contains(column: AnyColumnReference): Boolean = containsKey(column)
 public operator fun AnyRow.contains(column: KProperty<*>): Boolean = containsKey(column)
 
 // endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index 6c04bc01a..4949edd0b 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -1,9 +1,9 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.AnyFrame
 import org.jetbrains.kotlinx.dataframe.AnyRow
-import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -21,25 +21,24 @@ import kotlin.reflect.KProperty
 
 /**
  * ## The Fill Nulls Operation
- * 
+ *
  * Replaces `null` values with given value or expression.
  * Specific case of [update].
- * 
+ *
  * Check out the [`fillNulls` Operation Usage][Usage].
- * 
+ *
  * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls)
  */
 internal interface FillNulls {
 
-    /**
-     * ## [fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls] Operation Usage
-     * 
+    /** ## [fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls] Operation Usage
+     *
      * [fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls] `{ `[columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]` }`
-     * 
+     *
      * - `[.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { `[rowValueCondition][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows.RowValueCondition.WithExample]` } ]`
-     * 
+     *
      * - `[.`[at][org.jetbrains.kotlinx.dataframe.api.Update.at]` (`[rowIndices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]`) ]`
-     * 
+     *
      * - `.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
      *   | .`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
      *   | .`[perCol][org.jetbrains.kotlinx.dataframe.api.Update.perCol]` { `[colExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpression.WithExample]` }
@@ -52,17 +51,16 @@ internal interface FillNulls {
     interface Usage
 }
 
-
 private interface SetFillNullsOperationArg
 
 /**
  * ## The Fill Nulls Operation
- * 
+ *
  * Replaces `null` values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
- * 
+ *
  * Check out the [`fillNulls` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNulls.Usage].
- * 
+ *
  * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
@@ -72,29 +70,29 @@ private interface CommonFillNullsFunctionDoc
 
 /**
  * ## The Fill Nulls Operation
- * 
+ *
  * Replaces `null` values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
- * 
+ *
  * Check out the [`fillNulls` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNulls.Usage].
- * 
+ *
  * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
  * ## This Fill Nulls Overload
  * Select or express columns using the Column(s) Selection DSL.
  * (Any [Access Api][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
- * 
+ *
  * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
  * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
  * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
- * 
+ *
  * For example:
- * 
+ *
  * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]` { length `[and][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.and]` age }`
- * 
+ *
  * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
- * 
+ *
  * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<Double>() }`
  *  
  * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
@@ -104,21 +102,21 @@ public fun <T, C> DataFrame<T>.fillNulls(columns: ColumnsSelector<T, C?>): Updat
 
 /**
  * ## The Fill Nulls Operation
- * 
+ *
  * Replaces `null` values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
- * 
+ *
  * Check out the [`fillNulls` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNulls.Usage].
- * 
+ *
  * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
  * ## This Fill Nulls Overload
  * Select columns using their [column names][String]
  * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
- * 
+ *
  * For example:
- * 
+ *
  * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]`("length", "age")`
  *  
  * @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] belonging to this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
@@ -128,23 +126,23 @@ public fun <T> DataFrame<T>.fillNulls(vararg columns: String): Update<T, Any?> =
 
 /**
  * ## The Fill Nulls Operation
- * 
+ *
  * Replaces `null` values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
- * 
+ *
  * Check out the [`fillNulls` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNulls.Usage].
- * 
+ *
  * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
  * ## This Fill Nulls Overload
  * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
- * 
+ *
  * For example:
  * ```kotlin
  * data class Person(val length: Double, val age: Double)
  * ```
- * 
+ *
  * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]`(Person::length, Person::age)`
  *  
  * @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] corresponding to columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
@@ -154,25 +152,25 @@ public fun <T, C> DataFrame<T>.fillNulls(vararg columns: KProperty<C>): Update<T
 
 /**
  * ## The Fill Nulls Operation
- * 
+ *
  * Replaces `null` values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
- * 
+ *
  * Check out the [`fillNulls` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNulls.Usage].
- * 
+ *
  * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
  * ## This Fill Nulls Overload
  * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
  * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
- * 
+ *
  * For example:
- * 
+ *
  * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
- * 
+ *
  * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
- * 
+ *
  * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]`(length, age)`
  *  
  * @param columns The [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample] of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
@@ -236,25 +234,24 @@ internal inline val Float?.isNA: Boolean get() = this == null || this.isNaN()
 
 /**
  * ## The Fill NaNs Operation
- * 
+ *
  * Replaces [`NaN`][NaN] values with given value or expression.
  * Specific case of [update].
- * 
+ *
  * Check out the [`fillNaNs` Operation Usage][Usage].
- * 
+ *
  * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans)
  */
 internal interface FillNaNs {
 
-    /**
-     * ## [fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs] Operation Usage
-     * 
+    /** ## [fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs] Operation Usage
+     *
      * [fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs] `{ `[columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]` }`
-     * 
+     *
      * - `[.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { `[rowValueCondition][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows.RowValueCondition.WithExample]` } ]`
-     * 
+     *
      * - `[.`[at][org.jetbrains.kotlinx.dataframe.api.Update.at]` (`[rowIndices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]`) ]`
-     * 
+     *
      * - `.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
      *   | .`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
      *   | .`[perCol][org.jetbrains.kotlinx.dataframe.api.Update.perCol]` { `[colExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpression.WithExample]` }
@@ -267,17 +264,16 @@ internal interface FillNaNs {
     interface Usage
 }
 
-
 internal interface SetFillNaNsOperationArg
 
 /**
  * ## The Fill NaNs Operation
- * 
+ *
  * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.api.NaN] values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
- * 
+ *
  * Check out the [`fillNaNs` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Usage].
- * 
+ *
  * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
@@ -287,29 +283,29 @@ private interface CommonFillNaNsFunctionDoc
 
 /**
  * ## The Fill NaNs Operation
- * 
+ *
  * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.api.NaN] values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
- * 
+ *
  * Check out the [`fillNaNs` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Usage].
- * 
+ *
  * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
  * ## This Fill NaNs Overload
  * Select or express columns using the Column(s) Selection DSL.
  * (Any [Access Api][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
- * 
+ *
  * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
  * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
  * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
- * 
+ *
  * For example:
- * 
+ *
  * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]` { length `[and][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.and]` age }`
- * 
+ *
  * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
- * 
+ *
  * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<Double>() }`
  *  
  * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
@@ -319,21 +315,21 @@ public fun <T, C> DataFrame<T>.fillNaNs(columns: ColumnsSelector<T, C>): Update<
 
 /**
  * ## The Fill NaNs Operation
- * 
+ *
  * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.api.NaN] values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
- * 
+ *
  * Check out the [`fillNaNs` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Usage].
- * 
+ *
  * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
  * ## This Fill NaNs Overload
  * Select columns using their [column names][String]
  * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
- * 
+ *
  * For example:
- * 
+ *
  * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]`("length", "age")`
  *  
  * @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] belonging to this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
@@ -343,23 +339,23 @@ public fun <T> DataFrame<T>.fillNaNs(vararg columns: String): Update<T, Any?> =
 
 /**
  * ## The Fill NaNs Operation
- * 
+ *
  * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.api.NaN] values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
- * 
+ *
  * Check out the [`fillNaNs` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Usage].
- * 
+ *
  * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
  * ## This Fill NaNs Overload
  * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
- * 
+ *
  * For example:
  * ```kotlin
  * data class Person(val length: Double, val age: Double)
  * ```
- * 
+ *
  * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]`(Person::length, Person::age)`
  *  
  * @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] corresponding to columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
@@ -369,25 +365,25 @@ public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: KProperty<C>): Update<T,
 
 /**
  * ## The Fill NaNs Operation
- * 
+ *
  * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.api.NaN] values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
- * 
+ *
  * Check out the [`fillNaNs` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Usage].
- * 
+ *
  * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
  * ## This Fill NaNs Overload
  * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
  * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
- * 
+ *
  * For example:
- * 
+ *
  * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
- * 
+ *
  * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
- * 
+ *
  * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]`(length, age)`
  *  
  * @param columns The [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample] of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
@@ -407,25 +403,24 @@ public fun <T, C> DataFrame<T>.fillNaNs(columns: Iterable<ColumnReference<C>>):
 
 /**
  * ## The Fill NA Operation
- * 
+ *
  * Replaces [`NA`][NA] values with given value or expression.
  * Specific case of [update].
- * 
+ *
  * Check out the [`fillNA` Operation Usage][Usage].
- * 
+ *
  * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna)
  */
 internal interface FillNA {
 
-    /**
-     * ## [fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA] Operation Usage
-     * 
+    /** ## [fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA] Operation Usage
+     *
      * [fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA] `{ `[columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]` }`
-     * 
+     *
      * - `[.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { `[rowValueCondition][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows.RowValueCondition.WithExample]` } ]`
-     * 
+     *
      * - `[.`[at][org.jetbrains.kotlinx.dataframe.api.Update.at]` (`[rowIndices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]`) ]`
-     * 
+     *
      * - `.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
      *   | .`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
      *   | .`[perCol][org.jetbrains.kotlinx.dataframe.api.Update.perCol]` { `[colExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpression.WithExample]` }
@@ -438,17 +433,16 @@ internal interface FillNA {
     interface Usage
 }
 
-
 internal interface SetFillNAOperationArg
 
 /**
  * ## The Fill NA Operation
- * 
+ *
  * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
- * 
+ *
  * Check out the [`fillNA` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNA.Usage].
- * 
+ *
  * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
@@ -458,29 +452,29 @@ private interface CommonFillNAFunctionDoc
 
 /**
  * ## The Fill NA Operation
- * 
+ *
  * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
- * 
+ *
  * Check out the [`fillNA` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNA.Usage].
- * 
+ *
  * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
  * ## This Fill NA Overload
  * Select or express columns using the Column(s) Selection DSL.
  * (Any [Access Api][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
- * 
+ *
  * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
  * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
  * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
- * 
+ *
  * For example:
- * 
+ *
  * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]` { length `[and][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.and]` age }`
- * 
+ *
  * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
- * 
+ *
  * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<Double>() }`
  *  
  * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
@@ -490,21 +484,21 @@ public fun <T, C> DataFrame<T>.fillNA(columns: ColumnsSelector<T, C?>): Update<T
 
 /**
  * ## The Fill NA Operation
- * 
+ *
  * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
- * 
+ *
  * Check out the [`fillNA` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNA.Usage].
- * 
+ *
  * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
  * ## This Fill NA Overload
  * Select columns using their [column names][String]
  * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
- * 
+ *
  * For example:
- * 
+ *
  * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]`("length", "age")`
  *  
  * @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] belonging to this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
@@ -514,23 +508,23 @@ public fun <T> DataFrame<T>.fillNA(vararg columns: String): Update<T, Any?> =
 
 /**
  * ## The Fill NA Operation
- * 
+ *
  * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
- * 
+ *
  * Check out the [`fillNA` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNA.Usage].
- * 
+ *
  * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
  * ## This Fill NA Overload
  * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
- * 
+ *
  * For example:
  * ```kotlin
  * data class Person(val length: Double, val age: Double)
  * ```
- * 
+ *
  * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]`(Person::length, Person::age)`
  *  
  * @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] corresponding to columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
@@ -540,25 +534,25 @@ public fun <T, C> DataFrame<T>.fillNA(vararg columns: KProperty<C>): Update<T, C
 
 /**
  * ## The Fill NA Operation
- * 
+ *
  * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
- * 
+ *
  * Check out the [`fillNA` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNA.Usage].
- * 
+ *
  * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
  * ## This Fill NA Overload
  * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
  * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
- * 
+ *
  * For example:
- * 
+ *
  * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
- * 
+ *
  * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
- * 
+ *
  * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]`(length, age)`
  *  
  * @param columns The [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample] of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
@@ -591,11 +585,11 @@ public fun <T> DataFrame<T>.dropNulls(vararg columns: KProperty<*>, whereAllNull
 public fun <T> DataFrame<T>.dropNulls(vararg columns: String, whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNulls(vararg columns: Column, whereAllNull: Boolean = false): DataFrame<T> =
+public fun <T> DataFrame<T>.dropNulls(vararg columns: AnyColumnReference, whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumns() }
 
 public fun <T> DataFrame<T>.dropNulls(
-    columns: Iterable<Column>,
+    columns: Iterable<AnyColumnReference>,
     whereAllNull: Boolean = false
 ): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumnSet() }
@@ -620,10 +614,10 @@ public fun <T> DataFrame<T>.dropNA(vararg columns: KProperty<*>, whereAllNA: Boo
 public fun <T> DataFrame<T>.dropNA(vararg columns: String, whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNA(vararg columns: Column, whereAllNA: Boolean = false): DataFrame<T> =
+public fun <T> DataFrame<T>.dropNA(vararg columns: AnyColumnReference, whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNA(columns: Iterable<Column>, whereAllNA: Boolean = false): DataFrame<T> =
+public fun <T> DataFrame<T>.dropNA(columns: Iterable<AnyColumnReference>, whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { columns.toColumnSet() }
 
 public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false): DataFrame<T> =
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
index a81da1c9a..2a9375869 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
@@ -3,9 +3,9 @@ package org.jetbrains.kotlinx.dataframe.api
 import org.jetbrains.kotlinx.dataframe.AnyBaseCol
 import org.jetbrains.kotlinx.dataframe.AnyCol
 import org.jetbrains.kotlinx.dataframe.AnyColumnGroupAccessor
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.AnyFrame
 import org.jetbrains.kotlinx.dataframe.AnyRow
-import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsContainer
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -160,9 +160,9 @@ public class AddDsl<T>(@PublishedApi internal val df: DataFrame<T>) : ColumnsCon
     // TODO: support adding column into path
     internal val columns = mutableListOf<AnyCol>()
 
-    public fun add(column: Column): Boolean = columns.add(column.resolveSingle(df)!!.data)
+    public fun add(column: AnyColumnReference): Boolean = columns.add(column.resolveSingle(df)!!.data)
 
-    public operator fun Column.unaryPlus(): Boolean = add(this)
+    public operator fun AnyColumnReference.unaryPlus(): Boolean = add(this)
 
     public operator fun String.unaryPlus(): Boolean = add(df[this])
 
@@ -187,11 +187,11 @@ public class AddDsl<T>(@PublishedApi internal val df: DataFrame<T>) : ColumnsCon
     public inline infix fun <reified R> KProperty<R>.from(noinline expression: RowExpression<T, R>): Boolean =
         add(name, Infer.Nulls, expression)
 
-    public infix fun String.from(column: Column): Boolean = add(column.rename(this))
+    public infix fun String.from(column: AnyColumnReference): Boolean = add(column.rename(this))
     public inline infix fun <reified R> ColumnAccessor<R>.from(column: ColumnReference<R>): Boolean = name() from column
     public inline infix fun <reified R> KProperty<R>.from(column: ColumnReference<R>): Boolean = name from column
 
-    public infix fun Column.into(name: String): Boolean = add(rename(name))
+    public infix fun AnyColumnReference.into(name: String): Boolean = add(rename(name))
     public infix fun <R> ColumnReference<R>.into(column: ColumnAccessor<R>): Boolean = into(column.name())
     public infix fun <R> ColumnReference<R>.into(column: KProperty<R>): Boolean = into(column.name)
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
index 37cfdb6c9..e93f7c04d 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.AnyFrame
-import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
@@ -19,6 +19,6 @@ public fun <T, C> DataFrame<T>.countDistinct(columns: ColumnsSelector<T, C>): In
 
 public fun <T> DataFrame<T>.countDistinct(vararg columns: String): Int = countDistinct { columns.toColumns() }
 public fun <T, C> DataFrame<T>.countDistinct(vararg columns: KProperty<C>): Int = countDistinct { columns.toColumns() }
-public fun <T> DataFrame<T>.countDistinct(vararg columns: Column): Int = countDistinct { columns.toColumns() }
+public fun <T> DataFrame<T>.countDistinct(vararg columns: AnyColumnReference): Int = countDistinct { columns.toColumns() }
 
 // endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt
index be60508cd..f67760cf3 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -38,7 +38,7 @@ private val supportedClasses = setOf(Double::class, Float::class, Int::class, Lo
 public fun <T, C> DataFrame<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA, columns: ColumnsSelector<T, C>): DataFrame<T> =
     convert(columns).to { if (it.typeClass in supportedClasses) it.cast<Number?>().cumSum(skipNA) else it }
 public fun <T> DataFrame<T>.cumSum(vararg columns: String, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) { columns.toColumns() }
-public fun <T> DataFrame<T>.cumSum(vararg columns: Column, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) { columns.toColumns() }
+public fun <T> DataFrame<T>.cumSum(vararg columns: AnyColumnReference, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) { columns.toColumns() }
 public fun <T> DataFrame<T>.cumSum(vararg columns: KProperty<*>, skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) { columns.toColumns() }
 
 public fun <T> DataFrame<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) { allDfs() }
@@ -50,7 +50,7 @@ public fun <T> DataFrame<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataF
 public fun <T, G, C> GroupBy<T, G>.cumSum(skipNA: Boolean = defaultCumSumSkipNA, columns: ColumnsSelector<G, C>): GroupBy<T, G> =
     updateGroups { cumSum(skipNA, columns) }
 public fun <T, G> GroupBy<T, G>.cumSum(vararg columns: String, skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> = cumSum(skipNA) { columns.toColumns() }
-public fun <T, G> GroupBy<T, G>.cumSum(vararg columns: Column, skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> = cumSum(skipNA) { columns.toColumns() }
+public fun <T, G> GroupBy<T, G>.cumSum(vararg columns: AnyColumnReference, skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> = cumSum(skipNA) { columns.toColumns() }
 public fun <T, G> GroupBy<T, G>.cumSum(vararg columns: KProperty<*>, skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> = cumSum(skipNA) { columns.toColumns() }
 public fun <T, G> GroupBy<T, G>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> = cumSum(skipNA) { allDfs() }
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt
index c0c072c33..7c72af4e6 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
@@ -18,19 +18,19 @@ public fun <T> DataFrame<T>.distinct(vararg columns: KProperty<*>): DataFrame<T>
     set
 }
 public fun <T> DataFrame<T>.distinct(vararg columns: String): DataFrame<T> = distinct { columns.toColumns() }
-public fun <T> DataFrame<T>.distinct(vararg columns: Column): DataFrame<T> = distinct { columns.toColumns() }
+public fun <T> DataFrame<T>.distinct(vararg columns: AnyColumnReference): DataFrame<T> = distinct { columns.toColumns() }
 
 @JvmName("distinctT")
 public fun <T> DataFrame<T>.distinct(columns: Iterable<String>): DataFrame<T> = distinct { columns.toColumns() }
-public fun <T> DataFrame<T>.distinct(columns: Iterable<Column>): DataFrame<T> = distinct { columns.toColumnSet() }
+public fun <T> DataFrame<T>.distinct(columns: Iterable<AnyColumnReference>): DataFrame<T> = distinct { columns.toColumnSet() }
 
 public fun <T> DataFrame<T>.distinctBy(vararg columns: KProperty<*>): DataFrame<T> = distinctBy { columns.toColumns() }
 public fun <T> DataFrame<T>.distinctBy(vararg columns: String): DataFrame<T> = distinctBy { columns.toColumns() }
-public fun <T> DataFrame<T>.distinctBy(vararg columns: Column): DataFrame<T> = distinctBy { columns.toColumns() }
+public fun <T> DataFrame<T>.distinctBy(vararg columns: AnyColumnReference): DataFrame<T> = distinctBy { columns.toColumns() }
 
 @JvmName("distinctByT")
 public fun <T> DataFrame<T>.distinctBy(columns: Iterable<String>): DataFrame<T> = distinctBy { columns.toColumns() }
-public fun <T> DataFrame<T>.distinctBy(columns: Iterable<Column>): DataFrame<T> = distinctBy { columns.toColumnSet() }
+public fun <T> DataFrame<T>.distinctBy(columns: Iterable<AnyColumnReference>): DataFrame<T> = distinctBy { columns.toColumnSet() }
 
 public fun <T, C> DataFrame<T>.distinctBy(columns: ColumnsSelector<T, C>): DataFrame<T> {
     val cols = get(columns)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt
index 2c75681d3..c83f2db3f 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyColumnGroupAccessor
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
@@ -16,7 +16,7 @@ public data class GroupClause<T, C>(val df: DataFrame<T>, val columns: ColumnsSe
 
 public fun <T, C> DataFrame<T>.group(columns: ColumnsSelector<T, C>): GroupClause<T, C> = GroupClause(this, columns)
 public fun <T> DataFrame<T>.group(vararg columns: String): GroupClause<T, Any?> = group { columns.toColumns() }
-public fun <T> DataFrame<T>.group(vararg columns: Column): GroupClause<T, Any?> = group { columns.toColumns() }
+public fun <T> DataFrame<T>.group(vararg columns: AnyColumnReference): GroupClause<T, Any?> = group { columns.toColumns() }
 public fun <T> DataFrame<T>.group(vararg columns: KProperty<*>): GroupClause<T, Any?> = group { columns.toColumns() }
 
 @JvmName("intoString")
@@ -25,7 +25,7 @@ public fun <T> DataFrame<T>.group(vararg columns: KProperty<*>): GroupClause<T,
 public infix fun <T, C> GroupClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> String): DataFrame<T> = df.move(columns).under { column(it).toColumnAccessor() }
 
 @JvmName("intoColumn")
-public infix fun <T, C> GroupClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> Column): DataFrame<T> = df.move(columns).under(column)
+public infix fun <T, C> GroupClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> AnyColumnReference): DataFrame<T> = df.move(columns).under(column)
 public infix fun <T, C> GroupClause<T, C>.into(column: String): DataFrame<T> = into(columnGroup().named(column))
 public infix fun <T, C> GroupClause<T, C>.into(column: AnyColumnGroupAccessor): DataFrame<T> = df.move(columns).under(column)
 public infix fun <T, C> GroupClause<T, C>.into(column: KProperty<*>): DataFrame<T> = into(column.columnName)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
index b02c37e7b..d686dd3d6 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.AnyFrame
-import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
@@ -18,23 +18,18 @@ import kotlin.reflect.KProperty
 
 // region DataFrame
 
-public fun <T> DataFrame<T>.groupBy(moveToTop: Boolean = true, cols: ColumnsSelector<T, *>): GroupBy<T, T> =
-    groupByImpl(moveToTop, cols)
-
-public fun <T> DataFrame<T>.groupBy(cols: Iterable<Column>): GroupBy<T, T> = groupBy { cols.toColumnSet() }
+public fun <T> DataFrame<T>.groupBy(moveToTop: Boolean = true, cols: ColumnsSelector<T, *>): GroupBy<T, T> = groupByImpl(moveToTop, cols)
+public fun <T> DataFrame<T>.groupBy(cols: Iterable<AnyColumnReference>): GroupBy<T, T> = groupBy { cols.toColumnSet() }
 public fun <T> DataFrame<T>.groupBy(vararg cols: KProperty<*>): GroupBy<T, T> = groupBy { cols.toColumns() }
 public fun <T> DataFrame<T>.groupBy(vararg cols: String): GroupBy<T, T> = groupBy { cols.toColumns() }
-public fun <T> DataFrame<T>.groupBy(vararg cols: Column, moveToTop: Boolean = true): GroupBy<T, T> =
-    groupBy(moveToTop) { cols.toColumns() }
+public fun <T> DataFrame<T>.groupBy(vararg cols: AnyColumnReference, moveToTop: Boolean = true): GroupBy<T, T> = groupBy(moveToTop) { cols.toColumns() }
 
 // endregion
 
 // region Pivot
 
-public fun <T> Pivot<T>.groupBy(moveToTop: Boolean = true, columns: ColumnsSelector<T, *>): PivotGroupBy<T> =
-    (this as PivotImpl<T>).toGroupedPivot(moveToTop, columns)
-
-public fun <T> Pivot<T>.groupBy(vararg columns: Column): PivotGroupBy<T> = groupBy { columns.toColumns() }
+public fun <T> Pivot<T>.groupBy(moveToTop: Boolean = true, columns: ColumnsSelector<T, *>): PivotGroupBy<T> = (this as PivotImpl<T>).toGroupedPivot(moveToTop, columns)
+public fun <T> Pivot<T>.groupBy(vararg columns: AnyColumnReference): PivotGroupBy<T> = groupBy { columns.toColumns() }
 public fun <T> Pivot<T>.groupBy(vararg columns: String): PivotGroupBy<T> = groupBy { columns.toColumns() }
 public fun <T> Pivot<T>.groupBy(vararg columns: KProperty<*>): PivotGroupBy<T> = groupBy { columns.toColumns() }
 
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 5a01944c5..90ec36cf3 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
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyColumnGroupAccessor
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnSelector
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -21,20 +21,20 @@ public fun <T, C> DataFrame<T>.move(vararg cols: KProperty<C>): MoveClause<T, C>
 
 public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, columns: ColumnsSelector<T, *>): DataFrame<T> = move(columns).to(newColumnIndex)
 public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, vararg columns: String): DataFrame<T> = moveTo(newColumnIndex) { columns.toColumns() }
-public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, vararg columns: Column): DataFrame<T> = moveTo(newColumnIndex) { columns.toColumns() }
+public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, vararg columns: AnyColumnReference): DataFrame<T> = moveTo(newColumnIndex) { columns.toColumns() }
 public fun <T> DataFrame<T>.moveTo(newColumnIndex: Int, vararg columns: KProperty<*>): DataFrame<T> = moveTo(newColumnIndex) { columns.toColumns() }
 
 public fun <T> DataFrame<T>.moveToLeft(columns: ColumnsSelector<T, *>): DataFrame<T> = move(columns).toLeft()
 public fun <T> DataFrame<T>.moveToLeft(vararg columns: String): DataFrame<T> = moveToLeft { columns.toColumns() }
-public fun <T> DataFrame<T>.moveToLeft(vararg columns: Column): DataFrame<T> = moveToLeft { columns.toColumns() }
+public fun <T> DataFrame<T>.moveToLeft(vararg columns: AnyColumnReference): DataFrame<T> = moveToLeft { columns.toColumns() }
 public fun <T> DataFrame<T>.moveToLeft(vararg columns: KProperty<*>): DataFrame<T> = moveToLeft { columns.toColumns() }
 
 public fun <T> DataFrame<T>.moveToRight(columns: ColumnsSelector<T, *>): DataFrame<T> = move(columns).toRight()
 public fun <T> DataFrame<T>.moveToRight(vararg columns: String): DataFrame<T> = moveToRight { columns.toColumns() }
-public fun <T> DataFrame<T>.moveToRight(vararg columns: Column): DataFrame<T> = moveToRight { columns.toColumns() }
+public fun <T> DataFrame<T>.moveToRight(vararg columns: AnyColumnReference): DataFrame<T> = moveToRight { columns.toColumns() }
 public fun <T> DataFrame<T>.moveToRight(vararg columns: KProperty<*>): DataFrame<T> = moveToRight { columns.toColumns() }
 
-public fun <T, C> MoveClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> Column): DataFrame<T> = moveImpl(
+public fun <T, C> MoveClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> AnyColumnReference): DataFrame<T> = moveImpl(
     under = false,
     column
 )
@@ -42,7 +42,7 @@ public fun <T, C> MoveClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWi
 public fun <T, C> MoveClause<T, C>.into(column: String): DataFrame<T> = pathOf(column).let { path -> into { path } }
 
 public fun <T, C> MoveClause<T, C>.intoIndexed(
-    newPathExpression: ColumnsSelectionDsl<T>.(ColumnWithPath<C>, Int) -> Column
+    newPathExpression: ColumnsSelectionDsl<T>.(ColumnWithPath<C>, Int) -> AnyColumnReference
 ): DataFrame<T> {
     var counter = 0
     return into { col ->
@@ -52,7 +52,7 @@ public fun <T, C> MoveClause<T, C>.intoIndexed(
 
 public fun <T, C> MoveClause<T, C>.under(column: String): DataFrame<T> = pathOf(column).let { path -> under { path } }
 public fun <T, C> MoveClause<T, C>.under(column: AnyColumnGroupAccessor): DataFrame<T> = column.path().let { path -> under { path } }
-public fun <T, C> MoveClause<T, C>.under(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> Column): DataFrame<T> = moveImpl(
+public fun <T, C> MoveClause<T, C>.under(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> AnyColumnReference): DataFrame<T> = moveImpl(
     under = true,
     column
 )
@@ -66,7 +66,7 @@ public fun <T, C> MoveClause<T, C>.toTop(
 
 public fun <T, C> MoveClause<T, C>.after(column: ColumnSelector<T, *>): DataFrame<T> = afterOrBefore(column, true)
 public fun <T, C> MoveClause<T, C>.after(column: String): DataFrame<T> = after { column.toColumnAccessor() }
-public fun <T, C> MoveClause<T, C>.after(column: Column): DataFrame<T> = after { column }
+public fun <T, C> MoveClause<T, C>.after(column: AnyColumnReference): DataFrame<T> = after { column }
 public fun <T, C> MoveClause<T, C>.after(column: KProperty<*>): DataFrame<T> = after { column.toColumnAccessor() }
 
 // TODO: implement 'before'
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
index c4023430c..ed99ff907 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
@@ -41,17 +41,17 @@ public interface PivotDsl<out T> : ColumnsSelectionDsl<T> {
 
 public fun <T> DataFrame<T>.pivot(inward: Boolean? = null, columns: PivotColumnsSelector<T, *>): Pivot<T> = PivotImpl(this, columns, inward)
 public fun <T> DataFrame<T>.pivot(vararg columns: String, inward: Boolean? = null): Pivot<T> = pivot(inward) { columns.toColumns() }
-public fun <T> DataFrame<T>.pivot(vararg columns: Column, inward: Boolean? = null): Pivot<T> = pivot(inward) { columns.toColumns() }
+public fun <T> DataFrame<T>.pivot(vararg columns: AnyColumnReference, inward: Boolean? = null): Pivot<T> = pivot(inward) { columns.toColumns() }
 public fun <T> DataFrame<T>.pivot(vararg columns: KProperty<*>, inward: Boolean? = null): Pivot<T> = pivot(inward) { columns.toColumns() }
 
 public fun <T> DataFrame<T>.pivotMatches(inward: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T> = pivot(inward, columns).groupByOther().matches()
 public fun <T> DataFrame<T>.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
-public fun <T> DataFrame<T>.pivotMatches(vararg columns: Column, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
+public fun <T> DataFrame<T>.pivotMatches(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
 public fun <T> DataFrame<T>.pivotMatches(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
 
 public fun <T> DataFrame<T>.pivotCounts(inward: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T> = pivot(inward, columns).groupByOther().count()
 public fun <T> DataFrame<T>.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
-public fun <T> DataFrame<T>.pivotCounts(vararg columns: Column, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
+public fun <T> DataFrame<T>.pivotCounts(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
 public fun <T> DataFrame<T>.pivotCounts(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
 
 // endregion
@@ -59,18 +59,18 @@ public fun <T> DataFrame<T>.pivotCounts(vararg columns: KProperty<*>, inward: Bo
 // region GroupBy
 
 public fun <G> GroupBy<*, G>.pivot(inward: Boolean = true, columns: ColumnsSelector<G, *>): PivotGroupBy<G> = PivotGroupByImpl(this, columns, inward)
-public fun <G> GroupBy<*, G>.pivot(vararg columns: Column, inward: Boolean = true): PivotGroupBy<G> = pivot(inward) { columns.toColumns() }
+public fun <G> GroupBy<*, G>.pivot(vararg columns: AnyColumnReference, inward: Boolean = true): PivotGroupBy<G> = pivot(inward) { columns.toColumns() }
 public fun <G> GroupBy<*, G>.pivot(vararg columns: String, inward: Boolean = true): PivotGroupBy<G> = pivot(inward) { columns.toColumns() }
 public fun <G> GroupBy<*, G>.pivot(vararg columns: KProperty<*>, inward: Boolean = true): PivotGroupBy<G> = pivot(inward) { columns.toColumns() }
 
 public fun <G> GroupBy<*, G>.pivotMatches(inward: Boolean = true, columns: ColumnsSelector<G, *>): DataFrame<G> = pivot(inward, columns).matches()
 public fun <G> GroupBy<*, G>.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame<G> = pivotMatches(inward) { columns.toColumns() }
-public fun <G> GroupBy<*, G>.pivotMatches(vararg columns: Column, inward: Boolean = true): DataFrame<G> = pivotMatches(inward) { columns.toColumns() }
+public fun <G> GroupBy<*, G>.pivotMatches(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<G> = pivotMatches(inward) { columns.toColumns() }
 public fun <G> GroupBy<*, G>.pivotMatches(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<G> = pivotMatches(inward) { columns.toColumns() }
 
 public fun <G> GroupBy<*, G>.pivotCounts(inward: Boolean = true, columns: ColumnsSelector<G, *>): DataFrame<G> = pivot(inward, columns).count()
 public fun <G> GroupBy<*, G>.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame<G> = pivotCounts(inward) { columns.toColumns() }
-public fun <G> GroupBy<*, G>.pivotCounts(vararg columns: Column, inward: Boolean = true): DataFrame<G> = pivotCounts(inward) { columns.toColumns() }
+public fun <G> GroupBy<*, G>.pivotCounts(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<G> = pivotCounts(inward) { columns.toColumns() }
 public fun <G> GroupBy<*, G>.pivotCounts(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<G> = pivotCounts(inward) { columns.toColumns() }
 
 // endregion
@@ -80,17 +80,17 @@ public fun <G> GroupBy<*, G>.pivotCounts(vararg columns: KProperty<*>, inward: B
 public fun <T> AggregateGroupedDsl<T>.pivot(inward: Boolean = true, columns: ColumnsSelector<T, *>): PivotGroupBy<T> =
     PivotInAggregateImpl(this, columns, inward)
 public fun <T> AggregateGroupedDsl<T>.pivot(vararg columns: String, inward: Boolean = true): PivotGroupBy<T> = pivot(inward) { columns.toColumns() }
-public fun <T> AggregateGroupedDsl<T>.pivot(vararg columns: Column, inward: Boolean = true): PivotGroupBy<T> = pivot(inward) { columns.toColumns() }
+public fun <T> AggregateGroupedDsl<T>.pivot(vararg columns: AnyColumnReference, inward: Boolean = true): PivotGroupBy<T> = pivot(inward) { columns.toColumns() }
 public fun <T> AggregateGroupedDsl<T>.pivot(vararg columns: KProperty<*>, inward: Boolean = true): PivotGroupBy<T> = pivot(inward) { columns.toColumns() }
 
 public fun <T> AggregateGroupedDsl<T>.pivotMatches(inward: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T> = pivot(inward, columns).matches()
 public fun <T> AggregateGroupedDsl<T>.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
-public fun <T> AggregateGroupedDsl<T>.pivotMatches(vararg columns: Column, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
+public fun <T> AggregateGroupedDsl<T>.pivotMatches(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
 public fun <T> AggregateGroupedDsl<T>.pivotMatches(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T> = pivotMatches(inward) { columns.toColumns() }
 
 public fun <T> AggregateGroupedDsl<T>.pivotCounts(inward: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T> = pivot(inward, columns).matches()
 public fun <T> AggregateGroupedDsl<T>.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
-public fun <T> AggregateGroupedDsl<T>.pivotCounts(vararg columns: Column, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
+public fun <T> AggregateGroupedDsl<T>.pivotCounts(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
 public fun <T> AggregateGroupedDsl<T>.pivotCounts(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame<T> = pivotCounts(inward) { columns.toColumns() }
 
 // endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt
index b252b7ed0..85226f1c3 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.impl.api.removeImpl
@@ -13,12 +13,12 @@ import kotlin.reflect.KProperty
 public fun <T> DataFrame<T>.remove(columns: ColumnsSelector<T, *>): DataFrame<T> = removeImpl(allowMissingColumns = true, columns = columns).df
 public fun <T> DataFrame<T>.remove(vararg columns: KProperty<*>): DataFrame<T> = remove { columns.toColumns() }
 public fun <T> DataFrame<T>.remove(vararg columns: String): DataFrame<T> = remove { columns.toColumns() }
-public fun <T> DataFrame<T>.remove(vararg columns: Column): DataFrame<T> = remove { columns.toColumns() }
-public fun <T> DataFrame<T>.remove(columns: Iterable<Column>): DataFrame<T> = remove { columns.toColumnSet() }
+public fun <T> DataFrame<T>.remove(vararg columns: AnyColumnReference): DataFrame<T> = remove { columns.toColumns() }
+public fun <T> DataFrame<T>.remove(columns: Iterable<AnyColumnReference>): DataFrame<T> = remove { columns.toColumnSet() }
 
 public infix operator fun <T> DataFrame<T>.minus(columns: ColumnsSelector<T, *>): DataFrame<T> = remove(columns)
 public infix operator fun <T> DataFrame<T>.minus(column: String): DataFrame<T> = remove(column)
-public infix operator fun <T> DataFrame<T>.minus(column: Column): DataFrame<T> = remove(column)
-public infix operator fun <T> DataFrame<T>.minus(columns: Iterable<Column>): DataFrame<T> = remove(columns)
+public infix operator fun <T> DataFrame<T>.minus(column: AnyColumnReference): DataFrame<T> = remove(column)
+public infix operator fun <T> DataFrame<T>.minus(columns: Iterable<AnyColumnReference>): DataFrame<T> = remove(columns)
 
 // endregion
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 3277ec595..4a91e748f 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
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.impl.columnName
@@ -27,11 +27,11 @@ public fun <T> DataFrame<T>.select(vararg columns: String): DataFrame<T> =
 public fun <T> DataFrame<T>.select(columns: Iterable<String>): DataFrame<T> =
     columns.map { get(it) }.toDataFrame().cast()
 
-public fun <T> DataFrame<T>.select(vararg columns: Column): DataFrame<T> =
+public fun <T> DataFrame<T>.select(vararg columns: AnyColumnReference): DataFrame<T> =
     select { columns.toColumns() }
 
 @JvmName("selectAnyColumnReferenceIterable")
-public fun <T> DataFrame<T>.select(columns: Iterable<Column>): DataFrame<T> =
+public fun <T> DataFrame<T>.select(columns: Iterable<AnyColumnReference>): DataFrame<T> =
     select { columns.toColumnSet() }
 
 // endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
index 3bf5ec6d9..89d7581a2 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
@@ -1,8 +1,8 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyBaseCol
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.AnyFrame
-import org.jetbrains.kotlinx.dataframe.Column
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -41,7 +41,7 @@ public fun <T> DataFrame<T>.read(vararg columns: String): DataFrame<T> = unfold(
 public fun <T> DataFrame<T>.read(vararg columns: KProperty<*>): DataFrame<T> = unfold(*columns)
 
 @Deprecated("Replaced with `unfold` operation.", ReplaceWith("this.unfold(*columns)"), DeprecationLevel.ERROR)
-public fun <T> DataFrame<T>.read(vararg columns: Column): DataFrame<T> = unfold(*columns)
+public fun <T> DataFrame<T>.read(vararg columns: AnyColumnReference): DataFrame<T> = unfold(*columns)
 
 @JvmName("toDataFrameT")
 public fun <T> Iterable<DataRow<T>>.toDataFrame(): DataFrame<T> {
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/unfold.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/unfold.kt
index 54f59bf95..1ad347213 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/unfold.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/unfold.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyCol
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -25,4 +25,4 @@ public inline fun <reified T> DataColumn<T>.unfold(): AnyCol =
 public fun <T> DataFrame<T>.unfold(columns: ColumnsSelector<T, *>): DataFrame<T> = replace(columns).with { it.unfold() }
 public fun <T> DataFrame<T>.unfold(vararg columns: String): DataFrame<T> = unfold { columns.toColumns() }
 public fun <T> DataFrame<T>.unfold(vararg columns: KProperty<*>): DataFrame<T> = unfold { columns.toColumns() }
-public fun <T> DataFrame<T>.unfold(vararg columns: Column): DataFrame<T> = unfold { columns.toColumns() }
+public fun <T> DataFrame<T>.unfold(vararg columns: AnyColumnReference): DataFrame<T> = unfold { columns.toColumns() }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt
index 65e0f820c..7633687ba 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
@@ -15,7 +15,7 @@ public fun <T, C> DataFrame<T>.ungroup(columns: ColumnsSelector<T, C>): DataFram
 }
 
 public fun <T> DataFrame<T>.ungroup(vararg columns: String): DataFrame<T> = ungroup { columns.toColumns() }
-public fun <T> DataFrame<T>.ungroup(vararg columns: Column): DataFrame<T> = ungroup { columns.toColumns() }
+public fun <T> DataFrame<T>.ungroup(vararg columns: AnyColumnReference): DataFrame<T> = ungroup { columns.toColumns() }
 public fun <T> DataFrame<T>.ungroup(vararg columns: KProperty<*>): DataFrame<T> = ungroup { columns.toColumns() }
 
 // endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index 696b2bb46..e89c838b6 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -5,6 +5,7 @@ import org.jetbrains.kotlinx.dataframe.api.Update.Usage
 import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.documentation.*
+import org.jetbrains.kotlinx.dataframe.impl.api.asFrameImpl
 import org.jetbrains.kotlinx.dataframe.impl.api.updateImpl
 import org.jetbrains.kotlinx.dataframe.impl.api.updateWithValuePerColumnImpl
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
@@ -14,12 +15,12 @@ import kotlin.reflect.KProperty
 
 /**
  * ## The Update Operation
- * 
+ *
  * Returns the [DataFrame] with changed values in some cells
  * (column types can not be changed).
- * 
+ *
  * Check out the [`update` Operation Usage][Usage].
- * 
+ *
  * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html)
  */
 public data class Update<T, C>(
@@ -37,13 +38,13 @@ public data class Update<T, C>(
 
     /**
      * ## [update][update] Operation Usage
-     * 
+     *
      * [update][update] `{ `[columns][SelectingColumns]` }`
-     * 
+     *
      * - `[.`[where][Update.where]` { `[rowValueCondition][SelectingRows.RowValueCondition.WithExample]` } ]`
-     * 
+     *
      * - `[.`[at][Update.at]` (`[rowIndices][CommonUpdateAtFunctionDoc.RowIndicesParam]`) ]`
-     * 
+     *
      * - `.`[with][Update.with]` { `[rowExpression][ExpressionsGivenRow.RowValueExpression.WithExample]` }
      *   | .`[notNull][Update.notNull]` { `[rowExpression][ExpressionsGivenRow.RowValueExpression.WithExample]` }
      *   | .`[perCol][Update.perCol]` { `[colExpression][ExpressionsGivenColumn.ColumnExpression.WithExample]` }
@@ -52,6 +53,7 @@ public data class Update<T, C>(
      *   | .`[withNull][Update.withNull]`()
      *   | .`[withZero][Update.withZero]`()
      *   | .`[asFrame][Update.asFrame]` { `[dataFrameExpression][ExpressionsGivenDataFrame.DataFrameExpression.WithExample]` }`
+     *
      */
     public interface Usage
 
@@ -73,17 +75,16 @@ public data class Update<T, C>(
 
 // region update
 
-
 private interface SetSelectingColumnsOperationArg
 
 /**
  * ## The Update Operation
- * 
+ *
  * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
  * (column types can not be changed).
- * 
+ *
  * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
- * 
+ *
  * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
@@ -100,29 +101,29 @@ private interface UpdateWithNote
 
 /**
  * ## The Update Operation
- * 
+ *
  * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
  * (column types can not be changed).
- * 
+ *
  * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
- * 
+ *
  * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
  * ## This Update Overload
  * Select or express columns using the Column(s) Selection DSL.
  * (Any [Access Api][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
- * 
+ *
  * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
  * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
  * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
- * 
+ *
  * For example:
- * 
+ *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { length `[and][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.and]` age }`
- * 
+ *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
- * 
+ *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<Double>() }`
  *  
  * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
@@ -132,21 +133,21 @@ public fun <T, C> DataFrame<T>.update(columns: ColumnsSelector<T, C>): Update<T,
 
 /**
  * ## The Update Operation
- * 
+ *
  * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
  * (column types can not be changed).
- * 
+ *
  * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
- * 
+ *
  * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
  * ## This Update Overload
  * Select columns using their [column names][String]
  * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
- * 
+ *
  * For example:
- * 
+ *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`("length", "age")`
  *  
  * ## Optional
@@ -158,23 +159,23 @@ public fun <T> DataFrame<T>.update(vararg columns: String): Update<T, Any?> = up
 
 /**
  * ## The Update Operation
- * 
+ *
  * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
  * (column types can not be changed).
- * 
+ *
  * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
- * 
+ *
  * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
  * ## This Update Overload
  * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
- * 
+ *
  * For example:
  * ```kotlin
  * data class Person(val length: Double, val age: Double)
  * ```
- * 
+ *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(Person::length, Person::age)`
  *  
  * ## Optional
@@ -186,25 +187,25 @@ public fun <T, C> DataFrame<T>.update(vararg columns: KProperty<C>): Update<T, C
 
 /**
  * ## The Update Operation
- * 
+ *
  * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
  * (column types can not be changed).
- * 
+ *
  * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
- * 
+ *
  * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
  * ## This Update Overload
  * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
  * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
- * 
+ *
  * For example:
- * 
+ *
  * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
- * 
+ *
  * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
- * 
+ *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(length, age)`
  *  
  * ## Optional
@@ -223,20 +224,18 @@ public fun <T, C> DataFrame<T>.update(columns: Iterable<ColumnReference<C>>): Up
 
 // endregion
 
-/**
- * ## Where
+/** ## Where
  * Filter or find rows to operate on after [selecting columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] using a
  * [row value filter][org.jetbrains.kotlinx.dataframe.RowValueFilter].
- * 
+ *
  * For example:
- * 
- * `df.`[update][update]` { length }.`[where][where]` { it > 10.0 }`
- * 
- * `df.`[update][update]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }.`[where][where]` { `[index][org.jetbrains.kotlinx.dataframe.index]`() > 4 && city != "Paris" }`
- * 
- * 
- * 
- * 
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { length }.`[where][org.jetbrains.kotlinx.dataframe.api.where]` { it > 10.0 }`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }.`[where][org.jetbrains.kotlinx.dataframe.api.where]` { `[index][org.jetbrains.kotlinx.dataframe.index]`() > 4 && city != "Paris" }`
+ *  
+ *
+ *
  * @param predicate The [row value filter][RowValueFilter] to select the rows to update.
  */
 public fun <T, C> Update<T, C>.where(predicate: RowValueFilter<T, C>): Update<T, C> =
@@ -264,19 +263,18 @@ private interface CommonUpdateAtFunctionDoc {
 /**
  * ## At
  * Only update the columns at certain given [row indices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]:
- * 
+ *
  * Either a [Collection][Collection]<[Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
- * 
+ *
  * For example:
- * 
+ *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { city }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(5..10).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Paris" }`
- * 
+ *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(1, 2, 3, 4).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Empty" }`
- * 
+ *
  * ## This At Overload
- * 
- * Provide a [Collection]<[Int]> of row indices to update.
- * 
+ * Provide a [Collection][Collection]<[Int][Int]> of row indices to update.
+ *
  * @param rowIndices The indices of the rows to update. Either a [Collection][Collection]<[Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
  */
 public fun <T, C> Update<T, C>.at(rowIndices: Collection<Int>): Update<T, C> = where { index in rowIndices }
@@ -284,19 +282,18 @@ public fun <T, C> Update<T, C>.at(rowIndices: Collection<Int>): Update<T, C> = w
 /**
  * ## At
  * Only update the columns at certain given [row indices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]:
- * 
+ *
  * Either a [Collection][Collection]<[Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
- * 
+ *
  * For example:
- * 
+ *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { city }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(5..10).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Paris" }`
- * 
+ *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(1, 2, 3, 4).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Empty" }`
- * 
+ *
  * ## This At Overload
- * 
  * Provide a `vararg` of [Ints][Int] of row indices to update.
- * 
+ *
  * @param rowIndices The indices of the rows to update. Either a [Collection][Collection]<[Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
  */
 public fun <T, C> Update<T, C>.at(vararg rowIndices: Int): Update<T, C> = at(rowIndices.toSet())
@@ -304,38 +301,34 @@ public fun <T, C> Update<T, C>.at(vararg rowIndices: Int): Update<T, C> = at(row
 /**
  * ## At
  * Only update the columns at certain given [row indices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]:
- * 
+ *
  * Either a [Collection][Collection]<[Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
- * 
+ *
  * For example:
- * 
+ *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { city }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(5..10).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Paris" }`
- * 
+ *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(1, 2, 3, 4).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Empty" }`
- * 
+ *
  * ## This At Overload
- * 
- * Provide an [IntRange] of row indices to update.
- * 
+ * Provide an [IntRange][IntRange] of row indices to update.
+ *
  * @param rowRange The indices of the rows to update. Either a [Collection][Collection]<[Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
  */
 public fun <T, C> Update<T, C>.at(rowRange: IntRange): Update<T, C> = where { index in rowRange }
 
-/**
- * ## Per Row Col
+/** ## Per Row Col
  * Provide a new value for every selected cell given both its row and column using a [row-column expression][org.jetbrains.kotlinx.dataframe.RowColumnExpression].
- * 
  * For example:
- * 
- * `df.`[update][update]` { age }.`[perRowCol][perRowCol]` { row, col ->`
- * 
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { age ` { row, col ->`
+ *
  * `row.age / col.`[mean][org.jetbrains.kotlinx.dataframe.DataColumn.mean]`(skipNA = true)`
- * 
+ *
  * `}`
- * 
- * 
- * 
- * 
+ *
+ *  .`[perRowCol][org.jetbrains.kotlinx.dataframe.api.perRowCol]}
+ *
  * ## See Also
  *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
  *  - [Update per col][org.jetbrains.kotlinx.dataframe.api.Update.perCol] to provide a new value for every selected cell giving its column.
@@ -353,25 +346,23 @@ private interface SeeAlsoPerRowCol
  */ // doc processor plugin does not work with type aliases yet
 public typealias UpdateExpression<T, C, R> = AddDataRow<T>.(C) -> R
 
-/**
- * ## With
+/** ## With
  * Provide a new value for every selected cell given its row and its previous value using a
  * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
- * 
+ *
  * For example:
- * 
+ *
  * `df.`[update][update]` { city }.`[with][with]` { name.firstName + " from " + it }`
- * 
+ *
  * `df.`[update][update]` { city }.`[with][with]` { it.uppercase() }`
- * 
- * 
- * 
+ *
+ *
+ *
  * ## Note
  * [update with][org.jetbrains.kotlinx.dataframe.api.Update.with]- and [add][org.jetbrains.kotlinx.dataframe.api.add]-like expressions use [AddDataRow][org.jetbrains.kotlinx.dataframe.api.AddDataRow] instead of [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as the DSL's receiver type.
  * This is an extension to [RowValueExpression][org.jetbrains.kotlinx.dataframe.RowValueExpression] and
  * [RowExpression][org.jetbrains.kotlinx.dataframe.RowExpression] that provides access to
- * the modified/generated value of the preceding row ([AddDataRow.newValue][org.jetbrains.kotlinx.dataframe.api.AddDataRow.newValue]).
- * ## See Also
+ * the modified/generated value of the preceding row ([AddDataRow.newValue][org.jetbrains.kotlinx.dataframe.api.AddDataRow.newValue]). ## See Also
  * - [Update per col][org.jetbrains.kotlinx.dataframe.api.Update.perCol] to provide a new value for every selected cell giving its column.
  * - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
  * @param expression The [Row Value Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample] to update the rows with.
@@ -384,21 +375,19 @@ public infix fun <T, C> Update<T, C>.with(expression: UpdateExpression<T, C, C?>
 /** [Update with][Update.with] to provide a new value for every selected cell giving its row. */
 private interface SeeAlsoWith
 
-/**
- * ## As Frame
- * 
+/** ## As Frame
+ *
  * Updates selected [column group][ColumnGroup] as a [DataFrame] with the given [expression].
- * 
+ *
  * Provide a new value for every selected data frame using a [dataframe expression][org.jetbrains.kotlinx.dataframe.DataFrameExpression].
- * 
  * For example:
- * 
- * `df.`[update][update]` { name }.`[asFrame][asFrame]` { `[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { lastName } }`
- * 
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name ` { `[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { lastName } }`
+ * .`[asFrame][org.jetbrains.kotlinx.dataframe.api.asFrame]}
  * @param expression The [Data Frame Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.DataFrameExpression] to replace the selected column group with.
  */
 public infix fun <T, C, R> Update<T, DataRow<C>>.asFrame(expression: DataFrameExpression<C, DataFrame<R>>): DataFrame<T> =
-    df.replace(columns).with { it.asColumnGroup().let { expression(it, it) }.asColumnGroup(it.name()) }
+    asFrameImpl(expression)
 
 @Deprecated(
     "Useless unless in combination with `withValue(null)`, but then users can just use `with { null }`...",
@@ -406,14 +395,13 @@ public infix fun <T, C, R> Update<T, DataRow<C>>.asFrame(expression: DataFrameEx
 )
 public fun <T, C> Update<T, C>.asNullable(): Update<T, C?> = this as Update<T, C?>
 
-/**
- * ## Per Col
- * 
+/** ## Per Col
+ *
  * Per Col can be used for two different types of operations:
  *  - Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
  *  - Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
  *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
- * 
+ *
  * ## See Also
  *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
  *  - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
@@ -427,53 +415,50 @@ private interface UpdatePerColMap
 
 /**
  * ## Per Col
- * 
+ *
  * Per Col can be used for two different types of operations:
  *  - Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
  *  - Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
  *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
- * 
+ *
  * ## See Also
  *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
  *  - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
  * ## This Per Col Overload
  * Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
  *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
- * 
  * For example:
- * 
- * `val defaults = {@includeArg [CommonUpdatePerColMapDoc]}`
- * 
- * `df.`[update][update]` { name and age }.`[where][Update.where]` { ... }.`[perCol][perCol]`(defaults)`
- * 
+ *
+ * `val defaults = {@includeArg [CommonUpdatePerColMapDoc][org.jetbrains.kotlinx.dataframe.api.CommonUpdatePerColMapDoc]}`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name and age }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { ... }.`[perCol][org.jetbrains.kotlinx.dataframe.api.perCol]`(defaults)`
+ *
  * @throws IllegalArgumentException if a value for a selected cell's column is not defined in [values\].
  */
 private interface CommonUpdatePerColMapDoc
 
 /**
  * ## Per Col
- * 
+ *
  * Per Col can be used for two different types of operations:
  *  - Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
  *  - Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
  *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
- * 
+ *
  * ## See Also
  *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
  *  - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
  * ## This Per Col Overload
  * Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
  *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
- * 
  * For example:
- * 
+ *
  * `val defaults = `[mapOf][mapOf]`("name" to "Empty", "age" to 0)`
- * 
+ *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name and age }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { ... }.`[perCol][org.jetbrains.kotlinx.dataframe.api.perCol]`(defaults)`
- * 
- * @throws IllegalArgumentException if a value for a selected cell's column is not defined in [values][values].
- * 
- * 
+ *
+ * @throws IllegalArgumentException if a value for a selected cell's column is not defined in [values][values]. 
+ *
  * @param values The [Map]<[String], Value> to provide a new value for every selected cell.
  *   For each selected column, there must be a value in the map with the same name.
  */
@@ -483,60 +468,57 @@ public fun <T, C> Update<T, C>.perCol(values: Map<String, C>): DataFrame<T> = up
 
 /**
  * ## Per Col
- * 
+ *
  * Per Col can be used for two different types of operations:
  *  - Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
  *  - Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
  *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
- * 
+ *
  * ## See Also
  *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
  *  - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
  * ## This Per Col Overload
  * Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
  *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
- * 
  * For example:
- * 
- * `val defaults = df.`[getRows][DataFrame.getRows]`(`[listOf][listOf]`(0))`
- * 
- *   `.`[update][update]` { name }.`[with][Update.with]` { "Empty" }`
- * 
- *   `.`[update][update]` { age }.`[with][Update.with]` { 0 }`
- * 
- *   `.first()`
- * 
+ *
+ * `val defaults = df.`[getRows][org.jetbrains.kotlinx.dataframe.DataFrame.getRows]`(`[listOf][listOf]`(0))`
+ *
+ *   `.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name `
+ *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name and age }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { ... }.`[perCol][org.jetbrains.kotlinx.dataframe.api.perCol]`(defaults)`
- * 
- * @throws IllegalArgumentException if a value for a selected cell's column is not defined in [values][values].
- * 
- * 
- * @param values The [DataRow] to provide a new value for every selected cell.
+ *
+ * @throws IllegalArgumentException if a value for a selected cell's column is not defined in [values][values]. .`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { "Empty" }`
+ *
+ *   `.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { age }.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { 0 }`
+ *
+ *   `.first()}
+ *
+ * @param values The [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] to provide a new value for every selected cell.
  */
 public fun <T, C> Update<T, C>.perCol(values: AnyRow): DataFrame<T> = perCol(values.toMap() as Map<String, C>)
 
 /**
  * ## Per Col
- * 
+ *
  * Per Col can be used for two different types of operations:
  *  - Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
  *  - Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
  *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
- * 
+ *
  * ## See Also
  *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
  *  - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
  * ## This Per Col Overload
  * Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
- * 
+ *
  * For example:
- * 
- * `df.`[update][update]` { age }.`[perCol][perCol]` { `[mean][org.jetbrains.kotlinx.dataframe.DataColumn.mean]`(skipNA = true) }`
- * 
- * `df.`[update][update]` { age }.`[perCol][perCol]` { `[count][org.jetbrains.kotlinx.dataframe.DataColumn.count]` { it > 10 } }`
- * 
- * 
- * 
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { age ` { `[mean][org.jetbrains.kotlinx.dataframe.DataColumn.mean]`(skipNA = true) }`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { age ` { `[count][org.jetbrains.kotlinx.dataframe.DataColumn.count]` { it > 10 } }`
+ *  .`[perCol][org.jetbrains.kotlinx.dataframe.api.perCol]}
+ *
  * @param valueSelector The [Column Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpression] to provide a new value for every selected cell giving its column.
  */
 public fun <T, C> Update<T, C>.perCol(valueSelector: ColumnExpression<C, C>): DataFrame<T> =
@@ -552,49 +534,47 @@ internal infix fun <T, C> RowValueFilter<T, C>?.and(other: RowValueFilter<T, C>)
     return { thisExp(this, it) && other(this, it) }
 }
 
-/**
- * ## Not Null
- * 
+/** ## Not Null
+ *
  * Selects only the rows where the values in the selected columns are not null.
- * 
+ *
  * Shorthand for: [update][org.jetbrains.kotlinx.dataframe.api.update]` { ... }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it != null }`
- * 
+ *
  * For example:
- * 
+ *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Number][Number]`?>() }.`[notNull][org.jetbrains.kotlinx.dataframe.api.notNull]`()`.[perCol][org.jetbrains.kotlinx.dataframe.api.Update.perCol] `{ `[mean][org.jetbrains.kotlinx.dataframe.api.mean]`() }`
- * 
+ *
  * ### Optional
  * Provide an [expression][expression] to update the rows with.
  * This combines [with][org.jetbrains.kotlinx.dataframe.api.Update.with] with [notNull][org.jetbrains.kotlinx.dataframe.api.notNull].
- * 
+ *
  * For example:
- * 
+ *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { city }.`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { it.`[toUpperCase][String.toUpperCase]`() }`
- * 
- * @param expression Optional [Row Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowExpression.WithExample] to update the rows with.
- */
+ *
+ * @param expression Optional [Row Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowExpression.WithExample] to update the rows with. */
 public fun <T, C> Update<T, C?>.notNull(): Update<T, C> =
     where { it != null } as Update<T, C>
 
 /**
  * ## Not Null
- * 
+ *
  * Selects only the rows where the values in the selected columns are not null.
- * 
+ *
  * Shorthand for: [update][update]` { ... }.`[where][Update.where]` { it != null }`
- * 
+ *
  * For example:
- * 
+ *
  * `df.`[update][update]` { `[colsOf][colsOf]`<`[Number][Number]`?>() }.`[notNull][notNull]`()`.[perCol][Update.perCol] `{ `[mean][mean]`() }`
- * 
+ *
  * ### Optional
  * Provide an [expression] to update the rows with.
  * This combines [with][Update.with] with [notNull].
- * 
+ *
  * For example:
- * 
+ *
  * `df.`[update][update]` { city }.`[notNull][Update.notNull]` { it.`[toUpperCase][String.toUpperCase]`() }`
- * 
+ *
  * @param expression Optional [Row Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowExpression.WithExample] to update the rows with.
  */
 public fun <T, C> Update<T, C?>.notNull(expression: UpdateExpression<T, C, C>): DataFrame<T> =
@@ -602,32 +582,30 @@ public fun <T, C> Update<T, C?>.notNull(expression: UpdateExpression<T, C, C>):
 
 /**
  * ## The Update Operation
- * 
+ *
  * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
  * (column types can not be changed).
- * 
+ *
  * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
- * 
+ *
  * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
- * ## This Update Overload
- * ### This overload is a combination of [update] and [with][Update.with].
- * 
+ * ## This Update Overload ### This overload is a combination of [update][org.jetbrains.kotlinx.dataframe.api.update] and [with][org.jetbrains.kotlinx.dataframe.api.Update.with].
+ *
  * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
  * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
- * 
  * Provide a new value for every selected cell given its row and its previous value using a
  * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
- * 
+ *
  * For example:
- * 
- * `df.`[update][update]`("city")` ` { name.firstName + " from " + it }`
- * 
- * `df.`[update][update]`("city")` ` { it.uppercase() }`
- * 
- * 
- * 
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`("city")` ` { name.firstName + " from " + it }`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`("city")` ` { it.uppercase() }`
+ *
+ *
+ *
  * @param columns The [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample] of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
  * @param expression The [Row Value Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample] to update the rows with.
  */
@@ -640,31 +618,29 @@ public fun <T, C> DataFrame<T>.update(
 
 /**
  * ## The Update Operation
- * 
+ *
  * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
  * (column types can not be changed).
- * 
+ *
  * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
- * 
+ *
  * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
- * ## This Update Overload
- * ### This overload is a combination of [update] and [with][Update.with].
- * 
+ * ## This Update Overload ### This overload is a combination of [update][org.jetbrains.kotlinx.dataframe.api.update] and [with][org.jetbrains.kotlinx.dataframe.api.Update.with].
+ *
  * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
- * 
  * Provide a new value for every selected cell given its row and its previous value using a
  * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
- * 
+ *
  * For example:
- * 
- * `df.`[update][update]`("city")` ` { name.firstName + " from " + it }`
- * 
- * `df.`[update][update]`("city")` ` { it.uppercase() }`
- * 
- * 
- * 
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`("city")` ` { name.firstName + " from " + it }`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`("city")` ` { it.uppercase() }`
+ *
+ *
+ *
  * @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] corresponding to columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
  * @param expression The [Row Value Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample] to update the rows with.
  */
@@ -677,32 +653,30 @@ public fun <T, C> DataFrame<T>.update(
 
 /**
  * ## The Update Operation
- * 
+ *
  * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
  * (column types can not be changed).
- * 
+ *
  * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
- * 
+ *
  * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
- * ## This Update Overload
- * ### This overload is a combination of [update] and [with][Update.with].
- * 
+ * ## This Update Overload ### This overload is a combination of [update][org.jetbrains.kotlinx.dataframe.api.update] and [with][org.jetbrains.kotlinx.dataframe.api.Update.with].
+ *
  * Select columns using their [column names][String]
  * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
- * 
  * Provide a new value for every selected cell given its row and its previous value using a
  * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
- * 
+ *
  * For example:
- * 
- * `df.`[update][update]`("city")` ` { name.firstName + " from " + it }`
- * 
- * `df.`[update][update]`("city")` ` { it.uppercase() }`
- * 
- * 
- * 
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`("city")` ` { name.firstName + " from " + it }`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`("city")` ` { it.uppercase() }`
+ *
+ *
+ *
  * @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] belonging to this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
  * @param expression The [Row Value Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample] to update the rows with.
  */
@@ -715,9 +689,9 @@ public fun <T> DataFrame<T>.update(
 
 /**
  * Specific version of [with] that simply sets the value of each selected row to {@includeArg [CommonSpecificWithDocFirstArg]}.
- * 
+ *
  * For example:
- * 
+ *
  * `df.`[update][update]` { id }.`[where][Update.where]` { it < 0 }.`{@includeArg [CommonSpecificWithDocSecondArg]}`
  */
 private interface CommonSpecificWithDoc
@@ -731,33 +705,34 @@ private interface CommonSpecificWithDocSecondArg
 /**
  * ## With Null
  * Specific version of [with][org.jetbrains.kotlinx.dataframe.api.with] that simply sets the value of each selected row to `null`.
- * 
+ *
  * For example:
- * 
- * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { id }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it < 0 }.`[withNull][withNull]`()`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { id }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it < 0 }.`[withNull][org.jetbrains.kotlinx.dataframe.api.withNull]`()` 
+ *
  */
 public fun <T, C> Update<T, C>.withNull(): DataFrame<T> = with { null }
 
 /**
  * ## With Zero
  * Specific version of [with][org.jetbrains.kotlinx.dataframe.api.with] that simply sets the value of each selected row to `0`.
- * 
+ *
  * For example:
- * 
- * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { id }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it < 0 }.`[withZero][withZero]`()`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { id }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it < 0 }.`[withZero][org.jetbrains.kotlinx.dataframe.api.withZero]`()` 
+ *
  */
 public fun <T, C> Update<T, C>.withZero(): DataFrame<T> = updateWithValuePerColumnImpl { 0 as C }
 
 /**
  * ## With Value
- * Specific version of [with][org.jetbrains.kotlinx.dataframe.api.with] that simply sets the value of each selected row to [value].
- * 
+ * Specific version of [with][org.jetbrains.kotlinx.dataframe.api.with] that simply sets the value of each selected row to [value][org.jetbrains.kotlinx.dataframe.api.value].
+ *
  * For example:
- * 
- * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { id }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it < 0 }.`[withValue][withValue]`(-1)`
- * 
- * 
- * 
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { id }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it < 0 }.`[withValue][org.jetbrains.kotlinx.dataframe.api.withValue]`(-1)` 
+ *
+ *
  * @param value The value to set the selected rows to. In contrast to [with][Update.with], this must be the same exact type.
  */
 public infix fun <T, C> Update<T, C>.withValue(value: C): DataFrame<T> = with { value }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt
index 7de0675a8..fcfef0e04 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -70,7 +70,7 @@ public fun <T> DataFrame<T>.valueCounts(
     resultColumn: String = defaultCountColumnName
 ): DataFrame<T> = valueCounts(sort, ascending, dropNA, resultColumn) { columns.toColumns() }
 public fun <T> DataFrame<T>.valueCounts(
-    vararg columns: Column,
+    vararg columns: AnyColumnReference,
     sort: Boolean = true,
     ascending: Boolean = false,
     dropNA: Boolean = true,
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/values.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/values.kt
index 417487f73..a6e949a9e 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/values.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/values.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
@@ -24,7 +24,7 @@ public fun <T> DataFrame<T>.valuesNotNull(byRow: Boolean = false): Sequence<Any>
 
 // region GroupBy
 
-public fun <T> Grouped<T>.values(vararg columns: Column, dropNA: Boolean = false, distinct: Boolean = false): DataFrame<T> = values(dropNA, distinct) { columns.toColumns() }
+public fun <T> Grouped<T>.values(vararg columns: AnyColumnReference, dropNA: Boolean = false, distinct: Boolean = false): DataFrame<T> = values(dropNA, distinct) { columns.toColumns() }
 public fun <T> Grouped<T>.values(vararg columns: String, dropNA: Boolean = false, distinct: Boolean = false): DataFrame<T> = values(dropNA, distinct) { columns.toColumns() }
 public fun <T> Grouped<T>.values(
     dropNA: Boolean = false,
@@ -40,7 +40,7 @@ public fun <T> Grouped<T>.values(dropNA: Boolean = false, distinct: Boolean = fa
 public fun <T, G> ReducedGroupBy<T, G>.values(): DataFrame<G> = values(groupBy.remainingColumnsSelector())
 
 public fun <T, G> ReducedGroupBy<T, G>.values(
-    vararg columns: Column
+    vararg columns: AnyColumnReference
 ): DataFrame<G> = values { columns.toColumns() }
 
 public fun <T, G> ReducedGroupBy<T, G>.values(
@@ -66,7 +66,7 @@ public fun <T> Pivot<T>.values(
     columns: ColumnsForAggregateSelector<T, *>
 ): DataRow<T> = delegate { values(dropNA, distinct, separate, columns) }
 public fun <T> Pivot<T>.values(
-    vararg columns: Column,
+    vararg columns: AnyColumnReference,
     dropNA: Boolean = false,
     distinct: Boolean = false,
     separate: Boolean = false
@@ -95,7 +95,7 @@ public fun <T> ReducedPivot<T>.values(
 ): DataRow<T> = pivot.delegate { reduce(reducer).values(separate = separate) }
 
 public fun <T> ReducedPivot<T>.values(
-    vararg columns: Column,
+    vararg columns: AnyColumnReference,
     separate: Boolean = false
 ): DataRow<T> = values(separate) { columns.toColumns() }
 
@@ -121,7 +121,7 @@ public fun <T> ReducedPivot<T>.values(
 public fun <T> PivotGroupBy<T>.values(dropNA: Boolean = false, distinct: Boolean = false, separate: Boolean = false): DataFrame<T> = values(dropNA, distinct, separate, remainingColumnsSelector())
 
 public fun <T> PivotGroupBy<T>.values(
-    vararg columns: Column,
+    vararg columns: AnyColumnReference,
     dropNA: Boolean = false,
     distinct: Boolean = false,
     separate: Boolean = false
@@ -155,7 +155,7 @@ public fun <T> ReducedPivotGroupBy<T>.values(
 ): DataFrame<T> = values(separate, pivot.remainingColumnsSelector())
 
 public fun <T> ReducedPivotGroupBy<T>.values(
-    vararg columns: Column,
+    vararg columns: AnyColumnReference,
     separate: Boolean = false
 ): DataFrame<T> = values(separate) { columns.toColumns() }
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/with.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/with.kt
index 7b5942b83..04ae27ae3 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/with.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/with.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.RowExpression
@@ -37,7 +37,7 @@ public inline fun <T, reified V> ReducedPivotGroupBy<T>.with(noinline expression
     return pivot.aggregate {
         val value = reducer(this)?.let {
             val value = expression(it, it)
-            if (value is Column) it[value]
+            if (value is AnyColumnReference) it[value]
             else value
         }
         internal().yield(emptyPath(), value, type)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
index c3ab1880c..dae844ab9 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
@@ -6,20 +6,20 @@ import org.jetbrains.kotlinx.dataframe.documentation.samples.ApiLevels as ApiLev
  * By nature data frames are dynamic objects, column labels depend on the input source and also new columns could be added
  * or deleted while wrangling. Kotlin, in contrast, is a statically typed language and all types are defined and verified
  * ahead of execution. That's why creating a flexible, handy, and, at the same time, safe API to a data frame is tricky.
- * 
+ *
  * In `Kotlin DataFrame` we provide four different ways to access columns, and, while they are essentially different, they
  * look pretty similar in the data wrangling DSL. These include:
  *  - [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi]
  *  - [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
  *  - [Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]
  *  - [String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]
- * 
+ *
  * For more information: [See Access APIs on the documentation website.](https://kotlin.github.io/dataframe/apilevels.html)
+ *
  */
 internal interface AccessApi {
 
-    /**
-     * API:
+    /** API:
      * - [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi]
      * - [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
      * - [Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]
@@ -31,9 +31,9 @@ internal interface AccessApi {
      * String API.
      * In this [AccessApi], columns are accessed by a [String] representing their name.
      * Type-checking is done at runtime, name-checking too.
-     * 
+     *
      * For more information: [See String API on the documentation website.](https://kotlin.github.io/dataframe/stringapi.html)
-     * 
+     *
      * For example:
      * ```kotlin
      * DataFrame.read("titanic.csv")
@@ -55,9 +55,9 @@ internal interface AccessApi {
      * Column Accessors API.
      * In this [AccessApi], every column has a descriptor;
      * a variable that represents its name and type.
-     * 
+     *
      * For more information: [See Column Accessors API on the documentation website.](https://kotlin.github.io/dataframe/columnaccessorsapi.html)
-     * 
+     *
      * For example:
      * ```kotlin
      * val survived by column<Boolean>()
@@ -65,7 +65,7 @@ internal interface AccessApi {
      * val age by column<Int?>()
      * val name by column<String>()
      * val lastName by column<String>()
-     * 
+     *
      * DataFrame.read("titanic.csv")
      *     .add(lastName) { name().split(",").last() }
      *     .dropNulls { age }
@@ -83,9 +83,9 @@ internal interface AccessApi {
      * [`KProperty`](https://kotlinlang.org/docs/reflection.html#property-references)
      * of some class.
      * The name and type of column should match the name and type of property, respectively.
-     * 
+     *
      * For more information: [See KProperties API on the documentation website.](https://kotlin.github.io/dataframe/kpropertiesapi.html)
-     * 
+     *
      * For example:
      * ```kotlin
      * data class Passenger(
@@ -94,7 +94,7 @@ internal interface AccessApi {
      *     val age: Int,
      *     val lastName: String
      * )
-     * 
+     *
      * val passengers = DataFrame.read("titanic.csv")
      *     .add(Passenger::lastName) { "name"<String>().split(",").last() }
      *     .dropNulls(Passenger::age)
@@ -115,14 +115,14 @@ internal interface AccessApi {
      * Extension Properties API.
      * In this [AccessApi], extension access properties are generated based on the dataframe schema.
      * The name and type of properties are inferred from the name and type of the corresponding columns.
-     * 
+     *
      * For more information: [See Extension Properties API on the documentation website.](https://kotlin.github.io/dataframe/extensionpropertiesapi.html)
-     * 
+     *
      * For example:
      * ```kotlin
      * fun extensionProperties1() {
-     *      val df = DataFrame.read("titanic.csv")
-     *  }
+     *     val df = DataFrame.read("titanic.csv")
+     * }
      * ```
      */
     interface ExtensionPropertiesApi
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt
index eaef2bb9e..b092d3750 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt
@@ -18,7 +18,6 @@ internal interface ExpressionsGivenColumn {
      */
     interface OperationArg
 
-    
     interface SetDefaultOperationArg
 
     /** Provide a new value for every selected cell given its column using a [column expression][DfColumnExpression]. */
@@ -26,12 +25,13 @@ internal interface ExpressionsGivenColumn {
 
         /**
          * Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
-         * 
+         *
          * For example:
-         * 
+         *
          * `df.`operation` { `[mean][DataColumn.mean]`(skipNA = true) }`
-         * 
+         *
          * `df.`operation` { `[count][DataColumn.count]` { it > 10 } }`
+         *
          */
         interface WithExample
     }
@@ -44,14 +44,15 @@ internal interface ExpressionsGivenColumn {
 
         /**
          * Provide a new value for every selected cell given both its row and column using a [row-column expression][org.jetbrains.kotlinx.dataframe.RowColumnExpression].
-         * 
          * For example:
-         * 
+         *
          * `df.`operation` { row, col ->`
-         * 
-         * `row.age / col.`[mean][DataColumn.mean]`(skipNA = true)`
-         * 
+         *
+         * `row.age / col.`[mean][org.jetbrains.kotlinx.dataframe.DataColumn.mean]`(skipNA = true)`
+         *
          * `}`
+         *
+         *
          */
         interface WithExample
     }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenDataFrame.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenDataFrame.kt
index 09d9d12d5..dbd80df77 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenDataFrame.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenDataFrame.kt
@@ -19,10 +19,9 @@ internal interface ExpressionsGivenDataFrame {
 
         /**
          * Provide a new value for every selected data frame using a [dataframe expression][org.jetbrains.kotlinx.dataframe.DataFrameExpression].
-         * 
          * For example:
-         * 
-         * {@includeArg [OperationArg]}` { `[select][DataFrame.select]` { lastName } }`
+         *
+         * {@includeArg [OperationArg][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.OperationArg]}` { `[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { lastName } }`
          */
         interface WithExample
     }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
index 89edf6acc..7e81df834 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
@@ -20,23 +20,22 @@ import org.jetbrains.kotlinx.dataframe.RowValueExpression as DfRowValueExpressio
  * ## Expressions Given Row
  * Expressing values using a "Row Expression" ([See Row Expressions on the documentation website.](https://kotlin.github.io/dataframe/datarow.html#row-expressions))
  * can occur in the following two types of operations:
- * 
+ *
  * - Providing a new value for every selected cell given the row of that cell ([Row Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowExpression.WithExample]),
  * for instance in [map][DataFrame.map], [add][DataFrame.add], and [insert][DataFrame.insert]
  * (using [RowExpression][DfRowExpression]).
- * 
+ *
  * - Providing a new value for every selected cell given the row of that cell and its previous value ([Row Value Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]),
  * for instance in [update.with][Update.with], and [convert.notNull][Convert.notNull]
  * (using [RowValueExpression][DfRowValueExpression]).
- * 
+ *
  * Note:
- * 
+ *
  * [update with][org.jetbrains.kotlinx.dataframe.api.Update.with]- and [add][org.jetbrains.kotlinx.dataframe.api.add]-like expressions use [AddDataRow][org.jetbrains.kotlinx.dataframe.api.AddDataRow] instead of [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as the DSL's receiver type.
  * This is an extension to [RowValueExpression][org.jetbrains.kotlinx.dataframe.RowValueExpression] and
  * [RowExpression][org.jetbrains.kotlinx.dataframe.RowExpression] that provides access to
  * the modified/generated value of the preceding row ([AddDataRow.newValue][org.jetbrains.kotlinx.dataframe.api.AddDataRow.newValue]).
- * 
- * A Row Expression is similar to a [Row Condition][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows] but that expects a [Boolean] as result.
+ * A Row Expression is similar to a [Row Condition][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows] but that expects a [Boolean][Boolean] as result.
  */
 internal interface ExpressionsGivenRow {
 
@@ -46,7 +45,6 @@ internal interface ExpressionsGivenRow {
      */
     interface OperationArg
 
-    
     interface SetDefaultOperationArg
 
     /**
@@ -62,12 +60,13 @@ internal interface ExpressionsGivenRow {
 
         /**
          * Provide a new value for every selected cell given its row using a [row expression][org.jetbrains.kotlinx.dataframe.RowExpression].
-         * 
+         *
          * For example:
-         * 
+         *
          * `df.`operation` { name.firstName + " " + name.lastName }`
-         * 
+         *
          * `df.`operation` { 2021 - age }`
+         *
          */
         interface WithExample
     }
@@ -83,12 +82,13 @@ internal interface ExpressionsGivenRow {
         /**
          * Provide a new value for every selected cell given its row and its previous value using a
          * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
-         * 
+         *
          * For example:
-         * 
+         *
          * `df.`operation` { name.firstName + " from " + it }`
-         * 
+         *
          * `df.`operation` { it.uppercase() }`
+         *
          */
         interface WithExample
     }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
index 7e26fea86..d47d5bc07 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
@@ -21,45 +21,43 @@ internal interface SelectingColumnsLink
  * can be done in the following ways:
  * - Select or express columns using the Column(s) Selection DSL.
  * (Any [Access Api][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
- * 
+ *
  * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
  * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
  * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
- * 
+ *
  * For example:
- * 
+ *
  * `df.`operation` { length `[and][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.and]` age }`
- * 
+ *
  * `df.`operation` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
- * 
+ *
  * `df.`operation` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<Double>() }`
- * 
- * - Select columns using their [column names][String]
+ *  - Select columns using their [column names][String]
  * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
- * 
+ *
  * For example:
- * 
+ *
  * `df.`operation`("length", "age")`
- * 
- * - Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ *  - Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
  * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
- * 
+ *
  * For example:
- * 
+ *
  * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
- * 
+ *
  * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
- * 
+ *
  * `df.`operation`(length, age)`
- * 
- * - Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
- * 
+ *  - Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
  * For example:
  * ```kotlin
  * data class Person(val length: Double, val age: Double)
  * ```
- * 
+ *
  * `df.`operation`(Person::length, Person::age)`
+ *
  */
 internal interface SelectingColumns {
 
@@ -69,34 +67,32 @@ internal interface SelectingColumns {
      */
     interface OperationArg
 
-    
     interface SetDefaultOperationArg
 
-    /**
-     * Select or express columns using the Column(s) Selection DSL.
+    /** Select or express columns using the Column(s) Selection DSL.
      * (Any [Access Api][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
-     * 
+     *
      * This DSL comes in the form of either a [Column Selector][ColumnSelector]- or [Columns Selector][ColumnsSelector] lambda,
      * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
      * expect you to return a [SingleColumn] or [ColumnSet], respectively.
      */
     interface Dsl {
 
-        /**
-         * Select or express columns using the Column(s) Selection DSL.
+        /** Select or express columns using the Column(s) Selection DSL.
          * (Any [Access Api][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
-         * 
+         *
          * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
          * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
          * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
-         * 
+         *
          * For example:
-         * 
+         *
          * `df.`operation` { length `[and][ColumnsSelectionDsl.and]` age }`
-         * 
+         *
          * `df.`operation` { `[cols][ColumnsSelectionDsl.cols]`(1..5) }`
-         * 
+         *
          * `df.`operation` { `[colsOf][colsOf]`<Double>() }`
+         *
          */
         interface WithExample
     }
@@ -104,19 +100,18 @@ internal interface SelectingColumns {
     /** [Columns selector DSL][Dsl.WithExample] */
     interface DslLink
 
-    /**
-     * Select columns using their [column names][String]
+    /** Select columns using their [column names][String]
      * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
      */
     interface ColumnNames {
 
-        /**
-         * Select columns using their [column names][String]
+        /** Select columns using their [column names][String]
          * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
-         * 
+         *
          * For example:
-         * 
+         *
          * `df.`operation`("length", "age")`
+         *
          */
         interface WithExample
     }
@@ -124,23 +119,22 @@ internal interface SelectingColumns {
     /** [Column names][ColumnNames.WithExample] */
     interface ColumnNamesLink
 
-    /**
-     * Select columns using [column accessors][ColumnReference]
+    /** Select columns using [column accessors][ColumnReference]
      * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
      */
     interface ColumnAccessors {
 
-        /**
-         * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+        /** Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
          * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
-         * 
+         *
          * For example:
-         * 
+         *
          * `val length by `[column]`<Double>()`
-         * 
+         *
          * `val age by `[column]`<Double>()`
-         * 
+         *
          * `df.`operation`(length, age)`
+         *
          */
         interface WithExample
     }
@@ -151,15 +145,15 @@ internal interface SelectingColumns {
     /** Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]). */
     interface KProperties {
 
-        /**
-         * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
-         * 
+        /** Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+         *
          * For example:
          * ```kotlin
          * data class Person(val length: Double, val age: Double)
          * ```
-         * 
+         *
          * `df.`operation`(Person::length, Person::age)`
+         *
          */
         interface WithExample
     }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
index 6a976ee34..93d2f74fd 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
@@ -12,8 +12,9 @@ import org.jetbrains.kotlinx.dataframe.api.*
  * - Selecting parts of rows using a `where` operation after selecting columns ([Row-Value Condition][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows.RowValueCondition.WithExample]),
  * such as with [update], [gather], and [format]
  * (using [RowValueFilter]).
- * 
+ *
  * A Row Condition is similar to a [Row Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow] but expects a [Boolean] as result.
+ *
  */
 internal interface SelectingRows {
 
@@ -29,7 +30,6 @@ internal interface SelectingRows {
      */
     interface SecondOperationArg
 
-    
     interface SetDefaultOperationArg
 
     /** [Entire-Row Condition][EntireRowCondition.WithExample] */
@@ -40,12 +40,13 @@ internal interface SelectingRows {
 
         /**
          * Filter or find rows to operate on using a [row filter][org.jetbrains.kotlinx.dataframe.RowFilter].
-         * 
+         *
          * For example:
-         * 
+         *
          * `df.`operation` { `[index][index]`() % 2 == 0 }`
-         * 
+         *
          * `df.`operation` { `[diff][diff]` { age } == 0 }`
+         *
          */
         interface WithExample
     }
@@ -61,12 +62,13 @@ internal interface SelectingRows {
         /**
          * Filter or find rows to operate on after [selecting columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] using a
          * [row value filter][org.jetbrains.kotlinx.dataframe.RowValueFilter].
-         * 
+         *
          * For example:
-         * 
+         *
          * `df.`operation` { length }.`where` { it > 10.0 }`
-         * 
+         *
          * `df.`operation` { `[cols][ColumnsSelectionDsl.cols]`(1..5) }.`where` { `[index][index]`() > 4 && city != "Paris" }`
+         *
          */
         interface WithExample
     }
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 925a70fdd..f18c558ca 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
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.impl.aggregation
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.RowExpression
@@ -90,7 +90,7 @@ internal fun <T, C> AggregateInternalDsl<T>.columnValues(
 internal fun <T, V> AggregateInternalDsl<T>.withExpr(type: KType, path: ColumnPath, expression: RowExpression<T, V>) {
     val values = df.rows().map {
         val value = expression(it, it)
-        if (value is Column) it[value]
+        if (value is AnyColumnReference) it[value]
         else value
     }
     yieldOneOrMany(path, values, type)
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 0e51a7362..e70c945ef 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
@@ -1,6 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.impl.api
 
-import org.jetbrains.kotlinx.dataframe.Column
+import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
@@ -43,7 +43,7 @@ internal fun <T, C> MoveClause<T, C>.afterOrBefore(column: ColumnSelector<T, *>,
 
 internal fun <T, C> MoveClause<T, C>.moveImpl(
     under: Boolean = false,
-    newPathExpression: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> Column
+    newPathExpression: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> AnyColumnReference
 ): DataFrame<T> {
     val receiver = object : DataFrameReceiver<T>(df, UnresolvedColumnsPolicy.Fail), ColumnsSelectionDsl<T> {}
     val removeResult = df.removeImpl(columns = columns)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/split.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/split.kt
index 2d9fa64dd..7187019cb 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/split.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/split.kt
@@ -4,11 +4,11 @@ import org.jetbrains.kotlinx.dataframe.AnyFrame
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.api.SplitWithTransform
 import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
 import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
 import org.jetbrains.kotlinx.dataframe.impl.ColumnDataCollector
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnWithPath
 import org.jetbrains.kotlinx.dataframe.impl.createDataCollector
-import org.jetbrains.kotlinx.dataframe.impl.nameGenerator
 import org.jetbrains.kotlinx.dataframe.nrow
 
 internal fun valueToList(value: Any?, splitStrings: Boolean = true): List<Any?> = when (value) {
@@ -25,9 +25,13 @@ internal fun <T, C, R> splitImpl(
     val nrow = clause.df.nrow
 
     val removeResult = clause.df.removeImpl(columns = clause.columns)
-    val nameGenerator = removeResult.df.nameGenerator()
 
-    val toInsert = removeResult.removedColumns.flatMap { node ->
+    // As we insert multiple columns at once it's possible to encounter a name conflict within a batch of a new columns
+    // that's why an old school mutable list is used here to check for name conflicts in intermediate steps of generation
+    // of columns to insert
+    val columnsToInsert = mutableListOf<ColumnToInsert>()
+
+    removeResult.removedColumns.forEach { node ->
 
         val column = node.toColumnWithPath<C>()
         val columnCollectors = mutableListOf<ColumnDataCollector>()
@@ -46,22 +50,52 @@ internal fun <T, C, R> splitImpl(
                 columnCollectors[j].add(clause.default)
         }
 
-        var names = columnNamesGenerator(column, columnCollectors.size)
-        if (names.size < columnCollectors.size) {
-            names = names + (1..(columnCollectors.size - names.size)).map { "split$it" }
-        }
+        val names = columnNamesGenerator(column, columnCollectors.size)
+        val sourcePath = node.pathFromRoot()
+
+        columnCollectors.forEachIndexed { i, col ->
+            val preferredName = names.getOrNull(i)
 
-        columnCollectors.mapIndexed { i, col ->
+            val pathToInsert = if (clause.inward) sourcePath else sourcePath.dropLast(1)
+            val name = generateUnusedName(removeResult.df, preferredName, pathToInsert, columnsToInsert)
+
+            val path = pathToInsert + name
 
-            val name = nameGenerator.addUnique(names[i])
-            val sourcePath = node.pathFromRoot()
-            val path = if (clause.inward) sourcePath + name else sourcePath.dropLast(1) + name
             val data = col.toColumn(name)
-            ColumnToInsert(path, data, node)
+            columnsToInsert.add(ColumnToInsert(path, data, node))
+        }
+    }
+
+    return removeResult.df.insertImpl(columnsToInsert)
+}
+
+internal fun generateUnusedName(
+    df: DataFrame<*>,
+    preferredName: String?,
+    insertPath: ColumnPath,
+    columnsToBeInserted: List<ColumnToInsert>
+): String {
+    // check if column with this name already exists in the df in the same position in the hierarchy,
+    // or we already have a column with this name in the list of columns to be inserted to the same position in the hierarchy
+    fun isUsed(name: String) =
+        df.getColumnOrNull(insertPath + name) != null || columnsToBeInserted.any { it.insertionPath == insertPath + name }
+
+    fun generateNameVariationByTryingNumericSuffixes(original: String? = null, startSuffix: Int): String {
+        var k = startSuffix
+        var name = original ?: "split$k"
+        while (isUsed(name)) {
+            name = original ?: "split"
+            name = "${name}${k++}"
         }
+
+        return name
     }
 
-    return removeResult.df.insertImpl(toInsert)
+    return if (preferredName == null) {
+        generateNameVariationByTryingNumericSuffixes(startSuffix = 1)
+    } else {
+        generateNameVariationByTryingNumericSuffixes(preferredName, 1)
+    }
 }
 
 internal fun String.splitDefault() = split(",").map { it.trim() }
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 b3fca01b3..9f05b8f96 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
@@ -5,14 +5,19 @@ import org.jetbrains.kotlinx.dataframe.AnyRow
 import org.jetbrains.kotlinx.dataframe.ColumnExpression
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataFrameExpression
+import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.RowValueFilter
 import org.jetbrains.kotlinx.dataframe.api.AddDataRow
 import org.jetbrains.kotlinx.dataframe.api.Update
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.asDataFrame
 import org.jetbrains.kotlinx.dataframe.api.cast
 import org.jetbrains.kotlinx.dataframe.api.indices
 import org.jetbrains.kotlinx.dataframe.api.isEmpty
 import org.jetbrains.kotlinx.dataframe.api.name
 import org.jetbrains.kotlinx.dataframe.api.replace
+import org.jetbrains.kotlinx.dataframe.api.toColumn
 import org.jetbrains.kotlinx.dataframe.api.toDataFrame
 import org.jetbrains.kotlinx.dataframe.api.with
 import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
@@ -20,6 +25,7 @@ import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
 import org.jetbrains.kotlinx.dataframe.columns.size
 import org.jetbrains.kotlinx.dataframe.impl.columns.AddDataRowImpl
 import org.jetbrains.kotlinx.dataframe.impl.createDataCollector
+import org.jetbrains.kotlinx.dataframe.index
 import org.jetbrains.kotlinx.dataframe.type
 import kotlin.reflect.full.isSubclassOf
 import kotlin.reflect.full.withNullability
@@ -40,10 +46,48 @@ internal fun <T, C> Update<T, C>.updateWithValuePerColumnImpl(selector: ColumnEx
         }
     }
 
+/**
+ * Implementation for Update As Frame:
+ * Replaces selected column groups with the result of the expression only where the filter is true.
+ */
+internal fun <T, C, R> Update<T, DataRow<C>>.asFrameImpl(expression: DataFrameExpression<C, DataFrame<R>>): DataFrame<T> =
+    if (df.isEmpty()) df
+    else df.replace(columns).with {
+        // First, we create an updated column group with the result of the expression
+        val srcColumnGroup = it.asColumnGroup()
+        val updatedColumnGroup = srcColumnGroup
+            .asDataFrame()
+            .let { expression(it, it) }
+            .asColumnGroup(srcColumnGroup.name())
+
+        if (filter == null) {
+            // If there is no filter, we simply return the updated column group
+            updatedColumnGroup
+        } else {
+            // If there is a filter, then we replace the rows of the source column group with the updated column group
+            // only if they satisfy the filter
+            srcColumnGroup.replaceRowsIf(from = updatedColumnGroup) {
+                val srcRow = df[it.index]
+                val srcValue = srcRow[srcColumnGroup]
+
+                filter.invoke(srcRow, srcValue)
+            }
+        }
+    }
+
+private fun <C, R> ColumnGroup<C>.replaceRowsIf(
+    from: ColumnGroup<R>,
+    condition: (DataRow<C>) -> Boolean = { true },
+): ColumnGroup<C> = values()
+    .map { if (condition(it)) from[it.index] else it }
+    .toColumn(name)
+    .asColumnGroup()
+    .cast()
+
 internal fun <T, C> DataColumn<C>.updateImpl(
     df: DataFrame<T>,
     filter: RowValueFilter<T, C>?,
-    expression: (AddDataRow<T>, DataColumn<C>, C) -> C?
+    expression: (AddDataRow<T>, DataColumn<C>, C) -> C?,
 ): DataColumn<C> {
     val collector = createDataCollector<C>(size, type)
     val src = this
@@ -75,6 +119,7 @@ internal fun <T> DataColumn<T>.updateWith(values: List<T>): DataColumn<T> = when
         val groups = (values as List<AnyFrame>)
         DataColumn.createFrameColumn(name, groups) as DataColumn<T>
     }
+
     is ColumnGroup<*> -> {
         this.columns().mapIndexed { colIndex, col ->
             val newValues = values.map {
@@ -88,6 +133,7 @@ internal fun <T> DataColumn<T>.updateWith(values: List<T>): DataColumn<T> = when
             col.updateWith(newValues)
         }.toDataFrame().let { DataColumn.createColumnGroup(name, it) } as DataColumn<T>
     }
+
     else -> {
         var nulls = false
         val kclass = type.jvmErasure
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnImpl.kt
index b89dcd649..66fb12727 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnImpl.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/DataColumnImpl.kt
@@ -37,7 +37,7 @@ internal abstract class DataColumnImpl<T>(
 
     override fun hashCode() = hashCode
 
-    override operator fun get(range: IntRange) = createWithValues(values.subList(range.start, range.endInclusive + 1))
+    override operator fun get(range: IntRange) = createWithValues(values.subList(range.first, range.last + 1))
 
     protected abstract fun createWithValues(values: List<T>, hasNulls: Boolean? = null): DataColumn<T>
 }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/DisableRowsLimitWrapper.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/DisableRowsLimitWrapper.kt
new file mode 100644
index 000000000..68bd3d9ab
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/DisableRowsLimitWrapper.kt
@@ -0,0 +1,8 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+
+/**
+ * Allows for disabling the rows limit when generating a DISPLAY output in Jupyter.
+ */
+public data class DisableRowsLimitWrapper(public val value: AnyFrame)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/Integration.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/Integration.kt
index c475bdbc3..93e7b7902 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/Integration.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/Integration.kt
@@ -6,29 +6,8 @@ import org.jetbrains.kotlinx.dataframe.AnyCol
 import org.jetbrains.kotlinx.dataframe.AnyFrame
 import org.jetbrains.kotlinx.dataframe.AnyRow
 import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
-import org.jetbrains.kotlinx.dataframe.api.Convert
-import org.jetbrains.kotlinx.dataframe.api.FormattedFrame
-import org.jetbrains.kotlinx.dataframe.api.Gather
-import org.jetbrains.kotlinx.dataframe.api.GroupBy
-import org.jetbrains.kotlinx.dataframe.api.Merge
-import org.jetbrains.kotlinx.dataframe.api.Pivot
-import org.jetbrains.kotlinx.dataframe.api.PivotGroupBy
-import org.jetbrains.kotlinx.dataframe.api.ReducedGroupBy
-import org.jetbrains.kotlinx.dataframe.api.ReducedPivot
-import org.jetbrains.kotlinx.dataframe.api.ReducedPivotGroupBy
-import org.jetbrains.kotlinx.dataframe.api.Split
-import org.jetbrains.kotlinx.dataframe.api.SplitWithTransform
-import org.jetbrains.kotlinx.dataframe.api.Update
-import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
-import org.jetbrains.kotlinx.dataframe.api.asDataFrame
-import org.jetbrains.kotlinx.dataframe.api.columnsCount
-import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
-import org.jetbrains.kotlinx.dataframe.api.frames
-import org.jetbrains.kotlinx.dataframe.api.into
-import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.*
 import org.jetbrains.kotlinx.dataframe.api.name
-import org.jetbrains.kotlinx.dataframe.api.toDataFrame
-import org.jetbrains.kotlinx.dataframe.api.values
 import org.jetbrains.kotlinx.dataframe.codeGen.CodeWithConverter
 import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
@@ -111,42 +90,42 @@ internal class Integration(
         }
 
         with(JupyterHtmlRenderer(config.display, this)) {
+            render<DisableRowsLimitWrapper>(
+                { "DataRow: index = ${it.value.rowsCount()}, columnsCount = ${it.value.columnsCount()}" },
+                applyRowsLimit = false
+            )
+
             render<HtmlData> { notebook.renderHtmlAsIFrameIfNeeded(it) }
             render<AnyRow>(
-                { it.toDataFrame() },
                 { "DataRow: index = ${it.index()}, columnsCount = ${it.columnsCount()}" },
             )
             render<ColumnGroup<*>>(
-                { it.asDataFrame() },
                 { """ColumnGroup: name = "${it.name}", rowsCount = ${it.rowsCount()}, columnsCount = ${it.columnsCount()}""" },
             )
             render<AnyCol>(
-                { dataFrameOf(it) },
                 { """DataColumn: name = "${it.name}", type = ${renderType(it.type())}, size = ${it.size()}""" },
             )
             render<AnyFrame>(
-                { it },
-                { "DataFrame: rowsCount = ${it.rowsCount()}, columnsCount = ${it.columnsCount()}" },
+                { "DataFrame: rowsCount = ${it.rowsCount()}, columnsCount = ${it.columnsCount()}" }
             )
             render<FormattedFrame<*>>(
-                { it.df },
                 { "DataFrame: rowsCount = ${it.df.rowsCount()}, columnsCount = ${it.df.columnsCount()}" },
                 modifyConfig = { getDisplayConfiguration(it) },
             )
-            render<GroupBy<*, *>>({ it.toDataFrame() }, { "GroupBy" })
-            render<ReducedGroupBy<*, *>>({ it.into(it.groupBy.groups.name()) }, { "ReducedGroupBy" })
-            render<Pivot<*>>({ it.frames().toDataFrame() }, { "Pivot" })
-            render<ReducedPivot<*>>({ it.values().toDataFrame() }, { "ReducedPivot" })
-            render<PivotGroupBy<*>>({ it.frames() }, { "PivotGroupBy" })
-            render<ReducedPivotGroupBy<*>>({ it.values() }, { "ReducedPivotGroupBy" })
-            render<SplitWithTransform<*, *, *>>({ it.into() }, { "Split" })
-            render<Split<*, *>>({ it.toDataFrame() }, { "Split" })
-            render<Merge<*, *, *>>({ it.into("merged") }, { "Merge" })
-            render<Gather<*, *, *, *>>({ it.into("key", "value") }, { "Gather" })
+            render<GroupBy<*, *>>({ "GroupBy" })
+            render<ReducedGroupBy<*, *>>({ "ReducedGroupBy" })
+            render<Pivot<*>>({ "Pivot" })
+            render<ReducedPivot<*>>({ "ReducedPivot" })
+            render<PivotGroupBy<*>>({ "PivotGroupBy" })
+            render<ReducedPivotGroupBy<*>>({ "ReducedPivotGroupBy" })
+            render<SplitWithTransform<*, *, *>>({ "Split" })
+            render<Split<*, *>>({ "Split" })
+            render<Merge<*, *, *>>({ "Merge" })
+            render<Gather<*, *, *, *>>({ "Gather" })
             render<IMG> { HTML(it.toString()) }
             render<IFRAME> { HTML(it.toString()) }
-            render<Update<*, *>>({ it.df }, { "Update" })
-            render<Convert<*, *>>({ it.df }, { "Convert" })
+            render<Update<*, *>>({ "Update" })
+            render<Convert<*, *>>({ "Convert" })
         }
 
         import("org.jetbrains.kotlinx.dataframe.api.*")
@@ -156,6 +135,7 @@ internal class Integration(
         import("org.jetbrains.kotlinx.dataframe.columns.*")
         import("org.jetbrains.kotlinx.dataframe.jupyter.ImportDataSchema")
         import("org.jetbrains.kotlinx.dataframe.jupyter.importDataSchema")
+        import("org.jetbrains.kotlinx.dataframe.jupyter.KotlinNotebookPluginUtils")
         import("java.net.URL")
         import("java.io.File")
         import("kotlinx.datetime.Instant")
@@ -265,3 +245,28 @@ public fun KotlinKernelHost.useSchemas(schemaClasses: Iterable<KClass<*>>) {
 public fun KotlinKernelHost.useSchemas(vararg schemaClasses: KClass<*>): Unit = useSchemas(schemaClasses.asIterable())
 
 public inline fun <reified T> KotlinKernelHost.useSchema(): Unit = useSchemas(T::class)
+
+/**
+ * Converts [dataframeLike] to [AnyFrame].
+ * If [dataframeLike] is already [AnyFrame] then it is returned as is.
+ * If it's not possible to convert [dataframeLike] to [AnyFrame] then [IllegalArgumentException] is thrown.
+ */
+internal fun convertToDataFrame(dataframeLike: Any): AnyFrame =
+    when (dataframeLike) {
+        is Pivot<*> -> dataframeLike.frames().toDataFrame()
+        is ReducedPivot<*> -> dataframeLike.values().toDataFrame()
+        is PivotGroupBy<*> -> dataframeLike.frames()
+        is ReducedPivotGroupBy<*> -> dataframeLike.values()
+        is SplitWithTransform<*, *, *> -> dataframeLike.into()
+        is Merge<*, *, *> -> dataframeLike.into("merged")
+        is Gather<*, *, *, *> -> dataframeLike.into("key", "value")
+        is Update<*, *> -> dataframeLike.df
+        is Convert<*, *> -> dataframeLike.df
+        is FormattedFrame<*> -> dataframeLike.df
+        is AnyCol -> dataFrameOf(dataframeLike)
+        is AnyRow -> dataframeLike.toDataFrame()
+        is GroupBy<*, *> -> dataframeLike.toDataFrame()
+        is AnyFrame -> dataframeLike
+        is DisableRowsLimitWrapper -> dataframeLike.value
+        else -> throw IllegalArgumentException("Unsupported type: ${dataframeLike::class}")
+    }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterHtmlRenderer.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterHtmlRenderer.kt
index f959451e7..15cdec63c 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterHtmlRenderer.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterHtmlRenderer.kt
@@ -1,11 +1,17 @@
 package org.jetbrains.kotlinx.dataframe.jupyter
 
-import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+import com.beust.klaxon.json
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.io.*
 import org.jetbrains.kotlinx.dataframe.io.initHtml
-import org.jetbrains.kotlinx.dataframe.io.toHTML
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.size
+import org.jetbrains.kotlinx.jupyter.api.*
 import org.jetbrains.kotlinx.jupyter.api.libraries.JupyterIntegration
-import org.jetbrains.kotlinx.jupyter.api.renderHtmlAsIFrameIfNeeded
+
+/** Starting from this version, dataframe integration will respond with additional data for rendering in Kotlin Notebooks plugin. */
+private const val MIN_KERNEL_VERSION_FOR_NEW_TABLES_UI = "0.11.0.311"
 
 internal class JupyterHtmlRenderer(
     val display: DisplayConfiguration,
@@ -13,14 +19,23 @@ internal class JupyterHtmlRenderer(
 )
 
 internal inline fun <reified T : Any> JupyterHtmlRenderer.render(
-    crossinline getDf: (T) -> DataFrame<*>,
     noinline getFooter: (T) -> String,
-    crossinline modifyConfig: T.(DisplayConfiguration) -> DisplayConfiguration = { it }
+    crossinline modifyConfig: T.(DisplayConfiguration) -> DisplayConfiguration = { it },
+    applyRowsLimit: Boolean = true
 ) = builder.renderWithHost<T> { host, value ->
     val contextRenderer = JupyterCellRenderer(this.notebook, host)
     val reifiedDisplayConfiguration = value.modifyConfig(display)
     val footer = getFooter(value)
-    val html = getDf(value).toHTML(
+
+    val df = convertToDataFrame(value)
+
+    val limit = if (applyRowsLimit) {
+        reifiedDisplayConfiguration.rowsLimit ?: df.nrow
+    } else {
+        df.nrow
+    }
+
+    val html = df.toHTML(
         reifiedDisplayConfiguration,
         extraHtml = initHtml(
             includeJs = reifiedDisplayConfiguration.isolatedOutputs,
@@ -30,5 +45,30 @@ internal inline fun <reified T : Any> JupyterHtmlRenderer.render(
         contextRenderer
     ) { footer }
 
-    notebook.renderHtmlAsIFrameIfNeeded(html)
+    if (notebook.kernelVersion >= KotlinKernelVersion.from(MIN_KERNEL_VERSION_FOR_NEW_TABLES_UI)!!) {
+        val jsonEncodedDf = json {
+            obj(
+                "nrow" to df.size.nrow,
+                "ncol" to df.size.ncol,
+                "columns" to df.columnNames(),
+                "kotlin_dataframe" to encodeFrame(df.rows().take(limit).toDataFrame())
+            )
+        }.toJsonString()
+        notebook.renderAsIFrameAsNeeded(html, jsonEncodedDf)
+    } else {
+        notebook.renderHtmlAsIFrameIfNeeded(html)
+    }
+}
+
+internal fun Notebook.renderAsIFrameAsNeeded(data: HtmlData, jsonEncodedDf: String): MimeTypedResult {
+    val textHtml = if (jupyterClientType == JupyterClientType.KOTLIN_NOTEBOOK) {
+        data.generateIframePlaneText(currentColorScheme)
+    } else {
+        data.toString(currentColorScheme)
+    }
+
+    return mimeResult(
+        "text/html" to textHtml,
+        "application/kotlindataframe+json" to jsonEncodedDf
+    ).also { it.isolatedHtml = false }
 }
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
new file mode 100644
index 000000000..28315785f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/KotlinNotebookPluginUtils.kt
@@ -0,0 +1,33 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.api.filter
+
+/**
+ * A class with utility methods for Kotlin Notebook Plugin integration.
+ * Kotlin Notebook Plugin is acts as a client of Kotlin Jupyter kernel and use this functionality
+ * for dynamic pagination when rendering dataframes.
+ * The plugin sends Kotlin following code to the kernel to evaluate
+ * DISPLAY(KotlinNotebooksPluginUtils.getRowsSubsetForRendering(Out[x], 0, 20), "")
+ */
+public object KotlinNotebookPluginUtils {
+    /**
+     * Returns a subset of rows from the given dataframe for rendering.
+     * It's used for example for dynamic pagination in Kotlin Notebook Plugin.
+     */
+    public fun getRowsSubsetForRendering(
+        dataFrameLike: Any?,
+        startIdx: Int,
+        endIdx: Int
+    ): DisableRowsLimitWrapper = when (dataFrameLike) {
+        null -> throw IllegalArgumentException("Dataframe is null")
+        else -> getRowsSubsetForRendering(convertToDataFrame(dataFrameLike), startIdx, endIdx)
+    }
+
+    /**
+     * Returns a subset of rows from the given dataframe for rendering.
+     * It's used for example for dynamic pagination in Kotlin Notebook Plugin.
+     */
+    public fun getRowsSubsetForRendering(df: AnyFrame, startIdx: Int, endIdx: Int): DisableRowsLimitWrapper =
+        DisableRowsLimitWrapper(df.filter { it.index() in startIdx until endIdx })
+}

From fb22326111fa4332b9da2482f5d716a21e4f7ef7 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Tue, 14 Mar 2023 15:01:09 +0100
Subject: [PATCH 41/50] ExpressionsGivenRowAndColumn

---
 core/build.gradle.kts                         |  2 +-
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  |  6 +--
 .../jetbrains/kotlinx/dataframe/api/update.kt |  4 +-
 .../documentation/ExpressionsGivenColumn.kt   | 27 ++---------
 .../ExpressionsGivenRowAndColumn.kt           | 43 ++++++++++++++++++
 .../jetbrains/kotlinx/dataframe/api/update.kt |  8 ++--
 .../documentation/ExpressionsGivenColumn.kt   | 28 ++----------
 .../ExpressionsGivenRowAndColumn.kt           | 45 +++++++++++++++++++
 8 files changed, 104 insertions(+), 59 deletions(-)
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRowAndColumn.kt
 create mode 100644 core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRowAndColumn.kt

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 04aca2b1a..0e43e734a 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -18,7 +18,7 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.29"
+    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.30"
 //    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
 }
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index 4949edd0b..ea1746d88 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -42,7 +42,7 @@ internal interface FillNulls {
      * - `.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
      *   | .`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
      *   | .`[perCol][org.jetbrains.kotlinx.dataframe.api.Update.perCol]` { `[colExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpression.WithExample]` }
-     *   | .`[perRowCol][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol]` { `[rowColExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.RowColumnExpression.WithExample]` }
+     *   | .`[perRowCol][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol]` { `[rowColExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRowAndColumn.RowColumnExpression.WithExample]` }
      *   | .`[withValue][org.jetbrains.kotlinx.dataframe.api.Update.withValue]`(value)
      *   | .`[withNull][org.jetbrains.kotlinx.dataframe.api.Update.withNull]`()
      *   | .`[withZero][org.jetbrains.kotlinx.dataframe.api.Update.withZero]`()
@@ -255,7 +255,7 @@ internal interface FillNaNs {
      * - `.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
      *   | .`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
      *   | .`[perCol][org.jetbrains.kotlinx.dataframe.api.Update.perCol]` { `[colExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpression.WithExample]` }
-     *   | .`[perRowCol][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol]` { `[rowColExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.RowColumnExpression.WithExample]` }
+     *   | .`[perRowCol][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol]` { `[rowColExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRowAndColumn.RowColumnExpression.WithExample]` }
      *   | .`[withValue][org.jetbrains.kotlinx.dataframe.api.Update.withValue]`(value)
      *   | .`[withNull][org.jetbrains.kotlinx.dataframe.api.Update.withNull]`()
      *   | .`[withZero][org.jetbrains.kotlinx.dataframe.api.Update.withZero]`()
@@ -424,7 +424,7 @@ internal interface FillNA {
      * - `.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
      *   | .`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
      *   | .`[perCol][org.jetbrains.kotlinx.dataframe.api.Update.perCol]` { `[colExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpression.WithExample]` }
-     *   | .`[perRowCol][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol]` { `[rowColExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.RowColumnExpression.WithExample]` }
+     *   | .`[perRowCol][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol]` { `[rowColExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRowAndColumn.RowColumnExpression.WithExample]` }
      *   | .`[withValue][org.jetbrains.kotlinx.dataframe.api.Update.withValue]`(value)
      *   | .`[withNull][org.jetbrains.kotlinx.dataframe.api.Update.withNull]`()
      *   | .`[withZero][org.jetbrains.kotlinx.dataframe.api.Update.withZero]`()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index e89c838b6..cea9e5d76 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -48,7 +48,7 @@ public data class Update<T, C>(
      * - `.`[with][Update.with]` { `[rowExpression][ExpressionsGivenRow.RowValueExpression.WithExample]` }
      *   | .`[notNull][Update.notNull]` { `[rowExpression][ExpressionsGivenRow.RowValueExpression.WithExample]` }
      *   | .`[perCol][Update.perCol]` { `[colExpression][ExpressionsGivenColumn.ColumnExpression.WithExample]` }
-     *   | .`[perRowCol][Update.perRowCol]` { `[rowColExpression][ExpressionsGivenColumn.RowColumnExpression.WithExample]` }
+     *   | .`[perRowCol][Update.perRowCol]` { `[rowColExpression][ExpressionsGivenRowAndColumn.RowColumnExpression.WithExample]` }
      *   | .`[withValue][Update.withValue]`(value)
      *   | .`[withNull][Update.withNull]`()
      *   | .`[withZero][Update.withZero]`()
@@ -332,7 +332,7 @@ public fun <T, C> Update<T, C>.at(rowRange: IntRange): Update<T, C> = where { in
  * ## See Also
  *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
  *  - [Update per col][org.jetbrains.kotlinx.dataframe.api.Update.perCol] to provide a new value for every selected cell giving its column.
- * @param expression The [Row Column Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.RowColumnExpression] to provide a new value for every selected cell giving its row and column.
+ * @param expression The [Row Column Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRowAndColumn.RowColumnExpression] to provide a new value for every selected cell giving its row and column.
  */
 public infix fun <T, C> Update<T, C>.perRowCol(expression: RowColumnExpression<T, C, C>): DataFrame<T> =
     updateImpl { row, column, _ -> expression(row, column) }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt
index b092d3750..ac95e39c2 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt
@@ -2,13 +2,13 @@ package org.jetbrains.kotlinx.dataframe.documentation
 
 import org.jetbrains.kotlinx.dataframe.*
 import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpressionLink
 import org.jetbrains.kotlinx.dataframe.ColumnExpression as DfColumnExpression
-import org.jetbrains.kotlinx.dataframe.RowColumnExpression as DfRowColumnExpression
 
 /**
  * ## Expressions Given Column
- *
- * TODO
+ * Expressing values using a "Column Expression" can occur exclusively in a
+ * [Column Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpression].
  */
 internal interface ExpressionsGivenColumn {
 
@@ -38,25 +38,4 @@ internal interface ExpressionsGivenColumn {
 
     /** [Column Expression][ColumnExpression] */
     interface ColumnExpressionLink
-
-    /** Provide a new value for every selected cell given both its row and column using a [row-column expression][DfRowColumnExpression]. */
-    interface RowColumnExpression {
-
-        /**
-         * Provide a new value for every selected cell given both its row and column using a [row-column expression][org.jetbrains.kotlinx.dataframe.RowColumnExpression].
-         * For example:
-         *
-         * `df.`operation` { row, col ->`
-         *
-         * `row.age / col.`[mean][org.jetbrains.kotlinx.dataframe.DataColumn.mean]`(skipNA = true)`
-         *
-         * `}`
-         *
-         *
-         */
-        interface WithExample
-    }
-
-    /** [Row Column Expression][RowColumnExpression] */
-    interface RowColumnExpressionLink
 }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRowAndColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRowAndColumn.kt
new file mode 100644
index 000000000..c916bf46f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRowAndColumn.kt
@@ -0,0 +1,43 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRowAndColumn.RowColumnExpressionLink
+import org.jetbrains.kotlinx.dataframe.RowColumnExpression as DfRowColumnExpression
+
+/**
+ * ## Expressions Given Row and Column
+ * Expressing values using a "Row-Column Expression" can occur exclusively in a
+ * [Row Column Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRowAndColumn.RowColumnExpression].
+ */
+internal interface ExpressionsGivenRowAndColumn {
+
+    /**
+     * The key for an @arg that will define the operation name for the examples below.
+     * Make sure to [alias][your examples].
+     */
+    interface OperationArg
+
+    interface SetDefaultOperationArg
+
+    /** Provide a new value for every selected cell given both its row and column using a [row-column expression][DfRowColumnExpression]. */
+    interface RowColumnExpression {
+
+        /**
+         * Provide a new value for every selected cell given both its row and column using a [row-column expression][org.jetbrains.kotlinx.dataframe.RowColumnExpression].
+         * For example:
+         *
+         * `df.`operation` { row, col ->`
+         *
+         * `row.age / col.`[mean][org.jetbrains.kotlinx.dataframe.DataColumn.mean]`(skipNA = true)`
+         *
+         * `}`
+         *
+         *
+         */
+        interface WithExample
+    }
+
+    /** [Row Column Expression][RowColumnExpression] */
+    interface RowColumnExpressionLink
+}
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index f263ee665..5e13bcaad 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -48,7 +48,7 @@ public data class Update<T, C>(
      * - `.`[with][Update.with]` { `[rowExpression][ExpressionsGivenRow.RowValueExpression.WithExample]` }
      *   | .`[notNull][Update.notNull]` { `[rowExpression][ExpressionsGivenRow.RowValueExpression.WithExample]` }
      *   | .`[perCol][Update.perCol]` { `[colExpression][ExpressionsGivenColumn.ColumnExpression.WithExample]` }
-     *   | .`[perRowCol][Update.perRowCol]` { `[rowColExpression][ExpressionsGivenColumn.RowColumnExpression.WithExample]` }
+     *   | .`[perRowCol][Update.perRowCol]` { `[rowColExpression][ExpressionsGivenRowAndColumn.RowColumnExpression.WithExample]` }
      *   | .`[withValue][Update.withValue]`(value)
      *   | .`[withNull][Update.withNull]`()
      *   | .`[withZero][Update.withZero]`()
@@ -191,13 +191,13 @@ public fun <T, C> Update<T, C>.at(vararg rowIndices: Int): Update<T, C> = at(row
 public fun <T, C> Update<T, C>.at(rowRange: IntRange): Update<T, C> = where { index in rowRange }
 
 /** ## Per Row Col
- * @include [ExpressionsGivenColumn.RowColumnExpression.WithExample]
- * {@arg [ExpressionsGivenColumn.OperationArg] [update][update]` { age \}.`[perRowCol][perRowCol]}
+ * @include [ExpressionsGivenRowAndColumn.RowColumnExpression.WithExample]
+ * {@arg [ExpressionsGivenRowAndColumn.OperationArg] [update][update]` { age \}.`[perRowCol][perRowCol]}
  *
  * ## See Also
  *  - {@include [SeeAlsoWith]}
  *  - {@include [SeeAlsoPerCol]}
- * @param expression The {@include [ExpressionsGivenColumn.RowColumnExpressionLink]} to provide a new value for every selected cell giving its row and column.
+ * @param expression The {@include [ExpressionsGivenRowAndColumn.RowColumnExpressionLink]} to provide a new value for every selected cell giving its row and column.
  */
 public infix fun <T, C> Update<T, C>.perRowCol(expression: RowColumnExpression<T, C, C>): DataFrame<T> =
     updateImpl { row, column, _ -> expression(row, column) }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt
index e2fa5f4d8..3a0f61109 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt
@@ -2,13 +2,13 @@ package org.jetbrains.kotlinx.dataframe.documentation
 
 import org.jetbrains.kotlinx.dataframe.*
 import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpressionLink
 import org.jetbrains.kotlinx.dataframe.ColumnExpression as DfColumnExpression
-import org.jetbrains.kotlinx.dataframe.RowColumnExpression as DfRowColumnExpression
 
 /**
  * ## Expressions Given Column
- *
- * TODO
+ * Expressing values using a "Column Expression" can occur exclusively in a
+ * {@include [ColumnExpressionLink]}.
  */
 internal interface ExpressionsGivenColumn {
 
@@ -39,26 +39,4 @@ internal interface ExpressionsGivenColumn {
 
     /** [Column Expression][ColumnExpression] */
     interface ColumnExpressionLink
-
-    /** Provide a new value for every selected cell given both its row and column using a [row-column expression][DfRowColumnExpression]. */
-    interface RowColumnExpression {
-
-        /**
-         * @include [RowColumnExpression]
-         *
-         * For example:
-         *
-         * `df.`{@includeArg [OperationArg]}` { row, col ->`
-         *
-         * `row.age / col.`[mean][DataColumn.mean]`(skipNA = true)`
-         *
-         * `}`
-         *
-         * @include [SetDefaultOperationArg]
-         */
-        interface WithExample
-    }
-
-    /** [Row Column Expression][RowColumnExpression] */
-    interface RowColumnExpressionLink
 }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRowAndColumn.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRowAndColumn.kt
new file mode 100644
index 000000000..c640597d6
--- /dev/null
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRowAndColumn.kt
@@ -0,0 +1,45 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRowAndColumn.RowColumnExpressionLink
+import org.jetbrains.kotlinx.dataframe.RowColumnExpression as DfRowColumnExpression
+
+/**
+ * ## Expressions Given Row and Column
+ * Expressing values using a "Row-Column Expression" can occur exclusively in a
+ * {@include [RowColumnExpressionLink]}.
+ */
+internal interface ExpressionsGivenRowAndColumn {
+
+    /**
+     * The key for an @arg that will define the operation name for the examples below.
+     * Make sure to [alias][your examples].
+     */
+    interface OperationArg
+
+    /** {@arg [OperationArg] operation} */
+    interface SetDefaultOperationArg
+
+    /** Provide a new value for every selected cell given both its row and column using a [row-column expression][DfRowColumnExpression]. */
+    interface RowColumnExpression {
+
+        /**
+         * @include [RowColumnExpression]
+         *
+         * For example:
+         *
+         * `df.`{@includeArg [OperationArg]}` { row, col ->`
+         *
+         * `row.age / col.`[mean][DataColumn.mean]`(skipNA = true)`
+         *
+         * `}`
+         *
+         * @include [SetDefaultOperationArg]
+         */
+        interface WithExample
+    }
+
+    /** [Row Column Expression][RowColumnExpression] */
+    interface RowColumnExpressionLink
+}

From d289e86ce68d5a881b4ba2674bacdfabaddac094 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Wed, 15 Mar 2023 14:31:22 +0100
Subject: [PATCH 42/50] updating doc processor plugin and fixing linter

---
 core/build.gradle.kts                               |  2 +-
 .../dataframe/documentation/ExpressionsGivenRow.kt  | 13 ++-----------
 .../dataframe/documentation/ExpressionsGivenRow.kt  | 13 ++-----------
 3 files changed, 5 insertions(+), 23 deletions(-)

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 0e43e734a..c5c1ce131 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -18,7 +18,7 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.0.30"
+    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.1.0"
 //    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
 }
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
index 7e81df834..c86796cd0 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
@@ -2,17 +2,8 @@ package org.jetbrains.kotlinx.dataframe.documentation
 
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
-import org.jetbrains.kotlinx.dataframe.api.AddDataRow
-import org.jetbrains.kotlinx.dataframe.api.Convert
-import org.jetbrains.kotlinx.dataframe.api.Update
-import org.jetbrains.kotlinx.dataframe.api.add
-import org.jetbrains.kotlinx.dataframe.api.insert
-import org.jetbrains.kotlinx.dataframe.api.map
-import org.jetbrains.kotlinx.dataframe.api.notNull
-import org.jetbrains.kotlinx.dataframe.api.with
-import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.AddDataRowNote
-import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowExpressionLink
-import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpressionLink
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.*
 import org.jetbrains.kotlinx.dataframe.RowExpression as DfRowExpression
 import org.jetbrains.kotlinx.dataframe.RowValueExpression as DfRowValueExpression
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
index 48ba1b740..826fd6894 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
@@ -2,17 +2,8 @@ package org.jetbrains.kotlinx.dataframe.documentation
 
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
-import org.jetbrains.kotlinx.dataframe.api.AddDataRow
-import org.jetbrains.kotlinx.dataframe.api.Convert
-import org.jetbrains.kotlinx.dataframe.api.Update
-import org.jetbrains.kotlinx.dataframe.api.add
-import org.jetbrains.kotlinx.dataframe.api.insert
-import org.jetbrains.kotlinx.dataframe.api.map
-import org.jetbrains.kotlinx.dataframe.api.notNull
-import org.jetbrains.kotlinx.dataframe.api.with
-import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.AddDataRowNote
-import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowExpressionLink
-import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpressionLink
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.*
 import org.jetbrains.kotlinx.dataframe.RowExpression as DfRowExpression
 import org.jetbrains.kotlinx.dataframe.RowValueExpression as DfRowValueExpression
 

From 490ecdd1ba414ca6eea78801a8d9f0d21a491888 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Thu, 16 Mar 2023 20:08:24 +0100
Subject: [PATCH 43/50] docs for dropNulls

---
 core/build.gradle.kts                         |   6 +-
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  | 266 ++++++++++++++----
 .../jetbrains/kotlinx/dataframe/api/update.kt |  53 +++-
 .../documentation/DocumentationUrls.kt        |  14 +
 .../ExpressionsGivenDataFrame.kt              |   1 +
 .../documentation/ExpressionsGivenRow.kt      |   1 +
 .../ExpressionsGivenRowAndColumn.kt           |   1 +
 .../documentation/SelectingColumns.kt         |  30 +-
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  | 148 +++++++---
 .../documentation/DocumentationUrls.kt        |  14 +
 .../documentation/SelectingColumns.kt         |  17 +-
 11 files changed, 425 insertions(+), 126 deletions(-)

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index c5c1ce131..8227d7795 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -1,8 +1,4 @@
-import nl.jolanrensen.docProcessor.defaultProcessors.COMMENT_DOC_PROCESSOR
-import nl.jolanrensen.docProcessor.defaultProcessors.INCLUDE_ARG_DOC_PROCESSOR
-import nl.jolanrensen.docProcessor.defaultProcessors.INCLUDE_DOC_PROCESSOR
-import nl.jolanrensen.docProcessor.defaultProcessors.INCLUDE_FILE_DOC_PROCESSOR
-import nl.jolanrensen.docProcessor.defaultProcessors.SAMPLE_DOC_PROCESSOR
+import nl.jolanrensen.docProcessor.defaultProcessors.*
 import nl.jolanrensen.docProcessor.gradle.creatingProcessDocTask
 import org.gradle.jvm.tasks.Jar
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index ea1746d88..58a85b646 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -1,22 +1,38 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.AnyCol
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
-import org.jetbrains.kotlinx.dataframe.AnyFrame
-import org.jetbrains.kotlinx.dataframe.AnyRow
-import org.jetbrains.kotlinx.dataframe.ColumnsSelector
-import org.jetbrains.kotlinx.dataframe.DataColumn
-import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.*
 import org.jetbrains.kotlinx.dataframe.api.Update.UpdateOperationArg
 import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.documentation.*
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
-import org.jetbrains.kotlinx.dataframe.kind
-import org.jetbrains.kotlinx.dataframe.typeClass
 import kotlin.reflect.KProperty
 
+/**
+ * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
+ * in cases where a mathematical operation is undefined, such as dividing by zero.
+ *
+ * You can also use [fillNaNs][fillNaNs] to replace `NaNs` in certain columns with a given value or expression
+ * or [dropNaNs][dropNaNs] to drop rows with `NaNs` in them.
+ *
+ * @see NA
+ */
+internal interface NaN
+
+/**
+ * `NA` in Dataframe can be seen as "[NaN] or `null`".
+ *
+ * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
+ * in cases where a mathematical operation is undefined, such as dividing by zero.
+ *
+ * You can also use [fillNA][fillNA] to replace `NAs` in certain columns with a given value or expression
+ * or [dropNA][dropNA] to drop rows with `NAs` in them.
+ *
+ * @see NaN
+ */
+internal interface NA
+
 // region fillNulls
 
 /**
@@ -25,7 +41,7 @@ import kotlin.reflect.KProperty
  * Replaces `null` values with given value or expression.
  * Specific case of [update].
  *
- * Check out the [`fillNulls` Operation Usage][Usage].
+ * Check out the [`fillNulls` Operation Usage][FillNulls.Usage].
  *
  * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls)
  */
@@ -93,7 +109,7 @@ private interface CommonFillNullsFunctionDoc
  *
  * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
  *
- * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<Double>() }`
+ * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
  *  
  * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
  */
@@ -167,9 +183,9 @@ public fun <T, C> DataFrame<T>.fillNulls(vararg columns: KProperty<C>): Update<T
  *
  * For example:
  *
- * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
  *
- * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
  *
  * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]`(length, age)`
  *  
@@ -186,30 +202,6 @@ public fun <T, C> DataFrame<T>.fillNulls(columns: Iterable<ColumnReference<C>>):
 
 // endregion
 
-/**
- * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
- * in cases where a mathematical operation is undefined, such as dividing by zero.
- * In Dataframe we have helper functions to check for `NaNs`, such as [Any?.isNaN][Any.isNaN] and
- * [column.canHaveNaN][DataColumn.canHaveNaN].
- * You can also use [fillNaNs][fillNaNs] to replace `NaNs` in certain columns with a given value or expression.
- *
- * @see NA
- */
-internal interface NaN
-
-/**
- * `NA` in Dataframe can be seen as "[NaN] or `null`".
- *
- * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
- * in cases where a mathematical operation is undefined, such as dividing by zero.
- *
- * In Dataframe we have helper functions to check for `NAs`, such as [Any?.isNA][Any.isNA] and
- * [column.canHaveNA][DataColumn.canHaveNA].
- * You can also use [fillNA][fillNA] to replace `NAs` in certain columns with a given value or expression.
- * @see NaN
- */
-internal interface NA
-
 internal inline val Any?.isNaN: Boolean get() = (this is Double && isNaN()) || (this is Float && isNaN())
 
 internal inline val Any?.isNA: Boolean
@@ -238,7 +230,7 @@ internal inline val Float?.isNA: Boolean get() = this == null || this.isNaN()
  * Replaces [`NaN`][NaN] values with given value or expression.
  * Specific case of [update].
  *
- * Check out the [`fillNaNs` Operation Usage][Usage].
+ * Check out the [`fillNaNs` Operation Usage][FillNaNs.Usage].
  *
  * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans)
  */
@@ -306,7 +298,7 @@ private interface CommonFillNaNsFunctionDoc
  *
  * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
  *
- * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<Double>() }`
+ * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
  *  
  * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
  */
@@ -380,9 +372,9 @@ public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: KProperty<C>): Update<T,
  *
  * For example:
  *
- * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
  *
- * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
  *
  * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]`(length, age)`
  *  
@@ -407,7 +399,7 @@ public fun <T, C> DataFrame<T>.fillNaNs(columns: Iterable<ColumnReference<C>>):
  * Replaces [`NA`][NA] values with given value or expression.
  * Specific case of [update].
  *
- * Check out the [`fillNA` Operation Usage][Usage].
+ * Check out the [`fillNA` Operation Usage][FillNA.Usage].
  *
  * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna)
  */
@@ -475,7 +467,7 @@ private interface CommonFillNAFunctionDoc
  *
  * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
  *
- * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<Double>() }`
+ * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
  *  
  * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
  */
@@ -549,9 +541,9 @@ public fun <T, C> DataFrame<T>.fillNA(vararg columns: KProperty<C>): Update<T, C
  *
  * For example:
  *
- * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
  *
- * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
  *
  * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]`(length, age)`
  *  
@@ -568,32 +560,208 @@ public fun <T, C> DataFrame<T>.fillNA(columns: Iterable<ColumnReference<C>>): Up
 
 // endregion
 
+/** @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame] to drop rows in. */
+private interface DropDslParam
+
+
 // region dropNulls
 
-public fun <T> DataFrame<T>.dropNulls(whereAllNull: Boolean = false, selector: ColumnsSelector<T, *>): DataFrame<T> {
-    val columns = this[selector]
-    return if (whereAllNull) drop { row -> columns.all { col -> col[row] == null } }
-    else drop { row -> columns.any { col -> col[row] == null } }
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes rows with `null` values.
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
+ * rows are dropped if any of the selected cells are `null`.
+ *
+ * For more information: [See `dropNulls` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnulls)
+ */
+internal interface DropNulls {
+
+    /**
+     * @param whereAllNull `false` by default.
+     *   If `true`, rows are dropped if all selected cells are `null`.
+     *   If `false`, rows are dropped if any of the selected cells is `null`.
+     */
+    interface WhereAllNullParam
+}
+
+private interface SetDropNullsOperationArg
+
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes rows with `null` values.
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
+ * rows are dropped if any of the selected cells are `null`.
+ *
+ * For more information: [See `dropNulls` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnulls) 
+ * ## This Drop Nulls Overload
+ */
+private interface CommonDropNullsFunctionDoc
+
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes rows with `null` values.
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
+ * rows are dropped if any of the selected cells are `null`.
+ *
+ * For more information: [See `dropNulls` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnulls) 
+ * ## This Drop Nulls Overload
+ * Select or express columns using the Column(s) Selection DSL.
+ * (Any [Access Api][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ *
+ * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
+ *
+ * For example:
+ *
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]` { length `[and][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.and]` age }`
+ *
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ *
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
+ *  
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]`(whereAllNull = true) { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
+ *
+ * @param whereAllNull `false` by default.
+ *   If `true`, rows are dropped if all selected cells are `null`.
+ *   If `false`, rows are dropped if any of the selected cells is `null`.
+ * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNulls(whereAllNull: Boolean = false, columns: ColumnsSelector<T, *>): DataFrame<T> {
+    val cols = this[columns]
+    return if (whereAllNull) drop { row -> cols.all { col -> col[row] == null } }
+    else drop { row -> cols.any { col -> col[row] == null } }
 }
 
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes rows with `null` values.
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
+ * rows are dropped if any of the selected cells are `null`.
+ *
+ * For more information: [See `dropNulls` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnulls) 
+ * ## This Drop Nulls Overload
+ * This overload operates on all columns in the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+ * @param whereAllNull `false` by default.
+ *   If `true`, rows are dropped if all selected cells are `null`.
+ *   If `false`, rows are dropped if any of the selected cells is `null`.
+ */
 public fun <T> DataFrame<T>.dropNulls(whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { all() }
 
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes rows with `null` values.
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
+ * rows are dropped if any of the selected cells are `null`.
+ *
+ * For more information: [See `dropNulls` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnulls) 
+ * ## This Drop Nulls Overload
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ *
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]`(Person::length, Person::age)`
+ *  
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]`(Person::length, whereAllNull = true)`
+ * @param whereAllNull `false` by default.
+ *   If `true`, rows are dropped if all selected cells are `null`.
+ *   If `false`, rows are dropped if any of the selected cells is `null`.
+ * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
 public fun <T> DataFrame<T>.dropNulls(vararg columns: KProperty<*>, whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumns() }
 
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes rows with `null` values.
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
+ * rows are dropped if any of the selected cells are `null`.
+ *
+ * For more information: [See `dropNulls` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnulls) 
+ * ## This Drop Nulls Overload
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
+ * For example:
+ *
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]`("length", "age")`
+ *  
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]`("length", whereAllNull = true)`
+ * @param whereAllNull `false` by default.
+ *   If `true`, rows are dropped if all selected cells are `null`.
+ *   If `false`, rows are dropped if any of the selected cells is `null`.
+ * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
 public fun <T> DataFrame<T>.dropNulls(vararg columns: String, whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumns() }
 
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes rows with `null` values.
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
+ * rows are dropped if any of the selected cells are `null`.
+ *
+ * For more information: [See `dropNulls` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnulls) 
+ * ## This Drop Nulls Overload
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
+ * For example:
+ *
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]`(length, age)`
+ *  
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]`(length, whereAllNull = true)`
+ * @param whereAllNull `false` by default.
+ *   If `true`, rows are dropped if all selected cells are `null`.
+ *   If `false`, rows are dropped if any of the selected cells is `null`.
+ * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
 public fun <T> DataFrame<T>.dropNulls(vararg columns: AnyColumnReference, whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumns() }
 
+/**
+ * TODO will be deprecated
+ */
 public fun <T> DataFrame<T>.dropNulls(
     columns: Iterable<AnyColumnReference>,
     whereAllNull: Boolean = false
 ): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumnSet() }
 
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes `null` values from this [DataColumn], adjusting the type accordingly.
+ */
 public fun <T> DataColumn<T?>.dropNulls(): DataColumn<T> =
     (if (!hasNulls()) this else filter { it != null }) as DataColumn<T>
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index cea9e5d76..a79f4219a 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -124,7 +124,7 @@ private interface UpdateWithNote
  *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
  *
- * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<Double>() }`
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
  *  
  * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
  */
@@ -202,9 +202,9 @@ public fun <T, C> DataFrame<T>.update(vararg columns: KProperty<C>): Update<T, C
  *
  * For example:
  *
- * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
  *
- * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
  *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(length, age)`
  *  
@@ -233,7 +233,8 @@ public fun <T, C> DataFrame<T>.update(columns: Iterable<ColumnReference<C>>): Up
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { length }.`[where][org.jetbrains.kotlinx.dataframe.api.where]` { it > 10.0 }`
  *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }.`[where][org.jetbrains.kotlinx.dataframe.api.where]` { `[index][org.jetbrains.kotlinx.dataframe.index]`() > 4 && city != "Paris" }`
- *  
+ *
+ *
  *
  *
  * @param predicate The [row value filter][RowValueFilter] to select the rows to update.
@@ -273,6 +274,7 @@ private interface CommonUpdateAtFunctionDoc {
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(1, 2, 3, 4).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Empty" }`
  *
  * ## This At Overload
+ *
  * Provide a [Collection][Collection]<[Int][Int]> of row indices to update.
  *
  * @param rowIndices The indices of the rows to update. Either a [Collection][Collection]<[Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
@@ -292,6 +294,7 @@ public fun <T, C> Update<T, C>.at(rowIndices: Collection<Int>): Update<T, C> = w
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(1, 2, 3, 4).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Empty" }`
  *
  * ## This At Overload
+ *
  * Provide a `vararg` of [Ints][Int] of row indices to update.
  *
  * @param rowIndices The indices of the rows to update. Either a [Collection][Collection]<[Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
@@ -311,6 +314,7 @@ public fun <T, C> Update<T, C>.at(vararg rowIndices: Int): Update<T, C> = at(row
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(1, 2, 3, 4).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Empty" }`
  *
  * ## This At Overload
+ *
  * Provide an [IntRange][IntRange] of row indices to update.
  *
  * @param rowRange The indices of the rows to update. Either a [Collection][Collection]<[Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
@@ -319,6 +323,7 @@ public fun <T, C> Update<T, C>.at(rowRange: IntRange): Update<T, C> = where { in
 
 /** ## Per Row Col
  * Provide a new value for every selected cell given both its row and column using a [row-column expression][org.jetbrains.kotlinx.dataframe.RowColumnExpression].
+ *
  * For example:
  *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { age ` { row, col ->`
@@ -327,7 +332,8 @@ public fun <T, C> Update<T, C>.at(rowRange: IntRange): Update<T, C> = where { in
  *
  * `}`
  *
- *  .`[perRowCol][org.jetbrains.kotlinx.dataframe.api.perRowCol]}
+ *
+ * .`[perRowCol][org.jetbrains.kotlinx.dataframe.api.perRowCol]}
  *
  * ## See Also
  *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
@@ -362,7 +368,8 @@ public typealias UpdateExpression<T, C, R> = AddDataRow<T>.(C) -> R
  * [update with][org.jetbrains.kotlinx.dataframe.api.Update.with]- and [add][org.jetbrains.kotlinx.dataframe.api.add]-like expressions use [AddDataRow][org.jetbrains.kotlinx.dataframe.api.AddDataRow] instead of [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as the DSL's receiver type.
  * This is an extension to [RowValueExpression][org.jetbrains.kotlinx.dataframe.RowValueExpression] and
  * [RowExpression][org.jetbrains.kotlinx.dataframe.RowExpression] that provides access to
- * the modified/generated value of the preceding row ([AddDataRow.newValue][org.jetbrains.kotlinx.dataframe.api.AddDataRow.newValue]). ## See Also
+ * the modified/generated value of the preceding row ([AddDataRow.newValue][org.jetbrains.kotlinx.dataframe.api.AddDataRow.newValue]).
+ * ## See Also
  * - [Update per col][org.jetbrains.kotlinx.dataframe.api.Update.perCol] to provide a new value for every selected cell giving its column.
  * - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
  * @param expression The [Row Value Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample] to update the rows with.
@@ -380,6 +387,7 @@ private interface SeeAlsoWith
  * Updates selected [column group][ColumnGroup] as a [DataFrame] with the given [expression].
  *
  * Provide a new value for every selected data frame using a [dataframe expression][org.jetbrains.kotlinx.dataframe.DataFrameExpression].
+ *
  * For example:
  *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name ` { `[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { lastName } }`
@@ -427,6 +435,7 @@ private interface UpdatePerColMap
  * ## This Per Col Overload
  * Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
  *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ *
  * For example:
  *
  * `val defaults = {@includeArg [CommonUpdatePerColMapDoc][org.jetbrains.kotlinx.dataframe.api.CommonUpdatePerColMapDoc]}`
@@ -451,13 +460,15 @@ private interface CommonUpdatePerColMapDoc
  * ## This Per Col Overload
  * Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
  *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ *
  * For example:
  *
  * `val defaults = `[mapOf][mapOf]`("name" to "Empty", "age" to 0)`
  *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name and age }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { ... }.`[perCol][org.jetbrains.kotlinx.dataframe.api.perCol]`(defaults)`
  *
- * @throws IllegalArgumentException if a value for a selected cell's column is not defined in [values][values]. 
+ * @throws IllegalArgumentException if a value for a selected cell's column is not defined in [values][values].
+ *
  *
  * @param values The [Map]<[String], Value> to provide a new value for every selected cell.
  *   For each selected column, there must be a value in the map with the same name.
@@ -480,6 +491,7 @@ public fun <T, C> Update<T, C>.perCol(values: Map<String, C>): DataFrame<T> = up
  * ## This Per Col Overload
  * Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
  *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ *
  * For example:
  *
  * `val defaults = df.`[getRows][org.jetbrains.kotlinx.dataframe.DataFrame.getRows]`(`[listOf][listOf]`(0))`
@@ -488,7 +500,8 @@ public fun <T, C> Update<T, C>.perCol(values: Map<String, C>): DataFrame<T> = up
  *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name and age }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { ... }.`[perCol][org.jetbrains.kotlinx.dataframe.api.perCol]`(defaults)`
  *
- * @throws IllegalArgumentException if a value for a selected cell's column is not defined in [values][values]. .`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { "Empty" }`
+ * @throws IllegalArgumentException if a value for a selected cell's column is not defined in [values][values].
+ * .`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { "Empty" }`
  *
  *   `.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { age }.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { 0 }`
  *
@@ -517,7 +530,8 @@ public fun <T, C> Update<T, C>.perCol(values: AnyRow): DataFrame<T> = perCol(val
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { age ` { `[mean][org.jetbrains.kotlinx.dataframe.DataColumn.mean]`(skipNA = true) }`
  *
  * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { age ` { `[count][org.jetbrains.kotlinx.dataframe.DataColumn.count]` { it > 10 } }`
- *  .`[perCol][org.jetbrains.kotlinx.dataframe.api.perCol]}
+ *
+ * .`[perCol][org.jetbrains.kotlinx.dataframe.api.perCol]}
  *
  * @param valueSelector The [Column Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpression] to provide a new value for every selected cell giving its column.
  */
@@ -591,10 +605,12 @@ public fun <T, C> Update<T, C?>.notNull(expression: UpdateExpression<T, C, C>):
  * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
- * ## This Update Overload ### This overload is a combination of [update][org.jetbrains.kotlinx.dataframe.api.update] and [with][org.jetbrains.kotlinx.dataframe.api.Update.with].
+ * ## This Update Overload
+ * ### This overload is a combination of [update][org.jetbrains.kotlinx.dataframe.api.update] and [with][org.jetbrains.kotlinx.dataframe.api.Update.with].
  *
  * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
  * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
  * Provide a new value for every selected cell given its row and its previous value using a
  * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
  *
@@ -627,9 +643,11 @@ public fun <T, C> DataFrame<T>.update(
  * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
- * ## This Update Overload ### This overload is a combination of [update][org.jetbrains.kotlinx.dataframe.api.update] and [with][org.jetbrains.kotlinx.dataframe.api.Update.with].
+ * ## This Update Overload
+ * ### This overload is a combination of [update][org.jetbrains.kotlinx.dataframe.api.update] and [with][org.jetbrains.kotlinx.dataframe.api.Update.with].
  *
  * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
  * Provide a new value for every selected cell given its row and its previous value using a
  * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
  *
@@ -662,10 +680,12 @@ public fun <T, C> DataFrame<T>.update(
  * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
- * ## This Update Overload ### This overload is a combination of [update][org.jetbrains.kotlinx.dataframe.api.update] and [with][org.jetbrains.kotlinx.dataframe.api.Update.with].
+ * ## This Update Overload
+ * ### This overload is a combination of [update][org.jetbrains.kotlinx.dataframe.api.update] and [with][org.jetbrains.kotlinx.dataframe.api.Update.with].
  *
  * Select columns using their [column names][String]
  * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
  * Provide a new value for every selected cell given its row and its previous value using a
  * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
  *
@@ -708,7 +728,8 @@ private interface CommonSpecificWithDocSecondArg
  *
  * For example:
  *
- * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { id }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it < 0 }.`[withNull][org.jetbrains.kotlinx.dataframe.api.withNull]`()` 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { id }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it < 0 }.`[withNull][org.jetbrains.kotlinx.dataframe.api.withNull]`()`
+ *
  *
  */
 public fun <T, C> Update<T, C>.withNull(): DataFrame<T> = with { null }
@@ -719,7 +740,8 @@ public fun <T, C> Update<T, C>.withNull(): DataFrame<T> = with { null }
  *
  * For example:
  *
- * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { id }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it < 0 }.`[withZero][org.jetbrains.kotlinx.dataframe.api.withZero]`()` 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { id }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it < 0 }.`[withZero][org.jetbrains.kotlinx.dataframe.api.withZero]`()`
+ *
  *
  */
 public fun <T, C> Update<T, C>.withZero(): DataFrame<T> = updateWithValuePerColumnImpl { 0 as C }
@@ -730,7 +752,8 @@ public fun <T, C> Update<T, C>.withZero(): DataFrame<T> = updateWithValuePerColu
  *
  * For example:
  *
- * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { id }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it < 0 }.`[withValue][org.jetbrains.kotlinx.dataframe.api.withValue]`(-1)` 
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { id }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it < 0 }.`[withValue][org.jetbrains.kotlinx.dataframe.api.withValue]`(-1)`
+ *
  *
  *
  * @param value The value to set the selected rows to. In contrast to [with][Update.with], this must be the same exact type.
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
index 2508e858a..8ae796e8d 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
@@ -35,6 +35,20 @@ private interface DocumentationUrls {
         interface FillNA
     }
 
+    /** [See `drop` on the documentation website.](https://kotlin.github.io/dataframe/drop.html) */
+    interface Drop {
+
+        /** [See `dropNulls` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnulls) */
+        interface DropNulls
+
+        /** [See `dropNaNs` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnans) */
+        interface DropNaNs
+
+        /** [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna) */
+        interface DropNA
+
+    }
+
     /** [See Access APIs on the documentation website.](https://kotlin.github.io/dataframe/apilevels.html) */
     interface AccessApis {
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenDataFrame.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenDataFrame.kt
index dbd80df77..635e0a720 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenDataFrame.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenDataFrame.kt
@@ -19,6 +19,7 @@ internal interface ExpressionsGivenDataFrame {
 
         /**
          * Provide a new value for every selected data frame using a [dataframe expression][org.jetbrains.kotlinx.dataframe.DataFrameExpression].
+         *
          * For example:
          *
          * {@includeArg [OperationArg][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.OperationArg]}` { `[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { lastName } }`
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
index c86796cd0..16d5c1021 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
@@ -26,6 +26,7 @@ import org.jetbrains.kotlinx.dataframe.RowValueExpression as DfRowValueExpressio
  * This is an extension to [RowValueExpression][org.jetbrains.kotlinx.dataframe.RowValueExpression] and
  * [RowExpression][org.jetbrains.kotlinx.dataframe.RowExpression] that provides access to
  * the modified/generated value of the preceding row ([AddDataRow.newValue][org.jetbrains.kotlinx.dataframe.api.AddDataRow.newValue]).
+ *
  * A Row Expression is similar to a [Row Condition][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows] but that expects a [Boolean][Boolean] as result.
  */
 internal interface ExpressionsGivenRow {
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRowAndColumn.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRowAndColumn.kt
index c916bf46f..8f343c3e2 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRowAndColumn.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRowAndColumn.kt
@@ -25,6 +25,7 @@ internal interface ExpressionsGivenRowAndColumn {
 
         /**
          * Provide a new value for every selected cell given both its row and column using a [row-column expression][org.jetbrains.kotlinx.dataframe.RowColumnExpression].
+         *
          * For example:
          *
          * `df.`operation` { row, col ->`
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
index d47d5bc07..bae56aba5 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
@@ -1,8 +1,13 @@
 package org.jetbrains.kotlinx.dataframe.documentation
 
-import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.api.*
-import org.jetbrains.kotlinx.dataframe.columns.*
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.*
 import kotlin.reflect.KProperty
 
 /** {@comment
@@ -32,24 +37,27 @@ internal interface SelectingColumnsLink
  *
  * `df.`operation` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
  *
- * `df.`operation` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<Double>() }`
- *  - Select columns using their [column names][String]
+ * `df.`operation` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
+ *
+ * - Select columns using their [column names][String]
  * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
  *
  * For example:
  *
  * `df.`operation`("length", "age")`
- *  - Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ *
+ * - Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
  * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
  *
  * For example:
  *
- * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
  *
- * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<Double>()`
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
  *
  * `df.`operation`(length, age)`
- *  - Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * - Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
  *
  * For example:
  * ```kotlin
@@ -91,7 +99,7 @@ internal interface SelectingColumns {
          *
          * `df.`operation` { `[cols][ColumnsSelectionDsl.cols]`(1..5) }`
          *
-         * `df.`operation` { `[colsOf][colsOf]`<Double>() }`
+         * `df.`operation` { `[colsOf][colsOf]`<`[Double][Double]`>() }`
          *
          */
         interface WithExample
@@ -129,9 +137,9 @@ internal interface SelectingColumns {
          *
          * For example:
          *
-         * `val length by `[column]`<Double>()`
+         * `val length by `[column][column]`<`[Double][Double]`>()`
          *
-         * `val age by `[column]`<Double>()`
+         * `val age by `[column][column]`<`[Double][Double]`>()`
          *
          * `df.`operation`(length, age)`
          *
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index 1e20fd6ab..52584e2cd 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -1,22 +1,38 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.AnyCol
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
-import org.jetbrains.kotlinx.dataframe.AnyFrame
-import org.jetbrains.kotlinx.dataframe.AnyRow
-import org.jetbrains.kotlinx.dataframe.ColumnsSelector
-import org.jetbrains.kotlinx.dataframe.DataColumn
-import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.*
 import org.jetbrains.kotlinx.dataframe.api.Update.UpdateOperationArg
 import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.documentation.*
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
-import org.jetbrains.kotlinx.dataframe.kind
-import org.jetbrains.kotlinx.dataframe.typeClass
 import kotlin.reflect.KProperty
 
+/**
+ * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
+ * in cases where a mathematical operation is undefined, such as dividing by zero.
+ *
+ * You can also use [fillNaNs][fillNaNs] to replace `NaNs` in certain columns with a given value or expression
+ * or [dropNaNs][dropNaNs] to drop rows with `NaNs` in them.
+ *
+ * @see NA
+ */
+internal interface NaN
+
+/**
+ * `NA` in Dataframe can be seen as "[NaN] or `null`".
+ *
+ * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
+ * in cases where a mathematical operation is undefined, such as dividing by zero.
+ *
+ * You can also use [fillNA][fillNA] to replace `NAs` in certain columns with a given value or expression
+ * or [dropNA][dropNA] to drop rows with `NAs` in them.
+ *
+ * @see NaN
+ */
+internal interface NA
+
 // region fillNulls
 
 /**
@@ -25,7 +41,7 @@ import kotlin.reflect.KProperty
  * Replaces `null` values with given value or expression.
  * Specific case of [update].
  *
- * Check out the [`fillNulls` Operation Usage][Usage].
+ * Check out the [`fillNulls` Operation Usage][FillNulls.Usage].
  *
  * For more information: {@include [DocumentationUrls.Fill.FillNulls]}
  */
@@ -86,30 +102,6 @@ public fun <T, C> DataFrame<T>.fillNulls(columns: Iterable<ColumnReference<C>>):
 
 // endregion
 
-/**
- * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
- * in cases where a mathematical operation is undefined, such as dividing by zero.
- * In Dataframe we have helper functions to check for `NaNs`, such as [Any?.isNaN][Any.isNaN] and
- * [column.canHaveNaN][DataColumn.canHaveNaN].
- * You can also use [fillNaNs][fillNaNs] to replace `NaNs` in certain columns with a given value or expression.
- *
- * @see NA
- */
-internal interface NaN
-
-/**
- * `NA` in Dataframe can be seen as "[NaN] or `null`".
- *
- * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
- * in cases where a mathematical operation is undefined, such as dividing by zero.
- *
- * In Dataframe we have helper functions to check for `NAs`, such as [Any?.isNA][Any.isNA] and
- * [column.canHaveNA][DataColumn.canHaveNA].
- * You can also use [fillNA][fillNA] to replace `NAs` in certain columns with a given value or expression.
- * @see NaN
- */
-internal interface NA
-
 internal inline val Any?.isNaN: Boolean get() = (this is Double && isNaN()) || (this is Float && isNaN())
 
 internal inline val Any?.isNA: Boolean
@@ -138,7 +130,7 @@ internal inline val Float?.isNA: Boolean get() = this == null || this.isNaN()
  * Replaces [`NaN`][NaN] values with given value or expression.
  * Specific case of [update].
  *
- * Check out the [`fillNaNs` Operation Usage][Usage].
+ * Check out the [`fillNaNs` Operation Usage][FillNaNs.Usage].
  *
  * For more information: {@include [DocumentationUrls.Fill.FillNaNs]}
  */
@@ -207,7 +199,7 @@ public fun <T, C> DataFrame<T>.fillNaNs(columns: Iterable<ColumnReference<C>>):
  * Replaces [`NA`][NA] values with given value or expression.
  * Specific case of [update].
  *
- * Check out the [`fillNA` Operation Usage][Usage].
+ * Check out the [`fillNA` Operation Usage][FillNA.Usage].
  *
  * For more information: {@include [DocumentationUrls.Fill.FillNA]}
  */
@@ -268,32 +260,108 @@ public fun <T, C> DataFrame<T>.fillNA(columns: Iterable<ColumnReference<C>>): Up
 
 // endregion
 
+/** @param columns The {@include [SelectingColumns.DslLink]} used to select the columns of this [DataFrame] to drop rows in. */
+private interface DropDslParam
+
+
 // region dropNulls
 
-public fun <T> DataFrame<T>.dropNulls(whereAllNull: Boolean = false, selector: ColumnsSelector<T, *>): DataFrame<T> {
-    val columns = this[selector]
-    return if (whereAllNull) drop { row -> columns.all { col -> col[row] == null } }
-    else drop { row -> columns.any { col -> col[row] == null } }
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes rows with `null` values.
+ *
+ * Optionally, you can select which columns to operate on (see {@include [SelectingColumnsLink]}).
+ * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
+ * rows are dropped if any of the selected cells are `null`.
+ *
+ * For more information: {@include [DocumentationUrls.Drop.DropNulls]}
+ */
+internal interface DropNulls {
+
+    /**
+     * @param whereAllNull `false` by default.
+     *   If `true`, rows are dropped if all selected cells are `null`.
+     *   If `false`, rows are dropped if any of the selected cells is `null`.
+     */
+    interface WhereAllNullParam
+}
+
+/** {@arg [SelectingColumns.OperationArg] [dropNulls][dropNulls]} */
+private interface SetDropNullsOperationArg
+
+/**
+ * @include [DropNulls] {@comment Description of the dropNulls operation.}
+ * ## This Drop Nulls Overload
+ */
+private interface CommonDropNullsFunctionDoc
+
+/**
+ * @include [CommonDropNullsFunctionDoc]
+ * @include [SelectingColumns.Dsl.WithExample] {@include [SetDropNullsOperationArg]}
+ * `df.`[dropNulls][dropNulls]`(whereAllNull = true) { `[colsOf][colsOf]`<`[Double][Double]`>() }`
+ *
+ * @include [DropNulls.WhereAllNullParam]
+ * @include [DropDslParam]
+ */
+public fun <T> DataFrame<T>.dropNulls(whereAllNull: Boolean = false, columns: ColumnsSelector<T, *>): DataFrame<T> {
+    val cols = this[columns]
+    return if (whereAllNull) drop { row -> cols.all { col -> col[row] == null } }
+    else drop { row -> cols.any { col -> col[row] == null } }
 }
 
+/**
+ * @include [CommonDropNullsFunctionDoc]
+ * This overload operates on all columns in the [DataFrame].
+ * @include [DropNulls.WhereAllNullParam]
+ */
 public fun <T> DataFrame<T>.dropNulls(whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { all() }
 
+/**
+ * @include [CommonDropNullsFunctionDoc]
+ * @include [SelectingColumns.KProperties.WithExample] {@include [SetDropNullsOperationArg]}
+ * `df.`[dropNulls][dropNulls]`(Person::length, whereAllNull = true)`
+ * @include [DropNulls.WhereAllNullParam]
+ * @include [DropDslParam]
+ */
 public fun <T> DataFrame<T>.dropNulls(vararg columns: KProperty<*>, whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumns() }
 
+/**
+ * @include [CommonDropNullsFunctionDoc]
+ * @include [SelectingColumns.ColumnNames.WithExample] {@include [SetDropNullsOperationArg]}
+ * `df.`[dropNulls][dropNulls]`("length", whereAllNull = true)`
+ * @include [DropNulls.WhereAllNullParam]
+ * @include [DropDslParam]
+ */
 public fun <T> DataFrame<T>.dropNulls(vararg columns: String, whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumns() }
 
+/**
+ * @include [CommonDropNullsFunctionDoc]
+ * @include [SelectingColumns.ColumnAccessors.WithExample] {@include [SetDropNullsOperationArg]}
+ * `df.`[dropNulls][dropNulls]`(length, whereAllNull = true)`
+ * @include [DropNulls.WhereAllNullParam]
+ * @include [DropDslParam]
+ */
 public fun <T> DataFrame<T>.dropNulls(vararg columns: AnyColumnReference, whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumns() }
 
+/**
+ * TODO will be deprecated
+ */
 public fun <T> DataFrame<T>.dropNulls(
     columns: Iterable<AnyColumnReference>,
     whereAllNull: Boolean = false
 ): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumnSet() }
 
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes `null` values from this [DataColumn], adjusting the type accordingly.
+ */
 public fun <T> DataColumn<T?>.dropNulls(): DataColumn<T> =
     (if (!hasNulls()) this else filter { it != null }) as DataColumn<T>
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
index 01d072f10..9ace928d2 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
@@ -35,6 +35,20 @@ private interface DocumentationUrls {
         interface FillNA
     }
 
+    /** [{@include [Text]}{@arg [NameArg] `drop`}]({@include [Url]}/drop.html) */
+    interface Drop {
+
+        /** [{@include [Text]}{@arg [NameArg] `dropNulls`}]({@include [Url]}/drop.html#dropnulls) */
+        interface DropNulls
+
+        /** [{@include [Text]}{@arg [NameArg] `dropNaNs`}]({@include [Url]}/drop.html#dropnans) */
+        interface DropNaNs
+
+        /** [{@include [Text]}{@arg [NameArg] `dropNA`}]({@include [Url]}/drop.html#dropna) */
+        interface DropNA
+
+    }
+
     /** [{@include [Text]}{@arg [NameArg] Access APIs}]({@include [Url]}/apilevels.html) */
     interface AccessApis {
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
index c87c94827..33ec04c5a 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
@@ -1,8 +1,13 @@
 package org.jetbrains.kotlinx.dataframe.documentation
 
-import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.ColumnSelector
+import org.jetbrains.kotlinx.dataframe.ColumnsSelector
+import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.api.*
-import org.jetbrains.kotlinx.dataframe.columns.*
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.*
 import kotlin.reflect.KProperty
 
 /** {@comment
@@ -48,11 +53,11 @@ internal interface SelectingColumns {
          *
          * For example:
          *
-         * `df.`{@includeArg [OperationArg]}` { length `[and][ColumnsSelectionDsl.and]` age }`{@comment TODO this links up like "kotlin.String.and"}
+         * `df.`{@includeArg [OperationArg]}` { length `[and][ColumnsSelectionDsl.and]` age }`
          *
          * `df.`{@includeArg [OperationArg]}` { `[cols][ColumnsSelectionDsl.cols]`(1..5) }`
          *
-         * `df.`{@includeArg [OperationArg]}` { `[colsOf][colsOf]`<Double>() }`
+         * `df.`{@includeArg [OperationArg]}` { `[colsOf][colsOf]`<`[Double][Double]`>() }`
          * @include [SetDefaultOperationArg]
          */
         interface WithExample
@@ -88,9 +93,9 @@ internal interface SelectingColumns {
          *
          * For example:
          *
-         * `val length by `[column]`<Double>()`
+         * `val length by `[column][column]`<`[Double][Double]`>()`
          *
-         * `val age by `[column]`<Double>()`
+         * `val age by `[column][column]`<`[Double][Double]`>()`
          *
          * `df.`{@includeArg [OperationArg]}`(length, age)`
          * @include [SetDefaultOperationArg]

From cfa9b4a3403ef4d1cfff05970fb9564d5c95be62 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Mon, 20 Mar 2023 13:31:51 +0100
Subject: [PATCH 44/50] remaining docs for Nulls.kt

---
 core/build.gradle.kts                         |   4 +-
 .../dataframe/api/DataColumnArithmetics.kt    |   2 +-
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  | 417 +++++++++++++++++-
 .../kotlinx/dataframe/api/flatten.kt          |  14 +-
 .../jetbrains/kotlinx/dataframe/api/group.kt  |  10 +-
 .../jetbrains/kotlinx/dataframe/api/update.kt |   8 +-
 .../jetbrains/kotlinx/dataframe/io/html.kt    |   2 +-
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  | 189 +++++++-
 8 files changed, 594 insertions(+), 52 deletions(-)

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 8227d7795..76a53fe5d 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -14,8 +14,8 @@ plugins {
     id("org.jetbrains.kotlinx.kover")
     id("org.jmailen.kotlinter")
     id("org.jetbrains.kotlinx.dataframe")
-    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.1.0"
-//    id("nl.jolanrensen.docProcessor") version "1.0-SNAPSHOT"
+//    id("com.github.jolanrensen.docProcessorGradlePlugin") version "v0.1.0"
+    id("nl.jolanrensen.docProcessor") version "0.1.1"
 }
 
 group = "org.jetbrains.kotlinx"
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnArithmetics.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnArithmetics.kt
index 7d3531fc3..9189c41c0 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnArithmetics.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnArithmetics.kt
@@ -108,4 +108,4 @@ public infix fun <T> DataColumn<T>.neq(value: T): DataColumn<Boolean> = isMatchi
 public infix fun <T : Comparable<T>> DataColumn<T>.gt(value: T): DataColumn<Boolean> = isMatching { it > value }
 public infix fun <T : Comparable<T>> DataColumn<T>.lt(value: T): DataColumn<Boolean> = isMatching { it < value }
 
-internal infix fun <T> DataColumn<T>.isMatching(predicate: Predicate<T>): DataColumn<Boolean> = map { predicate(it) }
+internal fun <T> DataColumn<T>.isMatching(predicate: Predicate<T>): DataColumn<Boolean> = map { predicate(it) }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index 58a85b646..1f2fe2bb3 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -10,6 +10,7 @@ import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
 import kotlin.reflect.KProperty
 
 /**
+ * ## `NaN`
  * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
  * in cases where a mathematical operation is undefined, such as dividing by zero.
  *
@@ -21,6 +22,7 @@ import kotlin.reflect.KProperty
 internal interface NaN
 
 /**
+ * ## `NA`
  * `NA` in Dataframe can be seen as "[NaN] or `null`".
  *
  * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
@@ -563,13 +565,22 @@ public fun <T, C> DataFrame<T>.fillNA(columns: Iterable<ColumnReference<C>>): Up
 /** @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame] to drop rows in. */
 private interface DropDslParam
 
+/** @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] used to select the columns of this [DataFrame] to drop rows in. */
+private interface DropKPropertiesParam
+
+/** @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] used to select the columns of this [DataFrame] to drop rows in. */
+private interface DropColumnNamesParam
+
+/** @param columns The Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]). used to select the columns of this [DataFrame] to drop rows in. */
+private interface DropColumnAccessorsParam
 
 // region dropNulls
 
 /**
  * ## The Drop Nulls Operation
  *
- * Removes rows with `null` values.
+ * Removes rows with `null` values. Specific case of [drop][DataFrame.drop].
  *
  * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
  * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
@@ -592,7 +603,7 @@ private interface SetDropNullsOperationArg
 /**
  * ## The Drop Nulls Operation
  *
- * Removes rows with `null` values.
+ * Removes rows with `null` values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
  *
  * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
  * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
@@ -606,7 +617,7 @@ private interface CommonDropNullsFunctionDoc
 /**
  * ## The Drop Nulls Operation
  *
- * Removes rows with `null` values.
+ * Removes rows with `null` values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
  *
  * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
  * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
@@ -630,7 +641,6 @@ private interface CommonDropNullsFunctionDoc
  * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
  *  
  * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]`(whereAllNull = true) { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
- *
  * @param whereAllNull `false` by default.
  *   If `true`, rows are dropped if all selected cells are `null`.
  *   If `false`, rows are dropped if any of the selected cells is `null`.
@@ -645,7 +655,7 @@ public fun <T> DataFrame<T>.dropNulls(whereAllNull: Boolean = false, columns: Co
 /**
  * ## The Drop Nulls Operation
  *
- * Removes rows with `null` values.
+ * Removes rows with `null` values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
  *
  * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
  * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
@@ -664,7 +674,7 @@ public fun <T> DataFrame<T>.dropNulls(whereAllNull: Boolean = false): DataFrame<
 /**
  * ## The Drop Nulls Operation
  *
- * Removes rows with `null` values.
+ * Removes rows with `null` values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
  *
  * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
  * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
@@ -685,7 +695,7 @@ public fun <T> DataFrame<T>.dropNulls(whereAllNull: Boolean = false): DataFrame<
  * @param whereAllNull `false` by default.
  *   If `true`, rows are dropped if all selected cells are `null`.
  *   If `false`, rows are dropped if any of the selected cells is `null`.
- * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ * @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
  */
 public fun <T> DataFrame<T>.dropNulls(vararg columns: KProperty<*>, whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumns() }
@@ -693,7 +703,7 @@ public fun <T> DataFrame<T>.dropNulls(vararg columns: KProperty<*>, whereAllNull
 /**
  * ## The Drop Nulls Operation
  *
- * Removes rows with `null` values.
+ * Removes rows with `null` values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
  *
  * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
  * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
@@ -712,7 +722,7 @@ public fun <T> DataFrame<T>.dropNulls(vararg columns: KProperty<*>, whereAllNull
  * @param whereAllNull `false` by default.
  *   If `true`, rows are dropped if all selected cells are `null`.
  *   If `false`, rows are dropped if any of the selected cells is `null`.
- * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ * @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
  */
 public fun <T> DataFrame<T>.dropNulls(vararg columns: String, whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumns() }
@@ -720,7 +730,7 @@ public fun <T> DataFrame<T>.dropNulls(vararg columns: String, whereAllNull: Bool
 /**
  * ## The Drop Nulls Operation
  *
- * Removes rows with `null` values.
+ * Removes rows with `null` values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
  *
  * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
  * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
@@ -743,7 +753,8 @@ public fun <T> DataFrame<T>.dropNulls(vararg columns: String, whereAllNull: Bool
  * @param whereAllNull `false` by default.
  *   If `true`, rows are dropped if all selected cells are `null`.
  *   If `false`, rows are dropped if any of the selected cells is `null`.
- * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ * @param columns The Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]). used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
  */
 public fun <T> DataFrame<T>.dropNulls(vararg columns: AnyColumnReference, whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumns() }
@@ -753,7 +764,7 @@ public fun <T> DataFrame<T>.dropNulls(vararg columns: AnyColumnReference, whereA
  */
 public fun <T> DataFrame<T>.dropNulls(
     columns: Iterable<AnyColumnReference>,
-    whereAllNull: Boolean = false
+    whereAllNull: Boolean = false,
 ): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumnSet() }
 
@@ -769,28 +780,199 @@ public fun <T> DataColumn<T?>.dropNulls(): DataColumn<T> =
 
 // region dropNA
 
-public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false, selector: ColumnsSelector<T, *>): DataFrame<T> {
-    val columns = this[selector]
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes rows with [`NA`][NA] values. Specific case of [drop][DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][NA].
+ *
+ * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna)
+ */
+internal interface DropNA {
+
+    /**
+     * @param whereAllNA `false` by default.
+     *   If `true`, rows are dropped if all selected cells are [`NA`][NA].
+     *   If `false`, rows are dropped if any of the selected cells is [`NA`][NA].
+     */
+    interface WhereAllNAParam
+}
+
+private interface SetDropNAOperationArg
 
-    return if (whereAllNA) drop { columns.all { this[it].isNA } }
-    else drop { columns.any { this[it].isNA } }
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *
+ * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna) 
+ * ## This Drop NA Overload
+ */
+private interface CommonDropNAFunctionDoc
+
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *
+ * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna) 
+ * ## This Drop NA Overload
+ * Select or express columns using the Column(s) Selection DSL.
+ * (Any [Access Api][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ *
+ * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
+ *
+ * For example:
+ *
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]` { length `[and][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.and]` age }`
+ *
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ *
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
+ *  
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`(whereAllNA = true) { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
+ * @param whereAllNA `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false, columns: ColumnsSelector<T, *>): DataFrame<T> {
+    val cols = this[columns]
+    return if (whereAllNA) drop { cols.all { this[it].isNA } }
+    else drop { cols.any { this[it].isNA } }
 }
 
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *
+ * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna) 
+ * ## This Drop NA Overload
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ *
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`(Person::length, Person::age)`
+ *  
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`(Person::length, whereAllNA = true)`
+ * @param whereAllNA `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ * @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
 public fun <T> DataFrame<T>.dropNA(vararg columns: KProperty<*>, whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { columns.toColumns() }
 
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *
+ * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna) 
+ * ## This Drop NA Overload
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
+ * For example:
+ *
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`("length", "age")`
+ *  
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`("length", whereAllNA = true)`
+ * @param whereAllNA `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ * @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
 public fun <T> DataFrame<T>.dropNA(vararg columns: String, whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { columns.toColumns() }
 
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *
+ * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna) 
+ * ## This Drop NA Overload
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
+ * For example:
+ *
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`(length, age)`
+ *  
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`(length, whereAllNA = true)`
+ * @param whereAllNA `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ * @param columns The Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]). used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
 public fun <T> DataFrame<T>.dropNA(vararg columns: AnyColumnReference, whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { columns.toColumns() }
 
+/**
+ * TODO will be deprecated
+ */
 public fun <T> DataFrame<T>.dropNA(columns: Iterable<AnyColumnReference>, whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { columns.toColumnSet() }
 
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *
+ * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna) 
+ * ## This Drop NA Overload
+ * This overload operates on all columns in the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+ * @param whereAllNA `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ */
 public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { all() }
 
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes [`NA`][NA] values from this [DataColumn], adjusting the type accordingly.
+ */
 public fun <T> DataColumn<T?>.dropNA(): DataColumn<T> =
     when (typeClass) {
         Double::class, Float::class -> filter { !it.isNA }.cast()
@@ -798,3 +980,206 @@ public fun <T> DataColumn<T?>.dropNA(): DataColumn<T> =
     }
 
 // endregion
+
+// region dropNaNs
+
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [drop][DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNaN = true` to only drop rows where all selected cells are [`NaN`][Double.isNaN]. By default,
+ * rows are dropped if any of the selected cells are [`NaN`][Double.isNaN].
+ *
+ * For more information: [See `dropNaNs` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnans)
+ */
+internal interface DropNaNs {
+
+    /**
+     * @param whereAllNaN `false` by default.
+     *   If `true`, rows are dropped if all selected cells are [`NaN`][Double.isNaN].
+     *   If `false`, rows are dropped if any of the selected cells is [`NaN`][Double.isNaN].
+     */
+    interface WhereAllNaNParam
+}
+
+private interface SetDropNaNsOperationArg
+
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNaN = true` to only drop rows where all selected cells are [`NaN`][Double.isNaN]. By default,
+ * rows are dropped if any of the selected cells are [`NaN`][Double.isNaN].
+ *
+ * For more information: [See `dropNaNs` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnans) 
+ * ## This Drop NaNs Overload
+ */
+private interface CommonDropNaNsFunctionDoc
+
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNaN = true` to only drop rows where all selected cells are [`NaN`][Double.isNaN]. By default,
+ * rows are dropped if any of the selected cells are [`NaN`][Double.isNaN].
+ *
+ * For more information: [See `dropNaNs` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnans) 
+ * ## This Drop NaNs Overload
+ * Select or express columns using the Column(s) Selection DSL.
+ * (Any [Access Api][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ *
+ * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
+ *
+ * For example:
+ *
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]` { length `[and][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.and]` age }`
+ *
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ *
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
+ *  
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]`(whereAllNaN = true) { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
+ * @param whereAllNaN `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NaN`][Double.isNaN].
+ *   If `false`, rows are dropped if any of the selected cells is [`NaN`][Double.isNaN].
+ * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNaNs(whereAllNaN: Boolean = false, columns: ColumnsSelector<T, *>): DataFrame<T> {
+    val cols = this[columns]
+    return if (whereAllNaN) drop { cols.all { this[it].isNaN } }
+    else drop { cols.any { this[it].isNaN } }
+}
+
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNaN = true` to only drop rows where all selected cells are [`NaN`][Double.isNaN]. By default,
+ * rows are dropped if any of the selected cells are [`NaN`][Double.isNaN].
+ *
+ * For more information: [See `dropNaNs` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnans) 
+ * ## This Drop NaNs Overload
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ *
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]`(Person::length, Person::age)`
+ *  
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]`(Person::length, whereAllNaN = true)`
+ * @param whereAllNaN `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NaN`][Double.isNaN].
+ *   If `false`, rows are dropped if any of the selected cells is [`NaN`][Double.isNaN].
+ * @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNaNs(vararg columns: KProperty<*>, whereAllNaN: Boolean = false): DataFrame<T> =
+    dropNaNs(whereAllNaN) { columns.toColumns() }
+
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNaN = true` to only drop rows where all selected cells are [`NaN`][Double.isNaN]. By default,
+ * rows are dropped if any of the selected cells are [`NaN`][Double.isNaN].
+ *
+ * For more information: [See `dropNaNs` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnans) 
+ * ## This Drop NaNs Overload
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
+ * For example:
+ *
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]`("length", "age")`
+ *  
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]`("length", whereAllNaN = true)`
+ * @param whereAllNaN `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NaN`][Double.isNaN].
+ *   If `false`, rows are dropped if any of the selected cells is [`NaN`][Double.isNaN].
+ * @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNaNs(vararg columns: String, whereAllNaN: Boolean = false): DataFrame<T> =
+    dropNaNs(whereAllNaN) { columns.toColumns() }
+
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNaN = true` to only drop rows where all selected cells are [`NaN`][Double.isNaN]. By default,
+ * rows are dropped if any of the selected cells are [`NaN`][Double.isNaN].
+ *
+ * For more information: [See `dropNaNs` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnans) 
+ * ## This Drop NaNs Overload
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
+ * For example:
+ *
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]`(length, age)`
+ *  
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]`(length, whereAllNaN = true)`
+ * @param whereAllNaN `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NaN`][Double.isNaN].
+ *   If `false`, rows are dropped if any of the selected cells is [`NaN`][Double.isNaN].
+ * @param columns The Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]). used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNaNs(vararg columns: AnyColumnReference, whereAllNaN: Boolean = false): DataFrame<T> =
+    dropNaNs(whereAllNaN) { columns.toColumns() }
+
+/**
+ * TODO will be deprecated
+ */
+public fun <T> DataFrame<T>.dropNaNs(columns: Iterable<AnyColumnReference>, whereAllNaN: Boolean = false): DataFrame<T> =
+    dropNaNs(whereAllNaN) { columns.toColumnSet() }
+
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNaN = true` to only drop rows where all selected cells are [`NaN`][Double.isNaN]. By default,
+ * rows are dropped if any of the selected cells are [`NaN`][Double.isNaN].
+ *
+ * For more information: [See `dropNaNs` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnans) 
+ * ## This Drop NaNs Overload
+ * This overload operates on all columns in the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+ * @param whereAllNaN `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NaN`][Double.isNaN].
+ *   If `false`, rows are dropped if any of the selected cells is [`NaN`][Double.isNaN].
+ */
+public fun <T> DataFrame<T>.dropNaNs(whereAllNaN: Boolean = false): DataFrame<T> =
+    dropNaNs(whereAllNaN) { all() }
+
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes [`NaN`][NaN] values from this [DataColumn], adjusting the type accordingly.
+ */
+public fun <T> DataColumn<T>.dropNaNs(): DataColumn<T> =
+    when (typeClass) {
+        Double::class, Float::class -> filter { !it.isNaN }.cast()
+        else -> this
+    }
+
+// endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/flatten.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/flatten.kt
index 7d83957bb..dae7e2916 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/flatten.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/flatten.kt
@@ -2,14 +2,22 @@ package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.impl.api.flattenImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
+import kotlin.reflect.KProperty
 
 // region DataFrame
 
 public fun <T> DataFrame<T>.flatten(): DataFrame<T> = flatten { all() }
 
-public fun <T, C> DataFrame<T>.flatten(
-    columns: ColumnsSelector<T, C>
-): DataFrame<T> = flattenImpl(columns)
+public fun <T, C> DataFrame<T>.flatten(columns: ColumnsSelector<T, C>): DataFrame<T> = flattenImpl(columns)
+
+public fun <T> DataFrame<T>.flatten(vararg columns: String): DataFrame<T> = flattenImpl { columns.toColumns() }
+
+public fun <T, C> DataFrame<T>.flatten(vararg columns: KProperty<C>): DataFrame<T> = flattenImpl { columns.toColumns() }
+
+public fun <T, C> DataFrame<T>.flatten(vararg columns: ColumnReference<C>): DataFrame<T> =
+    flattenImpl { columns.toColumns() }
 
 // endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt
index c83f2db3f..d65a3bb76 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt
@@ -22,12 +22,12 @@ public fun <T> DataFrame<T>.group(vararg columns: KProperty<*>): GroupClause<T,
 @JvmName("intoString")
 @OverloadResolutionByLambdaReturnType
 @OptIn(ExperimentalTypeInference::class)
-public infix fun <T, C> GroupClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> String): DataFrame<T> = df.move(columns).under { column(it).toColumnAccessor() }
+public fun <T, C> GroupClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> String): DataFrame<T> = df.move(columns).under { column(it).toColumnAccessor() }
 
 @JvmName("intoColumn")
-public infix fun <T, C> GroupClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> AnyColumnReference): DataFrame<T> = df.move(columns).under(column)
-public infix fun <T, C> GroupClause<T, C>.into(column: String): DataFrame<T> = into(columnGroup().named(column))
-public infix fun <T, C> GroupClause<T, C>.into(column: AnyColumnGroupAccessor): DataFrame<T> = df.move(columns).under(column)
-public infix fun <T, C> GroupClause<T, C>.into(column: KProperty<*>): DataFrame<T> = into(column.columnName)
+public fun <T, C> GroupClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> AnyColumnReference): DataFrame<T> = df.move(columns).under(column)
+public fun <T, C> GroupClause<T, C>.into(column: String): DataFrame<T> = into(columnGroup().named(column))
+public fun <T, C> GroupClause<T, C>.into(column: AnyColumnGroupAccessor): DataFrame<T> = df.move(columns).under(column)
+public fun <T, C> GroupClause<T, C>.into(column: KProperty<*>): DataFrame<T> = into(column.columnName)
 
 // endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index a79f4219a..9b3feedb1 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -340,7 +340,7 @@ public fun <T, C> Update<T, C>.at(rowRange: IntRange): Update<T, C> = where { in
  *  - [Update per col][org.jetbrains.kotlinx.dataframe.api.Update.perCol] to provide a new value for every selected cell giving its column.
  * @param expression The [Row Column Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRowAndColumn.RowColumnExpression] to provide a new value for every selected cell giving its row and column.
  */
-public infix fun <T, C> Update<T, C>.perRowCol(expression: RowColumnExpression<T, C, C>): DataFrame<T> =
+public fun <T, C> Update<T, C>.perRowCol(expression: RowColumnExpression<T, C, C>): DataFrame<T> =
     updateImpl { row, column, _ -> expression(row, column) }
 
 /** [Update per row col][Update.perRowCol] to provide a new value for every selected cell giving its row and column. */
@@ -374,7 +374,7 @@ public typealias UpdateExpression<T, C, R> = AddDataRow<T>.(C) -> R
  * - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
  * @param expression The [Row Value Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample] to update the rows with.
  */
-public infix fun <T, C> Update<T, C>.with(expression: UpdateExpression<T, C, C?>): DataFrame<T> =
+public fun <T, C> Update<T, C>.with(expression: UpdateExpression<T, C, C?>): DataFrame<T> =
     updateImpl { row, _, value ->
         expression(row, value)
     }
@@ -394,7 +394,7 @@ private interface SeeAlsoWith
  * .`[asFrame][org.jetbrains.kotlinx.dataframe.api.asFrame]}
  * @param expression The [Data Frame Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.DataFrameExpression] to replace the selected column group with.
  */
-public infix fun <T, C, R> Update<T, DataRow<C>>.asFrame(expression: DataFrameExpression<C, DataFrame<R>>): DataFrame<T> =
+public fun <T, C, R> Update<T, DataRow<C>>.asFrame(expression: DataFrameExpression<C, DataFrame<R>>): DataFrame<T> =
     asFrameImpl(expression)
 
 @Deprecated(
@@ -758,4 +758,4 @@ public fun <T, C> Update<T, C>.withZero(): DataFrame<T> = updateWithValuePerColu
  *
  * @param value The value to set the selected rows to. In contrast to [with][Update.with], this must be the same exact type.
  */
-public infix fun <T, C> Update<T, C>.withValue(value: C): DataFrame<T> = with { value }
+public fun <T, C> Update<T, C>.withValue(value: C): DataFrame<T> = with { value }
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 190998df4..05f0e5d41 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
@@ -261,7 +261,7 @@ internal fun String.escapeHTML(): String {
     val str = this
     return buildString {
         for (c in str) {
-            if (c.code > 127 || c == '"' || c == '\'' || c == '<' || c == '>' || c == '&') {
+            if (c.code > 127 || c == '"' || c == '\'' || c == '<' || c == '>' || c == '&' || c == '\\') {
                 append("&#")
                 append(c.code)
                 append(';')
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index e044a6caf..50bb2f354 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -10,6 +10,7 @@ import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
 import kotlin.reflect.KProperty
 
 /**
+ * ## `NaN`
  * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
  * in cases where a mathematical operation is undefined, such as dividing by zero.
  *
@@ -21,6 +22,7 @@ import kotlin.reflect.KProperty
 internal interface NaN
 
 /**
+ * ## `NA`
  * `NA` in Dataframe can be seen as "[NaN] or `null`".
  *
  * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
@@ -263,13 +265,21 @@ public fun <T, C> DataFrame<T>.fillNA(columns: Iterable<ColumnReference<C>>): Up
 /** @param columns The {@include [SelectingColumns.DslLink]} used to select the columns of this [DataFrame] to drop rows in. */
 private interface DropDslParam
 
+/** @param columns The {@include [SelectingColumns.KPropertiesLink]} used to select the columns of this [DataFrame] to drop rows in. */
+private interface DropKPropertiesParam
+
+/** @param columns The {@include [SelectingColumns.ColumnNamesLink]} used to select the columns of this [DataFrame] to drop rows in. */
+private interface DropColumnNamesParam
+
+/** @param columns The {@include [SelectingColumns.ColumnAccessors]} used to select the columns of this [DataFrame] to drop rows in. */
+private interface DropColumnAccessorsParam
 
 // region dropNulls
 
 /**
  * ## The Drop Nulls Operation
  *
- * Removes rows with `null` values.
+ * Removes rows with `null` values. Specific case of [drop][DataFrame.drop].
  *
  * Optionally, you can select which columns to operate on (see {@include [SelectingColumnsLink]}).
  * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
@@ -300,7 +310,6 @@ private interface CommonDropNullsFunctionDoc
  * @include [CommonDropNullsFunctionDoc]
  * @include [SelectingColumns.Dsl.WithExample] {@include [SetDropNullsOperationArg]}
  * `df.`[dropNulls][dropNulls]`(whereAllNull = true) { `[colsOf][colsOf]`<`[Double][Double]`>() }`
- *
  * @include [DropNulls.WhereAllNullParam]
  * @include [DropDslParam]
  */
@@ -323,7 +332,7 @@ public fun <T> DataFrame<T>.dropNulls(whereAllNull: Boolean = false): DataFrame<
  * @include [SelectingColumns.KProperties.WithExample] {@include [SetDropNullsOperationArg]}
  * `df.`[dropNulls][dropNulls]`(Person::length, whereAllNull = true)`
  * @include [DropNulls.WhereAllNullParam]
- * @include [DropDslParam]
+ * @include [DropKPropertiesParam]
  */
 public fun <T> DataFrame<T>.dropNulls(vararg columns: KProperty<*>, whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumns() }
@@ -333,7 +342,7 @@ public fun <T> DataFrame<T>.dropNulls(vararg columns: KProperty<*>, whereAllNull
  * @include [SelectingColumns.ColumnNames.WithExample] {@include [SetDropNullsOperationArg]}
  * `df.`[dropNulls][dropNulls]`("length", whereAllNull = true)`
  * @include [DropNulls.WhereAllNullParam]
- * @include [DropDslParam]
+ * @include [DropColumnNamesParam]
  */
 public fun <T> DataFrame<T>.dropNulls(vararg columns: String, whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumns() }
@@ -343,7 +352,7 @@ public fun <T> DataFrame<T>.dropNulls(vararg columns: String, whereAllNull: Bool
  * @include [SelectingColumns.ColumnAccessors.WithExample] {@include [SetDropNullsOperationArg]}
  * `df.`[dropNulls][dropNulls]`(length, whereAllNull = true)`
  * @include [DropNulls.WhereAllNullParam]
- * @include [DropDslParam]
+ * @include [DropColumnAccessorsParam]
  */
 public fun <T> DataFrame<T>.dropNulls(vararg columns: AnyColumnReference, whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumns() }
@@ -353,7 +362,7 @@ public fun <T> DataFrame<T>.dropNulls(vararg columns: AnyColumnReference, whereA
  */
 public fun <T> DataFrame<T>.dropNulls(
     columns: Iterable<AnyColumnReference>,
-    whereAllNull: Boolean = false
+    whereAllNull: Boolean = false,
 ): DataFrame<T> =
     dropNulls(whereAllNull) { columns.toColumnSet() }
 
@@ -369,28 +378,98 @@ public fun <T> DataColumn<T?>.dropNulls(): DataColumn<T> =
 
 // region dropNA
 
-public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false, selector: ColumnsSelector<T, *>): DataFrame<T> {
-    val columns = this[selector]
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes rows with [`NA`][NA] values. Specific case of [drop][DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see {@include [SelectingColumnsLink]}).
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][NA].
+ *
+ * For more information: {@include [DocumentationUrls.Drop.DropNA]}
+ */
+internal interface DropNA {
+
+    /**
+     * @param whereAllNA `false` by default.
+     *   If `true`, rows are dropped if all selected cells are [`NA`][NA].
+     *   If `false`, rows are dropped if any of the selected cells is [`NA`][NA].
+     */
+    interface WhereAllNAParam
+}
+
+/** {@arg [SelectingColumns.OperationArg] [dropNA][dropNA]} */
+private interface SetDropNAOperationArg
+
+/**
+ * @include [DropNA] {@comment Description of the dropNA operation.}
+ * ## This Drop NA Overload
+ */
+private interface CommonDropNAFunctionDoc
 
-    return if (whereAllNA) drop { columns.all { this[it].isNA } }
-    else drop { columns.any { this[it].isNA } }
+/**
+ * @include [CommonDropNAFunctionDoc]
+ * @include [SelectingColumns.Dsl.WithExample] {@include [SetDropNAOperationArg]}
+ * `df.`[dropNA][dropNA]`(whereAllNA = true) { `[colsOf][colsOf]`<`[Double][Double]`>() }`
+ * @include [DropNA.WhereAllNAParam]
+ * @include [DropDslParam]
+ */
+public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false, columns: ColumnsSelector<T, *>): DataFrame<T> {
+    val cols = this[columns]
+    return if (whereAllNA) drop { cols.all { this[it].isNA } }
+    else drop { cols.any { this[it].isNA } }
 }
 
+/**
+ * @include [CommonDropNAFunctionDoc]
+ * @include [SelectingColumns.KProperties.WithExample] {@include [SetDropNAOperationArg]}
+ * `df.`[dropNA][dropNA]`(Person::length, whereAllNA = true)`
+ * @include [DropNA.WhereAllNAParam]
+ * @include [DropKPropertiesParam]
+ */
 public fun <T> DataFrame<T>.dropNA(vararg columns: KProperty<*>, whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { columns.toColumns() }
 
+/**
+ * @include [CommonDropNAFunctionDoc]
+ * @include [SelectingColumns.ColumnNames.WithExample] {@include [SetDropNAOperationArg]}
+ * `df.`[dropNA][dropNA]`("length", whereAllNA = true)`
+ * @include [DropNA.WhereAllNAParam]
+ * @include [DropColumnNamesParam]
+ */
 public fun <T> DataFrame<T>.dropNA(vararg columns: String, whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { columns.toColumns() }
 
+/**
+ * @include [CommonDropNAFunctionDoc]
+ * @include [SelectingColumns.ColumnAccessors.WithExample] {@include [SetDropNAOperationArg]}
+ * `df.`[dropNA][dropNA]`(length, whereAllNA = true)`
+ * @include [DropNA.WhereAllNAParam]
+ * @include [DropColumnAccessorsParam]
+ */
 public fun <T> DataFrame<T>.dropNA(vararg columns: AnyColumnReference, whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { columns.toColumns() }
 
+/**
+ * TODO will be deprecated
+ */
 public fun <T> DataFrame<T>.dropNA(columns: Iterable<AnyColumnReference>, whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { columns.toColumnSet() }
 
+/**
+ * @include [CommonDropNAFunctionDoc]
+ * This overload operates on all columns in the [DataFrame].
+ * @include [DropNA.WhereAllNAParam]
+ */
 public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { all() }
 
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes [`NA`][NA] values from this [DataColumn], adjusting the type accordingly.
+ */
 public fun <T> DataColumn<T?>.dropNA(): DataColumn<T> =
     when (typeClass) {
         Double::class, Float::class -> filter { !it.isNA }.cast()
@@ -401,28 +480,98 @@ public fun <T> DataColumn<T?>.dropNA(): DataColumn<T> =
 
 // region dropNaNs
 
-public fun <T> DataFrame<T>.dropNaNs(whereAllNaN: Boolean = false, selector: ColumnsSelector<T, *>): DataFrame<T> {
-    val cols = this[selector]
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [drop][DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see {@include [SelectingColumnsLink]}).
+ * Also, you can supply `whereAllNaN = true` to only drop rows where all selected cells are [`NaN`][Double.isNaN]. By default,
+ * rows are dropped if any of the selected cells are [`NaN`][Double.isNaN].
+ *
+ * For more information: {@include [DocumentationUrls.Drop.DropNaNs]}
+ */
+internal interface DropNaNs {
+
+    /**
+     * @param whereAllNaN `false` by default.
+     *   If `true`, rows are dropped if all selected cells are [`NaN`][Double.isNaN].
+     *   If `false`, rows are dropped if any of the selected cells is [`NaN`][Double.isNaN].
+     */
+    interface WhereAllNaNParam
+}
+
+/** {@arg [SelectingColumns.OperationArg] [dropNaNs][dropNaNs]} */
+private interface SetDropNaNsOperationArg
 
+/**
+ * @include [DropNaNs] {@comment Description of the dropNaNs operation.}
+ * ## This Drop NaNs Overload
+ */
+private interface CommonDropNaNsFunctionDoc
+
+/**
+ * @include [CommonDropNaNsFunctionDoc]
+ * @include [SelectingColumns.Dsl.WithExample] {@include [SetDropNaNsOperationArg]}
+ * `df.`[dropNaNs][dropNaNs]`(whereAllNaN = true) { `[colsOf][colsOf]`<`[Double][Double]`>() }`
+ * @include [DropNaNs.WhereAllNaNParam]
+ * @include [DropDslParam]
+ */
+public fun <T> DataFrame<T>.dropNaNs(whereAllNaN: Boolean = false, columns: ColumnsSelector<T, *>): DataFrame<T> {
+    val cols = this[columns]
     return if (whereAllNaN) drop { cols.all { this[it].isNaN } }
     else drop { cols.any { this[it].isNaN } }
 }
 
-public fun <T> DataFrame<T>.dropNaNs(vararg cols: KProperty<*>, whereAllNaN: Boolean = false): DataFrame<T> =
-    dropNaNs(whereAllNaN) { cols.toColumns() }
+/**
+ * @include [CommonDropNaNsFunctionDoc]
+ * @include [SelectingColumns.KProperties.WithExample] {@include [SetDropNaNsOperationArg]}
+ * `df.`[dropNaNs][dropNaNs]`(Person::length, whereAllNaN = true)`
+ * @include [DropNaNs.WhereAllNaNParam]
+ * @include [DropKPropertiesParam]
+ */
+public fun <T> DataFrame<T>.dropNaNs(vararg columns: KProperty<*>, whereAllNaN: Boolean = false): DataFrame<T> =
+    dropNaNs(whereAllNaN) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNaNs(vararg cols: String, whereAllNaN: Boolean = false): DataFrame<T> =
-    dropNaNs(whereAllNaN) { cols.toColumns() }
+/**
+ * @include [CommonDropNaNsFunctionDoc]
+ * @include [SelectingColumns.ColumnNames.WithExample] {@include [SetDropNaNsOperationArg]}
+ * `df.`[dropNaNs][dropNaNs]`("length", whereAllNaN = true)`
+ * @include [DropNaNs.WhereAllNaNParam]
+ * @include [DropColumnNamesParam]
+ */
+public fun <T> DataFrame<T>.dropNaNs(vararg columns: String, whereAllNaN: Boolean = false): DataFrame<T> =
+    dropNaNs(whereAllNaN) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNaNs(vararg cols: AnyColumnReference, whereAllNaN: Boolean = false): DataFrame<T> =
-    dropNaNs(whereAllNaN) { cols.toColumns() }
+/**
+ * @include [CommonDropNaNsFunctionDoc]
+ * @include [SelectingColumns.ColumnAccessors.WithExample] {@include [SetDropNaNsOperationArg]}
+ * `df.`[dropNaNs][dropNaNs]`(length, whereAllNaN = true)`
+ * @include [DropNaNs.WhereAllNaNParam]
+ * @include [DropColumnAccessorsParam]
+ */
+public fun <T> DataFrame<T>.dropNaNs(vararg columns: AnyColumnReference, whereAllNaN: Boolean = false): DataFrame<T> =
+    dropNaNs(whereAllNaN) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNaNs(cols: Iterable<AnyColumnReference>, whereAllNaN: Boolean = false): DataFrame<T> =
-    dropNaNs(whereAllNaN) { cols.toColumnSet() }
+/**
+ * TODO will be deprecated
+ */
+public fun <T> DataFrame<T>.dropNaNs(columns: Iterable<AnyColumnReference>, whereAllNaN: Boolean = false): DataFrame<T> =
+    dropNaNs(whereAllNaN) { columns.toColumnSet() }
 
+/**
+ * @include [CommonDropNaNsFunctionDoc]
+ * This overload operates on all columns in the [DataFrame].
+ * @include [DropNaNs.WhereAllNaNParam]
+ */
 public fun <T> DataFrame<T>.dropNaNs(whereAllNaN: Boolean = false): DataFrame<T> =
     dropNaNs(whereAllNaN) { all() }
 
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes [`NaN`][NaN] values from this [DataColumn], adjusting the type accordingly.
+ */
 public fun <T> DataColumn<T>.dropNaNs(): DataColumn<T> =
     when (typeClass) {
         Double::class, Float::class -> filter { !it.isNaN }.cast()

From 5d79b45287fe7c3aebfb4629ca740029afc3d6e5 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Thu, 23 Mar 2023 19:01:45 +0100
Subject: [PATCH 45/50] post master merge, small update and rendering docs

---
 .../jetbrains/kotlinx/dataframe/aliases.kt    |   11 +
 .../dataframe/api/ColumnsSelectionDsl.kt      |   94 +-
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  | 1138 ++++++++++++++++-
 .../jetbrains/kotlinx/dataframe/api/add.kt    |   27 +-
 .../jetbrains/kotlinx/dataframe/api/gather.kt |   40 +-
 .../kotlinx/dataframe/api/reorder.kt          |   18 +-
 .../jetbrains/kotlinx/dataframe/api/select.kt |   30 +-
 .../kotlinx/dataframe/api/toDataFrame.kt      |   12 +-
 .../jetbrains/kotlinx/dataframe/api/update.kt |  712 ++++++++++-
 .../dataframe/documentation/AccessApi.kt      |    9 +-
 .../documentation/SelectingColumns.kt         |    6 +-
 .../kotlinx/dataframe/impl/api/convertTo.kt   |    5 +-
 .../kotlinx/dataframe/impl/api/gather.kt      |    8 +-
 .../kotlinx/dataframe/impl/api/reorder.kt     |    4 +-
 .../kotlinx/dataframe/impl/api/update.kt      |    4 +-
 .../dataframe/impl/columns/constructors.kt    |    2 +-
 .../dataframe/api/ColumnsSelectionDsl.kt      |   86 +-
 .../dataframe/documentation/AccessApi.kt      |    9 +-
 18 files changed, 1972 insertions(+), 243 deletions(-)

diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt
index 74552bae8..064bbeb02 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt
@@ -74,6 +74,17 @@ public typealias RowValueExpression<T, C, R> = DataRow<T>.(it: C) -> R
  */
 public typealias RowColumnExpression<T, C, R> = (row: DataRow<T>, col: DataColumn<C>) -> R
 
+/**
+ * [ColumnExpression] is used to express or select any instance of `R` using the given instance of [DataColumn]`<C>` as
+ * `this` and `it`.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * DataColumn<C>.(it: DataColumn<C>) -> R
+ * ```
+ */
+public typealias ColumnExpression<C, R> = Selector<DataColumn<C>, R>
+
 /**
  * [ColumnSelector] is used to express or select a single column, represented by [SingleColumn]`<C>`, using the
  * context of [ColumnsSelectionDsl]`<T>` as `this` and `it`.
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
index 60ca70a44..00efd5892 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
@@ -11,36 +11,28 @@ import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.Predicate
-import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
-import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
-import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
-import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
-import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
-import org.jetbrains.kotlinx.dataframe.columns.renamedReference
+import org.jetbrains.kotlinx.dataframe.columns.*
+import org.jetbrains.kotlinx.dataframe.documentation.AccessApi
 import org.jetbrains.kotlinx.dataframe.hasNulls
 import org.jetbrains.kotlinx.dataframe.impl.columnName
-import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnsList
-import org.jetbrains.kotlinx.dataframe.impl.columns.DistinctColumnSet
-import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
-import org.jetbrains.kotlinx.dataframe.impl.columns.allColumnsExcept
-import org.jetbrains.kotlinx.dataframe.impl.columns.changePath
-import org.jetbrains.kotlinx.dataframe.impl.columns.createColumnSet
-import org.jetbrains.kotlinx.dataframe.impl.columns.getAt
-import org.jetbrains.kotlinx.dataframe.impl.columns.getChildrenAt
-import org.jetbrains.kotlinx.dataframe.impl.columns.single
-import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
-import org.jetbrains.kotlinx.dataframe.impl.columns.top
-import org.jetbrains.kotlinx.dataframe.impl.columns.transform
-import org.jetbrains.kotlinx.dataframe.impl.columns.transformSingle
+import org.jetbrains.kotlinx.dataframe.impl.columns.*
 import org.jetbrains.kotlinx.dataframe.impl.columns.tree.dfs
 import kotlin.reflect.KProperty
 import kotlin.reflect.KType
 import kotlin.reflect.typeOf
 
+/**
+ * Referring to a column in the selection DSL can be done in several ways corresponding to all
+ * [Access APIs][AccessApi]:
+ * TODO
+ */
+private interface CommonColumnSelectionExamples
+
+
+/** [Column Selection DSL][ColumnSelectionDsl] */
+internal interface ColumnSelectionDslLink
+
+/** TODO: Put examples and explanations here */
 public interface ColumnSelectionDsl<out T> : ColumnsContainer<T> {
 
     public operator fun <C> ColumnReference<C>.invoke(): DataColumn<C> = get(this)
@@ -56,6 +48,10 @@ public interface ColumnSelectionDsl<out T> : ColumnsContainer<T> {
     public operator fun String.get(column: String): ColumnPath = pathOf(this, column)
 }
 
+/** [Columns Selection DSL][ColumnsSelectionDsl] */
+internal interface ColumnsSelectionDslLink
+
+/** TODO: Put examples and explanations here */
 public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColumn<DataRow<T>> {
 
     public fun <C> ColumnSet<C>.first(condition: ColumnFilter<C>): SingleColumn<C> =
@@ -70,24 +66,26 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     public fun ColumnsContainer<*>.group(name: String): ColumnGroupReference = name.toColumnOf()
 
-    public operator fun String.rangeTo(endInclusive: String): ColumnSet<*> = toColumnAccessor().rangeTo(endInclusive.toColumnAccessor())
-
-    public operator fun AnyColumnReference.rangeTo(endInclusive: AnyColumnReference): ColumnSet<*> = object : ColumnSet<Any?> {
-        override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<Any?>> {
-            val startPath = this@rangeTo.resolveSingle(context)!!.path
-            val endPath = endInclusive.resolveSingle(context)!!.path
-            val parentPath = startPath.parent()!!
-            require(parentPath == endPath.parent()) { "Start and end columns have different parent column paths" }
-            val parentCol = context.df.getColumnGroup(parentPath)
-            val startIndex = parentCol.getColumnIndex(startPath.name)
-            val endIndex = parentCol.getColumnIndex(endPath.name)
-            return (startIndex..endIndex).map {
-                parentCol.getColumn(it).let {
-                    it.addPath(parentPath + it.name)
+    public operator fun String.rangeTo(endInclusive: String): ColumnSet<*> =
+        toColumnAccessor().rangeTo(endInclusive.toColumnAccessor())
+
+    public operator fun AnyColumnReference.rangeTo(endInclusive: AnyColumnReference): ColumnSet<*> =
+        object : ColumnSet<Any?> {
+            override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<Any?>> {
+                val startPath = this@rangeTo.resolveSingle(context)!!.path
+                val endPath = endInclusive.resolveSingle(context)!!.path
+                val parentPath = startPath.parent()!!
+                require(parentPath == endPath.parent()) { "Start and end columns have different parent column paths" }
+                val parentCol = context.df.getColumnGroup(parentPath)
+                val startIndex = parentCol.getColumnIndex(startPath.name)
+                val endIndex = parentCol.getColumnIndex(endPath.name)
+                return (startIndex..endIndex).map {
+                    parentCol.getColumn(it).let {
+                        it.addPath(parentPath + it.name)
+                    }
                 }
             }
         }
-    }
 
     public fun none(): ColumnSet<*> = ColumnsList<Any?>(emptyList())
 
@@ -115,7 +113,8 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     public fun <C> ColumnSet<DataRow<C>>.select(vararg columns: String): ColumnSet<*> = select { columns.toColumns() }
 
-    public fun <C, R> ColumnSet<DataRow<C>>.select(vararg columns: KProperty<R>): ColumnSet<R> = select { columns.toColumns() }
+    public fun <C, R> ColumnSet<DataRow<C>>.select(vararg columns: KProperty<R>): ColumnSet<R> =
+        select { columns.toColumns() }
 
     public fun <C, R> ColumnSet<DataRow<C>>.select(selector: ColumnsSelector<C, R>): ColumnSet<R> = createColumnSet {
         this@select.resolve(it).flatMap { group ->
@@ -145,7 +144,8 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     // region allDfs
 
-    public fun ColumnSet<*>.allDfs(includeGroups: Boolean = false): ColumnSet<Any?> = if (includeGroups) dfs { true } else dfs { !it.isColumnGroup() }
+    public fun ColumnSet<*>.allDfs(includeGroups: Boolean = false): ColumnSet<Any?> =
+        if (includeGroups) dfs { true } else dfs { !it.isColumnGroup() }
 
     public fun String.allDfs(includeGroups: Boolean = false): ColumnSet<Any?> = toColumnAccessor().allDfs(includeGroups)
 
@@ -242,7 +242,9 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     public fun <C> col(property: KProperty<C>): ColumnAccessor<C> = property.toColumnAccessor()
 
-    public operator fun ColumnSet<*>.get(colName: String): ColumnSet<Any?> = transform { it.mapNotNull { it.getChild(colName) } }
+    public operator fun ColumnSet<*>.get(colName: String): ColumnSet<Any?> =
+        transform { it.mapNotNull { it.getChild(colName) } }
+
     public operator fun <C> ColumnSet<*>.get(column: ColumnReference<C>): ColumnSet<C> = cols(column)
 
     public fun SingleColumn<AnyRow>.take(n: Int): ColumnSet<*> = transformSingle { it.children().take(n) }
@@ -288,8 +290,11 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     public infix fun <C> ColumnReference<C>.into(column: KProperty<*>): ColumnReference<C> = named(column.columnName)
 
     public infix fun String.into(newName: String): ColumnReference<Any?> = toColumnAccessor().into(newName)
-    public infix fun String.into(column: ColumnAccessor<*>): ColumnReference<Any?> = toColumnAccessor().into(column.name())
-    public infix fun String.into(column: KProperty<*>): ColumnReference<Any?> = toColumnAccessor().into(column.columnName)
+    public infix fun String.into(column: ColumnAccessor<*>): ColumnReference<Any?> =
+        toColumnAccessor().into(column.name())
+
+    public infix fun String.into(column: KProperty<*>): ColumnReference<Any?> =
+        toColumnAccessor().into(column.columnName)
 
     public infix fun <C> ColumnReference<C>.named(newName: String): ColumnReference<C> = renamedReference(newName)
     public infix fun <C> ColumnReference<C>.named(name: KProperty<*>): ColumnReference<C> = named(name.columnName)
@@ -311,6 +316,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     public infix fun <C> KProperty<C>.and(other: String): ColumnSet<Any?> = toColumnAccessor() and other
     public infix fun <C> KProperty<C>.and(other: KProperty<C>): ColumnSet<C> =
         toColumnAccessor() and other.toColumnAccessor()
+
     public infix fun <C> KProperty<C>.and(other: ColumnsSelector<T, C>): ColumnSet<C> = toColumnAccessor() and other()
 
     // endregion
@@ -339,7 +345,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 public inline fun <T, reified R> ColumnsSelectionDsl<T>.expr(
     name: String = "",
     infer: Infer = Infer.Nulls,
-    noinline expression: AddExpression<T, R>
+    noinline expression: AddExpression<T, R>,
 ): DataColumn<R> = mapToColumn(name, infer, expression)
 
 internal fun <T, C> ColumnsSelector<T, C>.filter(predicate: (ColumnWithPath<C>) -> Boolean): ColumnsSelector<T, C> =
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index 2b05fc3a9..75060155e 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -1,36 +1,206 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.AnyCol
-import org.jetbrains.kotlinx.dataframe.AnyColumnReference
-import org.jetbrains.kotlinx.dataframe.AnyFrame
-import org.jetbrains.kotlinx.dataframe.AnyRow
-import org.jetbrains.kotlinx.dataframe.ColumnsSelector
-import org.jetbrains.kotlinx.dataframe.DataColumn
-import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.api.Update.UpdateOperationArg
 import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.documentation.*
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
-import org.jetbrains.kotlinx.dataframe.kind
-import org.jetbrains.kotlinx.dataframe.typeClass
 import kotlin.reflect.KProperty
 
+/**
+ * ## `NaN`
+ * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
+ * in cases where a mathematical operation is undefined, such as dividing by zero.
+ *
+ * You can also use [fillNaNs][fillNaNs] to replace `NaNs` in certain columns with a given value or expression
+ * or [dropNaNs][dropNaNs] to drop rows with `NaNs` in them.
+ *
+ * @see NA
+ */
+internal interface NaN
+
+/**
+ * ## `NA`
+ * `NA` in Dataframe can be seen as "[NaN] or `null`".
+ *
+ * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
+ * in cases where a mathematical operation is undefined, such as dividing by zero.
+ *
+ * You can also use [fillNA][fillNA] to replace `NAs` in certain columns with a given value or expression
+ * or [dropNA][dropNA] to drop rows with `NAs` in them.
+ *
+ * @see NaN
+ */
+internal interface NA
+
 // region fillNulls
 
-public fun <T, C> DataFrame<T>.fillNulls(cols: ColumnsSelector<T, C?>): Update<T, C?> =
-    update(cols).where { it == null }
+/**
+ * ## The Fill Nulls Operation
+ *
+ * Replaces `null` values with given value or expression.
+ * Specific case of [update].
+ *
+ * Check out the [`fillNulls` Operation Usage][FillNulls.Usage].
+ *
+ * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls)
+ */
+internal interface FillNulls {
+
+    /** ## [fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls] Operation Usage
+     *
+     * [fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls] `{ `[columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]` }`
+     *
+     * - `[.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { `[rowValueCondition][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows.RowValueCondition.WithExample]` } ]`
+     *
+     * - `[.`[at][org.jetbrains.kotlinx.dataframe.api.Update.at]` (`[rowIndices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]`) ]`
+     *
+     * - `.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
+     *   | .`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
+     *   | .`[perCol][org.jetbrains.kotlinx.dataframe.api.Update.perCol]` { `[colExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpression.WithExample]` }
+     *   | .`[perRowCol][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol]` { `[rowColExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRowAndColumn.RowColumnExpression.WithExample]` }
+     *   | .`[withValue][org.jetbrains.kotlinx.dataframe.api.Update.withValue]`(value)
+     *   | .`[withNull][org.jetbrains.kotlinx.dataframe.api.Update.withNull]`()
+     *   | .`[withZero][org.jetbrains.kotlinx.dataframe.api.Update.withZero]`()
+     *   | .`[asFrame][org.jetbrains.kotlinx.dataframe.api.Update.asFrame]` { `[dataFrameExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.DataFrameExpression.WithExample]` }`
+     */
+    interface Usage
+}
+
+private interface SetFillNullsOperationArg
 
-public fun <T> DataFrame<T>.fillNulls(vararg cols: String): Update<T, Any?> =
-    fillNulls { cols.toColumns() }
+/**
+ * ## The Fill Nulls Operation
+ *
+ * Replaces `null` values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * Check out the [`fillNulls` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNulls.Usage].
+ *
+ * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill Nulls Overload
+ */
+private interface CommonFillNullsFunctionDoc
 
-public fun <T, C> DataFrame<T>.fillNulls(vararg cols: KProperty<C>): Update<T, C?> =
-    fillNulls { cols.toColumns() }
+/**
+ * ## The Fill Nulls Operation
+ *
+ * Replaces `null` values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * Check out the [`fillNulls` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNulls.Usage].
+ *
+ * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill Nulls Overload
+ * Select or express columns using the Column(s) Selection DSL.
+ * (Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ *
+ * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
+ *
+ * For example:
+ *
+ * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]` { length `[and][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.and]` age }`
+ *
+ * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ *
+ * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
+ *  
+ * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNulls(columns: ColumnsSelector<T, C?>): Update<T, C?> =
+    update(columns).where { it == null }
 
-public fun <T, C> DataFrame<T>.fillNulls(vararg cols: ColumnReference<C>): Update<T, C?> =
-    fillNulls { cols.toColumns() }
+/**
+ * ## The Fill Nulls Operation
+ *
+ * Replaces `null` values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * Check out the [`fillNulls` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNulls.Usage].
+ *
+ * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill Nulls Overload
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
+ * For example:
+ *
+ * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]`("length", "age")`
+ *  
+ * @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] belonging to this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T> DataFrame<T>.fillNulls(vararg columns: String): Update<T, Any?> =
+    fillNulls { columns.toColumns() }
 
-public fun <T, C> DataFrame<T>.fillNulls(cols: Iterable<ColumnReference<C>>): Update<T, C?> =
-    fillNulls { cols.toColumnSet() }
+/**
+ * ## The Fill Nulls Operation
+ *
+ * Replaces `null` values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * Check out the [`fillNulls` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNulls.Usage].
+ *
+ * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill Nulls Overload
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ *
+ * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]`(Person::length, Person::age)`
+ *  
+ * @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] corresponding to columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNulls(vararg columns: KProperty<C>): Update<T, C?> =
+    fillNulls { columns.toColumns() }
+
+/**
+ * ## The Fill Nulls Operation
+ *
+ * Replaces `null` values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * Check out the [`fillNulls` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNulls.Usage].
+ *
+ * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill Nulls Overload
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
+ * For example:
+ *
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `df.`[fillNulls][org.jetbrains.kotlinx.dataframe.api.fillNulls]`(length, age)`
+ *  
+ * @param columns The [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample] of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNulls(vararg columns: ColumnReference<C>): Update<T, C?> =
+    fillNulls { columns.toColumns() }
+
+/**
+ * TODO this will be deprecated
+ */
+public fun <T, C> DataFrame<T>.fillNulls(columns: Iterable<ColumnReference<C>>): Update<T, C?> =
+    fillNulls { columns.toColumnSet() }
 
 // endregion
 
@@ -56,65 +226,553 @@ internal inline val Float?.isNA: Boolean get() = this == null || this.isNaN()
 
 // region fillNaNs
 
-public fun <T, C> DataFrame<T>.fillNaNs(cols: ColumnsSelector<T, C>): Update<T, C> =
-    update(cols).where { it.isNaN }
+/**
+ * ## The Fill NaNs Operation
+ *
+ * Replaces [`NaN`][NaN] values with given value or expression.
+ * Specific case of [update].
+ *
+ * Check out the [`fillNaNs` Operation Usage][FillNaNs.Usage].
+ *
+ * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans)
+ */
+internal interface FillNaNs {
+
+    /** ## [fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs] Operation Usage
+     *
+     * [fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs] `{ `[columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]` }`
+     *
+     * - `[.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { `[rowValueCondition][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows.RowValueCondition.WithExample]` } ]`
+     *
+     * - `[.`[at][org.jetbrains.kotlinx.dataframe.api.Update.at]` (`[rowIndices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]`) ]`
+     *
+     * - `.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
+     *   | .`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
+     *   | .`[perCol][org.jetbrains.kotlinx.dataframe.api.Update.perCol]` { `[colExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpression.WithExample]` }
+     *   | .`[perRowCol][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol]` { `[rowColExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRowAndColumn.RowColumnExpression.WithExample]` }
+     *   | .`[withValue][org.jetbrains.kotlinx.dataframe.api.Update.withValue]`(value)
+     *   | .`[withNull][org.jetbrains.kotlinx.dataframe.api.Update.withNull]`()
+     *   | .`[withZero][org.jetbrains.kotlinx.dataframe.api.Update.withZero]`()
+     *   | .`[asFrame][org.jetbrains.kotlinx.dataframe.api.Update.asFrame]` { `[dataFrameExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.DataFrameExpression.WithExample]` }`
+     */
+    interface Usage
+}
 
-public fun <T> DataFrame<T>.fillNaNs(vararg cols: String): Update<T, Any?> =
-    fillNaNs { cols.toColumns() }
+internal interface SetFillNaNsOperationArg
 
-public fun <T, C> DataFrame<T>.fillNaNs(vararg cols: KProperty<C>): Update<T, C> =
-    fillNaNs { cols.toColumns() }
+/**
+ * ## The Fill NaNs Operation
+ *
+ * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.api.NaN] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * Check out the [`fillNaNs` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Usage].
+ *
+ * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill NaNs Overload
+ */
+private interface CommonFillNaNsFunctionDoc
 
-public fun <T, C> DataFrame<T>.fillNaNs(vararg cols: ColumnReference<C>): Update<T, C> =
-    fillNaNs { cols.toColumns() }
+/**
+ * ## The Fill NaNs Operation
+ *
+ * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.api.NaN] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * Check out the [`fillNaNs` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Usage].
+ *
+ * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill NaNs Overload
+ * Select or express columns using the Column(s) Selection DSL.
+ * (Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ *
+ * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
+ *
+ * For example:
+ *
+ * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]` { length `[and][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.and]` age }`
+ *
+ * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ *
+ * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
+ *  
+ * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNaNs(columns: ColumnsSelector<T, C>): Update<T, C> =
+    update(columns).where { it.isNaN }
 
-public fun <T, C> DataFrame<T>.fillNaNs(cols: Iterable<ColumnReference<C>>): Update<T, C> =
-    fillNaNs { cols.toColumnSet() }
+/**
+ * ## The Fill NaNs Operation
+ *
+ * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.api.NaN] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * Check out the [`fillNaNs` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Usage].
+ *
+ * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill NaNs Overload
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
+ * For example:
+ *
+ * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]`("length", "age")`
+ *  
+ * @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] belonging to this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T> DataFrame<T>.fillNaNs(vararg columns: String): Update<T, Any?> =
+    fillNaNs { columns.toColumns() }
+
+/**
+ * ## The Fill NaNs Operation
+ *
+ * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.api.NaN] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * Check out the [`fillNaNs` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Usage].
+ *
+ * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill NaNs Overload
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ *
+ * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]`(Person::length, Person::age)`
+ *  
+ * @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] corresponding to columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: KProperty<C>): Update<T, C> =
+    fillNaNs { columns.toColumns() }
+
+/**
+ * ## The Fill NaNs Operation
+ *
+ * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.api.NaN] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * Check out the [`fillNaNs` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Usage].
+ *
+ * For more information: [See `fillNaNs` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnans) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill NaNs Overload
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
+ * For example:
+ *
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `df.`[fillNaNs][org.jetbrains.kotlinx.dataframe.api.fillNaNs]`(length, age)`
+ *  
+ * @param columns The [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample] of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: ColumnReference<C>): Update<T, C> =
+    fillNaNs { columns.toColumns() }
+
+/**
+ * TODO this will be deprecated
+ */
+public fun <T, C> DataFrame<T>.fillNaNs(columns: Iterable<ColumnReference<C>>): Update<T, C> =
+    fillNaNs { columns.toColumnSet() }
 
 // endregion
 
 // region fillNA
 
-public fun <T, C> DataFrame<T>.fillNA(cols: ColumnsSelector<T, C?>): Update<T, C?> =
-    update(cols).where { it.isNA }
+/**
+ * ## The Fill NA Operation
+ *
+ * Replaces [`NA`][NA] values with given value or expression.
+ * Specific case of [update].
+ *
+ * Check out the [`fillNA` Operation Usage][FillNA.Usage].
+ *
+ * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna)
+ */
+internal interface FillNA {
+
+    /** ## [fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA] Operation Usage
+     *
+     * [fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA] `{ `[columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]` }`
+     *
+     * - `[.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { `[rowValueCondition][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows.RowValueCondition.WithExample]` } ]`
+     *
+     * - `[.`[at][org.jetbrains.kotlinx.dataframe.api.Update.at]` (`[rowIndices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]`) ]`
+     *
+     * - `.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
+     *   | .`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { `[rowExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample]` }
+     *   | .`[perCol][org.jetbrains.kotlinx.dataframe.api.Update.perCol]` { `[colExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpression.WithExample]` }
+     *   | .`[perRowCol][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol]` { `[rowColExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRowAndColumn.RowColumnExpression.WithExample]` }
+     *   | .`[withValue][org.jetbrains.kotlinx.dataframe.api.Update.withValue]`(value)
+     *   | .`[withNull][org.jetbrains.kotlinx.dataframe.api.Update.withNull]`()
+     *   | .`[withZero][org.jetbrains.kotlinx.dataframe.api.Update.withZero]`()
+     *   | .`[asFrame][org.jetbrains.kotlinx.dataframe.api.Update.asFrame]` { `[dataFrameExpression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.DataFrameExpression.WithExample]` }`
+     */
+    interface Usage
+}
+
+internal interface SetFillNAOperationArg
+
+/**
+ * ## The Fill NA Operation
+ *
+ * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * Check out the [`fillNA` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNA.Usage].
+ *
+ * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill NA Overload
+ */
+private interface CommonFillNAFunctionDoc
+
+/**
+ * ## The Fill NA Operation
+ *
+ * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * Check out the [`fillNA` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNA.Usage].
+ *
+ * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill NA Overload
+ * Select or express columns using the Column(s) Selection DSL.
+ * (Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ *
+ * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
+ *
+ * For example:
+ *
+ * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]` { length `[and][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.and]` age }`
+ *
+ * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ *
+ * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
+ *  
+ * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNA(columns: ColumnsSelector<T, C?>): Update<T, C?> =
+    update(columns).where { it.isNA }
 
-public fun <T> DataFrame<T>.fillNA(vararg cols: String): Update<T, Any?> =
-    fillNA { cols.toColumns() }
+/**
+ * ## The Fill NA Operation
+ *
+ * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * Check out the [`fillNA` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNA.Usage].
+ *
+ * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill NA Overload
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
+ * For example:
+ *
+ * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]`("length", "age")`
+ *  
+ * @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] belonging to this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T> DataFrame<T>.fillNA(vararg columns: String): Update<T, Any?> =
+    fillNA { columns.toColumns() }
 
-public fun <T, C> DataFrame<T>.fillNA(vararg cols: KProperty<C>): Update<T, C?> =
-    fillNA { cols.toColumns() }
+/**
+ * ## The Fill NA Operation
+ *
+ * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * Check out the [`fillNA` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNA.Usage].
+ *
+ * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill NA Overload
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ *
+ * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]`(Person::length, Person::age)`
+ *  
+ * @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] corresponding to columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNA(vararg columns: KProperty<C>): Update<T, C?> =
+    fillNA { columns.toColumns() }
 
-public fun <T, C> DataFrame<T>.fillNA(vararg cols: ColumnReference<C>): Update<T, C?> =
-    fillNA { cols.toColumns() }
+/**
+ * ## The Fill NA Operation
+ *
+ * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values with given value or expression.
+ * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
+ *
+ * Check out the [`fillNA` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNA.Usage].
+ *
+ * For more information: [See `fillNA` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillna) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Fill NA Overload
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
+ * For example:
+ *
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `df.`[fillNA][org.jetbrains.kotlinx.dataframe.api.fillNA]`(length, age)`
+ *  
+ * @param columns The [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample] of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
+public fun <T, C> DataFrame<T>.fillNA(vararg columns: ColumnReference<C>): Update<T, C?> =
+    fillNA { columns.toColumns() }
 
-public fun <T, C> DataFrame<T>.fillNA(cols: Iterable<ColumnReference<C>>): Update<T, C?> =
-    fillNA { cols.toColumnSet() }
+/**
+ * TODO this will be deprecated
+ */
+public fun <T, C> DataFrame<T>.fillNA(columns: Iterable<ColumnReference<C>>): Update<T, C?> =
+    fillNA { columns.toColumnSet() }
 
 // endregion
 
+/** @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame] to drop rows in. */
+private interface DropDslParam
+
+/** @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] used to select the columns of this [DataFrame] to drop rows in. */
+private interface DropKPropertiesParam
+
+/** @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] used to select the columns of this [DataFrame] to drop rows in. */
+private interface DropColumnNamesParam
+
+/** @param columns The Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]). used to select the columns of this [DataFrame] to drop rows in. */
+private interface DropColumnAccessorsParam
+
 // region dropNulls
 
-public fun <T> DataFrame<T>.dropNulls(whereAllNull: Boolean = false, selector: ColumnsSelector<T, *>): DataFrame<T> {
-    val cols = this[selector]
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes rows with `null` values. Specific case of [drop][DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
+ * rows are dropped if any of the selected cells are `null`.
+ *
+ * For more information: [See `dropNulls` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnulls)
+ */
+internal interface DropNulls {
+
+    /**
+     * @param whereAllNull `false` by default.
+     *   If `true`, rows are dropped if all selected cells are `null`.
+     *   If `false`, rows are dropped if any of the selected cells is `null`.
+     */
+    interface WhereAllNullParam
+}
+
+private interface SetDropNullsOperationArg
+
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes rows with `null` values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
+ * rows are dropped if any of the selected cells are `null`.
+ *
+ * For more information: [See `dropNulls` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnulls) 
+ * ## This Drop Nulls Overload
+ */
+private interface CommonDropNullsFunctionDoc
+
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes rows with `null` values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
+ * rows are dropped if any of the selected cells are `null`.
+ *
+ * For more information: [See `dropNulls` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnulls) 
+ * ## This Drop Nulls Overload
+ * Select or express columns using the Column(s) Selection DSL.
+ * (Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ *
+ * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
+ *
+ * For example:
+ *
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]` { length `[and][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.and]` age }`
+ *
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ *
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
+ *  
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]`(whereAllNull = true) { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
+ * @param whereAllNull `false` by default.
+ *   If `true`, rows are dropped if all selected cells are `null`.
+ *   If `false`, rows are dropped if any of the selected cells is `null`.
+ * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNulls(whereAllNull: Boolean = false, columns: ColumnsSelector<T, *>): DataFrame<T> {
+    val cols = this[columns]
     return if (whereAllNull) drop { row -> cols.all { col -> col[row] == null } }
     else drop { row -> cols.any { col -> col[row] == null } }
 }
 
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes rows with `null` values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
+ * rows are dropped if any of the selected cells are `null`.
+ *
+ * For more information: [See `dropNulls` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnulls) 
+ * ## This Drop Nulls Overload
+ * This overload operates on all columns in the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+ * @param whereAllNull `false` by default.
+ *   If `true`, rows are dropped if all selected cells are `null`.
+ *   If `false`, rows are dropped if any of the selected cells is `null`.
+ */
 public fun <T> DataFrame<T>.dropNulls(whereAllNull: Boolean = false): DataFrame<T> =
     dropNulls(whereAllNull) { all() }
 
-public fun <T> DataFrame<T>.dropNulls(vararg cols: KProperty<*>, whereAllNull: Boolean = false): DataFrame<T> =
-    dropNulls(whereAllNull) { cols.toColumns() }
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes rows with `null` values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
+ * rows are dropped if any of the selected cells are `null`.
+ *
+ * For more information: [See `dropNulls` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnulls) 
+ * ## This Drop Nulls Overload
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ *
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]`(Person::length, Person::age)`
+ *  
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]`(Person::length, whereAllNull = true)`
+ * @param whereAllNull `false` by default.
+ *   If `true`, rows are dropped if all selected cells are `null`.
+ *   If `false`, rows are dropped if any of the selected cells is `null`.
+ * @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNulls(vararg columns: KProperty<*>, whereAllNull: Boolean = false): DataFrame<T> =
+    dropNulls(whereAllNull) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNulls(vararg cols: String, whereAllNull: Boolean = false): DataFrame<T> =
-    dropNulls(whereAllNull) { cols.toColumns() }
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes rows with `null` values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
+ * rows are dropped if any of the selected cells are `null`.
+ *
+ * For more information: [See `dropNulls` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnulls) 
+ * ## This Drop Nulls Overload
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
+ * For example:
+ *
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]`("length", "age")`
+ *  
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]`("length", whereAllNull = true)`
+ * @param whereAllNull `false` by default.
+ *   If `true`, rows are dropped if all selected cells are `null`.
+ *   If `false`, rows are dropped if any of the selected cells is `null`.
+ * @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNulls(vararg columns: String, whereAllNull: Boolean = false): DataFrame<T> =
+    dropNulls(whereAllNull) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNulls(vararg cols: AnyColumnReference, whereAllNull: Boolean = false): DataFrame<T> =
-    dropNulls(whereAllNull) { cols.toColumns() }
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes rows with `null` values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNull = true` to only drop rows where all selected cells are `null`. By default,
+ * rows are dropped if any of the selected cells are `null`.
+ *
+ * For more information: [See `dropNulls` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnulls) 
+ * ## This Drop Nulls Overload
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
+ * For example:
+ *
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]`(length, age)`
+ *  
+ * `df.`[dropNulls][org.jetbrains.kotlinx.dataframe.api.dropNulls]`(length, whereAllNull = true)`
+ * @param whereAllNull `false` by default.
+ *   If `true`, rows are dropped if all selected cells are `null`.
+ *   If `false`, rows are dropped if any of the selected cells is `null`.
+ * @param columns The Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]). used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNulls(vararg columns: AnyColumnReference, whereAllNull: Boolean = false): DataFrame<T> =
+    dropNulls(whereAllNull) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNulls(cols: Iterable<AnyColumnReference>, whereAllNull: Boolean = false): DataFrame<T> =
-    dropNulls(whereAllNull) { cols.toColumnSet() }
+/**
+ * TODO will be deprecated
+ */
+public fun <T> DataFrame<T>.dropNulls(
+    columns: Iterable<AnyColumnReference>,
+    whereAllNull: Boolean = false,
+): DataFrame<T> =
+    dropNulls(whereAllNull) { columns.toColumnSet() }
 
+/**
+ * ## The Drop Nulls Operation
+ *
+ * Removes `null` values from this [DataColumn], adjusting the type accordingly.
+ */
 public fun <T> DataColumn<T?>.dropNulls(): DataColumn<T> =
     (if (!hasNulls()) this else filter { it != null }) as DataColumn<T>
 
@@ -122,28 +780,199 @@ public fun <T> DataColumn<T?>.dropNulls(): DataColumn<T> =
 
 // region dropNA
 
-public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false, selector: ColumnsSelector<T, *>): DataFrame<T> {
-    val cols = this[selector]
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes rows with [`NA`][NA] values. Specific case of [drop][DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][NA].
+ *
+ * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna)
+ */
+internal interface DropNA {
 
+    /**
+     * @param whereAllNA `false` by default.
+     *   If `true`, rows are dropped if all selected cells are [`NA`][NA].
+     *   If `false`, rows are dropped if any of the selected cells is [`NA`][NA].
+     */
+    interface WhereAllNAParam
+}
+
+private interface SetDropNAOperationArg
+
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *
+ * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna) 
+ * ## This Drop NA Overload
+ */
+private interface CommonDropNAFunctionDoc
+
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *
+ * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna) 
+ * ## This Drop NA Overload
+ * Select or express columns using the Column(s) Selection DSL.
+ * (Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ *
+ * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
+ *
+ * For example:
+ *
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]` { length `[and][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.and]` age }`
+ *
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ *
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
+ *  
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`(whereAllNA = true) { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
+ * @param whereAllNA `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false, columns: ColumnsSelector<T, *>): DataFrame<T> {
+    val cols = this[columns]
     return if (whereAllNA) drop { cols.all { this[it].isNA } }
     else drop { cols.any { this[it].isNA } }
 }
 
-public fun <T> DataFrame<T>.dropNA(vararg cols: KProperty<*>, whereAllNA: Boolean = false): DataFrame<T> =
-    dropNA(whereAllNA) { cols.toColumns() }
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *
+ * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna) 
+ * ## This Drop NA Overload
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ *
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`(Person::length, Person::age)`
+ *  
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`(Person::length, whereAllNA = true)`
+ * @param whereAllNA `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ * @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNA(vararg columns: KProperty<*>, whereAllNA: Boolean = false): DataFrame<T> =
+    dropNA(whereAllNA) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNA(vararg cols: String, whereAllNA: Boolean = false): DataFrame<T> =
-    dropNA(whereAllNA) { cols.toColumns() }
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *
+ * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna) 
+ * ## This Drop NA Overload
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
+ * For example:
+ *
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`("length", "age")`
+ *  
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`("length", whereAllNA = true)`
+ * @param whereAllNA `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ * @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNA(vararg columns: String, whereAllNA: Boolean = false): DataFrame<T> =
+    dropNA(whereAllNA) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNA(vararg cols: AnyColumnReference, whereAllNA: Boolean = false): DataFrame<T> =
-    dropNA(whereAllNA) { cols.toColumns() }
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *
+ * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna) 
+ * ## This Drop NA Overload
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
+ * For example:
+ *
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`(length, age)`
+ *  
+ * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`(length, whereAllNA = true)`
+ * @param whereAllNA `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ * @param columns The Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]). used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNA(vararg columns: AnyColumnReference, whereAllNA: Boolean = false): DataFrame<T> =
+    dropNA(whereAllNA) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNA(cols: Iterable<AnyColumnReference>, whereAllNA: Boolean = false): DataFrame<T> =
-    dropNA(whereAllNA) { cols.toColumnSet() }
+/**
+ * TODO will be deprecated
+ */
+public fun <T> DataFrame<T>.dropNA(columns: Iterable<AnyColumnReference>, whereAllNA: Boolean = false): DataFrame<T> =
+    dropNA(whereAllNA) { columns.toColumnSet() }
 
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *
+ * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna) 
+ * ## This Drop NA Overload
+ * This overload operates on all columns in the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+ * @param whereAllNA `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ */
 public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { all() }
 
+/**
+ * ## The Drop `NA` Operation
+ *
+ * Removes [`NA`][NA] values from this [DataColumn], adjusting the type accordingly.
+ */
 public fun <T> DataColumn<T?>.dropNA(): DataColumn<T> =
     when (typeClass) {
         Double::class, Float::class -> filter { !it.isNA }.cast()
@@ -154,28 +983,199 @@ public fun <T> DataColumn<T?>.dropNA(): DataColumn<T> =
 
 // region dropNaNs
 
-public fun <T> DataFrame<T>.dropNaNs(whereAllNaN: Boolean = false, selector: ColumnsSelector<T, *>): DataFrame<T> {
-    val cols = this[selector]
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [drop][DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNaN = true` to only drop rows where all selected cells are [`NaN`][Double.isNaN]. By default,
+ * rows are dropped if any of the selected cells are [`NaN`][Double.isNaN].
+ *
+ * For more information: [See `dropNaNs` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnans)
+ */
+internal interface DropNaNs {
+
+    /**
+     * @param whereAllNaN `false` by default.
+     *   If `true`, rows are dropped if all selected cells are [`NaN`][Double.isNaN].
+     *   If `false`, rows are dropped if any of the selected cells is [`NaN`][Double.isNaN].
+     */
+    interface WhereAllNaNParam
+}
+
+private interface SetDropNaNsOperationArg
+
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNaN = true` to only drop rows where all selected cells are [`NaN`][Double.isNaN]. By default,
+ * rows are dropped if any of the selected cells are [`NaN`][Double.isNaN].
+ *
+ * For more information: [See `dropNaNs` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnans) 
+ * ## This Drop NaNs Overload
+ */
+private interface CommonDropNaNsFunctionDoc
 
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNaN = true` to only drop rows where all selected cells are [`NaN`][Double.isNaN]. By default,
+ * rows are dropped if any of the selected cells are [`NaN`][Double.isNaN].
+ *
+ * For more information: [See `dropNaNs` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnans) 
+ * ## This Drop NaNs Overload
+ * Select or express columns using the Column(s) Selection DSL.
+ * (Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ *
+ * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
+ *
+ * For example:
+ *
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]` { length `[and][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.and]` age }`
+ *
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ *
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
+ *  
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]`(whereAllNaN = true) { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
+ * @param whereAllNaN `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NaN`][Double.isNaN].
+ *   If `false`, rows are dropped if any of the selected cells is [`NaN`][Double.isNaN].
+ * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNaNs(whereAllNaN: Boolean = false, columns: ColumnsSelector<T, *>): DataFrame<T> {
+    val cols = this[columns]
     return if (whereAllNaN) drop { cols.all { this[it].isNaN } }
     else drop { cols.any { this[it].isNaN } }
 }
 
-public fun <T> DataFrame<T>.dropNaNs(vararg cols: KProperty<*>, whereAllNaN: Boolean = false): DataFrame<T> =
-    dropNaNs(whereAllNaN) { cols.toColumns() }
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNaN = true` to only drop rows where all selected cells are [`NaN`][Double.isNaN]. By default,
+ * rows are dropped if any of the selected cells are [`NaN`][Double.isNaN].
+ *
+ * For more information: [See `dropNaNs` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnans) 
+ * ## This Drop NaNs Overload
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ *
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]`(Person::length, Person::age)`
+ *  
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]`(Person::length, whereAllNaN = true)`
+ * @param whereAllNaN `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NaN`][Double.isNaN].
+ *   If `false`, rows are dropped if any of the selected cells is [`NaN`][Double.isNaN].
+ * @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNaNs(vararg columns: KProperty<*>, whereAllNaN: Boolean = false): DataFrame<T> =
+    dropNaNs(whereAllNaN) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNaNs(vararg cols: String, whereAllNaN: Boolean = false): DataFrame<T> =
-    dropNaNs(whereAllNaN) { cols.toColumns() }
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNaN = true` to only drop rows where all selected cells are [`NaN`][Double.isNaN]. By default,
+ * rows are dropped if any of the selected cells are [`NaN`][Double.isNaN].
+ *
+ * For more information: [See `dropNaNs` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnans) 
+ * ## This Drop NaNs Overload
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
+ * For example:
+ *
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]`("length", "age")`
+ *  
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]`("length", whereAllNaN = true)`
+ * @param whereAllNaN `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NaN`][Double.isNaN].
+ *   If `false`, rows are dropped if any of the selected cells is [`NaN`][Double.isNaN].
+ * @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNaNs(vararg columns: String, whereAllNaN: Boolean = false): DataFrame<T> =
+    dropNaNs(whereAllNaN) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNaNs(vararg cols: AnyColumnReference, whereAllNaN: Boolean = false): DataFrame<T> =
-    dropNaNs(whereAllNaN) { cols.toColumns() }
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNaN = true` to only drop rows where all selected cells are [`NaN`][Double.isNaN]. By default,
+ * rows are dropped if any of the selected cells are [`NaN`][Double.isNaN].
+ *
+ * For more information: [See `dropNaNs` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnans) 
+ * ## This Drop NaNs Overload
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
+ * For example:
+ *
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]`(length, age)`
+ *  
+ * `df.`[dropNaNs][org.jetbrains.kotlinx.dataframe.api.dropNaNs]`(length, whereAllNaN = true)`
+ * @param whereAllNaN `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NaN`][Double.isNaN].
+ *   If `false`, rows are dropped if any of the selected cells is [`NaN`][Double.isNaN].
+ * @param columns The Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]). used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
+ */
+public fun <T> DataFrame<T>.dropNaNs(vararg columns: AnyColumnReference, whereAllNaN: Boolean = false): DataFrame<T> =
+    dropNaNs(whereAllNaN) { columns.toColumns() }
 
-public fun <T> DataFrame<T>.dropNaNs(cols: Iterable<AnyColumnReference>, whereAllNaN: Boolean = false): DataFrame<T> =
-    dropNaNs(whereAllNaN) { cols.toColumnSet() }
+/**
+ * TODO will be deprecated
+ */
+public fun <T> DataFrame<T>.dropNaNs(columns: Iterable<AnyColumnReference>, whereAllNaN: Boolean = false): DataFrame<T> =
+    dropNaNs(whereAllNaN) { columns.toColumnSet() }
 
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ *
+ * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
+ * Also, you can supply `whereAllNaN = true` to only drop rows where all selected cells are [`NaN`][Double.isNaN]. By default,
+ * rows are dropped if any of the selected cells are [`NaN`][Double.isNaN].
+ *
+ * For more information: [See `dropNaNs` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropnans) 
+ * ## This Drop NaNs Overload
+ * This overload operates on all columns in the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
+ * @param whereAllNaN `false` by default.
+ *   If `true`, rows are dropped if all selected cells are [`NaN`][Double.isNaN].
+ *   If `false`, rows are dropped if any of the selected cells is [`NaN`][Double.isNaN].
+ */
 public fun <T> DataFrame<T>.dropNaNs(whereAllNaN: Boolean = false): DataFrame<T> =
     dropNaNs(whereAllNaN) { all() }
 
+/**
+ * ## The Drop `NaN` Operation
+ *
+ * Removes [`NaN`][NaN] values from this [DataColumn], adjusting the type accordingly.
+ */
 public fun <T> DataColumn<T>.dropNaNs(): DataColumn<T> =
     when (typeClass) {
         Double::class, Float::class -> filter { !it.isNaN }.cast()
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
index 58c3c4804..2a9375869 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
@@ -50,7 +50,8 @@ public fun <T> DataFrame<T>.add(vararg columns: AnyBaseCol): DataFrame<T> = addA
  * @throws [UnequalColumnSizesException] if columns in expected result have different sizes
  * @return new [DataFrame] with added columns
  */
-public fun <T> DataFrame<T>.addAll(columns: Iterable<AnyBaseCol>): DataFrame<T> = dataFrameOf(columns() + columns).cast()
+public fun <T> DataFrame<T>.addAll(columns: Iterable<AnyBaseCol>): DataFrame<T> =
+    dataFrameOf(columns() + columns).cast()
 
 /**
  * Creates new [DataFrame] with all columns from given [dataFrames] added to the end of original [DataFrame.columns] list.
@@ -75,7 +76,8 @@ public fun <T> DataFrame<T>.add(vararg dataFrames: AnyFrame): DataFrame<T> = add
  * @return new [DataFrame] with added columns
  */
 @JvmName("addAllFrames")
-public fun <T> DataFrame<T>.addAll(dataFrames: Iterable<AnyFrame>): DataFrame<T> = addAll(dataFrames.flatMap { it.columns() })
+public fun <T> DataFrame<T>.addAll(dataFrames: Iterable<AnyFrame>): DataFrame<T> =
+    addAll(dataFrames.flatMap { it.columns() })
 
 // endregion
 
@@ -96,7 +98,16 @@ public interface AddDataRow<out T> : DataRow<T> {
     public fun <C> AnyRow.newValue(): C
 }
 
-public typealias AddExpression<T, C> = Selector<AddDataRow<T>, C>
+/**
+ * [AddExpression] is used to express or select any instance of `R` using the given instance of [AddDataRow]`<T>` as
+ * `this` and `it`.
+ *
+ * Shorthand for:
+ * ```kotlin
+ * AddDataRow<T>.(it: AddDataRow<T>) -> R
+ * ```
+ */
+public typealias AddExpression<T, R> = Selector<AddDataRow<T>, R>
 
 /**
  * Creates new column using row [expression] and adds it to the end of [DataFrame]
@@ -166,11 +177,15 @@ public class AddDsl<T>(@PublishedApi internal val df: DataFrame<T>) : ColumnsCon
         return df.mapToColumn("", Infer.Nulls, expression)
     }
 
-    public inline infix fun <reified R> String.from(noinline expression: RowExpression<T, R>): Boolean = add(this, Infer.Nulls, expression)
+    public inline infix fun <reified R> String.from(noinline expression: RowExpression<T, R>): Boolean =
+        add(this, Infer.Nulls, expression)
 
     // TODO: use path instead of name
-    public inline infix fun <reified R> ColumnAccessor<R>.from(noinline expression: RowExpression<T, R>): Boolean = name().from(expression)
-    public inline infix fun <reified R> KProperty<R>.from(noinline expression: RowExpression<T, R>): Boolean = add(name, Infer.Nulls, expression)
+    public inline infix fun <reified R> ColumnAccessor<R>.from(noinline expression: RowExpression<T, R>): Boolean =
+        name().from(expression)
+
+    public inline infix fun <reified R> KProperty<R>.from(noinline expression: RowExpression<T, R>): Boolean =
+        add(name, Infer.Nulls, expression)
 
     public infix fun String.from(column: AnyColumnReference): Boolean = add(column.rename(this))
     public inline infix fun <reified R> ColumnAccessor<R>.from(column: ColumnReference<R>): Boolean = name() from column
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt
index a65dfcc1f..119ab658a 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt
@@ -2,10 +2,9 @@ package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.Predicate
+import org.jetbrains.kotlinx.dataframe.RowValueFilter
 import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
-import org.jetbrains.kotlinx.dataframe.impl.and
 import org.jetbrains.kotlinx.dataframe.impl.api.gatherImpl
 import org.jetbrains.kotlinx.dataframe.impl.columnName
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
@@ -13,18 +12,33 @@ import kotlin.reflect.KProperty
 import kotlin.reflect.KType
 import kotlin.reflect.typeOf
 
-public fun <T, C> DataFrame<T>.gather(selector: ColumnsSelector<T, C>): Gather<T, C, String, C> = Gather(
-    this, selector, null, typeOf<String>(),
-    { it }, null
-)
-public fun <T> DataFrame<T>.gather(vararg columns: String): Gather<T, Any?, String, Any?> = gather { columns.toColumns() }
-public fun <T, C> DataFrame<T>.gather(vararg columns: ColumnReference<C>): Gather<T, C, String, C> = gather { columns.toColumns() }
-public fun <T, C> DataFrame<T>.gather(vararg columns: KProperty<C>): Gather<T, C, String, C> = gather { columns.toColumns() }
+public fun <T, C> DataFrame<T>.gather(selector: ColumnsSelector<T, C>): Gather<T, C, String, C> =
+    Gather(
+        df = this,
+        columns = selector,
+        filter = null,
+        keyType = typeOf<String>(),
+        keyTransform = { it },
+        valueTransform = null,
+    )
 
-public fun <T, C, K, R> Gather<T, C, K, R>.where(filter: Predicate<C>): Gather<T, C, K, R> = copy(filter = this.filter and filter)
-public fun <T, C, K, R> Gather<T, C?, K, R>.notNull(): Gather<T, C, K, R> = where { it != null } as Gather<T, C, K, R>
+public fun <T> DataFrame<T>.gather(vararg columns: String): Gather<T, Any?, String, Any?> =
+    gather { columns.toColumns() }
 
-public fun <T, C, K, R> Gather<T, C, K, R>.explodeLists(): Gather<T, C, K, R> = copy(explode = true)
+public fun <T, C> DataFrame<T>.gather(vararg columns: ColumnReference<C>): Gather<T, C, String, C> =
+    gather { columns.toColumns() }
+
+public fun <T, C> DataFrame<T>.gather(vararg columns: KProperty<C>): Gather<T, C, String, C> =
+    gather { columns.toColumns() }
+
+public fun <T, C, K, R> Gather<T, C, K, R>.where(filter: RowValueFilter<T, C>): Gather<T, C, K, R> =
+    copy(filter = this.filter and filter)
+
+public fun <T, C, K, R> Gather<T, C?, K, R>.notNull(): Gather<T, C, K, R> =
+    where { it != null } as Gather<T, C, K, R>
+
+public fun <T, C, K, R> Gather<T, C, K, R>.explodeLists(): Gather<T, C, K, R> =
+    copy(explode = true)
 
 public inline fun <T, C, reified K, R> Gather<T, C, *, R>.mapKeys(noinline transform: (String) -> K): Gather<T, C, K, R> =
     copy(keyTransform = transform as ((String) -> Nothing), keyType = typeOf<K>()) as Gather<T, C, K, R>
@@ -35,7 +49,7 @@ public fun <T, C, K, R> Gather<T, C, K, *>.mapValues(transform: (C) -> R): Gathe
 public data class Gather<T, C, K, R>(
     internal val df: DataFrame<T>,
     internal val columns: ColumnsSelector<T, C>,
-    internal val filter: ((C) -> Boolean)? = null,
+    internal val filter: RowValueFilter<T, C>? = null,
     internal val keyType: KType? = null,
     internal val keyTransform: ((String) -> K),
     internal val valueTransform: ((C) -> R)? = null,
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
index 31e8ee869..f6eb6cdfd 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
@@ -1,8 +1,8 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.ColumnExpression
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
-import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.Selector
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
@@ -21,15 +21,20 @@ public data class Reorder<T, C>(
 }
 
 public fun <T, C> DataFrame<T>.reorder(selector: ColumnsSelector<T, C>): Reorder<T, C> = Reorder(this, selector, false)
-public fun <T, C> DataFrame<T>.reorder(vararg columns: ColumnReference<C>): Reorder<T, C> = reorder { columns.toColumns() }
+public fun <T, C> DataFrame<T>.reorder(vararg columns: ColumnReference<C>): Reorder<T, C> =
+    reorder { columns.toColumns() }
+
 public fun <T, C> DataFrame<T>.reorder(vararg columns: KProperty<C>): Reorder<T, C> = reorder { columns.toColumns() }
 public fun <T> DataFrame<T>.reorder(vararg columns: String): Reorder<T, *> = reorder { columns.toColumns() }
 
-public fun <T, C, V : Comparable<V>> Reorder<T, C>.by(expression: Selector<DataColumn<C>, V>): DataFrame<T> = reorderImpl(false, expression)
+public fun <T, C, V : Comparable<V>> Reorder<T, C>.by(expression: ColumnExpression<C, V>): DataFrame<T> =
+    reorderImpl(false, expression)
 
-public fun <T, C> Reorder<T, C>.byName(desc: Boolean = false): DataFrame<T> = if (desc) byDesc { it.name } else by { it.name }
+public fun <T, C> Reorder<T, C>.byName(desc: Boolean = false): DataFrame<T> =
+    if (desc) byDesc { it.name } else by { it.name }
 
-public fun <T, C, V : Comparable<V>> Reorder<T, C>.byDesc(expression: Selector<DataColumn<C>, V>): DataFrame<T> = reorderImpl(true, expression)
+public fun <T, C, V : Comparable<V>> Reorder<T, C>.byDesc(expression: ColumnExpression<C, V>): DataFrame<T> =
+    reorderImpl(true, expression)
 
 public fun <T, V : Comparable<V>> DataFrame<T>.reorderColumnsBy(
     dfs: Boolean = true,
@@ -37,6 +42,7 @@ public fun <T, V : Comparable<V>> DataFrame<T>.reorderColumnsBy(
     expression: Selector<AnyCol, V>
 ): DataFrame<T> = Reorder(this, { if (dfs) allDfs(true) else all() }, dfs).reorderImpl(desc, expression)
 
-public fun <T> DataFrame<T>.reorderColumnsByName(dfs: Boolean = true, desc: Boolean = false): DataFrame<T> = reorderColumnsBy(dfs, desc) { name() }
+public fun <T> DataFrame<T>.reorderColumnsByName(dfs: Boolean = true, desc: Boolean = false): DataFrame<T> =
+    reorderColumnsBy(dfs, desc) { name() }
 
 // endregion
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 e134fd9dd..4a91e748f 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
@@ -10,12 +10,28 @@ import kotlin.reflect.KProperty
 
 // region DataFrame
 
-public fun <T> DataFrame<T>.select(columns: ColumnsSelector<T, *>): DataFrame<T> = get(columns).toDataFrame().cast()
-public fun <T> DataFrame<T>.select(vararg columns: KProperty<*>): DataFrame<T> = select(columns.map { it.columnName })
-public fun <T> DataFrame<T>.select(vararg columns: String): DataFrame<T> = select(columns.asIterable())
-public fun <T> DataFrame<T>.select(vararg columns: AnyColumnReference): DataFrame<T> = select { columns.toColumns() }
-@JvmName("selectT")
-public fun <T> DataFrame<T>.select(columns: Iterable<String>): DataFrame<T> = columns.map { get(it) }.toDataFrame().cast()
-public fun <T> DataFrame<T>.select(columns: Iterable<AnyColumnReference>): DataFrame<T> = select { columns.toColumnSet() }
+public fun <T> DataFrame<T>.select(columns: ColumnsSelector<T, *>): DataFrame<T> =
+    get(columns).toDataFrame().cast()
+
+public fun <T> DataFrame<T>.select(vararg columns: KProperty<*>): DataFrame<T> =
+    select(columns.asIterable())
+
+@JvmName("selectKPropertyIterable")
+public fun <T> DataFrame<T>.select(columns: Iterable<KProperty<*>>): DataFrame<T> =
+    select(columns.map { it.columnName })
+
+public fun <T> DataFrame<T>.select(vararg columns: String): DataFrame<T> =
+    select(columns.asIterable())
+
+@JvmName("selectStringIterable")
+public fun <T> DataFrame<T>.select(columns: Iterable<String>): DataFrame<T> =
+    columns.map { get(it) }.toDataFrame().cast()
+
+public fun <T> DataFrame<T>.select(vararg columns: AnyColumnReference): DataFrame<T> =
+    select { columns.toColumns() }
+
+@JvmName("selectAnyColumnReferenceIterable")
+public fun <T> DataFrame<T>.select(columns: Iterable<AnyColumnReference>): DataFrame<T> =
+    select { columns.toColumnSet() }
 
 // endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
index 943c94fa6..89d7581a2 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
@@ -23,7 +23,8 @@ public inline fun <reified T> Iterable<T>.toDataFrame(): DataFrame<T> = toDataFr
     properties()
 }
 
-public inline fun <reified T> Iterable<T>.toDataFrame(noinline body: CreateDataFrameDsl<T>.() -> Unit): DataFrame<T> = createDataFrameImpl(T::class, body)
+public inline fun <reified T> Iterable<T>.toDataFrame(noinline body: CreateDataFrameDsl<T>.() -> Unit): DataFrame<T> =
+    createDataFrameImpl(T::class, body)
 
 public inline fun <reified T> Iterable<T>.toDataFrame(vararg props: KProperty<*>, maxDepth: Int = 0): DataFrame<T> =
     toDataFrame {
@@ -76,6 +77,7 @@ public fun <T> Iterable<Pair<ColumnPath, AnyBaseCol>>.toDataFrameFromPairs(): Da
         when (path.size) {
             0 -> {
             }
+
             1 -> {
                 val name = path[0]
                 val uniqueName = nameGenerator.addUnique(name)
@@ -85,6 +87,7 @@ public fun <T> Iterable<Pair<ColumnPath, AnyBaseCol>>.toDataFrameFromPairs(): Da
                 columns.add(col.rename(uniqueName))
                 columnIndices[uniqueName] = index
             }
+
             else -> {
                 val name = path[0]
                 val uniqueName = columnGroupName.getOrPut(name) {
@@ -195,7 +198,12 @@ public fun Map<String, Iterable<Any?>>.toDataFrame(): AnyFrame {
 
 @JvmName("toDataFrameColumnPathAnyNullable")
 public fun Map<ColumnPath, Iterable<Any?>>.toDataFrame(): AnyFrame {
-    return map { it.key to DataColumn.createWithTypeInference(it.key.last(), it.value.asList()) }.toDataFrameFromPairs<Unit>()
+    return map {
+        it.key to DataColumn.createWithTypeInference(
+            it.key.last(),
+            it.value.asList()
+        )
+    }.toDataFrameFromPairs<Unit>()
 }
 
 // endregion
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index 8c719d870..ea909d48f 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -1,113 +1,761 @@
 package org.jetbrains.kotlinx.dataframe.api
 
-import org.jetbrains.kotlinx.dataframe.AnyRow
-import org.jetbrains.kotlinx.dataframe.ColumnsSelector
-import org.jetbrains.kotlinx.dataframe.DataColumn
-import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.DataFrameExpression
-import org.jetbrains.kotlinx.dataframe.DataRow
-import org.jetbrains.kotlinx.dataframe.RowColumnExpression
-import org.jetbrains.kotlinx.dataframe.RowValueExpression
-import org.jetbrains.kotlinx.dataframe.RowValueFilter
-import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.api.Update.Usage
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.documentation.*
 import org.jetbrains.kotlinx.dataframe.impl.api.asFrameImpl
 import org.jetbrains.kotlinx.dataframe.impl.api.updateImpl
 import org.jetbrains.kotlinx.dataframe.impl.api.updateWithValuePerColumnImpl
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
 import org.jetbrains.kotlinx.dataframe.impl.headPlusArray
-import org.jetbrains.kotlinx.dataframe.index
 import kotlin.reflect.KProperty
 
+/**
+ * ## The Update Operation
+ *
+ * Returns the [DataFrame] with changed values in some cells
+ * (column types can not be changed).
+ *
+ * Check out the [`update` Operation Usage][Usage].
+ *
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html)
+ */
+public data class Update<T, C>(
+    val df: DataFrame<T>,
+    val filter: RowValueFilter<T, C>?,
+    val columns: ColumnsSelector<T, C>,
+) {
+    public fun <R : C> cast(): Update<T, R> =
+        Update(df, filter as RowValueFilter<T, R>?, columns as ColumnsSelector<T, R>)
+
+    /** This argument providing the (clickable) name of the update-like function.
+     * Note: If clickable, make sure to [alias][your type].
+     */
+    internal interface UpdateOperationArg
+
+    /**
+     * ## [update][update] Operation Usage
+     *
+     * [update][update] `{ `[columns][SelectingColumns]` }`
+     *
+     * - `[.`[where][Update.where]` { `[rowValueCondition][SelectingRows.RowValueCondition.WithExample]` } ]`
+     *
+     * - `[.`[at][Update.at]` (`[rowIndices][CommonUpdateAtFunctionDoc.RowIndicesParam]`) ]`
+     *
+     * - `.`[with][Update.with]` { `[rowExpression][ExpressionsGivenRow.RowValueExpression.WithExample]` }
+     *   | .`[notNull][Update.notNull]` { `[rowExpression][ExpressionsGivenRow.RowValueExpression.WithExample]` }
+     *   | .`[perCol][Update.perCol]` { `[colExpression][ExpressionsGivenColumn.ColumnExpression.WithExample]` }
+     *   | .`[perRowCol][Update.perRowCol]` { `[rowColExpression][ExpressionsGivenRowAndColumn.RowColumnExpression.WithExample]` }
+     *   | .`[withValue][Update.withValue]`(value)
+     *   | .`[withNull][Update.withNull]`()
+     *   | .`[withZero][Update.withZero]`()
+     *   | .`[asFrame][Update.asFrame]` { `[dataFrameExpression][ExpressionsGivenDataFrame.DataFrameExpression.WithExample]` }`
+     *
+     */
+    public interface Usage
+
+    /** The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. */
+    public interface Columns
+
+    /** @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame] to update. */
+    internal interface DslParam
+
+    /** @param columns The [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample] of this [DataFrame] to update. */
+    internal interface ColumnAccessorsParam
+
+    /** @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] corresponding to columns of this [DataFrame] to update. */
+    internal interface KPropertiesParam
+
+    /** @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] belonging to this [DataFrame] to update. */
+    internal interface ColumnNamesParam
+}
+
+// region update
+
+private interface SetSelectingColumnsOperationArg
+
+/**
+ * ## The Update Operation
+ *
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types can not be changed).
+ *
+ * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
+ *
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Update Overload
+ */
+private interface CommonUpdateFunctionDoc
+
+/**
+ * ## Optional
+ * Combine `df.`[update][update]`(...).`[with][Update.with]` { ... }`
+ * into `df.`[update][update]`(...) { ... }`
+ */
+private interface UpdateWithNote
+
+/**
+ * ## The Update Operation
+ *
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types can not be changed).
+ *
+ * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
+ *
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Update Overload
+ * Select or express columns using the Column(s) Selection DSL.
+ * (Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ *
+ * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
+ * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
+ * expect you to return a [SingleColumn][org.jetbrains.kotlinx.dataframe.columns.SingleColumn] or [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet], respectively.
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { length `[and][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.and]` age }`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
+ *  
+ * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
 public fun <T, C> DataFrame<T>.update(columns: ColumnsSelector<T, C>): Update<T, C> =
     Update(this, null, columns)
 
-public fun <T, C> DataFrame<T>.update(columns: Iterable<ColumnReference<C>>): Update<T, C> =
-    update { columns.toColumnSet() }
-
+/**
+ * ## The Update Operation
+ *
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types can not be changed).
+ *
+ * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
+ *
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Update Overload
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`("length", "age")`
+ *  
+ * ## Optional
+ * Combine `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...).`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { ... }`
+ * into `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...) { ... }`
+ * @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] belonging to this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
 public fun <T> DataFrame<T>.update(vararg columns: String): Update<T, Any?> = update { columns.toColumns() }
+
+/**
+ * ## The Update Operation
+ *
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types can not be changed).
+ *
+ * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
+ *
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Update Overload
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * For example:
+ * ```kotlin
+ * data class Person(val length: Double, val age: Double)
+ * ```
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(Person::length, Person::age)`
+ *  
+ * ## Optional
+ * Combine `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...).`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { ... }`
+ * into `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...) { ... }`
+ * @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] corresponding to columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
 public fun <T, C> DataFrame<T>.update(vararg columns: KProperty<C>): Update<T, C> = update { columns.toColumns() }
+
+/**
+ * ## The Update Operation
+ *
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types can not be changed).
+ *
+ * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
+ *
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Update Overload
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
+ * For example:
+ *
+ * `val length by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `val age by `[column][org.jetbrains.kotlinx.dataframe.api.column]`<`[Double][Double]`>()`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(length, age)`
+ *  
+ * ## Optional
+ * Combine `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...).`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { ... }`
+ * into `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`(...) { ... }`
+ * @param columns The [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample] of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ */
 public fun <T, C> DataFrame<T>.update(vararg columns: ColumnReference<C>): Update<T, C> =
     update { columns.toColumns() }
 
-public data class Update<T, C>(
-    val df: DataFrame<T>,
-    val filter: RowValueFilter<T, C>?,
-    val columns: ColumnsSelector<T, C>
-) {
-    public fun <R : C> cast(): Update<T, R> =
-        Update(df, filter as RowValueFilter<T, R>?, columns as ColumnsSelector<T, R>)
-}
+/**
+ * TODO this will be deprecated
+ */
+public fun <T, C> DataFrame<T>.update(columns: Iterable<ColumnReference<C>>): Update<T, C> =
+    update { columns.toColumnSet() }
+
+// endregion
 
+/** ## Where
+ * Filter or find rows to operate on after [selecting columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] using a
+ * [row value filter][org.jetbrains.kotlinx.dataframe.RowValueFilter].
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { length }.`[where][org.jetbrains.kotlinx.dataframe.api.where]` { it > 10.0 }`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { `[cols][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.cols]`(1..5) }.`[where][org.jetbrains.kotlinx.dataframe.api.where]` { `[index][org.jetbrains.kotlinx.dataframe.index]`() > 4 && city != "Paris" }`
+ *
+ *
+ *
+ *
+ * @param predicate The [row value filter][RowValueFilter] to select the rows to update.
+ */
 public fun <T, C> Update<T, C>.where(predicate: RowValueFilter<T, C>): Update<T, C> =
     copy(filter = filter and predicate)
 
+/** ## At
+ * Only update the columns at certain given [row indices][CommonUpdateAtFunctionDoc.RowIndicesParam]:
+ *
+ * Either a [Collection]<[Int]>, an [IntRange], or just `vararg` indices.
+ *
+ * For example:
+ *
+ * `df.`[update][update]` { city }.`[at][at]`(5..10).`[with][with]` { "Paris" }`
+ *
+ * `df.`[update][update]` { name }.`[at][at]`(1, 2, 3, 4).`[with][with]` { "Empty" }`
+ *
+ * ## This At Overload
+ */
+private interface CommonUpdateAtFunctionDoc {
+
+    /** The indices of the rows to update. Either a [Collection]<[Int]>, an [IntRange], or just `vararg` indices. */
+    interface RowIndicesParam
+}
+
+/**
+ * ## At
+ * Only update the columns at certain given [row indices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]:
+ *
+ * Either a [Collection][Collection]<[Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { city }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(5..10).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Paris" }`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(1, 2, 3, 4).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Empty" }`
+ *
+ * ## This At Overload
+ *
+ * Provide a [Collection][Collection]<[Int][Int]> of row indices to update.
+ *
+ * @param rowIndices The indices of the rows to update. Either a [Collection][Collection]<[Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
+ */
 public fun <T, C> Update<T, C>.at(rowIndices: Collection<Int>): Update<T, C> = where { index in rowIndices }
+
+/**
+ * ## At
+ * Only update the columns at certain given [row indices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]:
+ *
+ * Either a [Collection][Collection]<[Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { city }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(5..10).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Paris" }`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(1, 2, 3, 4).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Empty" }`
+ *
+ * ## This At Overload
+ *
+ * Provide a `vararg` of [Ints][Int] of row indices to update.
+ *
+ * @param rowIndices The indices of the rows to update. Either a [Collection][Collection]<[Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
+ */
 public fun <T, C> Update<T, C>.at(vararg rowIndices: Int): Update<T, C> = at(rowIndices.toSet())
+
+/**
+ * ## At
+ * Only update the columns at certain given [row indices][org.jetbrains.kotlinx.dataframe.api.CommonUpdateAtFunctionDoc.RowIndicesParam]:
+ *
+ * Either a [Collection][Collection]<[Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { city }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(5..10).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Paris" }`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name }.`[at][org.jetbrains.kotlinx.dataframe.api.at]`(1, 2, 3, 4).`[with][org.jetbrains.kotlinx.dataframe.api.with]` { "Empty" }`
+ *
+ * ## This At Overload
+ *
+ * Provide an [IntRange][IntRange] of row indices to update.
+ *
+ * @param rowRange The indices of the rows to update. Either a [Collection][Collection]<[Int][Int]>, an [IntRange][IntRange], or just `vararg` indices.
+ */
 public fun <T, C> Update<T, C>.at(rowRange: IntRange): Update<T, C> = where { index in rowRange }
 
+/** ## Per Row Col
+ * Provide a new value for every selected cell given both its row and column using a [row-column expression][org.jetbrains.kotlinx.dataframe.RowColumnExpression].
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { age ` { row, col ->`
+ *
+ * `row.age / col.`[mean][org.jetbrains.kotlinx.dataframe.DataColumn.mean]`(skipNA = true)`
+ *
+ * `}`
+ *
+ *
+ * .`[perRowCol][org.jetbrains.kotlinx.dataframe.api.perRowCol]}
+ *
+ * ## See Also
+ *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
+ *  - [Update per col][org.jetbrains.kotlinx.dataframe.api.Update.perCol] to provide a new value for every selected cell giving its column.
+ * @param expression The [Row Column Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRowAndColumn.RowColumnExpression] to provide a new value for every selected cell giving its row and column.
+ */
 public fun <T, C> Update<T, C>.perRowCol(expression: RowColumnExpression<T, C, C>): DataFrame<T> =
     updateImpl { row, column, _ -> expression(row, column) }
 
+/** [Update per row col][Update.perRowCol] to provide a new value for every selected cell giving its row and column. */
+private interface SeeAlsoPerRowCol
+
+/** ## Update Expression
+ * @see ExpressionsGivenRow.RowValueExpression.WithExample
+ * @see ExpressionsGivenRow.AddDataRowNote
+ */ // doc processor plugin does not work with type aliases yet
 public typealias UpdateExpression<T, C, R> = AddDataRow<T>.(C) -> R
 
+/** ## With
+ * Provide a new value for every selected cell given its row and its previous value using a
+ * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
+ *
+ * For example:
+ *
+ * `df.`[update][update]` { city }.`[with][with]` { name.firstName + " from " + it }`
+ *
+ * `df.`[update][update]` { city }.`[with][with]` { it.uppercase() }`
+ *
+ *
+ *
+ * ## Note
+ * [update with][org.jetbrains.kotlinx.dataframe.api.Update.with]- and [add][org.jetbrains.kotlinx.dataframe.api.add]-like expressions use [AddDataRow][org.jetbrains.kotlinx.dataframe.api.AddDataRow] instead of [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as the DSL's receiver type.
+ * This is an extension to [RowValueExpression][org.jetbrains.kotlinx.dataframe.RowValueExpression] and
+ * [RowExpression][org.jetbrains.kotlinx.dataframe.RowExpression] that provides access to
+ * the modified/generated value of the preceding row ([AddDataRow.newValue][org.jetbrains.kotlinx.dataframe.api.AddDataRow.newValue]).
+ * ## See Also
+ * - [Update per col][org.jetbrains.kotlinx.dataframe.api.Update.perCol] to provide a new value for every selected cell giving its column.
+ * - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
+ * @param expression The [Row Value Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample] to update the rows with.
+ */
 public fun <T, C> Update<T, C>.with(expression: UpdateExpression<T, C, C?>): DataFrame<T> =
     updateImpl { row, _, value ->
         expression(row, value)
     }
 
+/** [Update with][Update.with] to provide a new value for every selected cell giving its row. */
+private interface SeeAlsoWith
+
+/** ## As Frame
+ *
+ * Updates selected [column group][ColumnGroup] as a [DataFrame] with the given [expression].
+ *
+ * Provide a new value for every selected data frame using a [dataframe expression][org.jetbrains.kotlinx.dataframe.DataFrameExpression].
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name ` { `[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { lastName } }`
+ * .`[asFrame][org.jetbrains.kotlinx.dataframe.api.asFrame]}
+ * @param expression The [Data Frame Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenDataFrame.DataFrameExpression] to replace the selected column group with.
+ */
 public fun <T, C, R> Update<T, DataRow<C>>.asFrame(expression: DataFrameExpression<C, DataFrame<R>>): DataFrame<T> =
     asFrameImpl(expression)
 
+@Deprecated(
+    "Useless unless in combination with `withValue(null)`, but then users can just use `with { null }`...",
+    ReplaceWith("this as Update<T, C?>")
+)
 public fun <T, C> Update<T, C>.asNullable(): Update<T, C?> = this as Update<T, C?>
 
+/** ## Per Col
+ *
+ * Per Col can be used for two different types of operations:
+ *  - Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
+ *  - Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ *
+ * ## See Also
+ *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
+ *  - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
+ * ## This Per Col Overload
+ */
+private interface CommonUpdatePerColDoc
+
+/** Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][DataRow] as Map. */
+private interface UpdatePerColMap
+
+/**
+ * ## Per Col
+ *
+ * Per Col can be used for two different types of operations:
+ *  - Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
+ *  - Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ *
+ * ## See Also
+ *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
+ *  - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
+ * ## This Per Col Overload
+ * Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ *
+ * For example:
+ *
+ * `val defaults = {@includeArg [CommonUpdatePerColMapDoc][org.jetbrains.kotlinx.dataframe.api.CommonUpdatePerColMapDoc]}`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name and age }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { ... }.`[perCol][org.jetbrains.kotlinx.dataframe.api.perCol]`(defaults)`
+ *
+ * @throws IllegalArgumentException if a value for a selected cell's column is not defined in [values\].
+ */
+private interface CommonUpdatePerColMapDoc
+
+/**
+ * ## Per Col
+ *
+ * Per Col can be used for two different types of operations:
+ *  - Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
+ *  - Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ *
+ * ## See Also
+ *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
+ *  - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
+ * ## This Per Col Overload
+ * Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ *
+ * For example:
+ *
+ * `val defaults = `[mapOf][mapOf]`("name" to "Empty", "age" to 0)`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name and age }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { ... }.`[perCol][org.jetbrains.kotlinx.dataframe.api.perCol]`(defaults)`
+ *
+ * @throws IllegalArgumentException if a value for a selected cell's column is not defined in [values][values].
+ *
+ *
+ * @param values The [Map]<[String], Value> to provide a new value for every selected cell.
+ *   For each selected column, there must be a value in the map with the same name.
+ */
 public fun <T, C> Update<T, C>.perCol(values: Map<String, C>): DataFrame<T> = updateWithValuePerColumnImpl {
     values[it.name()] ?: throw IllegalArgumentException("Update value for column ${it.name()} is not defined")
 }
 
+/**
+ * ## Per Col
+ *
+ * Per Col can be used for two different types of operations:
+ *  - Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
+ *  - Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ *
+ * ## See Also
+ *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
+ *  - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
+ * ## This Per Col Overload
+ * Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ *
+ * For example:
+ *
+ * `val defaults = df.`[getRows][org.jetbrains.kotlinx.dataframe.DataFrame.getRows]`(`[listOf][listOf]`(0))`
+ *
+ *   `.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name `
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { name and age }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { ... }.`[perCol][org.jetbrains.kotlinx.dataframe.api.perCol]`(defaults)`
+ *
+ * @throws IllegalArgumentException if a value for a selected cell's column is not defined in [values][values].
+ * .`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { "Empty" }`
+ *
+ *   `.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { age }.`[with][org.jetbrains.kotlinx.dataframe.api.Update.with]` { 0 }`
+ *
+ *   `.first()}
+ *
+ * @param values The [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] to provide a new value for every selected cell.
+ */
 public fun <T, C> Update<T, C>.perCol(values: AnyRow): DataFrame<T> = perCol(values.toMap() as Map<String, C>)
 
-public fun <T, C> Update<T, C>.perCol(valueSelector: Selector<DataColumn<C>, C>): DataFrame<T> =
+/**
+ * ## Per Col
+ *
+ * Per Col can be used for two different types of operations:
+ *  - Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
+ *  - Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>`
+ *  or [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as Map.
+ *
+ * ## See Also
+ *  - [Update with][org.jetbrains.kotlinx.dataframe.api.Update.with] to provide a new value for every selected cell giving its row.
+ *  - [Update per row col][org.jetbrains.kotlinx.dataframe.api.Update.perRowCol] to provide a new value for every selected cell giving its row and column.
+ * ## This Per Col Overload
+ * Provide a new value for every selected cell given its column using a [column expression][org.jetbrains.kotlinx.dataframe.ColumnExpression].
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { age ` { `[mean][org.jetbrains.kotlinx.dataframe.DataColumn.mean]`(skipNA = true) }`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { age ` { `[count][org.jetbrains.kotlinx.dataframe.DataColumn.count]` { it > 10 } }`
+ *
+ * .`[perCol][org.jetbrains.kotlinx.dataframe.api.perCol]}
+ *
+ * @param valueSelector The [Column Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenColumn.ColumnExpression] to provide a new value for every selected cell giving its column.
+ */
+public fun <T, C> Update<T, C>.perCol(valueSelector: ColumnExpression<C, C>): DataFrame<T> =
     updateWithValuePerColumnImpl(valueSelector)
 
+/** [Update per col][Update.perCol] to provide a new value for every selected cell giving its column. */
+private interface SeeAlsoPerCol
+
+/** Chains up two row value filters together. */
 internal infix fun <T, C> RowValueFilter<T, C>?.and(other: RowValueFilter<T, C>): RowValueFilter<T, C> {
     if (this == null) return other
     val thisExp = this
     return { thisExp(this, it) && other(this, it) }
 }
 
+/** ## Not Null
+ *
+ * Selects only the rows where the values in the selected columns are not null.
+ *
+ * Shorthand for: [update][org.jetbrains.kotlinx.dataframe.api.update]` { ... }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it != null }`
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Number][Number]`?>() }.`[notNull][org.jetbrains.kotlinx.dataframe.api.notNull]`()`.[perCol][org.jetbrains.kotlinx.dataframe.api.Update.perCol] `{ `[mean][org.jetbrains.kotlinx.dataframe.api.mean]`() }`
+ *
+ * ### Optional
+ * Provide an [expression][expression] to update the rows with.
+ * This combines [with][org.jetbrains.kotlinx.dataframe.api.Update.with] with [notNull][org.jetbrains.kotlinx.dataframe.api.notNull].
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { city }.`[notNull][org.jetbrains.kotlinx.dataframe.api.Update.notNull]` { it.`[toUpperCase][String.toUpperCase]`() }`
+ *
+ * @param expression Optional [Row Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowExpression.WithExample] to update the rows with. */
 public fun <T, C> Update<T, C?>.notNull(): Update<T, C> =
-    copy(filter = filter and { it != null }) as Update<T, C>
+    where { it != null } as Update<T, C>
 
-public fun <T, C> Update<T, C?>.notNull(expression: RowValueExpression<T, C, C>): DataFrame<T> =
-    notNull().updateImpl { row, column, value ->
-        expression(row, value)
-    }
+/**
+ * ## Not Null
+ *
+ * Selects only the rows where the values in the selected columns are not null.
+ *
+ * Shorthand for: [update][update]` { ... }.`[where][Update.where]` { it != null }`
+ *
+ * For example:
+ *
+ * `df.`[update][update]` { `[colsOf][colsOf]`<`[Number][Number]`?>() }.`[notNull][notNull]`()`.[perCol][Update.perCol] `{ `[mean][mean]`() }`
+ *
+ * ### Optional
+ * Provide an [expression] to update the rows with.
+ * This combines [with][Update.with] with [notNull].
+ *
+ * For example:
+ *
+ * `df.`[update][update]` { city }.`[notNull][Update.notNull]` { it.`[toUpperCase][String.toUpperCase]`() }`
+ *
+ * @param expression Optional [Row Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowExpression.WithExample] to update the rows with.
+ */
+public fun <T, C> Update<T, C?>.notNull(expression: UpdateExpression<T, C, C>): DataFrame<T> =
+    notNull().with(expression)
 
+/**
+ * ## The Update Operation
+ *
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types can not be changed).
+ *
+ * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
+ *
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Update Overload
+ * ### This overload is a combination of [update][org.jetbrains.kotlinx.dataframe.api.update] and [with][org.jetbrains.kotlinx.dataframe.api.Update.with].
+ *
+ * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
+ * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
+ *
+ * Provide a new value for every selected cell given its row and its previous value using a
+ * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`("city")` ` { name.firstName + " from " + it }`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`("city")` ` { it.uppercase() }`
+ *
+ *
+ *
+ * @param columns The [Column references][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnAccessors.WithExample] of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ * @param expression The [Row Value Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample] to update the rows with.
+ */
 public fun <T, C> DataFrame<T>.update(
     firstCol: ColumnReference<C>,
     vararg cols: ColumnReference<C>,
-    expression: RowValueExpression<T, C, C>
+    expression: UpdateExpression<T, C, C>
 ): DataFrame<T> =
     update(*headPlusArray(firstCol, cols)).with(expression)
 
+/**
+ * ## The Update Operation
+ *
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types can not be changed).
+ *
+ * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
+ *
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Update Overload
+ * ### This overload is a combination of [update][org.jetbrains.kotlinx.dataframe.api.update] and [with][org.jetbrains.kotlinx.dataframe.api.Update.with].
+ *
+ * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
+ *
+ * Provide a new value for every selected cell given its row and its previous value using a
+ * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`("city")` ` { name.firstName + " from " + it }`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`("city")` ` { it.uppercase() }`
+ *
+ *
+ *
+ * @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] corresponding to columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ * @param expression The [Row Value Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample] to update the rows with.
+ */
 public fun <T, C> DataFrame<T>.update(
     firstCol: KProperty<C>,
     vararg cols: KProperty<C>,
-    expression: RowValueExpression<T, C, C>
+    expression: UpdateExpression<T, C, C>
 ): DataFrame<T> =
     update(*headPlusArray(firstCol, cols)).with(expression)
 
+/**
+ * ## The Update Operation
+ *
+ * Returns the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] with changed values in some cells
+ * (column types can not be changed).
+ *
+ * Check out the [`update` Operation Usage][org.jetbrains.kotlinx.dataframe.api.Update.Usage].
+ *
+ * For more information: [See `update` on the documentation website.](https://kotlin.github.io/dataframe/update.html) 
+ * ## ‎
+ * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ * ## This Update Overload
+ * ### This overload is a combination of [update][org.jetbrains.kotlinx.dataframe.api.update] and [with][org.jetbrains.kotlinx.dataframe.api.Update.with].
+ *
+ * Select columns using their [column names][String]
+ * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
+ *
+ * Provide a new value for every selected cell given its row and its previous value using a
+ * [row value expression][org.jetbrains.kotlinx.dataframe.RowValueExpression].
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`("city")` ` { name.firstName + " from " + it }`
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]`("city")` ` { it.uppercase() }`
+ *
+ *
+ *
+ * @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] belonging to this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to update.
+ * @param expression The [Row Value Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowValueExpression.WithExample] to update the rows with.
+ */
 public fun <T> DataFrame<T>.update(
     firstCol: String,
     vararg cols: String,
-    expression: RowValueExpression<T, Any?, Any?>
+    expression: UpdateExpression<T, Any?, Any?>
 ): DataFrame<T> =
     update(*headPlusArray(firstCol, cols)).with(expression)
 
-public fun <T, C> Update<T, C>.withNull(): DataFrame<T> = asNullable().withValue(null)
+/**
+ * Specific version of [with] that simply sets the value of each selected row to {@includeArg [CommonSpecificWithDocFirstArg]}.
+ *
+ * For example:
+ *
+ * `df.`[update][update]` { id }.`[where][Update.where]` { it < 0 }.`{@includeArg [CommonSpecificWithDocSecondArg]}`
+ */
+private interface CommonSpecificWithDoc
+
+/** Arg for the resulting value */
+private interface CommonSpecificWithDocFirstArg
+
+/** Arg for the function call */
+private interface CommonSpecificWithDocSecondArg
+
+/**
+ * ## With Null
+ * Specific version of [with][org.jetbrains.kotlinx.dataframe.api.with] that simply sets the value of each selected row to `null`.
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { id }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it < 0 }.`[withNull][org.jetbrains.kotlinx.dataframe.api.withNull]`()`
+ *
+ *
+ */
+public fun <T, C> Update<T, C>.withNull(): DataFrame<T> = with { null }
 
+/**
+ * ## With Zero
+ * Specific version of [with][org.jetbrains.kotlinx.dataframe.api.with] that simply sets the value of each selected row to `0`.
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { id }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it < 0 }.`[withZero][org.jetbrains.kotlinx.dataframe.api.withZero]`()`
+ *
+ *
+ */
 public fun <T, C> Update<T, C>.withZero(): DataFrame<T> = updateWithValuePerColumnImpl { 0 as C }
 
+/**
+ * ## With Value
+ * Specific version of [with][org.jetbrains.kotlinx.dataframe.api.with] that simply sets the value of each selected row to [value][org.jetbrains.kotlinx.dataframe.api.value].
+ *
+ * For example:
+ *
+ * `df.`[update][org.jetbrains.kotlinx.dataframe.api.update]` { id }.`[where][org.jetbrains.kotlinx.dataframe.api.Update.where]` { it < 0 }.`[withValue][org.jetbrains.kotlinx.dataframe.api.withValue]`(-1)`
+ *
+ *
+ *
+ * @param value The value to set the selected rows to. In contrast to [with][Update.with], this must be the same exact type.
+ */
 public fun <T, C> Update<T, C>.withValue(value: C): DataFrame<T> = with { value }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
index dae844ab9..f65713f8d 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
@@ -1,13 +1,16 @@
 package org.jetbrains.kotlinx.dataframe.documentation
 
+import org.jetbrains.kotlinx.dataframe.documentation.AccessApi.*
 import org.jetbrains.kotlinx.dataframe.documentation.samples.ApiLevels as ApiLevelsSample
 
 /**
- * By nature data frames are dynamic objects, column labels depend on the input source and also new columns could be added
+ * ## Access APIs
+ *
+ * By nature, data frames are dynamic objects, column labels depend on the input source and also new columns could be added
  * or deleted while wrangling. Kotlin, in contrast, is a statically typed language and all types are defined and verified
  * ahead of execution. That's why creating a flexible, handy, and, at the same time, safe API to a data frame is tricky.
  *
- * In `Kotlin DataFrame` we provide four different ways to access columns, and, while they are essentially different, they
+ * In `Kotlin DataFrame` we provide four different ways to access columns, and, while they're essentially different, they
  * look pretty similar in the data wrangling DSL. These include:
  *  - [Extension Properties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ExtensionPropertiesApi]
  *  - [KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]
@@ -131,5 +134,5 @@ internal interface AccessApi {
     interface ExtensionPropertiesApiLink
 }
 
-/** [Access Api][AccessApi] */
+/** [Access API][AccessApi] */
 internal interface AccessApiLink
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
index bae56aba5..6e8638173 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
@@ -25,7 +25,7 @@ internal interface SelectingColumnsLink
  * [DataFrame.select], [DataFrame.update], [DataFrame.gather], and [DataFrame.fillNulls])
  * can be done in the following ways:
  * - Select or express columns using the Column(s) Selection DSL.
- * (Any [Access Api][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+ * (Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
  *
  * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
  * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
@@ -78,7 +78,7 @@ internal interface SelectingColumns {
     interface SetDefaultOperationArg
 
     /** Select or express columns using the Column(s) Selection DSL.
-     * (Any [Access Api][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+     * (Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
      *
      * This DSL comes in the form of either a [Column Selector][ColumnSelector]- or [Columns Selector][ColumnsSelector] lambda,
      * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
@@ -87,7 +87,7 @@ internal interface SelectingColumns {
     interface Dsl {
 
         /** Select or express columns using the Column(s) Selection DSL.
-         * (Any [Access Api][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
+         * (Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
          *
          * This DSL comes in the form of either a [Column Selector][org.jetbrains.kotlinx.dataframe.ColumnSelector]- or [Columns Selector][org.jetbrains.kotlinx.dataframe.ColumnsSelector] lambda,
          * which operate in the [Column Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl] or the [Columns Selection DSL][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl] and
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 405078255..e11e8bc0b 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
@@ -31,6 +31,7 @@ import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
 import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
 import org.jetbrains.kotlinx.dataframe.exceptions.ExcessiveColumnsException
 import org.jetbrains.kotlinx.dataframe.exceptions.TypeConversionException
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.emptyPath
 import org.jetbrains.kotlinx.dataframe.impl.schema.createEmptyColumn
 import org.jetbrains.kotlinx.dataframe.impl.schema.createEmptyDataFrame
@@ -265,8 +266,8 @@ internal fun AnyFrame.convertToImpl(
 
     dsl.fillers.forEach { filler ->
         val paths = result.getColumnPaths(filler.columns)
-        missingPaths.removeAll(paths)
-        result = result.update(paths).with {
+        missingPaths.removeAll(paths.toSet())
+        result = result.update { paths.toColumnSet() }.with {
             filler.expr(this, this)
         }
     }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/gather.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/gather.kt
index af046e5ef..4844853dd 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/gather.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/gather.kt
@@ -60,9 +60,9 @@ internal fun <T, C, K, R> Gather<T, C, K, R>.gatherImpl(
         }
 
         // explode keys and values
-        when {
-            keysColumn != null && valuesColumn != null -> df = df.explode(keysColumn, valuesColumn)
-            else -> df = df.explode(keysColumn ?: valuesColumn!!)
+        df = when {
+            keysColumn != null && valuesColumn != null -> df.explode(keysColumn, valuesColumn)
+            else -> df.explode(keysColumn ?: valuesColumn!!)
         }
 
         // explode values in lists
@@ -76,7 +76,7 @@ internal fun <T, C, K, R> Gather<T, C, K, R>.gatherImpl(
                 val value = col[row]
                 when {
                     explode && value is List<*> -> {
-                        val filtered = (value as List<C>).filter(filter)
+                        val filtered = (value as List<C>).filter { filter(it) }
                         val transformed = valueTransform?.let { filtered.map(it) } ?: filtered
                         keys[colIndex] to transformed
                     }
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 db04a39c1..2ce9f4db8 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
@@ -1,9 +1,9 @@
 package org.jetbrains.kotlinx.dataframe.impl.api
 
 import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.ColumnExpression
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.Selector
 import org.jetbrains.kotlinx.dataframe.api.Reorder
 import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
 import org.jetbrains.kotlinx.dataframe.api.cast
@@ -23,7 +23,7 @@ import kotlin.reflect.typeOf
 
 internal fun <T, C, V : Comparable<V>> Reorder<T, C>.reorderImpl(
     desc: Boolean,
-    expression: Selector<DataColumn<C>, V>
+    expression: ColumnExpression<C, V>
 ): DataFrame<T> {
     data class ColumnInfo(
         val treeNode: TreeNode<ColumnPosition>,
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 02e72afa2..9f05b8f96 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
@@ -2,12 +2,12 @@ package org.jetbrains.kotlinx.dataframe.impl.api
 
 import org.jetbrains.kotlinx.dataframe.AnyFrame
 import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnExpression
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataFrameExpression
 import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.RowValueFilter
-import org.jetbrains.kotlinx.dataframe.Selector
 import org.jetbrains.kotlinx.dataframe.api.AddDataRow
 import org.jetbrains.kotlinx.dataframe.api.Update
 import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
@@ -36,7 +36,7 @@ internal fun <T, C> Update<T, C>.updateImpl(expression: (AddDataRow<T>, DataColu
     if (df.isEmpty()) df
     else df.replace(columns).with { it.updateImpl(df, filter, expression) }
 
-internal fun <T, C> Update<T, C>.updateWithValuePerColumnImpl(selector: Selector<DataColumn<C>, C>) =
+internal fun <T, C> Update<T, C>.updateWithValuePerColumnImpl(selector: ColumnExpression<C, C>) =
     if (df.isEmpty()) df
     else {
         df.replace(columns).with {
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 5ba0ffaaf..68f50e0e4 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
@@ -189,7 +189,7 @@ internal fun <C> Array<out KProperty<C>>.toColumns(): ColumnSet<C> = map { it.to
 
 @PublishedApi
 internal fun <T> Array<out ColumnReference<T>>.toColumns(): ColumnSet<T> = asIterable().toColumnSet()
-internal fun Iterable<String>.toColumns() = map { it.toColumnAccessor() }.toColumnSet()
+internal fun Iterable<String>.toColumns(): ColumnSet<Any?> = map { it.toColumnAccessor() }.toColumnSet()
 
 // endregion
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
index 5525e8d7e..00efd5892 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
@@ -11,36 +11,24 @@ import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.Predicate
-import org.jetbrains.kotlinx.dataframe.columns.ColumnAccessor
-import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
-import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
-import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
-import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
-import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
-import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
-import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
-import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
-import org.jetbrains.kotlinx.dataframe.columns.renamedReference
+import org.jetbrains.kotlinx.dataframe.columns.*
+import org.jetbrains.kotlinx.dataframe.documentation.AccessApi
 import org.jetbrains.kotlinx.dataframe.hasNulls
 import org.jetbrains.kotlinx.dataframe.impl.columnName
-import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnsList
-import org.jetbrains.kotlinx.dataframe.impl.columns.DistinctColumnSet
-import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
-import org.jetbrains.kotlinx.dataframe.impl.columns.allColumnsExcept
-import org.jetbrains.kotlinx.dataframe.impl.columns.changePath
-import org.jetbrains.kotlinx.dataframe.impl.columns.createColumnSet
-import org.jetbrains.kotlinx.dataframe.impl.columns.getAt
-import org.jetbrains.kotlinx.dataframe.impl.columns.getChildrenAt
-import org.jetbrains.kotlinx.dataframe.impl.columns.single
-import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
-import org.jetbrains.kotlinx.dataframe.impl.columns.top
-import org.jetbrains.kotlinx.dataframe.impl.columns.transform
-import org.jetbrains.kotlinx.dataframe.impl.columns.transformSingle
+import org.jetbrains.kotlinx.dataframe.impl.columns.*
 import org.jetbrains.kotlinx.dataframe.impl.columns.tree.dfs
 import kotlin.reflect.KProperty
 import kotlin.reflect.KType
 import kotlin.reflect.typeOf
 
+/**
+ * Referring to a column in the selection DSL can be done in several ways corresponding to all
+ * [Access APIs][AccessApi]:
+ * TODO
+ */
+private interface CommonColumnSelectionExamples
+
+
 /** [Column Selection DSL][ColumnSelectionDsl] */
 internal interface ColumnSelectionDslLink
 
@@ -78,24 +66,26 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     public fun ColumnsContainer<*>.group(name: String): ColumnGroupReference = name.toColumnOf()
 
-    public operator fun String.rangeTo(endInclusive: String): ColumnSet<*> = toColumnAccessor().rangeTo(endInclusive.toColumnAccessor())
-
-    public operator fun AnyColumnReference.rangeTo(endInclusive: AnyColumnReference): ColumnSet<*> = object : ColumnSet<Any?> {
-        override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<Any?>> {
-            val startPath = this@rangeTo.resolveSingle(context)!!.path
-            val endPath = endInclusive.resolveSingle(context)!!.path
-            val parentPath = startPath.parent()!!
-            require(parentPath == endPath.parent()) { "Start and end columns have different parent column paths" }
-            val parentCol = context.df.getColumnGroup(parentPath)
-            val startIndex = parentCol.getColumnIndex(startPath.name)
-            val endIndex = parentCol.getColumnIndex(endPath.name)
-            return (startIndex..endIndex).map {
-                parentCol.getColumn(it).let {
-                    it.addPath(parentPath + it.name)
+    public operator fun String.rangeTo(endInclusive: String): ColumnSet<*> =
+        toColumnAccessor().rangeTo(endInclusive.toColumnAccessor())
+
+    public operator fun AnyColumnReference.rangeTo(endInclusive: AnyColumnReference): ColumnSet<*> =
+        object : ColumnSet<Any?> {
+            override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<Any?>> {
+                val startPath = this@rangeTo.resolveSingle(context)!!.path
+                val endPath = endInclusive.resolveSingle(context)!!.path
+                val parentPath = startPath.parent()!!
+                require(parentPath == endPath.parent()) { "Start and end columns have different parent column paths" }
+                val parentCol = context.df.getColumnGroup(parentPath)
+                val startIndex = parentCol.getColumnIndex(startPath.name)
+                val endIndex = parentCol.getColumnIndex(endPath.name)
+                return (startIndex..endIndex).map {
+                    parentCol.getColumn(it).let {
+                        it.addPath(parentPath + it.name)
+                    }
                 }
             }
         }
-    }
 
     public fun none(): ColumnSet<*> = ColumnsList<Any?>(emptyList())
 
@@ -123,7 +113,8 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     public fun <C> ColumnSet<DataRow<C>>.select(vararg columns: String): ColumnSet<*> = select { columns.toColumns() }
 
-    public fun <C, R> ColumnSet<DataRow<C>>.select(vararg columns: KProperty<R>): ColumnSet<R> = select { columns.toColumns() }
+    public fun <C, R> ColumnSet<DataRow<C>>.select(vararg columns: KProperty<R>): ColumnSet<R> =
+        select { columns.toColumns() }
 
     public fun <C, R> ColumnSet<DataRow<C>>.select(selector: ColumnsSelector<C, R>): ColumnSet<R> = createColumnSet {
         this@select.resolve(it).flatMap { group ->
@@ -153,7 +144,8 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     // region allDfs
 
-    public fun ColumnSet<*>.allDfs(includeGroups: Boolean = false): ColumnSet<Any?> = if (includeGroups) dfs { true } else dfs { !it.isColumnGroup() }
+    public fun ColumnSet<*>.allDfs(includeGroups: Boolean = false): ColumnSet<Any?> =
+        if (includeGroups) dfs { true } else dfs { !it.isColumnGroup() }
 
     public fun String.allDfs(includeGroups: Boolean = false): ColumnSet<Any?> = toColumnAccessor().allDfs(includeGroups)
 
@@ -250,7 +242,9 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
     public fun <C> col(property: KProperty<C>): ColumnAccessor<C> = property.toColumnAccessor()
 
-    public operator fun ColumnSet<*>.get(colName: String): ColumnSet<Any?> = transform { it.mapNotNull { it.getChild(colName) } }
+    public operator fun ColumnSet<*>.get(colName: String): ColumnSet<Any?> =
+        transform { it.mapNotNull { it.getChild(colName) } }
+
     public operator fun <C> ColumnSet<*>.get(column: ColumnReference<C>): ColumnSet<C> = cols(column)
 
     public fun SingleColumn<AnyRow>.take(n: Int): ColumnSet<*> = transformSingle { it.children().take(n) }
@@ -296,8 +290,11 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     public infix fun <C> ColumnReference<C>.into(column: KProperty<*>): ColumnReference<C> = named(column.columnName)
 
     public infix fun String.into(newName: String): ColumnReference<Any?> = toColumnAccessor().into(newName)
-    public infix fun String.into(column: ColumnAccessor<*>): ColumnReference<Any?> = toColumnAccessor().into(column.name())
-    public infix fun String.into(column: KProperty<*>): ColumnReference<Any?> = toColumnAccessor().into(column.columnName)
+    public infix fun String.into(column: ColumnAccessor<*>): ColumnReference<Any?> =
+        toColumnAccessor().into(column.name())
+
+    public infix fun String.into(column: KProperty<*>): ColumnReference<Any?> =
+        toColumnAccessor().into(column.columnName)
 
     public infix fun <C> ColumnReference<C>.named(newName: String): ColumnReference<C> = renamedReference(newName)
     public infix fun <C> ColumnReference<C>.named(name: KProperty<*>): ColumnReference<C> = named(name.columnName)
@@ -319,6 +316,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
     public infix fun <C> KProperty<C>.and(other: String): ColumnSet<Any?> = toColumnAccessor() and other
     public infix fun <C> KProperty<C>.and(other: KProperty<C>): ColumnSet<C> =
         toColumnAccessor() and other.toColumnAccessor()
+
     public infix fun <C> KProperty<C>.and(other: ColumnsSelector<T, C>): ColumnSet<C> = toColumnAccessor() and other()
 
     // endregion
@@ -347,7 +345,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 public inline fun <T, reified R> ColumnsSelectionDsl<T>.expr(
     name: String = "",
     infer: Infer = Infer.Nulls,
-    noinline expression: AddExpression<T, R>
+    noinline expression: AddExpression<T, R>,
 ): DataColumn<R> = mapToColumn(name, infer, expression)
 
 internal fun <T, C> ColumnsSelector<T, C>.filter(predicate: (ColumnWithPath<C>) -> Boolean): ColumnsSelector<T, C> =
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
index 02f5ae125..0f0e56b42 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
@@ -1,13 +1,16 @@
 package org.jetbrains.kotlinx.dataframe.documentation
 
+import org.jetbrains.kotlinx.dataframe.documentation.AccessApi.*
 import org.jetbrains.kotlinx.dataframe.documentation.samples.ApiLevels as ApiLevelsSample
 
 /**
- * By nature data frames are dynamic objects, column labels depend on the input source and also new columns could be added
+ * ## Access APIs
+ *
+ * By nature, data frames are dynamic objects, column labels depend on the input source and also new columns could be added
  * or deleted while wrangling. Kotlin, in contrast, is a statically typed language and all types are defined and verified
  * ahead of execution. That's why creating a flexible, handy, and, at the same time, safe API to a data frame is tricky.
  *
- * In `Kotlin DataFrame` we provide four different ways to access columns, and, while they are essentially different, they
+ * In `Kotlin DataFrame` we provide four different ways to access columns, and, while they're essentially different, they
  * look pretty similar in the data wrangling DSL. These include:
  *  - {@include [ExtensionPropertiesApiLink]}
  *  - {@include [KPropertiesApiLink]}
@@ -91,5 +94,5 @@ internal interface AccessApi {
     interface ExtensionPropertiesApiLink
 }
 
-/** [Access Api][AccessApi] */
+/** [Access API][AccessApi] */
 internal interface AccessApiLink

From 1a467b97822f428ff3d40ebb0fb6a9bd27f293f6 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Thu, 23 Mar 2023 19:07:45 +0100
Subject: [PATCH 46/50] updated settings.gradle.kts to master version

---
 settings.gradle.kts | 15 ---------------
 1 file changed, 15 deletions(-)

diff --git a/settings.gradle.kts b/settings.gradle.kts
index c908e5c26..24f580668 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -28,21 +28,6 @@ pluginManagement {
     repositories {
         mavenLocal()
         gradlePluginPortal()
-        maven(url = "https://jitpack.io")
-    }
-
-    resolutionStrategy {
-        eachPlugin {
-            requested.apply {
-                val jitpackPlugins = listOf(
-                    "com.github.jolanrensen.docProcessorGradlePlugin",
-                )
-                if ("$id" in jitpackPlugins) {
-                    val (_, _, user, name) = "$id".split(".", limit = 4)
-                    useModule("com.github.$user:$name:$version")
-                }
-            }
-        }
     }
 }
 include("dataframe-excel")

From f0e8c13e2689024872f46321aae7ca6957234002 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Fri, 24 Mar 2023 14:27:33 +0100
Subject: [PATCH 47/50] fixing linting

---
 .../org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt   | 1 -
 .../kotlinx/dataframe/documentation/DocumentationUrls.kt         | 1 -
 .../org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt   | 1 -
 .../kotlinx/dataframe/documentation/DocumentationUrls.kt         | 1 -
 4 files changed, 4 deletions(-)

diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
index 00efd5892..7a12a5abe 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
@@ -28,7 +28,6 @@ import kotlin.reflect.typeOf
  */
 private interface CommonColumnSelectionExamples
 
-
 /** [Column Selection DSL][ColumnSelectionDsl] */
 internal interface ColumnSelectionDslLink
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
index 8ae796e8d..7871a890d 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
@@ -46,7 +46,6 @@ private interface DocumentationUrls {
 
         /** [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna) */
         interface DropNA
-
     }
 
     /** [See Access APIs on the documentation website.](https://kotlin.github.io/dataframe/apilevels.html) */
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
index 00efd5892..7a12a5abe 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
@@ -28,7 +28,6 @@ import kotlin.reflect.typeOf
  */
 private interface CommonColumnSelectionExamples
 
-
 /** [Column Selection DSL][ColumnSelectionDsl] */
 internal interface ColumnSelectionDslLink
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
index 9ace928d2..4ae40ffc1 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
@@ -46,7 +46,6 @@ private interface DocumentationUrls {
 
         /** [{@include [Text]}{@arg [NameArg] `dropNA`}]({@include [Url]}/drop.html#dropna) */
         interface DropNA
-
     }
 
     /** [{@include [Text]}{@arg [NameArg] Access APIs}]({@include [Url]}/apilevels.html) */

From e6ab95b2be2e9d9a98a1be14a4e7e372d7b4abaf Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Mon, 27 Mar 2023 13:01:35 +0200
Subject: [PATCH 48/50] fixing some review issues

---
 .../dataframe/api/ColumnsSelectionDsl.kt      |   6 +-
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  | 129 ++++++++----------
 .../jetbrains/kotlinx/dataframe/api/update.kt |   2 +-
 .../dataframe/documentation/AccessApi.kt      |   2 +-
 .../documentation/ExpressionsGivenRow.kt      |   4 +-
 .../kotlinx/dataframe/documentation/NA.kt     |  18 +++
 .../kotlinx/dataframe/documentation/NaN.kt    |  16 +++
 .../documentation/SelectingColumns.kt         |   6 -
 .../dataframe/documentation/SelectingRows.kt  |   7 +-
 .../dataframe/api/ColumnsSelectionDsl.kt      |   6 +-
 .../jetbrains/kotlinx/dataframe/api/Nulls.kt  |  45 ++----
 .../jetbrains/kotlinx/dataframe/api/update.kt |   2 +-
 .../dataframe/documentation/AccessApi.kt      |   2 +-
 .../documentation/ExpressionsGivenRow.kt      |   4 +-
 .../kotlinx/dataframe/documentation/NA.kt     |  18 +++
 .../kotlinx/dataframe/documentation/NaN.kt    |  16 +++
 .../documentation/SelectingColumns.kt         |   6 -
 .../dataframe/documentation/SelectingRows.kt  |   7 +-
 .../idea-examples/movies/build.gradle.kts     |   1 -
 19 files changed, 162 insertions(+), 135 deletions(-)
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NA.kt
 create mode 100644 core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NaN.kt
 create mode 100644 core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NA.kt
 create mode 100644 core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NaN.kt

diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
index 7a12a5abe..7e837b558 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
@@ -24,14 +24,14 @@ import kotlin.reflect.typeOf
 /**
  * Referring to a column in the selection DSL can be done in several ways corresponding to all
  * [Access APIs][AccessApi]:
- * TODO
+ * TODO: [Issue #286](https://github.com/Kotlin/dataframe/issues/286)
  */
 private interface CommonColumnSelectionExamples
 
 /** [Column Selection DSL][ColumnSelectionDsl] */
 internal interface ColumnSelectionDslLink
 
-/** TODO: Put examples and explanations here */
+/** TODO: [Issue #286](https://github.com/Kotlin/dataframe/issues/286) */
 public interface ColumnSelectionDsl<out T> : ColumnsContainer<T> {
 
     public operator fun <C> ColumnReference<C>.invoke(): DataColumn<C> = get(this)
@@ -50,7 +50,7 @@ public interface ColumnSelectionDsl<out T> : ColumnsContainer<T> {
 /** [Columns Selection DSL][ColumnsSelectionDsl] */
 internal interface ColumnsSelectionDslLink
 
-/** TODO: Put examples and explanations here */
+/** TODO: [Issue #286](https://github.com/Kotlin/dataframe/issues/286) */
 public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColumn<DataRow<T>> {
 
     public fun <C> ColumnSet<C>.first(condition: ColumnFilter<C>): SingleColumn<C> =
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index 75060155e..c6e2541cd 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -9,32 +9,6 @@ import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
 import kotlin.reflect.KProperty
 
-/**
- * ## `NaN`
- * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
- * in cases where a mathematical operation is undefined, such as dividing by zero.
- *
- * You can also use [fillNaNs][fillNaNs] to replace `NaNs` in certain columns with a given value or expression
- * or [dropNaNs][dropNaNs] to drop rows with `NaNs` in them.
- *
- * @see NA
- */
-internal interface NaN
-
-/**
- * ## `NA`
- * `NA` in Dataframe can be seen as "[NaN] or `null`".
- *
- * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
- * in cases where a mathematical operation is undefined, such as dividing by zero.
- *
- * You can also use [fillNA][fillNA] to replace `NAs` in certain columns with a given value or expression
- * or [dropNA][dropNA] to drop rows with `NAs` in them.
- *
- * @see NaN
- */
-internal interface NA
-
 // region fillNulls
 
 /**
@@ -82,7 +56,9 @@ private interface SetFillNullsOperationArg
  * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ *
  * ## This Fill Nulls Overload
+ *
  */
 private interface CommonFillNullsFunctionDoc
 
@@ -97,7 +73,9 @@ private interface CommonFillNullsFunctionDoc
  * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ *
  * ## This Fill Nulls Overload
+ *
  * Select or express columns using the Column(s) Selection DSL.
  * (Any [Access API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi]).
  *
@@ -129,7 +107,9 @@ public fun <T, C> DataFrame<T>.fillNulls(columns: ColumnsSelector<T, C?>): Updat
  * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ *
  * ## This Fill Nulls Overload
+ *
  * Select columns using their [column names][String]
  * ([String API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.StringApi]).
  *
@@ -153,7 +133,9 @@ public fun <T> DataFrame<T>.fillNulls(vararg columns: String): Update<T, Any?> =
  * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ *
  * ## This Fill Nulls Overload
+ *
  * Select columns using [KProperties][KProperty] ([KProperties API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.KPropertiesApi]).
  *
  * For example:
@@ -179,7 +161,9 @@ public fun <T, C> DataFrame<T>.fillNulls(vararg columns: KProperty<C>): Update<T
  * For more information: [See `fillNulls` on the documentation website.](https://kotlin.github.io/dataframe/fill.html#fillnulls) 
  * ## ‎
  * The columns to update need to be selected. See [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns] for all the selecting options. 
+ *
  * ## This Fill Nulls Overload
+ *
  * Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
  * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]).
  *
@@ -197,7 +181,7 @@ public fun <T, C> DataFrame<T>.fillNulls(vararg columns: ColumnReference<C>): Up
     fillNulls { columns.toColumns() }
 
 /**
- * TODO this will be deprecated
+ * TODO this will be deprecated [PR #286](https://github.com/Kotlin/dataframe/pull/320)
  */
 public fun <T, C> DataFrame<T>.fillNulls(columns: Iterable<ColumnReference<C>>): Update<T, C?> =
     fillNulls { columns.toColumnSet() }
@@ -263,7 +247,7 @@ internal interface SetFillNaNsOperationArg
 /**
  * ## The Fill NaNs Operation
  *
- * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.api.NaN] values with given value or expression.
+ * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.documentation.NaN] values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
  *
  * Check out the [`fillNaNs` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Usage].
@@ -278,7 +262,7 @@ private interface CommonFillNaNsFunctionDoc
 /**
  * ## The Fill NaNs Operation
  *
- * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.api.NaN] values with given value or expression.
+ * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.documentation.NaN] values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
  *
  * Check out the [`fillNaNs` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Usage].
@@ -310,7 +294,7 @@ public fun <T, C> DataFrame<T>.fillNaNs(columns: ColumnsSelector<T, C>): Update<
 /**
  * ## The Fill NaNs Operation
  *
- * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.api.NaN] values with given value or expression.
+ * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.documentation.NaN] values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
  *
  * Check out the [`fillNaNs` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Usage].
@@ -334,7 +318,7 @@ public fun <T> DataFrame<T>.fillNaNs(vararg columns: String): Update<T, Any?> =
 /**
  * ## The Fill NaNs Operation
  *
- * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.api.NaN] values with given value or expression.
+ * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.documentation.NaN] values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
  *
  * Check out the [`fillNaNs` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Usage].
@@ -360,7 +344,7 @@ public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: KProperty<C>): Update<T,
 /**
  * ## The Fill NaNs Operation
  *
- * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.api.NaN] values with given value or expression.
+ * Replaces [`NaN`][org.jetbrains.kotlinx.dataframe.documentation.NaN] values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
  *
  * Check out the [`fillNaNs` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNaNs.Usage].
@@ -386,7 +370,7 @@ public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: ColumnReference<C>): Upd
     fillNaNs { columns.toColumns() }
 
 /**
- * TODO this will be deprecated
+ * TODO this will be deprecated [PR #286](https://github.com/Kotlin/dataframe/pull/320)
  */
 public fun <T, C> DataFrame<T>.fillNaNs(columns: Iterable<ColumnReference<C>>): Update<T, C> =
     fillNaNs { columns.toColumnSet() }
@@ -432,7 +416,7 @@ internal interface SetFillNAOperationArg
 /**
  * ## The Fill NA Operation
  *
- * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values with given value or expression.
+ * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA] values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
  *
  * Check out the [`fillNA` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNA.Usage].
@@ -447,7 +431,7 @@ private interface CommonFillNAFunctionDoc
 /**
  * ## The Fill NA Operation
  *
- * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values with given value or expression.
+ * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA] values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
  *
  * Check out the [`fillNA` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNA.Usage].
@@ -479,7 +463,7 @@ public fun <T, C> DataFrame<T>.fillNA(columns: ColumnsSelector<T, C?>): Update<T
 /**
  * ## The Fill NA Operation
  *
- * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values with given value or expression.
+ * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA] values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
  *
  * Check out the [`fillNA` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNA.Usage].
@@ -503,7 +487,7 @@ public fun <T> DataFrame<T>.fillNA(vararg columns: String): Update<T, Any?> =
 /**
  * ## The Fill NA Operation
  *
- * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values with given value or expression.
+ * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA] values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
  *
  * Check out the [`fillNA` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNA.Usage].
@@ -529,7 +513,7 @@ public fun <T, C> DataFrame<T>.fillNA(vararg columns: KProperty<C>): Update<T, C
 /**
  * ## The Fill NA Operation
  *
- * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values with given value or expression.
+ * Replaces [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA] values with given value or expression.
  * Specific case of [update][org.jetbrains.kotlinx.dataframe.api.update].
  *
  * Check out the [`fillNA` Operation Usage][org.jetbrains.kotlinx.dataframe.api.FillNA.Usage].
@@ -555,7 +539,7 @@ public fun <T, C> DataFrame<T>.fillNA(vararg columns: ColumnReference<C>): Updat
     fillNA { columns.toColumns() }
 
 /**
- * TODO this will be deprecated
+ * TODO this will be deprecated [PR #286](https://github.com/Kotlin/dataframe/pull/320)
  */
 public fun <T, C> DataFrame<T>.fillNA(columns: Iterable<ColumnReference<C>>): Update<T, C?> =
     fillNA { columns.toColumnSet() }
@@ -760,7 +744,7 @@ public fun <T> DataFrame<T>.dropNulls(vararg columns: AnyColumnReference, whereA
     dropNulls(whereAllNull) { columns.toColumns() }
 
 /**
- * TODO will be deprecated
+ * TODO this will be deprecated [PR #286](https://github.com/Kotlin/dataframe/pull/320)
  */
 public fun <T> DataFrame<T>.dropNulls(
     columns: Iterable<AnyColumnReference>,
@@ -806,11 +790,11 @@ private interface SetDropNAOperationArg
 /**
  * ## The Drop `NA` Operation
  *
- * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
  *
  * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
- * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA]. By default,
- * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
  *
  * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna) 
  * ## This Drop NA Overload
@@ -820,11 +804,11 @@ private interface CommonDropNAFunctionDoc
 /**
  * ## The Drop `NA` Operation
  *
- * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
  *
  * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
- * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA]. By default,
- * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
  *
  * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna) 
  * ## This Drop NA Overload
@@ -845,8 +829,8 @@ private interface CommonDropNAFunctionDoc
  *  
  * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`(whereAllNA = true) { `[colsOf][org.jetbrains.kotlinx.dataframe.api.colsOf]`<`[Double][Double]`>() }`
  * @param whereAllNA `false` by default.
- *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
- *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
+ *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
  * @param columns The [Columns selector DSL][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.Dsl.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
  */
 public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false, columns: ColumnsSelector<T, *>): DataFrame<T> {
@@ -858,11 +842,11 @@ public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false, columns: Columns
 /**
  * ## The Drop `NA` Operation
  *
- * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
  *
  * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
- * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA]. By default,
- * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
  *
  * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna) 
  * ## This Drop NA Overload
@@ -877,8 +861,8 @@ public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false, columns: Columns
  *  
  * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`(Person::length, whereAllNA = true)`
  * @param whereAllNA `false` by default.
- *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
- *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
+ *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
  * @param columns The [KProperties][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.KProperties.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
  */
 public fun <T> DataFrame<T>.dropNA(vararg columns: KProperty<*>, whereAllNA: Boolean = false): DataFrame<T> =
@@ -887,11 +871,11 @@ public fun <T> DataFrame<T>.dropNA(vararg columns: KProperty<*>, whereAllNA: Boo
 /**
  * ## The Drop `NA` Operation
  *
- * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
  *
  * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
- * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA]. By default,
- * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
  *
  * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna) 
  * ## This Drop NA Overload
@@ -904,8 +888,8 @@ public fun <T> DataFrame<T>.dropNA(vararg columns: KProperty<*>, whereAllNA: Boo
  *  
  * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`("length", whereAllNA = true)`
  * @param whereAllNA `false` by default.
- *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
- *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
+ *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
  * @param columns The [Column names][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.ColumnNames.WithExample] used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
  */
 public fun <T> DataFrame<T>.dropNA(vararg columns: String, whereAllNA: Boolean = false): DataFrame<T> =
@@ -914,11 +898,11 @@ public fun <T> DataFrame<T>.dropNA(vararg columns: String, whereAllNA: Boolean =
 /**
  * ## The Drop `NA` Operation
  *
- * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
  *
  * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
- * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA]. By default,
- * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
  *
  * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna) 
  * ## This Drop NA Overload
@@ -935,8 +919,8 @@ public fun <T> DataFrame<T>.dropNA(vararg columns: String, whereAllNA: Boolean =
  *  
  * `df.`[dropNA][org.jetbrains.kotlinx.dataframe.api.dropNA]`(length, whereAllNA = true)`
  * @param whereAllNA `false` by default.
- *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
- *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
+ *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
  * @param columns The Select columns using [column accessors][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]
  * ([Column Accessors API][org.jetbrains.kotlinx.dataframe.documentation.AccessApi.ColumnAccessorsApi]). used to select the columns of this [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame] to drop rows in.
  */
@@ -944,7 +928,7 @@ public fun <T> DataFrame<T>.dropNA(vararg columns: AnyColumnReference, whereAllN
     dropNA(whereAllNA) { columns.toColumns() }
 
 /**
- * TODO will be deprecated
+ * TODO this will be deprecated [PR #286](https://github.com/Kotlin/dataframe/pull/320)
  */
 public fun <T> DataFrame<T>.dropNA(columns: Iterable<AnyColumnReference>, whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { columns.toColumnSet() }
@@ -952,18 +936,18 @@ public fun <T> DataFrame<T>.dropNA(columns: Iterable<AnyColumnReference>, whereA
 /**
  * ## The Drop `NA` Operation
  *
- * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.api.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
+ * Removes rows with [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA] values. Specific case of [drop][org.jetbrains.kotlinx.dataframe.DataFrame.drop].
  *
  * Optionally, you can select which columns to operate on (see [Selecting Columns][org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns]).
- * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA]. By default,
- * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA]. By default,
+ * rows are dropped if any of the selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
  *
  * For more information: [See `dropNA` on the documentation website.](https://kotlin.github.io/dataframe/drop.html#dropna) 
  * ## This Drop NA Overload
  * This overload operates on all columns in the [DataFrame][org.jetbrains.kotlinx.dataframe.DataFrame].
  * @param whereAllNA `false` by default.
- *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
- *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.api.NA].
+ *   If `true`, rows are dropped if all selected cells are [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
+ *   If `false`, rows are dropped if any of the selected cells is [`NA`][org.jetbrains.kotlinx.dataframe.documentation.NA].
  */
 public fun <T> DataFrame<T>.dropNA(whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { all() }
@@ -1147,9 +1131,12 @@ public fun <T> DataFrame<T>.dropNaNs(vararg columns: AnyColumnReference, whereAl
     dropNaNs(whereAllNaN) { columns.toColumns() }
 
 /**
- * TODO will be deprecated
+ * TODO this will be deprecated [PR #286](https://github.com/Kotlin/dataframe/pull/320)
  */
-public fun <T> DataFrame<T>.dropNaNs(columns: Iterable<AnyColumnReference>, whereAllNaN: Boolean = false): DataFrame<T> =
+public fun <T> DataFrame<T>.dropNaNs(
+    columns: Iterable<AnyColumnReference>,
+    whereAllNaN: Boolean = false,
+): DataFrame<T> =
     dropNaNs(whereAllNaN) { columns.toColumnSet() }
 
 /**
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index ea909d48f..72e27075b 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -217,7 +217,7 @@ public fun <T, C> DataFrame<T>.update(vararg columns: ColumnReference<C>): Updat
     update { columns.toColumns() }
 
 /**
- * TODO this will be deprecated
+ * TODO this will be deprecated [PR #286](https://github.com/Kotlin/dataframe/pull/320)
  */
 public fun <T, C> DataFrame<T>.update(columns: Iterable<ColumnReference<C>>): Update<T, C> =
     update { columns.toColumnSet() }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
index f65713f8d..0f455581a 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
@@ -135,4 +135,4 @@ internal interface AccessApi {
 }
 
 /** [Access API][AccessApi] */
-internal interface AccessApiLink
+public const val AccessApiLink: Int = 0
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
index 16d5c1021..4fcaf9709 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
@@ -20,14 +20,14 @@ import org.jetbrains.kotlinx.dataframe.RowValueExpression as DfRowValueExpressio
  * for instance in [update.with][Update.with], and [convert.notNull][Convert.notNull]
  * (using [RowValueExpression][DfRowValueExpression]).
  *
- * Note:
+ * NOTE:
  *
  * [update with][org.jetbrains.kotlinx.dataframe.api.Update.with]- and [add][org.jetbrains.kotlinx.dataframe.api.add]-like expressions use [AddDataRow][org.jetbrains.kotlinx.dataframe.api.AddDataRow] instead of [DataRow][org.jetbrains.kotlinx.dataframe.DataRow] as the DSL's receiver type.
  * This is an extension to [RowValueExpression][org.jetbrains.kotlinx.dataframe.RowValueExpression] and
  * [RowExpression][org.jetbrains.kotlinx.dataframe.RowExpression] that provides access to
  * the modified/generated value of the preceding row ([AddDataRow.newValue][org.jetbrains.kotlinx.dataframe.api.AddDataRow.newValue]).
  *
- * A Row Expression is similar to a [Row Condition][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows] but that expects a [Boolean][Boolean] as result.
+ * A [Row Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow.RowExpression.WithExample] is similar to a [Row Condition][org.jetbrains.kotlinx.dataframe.documentation.SelectingRows] but that expects a [Boolean][Boolean] as result.
  */
 internal interface ExpressionsGivenRow {
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NA.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NA.kt
new file mode 100644
index 000000000..35251f23f
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NA.kt
@@ -0,0 +1,18 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.api.dropNA
+import org.jetbrains.kotlinx.dataframe.api.fillNA
+
+/**
+ * ## `NA`
+ * `NA` in Dataframe can be seen as "[NaN] or `null`".
+ *
+ * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
+ * in cases where a mathematical operation is undefined, such as dividing by zero.
+ *
+ * You can also use [fillNA][fillNA] to replace `NAs` in certain columns with a given value or expression
+ * or [dropNA][dropNA] to drop rows with `NAs` in them.
+ *
+ * @see NaN
+ */
+internal interface NA
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NaN.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NaN.kt
new file mode 100644
index 000000000..18b979294
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NaN.kt
@@ -0,0 +1,16 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.api.dropNaNs
+import org.jetbrains.kotlinx.dataframe.api.fillNaNs
+
+/**
+ * ## `NaN`
+ * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
+ * in cases where a mathematical operation is undefined, such as dividing by zero.
+ *
+ * You can also use [fillNaNs][fillNaNs] to replace `NaNs` in certain columns with a given value or expression
+ * or [dropNaNs][dropNaNs] to drop rows with `NaNs` in them.
+ *
+ * @see NA
+ */
+internal interface NaN
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
index 6e8638173..85dc436dc 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
@@ -10,12 +10,6 @@ import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
 import org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.*
 import kotlin.reflect.KProperty
 
-/** {@comment
- * In this file we provide documentation for high-level operations such as
- * the operation of selecting columns.
- * }
- */
-
 /** [Selecting Columns][SelectingColumns] */
 internal interface SelectingColumnsLink
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
index 93d2f74fd..6d65f010a 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
@@ -1,7 +1,11 @@
 package org.jetbrains.kotlinx.dataframe.documentation
 
-import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.RowValueFilter
 import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.documentation.SelectingRows.RowConditionLink
+import org.jetbrains.kotlinx.dataframe.documentation.SelectingRows.RowValueConditionLink
+import org.jetbrains.kotlinx.dataframe.index
 
 /**
  * ## Selecting Rows
@@ -14,7 +18,6 @@ import org.jetbrains.kotlinx.dataframe.api.*
  * (using [RowValueFilter]).
  *
  * A Row Condition is similar to a [Row Expression][org.jetbrains.kotlinx.dataframe.documentation.ExpressionsGivenRow] but expects a [Boolean] as result.
- *
  */
 internal interface SelectingRows {
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
index 7a12a5abe..7e837b558 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt
@@ -24,14 +24,14 @@ import kotlin.reflect.typeOf
 /**
  * Referring to a column in the selection DSL can be done in several ways corresponding to all
  * [Access APIs][AccessApi]:
- * TODO
+ * TODO: [Issue #286](https://github.com/Kotlin/dataframe/issues/286)
  */
 private interface CommonColumnSelectionExamples
 
 /** [Column Selection DSL][ColumnSelectionDsl] */
 internal interface ColumnSelectionDslLink
 
-/** TODO: Put examples and explanations here */
+/** TODO: [Issue #286](https://github.com/Kotlin/dataframe/issues/286) */
 public interface ColumnSelectionDsl<out T> : ColumnsContainer<T> {
 
     public operator fun <C> ColumnReference<C>.invoke(): DataColumn<C> = get(this)
@@ -50,7 +50,7 @@ public interface ColumnSelectionDsl<out T> : ColumnsContainer<T> {
 /** [Columns Selection DSL][ColumnsSelectionDsl] */
 internal interface ColumnsSelectionDslLink
 
-/** TODO: Put examples and explanations here */
+/** TODO: [Issue #286](https://github.com/Kotlin/dataframe/issues/286) */
 public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColumn<DataRow<T>> {
 
     public fun <C> ColumnSet<C>.first(condition: ColumnFilter<C>): SingleColumn<C> =
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
index 50bb2f354..3812b65f6 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt
@@ -9,32 +9,6 @@ import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumns
 import kotlin.reflect.KProperty
 
-/**
- * ## `NaN`
- * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
- * in cases where a mathematical operation is undefined, such as dividing by zero.
- *
- * You can also use [fillNaNs][fillNaNs] to replace `NaNs` in certain columns with a given value or expression
- * or [dropNaNs][dropNaNs] to drop rows with `NaNs` in them.
- *
- * @see NA
- */
-internal interface NaN
-
-/**
- * ## `NA`
- * `NA` in Dataframe can be seen as "[NaN] or `null`".
- *
- * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
- * in cases where a mathematical operation is undefined, such as dividing by zero.
- *
- * You can also use [fillNA][fillNA] to replace `NAs` in certain columns with a given value or expression
- * or [dropNA][dropNA] to drop rows with `NAs` in them.
- *
- * @see NaN
- */
-internal interface NA
-
 // region fillNulls
 
 /**
@@ -60,7 +34,9 @@ private interface SetFillNullsOperationArg
  * @include [FillNulls] {@comment Description of the fillNulls operation.}
  * @include [LineBreak]
  * @include [Update.Columns] {@comment Description of what this function expects the user to do: select columns}
+ *
  * ## This Fill Nulls Overload
+ *
  */
 private interface CommonFillNullsFunctionDoc
 
@@ -97,7 +73,7 @@ public fun <T, C> DataFrame<T>.fillNulls(vararg columns: ColumnReference<C>): Up
     fillNulls { columns.toColumns() }
 
 /**
- * TODO this will be deprecated
+ * TODO this will be deprecated [PR #286](https://github.com/Kotlin/dataframe/pull/320)
  */
 public fun <T, C> DataFrame<T>.fillNulls(columns: Iterable<ColumnReference<C>>): Update<T, C?> =
     fillNulls { columns.toColumnSet() }
@@ -186,7 +162,7 @@ public fun <T, C> DataFrame<T>.fillNaNs(vararg columns: ColumnReference<C>): Upd
     fillNaNs { columns.toColumns() }
 
 /**
- * TODO this will be deprecated
+ * TODO this will be deprecated [PR #286](https://github.com/Kotlin/dataframe/pull/320)
  */
 public fun <T, C> DataFrame<T>.fillNaNs(columns: Iterable<ColumnReference<C>>): Update<T, C> =
     fillNaNs { columns.toColumnSet() }
@@ -255,7 +231,7 @@ public fun <T, C> DataFrame<T>.fillNA(vararg columns: ColumnReference<C>): Updat
     fillNA { columns.toColumns() }
 
 /**
- * TODO this will be deprecated
+ * TODO this will be deprecated [PR #286](https://github.com/Kotlin/dataframe/pull/320)
  */
 public fun <T, C> DataFrame<T>.fillNA(columns: Iterable<ColumnReference<C>>): Update<T, C?> =
     fillNA { columns.toColumnSet() }
@@ -358,7 +334,7 @@ public fun <T> DataFrame<T>.dropNulls(vararg columns: AnyColumnReference, whereA
     dropNulls(whereAllNull) { columns.toColumns() }
 
 /**
- * TODO will be deprecated
+ * TODO this will be deprecated [PR #286](https://github.com/Kotlin/dataframe/pull/320)
  */
 public fun <T> DataFrame<T>.dropNulls(
     columns: Iterable<AnyColumnReference>,
@@ -452,7 +428,7 @@ public fun <T> DataFrame<T>.dropNA(vararg columns: AnyColumnReference, whereAllN
     dropNA(whereAllNA) { columns.toColumns() }
 
 /**
- * TODO will be deprecated
+ * TODO this will be deprecated [PR #286](https://github.com/Kotlin/dataframe/pull/320)
  */
 public fun <T> DataFrame<T>.dropNA(columns: Iterable<AnyColumnReference>, whereAllNA: Boolean = false): DataFrame<T> =
     dropNA(whereAllNA) { columns.toColumnSet() }
@@ -554,9 +530,12 @@ public fun <T> DataFrame<T>.dropNaNs(vararg columns: AnyColumnReference, whereAl
     dropNaNs(whereAllNaN) { columns.toColumns() }
 
 /**
- * TODO will be deprecated
+ * TODO this will be deprecated [PR #286](https://github.com/Kotlin/dataframe/pull/320)
  */
-public fun <T> DataFrame<T>.dropNaNs(columns: Iterable<AnyColumnReference>, whereAllNaN: Boolean = false): DataFrame<T> =
+public fun <T> DataFrame<T>.dropNaNs(
+    columns: Iterable<AnyColumnReference>,
+    whereAllNaN: Boolean = false,
+): DataFrame<T> =
     dropNaNs(whereAllNaN) { columns.toColumnSet() }
 
 /**
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
index 10e2360c5..0404b3938 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -127,7 +127,7 @@ public fun <T, C> DataFrame<T>.update(vararg columns: ColumnReference<C>): Updat
     update { columns.toColumns() }
 
 /**
- * TODO this will be deprecated
+ * TODO this will be deprecated [PR #286](https://github.com/Kotlin/dataframe/pull/320)
  */
 public fun <T, C> DataFrame<T>.update(columns: Iterable<ColumnReference<C>>): Update<T, C> =
     update { columns.toColumnSet() }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
index 0f0e56b42..e508110de 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
@@ -95,4 +95,4 @@ internal interface AccessApi {
 }
 
 /** [Access API][AccessApi] */
-internal interface AccessApiLink
+public const val AccessApiLink: Int = 0
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
index 826fd6894..aa3fa6d01 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt
@@ -20,11 +20,11 @@ import org.jetbrains.kotlinx.dataframe.RowValueExpression as DfRowValueExpressio
  * for instance in [update.with][Update.with], and [convert.notNull][Convert.notNull]
  * (using [RowValueExpression][DfRowValueExpression]).
  *
- * Note:
+ * NOTE:
  *
  * @include [AddDataRowNote]
  *
- * A Row Expression is similar to a {@include [RowConditionLink]} but that expects a [Boolean] as result.
+ * A {@include [RowExpressionLink]} is similar to a {@include [RowConditionLink]} but that expects a [Boolean] as result.
  */
 internal interface ExpressionsGivenRow {
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NA.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NA.kt
new file mode 100644
index 000000000..35251f23f
--- /dev/null
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NA.kt
@@ -0,0 +1,18 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.api.dropNA
+import org.jetbrains.kotlinx.dataframe.api.fillNA
+
+/**
+ * ## `NA`
+ * `NA` in Dataframe can be seen as "[NaN] or `null`".
+ *
+ * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
+ * in cases where a mathematical operation is undefined, such as dividing by zero.
+ *
+ * You can also use [fillNA][fillNA] to replace `NAs` in certain columns with a given value or expression
+ * or [dropNA][dropNA] to drop rows with `NAs` in them.
+ *
+ * @see NaN
+ */
+internal interface NA
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NaN.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NaN.kt
new file mode 100644
index 000000000..18b979294
--- /dev/null
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NaN.kt
@@ -0,0 +1,16 @@
+package org.jetbrains.kotlinx.dataframe.documentation
+
+import org.jetbrains.kotlinx.dataframe.api.dropNaNs
+import org.jetbrains.kotlinx.dataframe.api.fillNaNs
+
+/**
+ * ## `NaN`
+ * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively,
+ * in cases where a mathematical operation is undefined, such as dividing by zero.
+ *
+ * You can also use [fillNaNs][fillNaNs] to replace `NaNs` in certain columns with a given value or expression
+ * or [dropNaNs][dropNaNs] to drop rows with `NaNs` in them.
+ *
+ * @see NA
+ */
+internal interface NaN
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
index 33ec04c5a..755ae5e4e 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt
@@ -10,12 +10,6 @@ import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
 import org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns.*
 import kotlin.reflect.KProperty
 
-/** {@comment
- * In this file we provide documentation for high-level operations such as
- * the operation of selecting columns.
- * }
- */
-
 /** [Selecting Columns][SelectingColumns] */
 internal interface SelectingColumnsLink
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
index 6438b05aa..c560e0966 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt
@@ -1,7 +1,11 @@
 package org.jetbrains.kotlinx.dataframe.documentation
 
-import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.RowFilter
+import org.jetbrains.kotlinx.dataframe.RowValueFilter
 import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.documentation.SelectingRows.RowConditionLink
+import org.jetbrains.kotlinx.dataframe.documentation.SelectingRows.RowValueConditionLink
+import org.jetbrains.kotlinx.dataframe.index
 
 /**
  * ## Selecting Rows
@@ -14,7 +18,6 @@ import org.jetbrains.kotlinx.dataframe.api.*
  * (using [RowValueFilter]).
  *
  * A Row Condition is similar to a {@include [RowExpressionsLink]} but expects a [Boolean] as result.
- * {@comment TODO Is `where` present everywhere it should be?}
  */
 internal interface SelectingRows {
 
diff --git a/examples/idea-examples/movies/build.gradle.kts b/examples/idea-examples/movies/build.gradle.kts
index 2c38f37fa..fbb2c9e44 100644
--- a/examples/idea-examples/movies/build.gradle.kts
+++ b/examples/idea-examples/movies/build.gradle.kts
@@ -16,7 +16,6 @@ application.mainClass.set("org.jetbrains.kotlinx.dataframe.examples.movies.Movie
 
 dependencies {
     implementation(project(":core"))
-    implementation(project(":dataframe-openapi"))
 }
 
 tasks.withType<KotlinCompile> {

From 2a1b305f901384e448de3790deae807f09547e41 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Mon, 27 Mar 2023 13:31:56 +0200
Subject: [PATCH 49/50] including test sources to doc processor to enable
 cross-references

---
 core/build.gradle.kts                         |    9 +-
 .../dataframe/documentation/AccessApi.kt      |    5 +-
 .../org/jetbrains/kotlinx/dataframe/Utils.kt  |   23 +
 .../jetbrains/kotlinx/dataframe/api/add.kt    |   36 +
 .../jetbrains/kotlinx/dataframe/api/cast.kt   |   26 +
 .../kotlinx/dataframe/api/chunked.kt          |   17 +
 .../jetbrains/kotlinx/dataframe/api/concat.kt |   14 +
 .../kotlinx/dataframe/api/contains.kt         |   64 +
 .../kotlinx/dataframe/api/convert.kt          |  175 ++
 .../kotlinx/dataframe/api/convertTo.kt        |  344 +++
 .../jetbrains/kotlinx/dataframe/api/corr.kt   |   54 +
 .../kotlinx/dataframe/api/describe.kt         |   14 +
 .../kotlinx/dataframe/api/emptyDataFrame.kt   |   52 +
 .../kotlinx/dataframe/api/explode.kt          |   37 +
 .../kotlinx/dataframe/api/flatten.kt          |   77 +
 .../jetbrains/kotlinx/dataframe/api/gather.kt |  185 ++
 .../jetbrains/kotlinx/dataframe/api/get.kt    |   92 +
 .../kotlinx/dataframe/api/groupBy.kt          |   58 +
 .../kotlinx/dataframe/api/implode.kt          |   21 +
 .../kotlinx/dataframe/api/inferType.kt        |   31 +
 .../jetbrains/kotlinx/dataframe/api/join.kt   |   33 +
 .../jetbrains/kotlinx/dataframe/api/map.kt    |   21 +
 .../jetbrains/kotlinx/dataframe/api/move.kt   |   86 +
 .../jetbrains/kotlinx/dataframe/api/parse.kt  |  148 +
 .../jetbrains/kotlinx/dataframe/api/pivot.kt  |  156 +
 .../jetbrains/kotlinx/dataframe/api/remove.kt |   35 +
 .../jetbrains/kotlinx/dataframe/api/rename.kt |   58 +
 .../kotlinx/dataframe/api/reorder.kt          |   31 +
 .../kotlinx/dataframe/api/replace.kt          |   16 +
 .../kotlinx/dataframe/api/reverse.kt          |   27 +
 .../dataframe/api/sortGroupedDataframe.kt     |   72 +
 .../jetbrains/kotlinx/dataframe/api/split.kt  |  168 ++
 .../kotlinx/dataframe/api/toDataFrame.kt      |  200 ++
 .../jetbrains/kotlinx/dataframe/api/toList.kt |   28 +
 .../jetbrains/kotlinx/dataframe/api/update.kt |   86 +
 .../dataframe/codeGen/CodeGenerationTests.kt  |  316 ++
 .../dataframe/codeGen/MatchSchemeTests.kt     |  100 +
 .../dataframe/codeGen/NameGenerationTests.kt  |   53 +
 .../dataframe/codeGen/ReplCodeGenTests.kt     |  222 ++
 .../codeGen/ShortNamesRenderingTest.kt        |  137 +
 .../kotlinx/dataframe/columns/ColumnGroups.kt |   19 +
 .../kotlinx/dataframe/io/CsvTests.kt          |  258 ++
 .../kotlinx/dataframe/io/ParserTests.kt       |  206 ++
 .../kotlinx/dataframe/io/PlaylistJsonTest.kt  |  206 ++
 .../kotlinx/dataframe/io/ReadTests.kt         |  104 +
 .../kotlinx/dataframe/io/TypeInferenceTest.kt |   19 +
 .../jetbrains/kotlinx/dataframe/io/json.kt    |  954 +++++++
 .../dataframe/jupyter/CodeGenerationTests.kt  |   40 +
 .../dataframe/jupyter/DataFrameJupyterTest.kt |   51 +
 .../dataframe/jupyter/JupyterCodegenTests.kt  |  317 +++
 .../dataframe/jupyter/RenderingTests.kt       |  128 +
 .../dataframe/jupyter/ResourcesTest.kt        |   17 +
 .../dataframe/jupyter/SampleNotebooksTests.kt |  126 +
 .../kotlinx/dataframe/puzzles/BasicTests.kt   |  206 ++
 .../dataframe/puzzles/CleaningDataTests.kt    |  120 +
 .../dataframe/puzzles/DateTestUtils.kt        |   41 +
 .../kotlinx/dataframe/puzzles/DateTests.kt    |  105 +
 .../kotlinx/dataframe/puzzles/HardTests.kt    |  123 +
 .../kotlinx/dataframe/puzzles/MediumTests.kt  |  125 +
 .../dataframe/rendering/PrecisionTests.kt     |   45 +
 .../dataframe/rendering/RenderingTests.kt     |  128 +
 .../dataframe/rendering/RenderingTestsBase.kt |   18 +
 .../dataframe/rendering/TooltipTests.kt       |   25 +
 .../dataframe/rendering/TruncateTests.kt      |  127 +
 .../dataframe/rendering/html/Browsing.kt      |   40 +
 .../kotlinx/dataframe/rendering/html/Utils.kt |   15 +
 .../kotlinx/dataframe/samples/api/Access.kt   |  916 ++++++
 .../kotlinx/dataframe/samples/api/Analyze.kt  | 1145 ++++++++
 .../dataframe/samples/api}/ApiLevels.kt       |   47 +-
 .../dataframe/samples/api/Collections.kt      |   81 +
 .../kotlinx/dataframe/samples/api/Create.kt   |  389 +++
 .../dataframe/samples/api/DataRowApi.kt       |   45 +
 .../kotlinx/dataframe/samples/api/Join.kt     |  125 +
 .../kotlinx/dataframe/samples/api/Modify.kt   | 1256 ++++++++
 .../kotlinx/dataframe/samples/api/Schemas.kt  |  124 +
 .../kotlinx/dataframe/samples/api/TestBase.kt |   39 +
 .../dataframe/statistics/BasicMathTests.kt    |   22 +
 .../kotlinx/dataframe/statistics/cumsum.kt    |   68 +
 .../kotlinx/dataframe/statistics/median.kt    |   33 +
 .../dataframe/statistics/quickSelect.kt       |   33 +
 .../kotlinx/dataframe/statistics/std.kt       |   38 +
 .../testSets/animals/AnimalsTests.kt          |   46 +
 .../dataframe/testSets/person/BaseTest.kt     |   40 +
 .../dataframe/testSets/person/BuildTests.kt   |   33 +
 .../testSets/person/DataColumnTests.kt        |   17 +
 .../testSets/person/DataFrameTests.kt         | 2535 +++++++++++++++++
 .../testSets/person/DataFrameTreeTests.kt     |  737 +++++
 .../dataframe/testSets/person/DataRowTests.kt |  108 +
 .../testSets/person/FormattingTests.kt        |   49 +
 .../testSets/person/HtmlRenderingTests.kt     |   43 +
 .../dataframe/testSets/person/JoinTests.kt    |  121 +
 .../dataframe/testSets/person/PivotTests.kt   |  514 ++++
 .../dataframe/testSets/person2/Base.kt        |   35 +
 .../dataframe/testSets/person2/merge.kt       |   20 +
 .../dataframe/testSets/person2/replace.kt     |   21 +
 .../dataframe/testSets/weather/SeriesTests.kt |   74 +
 .../kotlinx/dataframe/types/DoubleTests.kt    |   21 +
 .../dataframe/types/TypeProjectionTests.kt    |   58 +
 .../kotlinx/dataframe/types/UtilTests.kt      |  253 ++
 .../dataframe/documentation/AccessApi.kt      |    9 +-
 .../documentation/samples/ApiLevels.kt        |  146 -
 101 files changed, 15945 insertions(+), 186 deletions(-)
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/Utils.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/chunked.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/concat.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/contains.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/convertTo.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/emptyDataFrame.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/flatten.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/get.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/implode.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/map.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/parse.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reverse.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/sortGroupedDataframe.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/split.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/toList.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeGenerationTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/MatchSchemeTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/NameGenerationTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ReplCodeGenTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ShortNamesRenderingTest.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnGroups.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/CsvTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ParserTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/PlaylistJsonTest.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ReadTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/TypeInferenceTest.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/CodeGenerationTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/DataFrameJupyterTest.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterCodegenTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/RenderingTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/ResourcesTest.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/BasicTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/CleaningDataTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/DateTestUtils.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/DateTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/HardTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/MediumTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/PrecisionTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/RenderingTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/RenderingTestsBase.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/TooltipTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/TruncateTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/html/Browsing.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/html/Utils.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Access.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Analyze.kt
 rename core/generated-sources/src/{main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/samples => test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api}/ApiLevels.kt (57%)
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Collections.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Create.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/DataRowApi.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Join.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Modify.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Schemas.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/TestBase.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/BasicMathTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/cumsum.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/median.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/quickSelect.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/std.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/animals/AnimalsTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/BaseTest.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/BuildTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataColumnTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTreeTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataRowTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/FormattingTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/HtmlRenderingTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/JoinTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/PivotTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/Base.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/merge.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/replace.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/weather/SeriesTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/types/DoubleTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/types/TypeProjectionTests.kt
 create mode 100644 core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/types/UtilTests.kt
 delete mode 100644 core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/samples/ApiLevels.kt

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 96ae9e8d6..1d1fc710b 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -69,10 +69,12 @@ val addGeneratedSourcesToGit by tasks.creating(GitTask::class) {
 
 // Backup the kotlin source files location
 val kotlinMainSources = kotlin.sourceSets.main.get().kotlin.sourceDirectories
+val kotlinTestSources = kotlin.sourceSets.test.get().kotlin.sourceDirectories
 
 // Task to generate the processed documentation
 val processKDocsMain by creatingProcessDocTask(
-    sources = kotlinMainSources.filterNot { "build/generated" in it.path }, // Exclude generated sources
+    sources = (kotlinMainSources + kotlinTestSources) // Include both test and main sources for cross-referencing
+        .filterNot { "build/generated" in it.path }, // Exclude generated sources
 ) {
     target = file(generatedSourcesFolderName)
     processors = listOf(
@@ -107,8 +109,9 @@ tasks.withType<Jar> {
     doFirst {
         kotlin.sourceSets.main {
             kotlin.setSrcDirs(
-                processKDocsMain.targets +
-                    kotlinMainSources.filter { "build/generated" in it.path } // Include generated sources (which were excluded above)
+                processKDocsMain.targets
+                    .filterNot { "src/test/kotlin" in it.path || "src/test/java" in it.path } // filter out test sources again
+                    .plus(kotlinMainSources.filter { "build/generated" in it.path }) // Include generated sources (which were excluded above)
             )
         }
     }
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
index 0f455581a..69db29b08 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
@@ -1,7 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.documentation
 
 import org.jetbrains.kotlinx.dataframe.documentation.AccessApi.*
-import org.jetbrains.kotlinx.dataframe.documentation.samples.ApiLevels as ApiLevelsSample
 
 /**
  * ## Access APIs
@@ -123,9 +122,7 @@ internal interface AccessApi {
      *
      * For example:
      * ```kotlin
-     * fun extensionProperties1() {
-     *     val df = DataFrame.read("titanic.csv")
-     * }
+     * val df = DataFrame.read("titanic.csv")
      * ```
      */
     interface ExtensionPropertiesApi
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/Utils.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/Utils.kt
new file mode 100644
index 000000000..79effbcb5
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/Utils.kt
@@ -0,0 +1,23 @@
+package org.jetbrains.kotlinx.dataframe
+
+import org.jetbrains.kotlinx.dataframe.api.print
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.io.renderToString
+import org.jetbrains.kotlinx.dataframe.types.UtilTests
+import java.net.URL
+
+fun testResource(resourcePath: String): URL = UtilTests::class.java.classLoader.getResource(resourcePath)!!
+fun testCsv(csvName: String) = testResource("$csvName.csv")
+fun testJson(jsonName: String) = testResource("$jsonName.json")
+
+fun <T : DataFrame<*>> T.toDebugString(rowsLimit: Int = 20) = """
+    ${renderToString(borders = true, title = true, columnTypes = true, valueLimit = -1, rowsLimit = rowsLimit)}
+    
+    ${schema()}
+""".trimIndent()
+
+fun <T : DataFrame<*>> T.alsoDebug(println: String? = null, rowsLimit: Int = 20): T = apply {
+    println?.let { println(it) }
+    print(borders = true, title = true, columnTypes = true, valueLimit = -1, rowsLimit = rowsLimit)
+    schema().print()
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
new file mode 100644
index 000000000..4f164215d
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt
@@ -0,0 +1,36 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class AddTests {
+
+    @Test
+    fun `add with new`() {
+        val x by columnOf(7, 2, 0, 3, 4, 2, 5, 0, 3, 4)
+        val df = dataFrameOf(x)
+        val added = df.add("Y") { if (x() == 0) 0 else (prev()?.newValue() ?: 0) + 1 }
+        val expected = listOf(1, 2, 0, 1, 2, 3, 4, 0, 1, 2)
+        added["Y"].values() shouldBe expected
+    }
+
+    @Test
+    fun `throw for newValue at the next row`() {
+        val x by columnOf(7, 2, 0, 3, 4, 2, 5, 0, 3, 4)
+        val df = dataFrameOf(x)
+        shouldThrow<IndexOutOfBoundsException> {
+            df.add("y") { next()?.newValue() ?: 1 }
+        }
+    }
+
+    private fun <T> AnyFrame.addValue(value: T) = add("value") { listOf(value) }
+
+    @Test
+    fun `add with generic function`() {
+        val df = dataFrameOf("a")(1).addValue(2)
+        df["value"].type() shouldBe typeOf<List<Any?>>()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt
new file mode 100644
index 000000000..025a68bbd
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt
@@ -0,0 +1,26 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.junit.Test
+import java.lang.IllegalArgumentException
+
+class CastTests {
+
+    @Test
+    fun safeUnsafeCast() {
+        @DataSchema
+        data class Data(val a: Int, val b: String)
+
+        val df = dataFrameOf("a", "b", "c")(1, "s", 2)
+        df.cast<Data>(verify = true) shouldBe df
+
+        shouldThrow<IllegalArgumentException> {
+            df.convert("a").toDouble().cast<Data>(verify = true)
+        }
+        val converted = df.convert("a").toDouble()
+        converted.cast<Data>(verify = false) shouldBe converted
+        converted.cast<Data>() shouldBe converted
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/chunked.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/chunked.kt
new file mode 100644
index 000000000..fd98ad8f3
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/chunked.kt
@@ -0,0 +1,17 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.size
+import org.junit.Test
+
+class ChunkedTests {
+
+    @Test
+    fun chunkedColumnGroup() {
+        val a by columnOf(listOf(1, 2, 3).toColumn("b"), listOf(4, 5, 6).toColumn("c"))
+        val chunked = a.asColumnGroup().chunked(2)
+        chunked.size shouldBe 2
+        chunked.name() shouldBe "a"
+        chunked[1].rowsCount() shouldBe 1
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/concat.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/concat.kt
new file mode 100644
index 000000000..c290e500f
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/concat.kt
@@ -0,0 +1,14 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class ConcatTests {
+
+    @Test
+    fun `different types`() {
+        val a by columnOf(1, 2)
+        val b by columnOf(3.0, null)
+        a.concat(b) shouldBe columnOf(1, 2, 3.0, null).named("a")
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/contains.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/contains.kt
new file mode 100644
index 000000000..47513b3cf
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/contains.kt
@@ -0,0 +1,64 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class ContainsTests {
+
+    @Test
+    fun `column contains`() {
+        val col by columnOf(1, 3, 5)
+        col.contains(3) shouldBe true
+        col.contains(2) shouldBe false
+    }
+
+    @Test
+    fun `column group contains`() {
+        val df = dataFrameOf("a", "b")(1, 2, 3, 4)
+        val col = df.asColumnGroup("col")
+        col.contains(df[0]) shouldBe true
+        col.contains(df.update("b").withValue(0)[0]) shouldBe false
+    }
+
+    @Test
+    fun `contains column`() {
+        val a by column<Int>()
+        val df = dataFrameOf("a")(1, 2)
+        (a in df) shouldBe true
+        df.containsColumn(a) shouldBe true
+        df.containsColumn("a") shouldBe true
+        df.containsColumn(df["a"]) shouldBe true
+        val b by column<Int>()
+        (b in df) shouldBe false
+        df.containsColumn(b) shouldBe false
+    }
+
+    @Test
+    fun `contains nested column`() {
+        val g by columnGroup()
+        val a by g.column<Int>()
+
+        val df = dataFrameOf("a")(1, 2).group("a").into("g")
+        (a in df) shouldBe true
+    }
+
+    @Test
+    fun `row contains key`() {
+        val a by column<Int>()
+        val b by column<Int>()
+        data class A(val a: Int, val b: Int)
+
+        val df = dataFrameOf("a")(1, 2)
+        val row = df[0]
+
+        row.containsKey("a") shouldBe true
+        row.containsKey(a) shouldBe true
+        row.containsKey(A::a) shouldBe true
+        (A::a in row) shouldBe true
+        (a in row) shouldBe true
+
+        row.containsKey("b") shouldBe false
+        row.containsKey(b) shouldBe false
+        row.containsKey(A::b) shouldBe false
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt
new file mode 100644
index 000000000..5269298fe
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt
@@ -0,0 +1,175 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldNotThrow
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.exceptions.CellConversionException
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConversionException
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConverterNotFoundException
+import org.jetbrains.kotlinx.dataframe.hasNulls
+import org.junit.Test
+import java.time.LocalTime
+import kotlin.reflect.typeOf
+import kotlin.time.Duration.Companion.hours
+
+class ConvertTests {
+
+    @Test
+    fun `convert nullable strings to time`() {
+        val time by columnOf("11?22?33", null)
+        val converted = time.toDataFrame().convert { time }.toLocalTime("HH?mm?ss")[time]
+        converted.hasNulls shouldBe true
+        converted[0] shouldBe LocalTime.of(11, 22, 33)
+    }
+
+    @Test
+    fun `nullability persistence after conversion`() {
+        val col by columnOf("1", null)
+        col.convertToInt().forEach {
+        }
+    }
+
+    @DataSchema
+    data class Schema(val time: Instant)
+
+    @Test
+    fun `Instant to LocalDateTime`() {
+        val df = listOf(Schema(Clock.System.now())).toDataFrame()
+        df.convert { time }.toLocalDateTime()
+    }
+
+    enum class EnumClass { A, B }
+
+    @Test
+    fun `convert string to enum`() {
+        columnOf("A", "B").convertTo<EnumClass>() shouldBe columnOf(EnumClass.A, EnumClass.B)
+    }
+
+    @JvmInline
+    value class IntClass(val v: Int)
+
+    @JvmInline
+    value class StringClass(val s: String?)
+
+    @JvmInline
+    value class PrivateInt(private val v: Int)
+
+    @Test
+    fun `convert string to value class`() {
+        columnOf("1").convertTo<IntClass>() shouldBe columnOf(IntClass(1))
+    }
+
+    @Test
+    fun `convert double to value class`() {
+        columnOf(1.0).convertTo<IntClass>() shouldBe columnOf(IntClass(1))
+    }
+
+    @Test
+    fun `convert from value class `() {
+        columnOf(IntClass(1)).convertTo<Double>() shouldBe columnOf(1.0)
+        columnOf(StringClass("1"), StringClass(null)).convertTo<Double?>() shouldBe columnOf(1.0, null)
+    }
+
+    @Test
+    fun `convert to value class exceptions`() {
+        shouldThrow<TypeConversionException> {
+            columnOf("a").convertTo<IntClass>()
+        }
+
+        shouldThrow<CellConversionException> {
+            columnOf("1", "10", "a").convertTo<IntClass>()
+        }.row shouldBe 2
+
+        shouldThrow<CellConversionException> {
+            columnOf("1", "x", "2.5").convertToDouble()
+        }.row shouldBe 1
+
+        shouldThrow<TypeConverterNotFoundException> {
+            columnOf(EnumClass.A).convertTo<IntClass>()
+        }
+    }
+
+    @Test
+    fun `convert from value class exceptions`() {
+        shouldThrow<TypeConversionException> {
+            columnOf(StringClass("a")).convertTo<Int>()
+        }.from shouldBe typeOf<String>()
+
+        shouldThrow<TypeConverterNotFoundException> {
+            columnOf(IntClass(1)).convertTo<EnumClass>()
+        }
+
+        shouldThrow<TypeConversionException> {
+            columnOf(StringClass(null)).convertTo<Double>()
+        }
+
+        shouldThrow<TypeConversionException> {
+            columnOf(PrivateInt(1)).convertTo<Double>()
+        }
+    }
+
+    @Test
+    fun `convert null strings`() {
+        val col = columnOf("none")
+
+        shouldThrow<TypeConversionException> {
+            col.convertTo<Int>()
+        }
+
+        shouldThrow<TypeConversionException> {
+            col.convertTo<Int?>()
+        }
+
+        DataFrame.parser.addNullString("none")
+
+        shouldThrow<TypeConversionException> {
+            col.convertTo<Int>()
+        }
+
+        col.convertTo<Int?>() shouldBe DataColumn.createValueColumn("", listOf(null), typeOf<Int?>())
+
+        DataFrame.parser.resetToDefault()
+    }
+
+    @Test
+    fun `convert to not nullable`() {
+        val col = columnOf(1.0, null)
+
+        col.convertToInt() shouldBe columnOf(1, null)
+
+        shouldThrow<TypeConversionException> {
+            col.cast<Double>().convertToInt()
+        }
+
+        col.convertTo<Int?>() shouldBe columnOf(1, null)
+    }
+
+    @Test
+    fun `convert to nullable without nulls`() {
+        val col = columnOf(1.0, 2.0)
+
+        col.convertTo<Int?>().hasNulls() shouldBe false
+    }
+
+    @Test
+    fun `convert instant`() {
+        println(Clock.System.now().toEpochMilliseconds())
+        val kotlinxInstants = columnOf(Instant.fromEpochMilliseconds(1657283006955))
+        shouldNotThrow<TypeConverterNotFoundException> {
+            val javaInstant = kotlinxInstants.convertTo<java.time.Instant>()
+            javaInstant.convertTo<Instant>() shouldBe kotlinxInstants
+        }
+    }
+
+    @Test
+    fun `convert duration to string`() {
+        val col = columnOf(1.hours)
+        val res = col.convertTo<String>()
+        res.print()
+    }
+}
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
new file mode 100644
index 000000000..04f797153
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/convertTo.kt
@@ -0,0 +1,344 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.alsoDebug
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConverterNotFoundException
+import org.jetbrains.kotlinx.dataframe.kind
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class ConvertToTests {
+
+    @Test
+    fun `convert frame column with empty frames`() {
+        val groups by columnOf(dataFrameOf("a")("1"), DataFrame.empty())
+        val df = dataFrameOf(groups)
+
+        @DataSchema
+        data class GroupSchema(val a: Int)
+
+        @DataSchema
+        data class DataFrameSchema(val groups: DataFrame<GroupSchema>)
+
+        val converted = df.convertTo<DataFrameSchema>()
+
+        converted[groups].forEach {
+            it["a"].type() shouldBe typeOf<Int>()
+        }
+    }
+
+    data class A(val value: Int)
+
+    @DataSchema
+    data class Schema(val a: A)
+
+    @Test
+    fun `convert with parser`() {
+        val df = dataFrameOf("a")("1")
+
+        shouldThrow<TypeConverterNotFoundException> {
+            df.convertTo<Schema>()
+        }
+
+        df.convertTo<Schema> {
+            parser { A(it.toInt()) }
+        }
+            .single().a.value shouldBe 1
+    }
+
+    @Test
+    fun `convert with converter`() {
+        val df = dataFrameOf("a")(1)
+
+        shouldThrow<TypeConverterNotFoundException> {
+            df.convertTo<Schema>()
+        }
+
+        df.convertTo<Schema> {
+            convert<Int>().with { A(it) }
+        }.single().a.value shouldBe 1
+    }
+
+    @Test
+    fun `convert nulls to not nulls with converter`() {
+        val df = dataFrameOf("a")("1", null)
+
+        val converted = df.convertTo<Schema> {
+            convert<String?>().with { it?.let { A(it.toInt()) } ?: A(0) }
+        }
+        val expected = dataFrameOf("a")(A(1), A(0))
+
+        converted shouldBe expected
+    }
+
+    @JvmInline
+    value class IntClass(val value: Int)
+
+    @DataSchema
+    interface IntSchema {
+        val a: IntClass?
+    }
+
+    @Test
+    fun `convert value class with converter`() {
+        dataFrameOf("a")("1%")
+            .convertTo<IntSchema> {
+                parser { IntClass(it.dropLast(1).toInt()) }
+            } shouldBe dataFrameOf("a")(IntClass(1))
+    }
+
+    @Test
+    fun `convert nulls with converter`() {
+        dataFrameOf("a")("1%", null)
+            .convertTo<IntSchema> {
+                parser { IntClass(it.dropLast(1).toInt()) }
+            } shouldBe dataFrameOf("a")(IntClass(1), null)
+    }
+
+    @Test
+    fun `convert with nullable converter argument`() {
+        val df = dataFrameOf("a")("1")
+
+        val converted = df.convertTo<IntSchema> {
+            convert<String?>().with {
+                it?.let { IntClass(it.toInt()) }
+            }
+        }
+        val expected = dataFrameOf("a")(IntClass(1))
+
+        converted shouldBe expected
+    }
+
+    @DataSchema
+    data class Location(
+        val name: String,
+        val gps: Gps?,
+    )
+
+    @DataSchema
+    data class Gps(val latitude: Double, val longitude: Double)
+
+    // @Test TODO: https://github.com/Kotlin/dataframe/issues/177
+    fun `convert df with nullable DataRow`() {
+        val locations: AnyFrame = dataFrameOf("name", "gps")(
+            "Home", Gps(0.0, 0.0),
+            "Away", null,
+        )
+
+        locations.print(borders = true, title = true, columnTypes = true)
+        locations.schema().print()
+
+        val converted = locations.convertTo<Location>()
+
+        converted shouldBe locations
+    }
+
+    @Test
+    fun `convert df with nullable DataRow to itself`() {
+        val locations: DataFrame<Location> = listOf(
+            Location("Home", Gps(0.0, 0.0)),
+            Location("Away", null),
+        ).toDataFrame()
+
+        val converted = locations.convertTo<Location>()
+
+        converted shouldBe locations
+    }
+
+    @DataSchema
+    data class DataSchemaWithAnyFrame(val dfs: AnyFrame?)
+
+    @Test
+    fun test() {
+        val df1 = dataFrameOf("a")(1, 2, 3)
+        val df2 = dataFrameOf("b")(4, 5)
+        val frameColumn by columnOf(df1, df2, null)
+        val df = dataFrameOf(frameColumn).alsoDebug()
+//        ⌌---------------⌍
+//        |  | untitled:[]|
+//        |--|------------|
+//        | 0|     [3 x 1]|
+//        | 1|     [2 x 1]|
+//        | 2|     [0 x 0]|
+//        ⌎---------------⌏
+//
+//        untitled: *
+    }
+
+    @Test
+    fun `convert df with AnyFrame to itself`() {
+        val locationsList = listOf(
+            Location("Home", Gps(0.0, 0.0)),
+            Location("Away", null),
+            null,
+        )
+        val locations = locationsList
+            .toDataFrame()
+            .alsoDebug("locations:")
+
+        val gpsList = listOf(
+            Gps(0.0, 0.0),
+            null,
+        )
+        val gps = gpsList
+            .toDataFrame()
+            .alsoDebug("gps:")
+
+        val df1 = listOf(
+            DataSchemaWithAnyFrame(locations),
+        )
+            .toDataFrame()
+            .alsoDebug("df1:")
+
+        df1.convertTo<DataSchemaWithAnyFrame>()
+
+        val df2 = listOf(
+            DataSchemaWithAnyFrame(gps),
+        )
+            .toDataFrame()
+            .alsoDebug("df2:")
+
+        df2.convertTo<DataSchemaWithAnyFrame>()
+
+        val df3 = listOf(
+            DataSchemaWithAnyFrame(null),
+            DataSchemaWithAnyFrame(gps),
+        )
+            .toDataFrame { properties { preserve(DataFrame::class) } }
+            .alsoDebug("df3 before convert:")
+
+        df3.convertTo<DataSchemaWithAnyFrame>()
+
+        val df4 = listOf(
+            DataSchemaWithAnyFrame(null),
+        )
+            .toDataFrame { properties { preserve(DataFrame::class) } }
+            .alsoDebug("df4 before convert:")
+
+        df4.convertTo<DataSchemaWithAnyFrame>()
+
+        val df5a: DataFrame<*> = dataFrameOf(
+            columnOf(locations, gps, null).named("dfs"),
+        ).alsoDebug("df5a:")
+
+        df5a.convertTo<DataSchemaWithAnyFrame>()
+
+        val df5 = listOf(
+            DataSchemaWithAnyFrame(null),
+            DataSchemaWithAnyFrame(locations),
+            DataSchemaWithAnyFrame(gps),
+        )
+            .toDataFrame { properties { preserve(DataFrame::class) } }
+            .alsoDebug("df5 before convert:")
+
+        df5.convertTo<DataSchemaWithAnyFrame>()
+            .alsoDebug("df5 after convert:")
+            .convertTo<DataSchemaWithAnyFrame>()
+            .alsoDebug("df5 after second convert:")
+    }
+
+    interface KeyValue<T> {
+        val key: String
+        val value: T
+    }
+
+    @DataSchema
+    interface MySchema : KeyValue<Int>
+
+    @Test
+    fun `Convert generic interface to itself`() {
+        val df = dataFrameOf("key", "value")(
+            "a", 1,
+            "b", 2,
+        ).alsoDebug()
+        val converted = df.convertTo<MySchema>().alsoDebug()
+        converted shouldBe df
+    }
+
+    @Test
+    fun `convert with missing nullable column`() {
+        @DataSchema
+        data class Result(val a: Int, val b: Int?)
+
+        val df = dataFrameOf("a")(1, 2)
+        val converted = df.convertTo<Result>()
+        converted shouldBe listOf(Result(1, null), Result(2, null)).toDataFrame()
+    }
+
+    @Test
+    fun `convert with custom fill of missing columns`() {
+        val locations = listOf(
+            Location("Home", Gps(1.0, 1.0)),
+            Location("Away", null),
+        ).toDataFrame().cast<Location>()
+
+        val converted = locations.remove { gps.longitude }.cast<Unit>()
+            .convertTo<Location> {
+                fill { gps.longitude }.with { gps.latitude }
+            }
+
+        converted shouldBe locations.update { gps.longitude }.with { gps.latitude }
+    }
+
+    @Test
+    fun `convert column of empty lists into FrameColumn`() {
+        @DataSchema
+        data class Entry(val v: Int)
+
+        @DataSchema
+        data class Result(val d: DataFrame<Entry>)
+
+        dataFrameOf("d")(emptyList<Any>(), emptyList<Any>())
+            .convertTo<Result>() shouldBe
+            dataFrameOf("d")(DataFrame.emptyOf<Entry>(), DataFrame.emptyOf<Entry>())
+    }
+
+    @Test
+    fun `convert ColumnGroup into FrameColumn`() {
+        @DataSchema
+        data class Entry(val v: Int)
+
+        @DataSchema
+        data class Result(val d: DataFrame<Entry>)
+
+        val columnGroup = DataColumn.createColumnGroup("d", dataFrameOf("v")(1, 2))
+        columnGroup.kind() shouldBe ColumnKind.Group
+        val res = dataFrameOf(columnGroup).convertTo<Result>()
+        val frameColumn = res.getFrameColumn("d")
+        frameColumn.kind shouldBe ColumnKind.Frame
+        frameColumn.values() shouldBe listOf(dataFrameOf("v")(1), dataFrameOf("v")(2))
+    }
+
+    @Test
+    fun `convert ValueColumn of lists, nulls and frames into FrameColumn`(){
+        @DataSchema
+        data class Entry(val v: Int)
+
+        @DataSchema
+        data class Result(val d: DataFrame<Entry>)
+
+        val emptyList: List<Any?> = emptyList()
+        val listOfRows: List<AnyRow> = dataFrameOf("v")(1, 2).rows().toList()
+        val frame: DataFrame<Entry> = listOf(Entry(3), Entry(4)).toDataFrame()
+
+        val src = DataColumn.createValueColumn("d", listOf(emptyList, listOfRows, frame, null)).toDataFrame()
+        src["d"].kind shouldBe ColumnKind.Value
+
+        val df = src.convertTo<Result>()
+        val frameColumn = df.getFrameColumn("d")
+        frameColumn.kind shouldBe ColumnKind.Frame
+        frameColumn.toList() shouldBe listOf(
+            DataFrame.emptyOf<Entry>(),
+            dataFrameOf("v")(1, 2),
+            dataFrameOf("v")(3, 4),
+            DataFrame.emptyOf<Entry>(),
+        )
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt
new file mode 100644
index 000000000..638e9ad32
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt
@@ -0,0 +1,54 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.doubles.ToleranceMatcher
+import io.kotest.matchers.should
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class CorrTests {
+
+    val df = dataFrameOf("a", "b", "c")(
+        3, true, 1,
+        6, false, 2
+    )
+
+    @Test
+    fun `corr with boolean`() {
+        val corr = df.corr("a", "b").with("c")
+        corr.rowsCount() shouldBe 2
+        corr.columnsCount() shouldBe 2
+        corr.getColumn(0) shouldBe (columnOf("a", "b") named "column")
+        corr.getColumn(1).name() shouldBe "c"
+        corr["c"][0] as Double should ToleranceMatcher(1.0, 0.01)
+        corr["c"][1] as Double should ToleranceMatcher(-1.0, 0.01)
+    }
+
+    @Test
+    fun `corr group`() {
+        val corr = df.group("a", "b").into("g")
+            .corr("g").with("c")
+
+        corr shouldBe df.corr("a", "b").with("c").rename("column" to "g")
+    }
+
+    @Test
+    fun `corr itself`() {
+        val corr = df.corr()
+        val expected = dataFrameOf("column", "a", "b", "c")(
+            "a", 1.0, -1.0, 1.0,
+            "b", -1.0, 1.0, -1.0,
+            "c", 1.0, -1.0, 1.0
+        )
+        corr.columns().zip(expected.columns()).forEach { (a, b) ->
+            a.type() shouldBe b.type()
+            if (a.isNumber()) {
+                a.name() shouldBe b.name()
+                a.values().zip(b.values()).forEach { (v1, v2) ->
+                    v1 as Double should ToleranceMatcher(v2 as Double, 0.01)
+                }
+            } else {
+                a shouldBe b
+            }
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt
new file mode 100644
index 000000000..a418e8744
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt
@@ -0,0 +1,14 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class DescribeTests {
+
+    @Test
+    fun `describe all nulls`() {
+        val a by columnOf(1, null)
+        val df = dataFrameOf(a).drop(1)
+        df.describe()["min"][0] shouldBe null
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/emptyDataFrame.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/emptyDataFrame.kt
new file mode 100644
index 000000000..6f7d3b33a
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/emptyDataFrame.kt
@@ -0,0 +1,52 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class EmptyDataFrameTests {
+
+    @Test
+    fun simple() {
+        with(DataFrame.empty()) {
+            rowsCount() shouldBe 0
+            columnsCount() shouldBe 0
+        }
+    }
+
+    @Test
+    fun emptyWithRows() {
+        with(DataFrame.empty(3)) {
+            rowsCount() shouldBe 3
+            columnsCount() shouldBe 0
+        }
+    }
+
+    @DataSchema
+    data class FrameSchema(val e: Double)
+
+    @DataSchema
+    data class GroupSchema(val c: Int, val d: String)
+
+    @DataSchema
+    data class Schema(val a: Int, val group: GroupSchema, val frame: List<FrameSchema>)
+
+    @Test
+    fun emptyWithColumns() {
+        with(DataFrame.emptyOf<Schema>()) {
+            rowsCount() shouldBe 0
+            columnsCount() shouldBe 3
+            columnNames() shouldBe listOf("a", "group", "frame")
+            get("a").type() shouldBe typeOf<Int>()
+            getColumnGroup("group").let {
+                it.columnNames() shouldBe listOf("c", "d")
+                it["c"].type() shouldBe typeOf<Int>()
+            }
+            getFrameColumn("frame").let {
+                it.schema.value.columns.keys shouldBe listOf("e")
+            }
+        }
+    }
+}
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
new file mode 100644
index 000000000..53b7bea3c
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/explode.kt
@@ -0,0 +1,37 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class ExplodeTests {
+
+    @Test
+    fun `explode into`() {
+        val df = dataFrameOf("a" to listOf(1), "b" to listOf(listOf(2, 3)))
+        val exploded = df.explode { "b" into "c" }
+        val expected = dataFrameOf("a" to listOf(1, 1), "c" to listOf(2, 3))
+        exploded shouldBe expected
+    }
+
+    @Test
+    fun `explode list and duplicate value`() {
+        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))
+            .explode().ungroup("c")
+        exploded shouldBe dataFrameOf("a", "b", "x", "y", "d")(
+            1, 2, 4, 5, 8,
+            1, 3, 6, 7, null
+        )
+    }
+
+    @Test
+    fun `explode nothing`() {
+        val df = dataFrameOf("a", "b")(1, 2)
+        df.explode() shouldBe df
+    }
+}
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
new file mode 100644
index 000000000..7a376daa0
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/flatten.kt
@@ -0,0 +1,77 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.junit.Test
+
+class FlattenTests {
+
+    @Test
+    fun `flatten names`() {
+        val df = dataFrameOf("a", "b", "c")(1, 2, 3)
+        val grouped = df.group("a", "b").into("d")
+        grouped.flatten() shouldBe df
+        grouped.add("a") { 0 }.flatten().columnNames() shouldBe listOf("a1", "b", "c", "a")
+    }
+
+    @DataSchema
+    interface TestRow {
+        val a: String
+        val b: String
+        val c: String
+    }
+
+    @DataSchema
+    interface Grouped {
+        val d: DataRow<TestRow>
+    }
+
+    @Test
+    fun `flatten access APIs`() {
+        val df = dataFrameOf("a", "b", "c")(1, 2, 3)
+        val grouped = df.group("a", "b").into("d")
+
+        // String API
+        grouped.flatten("d") shouldBe df
+        val castedGroupedDF = grouped.cast<Grouped>()
+
+        // KProperties API
+        castedGroupedDF.flatten(Grouped::d) shouldBe df
+
+        // Extension properties API
+        castedGroupedDF.flatten { d } shouldBe df
+
+        // Column accessors API
+        val d by columnGroup()
+        val a by d.column<String>()
+        val b by d.column<String>()
+        val c by d.column<String>()
+        grouped.flatten(d) shouldBe df
+    }
+
+    @Test
+    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")
+
+        grouped.flatten() shouldBe df
+        val flattened = grouped.flatten { "f"["e"] }
+        flattened.columnNames() shouldBe listOf("f", "d")
+        flattened.ungroup("f") shouldBe df
+
+        grouped.flatten { "f"["e"] and "f" } shouldBe df
+    }
+
+    @Test
+    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")
+        val flattened = grouped.flatten { "f"["a"] }
+        flattened.getColumnGroup("f").columnNames() shouldBe listOf("a", "b", "c")
+        flattened.ungroup("f") shouldBe df
+    }
+}
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
new file mode 100644
index 000000000..4412e7aa4
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt
@@ -0,0 +1,185 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.intellij.lang.annotations.Language
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.codeGen.generateCode
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.io.readJsonStr
+import org.jetbrains.kotlinx.dataframe.kind
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class GatherTests {
+
+    //region Data Source
+
+    @Language("json")
+    val df = """
+            [
+                {
+                    "name": "abc",
+                    "normal": {
+                        "c1": "a",
+                        "c2": "b",
+                        "c3": "c"
+                    },
+                    "reversed": {
+                        "c1": "c",
+                        "c2": "b",
+                        "c3": "a"
+                    },
+                    "first": {
+                        "c1": "c"
+                    }
+                },
+                {
+                    "name": "qw",
+                    "normal": {
+                        "c1": "q",
+                        "c2": "w"
+                    },
+                    "reversed": {
+                        "c1": "w",
+                        "c2": "q"
+                    },
+                    "first": {
+                        "c1": "q"
+                    }
+                }
+            ]
+        """.let {
+        DataFrame.readJsonStr(it)
+    }
+
+    //endregion
+
+    val generatedCode = df.generateCode("Marker")
+
+    //region Generated code
+
+    @DataSchema(isOpen = false)
+    interface Marker1 {
+        val c1: String
+        val c2: String
+        val c3: String?
+    }
+
+    @DataSchema(isOpen = false)
+    interface Marker2 {
+        val c1: String
+        val c2: String
+        val c3: String?
+    }
+
+    @DataSchema(isOpen = false)
+    interface Marker3 {
+        val c1: String
+    }
+
+    @DataSchema
+    interface Marker {
+        val name: String
+        val normal: DataRow<Marker1>
+        val reversed: DataRow<Marker2>
+        val first: DataRow<Marker3>
+    }
+
+    //endregion
+
+    val typed = df.cast<Marker>()
+
+    @Test
+    fun gather() {
+        val mode by column<String>()
+        val temp by column<String>()
+        val gathered = typed.gather { except(name) }.cast<String>().into(mode, temp).ungroup(temp)
+
+        val expected = typed.groupBy { name }.updateGroups {
+            val cols = columns().drop(1).map { it.asColumnGroup() } // drop 'name' column
+            val dataRows = cols.map { it[0] }
+
+            val newDf = listOf(
+                name.withValues(List(cols.size) { name[0] }),
+                mode.withValues(cols.map { it.name() }),
+                dataRows.map { it.getValueOrNull<String>("c1") }.toColumn("c1"),
+                dataRows.map { it.getValueOrNull<String>("c2") }.toColumn("c2"),
+                dataRows.map { it.getValueOrNull<String>("c3") }.toColumn("c3")
+            ).toDataFrame()
+
+            newDf
+        }.concat()
+
+        gathered shouldBe expected
+    }
+
+    @Test
+    fun `generated code is fully typed`() {
+        generatedCode.contains("<*>") shouldBe false
+    }
+
+    @Test
+    fun `gather column group`() {
+        val java by columnOf(1, 2, 3)
+        val kotlin by columnOf(1, 2, 3)
+        val languages by column<DataRow<Unit>>()
+
+        val df = dataFrameOf(java, kotlin).group { java and kotlin }.into("languages")
+
+        fun AnyFrame.check() {
+            this["value"].kind shouldBe ColumnKind.Group
+            columnsCount() shouldBe 2
+            rowsCount() shouldBe 3
+        }
+
+        df.gather { languages }.into("key", "value").check()
+    }
+
+    @Test
+    fun `gather mix of columns`() {
+        val a by columnOf(1, 1.1)
+        val b by columnOf(2, 2.2)
+
+        val df = dataFrameOf(a, b)[0..0]
+
+        val gathered = df.gather { a and b }
+            .into("key", "value")
+
+        gathered["value"].type() shouldBe typeOf<Int>()
+    }
+
+    @Test
+    fun `gather values`() {
+        val a by columnOf(1, 2)
+        val b by columnOf(3, 4)
+
+        var df = dataFrameOf(a, b).gather { a and b }.valuesInto("data")
+        df.columnsCount() shouldBe 1
+        df["data"].values() shouldBe listOf(1, 3, 2, 4)
+
+        df = dataFrameOf(a, b).gather { a and b }.where { it % 2 == 1 }.valuesInto("data")
+        df.columnsCount() shouldBe 1
+        df["data"].values() shouldBe listOf(1, 3)
+    }
+
+    @Test
+    fun `gather explode lists`() {
+        val a by columnOf(1, 2)
+        val b by columnOf(listOf(3, 4), listOf(5, 6))
+
+        val df = dataFrameOf(a, b).gather { a and b }
+            .explodeLists()
+            .cast<Int>()
+            .where { it % 2 == 1 }
+            .into("key", "value")
+
+        df shouldBe dataFrameOf("key", "value")(
+            "a", 1,
+            "b", 3,
+            "b", 5
+        )
+    }
+}
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
new file mode 100644
index 000000000..04a3fdf84
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/get.kt
@@ -0,0 +1,92 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.assertions.throwables.shouldThrowAny
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.string.shouldContain
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.junit.Test
+import java.lang.ClassCastException
+import java.lang.IllegalArgumentException
+
+class GetTests {
+
+    @Test
+    fun `exceptions from empty dataframe`() {
+        val empty = DataFrame.empty()
+        shouldThrow<NoSuchElementException> {
+            empty.first()
+        }
+        shouldThrow<NoSuchElementException> {
+            empty.last()
+        }
+        shouldThrow<IndexOutOfBoundsException> {
+            empty[0]
+        }
+    }
+
+    @Test
+    fun `get value from row`() {
+        val a by column<Int>()
+        val c by column<Int>()
+        data class A(val a: Int, val b: Int, val c: Int)
+
+        val df = dataFrameOf("a", "b")(1, 2)
+        val row = df[0]
+
+        row["a"] shouldBe 1
+        row.getValue<Int>("a") shouldBe 1
+        row.getValue(a) shouldBe 1
+        row.getValue(A::a) shouldBe 1
+
+        row.getValueOrNull<Int>("c") shouldBe null
+        row.getValueOrNull(c) shouldBe null
+        row.getValueOrNull(A::c) shouldBe null
+
+        shouldThrow<IllegalArgumentException> { row.getValue<Int>("c") }
+        shouldThrow<IllegalArgumentException> { row.getValue(c) }
+        shouldThrow<IllegalArgumentException> { row.getValue(A::c) }
+
+        val added = df.add(A::c) { "3" }[0]
+
+        shouldThrow<ClassCastException> { added.getValue(c) + 1 }
+        shouldThrow<ClassCastException> { added.getValue<Int>("c") + 1 }
+        shouldThrow<ClassCastException> { added.getValue(A::c) + 1 }
+    }
+
+    @DataSchema
+    data class Schema(val a: Int)
+
+    @Test
+    fun `create typed frame column accessor`() {
+        val df = dataFrameOf(
+            columnOf(
+                dataFrameOf("a")(1),
+                dataFrameOf("a", "b")(2, 3, 4, 5)
+            ).named("x")
+        )
+        val x by frameColumn<Schema>()
+        df[x][0].a[0] shouldBe 1
+        df[1][x].a[1] shouldBe 4
+    }
+
+    @Test
+    fun `create typed column group accessor`() {
+        val df = dataFrameOf(
+            dataFrameOf("a", "b")(1, 2, 3, 4).asColumnGroup("x")
+        )
+        val x by columnGroup<Schema>()
+        df[x][0].a shouldBe 1
+        df[1][x].a shouldBe 3
+    }
+
+    @Test
+    fun `throw meaningful exception when traverse columns in DataRow`() {
+        val df = dataFrameOf("a")(null)
+        val throwable = shouldThrowAny {
+            df[0].getColumnGroup("a")
+        }
+        throwable.message shouldContain "Cannot cast null value of a ValueColumn to"
+    }
+}
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
new file mode 100644
index 000000000..4f7e78748
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
@@ -0,0 +1,58 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class GroupByTests {
+
+    @Test
+    fun `groupBy values with nulls`() {
+        val df = dataFrameOf(
+            "a", "b"
+        )(
+            1, 1,
+            1, null,
+            2, null,
+            3, 1,
+        )
+
+        df.groupBy("a").values { "b" into "c" } shouldBe
+            dataFrameOf(
+                "a", "c"
+            )(
+                1, listOf(1, null),
+                2, listOf(null),
+                3, listOf(1),
+            )
+
+        df.groupBy("a").values(dropNA = true) { "b" into "c" } shouldBe
+            dataFrameOf(
+                "a", "c"
+            )(
+                1, listOf(1),
+                2, emptyList<Int>(),
+                3, listOf(1),
+            )
+    }
+
+    @Test
+    fun `aggregate FrameColumns into new column`() {
+        val df = dataFrameOf(
+            "a", "b", "c"
+        )(
+            1, 2, 3,
+            4, 5, 6,
+        )
+        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 {
+            getFrameColumn("d") into "e"
+        }["e"].type() shouldBe typeOf<List<AnyFrame>>()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/implode.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/implode.kt
new file mode 100644
index 000000000..c9ff8e689
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/implode.kt
@@ -0,0 +1,21 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class ImplodeTests {
+
+    @Test
+    fun `implode into`() {
+        val df = dataFrameOf("a" to listOf(1, 1), "b" to listOf(2, 3))
+        val imploded = df.implode { "b" into "c" }
+        val expected = dataFrameOf("a" to listOf(1), "c" to listOf(listOf(2, 3)))
+        imploded shouldBe expected
+    }
+
+    @Test
+    fun `implode all`() {
+        val df = dataFrameOf("a" to listOf(1, 1), "b" to listOf(2, 3))
+        df.implode() shouldBe df.implode { all() }[0]
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt
new file mode 100644
index 000000000..562cc3c95
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt
@@ -0,0 +1,31 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class InferTypeTests {
+
+    @Test
+    fun `infer type 1`() {
+        val col by columnOf("Alice", 1, 3.5)
+        col.type() shouldBe typeOf<Comparable<*>>()
+        val filtered = col.filter { it is String }
+        filtered.type() shouldBe typeOf<Comparable<*>>()
+        filtered.inferType().type() shouldBe typeOf<String>()
+    }
+
+    open class A<T>(val value: T)
+    class B<T>(value: T) : A<T>(value)
+
+    @Test
+    fun `infer type with argument`() {
+        val col by columnOf(1)
+        val df = dataFrameOf(col)
+        val converted = df.convert(col).with(Infer.None) {
+            B(it) as A<Int>
+        }
+        converted[col].type() shouldBe typeOf<A<Int>>()
+        converted.inferType(col)[col].type() shouldBe typeOf<B<Int>>()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt
new file mode 100644
index 000000000..ef8c1efac
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt
@@ -0,0 +1,33 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.nulls.shouldNotBeNull
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.junit.Ignore
+import org.junit.Test
+
+class JoinTests {
+
+    @Ignore
+    @Test
+    fun `left join frame column`() {
+        val df1 = dataFrameOf("a")(1, 2)
+        val df2 = dataFrameOf("a", "b")(
+            1, dataFrameOf("c")(3),
+            4, dataFrameOf("c")(5)
+        )
+        val df = df1.leftJoin(df2)
+
+        df.rowsCount() shouldBe 2
+        df.columnNames() shouldBe listOf("a", "b")
+        df["a"] shouldBe df1["a"]
+        val b = df["b"]
+        b.kind() shouldBe ColumnKind.Frame
+        b.hasNulls() shouldBe false
+        val f = b.asAnyFrameColumn()
+        f[0] shouldBe df2["b"][0]
+        f[1].shouldNotBeNull()
+        f[1].isEmpty() shouldBe true
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/map.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/map.kt
new file mode 100644
index 000000000..4f9046b46
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/map.kt
@@ -0,0 +1,21 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class MapTests {
+
+    @Test
+    fun `map frame column with empty frames`() {
+        val frames by columnOf(dataFrameOf("a")(1), emptyDataFrame())
+        frames.map { it.firstOrNull() }.size() shouldBe frames.size()
+    }
+
+    @Test
+    fun `map ColumnsContainer`() {
+        val df = dataFrameOf("a")(1, 2).add {
+            expr { "a"<Int>() + 1 }.cumSum() into "b"
+        }
+        df["b"][1] shouldBe 5
+    }
+}
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
new file mode 100644
index 000000000..b6b37bc99
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt
@@ -0,0 +1,86 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldNotThrowAny
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
+import org.junit.Test
+
+class MoveTests {
+
+    val columnNames = listOf("q", "a.b", "b.c", "w", "a.c.d", "e.f", "b.d", "r")
+    val columns = columnNames.map { emptyList<Int>().toColumn(it) }
+    val df = columns.toDataFrame()
+    val grouped = df.move { cols { it.name.contains(".") } }.into { it.name.split(".").toPath() }
+
+    @Test
+    fun batchGrouping() {
+        grouped.columnNames() shouldBe listOf("q", "a", "b", "w", "e", "r")
+        grouped["a"].asColumnGroup().columnNames() shouldBe listOf("b", "c")
+        grouped["a"]["c"].asColumnGroup().columnNames() shouldBe listOf("d")
+        grouped["b"].asColumnGroup().columnNames() shouldBe listOf("c", "d")
+        grouped["e"].asColumnGroup().columnNames() shouldBe listOf("f")
+    }
+
+    @Test
+    fun `select all`() {
+        grouped.getColumnsWithPaths { all() }.map { it.path.joinToString(".") } shouldBe grouped.columnNames()
+    }
+
+    @Test
+    fun `select all dfs`() {
+        val selected = grouped.getColumnsWithPaths { all().allDfs() }.map { it.path.joinToString(".") }
+        selected shouldBe listOf("a.b", "a.c.d", "b.c", "b.d", "e.f")
+    }
+
+    @Test
+    fun batchUngrouping() {
+        val ungrouped = grouped.move { dfs { 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")
+    }
+
+    @Test
+    fun `ungroup one`() {
+        val ungrouped = grouped.remove("b").ungroup { it["a"] }
+        ungrouped.columnNames() shouldBe listOf("q", "b", "c", "w", "e", "r")
+        ungrouped["c"].asColumnGroup().columnNames() shouldBe listOf("d")
+    }
+
+    @Test
+    fun `flatten one`() {
+        val flattened = grouped.flatten { it["a"] }
+        flattened.columnNames() shouldBe listOf("q", "b1", "d", "b", "w", "e", "r")
+    }
+
+    @Test
+    fun `flatten several`() {
+        val flattened = grouped.flatten { it["a"]["c"] and it["a"] and it["b"] }
+        flattened.columnNames() shouldBe listOf("q", "b", "d", "c", "d1", "w", "e", "r")
+    }
+
+    @Test
+    fun `flatten all`() {
+        val flattened = grouped.flatten()
+        flattened.columnNames() shouldBe listOf("q", "b", "d", "c", "d1", "w", "f", "r")
+    }
+
+    @Test
+    fun `selectDfs`() {
+        val selected = grouped.select { it["a"].dfs { !it.isColumnGroup() } }
+        selected.columnNames() shouldBe listOf("b", "d")
+    }
+
+    @Test
+    fun `columnsWithPath in selector`() {
+        val selected = grouped.getColumnsWithPaths { it["a"] }
+        val actual = grouped.getColumnsWithPaths { selected.map { it.allDfs() }.toColumnSet() }
+        actual.map { it.path.joinToString(".") } shouldBe listOf("a.b", "a.c.d")
+    }
+
+    @Test
+    fun `move after last`() {
+        val df = dataFrameOf("1", "2")(1, 2)
+        shouldNotThrowAny {
+            df.move("1").after("2") shouldBe dataFrameOf("2", "1")(2, 1)
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/parse.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/parse.kt
new file mode 100644
index 000000000..e1fbcd607
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/parse.kt
@@ -0,0 +1,148 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import kotlinx.datetime.Instant
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.type
+import org.junit.Test
+import java.time.LocalTime
+import java.time.Month
+import java.util.Locale
+import kotlin.reflect.typeOf
+import kotlin.time.Duration.Companion.days
+import kotlin.time.Duration.Companion.hours
+import kotlin.time.Duration.Companion.minutes
+import kotlin.time.Duration.Companion.seconds
+
+class ParseTests {
+    @Test
+    fun parseDate() {
+        val currentLocale = Locale.getDefault()
+        try {
+            Locale.setDefault(Locale.forLanguageTag("en-US"))
+            val date by columnOf("January 1, 2020")
+            val pattern = "MMMM d, yyyy"
+
+            val parsed = date.parse(ParserOptions(dateTimePattern = pattern)).cast<LocalDate>()
+
+            parsed.type() shouldBe typeOf<LocalDate>()
+            with(parsed[0]) {
+                month shouldBe Month.JANUARY
+                dayOfMonth shouldBe 1
+                year shouldBe 2020
+            }
+
+            date.convertToLocalDate(pattern) shouldBe parsed
+            with(date.toDataFrame()) {
+                convert { date }.toLocalDate(pattern)[date] shouldBe parsed
+                parse(ParserOptions(dateTimePattern = pattern))[date] shouldBe parsed
+            }
+
+            DataFrame.parser.addDateTimePattern(pattern)
+
+            date.parse() shouldBe parsed
+            date.convertToLocalDate() shouldBe parsed
+
+            DataFrame.parser.resetToDefault()
+        } finally {
+            Locale.setDefault(currentLocale)
+        }
+    }
+
+    @Test
+    fun parseDateTime() {
+        val currentLocale = Locale.getDefault()
+        try {
+            Locale.setDefault(Locale.forLanguageTag("en-US"))
+            val dateTime by columnOf("3 Jun 2008 13:05:30")
+            val pattern = "d MMM yyyy HH:mm:ss"
+            val locale = Locale.forLanguageTag("en-US")
+
+            val parsed = dateTime.parse(ParserOptions(dateTimePattern = pattern, locale = locale)).cast<LocalDateTime>()
+
+            parsed.type() shouldBe typeOf<LocalDateTime>()
+            with(parsed[0]) {
+                month shouldBe Month.JUNE
+                dayOfMonth shouldBe 3
+                year shouldBe 2008
+                hour shouldBe 13
+                minute shouldBe 5
+                second shouldBe 30
+            }
+
+            dateTime.convertToLocalDateTime(pattern, locale) shouldBe parsed
+            with(dateTime.toDataFrame()) {
+                convert { dateTime }.toLocalDateTime(pattern)[dateTime] shouldBe parsed
+                parse(ParserOptions(dateTimePattern = pattern))[dateTime] shouldBe parsed
+            }
+
+            DataFrame.parser.addDateTimePattern(pattern)
+
+            dateTime.parse(ParserOptions(locale = locale)) shouldBe parsed
+            dateTime.convertToLocalDateTime(pattern, locale) shouldBe parsed
+
+            DataFrame.parser.resetToDefault()
+        } finally {
+            Locale.setDefault(currentLocale)
+        }
+    }
+
+    @Test
+    fun parseTime() {
+        val time by columnOf(" 13-05-30")
+        val pattern = "HH-mm-ss"
+
+        val parsed = time.parse(ParserOptions(dateTimePattern = pattern)).cast<LocalTime>()
+
+        parsed.type() shouldBe typeOf<LocalTime>()
+        with(parsed[0]) {
+            hour shouldBe 13
+            minute shouldBe 5
+            second shouldBe 30
+        }
+        time.convertToLocalTime(pattern) shouldBe parsed
+        with(time.toDataFrame()) {
+            convert { time }.toLocalTime(pattern)[time] shouldBe parsed
+            parse(ParserOptions(dateTimePattern = pattern))[time] shouldBe parsed
+        }
+
+        DataFrame.parser.addDateTimePattern(pattern)
+
+        time.parse() shouldBe parsed
+        time.convertToLocalTime() shouldBe parsed
+
+        DataFrame.parser.resetToDefault()
+    }
+
+    @Test
+    fun `parse date without formatter`() {
+        val time by columnOf(" 2020-01-06", "2020-01-07 ")
+        val df = dataFrameOf(time)
+        val casted = df.convert(time).toLocalDate()
+        casted[time].type() shouldBe typeOf<LocalDate>()
+    }
+
+    @Test
+    fun `parse column group`() {
+        val df = dataFrameOf("a", "b")("1", "2")
+        df
+            .group("a", "b").into("c")
+            .parse("c")
+            .ungroup("c") shouldBe dataFrameOf("a", "b")(1, 2)
+    }
+
+    @Test
+    fun `parse instant`() {
+        columnOf("2022-01-23T04:29:40Z").parse().type shouldBe typeOf<Instant>()
+        columnOf("2022-01-23T04:29:40+01:00").parse().type shouldBe typeOf<Instant>()
+
+        columnOf("2022-01-23T04:29:40").parse().type shouldBe typeOf<LocalDateTime>()
+    }
+
+    @Test
+    fun `parse duration`() {
+        columnOf("1d 15m", "20h 35m 11s").parse() shouldBe columnOf(1.days + 15.minutes, 20.hours + 35.minutes + 11.seconds)
+    }
+}
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
new file mode 100644
index 000000000..727165729
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt
@@ -0,0 +1,156 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class PivotTests {
+
+    val a by columnOf(0, 1, 1)
+    val b by columnOf("q", "q", "w")
+    val c by columnOf('x', 'y', 'z')
+
+    val df = dataFrameOf(a, b, c)
+
+    @Test
+    fun `simple pivot`() {
+        val pivoted = df.pivot(b, inward = false).groupBy(a).values(c)
+        pivoted.columnNames() shouldBe listOf("a", "q", "w")
+        pivoted.rowsCount() shouldBe 2
+        pivoted["q"].values() shouldBe listOf('x', 'y')
+        pivoted["w"].values() shouldBe listOf(null, 'z')
+    }
+
+    @Test
+    fun `pivot with rename`() {
+        val pivoted = df.pivot(b).groupBy(a).values { c default '?' into "d" and (c into "e") }
+        pivoted.columnNames() shouldBe listOf("a", "b")
+        pivoted.rowsCount() shouldBe 2
+
+        pivoted["b"]["q"]["d"].values() shouldBe listOf('x', 'y')
+        pivoted["b"]["q"]["e"].values() shouldBe listOf('x', 'y')
+        pivoted["b"]["w"]["d"].values() shouldBe listOf('?', 'z')
+        pivoted["b"]["w"]["e"].values() shouldBe listOf(null, 'z')
+    }
+
+    @Test
+    fun `pivot aggregate with default`() {
+        val pivoted = df.pivot(b, inward = false).groupBy(a).aggregate {
+            get(c).first() default '-' into "first"
+            get(c).last() into "last" default '?'
+        }
+        pivoted.columnsCount() shouldBe 3
+        pivoted.rowsCount() shouldBe 2
+        val cols = pivoted.getColumns { except(a).allDfs() }
+        cols.size shouldBe 4
+        cols.forEach {
+            it.type() shouldBe typeOf<Char>()
+        }
+        pivoted["w"]["first"][0] shouldBe '-'
+        pivoted["w"]["last"][0] shouldBe '?'
+    }
+
+    @Test
+    fun `pivot groupBy inward by default`() {
+        val df = dataFrameOf(
+            "a", "b",
+        )(
+            2, "a",
+            4, "b",
+            3, "c",
+        )
+        val pivoted = df.pivot("b").groupBy("a").matches()
+        pivoted.columnNames() shouldBe listOf("a", "b")
+        pivoted.getColumnGroup("b").columnNames() shouldBe listOf("a", "b", "c")
+    }
+
+    @Test
+    fun `pivot values with nulls`() {
+        val df = dataFrameOf("a" to listOf(1, 2, 2, 3), "b" to listOf(1, 1, null, null))
+
+        df.pivot("a").values("b") shouldBe
+            dataFrameOf("1", "2", "3")(1, listOf(1, null), null)[0]
+
+        df.pivot("a").values("b", dropNA = true) shouldBe
+            dataFrameOf("1" to listOf(1), "2" to listOf(1), "3" to listOf<Int?>(null))[0]
+    }
+
+    @Test
+    fun `pivot in aggregate`() {
+        val df = dataFrameOf("a" to listOf(1, 2, 2), "b" to listOf("q", "w", "q"))
+
+        val expected = dataFrameOf("a", "q", "w")(
+            1, 1, 0,
+            2, 1, 1
+        ).group("q", "w").into("b")
+
+        df.groupBy("a").aggregate {
+            pivot("b").count()
+        } shouldBe expected
+
+        df.groupBy("a").aggregate {
+            pivot("b").count() into "c"
+        } shouldBe expected.rename("b" to "c")
+    }
+
+    @Test
+    fun `pivot two in aggregate`() {
+        val df = dataFrameOf(
+            "a" to listOf(1, 2, 2),
+            "b" to listOf("q", "w", "q"),
+            "c" to listOf("w", "q", "w"),
+        )
+
+        val expected = dataFrameOf(
+            columnOf(1, 2) named "a",
+            columnOf(
+                columnOf(
+                    columnOf(1, 1) named "q",
+                    columnOf(0, 1) named "w"
+                ) named "b",
+                columnOf(
+                    columnOf(1, 1) named "w",
+                    columnOf(0, 1) named "q"
+                ) named "c",
+            ) named "d"
+        )
+
+        df.groupBy("a").aggregate {
+            pivot("b", "c").count() into "d"
+        } shouldBe expected
+    }
+
+    @Test
+    fun `pivot minBy values`() {
+        val df = dataFrameOf("a", "b", "c", "d")(
+            1, 2, 3, 5,
+            1, 0, 2, 4,
+            2, 1, 3, 2,
+            2, 5, 5, 3
+        )
+        df.pivot("a").minBy("b").values("c", "d", separate = true) shouldBe
+            dataFrameOf("c1", "c2", "d1", "d2")(
+                2, 3, 4, 2
+            ).move { all() }.into { pathOf(it.name()[0].toString(), it.name()[1].toString()) }[0]
+    }
+
+    @Test
+    fun `pivot groupBy last with`() {
+        val df = dataFrameOf("a", "b", "c")(
+            1, 2, 3,
+            1, 0, 2,
+            2, 1, 3,
+            2, 1, 5
+        )
+        df.pivot("a", inward = false)
+            .groupBy("b")
+            .default(-1)
+            .last()
+            .with { "c"<Int>() } shouldBe
+            dataFrameOf("b", "1", "2")(
+                2, 3, -1,
+                0, 2, -1,
+                1, -1, 5
+            )
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt
new file mode 100644
index 000000000..6faeac999
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt
@@ -0,0 +1,35 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.impl.api.removeImpl
+import org.junit.Test
+
+class RemoveTests {
+
+    val df = dataFrameOf("a", "b")(1, 2)
+    val b by column<Int>()
+    data class C(val b: Int)
+
+    @Test
+    fun `simple remove`() {
+        val e = df.select("a")
+        df.remove("b") shouldBe e
+        df.remove { b } shouldBe e
+        df.remove(C::b) shouldBe e
+    }
+
+    @Test
+    fun `remove renamed`() {
+        val (_, removed) = df.removeImpl { "a" named "c" }
+        removed[0].data.column!!.name shouldBe "c"
+    }
+
+    @Test
+    fun `remove missing column`() {
+        val d = df.remove { b }
+
+        d.remove("b") shouldBe d
+        d.remove { b } shouldBe d
+        d.remove(C::b) shouldBe d
+    }
+}
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
new file mode 100644
index 000000000..46890a1e2
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt
@@ -0,0 +1,58 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.asClue
+import io.kotest.assertions.throwables.shouldNotThrowAny
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.junit.Test
+
+class RenameTests {
+    companion object {
+        val nestedDf = dataFrameOf("test_name")(dataFrameOf("another_name")(1))
+        val nestedColumnGroup = dataFrameOf("test_name")(
+            dataFrameOf("another_name")(1).first()
+        )
+        val deeplyNestedDf = kotlin.run {
+            val df = dataFrameOf("another_name")(1)
+            val rowWithDf = dataFrameOf("group_name")(df).first()
+            dataFrameOf("test_name")(rowWithDf)
+        }
+        val deeplyNestedFrameColumn = kotlin.run {
+            val df = dataFrameOf("col_0")(1)
+            val df1 = dataFrameOf("col_1")(df)
+            dataFrameOf("col_2")(df1)
+        }
+    }
+
+    @Test
+    fun `nested df`() {
+        nestedDf.renameToCamelCase() shouldBe dataFrameOf("testName")(dataFrameOf("anotherName")(1))
+    }
+
+    @Test
+    fun `nested row`() {
+        val df = nestedColumnGroup.renameToCamelCase()
+        df.columnNames() shouldBe listOf("testName")
+        df.getColumnGroup("testName").columnNames() shouldBe listOf("anotherName")
+    }
+
+    @Test
+    fun `deeply nested df`() {
+        val df = deeplyNestedDf.renameToCamelCase()
+        df.schema().asClue {
+            df.columnNames() shouldBe listOf("testName")
+            df.getColumnGroup("testName").columnNames() shouldBe listOf("groupName")
+            df["testName"]["groupName"].asAnyFrameColumn()[0].columnNames() shouldBe listOf("anotherName")
+        }
+    }
+
+    @Test
+    fun `deeply nested frame column`() {
+        val df = deeplyNestedFrameColumn.renameToCamelCase()
+        df.schema().asClue {
+            shouldNotThrowAny {
+                df["col2"].asAnyFrameColumn().firstOrNull()!!["col1"].asAnyFrameColumn().firstOrNull()!!["col0"]
+            }
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
new file mode 100644
index 000000000..87e28271c
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt
@@ -0,0 +1,31 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class ReorderTests {
+
+    @Test
+    fun simple() {
+        val df = dataFrameOf("b", "c", "a").fill(1, 0)
+        df.reorder { all() }.byName().columnNames() shouldBe listOf("a", "b", "c")
+        df.reorder { "a" and "c" }.byName().columnNames() shouldBe listOf("b", "a", "c")
+        df.reorder { "a" and "b" }.byName().columnNames() shouldBe listOf("a", "c", "b")
+    }
+
+    @Test
+    fun nested() {
+        val df = dataFrameOf("b", "c", "a").fill(1, 0)
+            .group("c", "a").into("a")
+
+        df.reorder { all() }.byName().columnNames() shouldBe listOf("a", "b")
+
+        val sorted1 = df.reorder { "a".all() }.byName()
+        sorted1.columnNames() shouldBe listOf("b", "a")
+        sorted1["a"].asColumnGroup().columnNames() shouldBe listOf("a", "c")
+
+        val sorted2 = df.reorder { allDfs(true) }.byName()
+        sorted2.columnNames() shouldBe listOf("a", "b")
+        sorted2["a"].asColumnGroup().columnNames() shouldBe listOf("a", "c")
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt
new file mode 100644
index 000000000..5df15bf10
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/replace.kt
@@ -0,0 +1,16 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class ReplaceTests {
+
+    @Test
+    fun `replace named`() {
+        val df = dataFrameOf("a")(1)
+        val conv = df.replace { "a"<Int>() named "b" }.with { it.convertToDouble() }
+        conv.columnNames() shouldBe listOf("b")
+        conv.columnTypes() shouldBe listOf(typeOf<Double>())
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reverse.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reverse.kt
new file mode 100644
index 000000000..39f351db9
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/reverse.kt
@@ -0,0 +1,27 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class ReverseTests {
+
+    @Test
+    fun dataframe() {
+        val df = dataFrameOf("a", "b")(1, 2, 3, 4)
+        df.reverse() shouldBe dataFrameOf("a", "b")(3, 4, 1, 2)
+    }
+
+    @Test
+    fun column() {
+        val col by columnOf(1, 2, 3)
+        col.reverse() shouldBe col.withValues(listOf(3, 2, 1))
+    }
+
+    @Test
+    fun columnGroup() {
+        val a by columnOf(1, 2)
+        val b by columnOf(3, 4)
+        val col by columnOf(a, b)
+        col.reverse() shouldBe columnOf(a.reverse(), b.reverse()).named("col")
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/sortGroupedDataframe.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/sortGroupedDataframe.kt
new file mode 100644
index 000000000..76d7b07ed
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/sortGroupedDataframe.kt
@@ -0,0 +1,72 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.alsoDebug
+import org.jetbrains.kotlinx.dataframe.io.read
+import org.junit.Test
+
+class SortGroupedDataframeTests {
+
+    @Test
+    fun `Sorted grouped iris dataset`() {
+        val irisData = DataFrame.read("src/test/resources/irisDataset.csv")
+        irisData.alsoDebug()
+
+        irisData.groupBy("variety").let {
+            it.sortBy("petal.length").toString() shouldBe
+                it.sortBy { it["petal.length"] }.toString()
+        }
+    }
+
+    enum class State {
+        Idle, Productive, Maintenance
+    }
+
+    @Test
+    fun test4() {
+        class Event(val toolId: String, val state: State, val timestamp: Long)
+
+        val tool1 = "tool_1"
+        val tool2 = "tool_2"
+        val tool3 = "tool_3"
+
+        val events = listOf(
+            Event(tool1, State.Idle, 0),
+            Event(tool1, State.Productive, 5),
+            Event(tool2, State.Idle, 0),
+            Event(tool2, State.Maintenance, 10),
+            Event(tool2, State.Idle, 20),
+            Event(tool3, State.Idle, 0),
+            Event(tool3, State.Productive, 25),
+        ).toDataFrame()
+
+        val lastTimestamp = events.maxOf { getValue<Long>("timestamp") }
+        val groupBy = events
+            .groupBy("toolId")
+            .sortBy("timestamp")
+            .add("stateDuration") {
+                (next()?.getValue("timestamp") ?: lastTimestamp) - getValue<Long>("timestamp")
+            }
+
+        groupBy.toDataFrame().alsoDebug()
+        groupBy.schema().print()
+        groupBy.keys.print()
+        groupBy.keys[0].print()
+
+        val df1 = groupBy.updateGroups {
+            val missingValues = State.values().asList().toDataFrame {
+                "state" from { it }
+            }
+
+            val df = it
+                .fullJoin(missingValues, "state")
+                .fillNulls("stateDuration")
+                .with { 100L }
+
+            df.groupBy("state").sumFor("stateDuration")
+        }
+
+        df1.toDataFrame().alsoDebug().isNotEmpty() shouldBe true
+    }
+}
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
new file mode 100644
index 000000000..717b64ef2
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/split.kt
@@ -0,0 +1,168 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.hasNulls
+import org.jetbrains.kotlinx.dataframe.impl.DataRowImpl
+import org.jetbrains.kotlinx.dataframe.type
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class SplitTests {
+
+    val stringPairDf = dataFrameOf("first", "second")("22-65", "22-66")
+    val listPairDf = dataFrameOf("first", "second")(listOf("22", "65"), listOf("22", "66"))
+
+    @Test
+    fun `split with default`() {
+        val recentDelays = listOf(listOf(23, 47), listOf(), listOf(24, 43, 87), listOf(13), listOf(67, 32)).toColumn("RecentDelays")
+        val df = dataFrameOf(recentDelays)
+        val split = df.split(recentDelays).default(0).into { "delay$it" }
+        split.columns().forEach {
+            it.hasNulls() shouldBe false
+        }
+        split.values().count { it == 0 } shouldBe 7
+    }
+
+    @Test
+    fun `split with regex`() {
+        val title by columnOf(
+            "Toy Story (1995)",
+            "Jumanji (1995)",
+            "Grumpier Old Men (1995)",
+            "Waiting to Exhale (1995)"
+        )
+
+        val regex = """(.*) \((\d{4})\)""".toRegex()
+        val split = title.toDataFrame()
+            .split { title }
+            .match(regex)
+            .into("title", "year")
+            .parse()
+        split.schema().print()
+        split["title"].hasNulls shouldBe false
+        split["year"].type shouldBe typeOf<Int>()
+    }
+
+    @Test
+    fun `split into columns`() {
+        val df = dataFrameOf("a", "b", "c")(
+            1, 2, 3,
+            1, 4, 5,
+            2, 3, 4,
+            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()
+            .ungroup("g")
+        res shouldBe dataFrameOf("a", "b", "c")(
+            1, listOf(2, 4), listOf(3, 5),
+            2, emptyList<Int>(), emptyList<Int>(),
+            3, emptyList<Int>(), emptyList<Int>()
+        )
+    }
+
+    @Test
+    fun `split string by delimiter inward`() {
+        val res = stringPairDf.split("first", "second").by("-").inward("left", "right")
+
+        res shouldBe dataFrameOf(
+            columnOf(columnOf("22") named "left", columnOf("65") named "right") named "first",
+            columnOf(columnOf("22") named "left", columnOf("66") named "right") named "second"
+        )
+    }
+
+    @Test
+    fun `split string by delimiter into columns with suffixes`() {
+        val res = stringPairDf.split("first", "second").by("-").into("left", "right")
+
+        res shouldBe dataFrameOf(
+            columnOf("22") named "left",
+            columnOf("65") named "right",
+            columnOf("22") named "left1",
+            columnOf("66") named "right1"
+        )
+    }
+
+    @Test
+    fun `split list inward with autogenerated names`() {
+        val res = listPairDf.split { "first"<List<String>>() and "second"<List<String>>() }.inward()
+
+        res shouldBe dataFrameOf(
+            columnOf(columnOf("22") named "split1", columnOf("65") named "split2") named "first",
+            columnOf(columnOf("22") named "split1", columnOf("66") named "split2") named "second"
+        )
+    }
+
+    @Test
+    fun `split list into with autogenerated names`() {
+        val res = listPairDf.split { "first"<List<String>>() and "second"<List<String>>() }.into()
+
+        res shouldBe dataFrameOf(
+            columnOf("22") named "split1",
+            columnOf("65") named "split2",
+            columnOf("22") named "split3",
+            columnOf("66") named "split4"
+        )
+    }
+
+    @Test
+    fun `sequence of splits with autogenerated names`() {
+        var res = listPairDf.split { "first"<List<String>>() }.into()
+        res = res.split { "second"<List<String>>() }.into()
+
+        res shouldBe dataFrameOf(
+            columnOf("22") named "split1",
+            columnOf("65") named "split2",
+            columnOf("22") named "split3",
+            columnOf("66") named "split4"
+        )
+    }
+
+    @Test
+    fun `split column group inward`() {
+        val df = stringPairDf.group("first", "second").into("group")
+
+        // Note: this operation replaces original columns in group so there is no name conflict
+        val res = df.split { "group"<DataRowImpl<*>>() }
+            .by { it -> listOf(it[1], it[0]) } // swap columns
+            .inward("first", "second") // no name conflict
+
+        res shouldBe dataFrameOf(
+            columnOf(columnOf("22-66") named "first", columnOf("22-65") named "second") named "group"
+        )
+    }
+
+    @Test
+    fun `split column group into hierarchy with correct names`() {
+        val df = dataFrameOf(
+            columnOf(
+                columnOf("a") named "first",
+                columnOf(
+                    columnOf("b") named "first",
+                    columnOf("c") named "second"
+                ) named "nestedGroup"
+            ) named "topLevelGroup",
+            columnOf("d") named "first",
+        )
+
+        val topLevelGroup by columnGroup()
+        val nestedGroup by topLevelGroup.columnGroup()
+
+        val res = df.split { nestedGroup }
+            .by { it -> listOf(it[0], it[1]) }
+            .into("first", "second") // name conflict
+
+        res shouldBe dataFrameOf(
+            columnOf(
+                columnOf("a") named "first",
+                columnOf("b") named "first1",
+                columnOf("c") named "second"
+            ) named "topLevelGroup",
+            columnOf("d") named "first",
+        )
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
new file mode 100644
index 000000000..632355356
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
@@ -0,0 +1,200 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.kind
+import org.jetbrains.kotlinx.dataframe.type
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class CreateDataFrameTests {
+
+    @Test
+    fun `visibility test`() {
+        class Data {
+            private val a = 1
+            protected val b = 2
+            internal val c = 3
+            public val d = 4
+        }
+
+        listOf(Data()).toDataFrame() shouldBe dataFrameOf("d")(4)
+    }
+
+    @Test
+    fun `exception test`() {
+        class Data {
+            val a: Int get() = error("Error")
+            val b = 1
+        }
+
+        val df = listOf(Data()).toDataFrame()
+        df.columnsCount() shouldBe 2
+        df.rowsCount() shouldBe 1
+        df.columnTypes() shouldBe listOf(typeOf<IllegalStateException>(), typeOf<Int>())
+        (df["a"][0] is IllegalStateException) shouldBe true
+        df["b"][0] shouldBe 1
+    }
+
+    @Test
+    fun `create frame column`() {
+        val df = dataFrameOf("a")(1)
+        val res = listOf(1, 2).toDataFrame {
+            "a" from { it }
+            "b" from { df }
+            "c" from { df[0] }
+            "d" from { if (it == 1) it else null }
+            "e" from { if (true) it else null }
+        }
+        res["a"].kind shouldBe ColumnKind.Value
+        res["a"].type() shouldBe typeOf<Int>()
+        res["b"].kind shouldBe ColumnKind.Frame
+        res["c"].kind shouldBe ColumnKind.Group
+        res["d"].type() shouldBe typeOf<Int?>()
+        res["e"].type() shouldBe typeOf<Int>()
+    }
+
+    @Test
+    fun `preserve fields order`() {
+        class B(val x: Int, val c: String, d: Double) {
+            val b: Int = x
+            val a: Double = d
+        }
+
+        listOf(B(1, "a", 2.0)).toDataFrame().columnNames() shouldBe listOf("x", "c", "a", "b")
+    }
+
+    @DataSchema
+    data class A(val v: Int)
+
+    @DataSchema
+    data class B(val str: String, val frame: DataFrame<A>, val row: DataRow<A>, val list: List<A>, val a: A)
+
+    @Test
+    fun `preserve properties test`() {
+        val d1 = listOf(A(2), A(3)).toDataFrame()
+        val d2 = listOf(A(4), A(5)).toDataFrame()
+
+        val data = listOf(
+            B("q", d1, d1[0], emptyList(), A(7)),
+            B("w", d2, d2[1], listOf(A(6)), A(8))
+        )
+
+        val df = data.toDataFrame()
+
+        df.frame.kind shouldBe ColumnKind.Frame
+        df.row.kind() shouldBe ColumnKind.Group
+        df.list.kind shouldBe ColumnKind.Frame
+        df.a.kind() shouldBe ColumnKind.Group
+
+        df.str[1] shouldBe "w"
+        df.frame[0].v[1] shouldBe 3
+        df.row[1].v shouldBe 5
+        df.list[1].v[0] shouldBe 6
+        df.a[0].v shouldBe 7
+
+        val df2 = data.toDataFrame { preserve(B::row); properties { preserve(DataFrame::class) } }
+        df2.frame.kind shouldBe ColumnKind.Value
+        df2.frame.type shouldBe typeOf<DataFrame<A>>()
+        df2["row"].kind shouldBe ColumnKind.Value
+        df2["row"].type shouldBe typeOf<DataRow<A>>()
+        df2.list.kind shouldBe ColumnKind.Frame
+        df2.a.kind() shouldBe ColumnKind.Group
+    }
+
+    enum class DummyEnum { A }
+
+    @Test
+    fun `don't convert value types`() {
+        data class Entry(val a: Int, val b: String, val c: Boolean, val e: DummyEnum)
+
+        val df = listOf(Entry(1, "s", true, DummyEnum.A)).toDataFrame(maxDepth = 100)
+        df.columns().forEach {
+            it.kind shouldBe ColumnKind.Value
+        }
+    }
+
+    @Test
+    fun `convert type with no properties`() {
+        class Child
+        class Entry(val a: Int, val child: Child)
+
+        val df = listOf(Entry(1, Child())).toDataFrame(maxDepth = 100)
+        df.rowsCount() shouldBe 1
+
+        val childCol = df[Entry::child]
+        childCol.kind() shouldBe ColumnKind.Group
+        childCol.asColumnGroup().columnsCount() shouldBe 0
+    }
+
+    @Test
+    fun `convert child schemas`() {
+        class Child2(val s: String)
+
+        @DataSchema
+        class Child1(val child: Child2)
+
+        @DataSchema
+        class Entry(val a: Int, val child: Child1)
+
+        val df = listOf(Entry(1, Child1(Child2("s")))).toDataFrame()
+        df.rowsCount() shouldBe 1
+
+        val child1 = df[Entry::child]
+        child1.kind shouldBe ColumnKind.Group
+
+        val child2 = child1.asColumnGroup()[Child1::child]
+        child2.kind shouldBe ColumnKind.Value
+    }
+
+    @Test
+    fun inferredTypeForPropertyWithGenericIterableType() {
+        class Container<E>(val data: Set<E>)
+
+        val element = Container(setOf(1))
+        val value = listOf(element).toDataFrame(maxDepth = 10)
+
+        value["data"].type() shouldBe typeOf<List<Int>>()
+    }
+
+    @Test
+    fun inferredNullableTypeForPropertyWithGenericIterableType() {
+        class Container<E>(val data: List<E>)
+
+        val element = Container(listOf(1, null))
+        val value = listOf(element).toDataFrame(maxDepth = 10)
+
+        value["data"].type() shouldBe typeOf<List<Int?>>()
+    }
+
+    @Suppress("unused")
+    @Test
+    fun treatErasedGenericAsAny() {
+        class IncompatibleVersionErrorData<T>(val expected: T, val actual: T)
+        class DeserializedContainerSource(val incompatibility: IncompatibleVersionErrorData<*>)
+        val functions = listOf(DeserializedContainerSource(IncompatibleVersionErrorData(1, 2)))
+
+        val df = functions.toDataFrame(maxDepth = 2)
+
+        val col = df.getColumnGroup(DeserializedContainerSource::incompatibility)
+        col[IncompatibleVersionErrorData<*>::actual].type() shouldBe typeOf<Any>()
+        col[IncompatibleVersionErrorData<*>::expected].type() shouldBe typeOf<Any>()
+    }
+
+    interface Named {
+        val name: String get() = "default impl"
+    }
+
+    class Data(override val name: String) : Named
+
+    @Test
+    fun simpleInheritance() {
+        val name = "temp"
+        val df = listOf(Data(name)).toDataFrame(maxDepth = 1)
+
+        df["name"][0] shouldBe name
+    }
+}
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
new file mode 100644
index 000000000..3ed621e19
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/toList.kt
@@ -0,0 +1,28 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class DataClassesTests {
+
+    @Test
+    fun convertDataClasses() {
+        data class Record(val sex: String, val grade: Int, val count: Int)
+
+        data class PivotedRecord(val grade: Int, val male: Int, val female: Int)
+
+        listOf(
+            Record("male", 5, 10),
+            Record("male", 6, 15),
+            Record("female", 5, 20),
+            Record("female", 6, 15)
+        )
+            .toDataFrame()
+            .pivot(Record::sex, inward = false).groupBy(Record::grade).values(Record::count)
+            .toListOf<PivotedRecord>() shouldBe
+            listOf(
+                PivotedRecord(5, 10, 20),
+                PivotedRecord(6, 15, 15)
+            )
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
new file mode 100644
index 000000000..4818f0a2c
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt
@@ -0,0 +1,86 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.size
+import org.junit.Test
+
+class UpdateTests {
+
+    @Test
+    fun `update empty dataframe with missing column`() {
+        val df = DataFrame.Empty
+        val col by column<Int>()
+        df.update { col }.with { 2 } shouldBe df
+    }
+
+    @DataSchema
+    interface DataPart {
+        val a: Int
+        val b: String
+    }
+
+    @DataSchema
+    data class Data(
+        override val a: Int,
+        override val b: String,
+        val c: Boolean,
+    ) : DataPart
+
+    @Test
+    fun `update asFrame`() {
+        val df = listOf(
+            Data(1, "a", true),
+            Data(2, "b", false),
+        ).toDataFrame()
+
+        val group by columnGroup<DataPart>() named "Some Group"
+        val groupedDf = df.group { a and b }.into { group }
+
+        val res = groupedDf
+            .update { group }
+            .where { !c }
+            .asFrame {
+                // size should still be full df size
+                size.nrow shouldBe 2
+
+                // this will only apply to rows where `.where { !c }` holds
+                update { a }.with { 0 }
+            }
+
+        val (first, second) = res[{ group }].map { it.a }.toList()
+        first shouldBe 1
+        second shouldBe 0
+
+        res[{ group }].name() shouldBe "Some Group"
+    }
+
+    @DataSchema
+    interface SchemaA {
+        val i: Int?
+    }
+
+    @DataSchema
+    interface SchemaB {
+        val i: Int
+    }
+
+    @Test
+    fun `fillNulls update`() {
+        val df = dataFrameOf("i")(1, null)
+
+        df.fillNulls(SchemaA::i).with { 42 }
+
+        df.fillNulls(SchemaB::i).with { 42 }
+    }
+
+    @Test
+    fun `fillNA update`() {
+        val df = dataFrameOf("i")(1, null)
+
+        df.fillNA(SchemaA::i).with { 42 }
+
+        df.fillNA(SchemaB::i).with { 42 }
+    }
+}
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
new file mode 100644
index 000000000..70c09b5d8
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeGenerationTests.kt
@@ -0,0 +1,316 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.dataframe.impl.codeGen.CodeGenerator
+import org.jetbrains.dataframe.impl.codeGen.InterfaceGenerationMode
+import org.jetbrains.dataframe.impl.codeGen.ReplCodeGenerator
+import org.jetbrains.dataframe.impl.codeGen.generate
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.dropNulls
+import org.jetbrains.kotlinx.dataframe.api.move
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.api.under
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.ReplCodeGeneratorImpl
+import org.jetbrains.kotlinx.dataframe.testSets.person.BaseTest
+import org.jetbrains.kotlinx.dataframe.testSets.person.Person
+import org.junit.Test
+
+class CodeGenerationTests : BaseTest() {
+
+    val personClassName = Person::class.qualifiedName!!
+
+    val personShortName = Person::class.simpleName!!
+
+    val dfName = (ColumnsContainer::class).simpleName!!
+    val dfRowName = (DataRow::class).simpleName!!
+    val dataCol = (DataColumn::class).simpleName!!
+    val dataRow = (DataRow::class).simpleName!!
+    val colGroup = (ColumnGroup::class).simpleName!!
+    val stringName = String::class.simpleName!!
+    val intName = Int::class.simpleName!!
+
+    fun expectedProperties(fullTypeName: String, shortTypeName: String) = """
+            val $dfName<$fullTypeName>.age: $dataCol<$intName> @JvmName("${shortTypeName}_age") get() = this["age"] as $dataCol<$intName>
+            val $dfRowName<$fullTypeName>.age: $intName @JvmName("${shortTypeName}_age") get() = this["age"] as $intName
+            val $dfName<$fullTypeName?>.age: $dataCol<$intName?> @JvmName("Nullable${shortTypeName}_age") get() = this["age"] as $dataCol<$intName?>
+            val $dfRowName<$fullTypeName?>.age: $intName? @JvmName("Nullable${shortTypeName}_age") get() = this["age"] as $intName?
+            val $dfName<$fullTypeName>.city: $dataCol<$stringName?> @JvmName("${shortTypeName}_city") get() = this["city"] as $dataCol<$stringName?>
+            val $dfRowName<$fullTypeName>.city: $stringName? @JvmName("${shortTypeName}_city") get() = this["city"] as $stringName?
+            val $dfName<$fullTypeName?>.city: $dataCol<$stringName?> @JvmName("Nullable${shortTypeName}_city") get() = this["city"] as $dataCol<$stringName?>
+            val $dfRowName<$fullTypeName?>.city: $stringName? @JvmName("Nullable${shortTypeName}_city") get() = this["city"] as $stringName?
+            val $dfName<$fullTypeName>.name: $dataCol<$stringName> @JvmName("${shortTypeName}_name") get() = this["name"] as $dataCol<$stringName>
+            val $dfRowName<$fullTypeName>.name: $stringName @JvmName("${shortTypeName}_name") get() = this["name"] as $stringName
+            val $dfName<$fullTypeName?>.name: $dataCol<$stringName?> @JvmName("Nullable${shortTypeName}_name") get() = this["name"] as $dataCol<$stringName?>
+            val $dfRowName<$fullTypeName?>.name: $stringName? @JvmName("Nullable${shortTypeName}_name") get() = this["name"] as $stringName?
+            val $dfName<$fullTypeName>.weight: $dataCol<$intName?> @JvmName("${shortTypeName}_weight") get() = this["weight"] as $dataCol<$intName?>
+            val $dfRowName<$fullTypeName>.weight: $intName? @JvmName("${shortTypeName}_weight") get() = this["weight"] as $intName?
+            val $dfName<$fullTypeName?>.weight: $dataCol<$intName?> @JvmName("Nullable${shortTypeName}_weight") get() = this["weight"] as $dataCol<$intName?>
+            val $dfRowName<$fullTypeName?>.weight: $intName? @JvmName("Nullable${shortTypeName}_weight") get() = this["weight"] as $intName?
+    """.trimIndent()
+
+    @Test
+    fun `generate marker interface`() {
+        val codeGen = ReplCodeGenerator.create()
+        val generated = codeGen.process(df, ::df)
+        val typeName = ReplCodeGeneratorImpl.markerInterfacePrefix
+        val expectedDeclaration = """
+            @DataSchema
+            interface $typeName
+            
+        """.trimIndent() + "\n" + expectedProperties(typeName, typeName)
+
+        val expectedConverter = "it.cast<$typeName>()"
+
+        generated.declarations shouldBe expectedDeclaration
+        generated.converter("it") shouldBe expectedConverter
+
+        val rowGenerated = codeGen.process(df[0], ::typedRow)
+        rowGenerated.hasDeclarations shouldBe true
+        rowGenerated.hasConverter shouldBe true
+    }
+
+    val row: AnyRow? = null
+
+    val typedRow: DataRow<Person> = typed[0]
+
+    @Test
+    fun `generate marker interface for row`() {
+        val property = ::row
+        val generated = ReplCodeGenerator.create().process(df[0], property)
+        val typeName = ReplCodeGeneratorImpl.markerInterfacePrefix
+        val expectedDeclaration = """
+            @DataSchema
+            interface $typeName
+            
+        """.trimIndent() + "\n" + expectedProperties(typeName, typeName)
+
+        val expectedConverter = "it.cast<$typeName>()"
+
+        generated.declarations shouldBe expectedDeclaration
+        generated.converter("it") shouldBe expectedConverter
+    }
+
+    @Test
+    fun `generate marker interface for nested data frame`() {
+        val property = ::df
+        val grouped = df.move { name and city }.under("nameAndCity")
+        val generated = ReplCodeGenerator.create().process(grouped, property)
+        val type1 = ReplCodeGeneratorImpl.markerInterfacePrefix + "1"
+        val type2 = ReplCodeGeneratorImpl.markerInterfacePrefix
+        val declaration1 = """
+            @DataSchema(isOpen = false)
+            interface $type1
+            
+            val $dfName<$type1>.city: $dataCol<$stringName?> @JvmName("${type1}_city") get() = this["city"] as $dataCol<$stringName?>
+            val $dfRowName<$type1>.city: $stringName? @JvmName("${type1}_city") get() = this["city"] as $stringName?
+            val $dfName<$type1?>.city: $dataCol<$stringName?> @JvmName("Nullable${type1}_city") get() = this["city"] as $dataCol<$stringName?>
+            val $dfRowName<$type1?>.city: $stringName? @JvmName("Nullable${type1}_city") get() = this["city"] as $stringName?
+            val $dfName<$type1>.name: $dataCol<$stringName> @JvmName("${type1}_name") get() = this["name"] as $dataCol<$stringName>
+            val $dfRowName<$type1>.name: $stringName @JvmName("${type1}_name") get() = this["name"] as $stringName
+            val $dfName<$type1?>.name: $dataCol<$stringName?> @JvmName("Nullable${type1}_name") get() = this["name"] as $dataCol<$stringName?>
+            val $dfRowName<$type1?>.name: $stringName? @JvmName("Nullable${type1}_name") get() = this["name"] as $stringName?
+            
+        """.trimIndent()
+
+        val declaration2 = """
+            @DataSchema
+            interface $type2
+            
+            val $dfName<$type2>.age: $dataCol<$intName> @JvmName("${type2}_age") get() = this["age"] as $dataCol<$intName>
+            val $dfRowName<$type2>.age: $intName @JvmName("${type2}_age") get() = this["age"] as $intName
+            val $dfName<$type2?>.age: $dataCol<$intName?> @JvmName("Nullable${type2}_age") get() = this["age"] as $dataCol<$intName?>
+            val $dfRowName<$type2?>.age: $intName? @JvmName("Nullable${type2}_age") get() = this["age"] as $intName?
+            val $dfName<$type2>.nameAndCity: $colGroup<$type1> @JvmName("${type2}_nameAndCity") get() = this["nameAndCity"] as $colGroup<$type1>
+            val $dfRowName<$type2>.nameAndCity: $dataRow<$type1> @JvmName("${type2}_nameAndCity") get() = this["nameAndCity"] as $dataRow<$type1>
+            val $dfName<$type2?>.nameAndCity: $colGroup<$type1?> @JvmName("Nullable${type2}_nameAndCity") get() = this["nameAndCity"] as $colGroup<$type1?>
+            val $dfRowName<$type2?>.nameAndCity: $dataRow<$type1?> @JvmName("Nullable${type2}_nameAndCity") get() = this["nameAndCity"] as $dataRow<$type1?>
+            val $dfName<$type2>.weight: $dataCol<$intName?> @JvmName("${type2}_weight") get() = this["weight"] as $dataCol<$intName?>
+            val $dfRowName<$type2>.weight: $intName? @JvmName("${type2}_weight") get() = this["weight"] as $intName?
+            val $dfName<$type2?>.weight: $dataCol<$intName?> @JvmName("Nullable${type2}_weight") get() = this["weight"] as $dataCol<$intName?>
+            val $dfRowName<$type2?>.weight: $intName? @JvmName("Nullable${type2}_weight") get() = this["weight"] as $intName?
+        """.trimIndent()
+
+        val expectedConverter = "it.cast<$type2>()"
+
+        generated.declarations shouldBe declaration1 + "\n" + declaration2
+        generated.converter("it") shouldBe expectedConverter
+    }
+
+    @Test
+    fun `generate extension properties`() {
+        val personClass = (Person::class).qualifiedName!!
+        val expected = """
+            @DataSchema
+            interface $personClass
+        """.trimIndent() + "\n" + expectedProperties(personClassName, personShortName)
+
+        val code = CodeGenerator.create(useFqNames = false)
+            .generate<Person>(InterfaceGenerationMode.NoFields, extensionProperties = true).declarations
+        code shouldBe expected
+    }
+
+    @Test
+    fun `frame to markers`() {
+        val f = SchemaProcessor.create("Temp")
+        val marker = f.process(df.schema(), true)
+        marker.isOpen shouldBe true
+        f.generatedMarkers shouldBe listOf(marker)
+    }
+
+    @Test
+    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 packageName = "org.jetbrains.kotlinx.dataframe"
+        val expected = """
+            @DataSchema
+            interface ValidPerson : $personClassName {
+                override val city: kotlin.String
+                override val weight: kotlin.Int
+            }
+            
+            val $packageName.ColumnsContainer<ValidPerson>.city: $packageName.DataColumn<kotlin.String> @JvmName("ValidPerson_city") get() = this["city"] as $packageName.DataColumn<kotlin.String>
+            val $packageName.DataRow<ValidPerson>.city: kotlin.String @JvmName("ValidPerson_city") get() = this["city"] as kotlin.String
+            val $packageName.ColumnsContainer<ValidPerson?>.city: $packageName.DataColumn<kotlin.String?> @JvmName("NullableValidPerson_city") get() = this["city"] as $packageName.DataColumn<kotlin.String?>
+            val $packageName.DataRow<ValidPerson?>.city: kotlin.String? @JvmName("NullableValidPerson_city") get() = this["city"] as kotlin.String?
+            val $packageName.ColumnsContainer<ValidPerson>.weight: $packageName.DataColumn<kotlin.Int> @JvmName("ValidPerson_weight") get() = this["weight"] as $packageName.DataColumn<kotlin.Int>
+            val $packageName.DataRow<ValidPerson>.weight: kotlin.Int @JvmName("ValidPerson_weight") get() = this["weight"] as kotlin.Int
+            val $packageName.ColumnsContainer<ValidPerson?>.weight: $packageName.DataColumn<kotlin.Int?> @JvmName("NullableValidPerson_weight") get() = this["weight"] as $packageName.DataColumn<kotlin.Int?>
+            val $packageName.DataRow<ValidPerson?>.weight: kotlin.Int? @JvmName("NullableValidPerson_weight") get() = this["weight"] as kotlin.Int?
+        """.trimIndent()
+        code shouldBe expected
+    }
+
+    @Test
+    fun `empty interface with properties`() {
+        val codeGen = CodeGenerator.create(useFqNames = false)
+        val code = codeGen.generate(df.schema(), "Person", false, true, true).code.declarations
+        val expected = """
+            @DataSchema
+            interface Person
+            
+        """.trimIndent() + "\n" + expectedProperties("Person", "Person")
+        code shouldBe expected
+    }
+
+    @Test
+    fun `interface with fields`() {
+        val repl = CodeGenerator.create()
+        val code = repl.generate(typed.schema(), "DataType", true, false, false).code.declarations
+        code shouldBe """
+            @DataSchema(isOpen = false)
+            interface DataType {
+                val age: kotlin.Int
+                val city: kotlin.String?
+                val name: kotlin.String
+                val weight: kotlin.Int?
+            }
+        """.trimIndent()
+    }
+
+    @Test
+    fun `declaration with internal visibility`() {
+        val repl = CodeGenerator.create()
+        val code =
+            repl.generate(typed.schema(), "DataType", true, true, false, MarkerVisibility.INTERNAL).code.declarations
+        val packageName = "org.jetbrains.kotlinx.dataframe"
+        code shouldBe """
+            @DataSchema(isOpen = false)
+            internal interface DataType {
+                val age: kotlin.Int
+                val city: kotlin.String?
+                val name: kotlin.String
+                val weight: kotlin.Int?
+            }
+            
+            internal val $packageName.ColumnsContainer<DataType>.age: $packageName.DataColumn<kotlin.Int> @JvmName("DataType_age") get() = this["age"] as $packageName.DataColumn<kotlin.Int>
+            internal val $packageName.DataRow<DataType>.age: kotlin.Int @JvmName("DataType_age") get() = this["age"] as kotlin.Int
+            internal val $packageName.ColumnsContainer<DataType?>.age: $packageName.DataColumn<kotlin.Int?> @JvmName("NullableDataType_age") get() = this["age"] as $packageName.DataColumn<kotlin.Int?>
+            internal val $packageName.DataRow<DataType?>.age: kotlin.Int? @JvmName("NullableDataType_age") get() = this["age"] as kotlin.Int?
+            internal val $packageName.ColumnsContainer<DataType>.city: $packageName.DataColumn<kotlin.String?> @JvmName("DataType_city") get() = this["city"] as $packageName.DataColumn<kotlin.String?>
+            internal val $packageName.DataRow<DataType>.city: kotlin.String? @JvmName("DataType_city") get() = this["city"] as kotlin.String?
+            internal val $packageName.ColumnsContainer<DataType?>.city: $packageName.DataColumn<kotlin.String?> @JvmName("NullableDataType_city") get() = this["city"] as $packageName.DataColumn<kotlin.String?>
+            internal val $packageName.DataRow<DataType?>.city: kotlin.String? @JvmName("NullableDataType_city") get() = this["city"] as kotlin.String?
+            internal val $packageName.ColumnsContainer<DataType>.name: $packageName.DataColumn<kotlin.String> @JvmName("DataType_name") get() = this["name"] as $packageName.DataColumn<kotlin.String>
+            internal val $packageName.DataRow<DataType>.name: kotlin.String @JvmName("DataType_name") get() = this["name"] as kotlin.String
+            internal val $packageName.ColumnsContainer<DataType?>.name: $packageName.DataColumn<kotlin.String?> @JvmName("NullableDataType_name") get() = this["name"] as $packageName.DataColumn<kotlin.String?>
+            internal val $packageName.DataRow<DataType?>.name: kotlin.String? @JvmName("NullableDataType_name") get() = this["name"] as kotlin.String?
+            internal val $packageName.ColumnsContainer<DataType>.weight: $packageName.DataColumn<kotlin.Int?> @JvmName("DataType_weight") get() = this["weight"] as $packageName.DataColumn<kotlin.Int?>
+            internal val $packageName.DataRow<DataType>.weight: kotlin.Int? @JvmName("DataType_weight") get() = this["weight"] as kotlin.Int?
+            internal val $packageName.ColumnsContainer<DataType?>.weight: $packageName.DataColumn<kotlin.Int?> @JvmName("NullableDataType_weight") get() = this["weight"] as $packageName.DataColumn<kotlin.Int?>
+            internal val $packageName.DataRow<DataType?>.weight: kotlin.Int? @JvmName("NullableDataType_weight") get() = this["weight"] as kotlin.Int?
+        """.trimIndent()
+    }
+
+    @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 packageName = "org.jetbrains.kotlinx.dataframe"
+        code shouldBe """
+            @DataSchema(isOpen = false)
+            public interface DataType {
+                public val age: kotlin.Int
+                public val city: kotlin.String?
+                public val name: kotlin.String
+                public val weight: kotlin.Int?
+            }
+            
+            public val $packageName.ColumnsContainer<DataType>.age: $packageName.DataColumn<kotlin.Int> @JvmName("DataType_age") get() = this["age"] as $packageName.DataColumn<kotlin.Int>
+            public val $packageName.DataRow<DataType>.age: kotlin.Int @JvmName("DataType_age") get() = this["age"] as kotlin.Int
+            public val $packageName.ColumnsContainer<DataType?>.age: $packageName.DataColumn<kotlin.Int?> @JvmName("NullableDataType_age") get() = this["age"] as $packageName.DataColumn<kotlin.Int?>
+            public val $packageName.DataRow<DataType?>.age: kotlin.Int? @JvmName("NullableDataType_age") get() = this["age"] as kotlin.Int?
+            public val $packageName.ColumnsContainer<DataType>.city: $packageName.DataColumn<kotlin.String?> @JvmName("DataType_city") get() = this["city"] as $packageName.DataColumn<kotlin.String?>
+            public val $packageName.DataRow<DataType>.city: kotlin.String? @JvmName("DataType_city") get() = this["city"] as kotlin.String?
+            public val $packageName.ColumnsContainer<DataType?>.city: $packageName.DataColumn<kotlin.String?> @JvmName("NullableDataType_city") get() = this["city"] as $packageName.DataColumn<kotlin.String?>
+            public val $packageName.DataRow<DataType?>.city: kotlin.String? @JvmName("NullableDataType_city") get() = this["city"] as kotlin.String?
+            public val $packageName.ColumnsContainer<DataType>.name: $packageName.DataColumn<kotlin.String> @JvmName("DataType_name") get() = this["name"] as $packageName.DataColumn<kotlin.String>
+            public val $packageName.DataRow<DataType>.name: kotlin.String @JvmName("DataType_name") get() = this["name"] as kotlin.String
+            public val $packageName.ColumnsContainer<DataType?>.name: $packageName.DataColumn<kotlin.String?> @JvmName("NullableDataType_name") get() = this["name"] as $packageName.DataColumn<kotlin.String?>
+            public val $packageName.DataRow<DataType?>.name: kotlin.String? @JvmName("NullableDataType_name") get() = this["name"] as kotlin.String?
+            public val $packageName.ColumnsContainer<DataType>.weight: $packageName.DataColumn<kotlin.Int?> @JvmName("DataType_weight") get() = this["weight"] as $packageName.DataColumn<kotlin.Int?>
+            public val $packageName.DataRow<DataType>.weight: kotlin.Int? @JvmName("DataType_weight") get() = this["weight"] as kotlin.Int?
+            public val $packageName.ColumnsContainer<DataType?>.weight: $packageName.DataColumn<kotlin.Int?> @JvmName("NullableDataType_weight") get() = this["weight"] as $packageName.DataColumn<kotlin.Int?>
+            public val $packageName.DataRow<DataType?>.weight: kotlin.Int? @JvmName("NullableDataType_weight") get() = this["weight"] as kotlin.Int?
+        """.trimIndent()
+    }
+
+    @Test
+    fun `column starts with number`() {
+        val df = dataFrameOf("1a", "-b", "?c")(1, 2, 3)
+        val repl = CodeGenerator.create()
+        val declarations = repl.generate(df.schema(), "DataType", false, true, false).code.declarations
+        df.columnNames().forEach {
+            val matches = "`$it`".toRegex().findAll(declarations).toList()
+            matches.size shouldBe 4
+        }
+    }
+
+    @Test
+    fun patterns() {
+        """^[\d]""".toRegex().matches("3fds")
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/MatchSchemeTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/MatchSchemeTests.kt
new file mode 100644
index 000000000..8a4bdd7df
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/MatchSchemeTests.kt
@@ -0,0 +1,100 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.dataframe.impl.codeGen.ReplCodeGenerator
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.io.readJsonStr
+import org.junit.Test
+
+class MatchSchemeTests {
+
+    @DataSchema(isOpen = false)
+    interface Snippet {
+        val position: Int
+        val info: String
+    }
+
+    @DataSchema(isOpen = false)
+    interface Item {
+        val kind: String
+        val id: String
+        val snippet: DataRow<Snippet>
+    }
+
+    @DataSchema(isOpen = false)
+    interface PageInfo {
+        val totalResults: Int
+        val resultsPerPage: Int
+        val snippets: DataFrame<Snippet>
+    }
+
+    @DataSchema
+    interface DataRecord {
+        val kind: String
+        val items: DataFrame<Item>
+        val pageInfo: DataRow<PageInfo>
+    }
+
+    val json = """
+        {
+            "kind": "qq",
+            "pageInfo": {
+                "totalResults": 2,
+                "resultsPerPage": 3,
+                "snippets": [
+                    {
+                        "position": 3,
+                        "info": "str"
+                    },
+                    {
+                        "position": 5,
+                        "info": "txt"
+                    }
+                ]
+            },
+            "items": [
+                {
+                    "kind": "asd",
+                    "id": "zxc",
+                    "snippet": {
+                        "position": 2,
+                        "info": "qwe"
+                    }
+                }
+            ]
+        }
+    """.trimIndent()
+
+    val df = DataFrame.readJsonStr(json)
+
+    val typed = df.cast<DataRecord>()
+
+    @Test
+    fun `marker is reused`() {
+        val codeGen = ReplCodeGenerator.create()
+        codeGen.process(DataRecord::class)
+        codeGen.process(typed, ::typed).hasConverter shouldBe false
+        val generated = codeGen.process(df, ::df)
+        generated.declarations.split("\n").size shouldBe 1
+    }
+
+    val modified = df.add("new") { 4 }
+
+    @Test
+    fun `marker is implemented`() {
+        val codeGen = ReplCodeGenerator.create()
+        codeGen.process(DataRecord::class)
+        val generated = codeGen.process(modified, ::modified)
+        generated.declarations.contains(DataRecord::class.simpleName!!) shouldBe true
+    }
+
+    @Test
+    fun printSchema() {
+        val res = df.generateCode(false, true)
+        println(res)
+    }
+}
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
new file mode 100644
index 000000000..dce359f3b
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/NameGenerationTests.kt
@@ -0,0 +1,53 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.dataframe.impl.codeGen.CodeGenerator
+import org.jetbrains.dataframe.impl.codeGen.ReplCodeGenerator
+import org.jetbrains.dataframe.impl.codeGen.process
+import org.jetbrains.kotlinx.dataframe.annotations.ColumnName
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.junit.Test
+
+class NameGenerationTests {
+
+    val df = dataFrameOf("first column", "second_column", "____")(3, 5, 7)
+
+    @Test
+    fun `interface generation`() {
+        val codeGen = CodeGenerator.create()
+        val code = codeGen.generate(df.schema(), "DataType", true, false, isOpen = false, MarkerVisibility.IMPLICIT_PUBLIC, emptyList()).code
+
+        val expected = """
+            @DataSchema(isOpen = false)
+            interface DataType {
+                @ColumnName("____")
+                val `____`: kotlin.Int
+                @ColumnName("first column")
+                val `first column`: kotlin.Int
+                val second_column: kotlin.Int
+            }
+        """.trimIndent()
+
+        code.declarations shouldBe expected
+    }
+
+    @DataSchema
+    interface DataRecord {
+        @ColumnName("first column")
+        val `first column`: Int
+        @ColumnName("second column")
+        val `second column`: Int
+    }
+
+    @Test
+    fun `properties generation`() {
+        val codeGen = ReplCodeGenerator.create()
+        val code = codeGen.process<DataRecord>().split("\n")
+        code.size shouldBe 8
+        code.forEach {
+            it.count { it == '`' } shouldBe 2
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ReplCodeGenTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ReplCodeGenTests.kt
new file mode 100644
index 000000000..50a3fbbf2
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ReplCodeGenTests.kt
@@ -0,0 +1,222 @@
+package org.jetbrains.kotlinx.dataframe.codeGen
+
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.string.shouldNotBeEmpty
+import org.jetbrains.dataframe.impl.codeGen.ReplCodeGenerator
+import org.jetbrains.dataframe.impl.codeGen.process
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.ReplCodeGeneratorImpl
+import org.jetbrains.kotlinx.dataframe.testSets.person.BaseTest
+import org.jetbrains.kotlinx.dataframe.testSets.person.city
+import org.jetbrains.kotlinx.dataframe.testSets.person.weight
+import org.junit.Test
+
+class ReplCodeGenTests : BaseTest() {
+
+    val dfName = (ColumnsContainer::class).simpleName!!
+    val dfRowName = (DataRow::class).simpleName!!
+    val dataCol = (DataColumn::class).simpleName!!
+    val intName = Int::class.simpleName!!
+    val stringName = String::class.simpleName!!
+
+    class Test1 {
+        @DataSchema
+        interface _DataFrameType
+
+        @DataSchema(isOpen = false)
+        interface _DataFrameType1 : _DataFrameType
+
+        @DataSchema(isOpen = false)
+        interface _DataFrameType2 : _DataFrameType
+    }
+
+    class Test2 {
+        @DataSchema
+        interface _DataFrameType
+
+        @DataSchema
+        interface _DataFrameType1
+
+        @DataSchema(isOpen = false)
+        interface _DataFrameType2 : _DataFrameType, _DataFrameType1
+    }
+
+    object Test3 {
+        @DataSchema
+        interface A { val x: List<*> }
+
+        @DataSchema
+        interface B : A
+
+        @DataSchema(isOpen = false)
+        interface C : B {
+            override val x: List<Int>
+        }
+
+        @DataSchema
+        interface D : A
+
+        val df = dataFrameOf("x")(listOf(1))
+    }
+
+    @Test
+    fun `process derived markers`() {
+        val repl = ReplCodeGenerator.create()
+        val code = repl.process(df).declarations
+
+        val marker = ReplCodeGeneratorImpl.markerInterfacePrefix
+        val markerFull = Test1._DataFrameType::class.qualifiedName!!
+
+        val expected = """
+            @DataSchema
+            interface $marker
+            
+            val $dfName<$marker>.age: $dataCol<$intName> @JvmName("${marker}_age") get() = this["age"] as $dataCol<$intName>
+            val $dfRowName<$marker>.age: $intName @JvmName("${marker}_age") get() = this["age"] as $intName
+            val $dfName<$marker?>.age: $dataCol<$intName?> @JvmName("Nullable${marker}_age") get() = this["age"] as $dataCol<$intName?>
+            val $dfRowName<$marker?>.age: $intName? @JvmName("Nullable${marker}_age") get() = this["age"] as $intName?
+            val $dfName<$marker>.city: $dataCol<$stringName?> @JvmName("${marker}_city") get() = this["city"] as $dataCol<$stringName?>
+            val $dfRowName<$marker>.city: $stringName? @JvmName("${marker}_city") get() = this["city"] as $stringName?
+            val $dfName<$marker?>.city: $dataCol<$stringName?> @JvmName("Nullable${marker}_city") get() = this["city"] as $dataCol<$stringName?>
+            val $dfRowName<$marker?>.city: $stringName? @JvmName("Nullable${marker}_city") get() = this["city"] as $stringName?
+            val $dfName<$marker>.name: $dataCol<$stringName> @JvmName("${marker}_name") get() = this["name"] as $dataCol<$stringName>
+            val $dfRowName<$marker>.name: $stringName @JvmName("${marker}_name") get() = this["name"] as $stringName
+            val $dfName<$marker?>.name: $dataCol<$stringName?> @JvmName("Nullable${marker}_name") get() = this["name"] as $dataCol<$stringName?>
+            val $dfRowName<$marker?>.name: $stringName? @JvmName("Nullable${marker}_name") get() = this["name"] as $stringName?
+            val $dfName<$marker>.weight: $dataCol<$intName?> @JvmName("${marker}_weight") get() = this["weight"] as $dataCol<$intName?>
+            val $dfRowName<$marker>.weight: $intName? @JvmName("${marker}_weight") get() = this["weight"] as $intName?
+            val $dfName<$marker?>.weight: $dataCol<$intName?> @JvmName("Nullable${marker}_weight") get() = this["weight"] as $dataCol<$intName?>
+            val $dfRowName<$marker?>.weight: $intName? @JvmName("Nullable${marker}_weight") get() = this["weight"] as $intName?
+        """.trimIndent()
+        code shouldBe expected
+
+        val code2 = repl.process<Test1._DataFrameType>()
+        code2 shouldBe ""
+
+        val df3 = typed.filter { city != null }
+        val code3 = repl.process(df3).declarations
+        val marker3 = marker + "1"
+        val expected3 = """
+            @DataSchema
+            interface $marker3 : $markerFull
+            
+            val $dfName<$marker3>.city: $dataCol<$stringName> @JvmName("${marker3}_city") get() = this["city"] as $dataCol<$stringName>
+            val $dfRowName<$marker3>.city: $stringName @JvmName("${marker3}_city") get() = this["city"] as $stringName
+            val $dfName<$marker3?>.city: $dataCol<$stringName?> @JvmName("Nullable${marker3}_city") get() = this["city"] as $dataCol<$stringName?>
+            val $dfRowName<$marker3?>.city: $stringName? @JvmName("Nullable${marker3}_city") get() = this["city"] as $stringName?
+        """.trimIndent()
+
+        code3 shouldBe expected3
+
+        val code4 = repl.process<Test1._DataFrameType1>()
+        code4 shouldBe ""
+
+        val df5 = typed.filter { weight != null }
+        val code5 = repl.process(df5).declarations
+        val marker5 = marker + "2"
+        val expected5 = """
+            @DataSchema
+            interface $marker5 : $markerFull
+            
+            val $dfName<$marker5>.weight: $dataCol<$intName> @JvmName("${marker5}_weight") get() = this["weight"] as $dataCol<$intName>
+            val $dfRowName<$marker5>.weight: $intName @JvmName("${marker5}_weight") get() = this["weight"] as $intName
+            val $dfName<$marker5?>.weight: $dataCol<$intName?> @JvmName("Nullable${marker5}_weight") get() = this["weight"] as $dataCol<$intName?>
+            val $dfRowName<$marker5?>.weight: $intName? @JvmName("Nullable${marker5}_weight") get() = this["weight"] as $intName?
+        """.trimIndent()
+        code5 shouldBe expected5
+
+        val code6 = repl.process<Test1._DataFrameType2>()
+        code6 shouldBe ""
+    }
+
+    @Test
+    fun `process markers union`() {
+        val repl = ReplCodeGenerator.create()
+        repl.process(typed.select { age and name })
+        repl.process<Test2._DataFrameType>() shouldBe ""
+        repl.process(typed.select { city and weight })
+        repl.process<Test2._DataFrameType1>() shouldBe ""
+
+        val expected = """
+            @DataSchema
+            interface ${Test2._DataFrameType2::class.simpleName!!} : ${Test2._DataFrameType::class.qualifiedName}, ${Test2._DataFrameType1::class.qualifiedName}
+            
+        """.trimIndent()
+
+        val code = repl.process(typed).declarations.trimIndent()
+        code shouldBe expected
+    }
+
+    @Test
+    fun `process wrong marker inheritance`() {
+        val repl = ReplCodeGenerator.create()
+        repl.process(typed.select { age and name })
+        repl.process<Test2._DataFrameType>() shouldBe ""
+        repl.process(typed.select { city and weight })
+        repl.process<Test1._DataFrameType1>() shouldBe "" // processed wrong marker (doesn't implement Test2.DataFrameType)
+
+        val marker = Test2._DataFrameType2::class.simpleName!!
+        val expected = """
+            @DataSchema
+            interface $marker : ${Test2._DataFrameType::class.qualifiedName}
+            
+            val $dfName<$marker>.city: $dataCol<$stringName?> @JvmName("${marker}_city") get() = this["city"] as $dataCol<$stringName?>
+            val $dfRowName<$marker>.city: $stringName? @JvmName("${marker}_city") get() = this["city"] as $stringName?
+            val $dfName<$marker?>.city: $dataCol<$stringName?> @JvmName("Nullable${marker}_city") get() = this["city"] as $dataCol<$stringName?>
+            val $dfRowName<$marker?>.city: $stringName? @JvmName("Nullable${marker}_city") get() = this["city"] as $stringName?
+            val $dfName<$marker>.weight: $dataCol<$intName?> @JvmName("${marker}_weight") get() = this["weight"] as $dataCol<$intName?>
+            val $dfRowName<$marker>.weight: $intName? @JvmName("${marker}_weight") get() = this["weight"] as $intName?
+            val $dfName<$marker?>.weight: $dataCol<$intName?> @JvmName("Nullable${marker}_weight") get() = this["weight"] as $dataCol<$intName?>
+            val $dfRowName<$marker?>.weight: $intName? @JvmName("Nullable${marker}_weight") get() = this["weight"] as $intName?
+        """.trimIndent()
+
+        val code = repl.process(typed).declarations.trimIndent()
+        code shouldBe expected
+    }
+
+    @Test
+    fun `process overridden property`() {
+        val repl = ReplCodeGenerator.create()
+        repl.process<Test3.A>()
+        repl.process<Test3.B>()
+        repl.process<Test3.C>()
+        val c = repl.process(Test3.df, Test3::df)
+        c.declarations.shouldNotBeEmpty()
+    }
+
+    @Test
+    fun `process diamond inheritance`() {
+        val repl = ReplCodeGenerator.create()
+        repl.process<Test3.A>()
+        repl.process<Test3.B>()
+        repl.process<Test3.D>()
+        val c = repl.process(Test3.df, Test3::df)
+        """val .*ColumnsContainer<\w*>.x:""".toRegex().findAll(c.declarations).count() shouldBe 1
+    }
+
+    object Test4 {
+
+        @DataSchema
+        interface A { val a: Int? }
+
+        @DataSchema
+        interface B { val a: Int? }
+
+        val df = dataFrameOf("a")(1)
+    }
+
+    @Test
+    fun `process duplicate override`() {
+        val repl = ReplCodeGenerator.create()
+        repl.process<Test4.A>()
+        repl.process<Test4.B>()
+        val c = repl.process(Test4.df, Test4::df)
+        """val .*ColumnsContainer<\w*>.a:""".toRegex().findAll(c.declarations).count() shouldBe 1
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ShortNamesRenderingTest.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ShortNamesRenderingTest.kt
new file mode 100644
index 000000000..07e683799
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ShortNamesRenderingTest.kt
@@ -0,0 +1,137 @@
+package org.jetbrains.kotlinx.dataframe.internal.codeGen
+
+import io.kotest.assertions.asClue
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.codeGen.MarkersExtractor
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.ShortNames
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.TypeRenderingStrategy
+import org.junit.Test
+
+internal class ShortNamesRenderingTest : TypeRenderingStrategy by ShortNames {
+
+    interface Marker
+
+    @DataSchema
+    interface DataSchemaMarker
+
+    interface A {
+        val a: DataSchemaMarker
+        val b: Int
+        val c: List<DataSchemaMarker>
+        val d: () -> Unit
+        val e: DataRow<Marker>
+        val f: DataFrame<Marker>
+    }
+
+    private val fields by lazy {
+        MarkersExtractor.get(A::class).allFields.associateBy { it.fieldName.unquoted }
+    }
+
+    @Test
+    fun `data schema type`() {
+        fields.keys.asClue {
+            fields["a"]!!.renderAccessorFieldType() shouldBe "DataRow<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.DataSchemaMarker>"
+            fields["a"]!!.renderFieldType() shouldBe "org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.DataSchemaMarker"
+        }
+    }
+
+    @Test
+    fun `builtin type`() {
+        fields.keys.asClue {
+            fields["b"]!!.renderAccessorFieldType() shouldBe "Int"
+            fields["b"]!!.renderFieldType() shouldBe "Int"
+        }
+    }
+
+    @Test
+    fun `list parametrized by data schema type`() {
+        fields.keys.asClue {
+            fields["c"]!!.renderAccessorFieldType() shouldBe "DataFrame<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.DataSchemaMarker>"
+            fields["c"]!!.renderFieldType() shouldBe "DataFrame<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.DataSchemaMarker>"
+        }
+    }
+
+    @Test
+    fun `short functional types are not supported`() {
+        fields.keys.asClue {
+            fields["d"]!!.renderAccessorFieldType() shouldBe "() -> kotlin.Unit"
+            fields["d"]!!.renderFieldType() shouldBe "() -> kotlin.Unit"
+        }
+    }
+
+    @Test
+    fun `data row`() {
+        fields.keys.asClue {
+            fields["e"]!!.renderAccessorFieldType() shouldBe "DataRow<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.Marker>"
+            fields["e"]!!.renderFieldType() shouldBe "org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.Marker"
+        }
+    }
+
+    @Test
+    fun `data frame`() {
+        fields.keys.asClue {
+            fields["f"]!!.renderAccessorFieldType() shouldBe "DataFrame<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.Marker>"
+            fields["f"]!!.renderFieldType() shouldBe "DataFrame<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.Marker>"
+        }
+    }
+
+    @Test
+    fun `column for data schema type`() {
+        fields.keys.asClue {
+            fields["a"]!!.renderColumnType() shouldBe "ColumnGroup<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.DataSchemaMarker>"
+        }
+    }
+
+    @Test
+    fun `builtin type column`() {
+        fields.keys.asClue {
+            fields["b"]!!.renderColumnType() shouldBe "DataColumn<Int>"
+        }
+    }
+
+    @Test
+    fun `column for list parametrized by data schema type`() {
+        fields.keys.asClue {
+            fields["c"]!!.renderColumnType() shouldBe "DataColumn<DataFrame<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.DataSchemaMarker>>"
+        }
+    }
+
+    @Test
+    fun `functional type column`() {
+        fields.keys.asClue {
+            fields["d"]!!.renderColumnType() shouldBe "DataColumn<() -> kotlin.Unit>"
+        }
+    }
+
+    @Test
+    fun `data row column`() {
+        fields.keys.asClue {
+            fields["e"]!!.renderColumnType() shouldBe "ColumnGroup<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.Marker>"
+        }
+    }
+
+    @Test
+    fun `data frame column`() {
+        fields.keys.asClue {
+            fields["f"]!!.renderColumnType() shouldBe "DataColumn<DataFrame<org.jetbrains.kotlinx.dataframe.internal.codeGen.ShortNamesRenderingTest.Marker>>"
+        }
+    }
+
+    interface GenericDataSchema<A> {
+        val a: A
+    }
+
+    @Test
+    fun `generic field`() {
+        MarkersExtractor.get(GenericDataSchema::class).allFields[0].renderAccessorFieldType() shouldBe "A"
+        MarkersExtractor.get(GenericDataSchema::class).allFields[0].renderFieldType() shouldBe "A"
+    }
+
+    @Test
+    fun `generic column`() {
+        MarkersExtractor.get(GenericDataSchema::class).allFields[0].renderColumnType() shouldBe "DataColumn<A>"
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnGroups.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnGroups.kt
new file mode 100644
index 000000000..5169e7c1c
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnGroups.kt
@@ -0,0 +1,19 @@
+package org.jetbrains.kotlinx.dataframe.columns
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.junit.Test
+
+class ColumnGroupTests {
+
+    @Test
+    fun emptyColumnGroup() {
+        val df = DataFrame.empty(2)
+        val group = DataColumn.createColumnGroup("a", df)
+        group.size() shouldBe 2
+        group.columnsCount() shouldBe 0
+        group.rowsCount() shouldBe 2
+        group.distinct().rowsCount() shouldBe 0
+    }
+}
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
new file mode 100644
index 000000000..e9c80d28a
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/CsvTests.kt
@@ -0,0 +1,258 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import io.kotest.assertions.throwables.shouldNotThrowAny
+import io.kotest.matchers.nulls.shouldNotBeNull
+import io.kotest.matchers.shouldBe
+import kotlinx.datetime.LocalDateTime
+import org.apache.commons.csv.CSVFormat
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.ParserOptions
+import org.jetbrains.kotlinx.dataframe.api.allNulls
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.group
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.api.toStr
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.testCsv
+import org.jetbrains.kotlinx.dataframe.testResource
+import org.junit.Test
+import java.io.File
+import java.io.StringWriter
+import java.util.Locale
+import kotlin.reflect.KClass
+import kotlin.reflect.typeOf
+
+class CsvTests {
+
+    @Test
+    fun readNulls() {
+        val src = """
+            first,second
+            2,,
+            3,,
+        """.trimIndent()
+        val df = DataFrame.readDelimStr(src)
+        df.nrow shouldBe 2
+        df.ncol shouldBe 2
+        df["first"].type() shouldBe typeOf<Int>()
+        df["second"].allNulls() shouldBe true
+        df["second"].type() shouldBe typeOf<String?>()
+    }
+
+    @Test
+    fun write() {
+        val df = dataFrameOf("col1", "col2")(
+            1,
+            null,
+            2,
+            null
+        ).convert("col2").toStr()
+
+        val str = StringWriter()
+        df.writeCSV(str)
+
+        val res = DataFrame.readDelimStr(str.buffer.toString())
+
+        res shouldBe df
+    }
+
+    @Test
+    fun readCSV() {
+        val df = DataFrame.read(simpleCsv)
+
+        df.ncol shouldBe 11
+        df.nrow shouldBe 5
+        df.columnNames()[5] shouldBe "duplicate1"
+        df.columnNames()[6] shouldBe "duplicate11"
+        df["duplicate1"].type() shouldBe typeOf<String?>()
+        df["double"].type() shouldBe typeOf<Double?>()
+        df["time"].type() shouldBe typeOf<LocalDateTime>()
+
+        println(df)
+    }
+
+    @Test
+    fun readCsvWithFrenchLocaleAndAlternativeDelimiter() {
+        val df = DataFrame.readCSV(
+            url = csvWithFrenchLocale,
+            delimiter = ';',
+            parserOptions = ParserOptions(locale = Locale.FRENCH),
+        )
+
+        df.ncol shouldBe 11
+        df.nrow shouldBe 5
+        df.columnNames()[5] shouldBe "duplicate1"
+        df.columnNames()[6] shouldBe "duplicate11"
+        df["duplicate1"].type() shouldBe typeOf<String?>()
+        df["double"].type() shouldBe typeOf<Double?>()
+        df["number"].type() shouldBe typeOf<Double>()
+        df["time"].type() shouldBe typeOf<LocalDateTime>()
+
+        println(df)
+    }
+
+    @Test
+    fun readCsvWithFloats() {
+        val df = DataFrame.readCSV(wineCsv, delimiter = ';')
+        val schema = df.schema()
+        fun assertColumnType(columnName: String, kClass: KClass<*>) {
+            val col = schema.columns[columnName]
+            col.shouldNotBeNull()
+            col.type.classifier shouldBe kClass
+        }
+
+        assertColumnType("citric acid", Double::class)
+        assertColumnType("alcohol", Double::class)
+        assertColumnType("quality", Int::class)
+    }
+
+    @Test
+    fun `read standard CSV with floats when user has alternative locale`() {
+        val currentLocale = Locale.getDefault()
+        try {
+            Locale.setDefault(Locale.forLanguageTag("ru-RU"))
+            val df = DataFrame.readCSV(wineCsv, delimiter = ';')
+            val schema = df.schema()
+            fun assertColumnType(columnName: String, kClass: KClass<*>) {
+                val col = schema.columns[columnName]
+                col.shouldNotBeNull()
+                col.type.classifier shouldBe kClass
+            }
+
+            assertColumnType("citric acid", Double::class)
+            assertColumnType("alcohol", Double::class)
+            assertColumnType("quality", Int::class)
+        } finally {
+            Locale.setDefault(currentLocale)
+        }
+    }
+
+    @Test
+    fun `read with custom header`() {
+        val header = ('A'..'K').map { it.toString() }
+        val df = DataFrame.readCSV(simpleCsv, header = header, skipLines = 1)
+        df.columnNames() shouldBe header
+        df["B"].type() shouldBe typeOf<Int>()
+
+        val headerShort = ('A'..'E').map { it.toString() }
+        val dfShort = DataFrame.readCSV(simpleCsv, header = headerShort, skipLines = 1)
+        dfShort.ncol shouldBe 5
+        dfShort.columnNames() shouldBe headerShort
+    }
+
+    @Test
+    fun `read first rows`() {
+        val expected =
+            listOf(
+                "untitled",
+                "user_id",
+                "name",
+                "duplicate",
+                "username",
+                "duplicate1",
+                "duplicate11",
+                "double",
+                "number",
+                "time",
+                "empty",
+            )
+        val dfHeader = DataFrame.readCSV(simpleCsv, readLines = 0)
+        dfHeader.nrow shouldBe 0
+        dfHeader.columnNames() shouldBe expected
+
+        val dfThree = DataFrame.readCSV(simpleCsv, readLines = 3)
+        dfThree.nrow shouldBe 3
+
+        val dfFull = DataFrame.readCSV(simpleCsv, readLines = 10)
+        dfFull.nrow shouldBe 5
+    }
+
+    @Test
+    fun `if string starts with a number, it should be parsed as a string anyway`() {
+        val df = DataFrame.readCSV(durationCsv)
+        df["duration"].type() shouldBe typeOf<String>()
+        df["floatDuration"].type() shouldBe typeOf<String>()
+    }
+
+    @Test
+    fun `if record has fewer columns than header then pad it with nulls`() {
+        val csvContent = """col1,col2,col3
+            568,801,587
+            780,588
+        """.trimIndent()
+
+        val df = shouldNotThrowAny {
+            DataFrame.readDelimStr(csvContent)
+        }
+
+        df shouldBe dataFrameOf("col1", "col2", "col3")(
+            568, 801, 587,
+            780, 588, null
+        )
+    }
+
+    @Test
+    fun `write and read frame column`() {
+        val df = dataFrameOf("a", "b", "c")(
+            1, 2, 3,
+            1, 3, 2,
+            2, 1, 3
+        )
+        val grouped = df.groupBy("a").into("g")
+        val str = grouped.toCsv()
+        val res = DataFrame.readDelimStr(str)
+        res shouldBe grouped
+    }
+
+    @Test
+    fun `write and read column group`() {
+        val df = dataFrameOf("a", "b", "c")(
+            1, 2, 3,
+            1, 3, 2
+        )
+        val grouped = df.group("b", "c").into("d")
+        val str = grouped.toCsv()
+        val res = DataFrame.readDelimStr(str)
+        res shouldBe grouped
+    }
+
+    @Test
+    fun `CSV String of saved dataframe starts with column name`() {
+        val df = dataFrameOf("a")(1)
+        df.toCsv().first() shouldBe 'a'
+    }
+
+    @Test
+    fun `guess tsv`() {
+        val df = DataFrame.read(testResource("abc.tsv"))
+        df.columnsCount() shouldBe 3
+        df.rowsCount() shouldBe 2
+    }
+
+    @Test
+    fun `write csv without header produce correct file`() {
+        val df = dataFrameOf("a", "b", "c")(
+            1, 2, 3,
+            1, 3, 2,
+        )
+        df.writeCSV(
+            "src/test/resources/without_header.csv",
+            CSVFormat.DEFAULT.withSkipHeaderRecord(),
+        )
+        val producedFile = File("src/test/resources/without_header.csv")
+        producedFile.exists() shouldBe true
+        producedFile.readText() shouldBe "1,2,3\r\n1,3,2\r\n"
+        producedFile.delete()
+    }
+
+    companion object {
+        private val simpleCsv = testCsv("testCSV")
+        private val csvWithFrenchLocale = testCsv("testCSVwithFrenchLocale")
+        private val wineCsv = testCsv("wine")
+        private val durationCsv = testCsv("duration")
+    }
+}
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
new file mode 100644
index 000000000..f4a8ab160
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ParserTests.kt
@@ -0,0 +1,206 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toKotlinLocalDate
+import kotlinx.datetime.toKotlinLocalDateTime
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.convertTo
+import org.jetbrains.kotlinx.dataframe.api.convertToDouble
+import org.jetbrains.kotlinx.dataframe.api.convertToLocalDate
+import org.jetbrains.kotlinx.dataframe.api.convertToLocalDateTime
+import org.jetbrains.kotlinx.dataframe.api.convertToLocalTime
+import org.jetbrains.kotlinx.dataframe.api.parse
+import org.jetbrains.kotlinx.dataframe.api.parser
+import org.jetbrains.kotlinx.dataframe.api.plus
+import org.jetbrains.kotlinx.dataframe.api.times
+import org.jetbrains.kotlinx.dataframe.api.tryParse
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConversionException
+import org.junit.Test
+import java.math.BigDecimal
+import java.time.LocalTime
+import java.util.Locale
+import kotlin.reflect.typeOf
+
+class ParserTests {
+
+    @Test
+    fun `parse datetime with custom format`() {
+        val col by columnOf("04.02.2021 -- 19:44:32")
+        col.tryParse().type() shouldBe typeOf<String>()
+        DataFrame.parser.addDateTimePattern("dd.MM.uuuu -- HH:mm:ss")
+        val parsed = col.parse()
+        parsed.type() shouldBe typeOf<LocalDateTime>()
+        parsed.cast<LocalDateTime>()[0].year shouldBe 2021
+        DataFrame.parser.resetToDefault()
+    }
+
+    @Test(expected = IllegalStateException::class)
+    fun `parse should throw`() {
+        val col by columnOf("a", "b")
+        col.parse()
+    }
+
+    @Test(expected = TypeConversionException::class)
+    fun `converter should throw`() {
+        val col by columnOf("a", "b")
+        col.convertTo<Int>()
+    }
+
+    @Test(expected = TypeConversionException::class)
+    fun `converter for mixed column should throw`() {
+        val col by columnOf(1, "a")
+        col.convertTo<Int>()
+    }
+
+    @Test
+    fun `convert mixed column`() {
+        val col by columnOf(1.0, "1")
+        val converted = col.convertTo<Int>()
+        converted.type() shouldBe typeOf<Int>()
+        converted[0] shouldBe 1
+        converted[1] shouldBe 1
+    }
+
+    @Test
+    fun `convert BigDecimal column`() {
+        val col by columnOf(BigDecimal(1.0), BigDecimal(0.321))
+        val converted = col.convertTo<Float>()
+        converted.type() shouldBe typeOf<Float>()
+        converted[0] shouldBe 1.0f
+        converted[1] shouldBe 0.321f
+    }
+
+    @Test
+    fun `convert to Boolean`() {
+        val col by columnOf(BigDecimal(1.0), BigDecimal(0.0), 0, 1, 10L, 0.0, 0.1)
+        col.convertTo<Boolean>().shouldBe(
+            DataColumn.createValueColumn("col", listOf(true, false, false, true, true, false, true), typeOf<Boolean>())
+        )
+    }
+
+    @Test
+    fun `convert to date and time`() {
+        val daysToStandardMillis = 24 * 60 * 60 * 1000L
+        val longCol = columnOf(1L, 60L, 3600L).times(1000L).plus(daysToStandardMillis * 366)
+        val datetimeCol = longCol.convertToLocalDateTime(TimeZone.UTC)
+
+        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()
+            )
+        )
+        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()
+            )
+        )
+        longCol.convertToLocalTime(TimeZone.UTC).shouldBe(
+            columnOf(
+                LocalTime.of(0, 0, 1),
+                LocalTime.of(0, 1, 0),
+                LocalTime.of(1, 0, 0)
+            )
+        )
+
+        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()
+            )
+        )
+        datetimeCol.convertToLocalTime().shouldBe(
+            columnOf(
+                LocalTime.of(0, 0, 1),
+                LocalTime.of(0, 1, 0),
+                LocalTime.of(1, 0, 0)
+            )
+        )
+    }
+
+    @Test
+    fun `converting String to Double in different locales`() {
+        val currentLocale = Locale.getDefault()
+        try {
+            // Test 36 behaviour combinations:
+
+            // 3 source columns
+            val columnDot = columnOf("12.345", "67.890")
+            val columnComma = columnOf("12,345", "67,890")
+            val columnMixed = columnOf("12.345", "67,890")
+            // *
+            // (3 locales as converting parameter + original converting)
+            val parsingLocaleNotDefined: Locale? = null
+            val parsingLocaleUsesDot: Locale = Locale.forLanguageTag("en-US")
+            val parsingLocaleUsesComma: Locale = Locale.forLanguageTag("ru-RU")
+            // *
+            // 3 system locales
+
+            Locale.setDefault(Locale.forLanguageTag("C.UTF-8"))
+
+            columnDot.convertTo<Double>().shouldBe(columnOf(12.345, 67.89))
+            columnComma.convertTo<Double>().shouldBe(columnOf(12345.0, 67890.0))
+            columnMixed.convertTo<Double>().shouldBe(columnOf(12.345, 67890.0))
+
+            columnDot.convertToDouble(parsingLocaleNotDefined).shouldBe(columnOf(12.345, 67.89))
+            columnComma.convertToDouble(parsingLocaleNotDefined).shouldBe(columnOf(12345.0, 67890.0))
+            columnMixed.convertToDouble(parsingLocaleNotDefined).shouldBe(columnOf(12.345, 67890.0))
+
+            columnDot.convertToDouble(parsingLocaleUsesDot).shouldBe(columnOf(12.345, 67.89))
+            columnComma.convertToDouble(parsingLocaleUsesDot).shouldBe(columnOf(12345.0, 67890.0))
+            columnMixed.convertToDouble(parsingLocaleUsesDot).shouldBe(columnOf(12.345, 67890.0))
+
+            shouldThrow<TypeConversionException> { columnDot.convertToDouble(parsingLocaleUsesComma) }
+            columnComma.convertToDouble(parsingLocaleUsesComma).shouldBe(columnOf(12.345, 67.89))
+            shouldThrow<TypeConversionException> { columnMixed.convertToDouble(parsingLocaleUsesComma) }
+
+            Locale.setDefault(Locale.forLanguageTag("en-US"))
+
+            columnDot.convertTo<Double>().shouldBe(columnOf(12.345, 67.89))
+            columnComma.convertTo<Double>().shouldBe(columnOf(12345.0, 67890.0))
+            columnMixed.convertTo<Double>().shouldBe(columnOf(12.345, 67890.0))
+
+            columnDot.convertToDouble(parsingLocaleNotDefined).shouldBe(columnOf(12.345, 67.89))
+            columnComma.convertToDouble(parsingLocaleNotDefined).shouldBe(columnOf(12345.0, 67890.0))
+            columnMixed.convertToDouble(parsingLocaleNotDefined).shouldBe(columnOf(12.345, 67890.0))
+
+            columnDot.convertToDouble(parsingLocaleUsesDot).shouldBe(columnOf(12.345, 67.89))
+            columnComma.convertToDouble(parsingLocaleUsesDot).shouldBe(columnOf(12345.0, 67890.0))
+            columnMixed.convertToDouble(parsingLocaleUsesDot).shouldBe(columnOf(12.345, 67890.0))
+
+            shouldThrow<TypeConversionException> { columnDot.convertToDouble(parsingLocaleUsesComma) }
+            columnComma.convertToDouble(parsingLocaleUsesComma).shouldBe(columnOf(12.345, 67.89))
+            shouldThrow<TypeConversionException> { columnMixed.convertToDouble(parsingLocaleUsesComma) }
+
+            Locale.setDefault(Locale.forLanguageTag("ru-RU"))
+
+            columnDot.convertTo<Double>().shouldBe(columnOf(12.345, 67.89))
+            columnComma.convertTo<Double>().shouldBe(columnOf(12.345, 67.89))
+            columnMixed.convertTo<Double>().shouldBe(columnOf(12.345, 67890.0))
+
+            columnDot.convertToDouble(parsingLocaleNotDefined).shouldBe(columnOf(12.345, 67.89))
+            columnComma.convertToDouble(parsingLocaleNotDefined).shouldBe(columnOf(12.345, 67.89))
+            columnMixed.convertToDouble(parsingLocaleNotDefined).shouldBe(columnOf(12.345, 67890.0))
+
+            columnDot.convertToDouble(parsingLocaleUsesDot).shouldBe(columnOf(12.345, 67.89))
+            columnComma.convertToDouble(parsingLocaleUsesDot).shouldBe(columnOf(12345.0, 67890.0))
+            columnMixed.convertToDouble(parsingLocaleUsesDot).shouldBe(columnOf(12.345, 67890.0))
+
+            shouldThrow<TypeConversionException> { columnDot.convertToDouble(parsingLocaleUsesComma) }
+            columnComma.convertToDouble(parsingLocaleUsesComma).shouldBe(columnOf(12.345, 67.89))
+            shouldThrow<TypeConversionException> { columnMixed.convertToDouble(parsingLocaleUsesComma) }
+        } finally {
+            Locale.setDefault(currentLocale)
+        }
+    }
+}
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
new file mode 100644
index 000000000..02cdc6642
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/PlaylistJsonTest.kt
@@ -0,0 +1,206 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.asGroupBy
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.getColumnGroupOrNull
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.minBy
+import org.jetbrains.kotlinx.dataframe.api.move
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.remove
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.dataTypes.IMG
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class PlaylistJsonTest {
+
+    @DataSchema(isOpen = false)
+    interface DataFrameType4 {
+        val url: String
+        val width: Int
+        val height: Int
+    }
+
+    @DataSchema(isOpen = false)
+    interface DataFrameType5 {
+        val url: String
+        val width: Int
+        val height: Int
+    }
+
+    @DataSchema(isOpen = false)
+    interface DataFrameType6 {
+        val url: String
+        val width: Int
+        val height: Int
+    }
+
+    @DataSchema(isOpen = false)
+    interface DataFrameType7 {
+        val url: String?
+        val width: Int?
+        val height: Int?
+    }
+
+    @DataSchema(isOpen = false)
+    interface DataFrameType8 {
+        val url: String?
+        val width: Int?
+        val height: Int?
+    }
+
+    @DataSchema(isOpen = false)
+    interface DataFrameType3 {
+        val default: DataRow<DataFrameType4>
+        val medium: DataRow<DataFrameType5>
+        val high: DataRow<DataFrameType6>
+        val standard: DataRow<DataFrameType7>
+        val maxres: DataRow<DataFrameType8>
+    }
+
+    @DataSchema(isOpen = false)
+    interface DataFrameType9 {
+        val kind: String
+        val videoId: String
+    }
+
+    @DataSchema(isOpen = false)
+    interface DataFrameType2 {
+        val publishedAt: String
+        val channelId: String
+        val title: String
+        val description: String
+        val thumbnails: DataRow<DataFrameType3>
+        val channelTitle: String
+        val playlistId: String
+        val position: Int
+        val resourceId: DataRow<DataFrameType9>
+    }
+
+    @DataSchema(isOpen = false)
+    interface DataFrameType1 {
+        val kind: String
+        val etag: String
+        val id: String
+        val snippet: DataRow<DataFrameType2>
+    }
+
+    @DataSchema(isOpen = false)
+    interface DataFrameType10 {
+        val totalResults: Int
+        val resultsPerPage: Int
+    }
+
+    @DataSchema
+    interface DataRecord {
+        val kind: String
+        val etag: String
+        val nextPageToken: String
+        val items: DataFrame<DataFrameType1>
+        val pageInfo: DataRow<DataFrameType10>
+    }
+
+    val path = "../data/playlistItems.json"
+    val df = DataFrame.read(path)
+    val typed = df.cast<DataRecord>()
+    val item = typed.items[0]
+
+    @Test
+    fun `deep update`() {
+        val updated = item.convert { snippet.thumbnails.default.url }.with { IMG(it) }
+        updated.snippet.thumbnails.default.url.type() shouldBe typeOf<IMG>()
+    }
+
+    @Test
+    fun `deep update group`() {
+        val updated = item.convert { snippet.thumbnails.default }.with { it.url }
+        updated.snippet.thumbnails["default"].type() shouldBe typeOf<String>()
+    }
+
+    @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>()
+    }
+
+    @Test
+    fun `deep batch update all`() {
+        val updated = item.convert { dfs { 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>()
+    }
+
+    @Test
+    fun `select group`() {
+        item.select { snippet.thumbnails.default }.columnsCount() shouldBe 1
+        item.select { snippet.thumbnails.default.all() }.columnsCount() shouldBe 3
+    }
+
+    @Test
+    fun `deep remove`() {
+        val item2 = item.remove { snippet.thumbnails.default and snippet.thumbnails.maxres and snippet.channelId and etag }
+        item2.columnsCount() shouldBe item.columnsCount() - 1
+        item2.snippet.columnsCount() shouldBe item.snippet.columnsCount() - 1
+        item2.snippet.thumbnails.columnsCount() shouldBe item.snippet.thumbnails.columnsCount() - 2
+    }
+
+    @Test
+    fun `remove all from group`() {
+        val item2 = item.remove { snippet.thumbnails.default and snippet.thumbnails.maxres and snippet.thumbnails.medium and snippet.thumbnails.high and snippet.thumbnails.standard }
+        item2.snippet.columnsCount() shouldBe item.snippet.columnsCount() - 1
+        item2.snippet.getColumnGroupOrNull("thumbnails") shouldBe null
+    }
+
+    @Test
+    fun `deep move with rename`() {
+        val moved = item.move { snippet.thumbnails.default }.into { snippet.path() + "movedDefault" }
+        moved.snippet.thumbnails.columnNames() shouldBe item.snippet.thumbnails.remove { default }.columnNames()
+        moved.snippet.columnsCount() shouldBe item.snippet.columnsCount() + 1
+        (moved.snippet["movedDefault"] as ColumnGroup<*>).columnsCount() shouldBe item.snippet.thumbnails.default.columnsCount()
+    }
+
+    @Test
+    fun `union`() {
+        val merged = item.concat(item)
+        merged.rowsCount() shouldBe item.rowsCount() * 2
+        val group = merged.snippet
+        group.rowsCount() shouldBe item.snippet.rowsCount() * 2
+        group.columnNames() shouldBe item.snippet.columnNames()
+    }
+
+    @Test
+    fun `select with rename`() {
+        val selected = item.select { snippet.thumbnails.default.url into "default" and (snippet.thumbnails.maxres.url named "maxres") }
+        selected.columnNames() shouldBe listOf("default", "maxres")
+        selected["default"].toList() shouldBe item.snippet.thumbnails.default.url.toList()
+        selected["maxres"].toList() shouldBe item.snippet.thumbnails.maxres.url.toList()
+    }
+
+    @Test
+    fun `aggregate by column`() {
+        val res = typed.asGroupBy { items }.aggregate {
+            this into "items"
+            minBy { snippet.publishedAt }.snippet into "earliest"
+        }
+
+        res.columnsCount() shouldBe typed.columnsCount() + 1
+        res.getColumnIndex("earliest") shouldBe typed.getColumnIndex("items") + 1
+
+        val expected = typed.items.map { it.snippet.minBy { publishedAt } }.toList()
+        res["earliest"].toList() shouldBe expected
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ReadTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ReadTests.kt
new file mode 100644
index 000000000..48415c580
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ReadTests.kt
@@ -0,0 +1,104 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.all
+import org.jetbrains.kotlinx.dataframe.api.allNulls
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.impl.columns.asAnyFrameColumn
+import org.jetbrains.kotlinx.dataframe.impl.nothingType
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class ReadTests {
+
+    @Test
+    fun readJsonNulls() {
+        val data = """
+            [{"a":null, "b":1},{"a":null, "b":2}]
+        """.trimIndent()
+
+        val df = DataFrame.readJsonStr(data)
+        df.ncol shouldBe 2
+        df.nrow shouldBe 2
+        df["a"].hasNulls() shouldBe true
+        df["a"].allNulls() shouldBe true
+        df.all { it["a"] == null } shouldBe true
+        df["a"].type() shouldBe nothingType(nullable = true)
+        df["b"].hasNulls() shouldBe false
+    }
+
+    @Test
+    fun readFrameColumn() {
+        val data = """
+            [{"a":[{"b":[]}]},{"a":[]},{"a":[{"b":[{"c":1}]}]}]
+        """.trimIndent()
+        val df = DataFrame.readJsonStr(data)
+        df.nrow shouldBe 3
+        val a = df["a"].asAnyFrameColumn()
+        a[1].nrow shouldBe 0
+        a[0].nrow shouldBe 1
+        a[2].nrow shouldBe 1
+        val schema = a.schema.value
+        schema.columns.size shouldBe 1
+        val schema2 = schema.columns["b"] as ColumnSchema.Frame
+        schema2.schema.columns.size shouldBe 1
+        schema2.schema.columns["c"]!!.kind shouldBe ColumnKind.Value
+    }
+
+    @Test
+    fun readFrameColumnEmptySlice() {
+        val data = """
+            [ [], [ {"a": [{"q":2},{"q":3}] } ] ]
+        """.trimIndent()
+
+        val df = DataFrame.readJsonStr(data)
+        df.nrow shouldBe 2
+        df.ncol shouldBe 1
+        val empty = df[0][0] as AnyFrame
+        empty.nrow shouldBe 0
+        empty.ncol shouldBe 0
+    }
+
+    @Test
+    fun `read big decimal`() {
+        val data = """
+            [[3452345234345, 7795.34000000], [12314123532, 7795.34000000]]
+        """.trimIndent()
+        val df = DataFrame.readJsonStr(data)
+        println(df.getColumn("array").cast<List<Number>>()[0][1].javaClass)
+    }
+
+    @Test
+    fun `array of arrays`() {
+        val data = """
+            {
+                "values": [[1,2,3],[4,5,6],[7,8,9]]
+            }
+        """.trimIndent()
+        val df = DataFrame.readJsonStr(data)
+        val values by column<List<List<Int>>>()
+        df[values][0][1][1] shouldBe 5
+    }
+
+    @Test
+    fun `read json with header`() {
+        val data = """
+            [[1,2,3],
+            [4,5,6]]
+        """.trimIndent()
+        val header = listOf("a", "b", "c")
+        val df = DataFrame.readJsonStr(data, header)
+        df.rowsCount() shouldBe 2
+        df.columnsCount() shouldBe 3
+        df.columnNames() shouldBe header
+        df.columnTypes() shouldBe List(3) { typeOf<Int>() }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/TypeInferenceTest.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/TypeInferenceTest.kt
new file mode 100644
index 000000000..6582ec510
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/TypeInferenceTest.kt
@@ -0,0 +1,19 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class TypeInferenceTest {
+
+    open class A
+
+    private class B : A()
+
+    @Test
+    fun `private subtypes`() {
+        val df = dataFrameOf("col")(B(), B())
+        df["col"].type() shouldBe typeOf<A>()
+    }
+}
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
new file mode 100644
index 000000000..f02d0060f
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt
@@ -0,0 +1,954 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import io.kotest.matchers.collections.shouldBeIn
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.string.shouldContain
+import io.kotest.matchers.string.shouldNotContain
+import io.kotest.matchers.types.instanceOf
+import org.intellij.lang.annotations.Language
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.alsoDebug
+import org.jetbrains.kotlinx.dataframe.api.JsonPath
+import org.jetbrains.kotlinx.dataframe.api.allNulls
+import org.jetbrains.kotlinx.dataframe.api.columnsCount
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.forEach
+import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.getFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.api.toDouble
+import org.jetbrains.kotlinx.dataframe.api.toMap
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.impl.nothingType
+import org.jetbrains.kotlinx.dataframe.io.JSON.TypeClashTactic.*
+import org.jetbrains.kotlinx.dataframe.type
+import org.jetbrains.kotlinx.dataframe.values
+import org.junit.Test
+import kotlin.reflect.*
+
+class JsonTests {
+
+    @Test
+    fun `parse json array with header`() {
+        @Language("json")
+        val json = """[
+                [1, "a"],
+                [2, "b"],
+                [3, "c"],
+                [4, "d"],
+                [5, "e"]                
+            ]
+        """.trimIndent()
+        val df = DataFrame.readJsonStr(json, header = listOf("numbers", "letters"))
+            .alsoDebug()
+
+        df.columnsCount() shouldBe 2
+        df.rowsCount() shouldBe 5
+        df["numbers"].type() shouldBe typeOf<Int>()
+        df["letters"].type() shouldBe typeOf<String>()
+        df["numbers"].values() shouldBe listOf(1, 2, 3, 4, 5)
+        df["letters"].values() shouldBe listOf("a", "b", "c", "d", "e")
+    }
+
+    @Test
+    fun `parse json array with header Any`() {
+        @Language("json")
+        val json = """[
+                [1, "a"],
+                [2, "b"],
+                [3, "c"],
+                [4, "d"],
+                [5, "e"]                
+            ]
+        """.trimIndent()
+        val df = DataFrame.readJsonStr(json, header = listOf("numbers", "letters"), typeClashTactic = ANY_COLUMNS)
+            .alsoDebug()
+
+        df.columnsCount() shouldBe 2
+        df.rowsCount() shouldBe 5
+        df["numbers"].type() shouldBe typeOf<Int>()
+        df["letters"].type() shouldBe typeOf<String>()
+        df["numbers"].values() shouldBe listOf(1, 2, 3, 4, 5)
+        df["letters"].values() shouldBe listOf("a", "b", "c", "d", "e")
+    }
+
+    @Test
+    fun parseJson1() {
+        @Language("json")
+        val json = """[
+                {"a":1, "b":"text"},
+                {"a":2, "b":5, "c":4.5}
+            ]
+        """.trimIndent()
+        val df = DataFrame.readJsonStr(json)
+            .alsoDebug()
+        df.columnsCount() shouldBe 3
+        df.rowsCount() shouldBe 2
+        df["a"].type() shouldBe typeOf<Int>()
+        df["b"].type() shouldBe typeOf<Comparable<*>>()
+        df["c"].type() shouldBe typeOf<Double?>()
+    }
+
+    @Test
+    fun parseJson1Any() {
+        @Language("json")
+        val json = """[
+                {"a":1, "b":"text"},
+                {"a":2, "b":5, "c":4.5}
+            ]
+        """.trimIndent()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS)
+            .alsoDebug()
+        df.columnsCount() shouldBe 3
+        df.rowsCount() shouldBe 2
+        df["a"].type() shouldBe typeOf<Int>()
+        df["b"].type() shouldBe typeOf<Comparable<*>>()
+        df["c"].type() shouldBe typeOf<Double?>()
+    }
+
+    @Test
+    fun parseJson2() {
+        @Language("json")
+        val json = """[
+                {"a":"text"},
+                {"a":{"b":2}},
+                {"a":[6,7,8]}
+            ]
+        """.trimIndent()
+        val df = DataFrame.readJsonStr(json)
+            .alsoDebug()
+        df.columnsCount() shouldBe 1
+        df.rowsCount() shouldBe 3
+        val group = df["a"] as ColumnGroup<*>
+        group.columnsCount() shouldBe 3
+        group["b"].type() shouldBe typeOf<Int?>()
+        group["value"].type() shouldBe typeOf<String?>()
+        group["array"].type() shouldBe typeOf<List<Int>>()
+    }
+
+    @Test
+    fun parseJson2Any() {
+        @Language("json")
+        val json = """[
+                {"a":"text"},
+                {"a":{"b":2}},
+                {"a":[6,7,8]}
+            ]
+        """.trimIndent()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS)
+            .alsoDebug()
+        df.columnsCount() shouldBe 1
+        df.rowsCount() shouldBe 3
+        val a = df["a"] as ValueColumn<*>
+        a.type() shouldBe typeOf<Any>()
+        a[0] shouldBe "text"
+        (a[1] as DataRow<*>)["b"] shouldBe 2
+        a[2] shouldBe listOf(6, 7, 8)
+    }
+
+    @Test
+    fun parseJson3() {
+        @Language("json")
+        val json = """[
+                {"a":[3, 5]},
+                {},
+                {"a":[3.4, 5.6]}
+            ]
+        """.trimIndent()
+        val df = DataFrame.readJsonStr(json)
+            .alsoDebug()
+        df.columnsCount() shouldBe 1
+        df.rowsCount() shouldBe 3
+        df["a"].type() shouldBe typeOf<List<Number>>()
+        df[1]["a"] shouldBe emptyList<Int>()
+    }
+
+    @Test
+    fun parseJson3Any() {
+        @Language("json")
+        val json = """[
+                {"a":[3, 5]},
+                {},
+                {"a":[3.4, 5.6]}
+            ]
+        """.trimIndent()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS)
+            .alsoDebug()
+        df.columnsCount() shouldBe 1
+        df.rowsCount() shouldBe 3
+        df["a"].type() shouldBe typeOf<List<Number>>()
+        df[1]["a"] shouldBe emptyList<Int>()
+    }
+
+    @Test
+    fun parseJson4() {
+        @Language("json")
+        val json = """[
+                {"a":[ {"b":2}, {"c":3} ]},
+                {"a":[ {"b":4}, {"d":5} ]}
+            ]
+        """.trimIndent()
+        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[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
+    fun parseJson4Any() {
+        @Language("json")
+        val json = """[
+                {"a":[ {"b":2}, {"c":3} ]},
+                {"a":[ {"b":4}, {"d":5} ]}
+            ]
+        """.trimIndent()
+        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[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
+    fun `parse json with nested json array with mixed values`() {
+        @Language("json")
+        val json = """[
+                {"a":"text"},
+                {"a":{"b":2}},
+                {"a":[6, {"a": "b"}, [1, {"a" : "b"}],8]},
+                {"a":[{"a": "b"}, {"a" : "c"}, {"a" : "d"}]}
+            ]
+        """.trimIndent()
+        val df = DataFrame.readJsonStr(json)
+            .alsoDebug()
+        df.columnsCount() shouldBe 1
+        df.rowsCount() shouldBe 4
+        val group = df["a"] as ColumnGroup<*>
+        group.columnsCount() shouldBe 3
+        group["b"].type() shouldBe typeOf<Int?>()
+        group["value"].type() shouldBe typeOf<String?>()
+        group["array"].type() shouldBe typeOf<DataFrame<*>>()
+        val nestedDf = group.getFrameColumn("array")[2]
+        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")
+            }
+    }
+
+    @Test
+    fun `parse json with nested json array with mixed values Any`() {
+        @Language("json")
+        val json = """[
+                {"a":"text"},
+                {"a":{"b":2}},
+                {"a":[6, {"a": "b"}, [1, {"a" : "b"}],8]},
+                {"a":[{"a": "b"}, {"a" : "c"}, {"a" : "d"}]}
+            ]
+        """.trimIndent()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS).alsoDebug()
+        df.columnsCount() shouldBe 1
+        df.rowsCount() shouldBe 4
+        val a = df["a"] as ValueColumn<*>
+        a.type() shouldBe typeOf<Any>()
+        a[0] shouldBe "text"
+        (a[1] as DataRow<*>).let {
+            it.columnsCount() shouldBe 1
+            it["b"] shouldBe 2
+        }
+        (a[2] as List<*>).let {
+            it[0] shouldBe 6
+            (it[1] as DataRow<*>).let {
+                it.columnsCount() shouldBe 1
+                it["a"] shouldBe "b"
+            }
+            (it[2] as List<*>).let {
+                it[0] shouldBe 1
+                (it[1] as DataRow<*>).let {
+                    it.columnsCount() shouldBe 1
+                    it["a"] shouldBe "b"
+                }
+            }
+            it[3] shouldBe 8
+        }
+        (a[3] as DataFrame<*>)
+            .alsoDebug()
+            .let {
+                it.columnsCount() shouldBe 1
+                it.rowsCount() shouldBe 3
+                it["a"].type() shouldBe typeOf<String>()
+                it["a"].values.toList() shouldBe listOf("b", "c", "d")
+            }
+    }
+
+    @Test
+    fun `write df with primitive types`() {
+        val df = dataFrameOf("colInt", "colDouble?", "colBoolean?")(
+            1, 1.0, true,
+            2, null, false,
+            3, 3.0, null
+        ).alsoDebug("df:")
+
+        val res = DataFrame.readJsonStr(df.toJson()).alsoDebug("res:")
+        res shouldBe df
+    }
+
+    @Test
+    fun `write df with primitive types Any`() {
+        val df = dataFrameOf("colInt", "colDouble?", "colBoolean?")(
+            1, 1.0, true,
+            2, null, false,
+            3, 3.0, null
+        ).alsoDebug("df:")
+
+        val res =
+            DataFrame.readJsonStr(df.toJson(), typeClashTactic = ANY_COLUMNS).alsoDebug("res:")
+        res shouldBe df
+    }
+
+    @Test
+    fun `NaN double serialization`() {
+        val df = dataFrameOf("v")(1.1, Double.NaN)
+        df["v"].type() shouldBe typeOf<Double>()
+        DataFrame.readJsonStr(df.toJson()) shouldBe df
+    }
+
+    @Test
+    fun `NaN double serialization Any`() {
+        val df = dataFrameOf("v")(1.1, Double.NaN)
+        df["v"].type() shouldBe typeOf<Double>()
+        DataFrame.readJsonStr(df.toJson(), typeClashTactic = ANY_COLUMNS) shouldBe df
+    }
+
+    @Test
+    fun `NaN float serialization`() {
+        val df = dataFrameOf("v")(1.1f, Float.NaN)
+        df["v"].type() shouldBe typeOf<Float>()
+        DataFrame.readJsonStr(df.toJson()) shouldBe df.convert("v").toDouble()
+    }
+
+    @Test
+    fun `NaN float serialization Any`() {
+        val df = dataFrameOf("v")(1.1f, Float.NaN)
+        df["v"].type() shouldBe typeOf<Float>()
+        DataFrame.readJsonStr(df.toJson(), typeClashTactic = ANY_COLUMNS) shouldBe df.convert("v")
+            .toDouble()
+    }
+
+    @Test
+    fun `NaN string serialization`() {
+        val df = dataFrameOf("v")("NaM", "NaN")
+        df["v"].type() shouldBe typeOf<String>()
+        DataFrame.readJsonStr(df.toJson()) shouldBe df
+    }
+
+    @Test
+    fun `NaN string serialization Any`() {
+        val df = dataFrameOf("v")("NaM", "NaN")
+        df["v"].type() shouldBe typeOf<String>()
+        DataFrame.readJsonStr(df.toJson(), typeClashTactic = ANY_COLUMNS) shouldBe df
+    }
+
+    @Test
+    fun `list serialization`() {
+        val df = dataFrameOf("a")(listOf(1, 2, 3))
+        DataFrame.readJsonStr(df.toJson()) shouldBe df
+    }
+
+    @Test
+    fun `list serialization Any`() {
+        val df = dataFrameOf("a")(listOf(1, 2, 3))
+        DataFrame.readJsonStr(df.toJson(), typeClashTactic = ANY_COLUMNS) shouldBe df
+    }
+
+    @Test
+    fun `list serialization with nulls`() {
+        val df = dataFrameOf("a")(listOf(1, 2, 3), null)
+        val text = df.toJson()
+        val df1 = DataFrame.readJsonStr(text)
+        df1["a"][1] shouldBe emptyList<Int>()
+    }
+
+    @Test
+    fun `list serialization with nulls Any`() {
+        val df = dataFrameOf("a")(listOf(1, 2, 3), null)
+        val text = df.toJson()
+        val df1 = DataFrame.readJsonStr(text, typeClashTactic = ANY_COLUMNS)
+        df1["a"][1] shouldBe emptyList<Int>()
+    }
+
+    @Test
+    fun `serialize column with name 'value'`() {
+        val df = dataFrameOf("a")(dataFrameOf("value")(1, 2, 3))
+
+        @Language("json")
+        val json = df.toJson()
+        json shouldContain "\"value\":1"
+        val df1 = DataFrame.readJsonStr(json)
+        df shouldBe df1
+    }
+
+    @Test
+    fun `literal json field named 'value'`() {
+        @Language("json")
+        val json = """
+                {
+                    "data": {
+                        "source": {
+                            "value": "123"
+                        }
+                    }
+                }
+        """.trimIndent()
+        val df = DataFrame.readJsonStr(json)
+        df[0].getColumnGroup("data").getColumnGroup("source")["value"] shouldBe "123"
+    }
+
+    @Test
+    fun `array json field named 'value'`() {
+        @Language("json")
+        val json = """{ "value": ["123"] }"""
+
+        val df = DataFrame.readJsonStr(json).alsoDebug()
+        df[0]["value"] shouldBe listOf("123")
+    }
+
+    @Test
+    fun `record json field named 'value'`() {
+        @Language("json")
+        val json = """{ "value": { "test" : "123" } }"""
+
+        val df = DataFrame.readJsonStr(json)
+        df[0].getColumnGroup("value")["test"] shouldBe "123"
+    }
+
+    @Test
+    fun `json field named 'array'`() {
+        @Language("json")
+        val json = """
+            {
+                "data": {
+                    "source": {
+                        "array": "123"
+                    }
+                }
+            }
+        """.trimIndent()
+
+        val df = DataFrame.readJsonStr(json)
+        df[0].getColumnGroup("data").getColumnGroup("source")["array"] shouldBe "123"
+    }
+
+    @Test
+    fun `array json field named 'array'`() {
+        @Language("json")
+        val json = """
+            [{
+              "a": {
+                "value": "text",
+                "array": []
+              }
+            }, {
+              "a": {
+                "b": 2,
+                "array": []
+              }
+            }, {
+              "a": {
+                "array": [6, 7, 8]
+              }
+            }]
+        """.trimIndent()
+
+        val df = DataFrame.readJsonStr(json).alsoDebug()
+        val group = df.getColumnGroup("a")
+        group["array"].type() shouldBe typeOf<List<Int>>()
+        group["value"].type() shouldBe typeOf<String?>()
+        group["b"].type() shouldBe typeOf<Int?>()
+    }
+
+    @Test
+    fun `value field name clash`() {
+        @Language("json")
+        val json = """[
+                {"a":"text", "c": 1},
+                {"a":{"b":2,"value":1.0, "array": null, "array1":12}},
+                {"a":[6,7,8]},
+                null
+            ]
+        """.trimIndent()
+        val df = DataFrame.readJsonStr(json)
+            .alsoDebug()
+        df.columnsCount() shouldBe 2
+        df.rowsCount() shouldBe 4
+        df["c"].type() shouldBe typeOf<Int?>()
+        val group = df["a"] as ColumnGroup<*>
+        group.columnsCount() shouldBe 6
+        group["b"].type() shouldBe typeOf<Int?>()
+        group["value"].type() shouldBe typeOf<Double?>()
+        group["value1"].type() shouldBe typeOf<String?>()
+        group["array"].type() shouldBe nothingType(nullable = true)
+
+        val schema = df.schema().toString()
+        schema shouldContain "Nothing?"
+        schema shouldNotContain "Void?"
+
+        group["array1"].type() shouldBe typeOf<Int?>()
+        group["array2"].type() shouldBe typeOf<List<Int>>()
+    }
+
+    @Test
+    fun `value field (no) name clash Any`() {
+        @Language("json")
+        val json = """[
+                {"a":"text", "c": 1},
+                {"a":{"b":2,"value":1.0, "array": null, "array1":12}},
+                {"a":[6,7,8]},
+                null
+            ]
+        """.trimIndent()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS)
+            .alsoDebug()
+        df.columnsCount() shouldBe 2
+        df.rowsCount() shouldBe 4
+        val c = df["c"] as ValueColumn<*>
+        c.type() shouldBe typeOf<Int?>()
+        c[0] shouldBe 1
+        c[1..3].allNulls() shouldBe true
+        val a = df["a"] as ValueColumn<*>
+        a.type() shouldBe typeOf<Any?>()
+        a[0] shouldBe "text"
+        (a[1] as DataRow<*>).let {
+            it.columnsCount() shouldBe 4
+            it["b"] shouldBe 2
+            it["value"] shouldBe 1.0
+            it["array"] shouldBe null
+            it["array1"] shouldBe 12
+        }
+        a[2] shouldBe listOf(6, 7, 8)
+        a[3] shouldBe null
+    }
+
+    @Test
+    fun `objects with null Any`() {
+        @Language("json")
+        val json = """[
+                {"a":{"b":1}},
+                {"a":{"b":2}},
+                {"a":{"b": null}},
+                {"a": {}},
+                {"a": null},
+                {},
+                null
+            ]
+        """.trimIndent()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS)
+            .alsoDebug()
+        df.columnsCount() shouldBe 1
+        df.rowsCount() shouldBe 7
+        val a = df["a"] as ColumnGroup<*>
+        a.columnsCount() shouldBe 1
+        a["b"].let {
+            it.type() shouldBe typeOf<Int?>()
+            it[0] shouldBe 1
+            it[1] shouldBe 2
+            it[2..6].allNulls() shouldBe true
+        }
+    }
+
+    @Test
+    fun `primitive arrays with null Any`() {
+        @Language("json")
+        val json = """[
+                {"a":[1,2,3]},
+                {"a":[null]},
+                {"a":[]},
+                {"a": null},
+                {},
+                null
+            ]
+        """.trimIndent()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS)
+            .alsoDebug()
+        df.columnsCount() shouldBe 1
+        df.rowsCount() shouldBe 6
+        val a = df["a"] as ValueColumn<*>
+        a.type shouldBe typeOf<List<Int?>>()
+        a[0] shouldBe listOf(1, 2, 3)
+        a[1] shouldBe listOf(null)
+        a[2..5].forEach {
+            it shouldBe emptyList<Int?>()
+        }
+    }
+
+    @Test
+    fun `non-primitive arrays with null Any`() {
+        @Language("json")
+        val json = """[
+                {"a":[null, null]},
+                {"a":[{"b" : 1},{"b":  2}]},
+                {"a":[]},
+                {"a": null},
+                {},
+                null
+            ]
+        """.trimIndent()
+        val df = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS)
+            .alsoDebug()
+        df.columnsCount() shouldBe 1
+        df.rowsCount() shouldBe 6
+        val a = df["a"] as FrameColumn<*>
+        a[0].let {
+            it.columnsCount() shouldBe 1
+            it.rowsCount() shouldBe 2
+            it["b"].let {
+                it.type() shouldBe typeOf<Int?>()
+                it[0] shouldBe null
+                it[1] shouldBe null
+            }
+        }
+        a[1].let {
+            it.columnsCount() shouldBe 1
+            it.rowsCount() shouldBe 2
+            it["b"].let {
+                it.type() shouldBe typeOf<Int>()
+                it[0] shouldBe 1
+                it[1] shouldBe 2
+            }
+        }
+        a[2..5].forEach {
+            it.columnsCount() shouldBe 0
+            it.rowsCount() shouldBe 0
+        }
+    }
+
+    @Test
+    fun `Listification test Array Value`() {
+        @Language("json")
+        val json = """[
+                {"a":[1,2,3]},
+                {"a":null},
+                {"a":1}
+            ]
+        """.trimIndent()
+        val df = DataFrame.readJsonStr(
+            text = json,
+            typeClashTactic = ARRAY_AND_VALUE_COLUMNS,
+            keyValuePaths = listOf(JsonPath()),
+        )
+            .alsoDebug()
+    }
+
+    @Test
+    fun `Listification test Any column`() {
+        @Language("json")
+        val json = """[
+                {"a":[1,2,3]},
+                {"a":null},
+                {"a":1}
+            ]
+        """.trimIndent()
+        val df = DataFrame.readJsonStr(
+            text = json,
+            typeClashTactic = ANY_COLUMNS,
+            keyValuePaths = listOf(JsonPath()),
+        )
+            .alsoDebug()
+    }
+
+    @Test
+    fun `KeyValue property Array Value`() {
+        @Language("json")
+        val json = """[
+                {"a":{"b":1}},
+                {"a":{"c": 2, "d": null, "b":[1, 2, 3]}},
+                {"a":{}},
+                {"a": null},
+                {},
+                null
+            ]
+        """.trimIndent()
+
+        // before
+        val noKeyValue = DataFrame.readJsonStr(json, typeClashTactic = ARRAY_AND_VALUE_COLUMNS)
+            .alsoDebug()
+
+//        ⌌-------------------------------------------------------⌍
+//        |  | a:{b:{value:Int?, array:List<Int>}, c:Int?, d:Any?}|
+//        |--|----------------------------------------------------|
+//        | 0|         { b:{ value:1, array:[] }, c:null, d:null }|
+//        | 1|  { b:{ value:null, array:[1, 2, 3] }, c:2, d:null }|
+//        | 2|      { b:{ value:null, array:[] }, c:null, d:null }|
+//        | 3|      { b:{ value:null, array:[] }, c:null, d:null }|
+//        | 4|      { b:{ value:null, array:[] }, c:null, d:null }|
+//        | 5|      { b:{ value:null, array:[] }, c:null, d:null }|
+//        ⌎-------------------------------------------------------⌏
+        noKeyValue.columnsCount() shouldBe 1
+        noKeyValue.rowsCount() shouldBe 6
+        noKeyValue["a"].also {
+            it shouldBe instanceOf<ColumnGroup<*>>()
+            it as ColumnGroup<*>
+
+            it["b"].type() shouldBe typeOf<DataRow<*>>()
+            it["b"]["value"].type() shouldBe typeOf<Int?>()
+            it["b"]["array"].type() shouldBe typeOf<List<Int>>()
+            it["c"].type() shouldBe typeOf<Int?>()
+            it["d"].type() shouldBe nothingType(nullable = true)
+
+            it[0].let {
+                (it["b"] as DataRow<*>).toMap() shouldBe mapOf("value" to 1, "array" to emptyList<Int>())
+                it["c"] shouldBe null
+                it["d"] shouldBe null
+            }
+            it[1].let {
+                (it["b"] as DataRow<*>).toMap() shouldBe mapOf("value" to null, "array" to listOf(1, 2, 3))
+                it["c"] shouldBe 2
+                it["d"] shouldBe null
+            }
+            (it as ColumnGroup<*>)[2..5].forEach {
+                it.let {
+                    (it["b"] as DataRow<*>).toMap() shouldBe mapOf("value" to null, "array" to emptyList<Int>())
+                    it["c"] shouldBe null
+                    it["d"] shouldBe null
+                }
+            }
+        }
+
+        // $["a"] should be read as keyValue
+        val keyValuePaths = listOf(
+            JsonPath().append("a")
+        )
+
+        // after
+        val withKeyValue =
+            DataFrame.readJsonStr(json, keyValuePaths = keyValuePaths, typeClashTactic = ARRAY_AND_VALUE_COLUMNS)
+                .alsoDebug()
+                .also {
+                    it["a"][1].let { it as AnyFrame }.alsoDebug()
+                }
+//        ⌌------------------------------⌍
+//        |  | a:[key:String, value:Any?]|
+//        |--|---------------------------|
+//        | 0| [1 x 2] { key:b, value:1 }|
+//        | 1|                    [3 x 2]| ->  { key:c, value:2 }
+//        | 2|                    [0 x 2]|     { key:d, value:null }
+//        | 3|                    [0 x 2]|     { key:b, value:[1,2,3] }
+//        | 4|                    [0 x 2]|
+//        | 5|                    [0 x 2]|
+//        ⌎------------------------------⌏
+
+        withKeyValue.columnsCount() shouldBe 1
+        withKeyValue.rowsCount() shouldBe 6
+        withKeyValue["a"].also {
+            it shouldBe instanceOf<FrameColumn<*>>()
+            it as FrameColumn<*>
+
+            it[0].let {
+                it.columnsCount() shouldBe 2
+                it.rowsCount() shouldBe 1
+                it["key"].let {
+                    it.type() shouldBe typeOf<String>()
+                    it[0] shouldBe "b"
+                }
+                it["value"].let {
+                    it.type() shouldBe typeOf<Int>() // tightened by values, but Int? is also valid of course
+                    it[0] shouldBe 1
+                }
+            }
+            it[1].let {
+                it.columnsCount() shouldBe 2
+                it.rowsCount() shouldBe 3
+                it["key"].let {
+                    it.type() shouldBe typeOf<String>()
+                    it[0] shouldBe "c"
+                    it[1] shouldBe "d"
+                }
+                it["value"].let {
+                    it.type() shouldBe typeOf<Any?>()
+                    it[0] shouldBe 2
+                    it[1] shouldBe null
+                }
+            }
+            it[2..5].forEach {
+                it.columnsCount() shouldBe 2
+                it.rowsCount() shouldBe 0
+
+                it["key"].type() shouldBe typeOf<String>()
+                it["value"].type() shouldBeIn listOf(typeOf<Any?>(), typeOf<Any>()) // no data, so Any(?) ValueColumn
+            }
+        }
+    }
+
+    @Test
+    fun `KeyValue property Any`() { // TODO needs more tests
+        @Language("json")
+        val json = """[
+                {"a":{"b": 1}},
+                {"a":{"c": 2, "d": null, "b":[1, 2, 3]}},
+                {"a":{}},
+                {"a": null},
+                {},
+                null
+            ]
+        """.trimIndent()
+
+        // before
+        val noKeyValue = DataFrame.readJsonStr(json, typeClashTactic = ANY_COLUMNS)
+            .alsoDebug()
+
+//        ⌌------------------------------⌍
+//        |  | a:{b:Any?, c:Int?, d:Any?}|
+//        |--|---------------------------|
+//        | 0|                    { b:1 }|
+//        | 1|{ b:[1,2,3], c:2, d: null }|
+//        | 2|                        { }|
+//        | 3|                        { }|
+//        | 4|                        { }|
+//        | 5|                        { }|
+//        ⌎------------------------------⌏
+        noKeyValue.columnsCount() shouldBe 1
+        noKeyValue.rowsCount() shouldBe 6
+        noKeyValue["a"].also {
+            it shouldBe instanceOf<ColumnGroup<*>>()
+            it as ColumnGroup<*>
+
+            it["b"].type() shouldBe typeOf<Any?>()
+            it["c"].type() shouldBe typeOf<Int?>()
+            it["d"].type() shouldBe typeOf<Any?>()
+
+            it[0].toMap() shouldBe mapOf("b" to 1, "c" to null, "d" to null)
+            it[1].toMap() shouldBe mapOf("b" to listOf(1, 2, 3), "c" to 2, "d" to null)
+            (it as ColumnGroup<*>)[2..5].forEach {
+                it.toMap() shouldBe mapOf("b" to null, "c" to null, "d" to null)
+            }
+        }
+
+        // $["a"] should be read as keyValue
+        val keyValuePaths = listOf(
+            JsonPath().append("a")
+        )
+
+        // after
+        val withKeyValue = DataFrame.readJsonStr(json, keyValuePaths = keyValuePaths, typeClashTactic = ANY_COLUMNS)
+            .alsoDebug()
+            .also {
+                it["a"][1].let { it as AnyFrame }.alsoDebug()
+            }
+
+//        ⌌------------------------------⌍
+//        |  | a:[key:String, value:Any?]|
+//        |--|---------------------------|
+//        | 0| [1 x 2] { key:b, value:1 }|
+//        | 1|                    [3 x 2]| ->  { key:c, value:2 }
+//        | 2|                    [0 x 2]|     { key:d, value:null }
+//        | 3|                    [0 x 2]|     { key:b, value:[1,2,3] }
+//        | 4|                    [0 x 2]|
+//        | 5|                    [0 x 2]|
+//        ⌎------------------------------⌏
+        withKeyValue.columnsCount() shouldBe 1
+        withKeyValue.rowsCount() shouldBe 6
+        withKeyValue["a"].also {
+            it shouldBe instanceOf<FrameColumn<*>>()
+            it as FrameColumn<*>
+
+            it[0].let {
+                it.columnsCount() shouldBe 2
+                it.rowsCount() shouldBe 1
+                it["key"].let {
+                    it.type() shouldBe typeOf<String>()
+                    it[0] shouldBe "b"
+                }
+                it["value"].let {
+                    it.type() shouldBe typeOf<Int>() // tightened by values, but Int? is also valid of course
+                    it[0] shouldBe 1
+                }
+            }
+            it[1].let {
+                it.columnsCount() shouldBe 2
+                it.rowsCount() shouldBe 3
+                it["key"].let {
+                    it.type() shouldBe typeOf<String>()
+                    it[0] shouldBe "c"
+                    it[1] shouldBe "d"
+                }
+                it["value"].let {
+                    it.type() shouldBe typeOf<Any?>()
+                    it[0] shouldBe 2
+                    it[1] shouldBe null
+                    it[2] shouldBe listOf(1, 2, 3)
+                }
+            }
+            it[2..5].forEach {
+                it.columnsCount() shouldBe 2
+                it.rowsCount() shouldBe 0
+
+                it["key"].type() shouldBe typeOf<String>()
+                it["value"].type() shouldBeIn listOf(typeOf<Any?>(), typeOf<Any>()) // no data, so Any(?) ValueColumn
+            }
+        }
+    }
+
+    @Test
+    fun `nulls in columns should be encoded explicitly`() {
+        val df = dataFrameOf("a", "b")("1", null, "2", 12)
+        df.toJson(canonical = true) shouldContain "\"b\":null"
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/CodeGenerationTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/CodeGenerationTests.kt
new file mode 100644
index 000000000..33c4b9e6e
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/CodeGenerationTests.kt
@@ -0,0 +1,40 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.kotlinx.jupyter.api.Code
+import org.junit.Test
+
+class CodeGenerationTests : DataFrameJupyterTest() {
+
+    private fun Code.checkCompilation() {
+        lines().forEach {
+            exec(it)
+        }
+    }
+
+    @Test
+    fun `nullable dataframe`() {
+        """
+            fun create(): AnyFrame? = dataFrameOf("a")(1)
+            val df = create()
+            df.a
+        """.checkCompilation()
+    }
+
+    @Test
+    fun `nullable columnGroup`() {
+        """
+            fun create(): AnyCol? = dataFrameOf("a")(1).asColumnGroup().asDataColumn()
+            val col = create()
+            col.a
+        """.checkCompilation()
+    }
+
+    @Test
+    fun `nullable dataRow`() {
+        """
+            fun create(): AnyRow? = dataFrameOf("a")(1).single()
+            val row = create()
+            row.a
+        """.checkCompilation()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/DataFrameJupyterTest.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/DataFrameJupyterTest.kt
new file mode 100644
index 000000000..f56be9591
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/DataFrameJupyterTest.kt
@@ -0,0 +1,51 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.jupyter.parser.notebook.Cell
+import org.jetbrains.kotlinx.jupyter.testkit.JupyterReplTestCase
+import org.jetbrains.kotlinx.jupyter.testkit.ReplProvider
+
+abstract class DataFrameJupyterTest : JupyterReplTestCase(
+    ReplProvider.forLibrariesTesting(listOf("dataframe"))
+)
+
+fun interface CodeReplacer {
+    fun replace(code: String): String
+
+    companion object {
+        val DEFAULT = CodeReplacer { it }
+
+        fun byMap(replacements: Map<String, String>) = CodeReplacer { code ->
+            replacements.entries.fold(code) { acc, (key, replacement) ->
+                acc.replace(key, replacement)
+            }
+        }
+
+        fun byMap(vararg replacements: Pair<String, String>): CodeReplacer = byMap(mapOf(*replacements))
+    }
+}
+
+fun interface CellClause {
+    fun isAccepted(cell: Cell): Boolean
+
+    companion object {
+        val IS_CODE = CellClause { it.type == Cell.Type.CODE }
+    }
+}
+
+infix fun CellClause.and(other: CellClause): CellClause {
+    return CellClause { cell ->
+        // Prevent lazy evaluation
+        val acceptedThis = this.isAccepted(cell)
+        val acceptedOther = other.isAccepted(cell)
+        acceptedThis && acceptedOther
+    }
+}
+
+fun CellClause.Companion.stopAfter(breakClause: CellClause) = object : CellClause {
+    var clauseTriggered: Boolean = false
+
+    override fun isAccepted(cell: Cell): Boolean {
+        clauseTriggered = clauseTriggered || breakClause.isAccepted(cell)
+        return !clauseTriggered
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterCodegenTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterCodegenTests.kt
new file mode 100644
index 000000000..1280f1191
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterCodegenTests.kt
@@ -0,0 +1,317 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import io.kotest.assertions.throwables.shouldNotThrowAny
+import io.kotest.matchers.should
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.types.shouldBeInstanceOf
+import org.intellij.lang.annotations.Language
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.api.isNotEmpty
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.type
+import org.jetbrains.kotlinx.jupyter.api.MimeTypedResult
+import org.jetbrains.kotlinx.jupyter.testkit.JupyterReplTestCase
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class JupyterCodegenTests : JupyterReplTestCase() {
+
+    @Test
+    fun `codegen adding column with generic type function`() {
+        @Language("kts")
+        val res1 = exec(
+            """
+            fun <T> AnyFrame.addValue(value: T) = add("value") { listOf(value) }
+            val df = dataFrameOf("a")(1).addValue(2)
+            """.trimIndent()
+        )
+        res1 shouldBe Unit
+        val res2 = execRaw("df") as AnyFrame
+
+        res2["value"].type shouldBe typeOf<List<Any?>>()
+    }
+
+    @Test
+    fun `Don't inherit from data class`() {
+        @Language("kts")
+        val res1 = exec(
+            """
+            @DataSchema
+            data class A(val a: Int)
+            """.trimIndent()
+        )
+
+        @Language("kts")
+        val res2 = execRaw(
+            """
+            val df = dataFrameOf("a", "b")(1, 2)
+            df
+            """.trimIndent()
+        )
+
+        (res2 as AnyFrame).should { it.isNotEmpty() }
+    }
+
+    @Test
+    fun `Don't inherit from non open class`() {
+        @Language("kts")
+        val res1 = exec(
+            """
+            @DataSchema
+            class A(val a: Int)
+            """.trimIndent()
+        )
+
+        @Language("kts")
+        val res2 = execRaw(
+            """
+            val df = dataFrameOf("a", "b")(1, 2)
+            df
+            """.trimIndent()
+        )
+
+        (res2 as AnyFrame).should { it.isNotEmpty() }
+    }
+
+    @Test
+    fun `Don't inherit from open class`() {
+        @Language("kts")
+        val res1 = exec(
+            """
+            @DataSchema
+            open class A(val a: Int)
+            """.trimIndent()
+        )
+
+        @Language("kts")
+        val res2 = execRaw(
+            """
+            val df = dataFrameOf("a", "b")(1, 2)
+            df
+            """.trimIndent()
+        )
+
+        (res2 as AnyFrame).should { it.isNotEmpty() }
+    }
+
+    @Test
+    fun `Do inherit from open interface`() {
+        @Language("kts")
+        val res1 = exec(
+            """
+            @DataSchema
+            interface A { val a: Int }
+            """.trimIndent()
+        )
+
+        @Language("kts")
+        val res2 = execRaw(
+            """
+            val df = dataFrameOf("a", "b")(1, 2)
+            df
+            """.trimIndent()
+        )
+
+        (res2 as AnyFrame).should { it.isNotEmpty() }
+    }
+
+    @Test
+    fun `codegen for enumerated frames`() {
+        @Language("kts")
+        val res1 = exec(
+            """
+            val names = (0..2).map { it.toString() }
+            val df = dataFrameOf(names)(1, 2, 3)
+            """.trimIndent()
+        )
+        res1 shouldBe Unit
+
+        val res2 = execRaw("df.`1`")
+        res2.shouldBeInstanceOf<ValueColumn<*>>()
+    }
+
+    @Test
+    fun `codegen for complex column names`() {
+        @Language("kts")
+        val res1 = exec(
+            """
+            val df = DataFrame.readDelimStr("[a], (b), {c}\n1, 2, 3")
+            df
+            """.trimIndent()
+        )
+        res1.shouldBeInstanceOf<MimeTypedResult>()
+
+        val res2 = exec(
+            """listOf(df.`{a}`[0], df.`(b)`[0], df.`{c}`[0])"""
+        )
+        res2 shouldBe listOf(1, 2, 3)
+    }
+
+    @Test
+    fun `codegen for '$' that is interpolator in kotlin string literals`() {
+        @Language("kts")
+        val res1 = exec(
+            """
+            val df = DataFrame.readDelimStr("\${'$'}id\n1")
+            df
+            """.trimIndent()
+        )
+        res1.shouldBeInstanceOf<MimeTypedResult>()
+        val res2 = exec(
+            "listOf(df.`\$id`[0])"
+        )
+        res2 shouldBe listOf(1)
+    }
+
+    @Test
+    fun `codegen for backtick that is forbidden in kotlin identifiers`() {
+        @Language("kts")
+        val res1 = exec(
+            """
+            val df = DataFrame.readDelimStr("Day`s\n1")
+            df
+            """.trimIndent()
+        )
+        res1.shouldBeInstanceOf<MimeTypedResult>()
+        println(res1.entries.joinToString())
+        val res2 = exec(
+            "listOf(df.`Day's`[0])"
+        )
+        res2 shouldBe listOf(1)
+    }
+
+    @Test
+    fun `codegen for chars that is forbidden in JVM identifiers`() {
+        val forbiddenChar = ";"
+
+        @Language("kts")
+        val res1 = exec(
+            """
+            val df = DataFrame.readDelimStr("Test$forbiddenChar\n1")
+            df
+            """.trimIndent()
+        )
+        res1.shouldBeInstanceOf<MimeTypedResult>()
+        println(res1.entries.joinToString())
+        val res2 = exec(
+            "listOf(df.`Test `[0])"
+        )
+        res2 shouldBe listOf(1)
+    }
+
+    @Test
+    fun `codegen for chars that is forbidden in JVM identifiers 1`() {
+        val forbiddenChar = "\\\\"
+
+        @Language("kts")
+        val res1 = exec(
+            """
+            val df = DataFrame.readDelimStr("Test$forbiddenChar\n1")
+            df
+            """.trimIndent()
+        )
+        res1.shouldBeInstanceOf<MimeTypedResult>()
+        println(res1.entries.joinToString())
+        val res2 = exec(
+            "listOf(df.`Test `[0])"
+        )
+        res2 shouldBe listOf(1)
+    }
+
+    @Test
+    fun `generic interface`() {
+        val res1 = exec(
+            """
+            @DataSchema
+            interface Generic<T> {
+                val field: T
+            }
+            """.trimIndent()
+        )
+        res1.shouldBeInstanceOf<Unit>()
+        val res2 = exec(
+            """
+                val <T> ColumnsContainer<Generic<T>>.test1: DataColumn<T> get() = field
+                val <T> DataRow<Generic<T>>.test2: T get() = field
+            """.trimIndent()
+        )
+        res2.shouldBeInstanceOf<Unit>()
+    }
+
+    @Test
+    fun `generic interface with upper bound`() {
+        val res1 = exec(
+            """
+                @DataSchema
+                interface Generic <T : String> {
+                    val field: T
+                }
+            """.trimIndent()
+        )
+        res1.shouldBeInstanceOf<Unit>()
+        val res2 = exec(
+            """
+                val <T : String> ColumnsContainer<Generic<T>>.test1: DataColumn<T> get() = field
+                val <T : String> DataRow<Generic<T>>.test2: T get() = field
+            """.trimIndent()
+        )
+        res2.shouldBeInstanceOf<Unit>()
+    }
+
+    @Test
+    fun `generic interface with variance and user type in type parameters`() {
+        val res1 = exec(
+            """
+                interface UpperBound
+
+                @DataSchema(isOpen = false)
+                interface Generic <out T : UpperBound> {
+                    val field: T
+                }
+            """.trimIndent()
+        )
+        res1.shouldBeInstanceOf<Unit>()
+        val res2 = exec(
+            """
+                val <T : UpperBound> ColumnsContainer<Generic<T>>.test1: DataColumn<T> get() = field
+                val <T : UpperBound> DataRow<Generic<T>>.test2: T get() = field
+            """.trimIndent()
+        )
+        res2.shouldBeInstanceOf<Unit>()
+    }
+
+    @Test
+    fun `generate a new marker when dataframe marker is not a data schema so that columns are accessible with extensions`() {
+        exec(
+            """
+            enum class State {
+                Idle, Productive, Maintenance
+            }
+
+            class Event(val toolId: String, val state: State, val timestamp: Long)
+
+            val tool1 = "tool_1"
+            val tool2 = "tool_2"
+            val tool3 = "tool_3"
+            val events = listOf(
+                Event(tool1, State.Idle, 0),
+                Event(tool1, State.Productive, 5),
+                Event(tool2, State.Idle, 0),
+                Event(tool2, State.Maintenance, 10),
+                Event(tool2, State.Idle, 20),
+                Event(tool3, State.Idle, 0),
+                Event(tool3, State.Productive, 25),
+            ).toDataFrame()
+            """.trimIndent()
+        )
+        shouldNotThrowAny {
+            exec(
+                """
+                events.toolId
+                events.state
+                events.timestamp
+                """.trimIndent()
+            )
+        }
+    }
+}
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
new file mode 100644
index 000000000..11be55cb9
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/RenderingTests.kt
@@ -0,0 +1,128 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import com.beust.klaxon.*
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.string.shouldContain
+import io.kotest.matchers.string.shouldNotContain
+import org.intellij.lang.annotations.Language
+import org.jetbrains.kotlinx.jupyter.api.MimeTypedResult
+import org.jetbrains.kotlinx.jupyter.testkit.JupyterReplTestCase
+import org.junit.Test
+
+class RenderingTests : JupyterReplTestCase() {
+    @Test
+    fun `dataframe is rendered to html`() {
+        @Language("kts")
+        val html = execHtml(
+            """
+            val name by column<String>()
+            val height by column<Int>()
+            val df = dataFrameOf(name, height)(
+                "Bill", 135,
+                "Charlie", 160
+            )
+            df
+            """.trimIndent()
+        )
+        html shouldContain "Bill"
+
+        @Language("kts")
+        val useRes = exec(
+            """
+            USE {
+                render<Int> { (it * 2).toString() }
+            }
+            """.trimIndent()
+        )
+        useRes shouldBe Unit
+
+        val html2 = execHtml("df")
+        html2 shouldContain (135 * 2).toString()
+        html2 shouldContain (160 * 2).toString()
+    }
+
+    @Test
+    fun `rendering options`() {
+        @Language("kts")
+        val html1 = execHtml(
+            """
+            data class Person(val age: Int, val name: String)
+            val df = (1..70).map { Person(it, "A".repeat(it)) }.toDataFrame()
+            df
+            """.trimIndent()
+        )
+        html1 shouldContain "showing only top 20 of 70 rows"
+
+        @Language("kts")
+        val html2 = execHtml(
+            """
+            dataFrameConfig.display.rowsLimit = 50
+            df
+            """.trimIndent()
+        )
+        html2 shouldContain "showing only top 50 of 70 rows"
+    }
+
+    @Test
+    fun `dark color scheme`() {
+        fun execSimpleDf() = execHtml("""dataFrameOf("a", "b")(1, 2, 3, 4)""")
+
+        val htmlLight = execSimpleDf()
+        val r1 = exec("notebook.changeColorScheme(ColorScheme.DARK); 1")
+        val htmlDark = execSimpleDf()
+
+        r1 shouldBe 1
+        val darkClassAttribute = """theme='dark'"""
+        htmlLight shouldNotContain darkClassAttribute
+        htmlDark shouldContain darkClassAttribute
+    }
+
+    @Test
+    fun `test kotlin notebook plugin utils rows subset`() {
+        @Language("kts")
+        val result = exec<MimeTypedResult>(
+            """
+            data class Row(val id: Int)
+            val df = (1..100).map { Row(it) }.toDataFrame()
+            KotlinNotebookPluginUtils.getRowsSubsetForRendering(df, 20 , 50)
+            """.trimIndent()
+        )
+
+        val json = parseDataframeJson(result)
+
+        json.int("nrow") shouldBe 30
+        json.int("ncol") shouldBe 1
+
+        val rows = json.array<JsonArray<*>>("kotlin_dataframe")!!
+        rows.getObj(0).int("id") shouldBe 21
+        rows.getObj(rows.lastIndex).int("id") shouldBe 50
+    }
+
+    private fun parseDataframeJson(result: MimeTypedResult): JsonObject {
+        val parser = Parser.default()
+        return parser.parse(StringBuilder(result["application/kotlindataframe+json"]!!)) as JsonObject
+    }
+
+    private fun JsonArray<*>.getObj(index: Int) = this.get(index) as JsonObject
+
+    @Test
+    fun `test kotlin notebook plugin utils groupby`() {
+        @Language("kts")
+        val result = exec<MimeTypedResult>(
+            """
+            data class Row(val id: Int, val group: Int)
+            val df = (1..100).map { Row(it, if (it <= 50) 1 else 2) }.toDataFrame()
+            KotlinNotebookPluginUtils.getRowsSubsetForRendering(df.groupBy("group"), 0, 10)
+            """.trimIndent()
+        )
+
+        val json = parseDataframeJson(result)
+
+        json.int("nrow") shouldBe 2
+        json.int("ncol") shouldBe 2
+
+        val rows = json.array<JsonArray<*>>("kotlin_dataframe")!!
+        rows.getObj(0).array<JsonObject>("group1")!!.size shouldBe 50
+        rows.getObj(1).array<JsonObject>("group1")!!.size shouldBe 50
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/ResourcesTest.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/ResourcesTest.kt
new file mode 100644
index 000000000..36077d14b
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/ResourcesTest.kt
@@ -0,0 +1,17 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import io.kotest.matchers.shouldNotBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.junit.Test
+import java.io.InputStreamReader
+
+class ResourcesTest {
+
+    @Test
+    fun `resources available`() {
+        val res = DataFrame::class.java.getResourceAsStream("/table.html")
+        println(InputStreamReader(res).readText())
+
+        res shouldNotBe null
+    }
+}
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
new file mode 100644
index 000000000..8a091f0b1
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
@@ -0,0 +1,126 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.jupyter.parser.JupyterParser
+import org.jetbrains.jupyter.parser.notebook.CodeCell
+import org.jetbrains.jupyter.parser.notebook.Output
+import org.junit.Ignore
+import org.junit.Test
+import java.io.File
+import java.util.Locale
+
+class SampleNotebooksTests : DataFrameJupyterTest() {
+    @Test
+    fun puzzles() = exampleTest("puzzles", "40 puzzles")
+
+    @Test
+    fun github() = exampleTest(
+        "github",
+        cellClause = CellClause.stopAfter { cell ->
+            "personal access token" in cell.source
+        },
+        cleanup = {
+            File("jetbrains.json").delete()
+        }
+    )
+
+    @Test
+    fun titanic() = exampleTest(
+        "titanic", "Titanic",
+        replacer = CodeReplacer.byMap(
+            "../../idea-examples/" to "$ideaExamplesPath/"
+        )
+    )
+
+    @Test
+    @Ignore
+    fun wine() = exampleTest(
+        "wine", "WineNetWIthKotlinDL",
+        replacer = CodeReplacer.byMap(
+            testFile("wine", "winequality-red.csv")
+        )
+    )
+
+    @Test
+    @Ignore
+    fun netflix() {
+        val currentLocale = Locale.getDefault()
+        try {
+            // Set explicit locale as of test data contains locale-dependent values (date for parsing)
+            Locale.setDefault(Locale.forLanguageTag("en-US"))
+
+            exampleTest(
+                "netflix",
+                replacer = CodeReplacer.byMap(
+                    testFile("netflix", "country_codes.csv"),
+                    testFile("netflix", "netflix_titles.csv"),
+                )
+            )
+        } finally {
+            Locale.setDefault(currentLocale)
+        }
+    }
+
+    @Test
+    @Ignore
+    fun movies() = exampleTest(
+        "movies",
+        replacer = CodeReplacer.byMap(
+            "ml-latest/movies.csv" to "$ideaExamplesPath/movies/src/main/resources/movies.csv"
+        ),
+        // There is no tags data in repository
+        cellClause = CellClause.stopAfter { cell ->
+            "tags.csv" in cell.source
+        }
+    )
+
+    private fun doTest(
+        notebookPath: String,
+        replacer: CodeReplacer,
+        cellClause: CellClause,
+        cleanup: () -> Unit = {},
+    ) {
+        val notebookFile = File(notebookPath)
+        val notebook = JupyterParser.parse(notebookFile)
+        val finalClause = cellClause and CellClause.IS_CODE
+
+        val codeCellsData = notebook.cells
+            .filter { finalClause.isAccepted(it) }
+            .map { CodeCellData(it.source, (it as? CodeCell)?.outputs.orEmpty()) }
+
+        try {
+            for (codeCellData in codeCellsData) {
+                val code = codeCellData.code
+                val codeToExecute = replacer.replace(code)
+
+                println("Executing code:\n$codeToExecute")
+                val cellResult = exec(codeToExecute)
+                println(cellResult)
+            }
+        } finally {
+            cleanup()
+        }
+    }
+
+    private fun exampleTest(
+        dir: String,
+        notebookName: String? = null,
+        replacer: CodeReplacer = CodeReplacer.DEFAULT,
+        cellClause: CellClause = CellClause { true },
+        cleanup: () -> Unit = {},
+    ) {
+        val fileName = if (notebookName == null) "$dir.ipynb" else "$notebookName.ipynb"
+        doTest("$jupyterExamplesPath/$dir/$fileName", replacer, cellClause, cleanup)
+    }
+
+    data class CodeCellData(
+        val code: String,
+        val outputs: List<Output>,
+    )
+
+    companion object {
+        const val ideaExamplesPath = "../examples/idea-examples"
+        const val jupyterExamplesPath = "../examples/jupyter-notebooks"
+
+        fun testFile(folder: String, fileName: String) = fileName to "$jupyterExamplesPath/$folder/$fileName"
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/BasicTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/BasicTests.kt
new file mode 100644
index 000000000..18f13ec75
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/BasicTests.kt
@@ -0,0 +1,206 @@
+package org.jetbrains.kotlinx.dataframe.puzzles
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.junit.Test
+import java.text.DecimalFormatSymbols
+import kotlin.reflect.typeOf
+
+class BasicTests {
+
+    private val animal by columnOf("cat", "cat", "snake", "dog", "dog", "cat", "snake", "cat", "dog", "dog")
+    private val age by columnOf(2.5, 3.0, 0.5, Double.NaN, 5.0, 2.0, 4.5, Double.NaN, 7.0, 3.0)
+    private val visits by columnOf(1, 3, 2, 3, 2, 3, 1, 1, 2, 1)
+    private val priority by columnOf("yes", "yes", "no", "yes", "no", "no", "no", "yes", "no", "no")
+
+    private val df = dataFrameOf(animal, age, visits, priority)
+
+    @Test
+    fun `return first 3 rows`() {
+        val expected = dataFrameOf("animal", "age", "visits", "priority")(
+            "cat", 2.5, 1, "yes",
+            "cat", 3.0, 3, "yes",
+            "snake", 0.5, 2, "no"
+        )
+
+        df[0 until 3] shouldBe expected
+        df.head(3) shouldBe expected
+        df.take(3) shouldBe expected
+    }
+
+    @Test
+    fun `select animal and age columns from df`() {
+        val expected = dataFrameOf(animal, age)
+
+        df[animal, age] shouldBe expected
+        df["animal", "age"] shouldBe expected
+        df.select { animal and age } shouldBe expected
+        df.select { "animal" and "age" } shouldBe expected
+    }
+
+    @Test
+    fun `select rows (3, 4, 8) and columns (animal, age)`() {
+        val expected = dataFrameOf("animal", "age")(
+            "dog", Double.NaN,
+            "dog", 5.0,
+            "dog", 7.0
+        )
+
+        df[3, 4, 8][animal, age] shouldBe expected
+        df[3, 4, 8]["animal", "age"] shouldBe expected
+        df.select { animal and age }[3, 4, 8] shouldBe expected
+        df.select { "animal" and "age" }[3, 4, 8] shouldBe expected
+    }
+
+    @Test
+    fun `select only rows where number of visits is grater than 2`() {
+        val expected = dataFrameOf("animal", "age", "visits", "priority")(
+            "cat", 3.0, 3, "yes",
+            "dog", Double.NaN, 3, "yes",
+            "cat", 2.0, 3, "no"
+        )
+
+        df.filter { visits > 2 } shouldBe expected
+        df.filter { "visits"<Int>() > 2 } shouldBe expected
+    }
+
+    @Test
+    fun `select rows where age is missing`() {
+        val expected = dataFrameOf("animal", "age", "visits", "priority")(
+            "dog", Double.NaN, 3, "yes",
+            "cat", Double.NaN, 1, "yes"
+        )
+
+        df.filter { age().isNaN() } shouldBe expected
+        df.filter { "age"<Double>().isNaN() } shouldBe expected
+    }
+
+    @Test
+    fun `select rows where animal is a cat and age is less than 3`() {
+        val expected = dataFrameOf("animal", "age", "visits", "priority")(
+            "cat", 2.5, 1, "yes",
+            "cat", 2.0, 3, "no"
+        )
+
+        df.filter { animal() == "cat" && age() < 3 } shouldBe expected
+        df.filter { "animal"<String>() == "cat" && "age"<Double>() < 3 } shouldBe expected
+    }
+
+    @Test
+    fun `select rows where age is between 2 and 4 (inclusive)`() {
+        val expected = dataFrameOf("animal", "age", "visits", "priority")(
+            "cat", 2.5, 1, "yes",
+            "cat", 3.0, 3, "yes",
+            "cat", 2.0, 3, "no",
+            "dog", 3.0, 1, "no"
+        )
+
+        df.filter { age() in 2.0..4.0 } shouldBe expected
+        df.filter { "age"() in 2.0..4.0 } shouldBe expected
+    }
+
+    @Test
+    fun `change age in row 5 to 1,5`() {
+        val dfActualAcc0 = df.update { age }.at(5).with { 1.5 }
+        val dfActualAcc1 = df.update { "age"<Double>() }.at(5).with { 1.5 }
+
+        dfActualAcc0[5][age] shouldBe 1.5
+        dfActualAcc1[5]["age"] shouldBe 1.5
+    }
+
+    @Test
+    fun `calculate sum of all visits`() {
+        df[visits].sum() shouldBe 19
+        df.sum { visits } shouldBe 19
+
+        df["visits"].cast<Int>().sum() shouldBe 19
+        df.sum { "visits"<Int>() } shouldBe 19
+        df.sum("visits") shouldBe 19
+    }
+
+    @Test
+    fun `calculate mean age for each animal`() {
+        val expected = dataFrameOf("animal", "age")(
+            "cat", Double.NaN,
+            "snake", 2.5,
+            "dog", Double.NaN
+        )
+
+        df.groupBy { animal }.mean { age } shouldBe expected
+        df.groupBy("animal").mean("age") shouldBe expected
+    }
+
+    @Test
+    fun `append and drop new row`() {
+        val modifiedDf = df.append("dog", 5.5, 2, "no")
+
+        val d = DecimalFormatSymbols.getInstance().decimalSeparator
+        modifiedDf[10].toString() shouldBe "{ animal:dog, age:5${d}500000, visits:2, priority:no }"
+
+        modifiedDf.dropLast() shouldBe df
+    }
+
+    @Test
+    fun `count number of each type of animal`() {
+        val expected = dataFrameOf("animal", "count")(
+            "cat", 4,
+            "snake", 2,
+            "dog", 4,
+        )
+
+        df.groupBy { animal }.count() shouldBe expected
+        df.groupBy("animal").count() shouldBe expected
+    }
+
+    @Test
+    fun `sort df first by the values in age in descending order, then by in visit in ascending order`() {
+        val expected = dataFrameOf("age", "visits")(4.5, 1, 3.0, 1, 3.0, 3)
+
+        val sortDfAcc = df.sortBy { age.desc() and visits }
+        val sortDfStr = df.sortBy { "age".desc() and "visits" }
+
+        sortDfAcc[age, visits][4..6] shouldBe expected
+        sortDfStr["age", "visits"][4..6] shouldBe expected
+    }
+
+    @Test
+    fun `replace priority column to boolean values`() {
+        val convertedDfAcc = df.convert { priority }.with { it == "yes" }
+        val convertedDfStr = df.convert { "priority"<String>() }.with { it == "yes" }
+
+        convertedDfAcc[priority].type() shouldBe typeOf<Boolean>()
+        convertedDfAcc["priority"].type() shouldBe typeOf<Boolean>()
+
+        convertedDfStr[priority][5] shouldBe false
+        convertedDfStr["priority"][5] shouldBe false
+    }
+
+    @Test
+    fun `change dog to corgi`() {
+        val updatedDfAcc = df.update { animal }.where { it == "dog" }.with { "corgi" }
+        val updatedDfStr = df.update("animal").where { it == "dog" }.with { "corgi" }
+
+        updatedDfAcc[animal][3] shouldBe "corgi"
+        updatedDfAcc[animal][8] shouldBe "corgi"
+
+        updatedDfStr["animal"][3] shouldBe "corgi"
+        updatedDfStr["animal"][8] shouldBe "corgi"
+    }
+
+    @Test
+    fun `find mean age for each animal type and number of visits`() {
+        val expected = dataFrameOf("animal", "1", "3", "2")(
+            "cat", 2.5, 2.5, null,
+            "snake", 4.5, null, 0.5,
+            "dog", 3.0, Double.NaN, 6.0
+        )
+
+        val actualDfAcc = df.pivot(inward = false) { visits }.groupBy { animal }.mean(skipNA = true) { age }
+        val actualDfStr = df.pivot("visits", inward = false).groupBy("animal").mean("age", skipNA = true)
+
+        actualDfAcc shouldBe expected
+        actualDfStr shouldBe expected
+    }
+}
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
new file mode 100644
index 000000000..7a159f5de
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/CleaningDataTests.kt
@@ -0,0 +1,120 @@
+package org.jetbrains.kotlinx.dataframe.puzzles
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.junit.Test
+
+class CleaningDataTests {
+
+    private val fromTo = listOf(
+        "LoNDon_paris",
+        "MAdrid_miLAN",
+        "londON_StockhOlm",
+        "Budapest_PaRis",
+        "Brussels_londOn"
+    ).toColumn("From_To")
+    private val flightNumber = listOf(10045.0, Double.NaN, 10065.0, Double.NaN, 10085.0).toColumn("FlightNumber")
+    private val recentDelays =
+        listOf(listOf(23, 47), listOf(), listOf(24, 43, 87), listOf(13), listOf(67, 32)).toColumn("RecentDelays")
+    private val airline = listOf(
+        "KLM(!)",
+        "{Air France} (12)",
+        "(British Airways. )",
+        "12. Air France",
+        "'Swiss Air'"
+    ).toColumn("Airline")
+
+    private var df = dataFrameOf(fromTo, flightNumber, recentDelays, airline)
+
+    @Test
+    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
+    }
+
+    @Test
+    fun `split From_To`() {
+        val expected = dataFrameOf("From", "To")(
+            "LoNDon", "paris",
+            "MAdrid", "miLAN",
+            "londON", "StockhOlm",
+            "Budapest", "PaRis",
+            "Brussels", "londOn"
+        )
+
+        df.split { fromTo }.by('_').into("From", "To")["From", "To"] shouldBe expected
+        df.split { "From_To"<String>() }.by('_').into("From", "To")["From", "To"] shouldBe expected
+    }
+
+    @Test
+    fun `uppercase for cities`() {
+        val from by column<String>("From")
+        val to by column<String>("To")
+
+        val expected = dataFrameOf("From", "To")(
+            "London", "Paris",
+            "Madrid", "Milan",
+            "London", "Stockholm",
+            "Budapest", "Paris",
+            "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
+    }
+
+    @Test
+    fun `airline test`() {
+        val expected = columnOf("KLM", "Air France", "British Airways", "Air France", "Swiss Air").named("Airline")
+
+        df.update { airline }.with {
+            "([a-zA-Z\\s]+)".toRegex().find(it)?.value?.trim() ?: ""
+        }[airline] shouldBe expected
+
+        df.update { "Airline"<String>() }.with {
+            "([a-zA-Z\\s]+)".toRegex().find(it)?.value?.trim() ?: ""
+        }["Airline"] shouldBe expected
+    }
+
+    @Test
+    fun `split delays`() {
+        val delay1 by column<Double>("delay_1")
+        val delay2 by column<Double>("delay_2")
+        val delay3 by column<Double>("delay_3")
+
+        val expected = dataFrameOf("delay_1", "delay_2", "delay_3")(
+            23.0, 47.0, Double.NaN,
+            Double.NaN, Double.NaN, Double.NaN,
+            24.0, 43.0, 87.0,
+            13.0, Double.NaN, Double.NaN,
+            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
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/DateTestUtils.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/DateTestUtils.kt
new file mode 100644
index 000000000..a608786b1
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/DateTestUtils.kt
@@ -0,0 +1,41 @@
+package org.jetbrains.kotlinx.dataframe.puzzles
+
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.daysUntil
+import kotlinx.datetime.plus
+
+class DateRangeIterator(first: LocalDate, last: LocalDate, val step: Int) : Iterator<LocalDate> {
+    private val finalElement: LocalDate = last
+    private var hasNext: Boolean = if (step > 0) first <= last else first >= last
+    private var next: LocalDate = if (hasNext) first else finalElement
+
+    override fun hasNext(): Boolean = hasNext
+
+    override fun next(): LocalDate {
+        val value = next
+        if (value == finalElement) {
+            if (!hasNext) throw kotlin.NoSuchElementException()
+            hasNext = false
+        } else {
+            next = next.plus(step, DateTimeUnit.DayBased(1))
+        }
+        return value
+    }
+}
+
+operator fun ClosedRange<LocalDate>.iterator() = DateRangeIterator(this.start, this.endInclusive, 1)
+
+fun ClosedRange<LocalDate>.toList(): List<LocalDate> {
+    return when (val size = this.start.daysUntil(this.endInclusive)) {
+        0 -> emptyList()
+        1 -> listOf(iterator().next())
+        else -> {
+            val dest = ArrayList<LocalDate>(size)
+            for (item in this) {
+                dest.add(item)
+            }
+            dest
+        }
+    }
+}
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
new file mode 100644
index 000000000..67a5a5a93
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/DateTests.kt
@@ -0,0 +1,105 @@
+package org.jetbrains.kotlinx.dataframe.puzzles
+
+import io.kotest.matchers.shouldBe
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.Month
+import kotlinx.datetime.toJavaLocalDate
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.junit.Test
+import java.time.temporal.WeekFields
+import java.util.*
+import kotlin.math.round
+import kotlin.random.Random
+
+class DateTests {
+
+    private val start = LocalDate(2015, 1, 1)
+    private val end = LocalDate(2016, 1, 1)
+    private val dti = (start..end).toList().toColumn("dti")
+    private val random = Random(42)
+    private val s = List(dti.size()) { random.nextDouble() }.toColumn("s")
+    private val df = dataFrameOf(dti, s)
+
+    @Test
+    fun `sum for every Wednesday`() {
+        round(df.filter { dti().dayOfWeek.ordinal == 2 }.sum { s }) shouldBe 29.0
+        round(df.filter { "dti"<LocalDate>().dayOfWeek.ordinal == 2 }.sum { "s"<Double>() }) shouldBe 29.0
+    }
+
+    @Test
+    fun `mean for each calendar month`() {
+        val expected = dataFrameOf("month", "s")(
+            Month.JANUARY, 0.4931329003584097,
+            Month.FEBRUARY, 0.5712887136099648,
+            Month.MARCH, 0.5263142140806993,
+            Month.APRIL, 0.5125149149109348,
+            Month.MAY, 0.5030292029672427,
+            Month.JUNE, 0.4691575481416088,
+            Month.JULY, 0.5533841389695694,
+            Month.AUGUST, 0.5661103164088407,
+            Month.SEPTEMBER, 0.44344455128172383,
+            Month.OCTOBER, 0.41726495068242264,
+            Month.NOVEMBER, 0.43862977969202627,
+            Month.DECEMBER, 0.5130316016982762
+        )
+
+        df.groupBy { dti.map { it.month } named "month" }.mean() shouldBe expected
+        df.groupBy { "dti"<LocalDate>().map { it.month } named "month" }.mean() shouldBe expected
+    }
+
+    @Test
+    fun `find date on which highest value`() {
+        val expected = dataFrameOf("month4", "dti", "month41")(
+            1, LocalDate(2015, 2, 11), 1,
+            2, LocalDate(2015, 8, 25), 2,
+            3, LocalDate(2015, 9, 2), 3,
+        )
+        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" }.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" }.flatten()["month4", "dti", "month41"] shouldBe expected
+    }
+
+    @Test
+    fun `create column consisting of the third Thursday in each month`() {
+        val start = LocalDate(2015, 1, 1)
+        val end = LocalDate(2015, 12, 31)
+
+        val expected = columnOf(
+            LocalDate(2015, 1, 15),
+            LocalDate(2015, 2, 19),
+            LocalDate(2015, 3, 19),
+            LocalDate(2015, 4, 16),
+            LocalDate(2015, 5, 14),
+            LocalDate(2015, 6, 18),
+            LocalDate(2015, 7, 16),
+            LocalDate(2015, 8, 13),
+            LocalDate(2015, 9, 17),
+            LocalDate(2015, 10, 15),
+            LocalDate(2015, 11, 19),
+            LocalDate(2015, 12, 17),
+        ).named("3thu")
+
+        (start..end).toList().toColumn("3thu").filter {
+            it.toJavaLocalDate()[WeekFields.of(Locale.ENGLISH).weekOfMonth()] == 3 &&
+                it.dayOfWeek.value == 4
+        } 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
new file mode 100644
index 000000000..49b913777
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/HardTests.kt
@@ -0,0 +1,123 @@
+package org.jetbrains.kotlinx.dataframe.puzzles
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.junit.Test
+import kotlin.math.round
+import kotlin.random.Random
+
+class HardTests {
+
+    @Test
+    fun `count difference back to previous zero`() {
+        val x = columnOf(7, 2, 0, 3, 4, 2, 5, 0, 3, 4).named("X")
+        val df = x.toDataFrame()
+        val y = columnOf(1, 2, 0, 1, 2, 3, 4, 0, 1, 2).named("Y")
+
+        df.mapToColumn("Y") {
+            if (it[x] == 0) 0 else (prev()?.newValue() ?: 0) + 1
+        } shouldBe y
+
+        df.mapToColumn("Y") {
+            if (it["X"] == 0) 0 else (prev()?.newValue() ?: 0) + 1
+        } shouldBe y
+    }
+
+    @Test
+    fun `3 largest values`() {
+        val names = ('a'..'h').map { it.toString() }
+        val random = Random(30)
+        val list = List(64) { random.nextInt(1, 101) }
+        val df = dataFrameOf(names)(*list.toTypedArray())
+        val index by column<Int>()
+        val vals by column<Int>()
+        val name by column<String>()
+
+        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
+    }
+
+    @Test
+    fun `group mean and negative values`() {
+        val random = Random(31)
+        val lab = listOf("A", "B")
+
+        val vals by columnOf(*Array(15) { random.nextInt(-30, 30) })
+        val grps by columnOf(*Array(15) { lab[random.nextInt(0, 2)] })
+
+        val df = dataFrameOf(vals, grps)
+
+        val expected = dataFrameOf("vals", "grps", "patched_values")(
+            -17, "B", 21.0,
+            -7, "B", 21.0,
+            16, "A", 16.0,
+            28, "B", 28.0,
+            9, "A", 9.0,
+            16, "B", 16.0,
+            -21, "B", 21.0,
+            -14, "A", 16.0,
+            -19, "A", 16.0,
+            -22, "A", 16.0,
+            19, "B", 19.0,
+            -2, "B", 21.0,
+            -1, "A", 16.0,
+            -19, "B", 21.0,
+            23, "A", 23.0
+        )
+
+        val means = df.filter { vals >= 0 }
+            .groupBy { grps }.mean()
+            .pivot { grps }.values { vals }
+
+        df.add("patched_values") {
+            if (vals() < 0) means[grps()] as Double else vals().toDouble()
+        } shouldBe expected
+
+        val meansStr = df.filter { "vals"<Int>() >= 0 }
+            .groupBy("grps").mean()
+            .pivot("grps").values("vals")
+
+        df.add("patched_values") {
+            if ("vals"<Int>() < 0) meansStr["grps"<String>()] as Double else "vals"<Int>().toDouble()
+        } shouldBe expected
+    }
+
+    @Test
+    fun `rolling mean`() {
+        val groups by columnOf("a", "a", "b", "b", "a", "b", "b", "b", "a", "b", "a", "b")
+        val value by columnOf(1.0, 2.0, 3.0, Double.NaN, 2.0, 3.0, Double.NaN, 1.0, 7.0, 3.0, Double.NaN, 8.0)
+        val df = dataFrameOf(groups, value)
+
+        val expected = dataFrameOf("groups", "value", "res")(
+            "a", 1.0, 1.0,
+            "a", 2.0, 2.0,
+            "b", 3.0, 3.0,
+            "b", Double.NaN, 3.0,
+            "a", 2.0, 2.0,
+            "b", 3.0, 3.0,
+            "b", Double.NaN, 3.0,
+            "b", 1.0, 2.0,
+            "a", 7.0, 4.0,
+            "b", 3.0, 2.0,
+            "a", Double.NaN, 4.0,
+            "b", 8.0, 4.0,
+        )
+
+        df.add("id") { index() }
+            .groupBy { groups }.add("res") {
+                round(relative(-2..0)[value].filter { !it.isNaN() }.mean())
+            }.concat()
+            .sortBy("id")
+            .remove("id") shouldBe expected
+    }
+}
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
new file mode 100644
index 000000000..01d5155d6
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/puzzles/MediumTests.kt
@@ -0,0 +1,125 @@
+package org.jetbrains.kotlinx.dataframe.puzzles
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.junit.Test
+import kotlin.math.roundToInt
+import kotlin.random.Random
+import kotlin.random.nextInt
+
+class MediumTests {
+
+    private val random = Random(42)
+
+    @Test
+    fun `filter rows that contain same value as row above`() {
+        val df = dataFrameOf("A")(1, 2, 2, 3, 4, 5, 5, 5, 6, 7, 7)
+        val a by column<Int>("A")
+
+        val expected = dataFrameOf("A")(1, 2, 3, 4, 5, 6, 7)
+
+        df.filter { prev()?.get(a) != a() } shouldBe expected
+        df.filter { prev()?.get("A") != "A"() } shouldBe expected
+
+        df.filter { diff { a() } != 0 } shouldBe expected
+        df.filter { diff { "A"<Int>() } != 0 } shouldBe expected
+    }
+
+    @Test
+    fun `subtract row mean from each element in row`() {
+        val df = dataFrameOf("a", "b", "c")(
+            1.0, 2.0, 3.0,
+            1.3, 2.3, 3.3,
+            1.57, 2.57, 3.57
+        )
+
+        val expected = dataFrameOf("a", "b", "c")(
+            -1, 0, 1,
+            -1, 0, 1,
+            -1, 0, 1
+        )
+
+        df.convert { colsOf<Double>() }.with { (it - rowMean()).roundToInt() } shouldBe expected
+    }
+
+    @Test
+    fun `smallest sum`() {
+        val names = ('a'..'j').map { it.toString() }
+        val df = dataFrameOf(names) { List(5) { random.nextDouble() } }
+
+        df.sum().transposeTo<Double>().minBy { value }.name shouldBe "b"
+        df.sum().transpose().minBy("value")["name"] shouldBe "b"
+    }
+
+    @Test
+    fun `count unique rows`() {
+        val df = dataFrameOf("a", "b", "c") { List(30) { random.nextInt(0..2) } }
+        df.countDistinct() shouldBe 19
+    }
+
+    @Test
+    fun `find column which contains third NaN value`() {
+        val nan = Double.NaN
+        val names = ('a'..'j').map { it.toString() }
+        val df = dataFrameOf(names)(
+            0.04, nan, nan, 0.25, nan, 0.43, 0.71, 0.51, nan, nan,
+            nan, nan, nan, 0.04, 0.76, nan, nan, 0.67, 0.76, 0.16,
+            nan, nan, 0.5, nan, 0.31, 0.4, nan, nan, 0.24, 0.01,
+            0.49, nan, nan, 0.62, 0.73, 0.26, 0.85, nan, nan, nan,
+            nan, nan, 0.41, nan, 0.05, nan, 0.61, nan, 0.48, 0.68
+        )
+
+        val expected = columnOf("e", "c", "d", "h", "d").named("res")
+
+        df.mapToColumn("res") {
+            namedValuesOf<Double>().filter { it.value.isNaN }.drop(2).firstOrNull()?.name
+        } shouldBe expected
+    }
+
+    @Test
+    fun `sum of three greatest values`() {
+        val grps by columnOf("a", "a", "a", "b", "b", "c", "a", "a", "b", "c", "c", "c", "b", "b", "c")
+        val vals by columnOf(12, 345, 3, 1, 45, 14, 4, 52, 54, 23, 235, 21, 57, 3, 87)
+        val df = dataFrameOf(grps, vals)
+
+        val expected = dataFrameOf("grps", "res")("a", 409, "b", 156, "c", 345)
+
+        df.groupBy { grps }.aggregate {
+            vals().sortDesc().take(3).sum() into "res"
+        } shouldBe expected
+
+        df.groupBy { grps }.aggregate {
+            "vals"<Int>().sortDesc().take(3).sum() into "res"
+        } shouldBe expected
+    }
+
+    @Test
+    fun `sum bins`() {
+        val list = List(200) { random.nextInt(1, 101) }
+        val df = dataFrameOf("A", "B")(*list.toTypedArray())
+        val a by column<Int>("A")
+        val b by column<Int>("B")
+
+        val expected = dataFrameOf("A", "B")(
+            "(0, 10]", 353,
+            "(10, 20]", 873,
+            "(20, 30]", 321,
+            "(30, 40]", 322,
+            "(40, 50]", 432,
+            "(50, 60]", 754,
+            "(60, 70]", 405,
+            "(70, 80]", 561,
+            "(80, 90]", 657,
+            "(90, 100]", 527
+        )
+
+        df.groupBy { a.map { (it - 1) / 10 } }.sum { b }
+            .sortBy { a }.convert { a }.with { "(${it * 10}, ${it * 10 + 10}]" } shouldBe expected
+
+        df.groupBy { "A"<Int>().map { (it - 1) / 10 } }.sum("B").sortBy("A")
+            .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/PrecisionTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/PrecisionTests.kt
new file mode 100644
index 000000000..1cc860111
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/PrecisionTests.kt
@@ -0,0 +1,45 @@
+package org.jetbrains.kotlinx.dataframe.rendering
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.impl.scale
+import org.jetbrains.kotlinx.dataframe.io.RendererDecimalFormat
+import org.jetbrains.kotlinx.dataframe.io.defaultPrecision
+import org.jetbrains.kotlinx.dataframe.io.format
+import org.junit.Test
+import java.text.DecimalFormatSymbols
+
+class PrecisionTests {
+
+    @Test
+    fun precision() {
+        columnOf(1.2, 3.2).scale() shouldBe 1
+        columnOf(1.1232, 3.2).scale() shouldBe 4
+        columnOf(1.1220001, 12313).scale() shouldBe defaultPrecision
+        columnOf(1, 2).scale() shouldBe 0
+        columnOf(1.0, 2).scale() shouldBe 1
+        columnOf(123121.0, -1231.0).scale() shouldBe 1
+        columnOf(123121.00001, -1231.120).scale() shouldBe 5
+        columnOf(0.000343434343434343434343).scale() shouldBe defaultPrecision
+        columnOf(1E24).scale() shouldBe -23
+    }
+
+    @Test
+    fun format() {
+        val d = DecimalFormatSymbols.getInstance().decimalSeparator
+        val value = 1.2341
+        val expected = "1${d}23"
+        val digits = 2
+        val formatter = RendererDecimalFormat.fromPrecision(digits)
+        value.format(formatter) shouldBe expected
+        value.toFloat().format(formatter) shouldBe expected
+        value.toBigDecimal().format(formatter) shouldBe expected
+    }
+
+    @Test
+    fun emptyColPrecision() {
+        val col by columnOf(1.0)
+        col.filter { false }.scale() shouldBe 0
+    }
+}
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
new file mode 100644
index 000000000..ed6f5c9f1
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/RenderingTests.kt
@@ -0,0 +1,128 @@
+package org.jetbrains.kotlinx.dataframe.rendering
+
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.string.shouldContain
+import io.kotest.matchers.string.shouldNotContain
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.group
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.move
+import org.jetbrains.kotlinx.dataframe.api.parse
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+import org.jetbrains.kotlinx.dataframe.io.escapeHTML
+import org.jetbrains.kotlinx.dataframe.io.formatter
+import org.jetbrains.kotlinx.dataframe.io.print
+import org.jetbrains.kotlinx.dataframe.io.renderToString
+import org.jetbrains.kotlinx.dataframe.io.renderToStringTable
+import org.jetbrains.kotlinx.dataframe.io.toHTML
+import org.jetbrains.kotlinx.dataframe.jupyter.DefaultCellRenderer
+import org.jetbrains.kotlinx.dataframe.jupyter.RenderedContent
+import org.jsoup.Jsoup
+import org.junit.Test
+import java.net.URL
+import java.text.DecimalFormatSymbols
+import kotlin.reflect.typeOf
+
+class RenderingTests {
+
+    @Test
+    fun `render row with unicode values as table`() {
+        val value = "Шёл Шива по шоссе, сокрушая сущее.\r\nА на встречу Саша шла, круглое сосущая"
+        val col by columnOf(value)
+        val df = col.toDataFrame()
+        val rendered = df[0].renderToStringTable()
+        rendered shouldContain "Шива"
+        rendered shouldNotContain "\n"
+        rendered shouldNotContain "\r"
+        rendered shouldContain "\\r"
+        rendered shouldContain "А"
+        rendered shouldContain "..."
+        rendered shouldNotContain "Саша"
+    }
+
+    @Test
+    fun `parse url`() {
+        val df = dataFrameOf("url")("http://www.google.com").parse()
+        df["url"].type() shouldBe typeOf<URL>()
+    }
+
+    @Test
+    fun htmlTagsAreEscaped() {
+        val df = dataFrameOf("name", "int")("<Air France> (12)", 1)
+        val html = df.toHTML().toString()
+        html shouldContain "&#60;Air France&#62;"
+    }
+
+    @Test
+    fun unicodeEscapeSequencesAreEscaped() {
+        val df = dataFrameOf("content")("""Hello\nfrom \x and \y""")
+        val html = df.toHTML().toString()
+        html shouldContain "Hello&#92;nfrom &#92;x and &#92;y"
+    }
+
+    @Test
+    fun `long text is trimmed without escaping`() {
+        val df = dataFrameOf("text")("asdfkjasdlkjfhasljkddasdasdasdasdasdasdhf")
+        val html = df.toHTML().toString()
+        html shouldNotContain "\\\\"
+        html shouldNotContain "&#34;"
+    }
+
+    @Test
+    fun `non ascii text`() {
+        val value = "Шёл Шива по шоссе, сокрушая сущее"
+        val df = dataFrameOf("text")(value)
+        val script = df.toHTML().script
+        script shouldContain value.escapeHTML()
+    }
+
+    @Test
+    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]
+
+        val formatted = formatter.format(grouped, DefaultCellRenderer, DisplayConfiguration())
+        Jsoup.parse(formatted).text() shouldBe "{ }"
+
+        grouped.renderToString() shouldBe "{ }"
+    }
+
+    @Test
+    fun `render successfully`() {
+        dataFrameOf("a", "b")(listOf(1, 1), listOf(2, 4))
+            .group("a", "b")
+            .into("g")
+            .add("a") { 1 }
+            .toHTML()
+    }
+
+    @Test
+    fun `render URL`() {
+        val df = dataFrameOf("url")("https://api.github.com/orgs/JetBrains")
+        val html = df.parse().toHTML()
+        html.toString() shouldNotContain RenderedContent::class.simpleName!!
+    }
+
+    @Test
+    fun `render successfully 2`() {
+        val df = dataFrameOf("name", "parent", "type")("Boston (MA)", "123wazxdPag5", "Campus")
+            .move("parent").into { "parent"["id"] }
+            .group { all() }.into("Campus")
+        df.toHTML().print()
+    }
+
+    @Test
+    fun `render double with exponent`() {
+        val d = DecimalFormatSymbols.getInstance().decimalSeparator
+        listOf(
+            dataFrameOf("col")(1E27) to "1${d}000000e+27",
+            dataFrameOf("col")(1.123) to "1${d}123",
+            dataFrameOf("col")(1.0) to "1${d}0",
+        ).forEach { (df, rendered) ->
+            df.toHTML().script shouldContain rendered
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/RenderingTestsBase.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/RenderingTestsBase.kt
new file mode 100644
index 000000000..e80ec971c
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/RenderingTestsBase.kt
@@ -0,0 +1,18 @@
+package org.jetbrains.kotlinx.dataframe.rendering
+
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+import org.jetbrains.kotlinx.dataframe.io.formatter
+import org.jetbrains.kotlinx.dataframe.jupyter.DefaultCellRenderer
+import org.jsoup.Jsoup
+import org.jsoup.nodes.Element
+
+abstract class RenderingTestsBase {
+    protected fun rowOf(vararg pairs: Pair<String, Any?>) = dataFrameOf(pairs.map { it.first }).withValues(pairs.map { it.second })[0]
+
+    protected fun Any?.truncate(limit: Int): String = format(limit).text()
+
+    protected fun Any?.tooltip(limit: Int): String? = format(limit).children().singleOrNull()?.attr("title")
+
+    protected fun Any?.format(limit: Int): Element = Jsoup.parse(formatter.format(this, DefaultCellRenderer, DisplayConfiguration(cellContentLimit = limit))).body()
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/TooltipTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/TooltipTests.kt
new file mode 100644
index 000000000..28caf2230
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/TooltipTests.kt
@@ -0,0 +1,25 @@
+package org.jetbrains.kotlinx.dataframe.rendering
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class TooltipTests : RenderingTestsBase() {
+
+    @Test
+    fun `long str`() {
+        "12345678".tooltip(5) shouldBe "12345678"
+    }
+
+    @Test
+    fun `short str`() {
+        "1234".tooltip(5) shouldBe null
+    }
+
+    @Test
+    fun row() {
+        val data = rowOf("name" to "Alice", "age" to 10)
+        val tooltip = "name: Alice\nage: 10"
+        data.tooltip(5) shouldBe tooltip
+        data.tooltip(15) shouldBe tooltip
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/TruncateTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/TruncateTests.kt
new file mode 100644
index 000000000..c42bb6574
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/TruncateTests.kt
@@ -0,0 +1,127 @@
+package org.jetbrains.kotlinx.dataframe.rendering
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class TruncateTests : RenderingTestsBase() {
+
+    @Test
+    fun `truncate str`() {
+        "123456789".truncate(5) shouldBe "12..."
+    }
+
+    @Test
+    fun `truncate str to ellipsis`() {
+        "123456789".truncate(3) shouldBe "..."
+    }
+
+    @Test
+    fun `no truncate`() {
+        "123".truncate(3) shouldBe "123"
+    }
+
+    @Test
+    fun truncateMany() {
+        listOf("1", "2", "34567890").truncate(15) shouldBe "[1, 2, 3456...]"
+    }
+
+    @Test
+    fun truncateMany2() {
+        listOf("1", "2345678", "9").truncate(15) shouldBe "[1, 2345678, 9]"
+    }
+
+    @Test
+    fun truncateMany7() {
+        listOf("1", "23456789", "0").truncate(15) shouldBe "[1, 2345..., 0]"
+    }
+
+    @Test
+    fun truncateMany3() {
+        listOf("1", "2345", "6789").truncate(15) shouldBe "[1, 2345, 6789]"
+    }
+
+    @Test
+    fun truncateMany4() {
+        listOf("1", "234567", "89012").truncate(15) shouldBe "[1, 2..., 8...]"
+    }
+
+    @Test
+    fun truncateMany5() {
+        listOf("1", "234567", "8901").truncate(15) shouldBe "[1, 2..., 8901]"
+    }
+
+    @Test
+    fun truncateMany6() {
+        listOf("1", "234567", "8", "9").truncate(15) shouldBe "[1, 23..., ...]"
+    }
+
+    @Test
+    fun truncateMany8() {
+        listOf("123456", "789", "0", "1").truncate(15) shouldBe "[123456, ...]"
+    }
+
+    @Test
+    fun truncateMany9() {
+        listOf("123456789", "789", "0", "1").truncate(15) shouldBe "[12345..., ...]"
+    }
+
+    @Test
+    fun truncateManyMany() {
+        listOf(1).truncate(3) shouldBe "[1]"
+        listOf(10).truncate(4) shouldBe "[10]"
+        listOf(1, 2).truncate(4) shouldBe "[..]"
+        listOf(100).truncate(4) shouldBe "[..]"
+        listOf(100).truncate(5) shouldBe "[100]"
+        listOf(1000).truncate(5) shouldBe "[...]"
+        listOf(1, 2).truncate(5) shouldBe "[...]"
+        listOf(1, 2).truncate(6) shouldBe "[1, 2]"
+    }
+
+    @Test
+    fun `run truncate row`() {
+        testTruncates(
+            rowOf("name" to "Alice", "age" to 10),
+            listOf(
+                "{..}",
+                "{...}",
+                "{ ...}",
+                "{ ... }",
+                "{ n..., a... }",
+                "{ na..., a... }",
+                "{ nam..., a... }",
+                "{ name..., a... }",
+                "{ name:..., a... }",
+                "{ name: ..., a... }",
+                "{ name: A..., a... }",
+                "{ name: Alice, a... }",
+                "{ name: Alice, ag... }",
+                "{ name: Alice, age... }",
+                "{ name: Alice, age: 10 }"
+            )
+        )
+    }
+
+    private fun testTruncates(value: Any?, truncates: List<String>) {
+        val start = truncates[0].length
+        val end = truncates.last().length
+        val actual = (start..end).map { value.truncate(it) }
+        val expected = (start..end).map { len -> truncates.indexOfFirst { it.length > len }.let { if (it == -1) truncates.last() else truncates[it - 1] } }
+        actual shouldBe expected
+    }
+
+    @Test
+    fun `run truncate many`() {
+        val value = listOf("Alice", "Bob", "Billy")
+        testTruncates(
+            value,
+            listOf(
+                "[..]",
+                "[...]",
+                "[A..., ...]",
+                "[Alice, ...]",
+                "[Alice, Bob, B...]",
+                "[Alice, Bob, Billy]",
+            )
+        )
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/html/Browsing.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/html/Browsing.kt
new file mode 100644
index 000000000..2c456b06d
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/html/Browsing.kt
@@ -0,0 +1,40 @@
+package org.jetbrains.kotlinx.dataframe.rendering.html
+
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.junit.Ignore
+import org.junit.Test
+
+class Browsing {
+
+    @Ignore
+    @Test
+    fun test() {
+        data class Name(val firstName: String, val lastName: String?)
+        data class Score(val subject: String, val value: Int)
+        data class Student(val name: Name, val age: Int, val scores: List<Score>)
+
+        val students = listOf(
+            Student(Name("Alice", "Cooper"), 15, listOf(Score("math", 4), Score("biology", 3))),
+            Student(Name("Bob", "Marley"), 20, listOf(Score("music", 5))),
+            Student(Name("Null", null), 100, listOf(Score("nothing", 5))),
+            Student(Name("Antony", "Hover"), 20, listOf(Score("russian", 1))),
+            Student(Name("Sally", "Fever"), 20, listOf(Score("art", 4), Score("math", 4), Score("biology", 3)))
+        )
+
+        val df = students.toDataFrame {
+            "year of birth" from { 2021 - it.age }
+
+            properties(maxDepth = 1) {
+//                exclude(Score::subject) // `subject` property will be skipped from object graph traversal
+//                preserve<Name>() // `Name` objects will be stored as-is without transformation into DataFrame
+            }
+
+            "summary" {
+                "max score" from { it.scores.maxOf { it.value } }
+                "min score" from { it.scores.minOf { it.value } }
+            }
+        }
+
+        df.browse()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/html/Utils.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/html/Utils.kt
new file mode 100644
index 000000000..7497d29e0
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/rendering/html/Utils.kt
@@ -0,0 +1,15 @@
+package org.jetbrains.kotlinx.dataframe.rendering.html
+
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.io.initHtml
+import org.jetbrains.kotlinx.dataframe.io.toHTML
+import java.awt.Desktop
+import java.io.File
+
+fun AnyFrame.browse() {
+    val file = File("temp.html") // File.createTempFile("df_rendering", ".html")
+    file.writeText(toHTML(extraHtml = initHtml()).toString())
+    val uri = file.toURI()
+    val desktop = Desktop.getDesktop()
+    desktop.browse(uri)
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Access.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Access.kt
new file mode 100644
index 000000000..46d2ab2a4
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Access.kt
@@ -0,0 +1,916 @@
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.junit.Test
+
+class Access : TestBase() {
+
+    @Test
+    fun getColumnByName_properties() {
+        // SampleStart
+        df.age
+        df.name.lastName
+        // SampleEnd
+    }
+
+    @Test
+    fun getColumnByName_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val name by columnGroup()
+        val lastName by name.column<String>()
+
+        df[age]
+        df[lastName]
+        // SampleEnd
+    }
+
+    @Test
+    fun getColumnByName_strings() {
+        // SampleStart
+        df["age"]
+        df["name"]["firstName"]
+        // SampleEnd
+    }
+
+    @Test
+    fun getColumn_properties() {
+        // SampleStart
+        df.getColumn { age }
+        // SampleEnd
+    }
+
+    @Test
+    fun getColumn_accessors() {
+        // SampleStart
+        val age by column<Int>()
+
+        df.getColumn { age }
+        // SampleEnd
+    }
+
+    @Test
+    fun getColumn_strings() {
+        // SampleStart
+        df.getColumn("age")
+        // SampleEnd
+    }
+
+    @Test
+    fun getColumnOrNull_properties() {
+        // SampleStart
+        df.getColumnOrNull { age }
+        // SampleEnd
+    }
+
+    @Test
+    fun getColumnOrNull_accessors() {
+        // SampleStart
+        val age by column<Int>()
+
+        df.getColumnOrNull(age)
+        // SampleEnd
+    }
+
+    @Test
+    fun getColumnOrNull_strings() {
+        // SampleStart
+        df.getColumnOrNull("age")
+        // SampleEnd
+    }
+
+    @Test
+    fun getColumns_properties() {
+        // SampleStart
+        df.getColumns { age and name }
+        // SampleEnd
+    }
+
+    @Test
+    fun getColumns_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val name by columnGroup()
+
+        df.getColumns { age and name }
+        // SampleEnd
+    }
+
+    @Test
+    fun getColumns_strings() {
+        // SampleStart
+        df.getColumns("age", "name")
+        // SampleEnd
+    }
+
+    @Test
+    fun getColumnGroup_properties() {
+        // SampleStart
+        df.getColumnGroup { name }
+        // SampleEnd
+    }
+
+    @Test
+    fun getColumnGroup_accessors() {
+        // SampleStart
+        val name by columnGroup()
+
+        df.getColumnGroup(name)
+        // SampleEnd
+    }
+
+    @Test
+    fun getColumnGroup_strings() {
+        // SampleStart
+        df.getColumnGroup("name")
+        // SampleEnd
+    }
+
+    @Test
+    fun getColumnByIndex() {
+        // SampleStart
+        df.getColumn(2)
+        df.getColumnGroup(0).getColumn(1)
+        // SampleEnd
+    }
+
+    @Test
+    fun getRowByIndex() {
+        // SampleStart
+        df[2]
+        // SampleEnd
+    }
+
+    @Test
+    fun getRowByCondition_properties() {
+        // SampleStart
+        df.single { age == 45 }
+        df.first { weight != null }
+        df.minBy { age }
+        df.maxBy { name.firstName.length }
+        df.maxByOrNull { weight }
+        // SampleEnd
+    }
+
+    @Test
+    fun getRowByCondition_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val weight by column<Int?>()
+        val name by columnGroup()
+        val firstName by name.column<String>()
+
+        df.single { age() == 45 }
+        df.first { weight() != null }
+        df.minBy(age)
+        df.maxBy { firstName().length }
+        df.maxByOrNull { weight() }
+        // SampleEnd
+    }
+
+    @Test
+    fun getRowByCondition_strings() {
+        // SampleStart
+        df.single { "age"<Int>() == 45 }
+        df.first { it["weight"] != null }
+        df.minBy("weight")
+        df.maxBy { "name"["firstName"]<String>().length }
+        df.maxByOrNull("weight")
+        // SampleEnd
+    }
+
+    @Test
+    fun getCell_strings() {
+        // SampleStart
+        df["age"][1]
+        df[1]["age"]
+        // SampleEnd
+    }
+
+    @Test
+    fun getCell_properties() {
+        // SampleStart
+        df.age[1]
+        df[1].age
+        // SampleEnd
+    }
+
+    @Test
+    fun getCell_accessors() {
+        // SampleStart
+        val age by column<String>()
+
+        df[age][1]
+        df[1][age]
+        // SampleEnd
+    }
+
+    @Test
+    fun getColumnsByName_properties() {
+        // SampleStart
+        df[df.age, df.weight]
+        // SampleEnd
+    }
+
+    @Test
+    fun getColumnsByName_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val weight by column<Int?>()
+
+        df[age, weight]
+        // SampleEnd
+    }
+
+    @Test
+    fun getColumnsByName_strings() {
+        // SampleStart
+        df["age", "weight"]
+        // SampleEnd
+    }
+
+    @Test
+    fun select_properties() {
+        // SampleStart
+        df.select { age and weight }
+        // SampleEnd
+    }
+
+    @Test
+    fun select_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val weight by column<Int?>()
+
+        df.select { age and weight }
+        df.select(age, weight)
+        // SampleEnd
+    }
+
+    @Test
+    fun select_strings() {
+        // SampleStart
+        df.select { "age" and "weight" }
+        df.select("age", "weight")
+        // SampleEnd
+    }
+
+    @Test
+    fun getSeveralRowsByIndices() {
+        // SampleStart
+        df[0, 3, 4]
+        // SampleEnd
+    }
+
+    @Test
+    fun getSeveralRowsByRanges() {
+        // SampleStart
+        df[1..2]
+        df[0..2, 4..5]
+        // SampleEnd
+    }
+
+    @Test
+    fun getRowsColumns() {
+        // SampleStart
+        df.columns() // List<DataColumn>
+        df.rows() // Iterable<DataRow>
+        df.values() // Sequence<Any?>
+        // SampleEnd
+    }
+
+    @Test
+    fun take() {
+        // SampleStart
+        df.take(5)
+        // SampleEnd
+    }
+
+    @Test
+    fun takeLast() {
+        // SampleStart
+        df.takeLast(5)
+        // SampleEnd
+    }
+
+    @Test
+    fun takeWhile() {
+        // SampleStart
+        df.takeWhile { isHappy }
+        // SampleEnd
+    }
+
+    @Test
+    fun drop() {
+        // SampleStart
+        df.drop(5)
+        // SampleEnd
+    }
+
+    @Test
+    fun dropLast() {
+        // SampleStart
+        df.dropLast() // default 1
+        df.dropLast(5)
+        // SampleEnd
+    }
+
+    @Test
+    fun dropWhile() {
+        // SampleStart
+        df.dropWhile { !isHappy }
+        // SampleEnd
+    }
+
+    @Test
+    fun filter_properties() {
+        // SampleStart
+        df.filter { age > 18 && name.firstName.startsWith("A") }
+        // SampleEnd
+    }
+
+    @Test
+    fun filter_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val name by columnGroup()
+        val firstName by name.column<String>()
+
+        df.filter { age() > 18 && firstName().startsWith("A") }
+        // or
+        df.filter { it[age] > 18 && it[firstName].startsWith("A") }
+        // SampleEnd
+    }
+
+    @Test
+    fun filter_strings() {
+        // SampleStart
+        df.filter { "age"<Int>() > 18 && "name"["firstName"]<String>().startsWith("A") }
+        // SampleEnd
+    }
+
+    @Test
+    fun filterBy_properties() {
+        // SampleStart
+        df.filterBy { isHappy }
+        // SampleEnd
+    }
+
+    @Test
+    fun filterBy_accessors() {
+        // SampleStart
+        val isHappy by column<Boolean>()
+        df.filterBy { isHappy }
+        // SampleEnd
+    }
+
+    @Test
+    fun filterBy_strings() {
+        // SampleStart
+        df.filterBy("isHappy")
+        // SampleEnd
+    }
+
+    @Test
+    fun dropWhere_properties() {
+        // SampleStart
+        df.drop { weight == null || city == null }
+        // SampleEnd
+    }
+
+    @Test
+    fun dropWhere_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val weight by column<Int?>()
+        val city by column<String?>()
+
+        df.drop { weight() == null || city() == null }
+        // or
+        df.drop { it[weight] == null || it[city] == null }
+        // SampleEnd
+    }
+
+    @Test
+    fun dropWhere_strings() {
+        // SampleStart
+        df.drop { it["weight"] == null || it["city"] == null }
+        // SampleEnd
+    }
+
+    @Test
+    fun dropNulls() {
+        // SampleStart
+        df.dropNulls() // remove rows with null value in any column
+        df.dropNulls(whereAllNull = true) // remove rows with null values in all columns
+        df.dropNulls { city } // remove rows with null value in 'city' column
+        df.dropNulls { city and weight } // remove rows with null value in 'city' OR 'weight' columns
+        df.dropNulls(whereAllNull = true) { city and weight } // remove rows with null value in 'city' AND 'weight' columns
+        // SampleEnd
+    }
+
+    @Test
+    fun dropNaNs() {
+        // SampleStart
+        df.dropNaNs() // remove rows containing NaN in any column
+        df.dropNaNs(whereAllNaN = true) // remove rows with NaN in all columns
+        df.dropNaNs { weight } // remove rows where 'weight' is NaN
+        df.dropNaNs { age and weight } // remove rows where either 'age' or 'weight' is NaN
+        df.dropNaNs(whereAllNaN = true) { age and weight } // remove rows where both 'age' and 'weight' are NaN
+        // SampleEnd
+    }
+
+    @Test
+    fun dropNA() {
+        // SampleStart
+        df.dropNA() // remove rows containing null or NaN in any column
+        df.dropNA(whereAllNA = true) // remove rows with null or NaN in all columns
+        df.dropNA { weight } // remove rows where 'weight' is null or NaN
+        df.dropNA { age and weight } // remove rows where either 'age' or 'weight' is null or NaN
+        df.dropNA(whereAllNA = true) { age and weight } // remove rows where both 'age' and 'weight' are null or NaN
+        // SampleEnd
+    }
+
+    @Test
+    fun byColumn_strings() {
+        // SampleStart
+        df["name"][0]
+        df["name", "age"][3, 5, 6]
+        // SampleEnd
+        // TODO: df["age"][2..4]
+    }
+
+    @Test
+    fun byColumn_accessors() {
+        // SampleStart
+        val name by column<String>()
+        val age by column<Int>()
+        df[name][0]
+        df[name, age][3, 5, 6]
+        // SampleEnd
+        // TODO: df[age][2..4]
+    }
+
+    @Test
+    fun byColumn_properties() {
+        // SampleStart
+        df.name[0]
+        df.select { name and age }[3, 5, 6]
+        df.age[2..4]
+        // SampleEnd
+    }
+
+    @Test
+    fun byRow_strings() {
+        // SampleStart
+        df[0]["name"]
+        df[3, 5, 6]["name", "age"]
+        df[3..5]["age"]
+        // SampleEnd
+    }
+
+    @Test
+    fun byRow_accessors() {
+        // SampleStart
+        val name by column<String>()
+        val age by column<Int>()
+        df[0][name]
+        df[3, 5, 6][name, age]
+        df[3..5][age]
+        // SampleEnd
+    }
+
+    @Test
+    fun byRow_properties() {
+        // SampleStart
+        df[0].name
+        df[3, 5, 6].select { name and age }
+        df[3..5].age
+        // SampleEnd
+    }
+
+    @Test
+    fun namedAndRenameCol() {
+        // SampleStart
+        val unnamedCol = columnOf("Alice", "Bob")
+        val colRename = unnamedCol.rename("name")
+        val colNamed = columnOf("Alice", "Bob") named "name"
+        // SampleEnd
+    }
+
+    @Test
+    fun namedColumnWithoutValues() {
+        // SampleStart
+        val name by column<String>()
+        val col = column<String>("name")
+        // SampleEnd
+    }
+
+    @Test
+    fun colRefForTypedAccess() {
+        val df = dataFrameOf("name")("Alice", "Bob")
+        val name by column<String>()
+        val col = column<String>("name")
+        // SampleStart
+        df.filter { it[name].startsWith("A") }
+        df.sortBy { col }
+        // SampleEnd
+    }
+
+    @Test
+    fun iterableApi() {
+        // SampleStart
+        df.forEach { println(it) }
+        df.take(5)
+        df.drop(2)
+        df.chunked(10)
+        // SampleEnd
+    }
+
+    @Test
+    fun distinct() {
+        // SampleStart
+        df.distinct()
+        // SampleEnd
+    }
+
+    @Test
+    fun distinctColumns_properties() {
+        // SampleStart
+        df.distinct { age and name }
+        // same as
+        df.select { age and name }.distinct()
+        // SampleEnd
+    }
+
+    @Test
+    fun distinctColumns_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val name by columnGroup()
+        df.distinct { age and name }
+        // same as
+        df.select { age and name }.distinct()
+        // SampleEnd
+    }
+
+    @Test
+    fun countDistinct() {
+        // SampleStart
+        df.countDistinct()
+        // SampleEnd
+    }
+
+    @Test
+    fun countDistinctColumns_properties() {
+        // SampleStart
+        df.countDistinct { age and name }
+        // SampleEnd
+    }
+
+    @Test
+    fun countDistinctColumns_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val name by columnGroup()
+        df.countDistinct { age and name }
+        // SampleEnd
+    }
+
+    @Test
+    fun countDistinctColumns_strings() {
+        // SampleStart
+        df.countDistinct("age", "name")
+        // SampleEnd
+    }
+
+    @Test
+    fun distinctColumns_strings() {
+        // SampleStart
+        df.distinct("age", "name")
+        // same as
+        df.select("age", "name").distinct()
+        // SampleEnd
+    }
+
+    @Test
+    fun distinctBy_properties() {
+        // SampleStart
+        df.distinctBy { age and name }
+        // same as
+        df.groupBy { age and name }.mapToRows { group.first() }
+        // SampleEnd
+    }
+
+    @Test
+    fun distinctBy_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val name by columnGroup()
+        val firstName by name.column<String>()
+
+        df.distinctBy { age and name }
+        // same as
+        df.groupBy { age and name }.mapToRows { group.first() }
+        // SampleEnd
+    }
+
+    @Test
+    fun distinctBy_strings() {
+        // SampleStart
+        df.distinctBy("age", "name")
+        // same as
+        df.groupBy("age", "name").mapToRows { group.first() }
+        // SampleEnd
+    }
+
+    @Test
+    fun columnSelectorsUsages() {
+        // SampleStart
+        df.select { age and name }
+        df.fillNaNs { dfsOf<Double>() }.withZero()
+        df.remove { cols { it.hasNulls() } }
+        df.update { city }.notNull { it.lowercase() }
+        df.gather { colsOf<Number>() }.into("key", "value")
+        df.move { name.firstName and name.lastName }.after { city }
+        // SampleEnd
+    }
+
+    @Test
+    fun columnSelectors_properties() {
+        // SampleStart
+        // by column name
+        df.select { it.name }
+        df.select { name }
+
+        // by column path
+        df.select { name.firstName }
+
+        // with a new name
+        df.select { name named "Full Name" }
+
+        // converted
+        df.select { name.firstName.map { it.lowercase() } }
+
+        // column arithmetics
+        df.select { 2021 - age }
+
+        // two columns
+        df.select { name and age }
+
+        // range of columns
+        df.select { name..age }
+
+        // all children of ColumnGroup
+        df.select { name.all() }
+
+        // dfs traversal of all children columns
+        df.select { name.allDfs() }
+
+        // SampleEnd
+    }
+
+    @Test
+    fun columnSelectors_accessors() {
+        // SampleStart
+        // by column name
+        val name by columnGroup()
+        df.select { it[name] }
+        df.select { name }
+
+        // by column path
+        val firstName by name.column<String>()
+        df.select { firstName }
+
+        // with a new name
+        df.select { name named "Full Name" }
+
+        // converted
+        df.select { firstName.map { it.lowercase() } }
+
+        // column arithmetics
+        val age by column<Int>()
+        df.select { 2021 - age }
+
+        // two columns
+        df.select { name and age }
+
+        // range of columns
+        df.select { name..age }
+
+        // all children of ColumnGroup
+        df.select { name.all() }
+
+        // dfs traversal of all children columns
+        df.select { name.allDfs() }
+        // SampleEnd
+    }
+
+    @Test
+    fun columnSelectors_strings() {
+        // SampleStart
+        // by column name
+        df.select { it["name"] }
+
+        // by column path
+        df.select { it["name"]["firstName"] }
+        df.select { "name"["firstName"] }
+
+        // with a new name
+        df.select { "name" named "Full Name" }
+
+        // converted
+        df.select { "name"["firstName"]<String>().map { it.uppercase() } }
+
+        // column arithmetics
+        df.select { 2021 - "age"<Int>() }
+
+        // two columns
+        df.select { "name" and "age" }
+
+        // by range of names
+        df.select { "name".."age" }
+
+        // all children of ColumnGroup
+        df.select { "name".all() }
+
+        // dfs traversal of all children columns
+        df.select { "name".allDfs() }
+        // SampleEnd
+    }
+
+    @Test
+    fun columnsSelectorByIndices() {
+        // SampleStart
+        // by index
+        df.select { col(2) }
+
+        // by several indices
+        df.select { cols(0, 1, 3) }
+
+        // by range of indices
+        df.select { cols(1..4) }
+        // SampleEnd
+    }
+
+    @Test
+    fun columnSelectorsMisc() {
+        // SampleStart
+        // by condition
+        df.select { cols { it.name().startsWith("year") } }
+        df.select { startsWith("year") }
+
+        // by type
+        df.select { colsOf<String>() }
+
+        // by type with condition
+        df.select { colsOf<String?> { it.countDistinct() > 5 } }
+
+        // all top-level columns
+        df.select { all() }
+
+        // first/last n columns
+        df.select { take(2) }
+        df.select { takeLast(2) }
+
+        // all except first/last n columns
+        df.select { drop(2) }
+        df.select { dropLast(2) }
+
+        // dfs traversal of all columns, excluding ColumnGroups from result
+        df.select { allDfs() }
+
+        // dfs traversal of all columns, including ColumnGroups in result
+        df.select { allDfs(includeGroups = true) }
+
+        // dfs traversal with condition
+        df.select { dfs { it.name().contains(":") } }
+
+        // dfs traversal of columns of given type
+        df.select { dfsOf<String>() }
+
+        // all columns except given column set
+        df.select { except { colsOf<String>() } }
+
+        // union of column sets
+        df.select { take(2) and col(3) }
+        // SampleEnd
+    }
+
+    @Test
+    fun columnSelectorsModifySet() {
+        // SampleStart
+        // first/last n columns in column set
+        df.select { allDfs().take(3) }
+        df.select { allDfs().takeLast(3) }
+
+        // all except first/last n columns in column set
+        df.select { allDfs().drop(3) }
+        df.select { allDfs().dropLast(3) }
+
+        // filter column set by condition
+        df.select { allDfs().filter { it.name().startsWith("year") } }
+
+        // exclude columns from column set
+        df.select { allDfs().except { age } }
+
+        // keep only unique columns
+        df.select { (colsOf<Int>() and age).distinct() }
+        // SampleEnd
+    }
+
+    @Test
+    fun forRows_properties() {
+        // SampleStart
+        for (row in df) {
+            println(row.age)
+        }
+
+        df.forEach {
+            println(it.age)
+        }
+
+        df.rows().forEach {
+            println(it.age)
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun forRows_accessors() {
+        // SampleStart
+        val age by column<Int>()
+
+        for (row in df) {
+            println(row[age])
+        }
+
+        df.forEach {
+            println(it[age])
+        }
+
+        df.rows().forEach {
+            println(it[age])
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun forRows_strings() {
+        // SampleStart
+        for (row in df) {
+            println(row["age"])
+        }
+
+        df.forEach {
+            println(it["age"])
+        }
+
+        df.rows().forEach {
+            println(it["age"])
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun forColumn() {
+        // SampleStart
+        df.columns().forEach {
+            println(it.name())
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun forCells() {
+        // SampleStart
+        // from top to bottom, then from left to right
+        df.values().forEach {
+            println(it)
+        }
+
+        // from left to right, then from top to bottom
+        df.values(byRows = true).forEach {
+            println(it)
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun xs() {
+        // SampleStart
+        df.xs("Charlie", "Chaplin")
+
+        df.xs("Moscow", true) { city and isHappy }
+        // SampleEnd
+    }
+
+    @Test
+    fun values() {
+        // SampleStart
+        df.values()
+        df.values(byRows = true)
+        df.values { age and weight }
+        // SampleEnd
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Analyze.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Analyze.kt
new file mode 100644
index 000000000..912447198
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Analyze.kt
@@ -0,0 +1,1145 @@
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import org.jetbrains.kotlinx.dataframe.api.aggregate
+import org.jetbrains.kotlinx.dataframe.api.asComparable
+import org.jetbrains.kotlinx.dataframe.api.asGroupBy
+import org.jetbrains.kotlinx.dataframe.api.asNumbers
+import org.jetbrains.kotlinx.dataframe.api.colsOf
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnGroup
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.count
+import org.jetbrains.kotlinx.dataframe.api.cumSum
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.describe
+import org.jetbrains.kotlinx.dataframe.api.div
+import org.jetbrains.kotlinx.dataframe.api.expr
+import org.jetbrains.kotlinx.dataframe.api.frames
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.groupByOther
+import org.jetbrains.kotlinx.dataframe.api.head
+import org.jetbrains.kotlinx.dataframe.api.indices
+import org.jetbrains.kotlinx.dataframe.api.length
+import org.jetbrains.kotlinx.dataframe.api.matches
+import org.jetbrains.kotlinx.dataframe.api.max
+import org.jetbrains.kotlinx.dataframe.api.maxBy
+import org.jetbrains.kotlinx.dataframe.api.maxByOrNull
+import org.jetbrains.kotlinx.dataframe.api.maxFor
+import org.jetbrains.kotlinx.dataframe.api.maxOf
+import org.jetbrains.kotlinx.dataframe.api.maxOrNull
+import org.jetbrains.kotlinx.dataframe.api.mean
+import org.jetbrains.kotlinx.dataframe.api.meanFor
+import org.jetbrains.kotlinx.dataframe.api.meanOf
+import org.jetbrains.kotlinx.dataframe.api.median
+import org.jetbrains.kotlinx.dataframe.api.medianFor
+import org.jetbrains.kotlinx.dataframe.api.medianOf
+import org.jetbrains.kotlinx.dataframe.api.min
+import org.jetbrains.kotlinx.dataframe.api.minBy
+import org.jetbrains.kotlinx.dataframe.api.minFor
+import org.jetbrains.kotlinx.dataframe.api.minOf
+import org.jetbrains.kotlinx.dataframe.api.minOrNull
+import org.jetbrains.kotlinx.dataframe.api.pivot
+import org.jetbrains.kotlinx.dataframe.api.pivotCounts
+import org.jetbrains.kotlinx.dataframe.api.pivotMatches
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.api.std
+import org.jetbrains.kotlinx.dataframe.api.stdFor
+import org.jetbrains.kotlinx.dataframe.api.stdOf
+import org.jetbrains.kotlinx.dataframe.api.sum
+import org.jetbrains.kotlinx.dataframe.api.sumFor
+import org.jetbrains.kotlinx.dataframe.api.sumOf
+import org.jetbrains.kotlinx.dataframe.api.valueCounts
+import org.jetbrains.kotlinx.dataframe.api.values
+import org.junit.Test
+import kotlin.math.ln
+
+class Analyze : TestBase() {
+
+    @Test
+    fun basicInfo() {
+        // SampleStart
+        df.count() // same as df.rowsCount()
+        df.indices() // 0 until count()
+        df.columnsCount()
+        df.columnNames()
+        df.head()
+        df.schema()
+        df.describe()
+        // SampleEnd
+    }
+
+    @Test
+    fun head() {
+        // SampleStart
+        df.head(3)
+        // SampleEnd
+    }
+
+    @Test
+    fun schema() {
+        // SampleStart
+        df.schema()
+        // SampleEnd
+    }
+
+    @Test
+    fun schemaGroupBy() {
+        // SampleStart
+        df.groupBy { city }.schema()
+        // SampleEnd
+    }
+
+    @Test
+    fun describe() {
+        // SampleStart
+        df.describe()
+        // SampleEnd
+    }
+
+    @Test
+    fun describeColumns_properties() {
+        // SampleStart
+        df.describe { age and name.all() }
+        // SampleEnd
+    }
+
+    @Test
+    fun describeColumns_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val name by columnGroup()
+
+        df.describe { age and name.all() }
+        // SampleEnd
+    }
+
+    @Test
+    fun describeColumns_strings() {
+        // SampleStart
+        df.describe { "age" and "name".all() }
+        // SampleEnd
+    }
+
+    @Test
+    fun countCondition() {
+        // SampleStart
+        df.count { age > 15 }
+        // SampleEnd
+    }
+
+    @Test
+    fun count() {
+        // SampleStart
+        df.count()
+        // SampleEnd
+    }
+
+    @Test
+    fun countAggregation() {
+        // SampleStart
+        df.groupBy { city }.count()
+        df.pivot { city }.count { age > 18 }
+        df.pivot { name.firstName }.groupBy { name.lastName }.count()
+        // SampleEnd
+    }
+
+    @Test
+    fun sumAggregations() {
+        // SampleStart
+        df.age.sum()
+        df.groupBy { city }.sum()
+        df.pivot { city }.sum()
+        df.pivot { city }.groupBy { name.lastName }.sum()
+        // SampleEnd
+    }
+
+    @Test
+    fun statisticModes() {
+        // SampleStart
+        df.sum() // sum of values per every numeric column
+        df.sum { age and weight } // sum of all values in `age` and `weight`
+        df.sumFor { age and weight } // sum of values per `age` and `weight` separately
+        df.sumOf { (weight ?: 0) / age } // sum of expression evaluated for every row
+        // SampleEnd
+    }
+
+    @Test
+    fun minmaxModes() {
+        // SampleStart
+        df.min() // min of values per every comparable column
+        df.min { age and weight } // min of all values in `age` and `weight`
+        df.minFor { age and weight } // min of values per `age` and `weight` separately
+        df.minOf { (weight ?: 0) / age } // min of expression evaluated for every row
+        df.minBy { age } // DataRow with minimal `age`
+        // SampleEnd
+    }
+
+    @Test
+    fun minmaxAggregations() {
+        // SampleStart
+        df.min()
+        df.age.min()
+        df.groupBy { city }.min()
+        df.pivot { city }.min()
+        df.pivot { city }.groupBy { name.lastName }.min()
+        // SampleEnd
+    }
+
+    @Test
+    fun medianModes() {
+        // SampleStart
+        df.median() // median of values per every comparable column
+        df.median { age and weight } // median of all values in `age` and `weight`
+        df.medianFor { age and weight } // median of values per `age` and `weight` separately
+        df.medianOf { (weight ?: 0) / age } // median of expression evaluated for every row
+        // SampleEnd
+    }
+
+    @Test
+    fun medianAggregations() {
+        // SampleStart
+        df.median()
+        df.age.median()
+        df.groupBy { city }.median()
+        df.pivot { city }.median()
+        df.pivot { city }.groupBy { name.lastName }.median()
+        // SampleEnd
+    }
+
+    @Test
+    fun meanModes() {
+        // SampleStart
+        df.mean() // mean of values per every numeric column
+        df.mean(skipNA = true) { age and weight } // mean of all values in `age` and `weight`, skips NA
+        df.meanFor(skipNA = true) { age and weight } // mean of values per `age` and `weight` separately, skips NA
+        df.meanOf { (weight ?: 0) / age } // median of expression evaluated for every row
+        // SampleEnd
+    }
+
+    @Test
+    fun meanAggregations() {
+        // SampleStart
+        df.mean()
+        df.age.mean()
+        df.groupBy { city }.mean()
+        df.pivot { city }.mean()
+        df.pivot { city }.groupBy { name.lastName }.mean()
+        // SampleEnd
+    }
+
+    @Test
+    fun stdModes() {
+        // SampleStart
+        df.std() // std of values per every numeric column
+        df.std { age and weight } // std of all values in `age` and `weight`
+        df.stdFor { age and weight } // std of values per `age` and `weight` separately, skips NA
+        df.stdOf { (weight ?: 0) / age } // std of expression evaluated for every row
+        // SampleEnd
+    }
+
+    @Test
+    fun stdAggregations() {
+        // SampleStart
+        df.std()
+        df.age.std()
+        df.groupBy { city }.std()
+        df.pivot { city }.std()
+        df.pivot { city }.groupBy { name.lastName }.std()
+        // SampleEnd
+    }
+
+    @Test
+    fun meanAggregationsSkipNA() {
+        // SampleStart
+        df.mean(skipNA = true)
+        // SampleEnd
+    }
+
+    @Test
+    fun statisticAggregations() {
+        // SampleStart
+        df.mean()
+        df.age.sum()
+        df.groupBy { city }.mean()
+        df.pivot { city }.median()
+        df.pivot { city }.groupBy { name.lastName }.std()
+        // SampleEnd
+    }
+
+    @Test
+    fun statisticGroupBySingle() {
+        // SampleStart
+        df.groupBy { city }.mean { age } // [`city`, `mean`]
+        df.groupBy { city }.meanOf { age / 2 } // [`city`, `mean`]
+        // SampleEnd
+    }
+
+    @Test
+    fun statisticGroupBySingleNamed() {
+        // SampleStart
+        df.groupBy { city }.mean("mean age") { age } // [`city`, `mean age`]
+        df.groupBy { city }.meanOf("custom") { age / 2 } // [`city`, `custom`]
+        // SampleEnd
+    }
+
+    @Test
+    fun statisticGroupByMany() {
+        // SampleStart
+        df.groupBy { city }.meanFor { age and weight } // [`city`, `age`, `weight`]
+        df.groupBy { city }.mean() // [`city`, `age`, `weight`, ...]
+        // SampleEnd
+    }
+
+    @Test
+    fun statisticPivotSingle_properties() {
+        // SampleStart
+        df.groupBy { city }.pivot { name.lastName }.mean { age }
+        df.groupBy { city }.pivot { name.lastName }.meanOf { age / 2.0 }
+        // SampleEnd
+    }
+
+    @Test
+    fun statisticPivotSingle_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val age by column<Int>()
+        val name by columnGroup()
+        val lastName by name.column<String>()
+
+        df.groupBy { city }.pivot { lastName }.mean { age }
+        df.groupBy { city }.pivot { lastName }.meanOf { age() / 2.0 }
+        // SampleEnd
+    }
+
+    @Test
+    fun statisticPivotSingle_strings() {
+        // SampleStart
+        df.groupBy("city").pivot { "name"["lastName"] }.mean("age")
+        df.groupBy("city").pivot { "name"["lastName"] }.meanOf { "age"<Int>() / 2.0 }
+        // SampleEnd
+    }
+
+    @Test
+    fun statisticPivotMany() {
+        // SampleStart
+        df.groupBy { city }.pivot { name.lastName }.meanFor { age and weight }
+        df.groupBy { city }.pivot { name.lastName }.mean()
+        // SampleEnd
+    }
+
+    @Test
+    fun statisticPivotManySeparate() {
+        // SampleStart
+        df.groupBy { city }.pivot { name.lastName }.meanFor(separate = true) { age and weight }
+        df.groupBy { city }.pivot { name.lastName }.mean(separate = true)
+        // SampleEnd
+    }
+
+    @Test
+    fun columnStats_properties() {
+        // SampleStart
+        df.sum { weight }
+        df.min { age }
+        df.mean { age }
+        df.median { age }
+
+        df.weight.sum()
+        df.age.max()
+        df.age.mean()
+        df.age.median()
+        // SampleEnd
+    }
+
+    @Test
+    fun columnStats_accessors() {
+        // SampleStart
+        val weight by column<Int?>()
+        val age by column<Int>()
+
+        df.sum { weight }
+        df.min { age }
+        df.mean { age }
+        df.median { age }
+
+        df.sum(weight)
+        df.min(age)
+        df.mean(age)
+        df.median(age)
+
+        df[weight].sum()
+        df[age].mean()
+        df[age].min()
+        df[age].median()
+        // SampleEnd
+    }
+
+    @Test
+    fun columnStats_strings() {
+        // SampleStart
+        df.sum("weight")
+        df.min("age")
+        df.mean("age")
+        df.median("age")
+        // SampleEnd
+    }
+
+    @Test
+    fun multipleColumnsStat_properties() {
+        // SampleStart
+        df.min { colsOf<Int>() }
+        df.max { name.firstName and name.lastName }
+        df.sum { age and weight }
+        df.mean { cols(1, 3).asNumbers() }
+        df.median { name.cols().asComparable() }
+        // SampleEnd
+    }
+
+    @Test
+    fun multipleColumnsStat_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val firstName by name.column<String>()
+        val lastName by name.column<String>()
+        val age by column<Int>()
+        val weight by column<Int?>()
+
+        df.min { colsOf<Int>() }
+
+        df.max { firstName and lastName }
+        // or
+        df.max(firstName, lastName)
+
+        df.sum { age and weight }
+        // or
+        df.sum(age, weight)
+
+        df.mean { cols(1, 3).asNumbers() }
+        df.median { name.cols().asComparable() }
+        // SampleEnd
+    }
+
+    @Test
+    fun multipleColumnsStat_strings() {
+        // SampleStart
+
+        df.min { colsOf<Int>() }
+
+        df.max { "name"["firstName"].asComparable() and "name"["lastName"].asComparable() }
+
+        df.sum("age", "weight")
+        // or
+        df.sum { "age"<Int>() and "weight"<Int?>() }
+
+        df.mean { cols(1, 3).asNumbers() }
+        df.median { name.cols().asComparable() }
+        // SampleEnd
+    }
+
+    @Test
+    fun columnsFor_properties() {
+        // SampleStart
+        df.minFor { colsOf<Int>() }
+        df.maxFor { name.firstName and name.lastName }
+        df.sumFor { age and weight }
+        df.meanFor { cols(1, 3).asNumbers() }
+        df.medianFor { name.cols().asComparable() }
+        // SampleEnd
+    }
+
+    @Test
+    fun columnsFor_aсcessors() {
+        // SampleStart
+        val name by columnGroup()
+        val firstName by name.column<String>()
+        val lastName by name.column<String>()
+        val age by column<Int>()
+        val weight by column<Int?>()
+
+        df.minFor { colsOf<Int>() }
+
+        df.maxFor { firstName and lastName }
+        // or
+        df.maxFor(firstName, lastName)
+
+        df.sumFor { age and weight }
+        // or
+        df.sum(age, weight)
+
+        df.mean { cols(1, 3).asNumbers() }
+        df.median { name.cols().asComparable() }
+        // SampleEnd
+    }
+
+    @Test
+    fun columnsFor_strings() {
+        // SampleStart
+        df.minFor { colsOf<Int>() }
+        df.maxFor { "name"["firstName"].asComparable() and "name"["lastName"].asComparable() }
+
+        df.sumFor("age", "weight")
+        // or
+        df.sumFor { "age"<Int>() and "weight"<Int?>() }
+
+        df.meanFor { cols(1, 3).asNumbers() }
+        df.medianFor { name.cols().asComparable() }
+        // SampleEnd
+    }
+
+    @Test
+    fun ofExpressions_properties() {
+        // SampleStart
+        df.minOf { 2021 - age }
+        df.maxOf { name.firstName.length + name.lastName.length }
+        df.sumOf { weight?.let { it - 50 } }
+        df.meanOf { ln(age.toDouble()) }
+        df.medianOf { city?.length }
+        // SampleEnd
+    }
+
+    @Test
+    fun ofExpressions_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val firstName by name.column<String>()
+        val lastName by name.column<String>()
+        val age by column<Int>()
+        val weight by column<Int?>()
+        val city by column<String?>()
+
+        df.minOf { 2021 - age() }
+        df.maxOf { firstName().length + lastName().length }
+        df.sumOf { weight()?.let { it - 50 } }
+        df.meanOf { ln(age().toDouble()) }
+        df.medianOf { city()?.length }
+        // SampleEnd
+    }
+
+    @Test
+    fun ofExpressions_strings() {
+        // SampleStart
+        df.minOf { 2021 - "age"<Int>() }
+        df.maxOf { "name"["firstName"]<String>().length + "name"["lastName"]<String>().length }
+        df.sumOf { "weight"<Int?>()?.let { it - 50 } }
+        df.meanOf { ln("age"<Int>().toDouble()) }
+        df.medianOf { "city"<String?>()?.length }
+        // SampleEnd
+    }
+
+    @Test
+    fun groupBy_properties() {
+        // SampleStart
+        df.groupBy { name }
+        df.groupBy { city and name.lastName }
+        df.groupBy { age / 10 named "ageDecade" }
+        df.groupBy { expr { name.firstName.length + name.lastName.length } named "nameLength" }
+        // SampleEnd
+    }
+
+    @Test
+    fun groupBy_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val lastName by name.column<String>()
+        val firstName by name.column<String>()
+        val age by column<Int>()
+        val city by column<String?>()
+
+        df.groupBy { name }
+        // or
+        df.groupBy(name)
+
+        df.groupBy { city and lastName }
+        // or
+        df.groupBy(city, lastName)
+
+        df.groupBy { age / 10 named "ageDecade" }
+
+        df.groupBy { expr { firstName().length + lastName().length } named "nameLength" }
+        // SampleEnd
+    }
+
+    @Test
+    fun groupBy_strings() {
+        // SampleStart
+        df.groupBy("name")
+        df.groupBy { "city" and "name"["lastName"] }
+        df.groupBy { "age"<Int>() / 10 named "ageDecade" }
+        df.groupBy { expr { "name"["firstName"]<String>().length + "name"["lastName"]<String>().length } named "nameLength" }
+        // SampleEnd
+    }
+
+    @Test
+    fun dataFrameToGroupBy() {
+        // SampleStart
+        val key by columnOf(1, 2) // create int column with name "key"
+        val data by columnOf(df[0..3], df[4..6]) // create frame column with name "data"
+        val df = dataFrameOf(key, data) // create dataframe with two columns
+
+        df.asGroupBy { data } // convert dataframe to GroupBy by interpreting 'data' column as groups
+        // SampleEnd
+    }
+
+    @Test
+    fun groupByToFrame() {
+        // SampleStart
+        df.groupBy { city }.toDataFrame()
+        // SampleEnd
+    }
+
+    @Test
+    fun groupByAggregations_properties() {
+        // SampleStart
+        df.groupBy { city }.aggregate {
+            count() into "total"
+            count { age > 18 } into "adults"
+            median { age } into "median age"
+            min { age } into "min age"
+            maxBy { age }.name into "oldest"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun groupByAggregations_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val age by column<Int>()
+        val name by columnGroup()
+
+        df.groupBy { city }.aggregate {
+            count() into "total"
+            count { age() > 18 } into "adults"
+            median { age } into "median age"
+            min { age } into "min age"
+            maxBy { age() }[name] into "name of oldest"
+        }
+        // or
+        df.groupBy(city).aggregate {
+            count() into "total"
+            count { age > 18 } into "adults"
+            median(age) into "median age"
+            min(age) into "min age"
+            maxBy(age)[name] into "name of oldest"
+        }
+        // or
+        df.groupBy(city).aggregate {
+            count() into "total"
+            age().count { it > 18 } into "adults"
+            age().median() into "median age"
+            age().min() into "min age"
+            maxBy(age)[name] into "name of oldest"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun groupByAggregations_strings() {
+        // SampleStart
+        df.groupBy("city").aggregate {
+            count() into "total"
+            count { "age"<Int>() > 18 } into "adults"
+            median("age") into "median age"
+            min("age") into "min age"
+            maxBy("age")["name"] into "oldest"
+        }
+        // or
+        df.groupBy("city").aggregate {
+            count() into "total"
+            count { "age"<Int>() > 18 } into "adults"
+            "age"<Int>().median() into "median age"
+            "age"<Int>().min() into "min age"
+            maxBy("age")["name"] into "oldest"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun groupByAggregateWithoutInto_properties() {
+        // SampleStart
+        df.groupBy { city }.aggregate { maxBy { age }.name }
+        // SampleEnd
+    }
+
+    @Test
+    fun groupByAggregateWithoutInto_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val age by column<Int>()
+        val name by columnGroup()
+
+        df.groupBy { city }.aggregate { maxBy { age() }[name] }
+        // or
+        df.groupBy(city).aggregate { maxBy(age)[name] }
+        // SampleEnd
+    }
+
+    @Test
+    fun groupByAggregateWithoutInto_strings() {
+        // SampleStart
+        df.groupBy("city").aggregate { maxBy("age")["name"] }
+        // SampleEnd
+    }
+
+    @Test
+    fun groupByDirectAggregations_properties() {
+        // SampleStart
+        df.groupBy { city }.max() // max for every comparable column
+        df.groupBy { city }.mean() // mean for every numeric column
+        df.groupBy { city }.max { age } // max age into column "age"
+        df.groupBy { city }.sum("total weight") { weight } // sum of weights into column "total weight"
+        df.groupBy { city }.count() // number of rows into column "count"
+        df.groupBy { city }
+            .max { name.firstName.length() and name.lastName.length() } // maximum length of firstName or lastName into column "max"
+        df.groupBy { city }
+            .medianFor { age and weight } // median age into column "age", median weight into column "weight"
+        df.groupBy { city }
+            .minFor { (age into "min age") and (weight into "min weight") } // min age into column "min age", min weight into column "min weight"
+        df.groupBy { city }.meanOf("mean ratio") { weight?.div(age) } // mean of weight/age into column "mean ratio"
+        // SampleEnd
+    }
+
+    @Test
+    fun groupByDirectAggregations_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val age by column<Int>()
+        val weight by column<Int?>()
+        val name by columnGroup()
+        val firstName by name.column<String>()
+        val lastName by name.column<String>()
+
+        df.groupBy { city }.max() // max for every comparable column
+        df.groupBy { city }.mean() // mean for every numeric column
+        df.groupBy { city }.max { age } // max age into column "age"
+        df.groupBy { city }.sum("total weight") { weight } // sum of weights into column "total weight"
+        df.groupBy { city }.count() // number of rows into column "count"
+        df.groupBy { city }
+            .max { firstName.length() and lastName.length() } // maximum length of firstName or lastName into column "max"
+        df.groupBy { city }
+            .medianFor { age and weight } // median age into column "age", median weight into column "weight"
+        df.groupBy { city }
+            .minFor { (age into "min age") and (weight into "min weight") } // min age into column "min age", min weight into column "min weight"
+        df.groupBy { city }.meanOf("mean ratio") { weight()?.div(age()) } // mean of weight/age into column "mean ratio"
+        // SampleEnd
+    }
+
+    @Test
+    fun groupByDirectAggregations_strings() {
+        // SampleStart
+        df.groupBy("city").max() // max for every comparable column
+        df.groupBy("city").mean() // mean for every numeric column
+        df.groupBy("city").max("age") // max age into column "age"
+        df.groupBy("city").sum("weight", name = "total weight") // sum of weights into column "total weight"
+        df.groupBy("city").count() // number of rows into column "count"
+        df.groupBy("city").max {
+            "name"["firstName"]<String>().length() and "name"["lastName"]<String>().length()
+        } // maximum length of firstName or lastName into column "max"
+        df.groupBy("city")
+            .medianFor("age", "weight") // median age into column "age", median weight into column "weight"
+        df.groupBy("city")
+            .minFor { ("age"<Int>() into "min age") and ("weight"<Int?>() into "min weight") } // min age into column "min age", min weight into column "min weight"
+        df.groupBy("city").meanOf("mean ratio") {
+            "weight"<Int?>()?.div("age"<Int>())
+        } // mean of weight/age into column "mean ratio"
+        // SampleEnd
+    }
+
+    @Test
+    fun groupByWithoutAggregation_properties() {
+        // SampleStart
+        df.groupBy { city }.values()
+        df.groupBy { city }.values { name and age }
+        df.groupBy { city }.values { weight into "weights" }
+        // SampleEnd
+    }
+
+    @Test
+    fun groupByWithoutAggregation_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val age by column<Int>()
+        val weight by column<Int?>()
+        val name by columnGroup()
+
+        df.groupBy(city).values()
+        df.groupBy(city).values(name, age)
+        df.groupBy(city).values { weight into "weights" }
+        // SampleEnd
+    }
+
+    @Test
+    fun groupByWithoutAggregation_strings() {
+        // SampleStart
+        df.groupBy("city").values()
+        df.groupBy("city").values("name", "age")
+        df.groupBy("city").values { "weight" into "weights" }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivot_properties() {
+        // SampleStart
+        df.pivot { city }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivot_accessors() {
+        // SampleStart
+        val city by column<String?>()
+
+        df.pivot { city }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivot_strings() {
+        // SampleStart
+        df.pivot("city")
+        // SampleEnd
+    }
+
+    @Test
+    fun pivot2_properties() {
+        // SampleStart
+        df.pivot { city and name.firstName }
+        df.pivot { city then name.firstName }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivot2_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val name by columnGroup()
+        val firstName by name.column<String>()
+
+        df.pivot { city and firstName }
+        df.pivot { city then firstName }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivot2_strings() {
+        // SampleStart
+        df.pivot { "city" and "name"["firstName"] }
+        df.pivot { "city" then "name"["firstName"] }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotInward_properties() {
+        // SampleStart
+        df.pivot(inward = true) { city }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotInward_accessors() {
+        // SampleStart
+        val city by column<String?>()
+
+        df.pivot(inward = true) { city }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotInward_strings() {
+        // SampleStart
+        df.pivot("city", inward = true)
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotAsDataRowOrFrame() {
+        // SampleStart
+        df.pivot { city }.frames()
+        df.pivot { city }.groupBy { name }.frames()
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotGroupBy_properties() {
+        // SampleStart
+        df.pivot { city }.groupBy { name }
+        // same as
+        df.groupBy { name }.pivot { city }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotGroupBy_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val name by columnGroup()
+
+        df.pivot { city }.groupBy { name }
+        // same as
+        df.groupBy { name }.pivot { city }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotGroupBy_strings() {
+        // SampleStart
+        df.pivot("city").groupBy("name")
+        // same as
+        df.groupBy("name").pivot("city")
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotGroupByOther() {
+        // SampleStart
+        df.pivot { city }.groupByOther()
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotAggregate_properties() {
+        // SampleStart
+        df.pivot { city }.aggregate { minBy { age }.name }
+        df.pivot { city }.groupBy { name.firstName }.aggregate {
+            meanFor { age and weight } into "means"
+            stdFor { age and weight } into "stds"
+            maxByOrNull { weight }?.name?.lastName into "biggest"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotAggregate_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val name by columnGroup()
+        val firstName by name.column<String>()
+        val age by column<Int>()
+        val weight by column<Int?>()
+
+        df.pivot { city }.aggregate { minBy(age).name }
+
+        df.pivot { city }.groupBy { firstName }.aggregate {
+            meanFor { age and weight } into "means"
+            stdFor { age and weight } into "stds"
+            maxByOrNull(weight)?.name?.lastName into "biggest"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotAggregate_strings() {
+        // SampleStart
+        df.pivot("city").aggregate { minBy("age")["name"] }
+
+        df.pivot("city").groupBy { "name"["firstName"] }.aggregate {
+            meanFor("age", "weight") into "means"
+            stdFor("age", "weight") into "stds"
+            maxByOrNull("weight")?.getColumnGroup("name")?.get("lastName") into "biggest"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotCommonAggregations_properties() {
+        // SampleStart
+        df.pivot { city }.maxFor { age and weight }
+        df.groupBy { name }.pivot { city }.median { age }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotCommonAggregations_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val name by columnGroup()
+        val age by column<Int>()
+        val weight by column<Int?>()
+
+        df.pivot { city }.maxFor { age and weight }
+        df.groupBy { name }.pivot { city }.median { age }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotCommonAggregations_strings() {
+        // SampleStart
+        df.pivot("city").maxFor("age", "weight")
+        df.groupBy("name").pivot("city").median("age")
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotSeparate_properties() {
+        // SampleStart
+        df.pivot { city }.maxFor(separate = true) { age and weight }
+        df.pivot { city }.aggregate(separate = true) {
+            min { age } into "min age"
+            maxOrNull { weight } into "max weight"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotSeparate_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val age by column<Int>()
+        val weight by column<Int?>()
+
+        df.pivot { city }.maxFor(separate = true) { age and weight }
+        df.pivot { city }.aggregate(separate = true) {
+            min { age } into "min age"
+            maxOrNull { weight } into "max weight"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotSeparate_strings() {
+        // SampleStart
+        df.pivot("city").maxFor("age", "weight", separate = true)
+        df.pivot("city").aggregate(separate = true) {
+            min("age") into "min age"
+            maxOrNull("weight") into "max weight"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotDefault_properties() {
+        // SampleStart
+        df.pivot { city }.groupBy { name }.aggregate { min { age } default 0 }
+        df.pivot { city }.groupBy { name }.aggregate {
+            median { age } into "median age" default 0
+            minOrNull { weight } into "min weight" default 100
+        }
+        df.pivot { city }.groupBy { name }.default(0).min()
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotDefault_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val age by column<Int>()
+        val weight by column<Int?>()
+        val name by columnGroup()
+
+        df.pivot { city }.groupBy { name }.aggregate { min { age } default 0 }
+        df.pivot { city }.groupBy { name }.aggregate {
+            median { age } into "median age" default 0
+            minOrNull { weight } into "min weight" default 100
+        }
+        df.pivot { city }.groupBy { name }.default(0).min()
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotDefault_strings() {
+        // SampleStart
+        df.pivot("city").groupBy("name").aggregate { min("age") default 0 }
+        df.pivot("city").groupBy("name").aggregate {
+            median("age") into "median age" default 0
+            minOrNull("weight") into "min weight" default 100
+        }
+        df.pivot("city").groupBy("name").default(0).min()
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotInAggregate_properties() {
+        // SampleStart
+        df.groupBy { name.firstName }.aggregate {
+            pivot { city }.aggregate(separate = true) {
+                mean { age } into "mean age"
+                count() into "count"
+            }
+            count() into "total"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotInAggregate_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val name by columnGroup()
+        val firstName by name.column<String>()
+        val age by column<Int>()
+
+        df.groupBy { firstName }.aggregate {
+            pivot { city }.aggregate(separate = true) {
+                mean { age } into "mean age"
+                count() into "count"
+            }
+            count() into "total"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotInAggregate_strings() {
+        // SampleStart
+        df.groupBy { "name"["firstName"] }.aggregate {
+            pivot("city").aggregate(separate = true) {
+                mean("age") into "mean age"
+                count() into "count"
+            }
+            count() into "total"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotCounts() {
+        // SampleStart
+        df.pivotCounts { city }
+        // same as
+        df.pivot { city }.groupByOther().count()
+
+        df.groupBy { name }.pivotCounts { city }
+        // same as
+        df.groupBy { name }.pivot { city }.count()
+        // same as
+        df.groupBy { name }.aggregate {
+            pivotCounts { city }
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun pivotMatches() {
+        // SampleStart
+        df.pivotMatches { city }
+        // same as
+        df.pivot { city }.groupByOther().matches()
+
+        df.groupBy { name }.pivotMatches { city }
+        // same as
+        df.groupBy { name }.pivot { city }.matches()
+        // same as
+        df.groupBy { name }.aggregate {
+            pivotMatches { city }
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun cumSum() {
+        // SampleStart
+        df.cumSum { weight }
+        df.weight.cumSum()
+        df.groupBy { city }.cumSum { weight }.concat()
+        // SampleEnd
+    }
+
+    @Test
+    fun valueCounts() {
+        // SampleStart
+        df.city.valueCounts()
+
+        df.valueCounts { name and city }
+        // SampleEnd
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/samples/ApiLevels.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/ApiLevels.kt
similarity index 57%
rename from core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/samples/ApiLevels.kt
rename to core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/ApiLevels.kt
index 81c553b0c..8daa74e1d 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/samples/ApiLevels.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/ApiLevels.kt
@@ -1,12 +1,8 @@
-@file:Suppress("RemoveExplicitTypeArguments")
+package org.jetbrains.kotlinx.dataframe.samples.api
 
-package org.jetbrains.kotlinx.dataframe.documentation.samples
-
-import org.jetbrains.kotlinx.dataframe.ColumnsContainer
-import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.annotations.ColumnName
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
 import org.jetbrains.kotlinx.dataframe.api.add
 import org.jetbrains.kotlinx.dataframe.api.cast
 import org.jetbrains.kotlinx.dataframe.api.column
@@ -14,9 +10,13 @@ import org.jetbrains.kotlinx.dataframe.api.dropNulls
 import org.jetbrains.kotlinx.dataframe.api.filter
 import org.jetbrains.kotlinx.dataframe.api.toListOf
 import org.jetbrains.kotlinx.dataframe.io.read
+import org.junit.Ignore
+import org.junit.Test
 
-internal interface ApiLevels {
+@Ignore
+class ApiLevels {
 
+    @Test
     fun strings() {
         // SampleStart
         DataFrame.read("titanic.csv")
@@ -30,6 +30,7 @@ internal interface ApiLevels {
         // SampleEnd
     }
 
+    @Test
     fun accessors1() {
         // SampleStart
         val survived by column<Boolean>() // accessor for Boolean column with name 'survived'
@@ -40,13 +41,14 @@ internal interface ApiLevels {
         // SampleEnd
     }
 
+    @Test
     fun accessors2() {
-        // SampleStart
         val survived by column<Boolean>()
         val home by column<String>()
         val age by column<Int?>()
         val name by column<String>()
         val lastName by column<String>()
+        // SampleStart
 
         DataFrame.read("titanic.csv")
             .add(lastName) { name().split(",").last() }
@@ -55,6 +57,7 @@ internal interface ApiLevels {
         // SampleEnd
     }
 
+    @Test
     fun accessors3() {
         // SampleStart
         val survived by column<Boolean>()
@@ -70,6 +73,7 @@ internal interface ApiLevels {
         // SampleEnd
     }
 
+    @Test
     fun kproperties1() {
         // SampleStart
         data class Passenger(
@@ -91,6 +95,7 @@ internal interface ApiLevels {
         // SampleEnd
     }
 
+    @Test
     fun kproperties2() {
         // SampleStart
         data class Passenger(
@@ -105,7 +110,7 @@ internal interface ApiLevels {
         // SampleEnd
     }
 
-    //    @DataSchema
+    @DataSchema
     interface TitanicPassenger {
         val survived: Boolean
         val home: String
@@ -113,34 +118,20 @@ internal interface ApiLevels {
         val name: String
     }
 
+    @Test
     fun extensionProperties2() {
-        // SampleStart
         val df = DataFrame.read("titanic.csv").cast<TitanicPassenger>()
-
+        // SampleStart
         df.add("lastName") { name.split(",").last() }
             .dropNulls { age }
             .filter { survived && home.endsWith("NY") && age in 10..20 }
         // SampleEnd
     }
 
+    @Test
     fun extensionProperties1() {
+        // SampleStart
         val df = DataFrame.read("titanic.csv")
+        // SampleEnd
     }
 }
-
-internal val ColumnsContainer<ApiLevels.TitanicPassenger>.age: DataColumn<Int> @JvmName("TitanicPassenger_age") get() = this["age"] as DataColumn<Int>
-internal val DataRow<ApiLevels.TitanicPassenger>.age: Int @JvmName("TitanicPassenger_age") get() = this["age"] as Int
-internal val ColumnsContainer<ApiLevels.TitanicPassenger?>.age: DataColumn<Int?> @JvmName("NullableTitanicPassenger_age") get() = this["age"] as DataColumn<Int?>
-internal val DataRow<ApiLevels.TitanicPassenger?>.age: Int? @JvmName("NullableTitanicPassenger_age") get() = this["age"] as Int?
-internal val ColumnsContainer<ApiLevels.TitanicPassenger>.home: DataColumn<String> @JvmName("TitanicPassenger_home") get() = this["home"] as DataColumn<String>
-internal val DataRow<ApiLevels.TitanicPassenger>.home: String @JvmName("TitanicPassenger_home") get() = this["home"] as String
-internal val ColumnsContainer<ApiLevels.TitanicPassenger?>.home: DataColumn<String?> @JvmName("NullableTitanicPassenger_home") get() = this["home"] as DataColumn<String?>
-internal val DataRow<ApiLevels.TitanicPassenger?>.home: String? @JvmName("NullableTitanicPassenger_home") get() = this["home"] as String?
-internal val ColumnsContainer<ApiLevels.TitanicPassenger>.name: DataColumn<String> @JvmName("TitanicPassenger_name") get() = this["name"] as DataColumn<String>
-internal val DataRow<ApiLevels.TitanicPassenger>.name: String @JvmName("TitanicPassenger_name") get() = this["name"] as String
-internal val ColumnsContainer<ApiLevels.TitanicPassenger?>.name: DataColumn<String?> @JvmName("NullableTitanicPassenger_name") get() = this["name"] as DataColumn<String?>
-internal val DataRow<ApiLevels.TitanicPassenger?>.name: String? @JvmName("NullableTitanicPassenger_name") get() = this["name"] as String?
-internal val ColumnsContainer<ApiLevels.TitanicPassenger>.survived: DataColumn<Boolean> @JvmName("TitanicPassenger_survived") get() = this["survived"] as DataColumn<Boolean>
-internal val DataRow<ApiLevels.TitanicPassenger>.survived: Boolean @JvmName("TitanicPassenger_survived") get() = this["survived"] as Boolean
-internal val ColumnsContainer<ApiLevels.TitanicPassenger?>.survived: DataColumn<Boolean?> @JvmName("NullableTitanicPassenger_survived") get() = this["survived"] as DataColumn<Boolean?>
-internal val DataRow<ApiLevels.TitanicPassenger?>.survived: Boolean? @JvmName("NullableTitanicPassenger_survived") get() = this["survived"] as Boolean?
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Collections.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Collections.kt
new file mode 100644
index 000000000..5e9ff8ced
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Collections.kt
@@ -0,0 +1,81 @@
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.group
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.api.toListOf
+import org.junit.Test
+
+class Collections {
+
+    @Test
+    fun listInterop1() {
+        // SampleStart
+        data class Input(val a: Int, val b: Int)
+
+        val list = listOf(Input(1, 2), Input(3, 4))
+        // SampleEnd
+    }
+
+    @Test
+    fun listInterop2() {
+        data class Input(val a: Int, val b: Int)
+        val list = listOf(Input(1, 2), Input(3, 4))
+        // SampleStart
+        val df = list.toDataFrame()
+        // SampleEnd
+    }
+
+    @Test
+    fun listInterop3() {
+        val list = listOf(Input(1, 2), Input(3, 4))
+        val df = list.toDataFrame()
+
+        // SampleStart
+        @DataSchema
+        data class Input(val a: Int, val b: Int)
+
+        val df2 = df.add("c") { a + b }
+        // SampleEnd
+    }
+
+    @DataSchema
+    data class Input(val a: Int, val b: Int)
+
+    @DataSchema
+    interface Input2 {
+        val a: Int
+        val b: Int
+    }
+
+    @Test
+    fun listInterop4() {
+        val list = listOf(Input(1, 2), Input(3, 4))
+        val df2 = list.toDataFrame().add("c") { a + b }
+
+        // SampleStart
+        data class Output(val a: Int, val b: Int, val c: Int)
+
+        val result = df2.toListOf<Output>()
+        // SampleEnd
+    }
+
+    @Test
+    fun listInterop5() {
+        // SampleStart
+        val df = dataFrameOf("name", "lastName", "age")("John", "Doe", 21)
+            .group("name", "lastName").into("fullName")
+
+        data class FullName(val name: String, val lastName: String)
+        data class Person(val fullName: FullName, val age: Int)
+
+        val persons = df.toListOf<Person>() // [Person(fullName = FullName(name = "John", lastName = "Doe"), age = 21)]
+        // SampleEnd
+
+        persons shouldBe listOf(Person(FullName("John", "Doe"), 21))
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Create.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Create.kt
new file mode 100644
index 000000000..a6168fe98
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Create.kt
@@ -0,0 +1,389 @@
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.Infer
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnGroup
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.emptyDataFrame
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.frameColumn
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.named
+import org.jetbrains.kotlinx.dataframe.api.preserve
+import org.jetbrains.kotlinx.dataframe.api.print
+import org.jetbrains.kotlinx.dataframe.api.sortBy
+import org.jetbrains.kotlinx.dataframe.api.toColumn
+import org.jetbrains.kotlinx.dataframe.api.toColumnOf
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.api.withValues
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.kind
+import org.jetbrains.kotlinx.dataframe.type
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class Create : TestBase() {
+
+    @Test
+    fun createValueByColumnOf() {
+        // SampleStart
+        // Create ValueColumn with name 'student' and two elements of type String
+        val student by columnOf("Alice", "Bob")
+        // SampleEnd
+    }
+
+    @Test
+    fun createValueByToColumn() {
+        // SampleStart
+        listOf("Alice", "Bob").toColumn("name")
+        // SampleEnd
+    }
+
+    @Test
+    fun columnAccessorsUsage() {
+        // SampleStart
+        val age by column<Int>()
+
+        // Access fourth cell in the "age" column of dataframe `df`.
+        // This expression returns `Int` because variable `age` has `ColumnAccessor<Int>` type.
+        // If dataframe `df` has no column "age" or column "age" has type which is incompatible with `Int`,
+        // runtime exception will be thrown.
+        df[age][3] + 5
+
+        // Access first cell in the "age" column of dataframe `df`.
+        df[0][age] * 2
+
+        // Returns new dataframe sorted by age column (ascending)
+        df.sortBy(age)
+
+        // Returns new dataframe with the column "year of birth" added
+        df.add("year of birth") { 2021 - age }
+
+        // Returns new dataframe containing only rows with age > 30
+        df.filter { age > 30 }
+        // SampleEnd
+    }
+
+    @Test
+    fun columnAccessorToColumn() {
+        // SampleStart
+        val age by column<Int>()
+        val ageCol1 = age.withValues(15, 20)
+        val ageCol2 = age.withValues(1..10)
+        // SampleEnd
+
+        ageCol2.size() shouldBe 10
+    }
+
+    @Test
+    fun columnAccessorMap() {
+        // SampleStart
+        val age by column<Int>()
+        val year by age.map { 2021 - it }
+
+        df.filter { year > 2000 }
+        // SampleEnd
+    }
+
+    @Test
+    fun columnAccessorComputed_properties() {
+        // SampleStart
+        val fullName by column(df) { name.firstName + " " + name.lastName }
+
+        df[fullName]
+        // SampleEnd
+    }
+
+    @Test
+    fun columnAccessorComputed_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val firstName by name.column<String>()
+        val lastName by name.column<String>()
+
+        val fullName by column { firstName() + " " + lastName() }
+
+        df[fullName]
+        // SampleEnd
+    }
+
+    @Test
+    fun columnAccessorComputed_strings() {
+        // SampleStart
+
+        val fullName by column { "name"["firstName"]<String>() + " " + "name"["lastName"]<String>() }
+
+        df[fullName]
+        // SampleEnd
+    }
+
+    @Test
+    fun createValueColumnInferred() {
+        // SampleStart
+        val values: List<Any?> = listOf(1, 2.5)
+
+        values.toColumn("data") // type: Any?
+        values.toColumn("data", Infer.Type) // type: Number
+        values.toColumn("data", Infer.Nulls) // type: Any
+        // SampleEnd
+    }
+
+    @Test
+    fun createValueColumnOfType() {
+        // SampleStart
+        val values: List<Any?> = listOf(1, 2.5)
+
+        values.toColumnOf<Number?>("data") // type: Number?
+        // SampleEnd
+    }
+
+    @Test
+    fun createColumnRenamed() {
+        // SampleStart
+        val column = columnOf("Alice", "Bob") named "student"
+        // SampleEnd
+    }
+
+    @Test
+    fun createColumnGroup() {
+        // SampleStart
+        val firstName by columnOf("Alice", "Bob")
+        val lastName by columnOf("Cooper", "Marley")
+
+        // Create ColumnGroup with two nested columns
+        val fullName by columnOf(firstName, lastName)
+        // SampleEnd
+    }
+
+    @Test
+    fun createFrameColumn() {
+        // SampleStart
+        val df1 = dataFrameOf("name", "age")("Alice", 20, "Bob", 25)
+        val df2 = dataFrameOf("name", "temp")("Charlie", 36.6)
+
+        // Create FrameColumn with two elements of type DataFrame
+        val frames by columnOf(df1, df2)
+        // SampleEnd
+    }
+
+    @Test
+    fun createColumnAccessor() {
+        // SampleStart
+        val name by column<String>()
+        // SampleEnd
+    }
+
+    @Test
+    fun createColumnAccessorRenamed() {
+        // SampleStart
+        val accessor by column<String>("complex column name")
+        // SampleEnd
+        accessor.name() shouldBe "complex column name"
+    }
+
+    @Test
+    fun createDeepColumnAccessor() {
+        // SampleStart
+        val name by columnGroup()
+        val firstName by name.column<String>()
+        // SampleEnd
+    }
+
+    @Test
+    fun createGroupOrFrameColumnAccessor() {
+        // SampleStart
+        val columns by columnGroup()
+        val frames by frameColumn()
+        // SampleEnd
+    }
+
+    @Test
+    fun createEmptyDataFrame() {
+        // SampleStart
+        val df = emptyDataFrame<Any>()
+        // SampleEnd
+        df.columnsCount() shouldBe 0
+        df.rowsCount() shouldBe 0
+    }
+
+    @Test
+    fun createDataFrameOf() {
+        // SampleStart
+        // DataFrame with 2 columns and 3 rows
+        val df = dataFrameOf("name", "age")(
+            "Alice", 15,
+            "Bob", 20,
+            "Charlie", 100
+        )
+        // SampleEnd
+    }
+
+    @Test
+    fun createDataFrameOfPairs() {
+        // SampleStart
+        // DataFrame with 2 columns and 3 rows
+        val df = dataFrameOf(
+            "name" to listOf("Alice", "Bob", "Charlie"),
+            "age" to listOf(15, 20, 100)
+        )
+        // SampleEnd
+    }
+
+    @Test
+    fun createDataFrameWithFill() {
+        // SampleStart
+        // Multiplication table
+        dataFrameOf(1..10) { x -> (1..10).map { x * it } }
+        // SampleEnd
+    }
+
+    @Test
+    fun createDataFrameFillConstant() {
+        // SampleStart
+        val names = listOf("first", "second", "third")
+
+        // DataFrame with 3 columns, fill each column with 15 `true` values
+        val df = dataFrameOf(names).fill(15, true)
+        // SampleEnd
+    }
+
+    @Test
+    fun createDataFrameWithRandom() {
+        // SampleStart
+        // 5 columns filled with 7 random double values:
+        val names = (1..5).map { "column$it" }
+        dataFrameOf(names).randomDouble(7)
+
+        // 5 columns filled with 7 random double values between 0 and 1 (inclusive)
+        dataFrameOf(names).randomDouble(7, 0.0..1.0).print()
+
+        // 5 columns filled with 7 random int values between 0 and 100 (inclusive)
+        dataFrameOf(names).randomInt(7, 0..100).print()
+        // SampleEnd
+    }
+
+    @Test
+    fun createDataFrameFromColumns() {
+        // SampleStart
+
+        val name by columnOf("Alice", "Bob", "Charlie")
+        val age by columnOf(15, 20, 22)
+
+        // DataFrame with 2 columns
+        val df = dataFrameOf(name, age)
+        // SampleEnd
+    }
+
+    @Test
+    fun createDataFrameFromMap() {
+        // SampleStart
+        val map = mapOf("name" to listOf("Alice", "Bob", "Charlie"), "age" to listOf(15, 20, 22))
+
+        // DataFrame with 2 columns
+        map.toDataFrame()
+        // SampleEnd
+    }
+
+    @Test
+    fun createDataFrameFromIterable() {
+        // SampleStart
+        val name by columnOf("Alice", "Bob", "Charlie")
+        val age by columnOf(15, 20, 22)
+
+        listOf(name, age).toDataFrame()
+        // SampleEnd
+    }
+
+    @Test
+    fun createDataFrameFromNamesAndValues() {
+        // SampleStart
+        val names = listOf("name", "age")
+        val values = listOf(
+            "Alice", 15,
+            "Bob", 20,
+            "Charlie", 22
+        )
+        val df = dataFrameOf(names, values)
+        // SampleEnd
+        df.columnNames() shouldBe listOf("name", "age")
+        df.rowsCount() shouldBe 3
+        df["name"].type() shouldBe typeOf<String>()
+        df["age"].type() shouldBe typeOf<Int>()
+    }
+
+    @Test
+    fun readDataFrameFromObject() {
+        // SampleStart
+        data class Person(val name: String, val age: Int)
+
+        val persons = listOf(Person("Alice", 15), Person("Bob", 20), Person("Charlie", 22))
+
+        val df = persons.toDataFrame()
+        // SampleEnd
+        df.columnsCount() shouldBe 2
+        df.rowsCount() shouldBe 3
+        df["name"].type() shouldBe typeOf<String>()
+        df["age"].type() shouldBe typeOf<Int>()
+    }
+
+    @Test
+    fun readDataFrameFromDeepObject() {
+        // SampleStart
+        data class Name(val firstName: String, val lastName: String)
+        data class Score(val subject: String, val value: Int)
+        data class Student(val name: Name, val age: Int, val scores: List<Score>)
+
+        val students = listOf(
+            Student(Name("Alice", "Cooper"), 15, listOf(Score("math", 4), Score("biology", 3))),
+            Student(Name("Bob", "Marley"), 20, listOf(Score("music", 5)))
+        )
+
+        val df = students.toDataFrame(maxDepth = 1)
+        // SampleEnd
+        df.columnsCount() shouldBe 3
+        df.rowsCount() shouldBe 2
+        df["name"].kind shouldBe ColumnKind.Group
+        df["name"]["firstName"].type() shouldBe typeOf<String>()
+        df["scores"].kind shouldBe ColumnKind.Frame
+    }
+
+    @Test
+    fun readDataFrameFromDeepObjectWithExclude() {
+        data class Name(val firstName: String, val lastName: String)
+        data class Score(val subject: String, val value: Int)
+        data class Student(val name: Name, val age: Int, val scores: List<Score>)
+
+        val students = listOf(
+            Student(Name("Alice", "Cooper"), 15, listOf(Score("math", 4), Score("biology", 3))),
+            Student(Name("Bob", "Marley"), 20, listOf(Score("music", 5)))
+        )
+
+        // SampleStart
+        val df = students.toDataFrame {
+            // add column
+            "year of birth" from { 2021 - it.age }
+
+            // scan all properties
+            properties(maxDepth = 1) {
+                exclude(Score::subject) // `subject` property will be skipped from object graph traversal
+                preserve<Name>() // `Name` objects will be stored as-is without transformation into DataFrame
+            }
+
+            // add column group
+            "summary" {
+                "max score" from { it.scores.maxOf { it.value } }
+                "min score" from { it.scores.minOf { it.value } }
+            }
+        }
+        // SampleEnd
+        df.columnsCount() shouldBe 5
+        df.rowsCount() shouldBe 2
+        df["name"].kind shouldBe ColumnKind.Value
+        df["name"].type shouldBe typeOf<Name>()
+        df["scores"].kind shouldBe ColumnKind.Frame
+        df["summary"]["min score"].values() shouldBe listOf(3, 5)
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/DataRowApi.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/DataRowApi.kt
new file mode 100644
index 000000000..275c8f029
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/DataRowApi.kt
@@ -0,0 +1,45 @@
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.at
+import org.jetbrains.kotlinx.dataframe.api.diff
+import org.jetbrains.kotlinx.dataframe.api.drop
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.pivot
+import org.jetbrains.kotlinx.dataframe.api.prev
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.api.where
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.api.withValue
+import org.junit.Test
+
+class DataRowApi : TestBase() {
+
+    @Test
+    fun expressions() {
+        // SampleStart
+        // Row expression computes values for a new column
+        df.add("fullName") { name.firstName + " " + name.lastName }
+
+        // Row expression computes updated values
+        df.update { weight }.at(1, 3, 4).with { prev()?.weight }
+
+        // Row expression computes cell content for values of pivoted column
+        df.pivot { city }.with { name.lastName.uppercase() }
+        // SampleEnd
+    }
+
+    @Test
+    fun conditions() {
+        // SampleStart
+        // Row condition is used to filter rows by index
+        df.filter { index() % 5 == 0 }
+
+        // Row condition is used to drop rows where `age` is the same as in previous row
+        df.drop { diff { age } == 0 }
+
+        // Row condition is used to filter rows for value update
+        df.update { weight }.where { index() > 4 && city != "Paris" }.withValue(50)
+        // SampleEnd
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Join.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Join.kt
new file mode 100644
index 000000000..675e5ced2
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Join.kt
@@ -0,0 +1,125 @@
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnGroup
+import org.jetbrains.kotlinx.dataframe.api.excludeJoin
+import org.jetbrains.kotlinx.dataframe.api.fullJoin
+import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.innerJoin
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.join
+import org.jetbrains.kotlinx.dataframe.api.leftJoin
+import org.jetbrains.kotlinx.dataframe.api.rename
+import org.jetbrains.kotlinx.dataframe.api.rightJoin
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.junit.Test
+
+class Join : TestBase() {
+
+    private val other = df.add("year") { 2021 - age }.select { name and city and "year" }
+
+    @Test
+    fun join_properties() {
+        // SampleStart
+        df.join(other) { name and city }
+        // SampleEnd
+    }
+
+    @Test
+    fun join_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val city by column<String>()
+
+        df.join(other) { name and city }
+        // SampleEnd
+    }
+
+    @Test
+    fun join_strings() {
+        // SampleStart
+        df.join(other, "name", "city")
+        // SampleEnd
+    }
+
+    @Test
+    fun joinDefault() {
+        // SampleStart
+        df.join(other)
+        // SampleEnd
+    }
+
+    class Right
+    val DataFrame<Right>.fullName: ColumnGroup<Name> get() = getColumnGroup("fullName").cast()
+
+    @Test
+    fun joinWithMatch_properties() {
+        val other = other.rename { name }.into("fullName").cast<Right>()
+        val joined =
+            // SampleStart
+            df.join(other) { name match right.fullName }
+        // SampleEnd
+        joined.rowsCount() shouldBe df.rowsCount()
+        joined.columnsCount() shouldBe df.columnsCount() + 2
+    }
+
+    @Test
+    fun joinWithMatch_accessors() {
+        val other = df.add("year") { 2021 - age }.select { name named "fullName" and "year" }
+        // SampleStart
+        val name by columnGroup()
+        val fullName by columnGroup()
+
+        df.join(other) { name match fullName }
+        // SampleEnd
+    }
+
+    @Test
+    fun joinWithMatch_strings() {
+        val other = df.add("year") { 2021 - age }.select { name named "fullName" and "year" }
+        // SampleStart
+        df.join(other) { "name" match "fullName" }
+        // SampleEnd
+    }
+
+    @Test
+    fun joinSpecial_properties() {
+        // SampleStart
+        df.innerJoin(other) { name and city }
+        df.leftJoin(other) { name and city }
+        df.rightJoin(other) { name and city }
+        df.fullJoin(other) { name and city }
+        df.excludeJoin(other) { name and city }
+        // SampleEnd
+    }
+
+    @Test
+    fun joinSpecial_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val city by column<String>()
+
+        df.innerJoin(other) { name and city }
+        df.leftJoin(other) { name and city }
+        df.rightJoin(other) { name and city }
+        df.fullJoin(other) { name and city }
+        df.excludeJoin(other) { name and city }
+        // SampleEnd
+    }
+
+    @Test
+    fun joinSpecial_strings() {
+        // SampleStart
+        df.innerJoin(other, "name", "city")
+        df.leftJoin(other, "name", "city")
+        df.rightJoin(other, "name", "city")
+        df.fullJoin(other, "name", "city")
+        df.excludeJoin(other, "name", "city")
+        // SampleEnd
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Modify.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Modify.kt
new file mode 100644
index 000000000..7c32b9d3e
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Modify.kt
@@ -0,0 +1,1256 @@
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.alsoDebug
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.ParserOptions
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.after
+import org.jetbrains.kotlinx.dataframe.api.asFrame
+import org.jetbrains.kotlinx.dataframe.api.asGroupBy
+import org.jetbrains.kotlinx.dataframe.api.at
+import org.jetbrains.kotlinx.dataframe.api.by
+import org.jetbrains.kotlinx.dataframe.api.byName
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.colsOf
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnGroup
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.convertTo
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.default
+import org.jetbrains.kotlinx.dataframe.api.dfsOf
+import org.jetbrains.kotlinx.dataframe.api.dropNulls
+import org.jetbrains.kotlinx.dataframe.api.explode
+import org.jetbrains.kotlinx.dataframe.api.fill
+import org.jetbrains.kotlinx.dataframe.api.fillNA
+import org.jetbrains.kotlinx.dataframe.api.fillNaNs
+import org.jetbrains.kotlinx.dataframe.api.fillNulls
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.flatten
+import org.jetbrains.kotlinx.dataframe.api.gather
+import org.jetbrains.kotlinx.dataframe.api.group
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.gt
+import org.jetbrains.kotlinx.dataframe.api.implode
+import org.jetbrains.kotlinx.dataframe.api.inplace
+import org.jetbrains.kotlinx.dataframe.api.insert
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.intoColumns
+import org.jetbrains.kotlinx.dataframe.api.intoList
+import org.jetbrains.kotlinx.dataframe.api.intoRows
+import org.jetbrains.kotlinx.dataframe.api.inward
+import org.jetbrains.kotlinx.dataframe.api.keysInto
+import org.jetbrains.kotlinx.dataframe.api.length
+import org.jetbrains.kotlinx.dataframe.api.lowercase
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.mapKeys
+import org.jetbrains.kotlinx.dataframe.api.mapToColumn
+import org.jetbrains.kotlinx.dataframe.api.mapToFrame
+import org.jetbrains.kotlinx.dataframe.api.mapValues
+import org.jetbrains.kotlinx.dataframe.api.match
+import org.jetbrains.kotlinx.dataframe.api.max
+import org.jetbrains.kotlinx.dataframe.api.mean
+import org.jetbrains.kotlinx.dataframe.api.meanFor
+import org.jetbrains.kotlinx.dataframe.api.merge
+import org.jetbrains.kotlinx.dataframe.api.minus
+import org.jetbrains.kotlinx.dataframe.api.move
+import org.jetbrains.kotlinx.dataframe.api.named
+import org.jetbrains.kotlinx.dataframe.api.notNull
+import org.jetbrains.kotlinx.dataframe.api.parse
+import org.jetbrains.kotlinx.dataframe.api.parser
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.api.perCol
+import org.jetbrains.kotlinx.dataframe.api.perRowCol
+import org.jetbrains.kotlinx.dataframe.api.pivotCounts
+import org.jetbrains.kotlinx.dataframe.api.prev
+import org.jetbrains.kotlinx.dataframe.api.print
+import org.jetbrains.kotlinx.dataframe.api.remove
+import org.jetbrains.kotlinx.dataframe.api.rename
+import org.jetbrains.kotlinx.dataframe.api.reorder
+import org.jetbrains.kotlinx.dataframe.api.replace
+import org.jetbrains.kotlinx.dataframe.api.reverse
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.jetbrains.kotlinx.dataframe.api.shuffle
+import org.jetbrains.kotlinx.dataframe.api.sortBy
+import org.jetbrains.kotlinx.dataframe.api.sortByDesc
+import org.jetbrains.kotlinx.dataframe.api.sortWith
+import org.jetbrains.kotlinx.dataframe.api.split
+import org.jetbrains.kotlinx.dataframe.api.sum
+import org.jetbrains.kotlinx.dataframe.api.to
+import org.jetbrains.kotlinx.dataframe.api.toFloat
+import org.jetbrains.kotlinx.dataframe.api.toLeft
+import org.jetbrains.kotlinx.dataframe.api.toMap
+import org.jetbrains.kotlinx.dataframe.api.toPath
+import org.jetbrains.kotlinx.dataframe.api.toTop
+import org.jetbrains.kotlinx.dataframe.api.under
+import org.jetbrains.kotlinx.dataframe.api.unfold
+import org.jetbrains.kotlinx.dataframe.api.ungroup
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.api.where
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.api.withNull
+import org.jetbrains.kotlinx.dataframe.api.withValue
+import org.jetbrains.kotlinx.dataframe.api.withZero
+import org.jetbrains.kotlinx.dataframe.impl.api.mapNotNullValues
+import org.jetbrains.kotlinx.dataframe.io.readJsonStr
+import org.jetbrains.kotlinx.dataframe.io.renderToString
+import org.jetbrains.kotlinx.dataframe.testResource
+import org.jetbrains.kotlinx.dataframe.types.UtilTests
+import org.junit.Test
+import java.net.URL
+import java.time.format.DateTimeFormatter
+import java.util.Locale
+import kotlin.streams.toList
+
+class Modify : TestBase() {
+
+    @Test
+    fun update() {
+        // SampleStart
+        df.update { age }.with { it * 2 }
+        df.update { dfsOf<String>() }.with { it.uppercase() }
+        df.update { weight }.at(1..4).notNull { it / 2 }
+        df.update { name.lastName and age }.at(1, 3, 4).withNull()
+        // SampleEnd
+    }
+
+    @Test
+    fun updateWith() {
+        // SampleStart
+        df.update { city }.with { name.firstName + " from " + it }
+        // SampleEnd
+    }
+
+    @Test
+    fun updateWithConst() {
+        // SampleStart
+        df.update { city }.where { name.firstName == "Alice" }.withValue("Paris")
+        // SampleEnd
+    }
+
+    @Test
+    fun updateAsFrame() {
+        val res =
+            // SampleStart
+            df.update { name }.asFrame { select { lastName } }
+        // SampleEnd
+        res shouldBe df.remove { name.firstName }
+    }
+
+    @Test
+    fun updatePerColumn() {
+        val updated =
+            // SampleStart
+            df.update { colsOf<Number?>() }.perCol { mean(skipNA = true) }
+        // SampleEnd
+        updated.age.countDistinct() shouldBe 1
+        updated.weight.countDistinct() shouldBe 1
+
+        val means = df.meanFor(skipNA = true) { colsOf() }
+        df.update { colsOf<Number?>() }.perCol(means) shouldBe updated
+        df.update { colsOf<Number?>() }.perCol(means.toMap() as Map<String, Double>) shouldBe updated
+    }
+
+    @Test
+    fun updatePerRowCol() {
+        val updated =
+            // SampleStart
+            df.update { colsOf<String?>() }.perRowCol { row, col -> col.name() + ": " + row.index() }
+        // SampleEnd
+    }
+
+    @Test
+    fun convert() {
+        // SampleStart
+        df.convert { age }.with { it.toDouble() }
+        df.convert { dfsOf<String>() }.with { it.toCharArray().toList() }
+        // SampleEnd
+    }
+
+    @Test
+    fun convertTo() {
+        // SampleStart
+        df.convert { age }.to<Double>()
+        df.convert { colsOf<Number>() }.to<String>()
+        df.convert { name.firstName and name.lastName }.to { it.length() }
+        df.convert { weight }.toFloat()
+        // SampleEnd
+    }
+
+    enum class Direction {
+        NORTH, SOUTH, WEST, EAST
+    }
+
+    @Test
+    fun convertToEnum() {
+        // SampleStart
+        dataFrameOf("direction")("NORTH", "WEST")
+            .convert("direction").to<Direction>()
+        // SampleEnd
+    }
+
+    @Test
+    fun parseAll() {
+        // SampleStart
+        df.parse()
+        // SampleEnd
+    }
+
+    @Test
+    fun parseSome() {
+        // SampleStart
+        df.parse { age and weight }
+        // SampleEnd
+    }
+
+    @Test
+    fun parseWithOptions() {
+        // SampleStart
+        df.parse(options = ParserOptions(locale = Locale.CHINA, dateTimeFormatter = DateTimeFormatter.ISO_WEEK_DATE))
+        // SampleEnd
+    }
+
+    @Test
+    fun globalParserOptions() {
+        // SampleStart
+        DataFrame.parser.locale = Locale.FRANCE
+        DataFrame.parser.addDateTimePattern("dd.MM.uuuu HH:mm:ss")
+        // SampleEnd
+        DataFrame.parser.resetToDefault()
+    }
+
+    @Test
+    fun replace() {
+        // SampleStart
+        df.replace { name }.with { name.firstName }
+        df.replace { colsOf<String?>() }.with { it.lowercase() }
+        df.replace { age }.with { 2021 - age named "year" }
+        // SampleEnd
+    }
+
+    @Test
+    fun shuffle() {
+        // SampleStart
+        df.shuffle()
+        // SampleEnd
+    }
+
+    @Test
+    fun reverse() {
+        // SampleStart
+        df.reverse()
+        // SampleEnd
+    }
+
+    @Test
+    fun fillNulls() {
+        // SampleStart
+        df.fillNulls { colsOf<Int?>() }.with { -1 }
+        // same as
+        df.update { colsOf<Int?>() }.where { it == null }.with { -1 }
+        // SampleEnd
+    }
+
+    @Test
+    fun fillNaNs() {
+        // SampleStart
+        df.fillNaNs { colsOf<Double>() }.withZero()
+        // SampleEnd
+    }
+
+    @Test
+    fun fillNA() {
+        // SampleStart
+        df.fillNA { weight }.withValue(-1)
+        // SampleEnd
+    }
+
+    @Test
+    fun move() {
+        // SampleStart
+        df.move { age }.toLeft()
+
+        df.move { weight }.to(1)
+
+        // age -> info.age
+        // weight -> info.weight
+        df.move { age and weight }.into { pathOf("info", it.name()) }
+        df.move { age and weight }.into { "info"[it.name()] }
+        df.move { age and weight }.under("info")
+
+        // name.firstName -> fullName.first
+        // name.lastName -> fullName.last
+        df.move { name.firstName and name.lastName }.into { pathOf("fullName", it.name().dropLast(4)) }
+
+        // a|b|c -> a.b.c
+        // a|d|e -> a.d.e
+        dataFrameOf("a|b|c", "a|d|e")(0, 0)
+            .move { all() }.into { it.name().split("|").toPath() }
+
+        // name.firstName -> firstName
+        // name.lastName -> lastName
+        df.move { name.cols() }.toTop()
+
+        // a.b.e -> be
+        // c.d.e -> de
+        df.move { dfs { it.name() == "e" } }.toTop { it.parentName + it.name() }
+        // SampleEnd
+    }
+
+    @Test
+    fun sortBy_properties() {
+        // SampleStart
+        df.sortBy { age }
+        df.sortBy { age and name.firstName.desc() }
+        df.sortBy { weight.nullsLast() }
+        // SampleEnd
+    }
+
+    @Test
+    fun sortBy_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val weight by column<Int?>()
+        val name by columnGroup()
+        val firstName by name.column<String>()
+
+        df.sortBy { age }
+        df.sortBy { age and firstName }
+        df.sortBy { weight.nullsLast() }
+        // SampleEnd
+    }
+
+    @Test
+    fun sortBy_strings() {
+        // SampleStart
+        df.sortBy("age")
+        df.sortBy { "age" and "name"["firstName"].desc() }
+        df.sortBy { "weight".nullsLast() }
+        // SampleEnd
+    }
+
+    @Test
+    fun sortByDesc_properties() {
+        // SampleStart
+        df.sortByDesc { age and weight }
+        // SampleEnd
+    }
+
+    @Test
+    fun sortByDesc_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val weight by column<Int?>()
+
+        df.sortByDesc { age and weight }
+        // SampleEnd
+    }
+
+    @Test
+    fun sortByDesc_strings() {
+        // SampleStart
+        df.sortByDesc("age", "weight")
+        // SampleEnd
+    }
+
+    @Test
+    fun sortWith() {
+        // SampleStart
+        df.sortWith { row1, row2 ->
+            when {
+                row1.age < row2.age -> -1
+                row1.age > row2.age -> 1
+                else -> row1.name.firstName.compareTo(row2.name.firstName)
+            }
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun reorder_properties() {
+        // SampleStart
+        df.reorder { age..isHappy }.byName()
+        // SampleEnd
+    }
+
+    @Test
+    fun reorder_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val isHappy by column<Boolean>()
+
+        df.reorder { age..isHappy }.byName()
+        // SampleEnd
+    }
+
+    @Test
+    fun reorder_strings() {
+        // SampleStart
+        df.reorder { "age".."isHappy" }.byName()
+    }
+
+    @Test
+    fun reorderSome() {
+        // SampleStart
+        val df = dataFrameOf("c", "d", "a", "b")(
+            3, 4, 1, 2,
+            1, 1, 1, 1
+        )
+        df.reorder("d", "b").cast<Int>().by { sum() } // [c, b, a, d]
+            // SampleEnd
+            .columnNames() shouldBe listOf("c", "b", "a", "d")
+        // SampleEnd
+    }
+
+    @Test
+    fun reorderInGroup() {
+        // SampleStart
+        df.reorder { name }.byName(desc = true) // [name.lastName, name.firstName]
+            // SampleEnd
+            .name.columnNames() shouldBe listOf("lastName", "firstName")
+    }
+
+    @Test
+    fun splitInplace_properties() {
+        // SampleStart
+        df.split { name.firstName }.by { it.chars().toList() }.inplace()
+        // SampleEnd
+    }
+
+    @Test
+    fun splitInplace_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val firstName by name.column<String>()
+
+        df.split { firstName }.by { it.chars().toList() }.inplace()
+        // SampleEnd
+    }
+
+    @Test
+    fun splitInplace_strings() {
+        // SampleStart
+        df.split { "name"["firstName"]<String>() }.by { it.chars().toList() }.inplace()
+        // SampleEnd
+    }
+
+    @Test
+    fun split_properties() {
+        // SampleStart
+        df.split { name }.by { it.values() }.into("nameParts")
+
+        df.split { name.lastName }.by(" ").default("").inward { "word$it" }
+        // SampleEnd
+    }
+
+    @Test
+    fun split_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val lastName by name.column<String>()
+
+        df.split { name }.by { it.values() }.into("nameParts")
+
+        df.split { lastName }.by(" ").default("").inward { "word$it" }
+        // SampleEnd
+    }
+
+    @Test
+    fun split_strings() {
+        // SampleStart
+        df.split { name }.by { it.values() }.into("nameParts")
+
+        df.split { "name"["lastName"] }.by(" ").default("").inward { "word$it" }
+        // SampleEnd
+    }
+
+    @Test
+    fun splitRegex() {
+        val merged = df.merge { name.lastName and name.firstName }.by { it[0] + " (" + it[1] + ")" }.into("name")
+        val name by column<String>()
+        // SampleStart
+        merged.split { name }
+            .match("""(.*) \((.*)\)""")
+            .inward("firstName", "lastName")
+        // SampleEnd
+    }
+
+    @Test
+    fun splitFrameColumn() {
+        // SampleStart
+        val df1 = dataFrameOf("a", "b", "c")(
+            1, 2, 3,
+            4, 5, 6
+        )
+        val df2 = dataFrameOf("a", "b")(
+            5, 6,
+            7, 8,
+            9, 10
+        )
+        val group by columnOf(df1, df2)
+        val id by columnOf("x", "y")
+        val df = dataFrameOf(id, group)
+
+        df.split { group }.intoColumns()
+        // SampleEnd
+    }
+
+    @Test
+    fun splitIntoRows_properties() {
+        // SampleStart
+        df.split { name.firstName }.by { it.chars().toList() }.intoRows()
+
+        df.split { name }.by { it.values() }.intoRows()
+        // SampleEnd
+    }
+
+    @Test
+    fun splitIntoRows_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val firstName by name.column<String>()
+
+        df.split { firstName }.by { it.chars().toList() }.intoRows()
+
+        df.split { name }.by { it.values() }.intoRows()
+        // SampleEnd
+    }
+
+    @Test
+    fun splitIntoRows_strings() {
+        // SampleStart
+        df.split { "name"["firstName"]<String>() }.by { it.chars().toList() }.intoRows()
+
+        df.split { group("name") }.by { it.values() }.intoRows()
+        // SampleEnd
+    }
+
+    @Test
+    fun merge() {
+        // SampleStart
+        // Merge two columns into one column "fullName"
+        df.merge { name.firstName and name.lastName }.by(" ").into("fullName")
+        // SampleEnd
+    }
+
+    @Test
+    fun mergeIntoList() {
+        // SampleStart
+        // Merge data from two columns into List<String>
+        df.merge { name.firstName and name.lastName }.by(",").intoList()
+        // SampleEnd
+    }
+
+    @Test
+    fun mergeSameWith() {
+        // SampleStart
+        df.merge { name.firstName and name.lastName }
+            .by { it[0] + " (" + it[1].uppercase() + ")" }
+            .into("fullName")
+        // SampleEnd
+    }
+
+    @Test
+    fun mergeDifferentWith() {
+        // SampleStart
+        df.merge { name.firstName and age and isHappy }
+            .by { "${it[0]} aged ${it[1]} is " + (if (it[2] as Boolean) "" else "not ") + "happy" }
+            .into("status")
+        // SampleEnd
+    }
+
+    @Test
+    fun mergeDefault() {
+        // SampleStart
+        df.merge { colsOf<Number>() }.into("data")
+        // SampleEnd
+    }
+
+    @Test
+    fun explode_accessors() {
+        // SampleStart
+        val a by columnOf(1, 2)
+        val b by columnOf(listOf(1, 2), listOf(3, 4))
+
+        val df = dataFrameOf(a, b)
+
+        df.explode { b }
+        // SampleEnd
+    }
+
+    @Test
+    fun explode_strings() {
+        // SampleStart
+        val df = dataFrameOf("a", "b")(
+            1, listOf(1, 2),
+            2, listOf(3, 4)
+        )
+
+        df.explode("b")
+        // SampleEnd
+    }
+
+    @Test
+    fun explodeSeveral() {
+        // SampleStart
+        val a by columnOf(listOf(1, 2), listOf(3, 4, 5))
+        val b by columnOf(listOf(1, 2, 3), listOf(4, 5))
+
+        val df = dataFrameOf(a, b)
+        df.explode { a and b }
+        // SampleEnd
+    }
+
+    @Test
+    fun explodeColumnList() {
+        // SampleStart
+        val col by columnOf(listOf(1, 2), listOf(3, 4))
+
+        col.explode()
+        // SampleEnd
+    }
+
+    @Test
+    fun explodeColumnFrames() {
+        // SampleStart
+        val col by columnOf(
+            dataFrameOf("a", "b")(1, 2, 3, 4),
+            dataFrameOf("a", "b")(5, 6, 7, 8)
+        )
+
+        col.explode()
+        // SampleEnd
+    }
+
+    @Test
+    fun implode() {
+        // SampleStart
+        df.implode { name and age and weight and isHappy }
+        // SampleEnd
+    }
+
+    @Test
+    fun gatherNames() {
+        val pivoted = df.dropNulls { city }.pivotCounts(inward = false) { city }
+        // SampleStart
+        pivoted.gather { "London".."Tokyo" }.cast<Int>()
+            .where { it > 0 }.keysInto("city")
+        // SampleEnd
+    }
+
+    @Test
+    fun gather() {
+        val pivoted = df.dropNulls { city }.pivotCounts(inward = false) { city }
+        // SampleStart
+        pivoted.gather { "London".."Tokyo" }.into("city", "population")
+        // SampleEnd
+    }
+
+    @Test
+    fun gatherWithMapping() {
+        val pivoted = df.dropNulls { city }.pivotCounts(inward = false) { city }
+        // SampleStart
+        pivoted.gather { "London".."Tokyo" }
+            .cast<Int>()
+            .where { it > 10 }
+            .mapKeys { it.lowercase() }
+            .mapValues { 1.0 / it }
+            .into("city", "density")
+        // SampleEnd
+    }
+
+    @Test
+    fun insert_properties() {
+        // SampleStart
+        df.insert("year of birth") { 2021 - age }.after { age }
+        // SampleEnd
+    }
+
+    @Test
+    fun insert_accessors() {
+        // SampleStart
+        val year = column<Int>("year of birth")
+        val age by column<Int>()
+
+        df.insert(year) { 2021 - age }.after { age }
+        // SampleEnd
+    }
+
+    @Test
+    fun insert_strings() {
+        // SampleStart
+        df.insert("year of birth") { 2021 - "age"<Int>() }.after("age")
+        // SampleEnd
+    }
+
+    @Test
+    fun insertColumn() {
+        // SampleStart
+        val score by columnOf(4, 5, 3, 5, 4, 5, 3)
+        df.insert(score).at(2)
+        // SampleEnd
+    }
+
+    @Test
+    fun concatDfs() {
+        val df1 = df
+        val df2 = df
+        // SampleStart
+        df.concat(df1, df2)
+        // SampleEnd
+    }
+
+    @Test
+    fun concatColumns() {
+        // SampleStart
+        val a by columnOf(1, 2)
+        val b by columnOf(3, 4)
+        a.concat(b)
+            // SampleEnd
+            .shouldBe(columnOf(1, 2, 3, 4).named("a"))
+    }
+
+    @Test
+    fun concatColumnsIterable() {
+        // SampleStart
+        val a by columnOf(1, 2)
+        val b by columnOf(3, 4)
+        listOf(a, b).concat()
+            // SampleEnd
+            .shouldBe(columnOf(1, 2, 3, 4).named("a"))
+    }
+
+    @Test
+    fun concatIterable() {
+        val df1 = df
+        val df2 = df
+        // SampleStart
+        listOf(df1, df2).concat()
+        // SampleEnd
+    }
+
+    @Test
+    fun concatRows() {
+        // SampleStart
+        val rows = listOf(df[2], df[4], df[5])
+        rows.concat()
+        // SampleEnd
+    }
+
+    @Test
+    fun concatFrameColumn() {
+        // SampleStart
+        val x = dataFrameOf("a", "b")(
+            1, 2,
+            3, 4
+        )
+        val y = dataFrameOf("b", "c")(
+            5, 6,
+            7, 8
+        )
+        val frameColumn by columnOf(x, y)
+        frameColumn.concat()
+        // SampleEnd
+    }
+
+    @Test
+    fun concatGroupBy() {
+        // SampleStart
+        df.groupBy { name }.concat()
+        // SampleEnd
+    }
+
+    @Test
+    fun add_properties() {
+        // SampleStart
+        df.add("year of birth") { 2021 - age }
+        // SampleEnd
+    }
+
+    @Test
+    fun add_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val yearOfBirth by column<Int>("year of birth")
+
+        df.add(yearOfBirth) { 2021 - age }
+        // SampleEnd
+        val added = df.add(yearOfBirth) { 2021 - age }
+        added[yearOfBirth].name() shouldBe "year of birth"
+    }
+
+    @Test
+    fun add_strings() {
+        // SampleStart
+        df.add("year of birth") { 2021 - "age"<Int>() }
+        // SampleEnd
+    }
+
+    @Test
+    fun addRecurrent() {
+        // SampleStart
+        df.add("fibonacci") {
+            if (index() < 2) 1
+            else prev()!!.newValue<Int>() + prev()!!.prev()!!.newValue<Int>()
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun addExisting() {
+        // SampleStart
+        val score by columnOf(4, 3, 5, 2, 1, 3, 5)
+
+        df.add(score)
+        df + score
+        // SampleEnd
+    }
+
+    @Test
+    fun addDfs() {
+        val df1 = df.select { name named "name2" }
+        val df2 = df.select { age named "age2" }
+        // SampleStart
+        df.add(df1, df2)
+        // SampleEnd
+    }
+
+    private class CityInfo(val city: String?, val population: Int, val location: String)
+    private fun queryCityInfo(city: String?): CityInfo { return CityInfo(city, city?.length ?: 0, "35.5 32.2") }
+
+    @Test
+    fun addCalculatedApi() {
+        // SampleStart
+        class CityInfo(val city: String?, val population: Int, val location: String)
+        fun queryCityInfo(city: String?): CityInfo {
+            return CityInfo(city, city?.length ?: 0, "35.5 32.2")
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun addCalculated_properties() {
+        // SampleStart
+        val personWithCityInfo = df.add {
+            val cityInfo = city.map { queryCityInfo(it) }
+            "cityInfo" {
+                cityInfo.map { it.location } into CityInfo::location
+                cityInfo.map { it.population } into "population"
+            }
+        }
+        // SampleEnd
+        personWithCityInfo["cityInfo"]["population"] shouldBe df.city.map { it?.length ?: 0 }.named("population")
+    }
+
+    @Test
+    fun addCalculated_accessors() {
+        // SampleStart
+        val city by column<String?>()
+        val personWithCityInfo = df.add {
+            val cityInfo = city().map { queryCityInfo(it) }
+            "cityInfo" {
+                cityInfo.map { it.location } into CityInfo::location
+                cityInfo.map { it.population } into "population"
+            }
+        }
+        // SampleEnd
+        personWithCityInfo["cityInfo"]["population"] shouldBe df.city.map { it?.length ?: 0 }.named("population")
+    }
+
+    @Test
+    fun addCalculated_strings() {
+        // SampleStart
+        val personWithCityInfo = df.add {
+            val cityInfo = "city"<String?>().map { queryCityInfo(it) }
+            "cityInfo" {
+                cityInfo.map { it.location } into CityInfo::location
+                cityInfo.map { it.population } into "population"
+            }
+        }
+        // SampleEnd
+        personWithCityInfo["cityInfo"]["population"] shouldBe df.city.map { it?.length ?: 0 }.named("population")
+    }
+
+    @Test
+    fun addMany_properties() {
+        // SampleStart
+        df.add {
+            "year of birth" from 2021 - age
+            age gt 18 into "is adult"
+            "details" {
+                name.lastName.length() into "last name length"
+                "full name" from { name.firstName + " " + name.lastName }
+            }
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun addMany_accessors() {
+        // SampleStart
+        val yob = column<Int>("year of birth")
+        val lastNameLength = column<Int>("last name length")
+        val age by column<Int>()
+        val isAdult = column<Boolean>("is adult")
+        val fullName = column<String>("full name")
+        val name by columnGroup()
+        val details by columnGroup()
+        val firstName by name.column<String>()
+        val lastName by name.column<String>()
+
+        df.add {
+            yob from 2021 - age
+            age gt 18 into isAdult
+            details from {
+                lastName.length() into lastNameLength
+                fullName from { firstName() + " " + lastName() }
+            }
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun addMany_strings() {
+        // SampleStart
+        df.add {
+            "year of birth" from 2021 - "age"<Int>()
+            "age"<Int>() gt 18 into "is adult"
+            "details" {
+                "name"["lastName"]<String>().length() into "last name length"
+                "full name" from { "name"["firstName"]<String>() + " " + "name"["lastName"]<String>() }
+            }
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun remove_properties() {
+        // SampleStart
+        df.remove { name and weight }
+        // SampleEnd
+    }
+
+    @Test
+    fun remove_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val weight by column<Int?>()
+
+        df.remove { name and weight }
+        // SampleEnd
+    }
+
+    @Test
+    fun remove_strings() {
+        // SampleStart
+        df.remove("name", "weight")
+        // SampleEnd
+    }
+
+    @Test
+    fun map() {
+        // SampleStart
+        df.map { 2021 - it.age }
+        // SampleEnd
+    }
+
+    @Test
+    fun mapToColumn_properties() {
+        // SampleStart
+        df.mapToColumn("year of birth") { 2021 - age }
+        // SampleEnd
+    }
+
+    @Test
+    fun mapToColumn_accessors() {
+        // SampleStart
+        val age by column<Int>()
+        val yearOfBirth by column<Int>("year of birth")
+
+        df.mapToColumn(yearOfBirth) { 2021 - age }
+        // SampleEnd
+    }
+
+    @Test
+    fun mapToColumn_strings() {
+        // SampleStart
+        df.mapToColumn("year of birth") { 2021 - "age"<Int>() }
+        // SampleEnd
+    }
+
+    @Test
+    fun mapMany_properties() {
+        // SampleStart
+        df.mapToFrame {
+            "year of birth" from 2021 - age
+            age gt 18 into "is adult"
+            name.lastName.length() into "last name length"
+            "full name" from { name.firstName + " " + name.lastName }
+            +city
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun mapMany_accessors() {
+        // SampleStart
+        val yob = column<Int>("year of birth")
+        val lastNameLength = column<Int>("last name length")
+        val age by column<Int>()
+        val isAdult = column<Boolean>("is adult")
+        val fullName = column<String>("full name")
+        val name by columnGroup()
+        val firstName by name.column<String>()
+        val lastName by name.column<String>()
+        val city by column<String?>()
+
+        df.mapToFrame {
+            yob from 2021 - age
+            age gt 18 into isAdult
+            lastName.length() into lastNameLength
+            fullName from { firstName() + " " + lastName() }
+            +city
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun mapMany_strings() {
+        // SampleStart
+        df.mapToFrame {
+            "year of birth" from 2021 - "age"<Int>()
+            "age"<Int>() gt 18 into "is adult"
+            "name"["lastName"]<String>().length() into "last name length"
+            "full name" from { "name"["firstName"]<String>() + " " + "name"["lastName"]<String>() }
+            +"city"
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun group() {
+        // SampleStart
+        df.group { age and city }.into("info")
+
+        df.group { all() }.into { it.type().toString() }.print()
+        // SampleEnd
+    }
+
+    @Test
+    fun ungroup() {
+        // SampleStart
+        // name.firstName -> firstName
+        // name.lastName -> lastName
+        df.ungroup { name }
+        // SampleEnd
+    }
+
+    @Test
+    fun flatten_properties() {
+        // SampleStart
+        // name.firstName -> firstName
+        // name.lastName -> lastName
+        df.flatten { name }
+        // SampleEnd
+    }
+
+    @Test
+    fun flatten_strings() {
+        // SampleStart
+        // name.firstName -> firstName
+        // name.lastName -> lastName
+        df.flatten("name")
+        // SampleEnd
+    }
+
+    @Test
+    fun flatten_accessors() {
+        // SampleStart
+        val name by columnGroup()
+        val firstName by name.column<String>()
+        val lastName by name.column<String>()
+        // name.firstName -> firstName
+        // name.lastName -> lastName
+        df.flatten(name)
+        // SampleEnd
+    }
+
+    @Test
+    fun flatten_KProperties() {
+        // SampleStart
+        // name.firstName -> firstName
+        // name.lastName -> lastName
+        df.flatten(df::name)
+        // SampleEnd
+    }
+
+    @Test
+    fun flattenAll() {
+        // SampleStart
+        df.flatten()
+        // SampleEnd
+    }
+
+    @Test
+    fun multiCallOperations() {
+        // SampleStart
+        df.update { age }.where { city == "Paris" }.with { it - 5 }
+            .filter { isHappy && age > 100 }
+            .move { name.firstName and name.lastName }.after { isHappy }
+            .merge { age and weight }.by { "Age: ${it[0]}, weight: ${it[1]}" }.into("info")
+            .rename { isHappy }.into("isOK")
+        // SampleEnd
+    }
+
+    class MyType(val value: Int)
+
+    @DataSchema
+    class MySchema(val a: MyType, val b: MyType, val c: Int)
+
+    fun customConvertersData() {
+        // SampleStart
+        class MyType(val value: Int)
+
+        @DataSchema
+        class MySchema(val a: MyType, val b: MyType, val c: Int)
+
+        // SampleEnd
+    }
+
+    @Test
+    fun customConverters() {
+        // SampleStart
+        val df = dataFrameOf("a", "b")(1, "2")
+        df.convertTo<MySchema> {
+            convert<Int>().with { MyType(it) } // converts `a` from Int to MyType
+            parser { MyType(it.toInt()) } // converts `b` from String to MyType
+            fill { c }.with { a.value + b.value } // computes missing column `c`
+        }
+        // SampleEnd
+    }
+
+    @Test
+    fun convertToColumnGroupUseCase() {
+        // SampleStart
+        class RepositoryInfo(val data: Any)
+
+        fun downloadRepositoryInfo(url: String) = RepositoryInfo("fancy response from the API")
+        // SampleEnd
+    }
+
+    @Test
+    fun convertToColumnGroupData() {
+        class RepositoryInfo(val data: Any)
+
+        fun downloadRepositoryInfo(url: String) = RepositoryInfo("fancy response from the API")
+
+        // SampleStart
+        val interestingRepos = dataFrameOf("name", "url")(
+            "dataframe", "/dataframe",
+            "kotlin", "/kotlin",
+        )
+
+        val initialData = interestingRepos
+            .add("response") { downloadRepositoryInfo("url"<String>()) }
+        // SampleEnd
+    }
+
+    @Test
+    fun convertToColumnGroup() {
+        class RepositoryInfo(val data: Any)
+
+        fun downloadRepositoryInfo(url: String) = RepositoryInfo("fancy response from the API")
+
+        val interestingRepos = dataFrameOf("name", "url")(
+            "dataframe", "/dataframe",
+            "kotlin", "/kotlin",
+        )
+
+        val initialData = interestingRepos
+            .add("response") { downloadRepositoryInfo("url"()) }
+
+        // SampleStart
+        val df = initialData.unfold("response")
+        // SampleEnd
+        df.schema().print()
+    }
+
+    @DataSchema
+    interface Df {
+        val response: DataRow<Response>
+    }
+
+    @DataSchema
+    interface Response {
+        val data: Any
+    }
+
+    @Test
+    fun convertToColumnGroupBenefits() {
+        class RepositoryInfo(val data: Any)
+
+        fun downloadRepositoryInfo(url: String) = RepositoryInfo("fancy response from the API")
+
+        val interestingRepos = dataFrameOf("name", "url")(
+            "dataframe", "/dataframe",
+            "kotlin", "/kotlin",
+        )
+
+        val initialData = interestingRepos
+            .add("response") { downloadRepositoryInfo("url"()) }
+
+        val df = initialData.unfold("response").cast<Df>()
+
+        // SampleStart
+        df.move { response.data }.toTop()
+        df.rename { response.data }.into("description")
+        // SampleEnd
+
+        df.move { response.data }.toTop().alsoDebug()
+        df.rename { response.data }.into("description").alsoDebug()
+    }
+
+    @Test
+    fun convertToFrameColumnAPI() {
+        // SampleStart
+        fun testResource(resourcePath: String): URL = UtilTests::class.java.classLoader.getResource(resourcePath)!!
+
+        val interestingRepos = dataFrameOf("name", "url", "contributors")(
+            "dataframe", "/dataframe", testResource("dataframeContributors.json"),
+            "kotlin", "/kotlin", testResource("kotlinContributors.json"),
+        )
+        // SampleEnd
+    }
+
+    @Test
+    fun customUnfoldRead() {
+        val interestingRepos = dataFrameOf("name", "url", "contributors")(
+            "dataframe", "/dataframe", testResource("dataframeContributors.json"),
+            "kotlin", "/kotlin", testResource("kotlinContributors.json"),
+        )
+
+        // SampleStart
+        val contributors by column<URL>()
+
+        val df = interestingRepos
+            .replace { contributors }
+            .with {
+                it.mapNotNullValues { url -> DataFrame.readJsonStr(url.readText()) }
+            }
+
+        df.asGroupBy("contributors").max("contributions")
+        // SampleEnd
+
+        df.asGroupBy("contributors").max("contributions").renderToString() shouldBe
+            """|        name        url contributions
+               | 0 dataframe /dataframe           111
+               | 1    kotlin    /kotlin           180
+               |""".trimMargin()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Schemas.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Schemas.kt
new file mode 100644
index 000000000..32a61f437
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Schemas.kt
@@ -0,0 +1,124 @@
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.by
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.count
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.inward
+import org.jetbrains.kotlinx.dataframe.api.maxBy
+import org.jetbrains.kotlinx.dataframe.api.print
+import org.jetbrains.kotlinx.dataframe.api.split
+import org.jetbrains.kotlinx.dataframe.api.toList
+import org.junit.Test
+
+class Schemas {
+
+    @DataSchema
+    interface Person {
+        val name: String
+        val age: Int
+    }
+
+    fun DataFrame<Person>.splitName() = split { name }.by(",").inward("firstName", "lastName")
+    fun DataFrame<Person>.adults() = filter { age > 18 }
+
+    @Test
+    fun createDfNullable() {
+        // SampleStart
+        val df = dataFrameOf("name", "age")(
+            "Alice", 15,
+            "Bob", null
+        )
+        // SampleEnd
+    }
+
+    @Test
+    fun createDf() {
+        // SampleStart
+        val df = dataFrameOf("name", "age")(
+            "Alice", 15,
+            "Bob", 20
+        )
+        // SampleEnd
+    }
+
+    @Test
+    fun extendedDf() {
+        // SampleStart
+        val df = dataFrameOf("name", "age", "weight")(
+            "Merton, Alice", 15, 60.0,
+            "Marley, Bob", 20, 73.5
+        )
+        // SampleEnd
+        df.print()
+    }
+
+    @Test
+    fun splitNameWorks() {
+        val df = dataFrameOf("name", "age", "weight")(
+            "Merton, Alice", 15, 60.0,
+            "Marley, Bob", 20, 73.5
+        ).cast<Person>()
+        // SampleStart
+        df.splitName()
+        // SampleEnd
+    }
+
+    @Test
+    fun adultsWorks() {
+        val df = dataFrameOf("name", "age", "weight")(
+            "Merton, Alice", 15, 60.0,
+            "Marley, Bob", 20, 73.5
+        ).cast<Person>()
+        // SampleStart
+        df.adults()
+        // SampleEnd
+    }
+
+    fun DataFrame<Person>.countAdults() = count { it[Person::age] > 18 }
+
+    @Test
+    fun convertTo() {
+        // SampleStart
+        @DataSchema
+        data class Name(val firstName: String, val lastName: String)
+        @DataSchema
+        data class Person(val name: Name, val age: Int?)
+
+        val df = dataFrameOf("name", "age", "weight")(
+            "Merton, Alice", "15", 60.0,
+            "Marley, Bob", "20", 73.5
+        ).split { "name"<String>() }.inward("firstName", "lastName")
+
+        val persons = df.cast<Person>().toList()
+        // SampleEnd
+    }
+
+    @Test
+    fun useProperties() {
+        // SampleStart
+        val df = dataFrameOf("name", "age")(
+            "Alice", 15,
+            "Bob", 20
+        ).cast<Person>()
+        // age only available after executing `build` or `kspKotlin`!
+        val teens = df.filter { age in 10..19 }
+        teens.print()
+        // SampleEnd
+    }
+
+    @Test
+    fun useInferredSchema() {
+        // SampleStart
+        // Repository.readCSV() has argument 'path' with default value https://raw.githubusercontent.com/Kotlin/dataframe/master/data/jetbrains_repositories.csv
+        val df = Repository.readCSV()
+        // Use generated properties to access data in rows
+        df.maxBy { stargazersCount }.print()
+        // Or to access columns in dataframe.
+        print(df.fullName.count { it.contains("kotlin") })
+        // SampleEnd
+    }
+}
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
new file mode 100644
index 000000000..4a78c8e66
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/TestBase.kt
@@ -0,0 +1,39 @@
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.group
+import org.jetbrains.kotlinx.dataframe.api.into
+
+public open class TestBase {
+
+    val df = dataFrameOf("firstName", "lastName", "age", "city", "weight", "isHappy")(
+        "Alice", "Cooper", 15, "London", 54, true,
+        "Bob", "Dylan", 45, "Dubai", 87, true,
+        "Charlie", "Daniels", 20, "Moscow", null, false,
+        "Charlie", "Chaplin", 40, "Milan", null, true,
+        "Bob", "Marley", 30, "Tokyo", 68, true,
+        "Alice", "Wolf", 20, null, 55, false,
+        "Charlie", "Byrd", 30, "Moscow", 90, true
+    ).group("firstName", "lastName").into("name").cast<Person>()
+
+    @DataSchema
+    interface Name {
+        val firstName: String
+        val lastName: String
+    }
+
+    @DataSchema
+    interface Person {
+        val age: Int
+        val city: String?
+        val name: DataRow<Name>
+        val weight: Int?
+        val isHappy: Boolean
+    }
+
+    infix fun <T, U : T> T.willBe(expected: U?) = shouldBe(expected)
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/BasicMathTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/BasicMathTests.kt
new file mode 100644
index 000000000..ca9f8fcd1
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/BasicMathTests.kt
@@ -0,0 +1,22 @@
+package org.jetbrains.kotlinx.dataframe.statistics
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.mean
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class BasicMathTests {
+
+    @Test
+    fun `type for column with mixed numbers`() {
+        val col = columnOf(10, 10.0, null)
+        col.type() shouldBe typeOf<Number?>()
+    }
+
+    @Test
+    fun `mean with nans and nulls`() {
+        columnOf(10, 20, Double.NaN, null).mean() shouldBe Double.NaN
+        columnOf(10, 20, Double.NaN, null).mean(skipNA = true) shouldBe 15
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/cumsum.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/cumsum.kt
new file mode 100644
index 000000000..6b3e6d944
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/cumsum.kt
@@ -0,0 +1,68 @@
+package org.jetbrains.kotlinx.dataframe.statistics
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.cumSum
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.junit.Test
+
+class CumsumTests {
+
+    val col by columnOf(1, 2, null, 3, 4)
+    val expected = listOf(1, 3, null, 6, 10)
+    val expectedNoSkip = listOf(1, 3, null, null, null)
+
+    @Test
+    fun `int column`() {
+        col.cumSum().toList() shouldBe expected
+        col.cumSum(skipNA = false).toList() shouldBe expectedNoSkip
+    }
+
+    @Test
+    fun frame() {
+        val str by columnOf("a", "b", "c", "d", "e")
+        val df = dataFrameOf(col, str)
+
+        df.cumSum()[col].toList() shouldBe expected
+        df.cumSum(skipNA = false)[col].toList() shouldBe expectedNoSkip
+
+        df.cumSum { col }[col].toList() shouldBe expected
+        df.cumSum(skipNA = false) { col }[col].toList() shouldBe expectedNoSkip
+
+        df.cumSum(col)[col].toList() shouldBe expected
+        df.cumSum(col, skipNA = false)[col].toList() shouldBe expectedNoSkip
+    }
+
+    @Test
+    fun `double column`() {
+        val doubles by columnOf(1.0, 2.0, null, Double.NaN, 4.0)
+        doubles.cumSum().toList() shouldBe listOf(1.0, 3.0, Double.NaN, Double.NaN, 7.0)
+    }
+
+    @Test
+    fun `number column`() {
+        val doubles by columnOf(1, 2, null, Double.NaN, 4)
+        doubles.cumSum().toList() shouldBe listOf(1.0, 3.0, Double.NaN, Double.NaN, 7.0)
+    }
+
+    @Test
+    fun `groupBy`() {
+        val df = dataFrameOf("str", "col")(
+            "a", 1,
+            "b", 2,
+            "c", null,
+            "a", 3,
+            "c", 4
+        )
+        df.groupBy("str").cumSum().concat() shouldBe
+            dataFrameOf("str", "col")(
+                "a", 1,
+                "a", 4,
+                "b", 2,
+                "c", null,
+                "c", 4
+            )
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/median.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/median.kt
new file mode 100644
index 000000000..83648760b
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/median.kt
@@ -0,0 +1,33 @@
+package org.jetbrains.kotlinx.dataframe.statistics
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.Infer
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.mapToColumn
+import org.jetbrains.kotlinx.dataframe.api.median
+import org.jetbrains.kotlinx.dataframe.api.rowMedian
+import org.junit.Test
+
+class MedianTests {
+
+    @Test
+    fun `median of two columns`() {
+        val df = dataFrameOf("a", "b")(
+            1, 4,
+            2, 6,
+            7, 7
+        )
+        df.median("a", "b") shouldBe 5
+    }
+
+    @Test
+    fun `row median`() {
+        val df = dataFrameOf("a", "b")(
+            1, 3,
+            2, 4,
+            7, 7
+        )
+        df.mapToColumn("", Infer.Type) { it.rowMedian() } shouldBe columnOf(2, 3, 7)
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/quickSelect.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/quickSelect.kt
new file mode 100644
index 000000000..29ad4bf1d
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/quickSelect.kt
@@ -0,0 +1,33 @@
+package org.jetbrains.kotlinx.dataframe.statistics
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.math.quickSelect
+import org.junit.Test
+import kotlin.random.Random
+
+class QuickSelectTests {
+
+    @Test
+    fun empty() {
+        shouldThrow<IndexOutOfBoundsException> {
+            listOf<Int>().quickSelect(0)
+        }
+    }
+
+    @Test
+    fun short() {
+        val list = listOf(2, 5, 1)
+        list.quickSelect(0) shouldBe 1
+        list.quickSelect(1) shouldBe 2
+        list.quickSelect(2) shouldBe 5
+    }
+
+    @Test
+    fun long() {
+        val random = Random(120)
+        val list = (0..20).shuffled(random)
+        for (i in list)
+            list.quickSelect(i) shouldBe i
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/std.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/std.kt
new file mode 100644
index 000000000..15c1f56e3
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/statistics/std.kt
@@ -0,0 +1,38 @@
+package org.jetbrains.kotlinx.dataframe.statistics
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.std
+import org.jetbrains.kotlinx.dataframe.math.std
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class StdTests {
+
+    @Test
+    fun `std one column`() {
+        val value by columnOf(1, 2, 3)
+        val df = dataFrameOf(value)
+        val expected = 1.0
+
+        value.values().std() shouldBe expected
+        value.values().std(typeOf<Int>()) shouldBe expected
+        value.std() shouldBe expected
+        df[value].std() shouldBe expected
+        df.std { value } shouldBe expected
+    }
+
+    @Test
+    fun `std one double column`() {
+        val value by columnOf(1.0, 2.0, 3.0)
+        val df = dataFrameOf(value)
+        val expected = 1.0
+
+        value.values().std() shouldBe expected
+        value.values().std(typeOf<Double>()) shouldBe expected
+        value.std() shouldBe expected
+        df[value].std() shouldBe expected
+        df.std { value } shouldBe expected
+    }
+}
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
new file mode 100644
index 000000000..ad1498a0a
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/animals/AnimalsTests.kt
@@ -0,0 +1,46 @@
+package org.jetbrains.kotlinx.dataframe.testSets.animals
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.mean
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.transpose
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.api.value
+import org.jetbrains.kotlinx.dataframe.api.withNull
+import org.jetbrains.kotlinx.dataframe.api.withValue
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class AnimalsTests {
+
+    val animal by columnOf("cat", "cat", "snake", "dog", "dog", "cat", "snake", "cat", "dog", "dog")
+    val age by columnOf(2.5, 3.0, 0.5, Double.NaN, 5.0, 2.0, 4.5, Double.NaN, 7.0, 3.0)
+    val visits by columnOf(1, 3, 2, 3, 2, 3, 1, 1, 2, 1)
+    val priority by columnOf("yes", "yes", "no", "yes", "no", "no", "no", "yes", "no", "no")
+
+    val df = dataFrameOf(animal, age, visits, priority)
+
+    @Test
+    fun `ignore nans`() {
+        df.mean("age", skipNA = true) shouldBe 3.4375
+    }
+
+    @Test
+    fun `mean transpose`() {
+        val mean = df.mean().transpose()
+        mean.columnsCount() shouldBe 2
+        mean.rowsCount() shouldBe 2
+        mean.name.values() shouldBe listOf("age", "visits")
+        mean.value.type() shouldBe typeOf<Double>()
+    }
+
+    @Test
+    fun `mean of empty`() {
+        val cleared = df.update { age }.withValue(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/BaseTest.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/BaseTest.kt
new file mode 100644
index 000000000..88a7439c3
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/BaseTest.kt
@@ -0,0 +1,40 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.toColumnAccessor
+
+@DataSchema
+interface Person {
+    val name: String
+    val age: Int
+    val city: String?
+    val weight: Int?
+}
+
+open class BaseTest {
+
+// Data set
+
+    val df = dataFrameOf("name", "age", "city", "weight")(
+        "Alice", 15, "London", 54,
+        "Bob", 45, "Dubai", 87,
+        "Charlie", 20, "Moscow", null,
+        "Charlie", 40, "Milan", null,
+        "Bob", 30, "Tokyo", 68,
+        "Alice", 20, null, 55,
+        "Charlie", 30, "Moscow", 90
+    )
+
+    val typed: DataFrame<Person> = df.cast()
+
+// Manual Column Definitions
+
+    val name by column<String>()
+    val age = column<Int>() named "age"
+    val city = Person::city.toColumnAccessor()
+    val weight by column<Int?>()
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/BuildTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/BuildTests.kt
new file mode 100644
index 000000000..42fe23861
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/BuildTests.kt
@@ -0,0 +1,33 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.toColumn
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.junit.Test
+
+class BuildTests {
+
+    data class Person(val name: String, val age: Int)
+
+    val persons = listOf(Person("Alice", 15), Person("Bob", 20))
+
+    @Test
+    fun test3() {
+        val list = persons + listOf(null)
+        val df = list.toDataFrame()
+        df.nrow shouldBe 3
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `unequal column sizes`() {
+        persons.toDataFrame() + listOf(1, 2, 3).toColumn("id")
+    }
+
+    @Test
+    fun `create dataframe`() {
+        persons.toDataFrame {
+            expr { it.age + 4 } into "age"
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataColumnTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataColumnTests.kt
new file mode 100644
index 000000000..83ae9780c
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataColumnTests.kt
@@ -0,0 +1,17 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.sort
+import org.jetbrains.kotlinx.dataframe.api.sortBy
+import org.jetbrains.kotlinx.dataframe.api.sortByDesc
+import org.jetbrains.kotlinx.dataframe.api.sortDesc
+import org.junit.Test
+
+class DataColumnTests : BaseTest() {
+
+    @Test
+    fun `sort column`() {
+        typed.age.sort() shouldBe typed.sortBy { age }.age
+        typed.age.sortDesc() shouldBe typed.sortByDesc { age }.age
+    }
+}
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
new file mode 100644
index 000000000..b087f590f
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTests.kt
@@ -0,0 +1,2535 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.doubles.ToleranceMatcher
+import io.kotest.matchers.should
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.shouldNotBe
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.RowExpression
+import org.jetbrains.kotlinx.dataframe.annotations.ColumnName
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.ExcessiveColumns
+import org.jetbrains.kotlinx.dataframe.api.GroupBy
+import org.jetbrains.kotlinx.dataframe.api.ParserOptions
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.addAll
+import org.jetbrains.kotlinx.dataframe.api.addId
+import org.jetbrains.kotlinx.dataframe.api.all
+import org.jetbrains.kotlinx.dataframe.api.allNulls
+import org.jetbrains.kotlinx.dataframe.api.append
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.asDataFrame
+import org.jetbrains.kotlinx.dataframe.api.asGroupBy
+import org.jetbrains.kotlinx.dataframe.api.asIterable
+import org.jetbrains.kotlinx.dataframe.api.at
+import org.jetbrains.kotlinx.dataframe.api.between
+import org.jetbrains.kotlinx.dataframe.api.by
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.chunked
+import org.jetbrains.kotlinx.dataframe.api.colsOf
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnGroup
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.convertTo
+import org.jetbrains.kotlinx.dataframe.api.corr
+import org.jetbrains.kotlinx.dataframe.api.count
+import org.jetbrains.kotlinx.dataframe.api.countDistinct
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.default
+import org.jetbrains.kotlinx.dataframe.api.describe
+import org.jetbrains.kotlinx.dataframe.api.dfsOf
+import org.jetbrains.kotlinx.dataframe.api.digitize
+import org.jetbrains.kotlinx.dataframe.api.distinct
+import org.jetbrains.kotlinx.dataframe.api.distinctBy
+import org.jetbrains.kotlinx.dataframe.api.div
+import org.jetbrains.kotlinx.dataframe.api.drop
+import org.jetbrains.kotlinx.dataframe.api.dropLast
+import org.jetbrains.kotlinx.dataframe.api.dropNA
+import org.jetbrains.kotlinx.dataframe.api.dropNulls
+import org.jetbrains.kotlinx.dataframe.api.dropWhile
+import org.jetbrains.kotlinx.dataframe.api.explode
+import org.jetbrains.kotlinx.dataframe.api.expr
+import org.jetbrains.kotlinx.dataframe.api.fill
+import org.jetbrains.kotlinx.dataframe.api.fillNulls
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.first
+import org.jetbrains.kotlinx.dataframe.api.forEach
+import org.jetbrains.kotlinx.dataframe.api.forEachIndexed
+import org.jetbrains.kotlinx.dataframe.api.frameColumn
+import org.jetbrains.kotlinx.dataframe.api.gather
+import org.jetbrains.kotlinx.dataframe.api.getColumn
+import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.getColumns
+import org.jetbrains.kotlinx.dataframe.api.getFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.getValue
+import org.jetbrains.kotlinx.dataframe.api.group
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.implode
+import org.jetbrains.kotlinx.dataframe.api.indices
+import org.jetbrains.kotlinx.dataframe.api.inplace
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.intoColumns
+import org.jetbrains.kotlinx.dataframe.api.intoList
+import org.jetbrains.kotlinx.dataframe.api.intoRows
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.isFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.isNA
+import org.jetbrains.kotlinx.dataframe.api.isNumber
+import org.jetbrains.kotlinx.dataframe.api.keysInto
+import org.jetbrains.kotlinx.dataframe.api.last
+import org.jetbrains.kotlinx.dataframe.api.leftJoin
+import org.jetbrains.kotlinx.dataframe.api.lowercase
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.mapToFrame
+import org.jetbrains.kotlinx.dataframe.api.match
+import org.jetbrains.kotlinx.dataframe.api.matches
+import org.jetbrains.kotlinx.dataframe.api.max
+import org.jetbrains.kotlinx.dataframe.api.maxBy
+import org.jetbrains.kotlinx.dataframe.api.mean
+import org.jetbrains.kotlinx.dataframe.api.meanFor
+import org.jetbrains.kotlinx.dataframe.api.meanOf
+import org.jetbrains.kotlinx.dataframe.api.median
+import org.jetbrains.kotlinx.dataframe.api.merge
+import org.jetbrains.kotlinx.dataframe.api.min
+import org.jetbrains.kotlinx.dataframe.api.minBy
+import org.jetbrains.kotlinx.dataframe.api.minOf
+import org.jetbrains.kotlinx.dataframe.api.minus
+import org.jetbrains.kotlinx.dataframe.api.move
+import org.jetbrains.kotlinx.dataframe.api.moveTo
+import org.jetbrains.kotlinx.dataframe.api.moveToLeft
+import org.jetbrains.kotlinx.dataframe.api.moveToRight
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.named
+import org.jetbrains.kotlinx.dataframe.api.notNull
+import org.jetbrains.kotlinx.dataframe.api.nullable
+import org.jetbrains.kotlinx.dataframe.api.parse
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.api.pivot
+import org.jetbrains.kotlinx.dataframe.api.print
+import org.jetbrains.kotlinx.dataframe.api.remove
+import org.jetbrains.kotlinx.dataframe.api.rename
+import org.jetbrains.kotlinx.dataframe.api.reorderColumnsByName
+import org.jetbrains.kotlinx.dataframe.api.replace
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.jetbrains.kotlinx.dataframe.api.single
+import org.jetbrains.kotlinx.dataframe.api.sortBy
+import org.jetbrains.kotlinx.dataframe.api.sortByCount
+import org.jetbrains.kotlinx.dataframe.api.sortByDesc
+import org.jetbrains.kotlinx.dataframe.api.sortByKey
+import org.jetbrains.kotlinx.dataframe.api.sortWith
+import org.jetbrains.kotlinx.dataframe.api.split
+import org.jetbrains.kotlinx.dataframe.api.sum
+import org.jetbrains.kotlinx.dataframe.api.sumOf
+import org.jetbrains.kotlinx.dataframe.api.take
+import org.jetbrains.kotlinx.dataframe.api.takeLast
+import org.jetbrains.kotlinx.dataframe.api.takeWhile
+import org.jetbrains.kotlinx.dataframe.api.times
+import org.jetbrains.kotlinx.dataframe.api.to
+import org.jetbrains.kotlinx.dataframe.api.toColumn
+import org.jetbrains.kotlinx.dataframe.api.toColumnAccessor
+import org.jetbrains.kotlinx.dataframe.api.toColumnOf
+import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.api.toDouble
+import org.jetbrains.kotlinx.dataframe.api.toInt
+import org.jetbrains.kotlinx.dataframe.api.toList
+import org.jetbrains.kotlinx.dataframe.api.toListOf
+import org.jetbrains.kotlinx.dataframe.api.toMap
+import org.jetbrains.kotlinx.dataframe.api.toRight
+import org.jetbrains.kotlinx.dataframe.api.toStr
+import org.jetbrains.kotlinx.dataframe.api.toValueColumn
+import org.jetbrains.kotlinx.dataframe.api.transpose
+import org.jetbrains.kotlinx.dataframe.api.under
+import org.jetbrains.kotlinx.dataframe.api.ungroup
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.api.value
+import org.jetbrains.kotlinx.dataframe.api.values
+import org.jetbrains.kotlinx.dataframe.api.valuesNotNull
+import org.jetbrains.kotlinx.dataframe.api.where
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.api.withNull
+import org.jetbrains.kotlinx.dataframe.api.withValue
+import org.jetbrains.kotlinx.dataframe.api.withValues
+import org.jetbrains.kotlinx.dataframe.api.withZero
+import org.jetbrains.kotlinx.dataframe.api.xs
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.exceptions.ExcessiveColumnsException
+import org.jetbrains.kotlinx.dataframe.exceptions.TypeConversionException
+import org.jetbrains.kotlinx.dataframe.hasNulls
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameSize
+import org.jetbrains.kotlinx.dataframe.impl.api.convertToImpl
+import org.jetbrains.kotlinx.dataframe.impl.between
+import org.jetbrains.kotlinx.dataframe.impl.columns.isMissingColumn
+import org.jetbrains.kotlinx.dataframe.impl.emptyPath
+import org.jetbrains.kotlinx.dataframe.impl.getColumnsImpl
+import org.jetbrains.kotlinx.dataframe.impl.nothingType
+import org.jetbrains.kotlinx.dataframe.impl.trackColumnAccess
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.io.renderValueForStdout
+import org.jetbrains.kotlinx.dataframe.kind
+import org.jetbrains.kotlinx.dataframe.math.mean
+import org.jetbrains.kotlinx.dataframe.ncol
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.size
+import org.jetbrains.kotlinx.dataframe.type
+import org.jetbrains.kotlinx.dataframe.typeClass
+import org.junit.Test
+import java.math.BigDecimal
+import java.time.LocalDate
+import kotlin.reflect.jvm.jvmErasure
+import kotlin.reflect.typeOf
+
+class DataFrameTests : BaseTest() {
+
+    @Test
+    fun `create with columns`() {
+        dataFrameOf("name", "age", "city", "weight")(df.columns()) shouldBe df
+
+        dataFrameOf("name", "age", "city", "weight")(
+            typed.name named "bla",
+            typed.age named "",
+            typed.city.rename("qq"),
+            typed.weight.named("asda")
+        ) shouldBe df
+
+        val c1 = typed.name.toList().toValueColumn()
+        val c2 = typed.age.toList().toValueColumn()
+        val c3 = typed.city.toList().toValueColumn()
+        val c4 = typed.weight.toList().toValueColumn()
+
+        dataFrameOf("name", "age", "city", "weight")(c1, c2, c3, c4) shouldBe df
+    }
+
+    @Test
+    fun `create with columnOf`() {
+        val col = columnOf("Alice", "Bob")
+        val d = dataFrameOf("name")(col)
+        d.nrow shouldBe 2
+        d.columnNames() shouldBe listOf("name")
+    }
+
+    @Test
+    fun `create with unnamed columns`() {
+        val a = columnOf("Alice", "Bob")
+        val b = columnOf(1, 2)
+        val d = dataFrameOf(a, b)
+        d.nrow shouldBe 2
+        d.ncol shouldBe 2
+        d.columnNames() shouldBe listOf("untitled", "untitled1")
+        d["untitled"] shouldBe d.getColumn(0)
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `create with duplicate columns`() {
+        val a = columnOf("Alice", "Bob") named "col"
+        val b = columnOf(1, 2) named "col"
+        val d = dataFrameOf(a, b)
+    }
+
+    @Test
+    fun `create column reference`() {
+        val name by column<String>()
+        val col = name.withValues("Alice", "Bob")
+        val df = col.toDataFrame()
+        df.nrow shouldBe 2
+        df.columnNames() shouldBe listOf("name")
+    }
+
+    @Test
+    fun `add values to column reference`() {
+        val name by column<String>()
+        val values = listOf("Alice", "Bob")
+        val col1 = name.withValues(values)
+        val col2 = values.toColumn(name)
+        col1 shouldBe col2
+    }
+
+    @Test
+    fun `create from map`() {
+        val data = mapOf("name" to listOf("Alice", "Bob"), "age" to listOf(15, null))
+        val df = data.toDataFrame()
+        df.ncol shouldBe 2
+        df.nrow shouldBe 2
+        df.columnNames() shouldBe listOf("name", "age")
+        df["name"].type() shouldBe typeOf<String>()
+        df["age"].type() shouldBe typeOf<Int?>()
+    }
+
+    @Test
+    fun `toMap`() {
+        val map = df.toMap()
+        map.size shouldBe 4
+        map.forEach {
+            it.value.size shouldBe df.nrow
+        }
+    }
+
+    @Test
+    fun `size`() {
+        df.size() shouldBe DataFrameSize(df.ncol, df.nrow)
+    }
+
+    @Test
+    fun `slicing`() {
+        val sliced = typed[1..2]
+        sliced.nrow shouldBe 2
+        sliced[0].name shouldBe typed[1].name
+    }
+
+    @Test
+    fun `access tracking`() {
+        trackColumnAccess {
+            typed[2].age
+        } shouldBe listOf("age")
+    }
+
+    @Test
+    fun `indexing`() {
+        val expected = 45
+        val i = 1
+
+        fun Int.check() = this shouldBe expected
+
+        typed[i].age.check()
+        typed.age[i].check()
+
+        df[i][age].check()
+        df[age][i].check()
+
+        df[i][Person::age].check()
+        df[Person::age][i].check()
+
+        df[i].getValue<Int>("age").check()
+        (df[i]["age"] as Int).check()
+
+        df["age"].cast<Int>()[i].check()
+        (df["age"][i] as Int).check()
+    }
+
+    @Test
+    fun `null indexing`() {
+        val i = 5
+
+        fun String?.check() = this shouldBe null
+
+        typed[i].city.check()
+        typed.city[i].check()
+
+        df[i][city].check()
+        df[city][i].check()
+
+        df[i][Person::city].check()
+        df[Person::city][i].check()
+
+        df[i].getValue<String?>("city").check()
+        (df[i]["city"] as String?).check()
+
+        df["city"].cast<String?>()[i].check()
+        (df["city"][i] as String?).check()
+    }
+
+    @Test
+    fun `incorrect column nullability`() {
+        val col =
+            column<Int>().named("weight") // non-nullable column definition is incorrect here, because actual dataframe has nulls in this column
+
+        shouldThrow<NullPointerException> {
+            println(df[2][col])
+        }
+    }
+
+    @Test
+    fun `chunked`() {
+        val res = df.chunked(2)
+        res.size() shouldBe 4
+        res.toList().dropLast(1).forEach {
+            it.nrow shouldBe 2
+        }
+    }
+
+    @Test
+    fun `update`() {
+        fun AnyFrame.check() {
+            getColumn(1).name() shouldBe "age"
+            ncol shouldBe typed.ncol
+            this["age"].toList() shouldBe typed.rows().map { it.age * 2 }
+        }
+
+        typed.update { age }.with { it * 2 }.check()
+        typed.update { age }.with { it * 2 }.check()
+        typed.update(typed.age) { it * 2 }.check()
+
+        df.update { age }.with { it * 2 }.check()
+        df.update(age) { it * 2 }.check()
+        df.update(age) { it * 2 }.check()
+
+        df.update(Person::age) { it * 2 }.check()
+
+        df.update("age") { "age"<Int>() * 2 }.check()
+    }
+
+    @Test
+    fun `conditional update`() {
+        fun AnyFrame.check() {
+            getColumn(1).name() shouldBe "age"
+            ncol shouldBe typed.ncol
+            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()
+
+        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("age").where { it as Int > 25 }.withNull().check()
+        df.update("age").where { it as Int > 25 }.withNull().check()
+    }
+
+    @Test
+    fun `update cells by index`() {
+        val res = typed.update { age }.at(2, 4).withValue(100)
+        val expected = typed.rows().map { if (it.index == 2 || it.index == 4) 100 else it.age }
+        res.age.toList() shouldBe expected
+    }
+
+    @Test
+    fun `update cells by index range`() {
+        val res = typed.update { age }.at(2..4).withValue(100)
+        val expected = typed.rows().map { if (it.index in 2..4) 100 else it.age }
+        res.age.toList() shouldBe expected
+    }
+
+    @Test
+    fun `null to zero`() {
+        val expected = typed.weight.toList().map { it ?: 0 }
+        fun AnyFrame.check() {
+            this["weight"].toList() shouldBe expected
+        }
+
+        typed.fillNulls { weight }.withValue(0).check()
+        typed.fillNulls(typed.weight).withValue(0).check()
+
+        df.fillNulls { weight }.withValue(0).check()
+        df.fillNulls(weight).withValue(0).check()
+
+        df.fillNulls("weight").withValue(0).check()
+
+        typed.fillNulls { weight }.withZero().check()
+        typed.fillNulls { weight }.withZero().check()
+        typed.fillNulls(typed.weight).withZero().check()
+
+        df.fillNulls { weight }.withZero().check()
+        df.fillNulls { weight }.withZero().check()
+    }
+
+    @Test
+    fun `resetToNull`() {
+        val updated = typed.update { all() }.withNull()
+
+        updated.columns().forEach {
+            it.forEach { it shouldBe null }
+        }
+    }
+
+    @Test
+    fun `sort`() {
+        val expected = listOf(null, "London", "Dubai", "Tokyo", "Milan", "Moscow", "Moscow")
+
+        fun AnyFrame.check() = this[city].toList() shouldBe expected
+
+        typed.sortBy { name and age.desc() }.check()
+        typed.sortBy { it.name and it.age.desc() }.check()
+
+        df.sortBy { name and age.desc() }.check()
+
+        df.sortBy { Person::name and Person::age.desc() }.check()
+
+        df.sortBy { "name"<String>() and "age".desc() }.check()
+    }
+
+    @Test
+    fun `sort nulls first`() {
+        val expected = typed.city.toList().sortedBy { it }
+
+        fun AnyFrame.check() = this[city].toList() shouldBe expected
+
+        typed.sortBy { city }.check()
+        df.sortBy { city }.check()
+        df.sortBy { col(Person::city) }.check()
+        df.sortBy { get("city") }.check()
+    }
+
+    @Test
+    fun `sort nulls last`() {
+        val expected = typed.city.toList().filterNotNull().sortedBy { it } + listOf(null)
+
+        fun AnyFrame.check() = this[city].toList() shouldBe expected
+
+        typed.sortBy { city.nullsLast() }.check()
+        df.sortBy { city.nullsLast() }.check()
+        df.sortBy { Person::city.nullsLast() }.check()
+        df.sortBy { "city".nullsLast() }.check()
+    }
+
+    @Test
+    fun `equals`() {
+        typed shouldBe typed.update { age }.with { age }
+    }
+
+    @Test
+    fun `get group by single key`() {
+        typed.groupBy { name }.xs("Charlie").concat() shouldBe typed.filter { name == "Charlie" }.remove { name }
+    }
+
+    @Test
+    fun `get group by complex key`() {
+        typed.groupBy { city and name }.xs("Tokyo", "Bob").concat() shouldBe
+            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" }.remove { city }.groupBy { name }.toDataFrame()
+    }
+
+    @Test
+    fun `group and sort`() {
+        val expected = typed.sortBy { name.desc() and age }
+        val actual = typed.groupBy { name }.sortBy { name.desc() and age }.concat()
+        actual shouldBe expected
+    }
+
+    @Test
+    fun `filter`() {
+        val expected = listOf("Bob", "Bob", "Charlie")
+        fun AnyFrame.check() = this[name].toList() shouldBe expected
+
+        val limit = 20
+
+        typed.filter { it.age > limit && it.weight != null }.check()
+        typed.filter { age > limit && it.weight != null }.check()
+
+        df.filter { it[Person::age] > limit && it[Person::weight] != null }.check()
+
+        df.filter { age > limit && weight() != null }.check()
+        df.filter { it[age] > limit && this[weight] != null }.check()
+
+        df.filter { "age"<Int>() > limit && "weight"<Int?>() != null }.check()
+    }
+
+    @Test
+    fun `drop nulls 1`() {
+        fun AnyFrame.check() = rows().forEach { get("weight") shouldNotBe null }
+
+        typed.dropNulls(typed.weight).check()
+        typed.dropNulls { weight }.check()
+        typed.dropNulls { it.weight }.check()
+
+        df.dropNulls(weight).check()
+        df.dropNulls { weight }.check()
+
+        df.dropNulls("weight").check()
+    }
+
+    @Test
+    fun `drop where all null`() {
+        val filtered = typed.update { weight }.where { name == "Alice" }.withNull()
+        val expected = typed.nrow - 1
+
+        fun AnyFrame.check() = nrow shouldBe expected
+
+        filtered.dropNulls(typed.weight.toColumnAccessor(), typed.city.toColumnAccessor(), whereAllNull = true).check()
+        filtered.dropNulls(whereAllNull = true) { weight and city }.check()
+        filtered.dropNulls(whereAllNull = true) { it.weight and it.city }.check()
+
+        filtered.dropNulls(Person::weight, Person::city, whereAllNull = true).check()
+
+        filtered.dropNulls(weight, city, whereAllNull = true).check()
+        filtered.dropNulls(whereAllNull = true) { weight and city }.check()
+
+        filtered.dropNulls("weight", "city", whereAllNull = true).check()
+    }
+
+    @Test
+    fun `drop where any null`() {
+        val filtered = typed.update { weight }.where { name == "Alice" }.withNull()
+        val expected = filtered.count { weight != null && city != null }
+
+        fun AnyFrame.check() = nrow shouldBe expected
+
+        filtered.dropNulls(typed.weight.toColumnAccessor(), typed.city.toColumnAccessor()).check()
+        filtered.dropNulls { weight and city }.check()
+        filtered.dropNulls { it.weight and it.city }.check()
+
+        filtered.dropNulls(Person::weight, Person::city).check()
+
+        filtered.dropNulls(weight, city).check()
+        filtered.dropNulls { weight and city }.check()
+
+        filtered.dropNulls("weight", "city").check()
+
+        filtered.dropNulls().check()
+
+        filtered.select { weight and city }.dropNulls().check()
+    }
+
+    @Test
+    fun `select one `() {
+        val expected = listOf(typed.age)
+        fun AnyFrame.check() = columns() shouldBe expected
+
+        typed.select { age }.check()
+        typed.select { it.age }.check()
+        typed.select(typed.age).check()
+
+        df.select(Person::age).check()
+
+        df.select { age }.check()
+        df.select(age).check()
+
+        df.select("age").check()
+
+        df.select { it["age"] }.check()
+        df.select { get("age") }.check()
+        df.select { this["age"] }.check()
+    }
+
+    @Test
+    fun `select if`() {
+        val expected = listOf(typed.name, typed.city)
+
+        fun AnyFrame.check() = columns() shouldBe expected
+
+        typed.select { cols { it.name().length == 4 } }.check()
+        df.select { cols { it.name().length == 4 } }.check()
+    }
+
+    @Test
+    fun `select two`() {
+        val expected = listOf(typed.age, typed.city)
+        fun AnyFrame.check() = columns() shouldBe expected
+
+        typed.select { age and city }.check()
+        typed.select { it.age and it.city }.check()
+        typed.select(typed.age, typed.city).check()
+
+        typed.select(Person::age, Person::city).check()
+
+        df.select { age and city }.check()
+        df.select(age, city).check()
+        df[age, city].check()
+
+        df.select { "age" and "city" }.check()
+        df.select("age", "city").check()
+        df["age", "city"].check()
+    }
+
+    @Test
+    fun `select by type`() {
+        val selected = typed.select { colsOf<String?>() }
+        selected shouldBe typed.select { name and city }
+    }
+
+    @Test
+    fun `select by type not nullable`() {
+        val selected = typed.select { colsOf<String> { !it.hasNulls() } }
+        selected shouldBe typed.select { name }
+    }
+
+    @Test
+    fun `move one column`() {
+        val moved = typed.moveTo(1) { city }
+        val expected = typed.select { cols(name, city, age, weight) }
+        moved shouldBe expected
+    }
+
+    @Test
+    fun `move several columns`() {
+        val moved = typed.moveTo(2) { name and city }
+        val expected = typed.select { cols(age, weight, name, city) }
+        moved shouldBe expected
+    }
+
+    @Test
+    fun `move several columns to left`() {
+        val moved = typed.moveToLeft { weight and age }
+        val expected = typed.select { cols(weight, age, name, city) }
+        moved shouldBe expected
+    }
+
+    @Test
+    fun `move several columns to right`() {
+        val moved = typed.moveToRight { weight and name }
+        val expected = typed.select { cols(age, city, weight, name) }
+        moved shouldBe expected
+    }
+
+    @Test
+    fun `select with rename 2`() {
+        val res = typed.select { name named "Name" }
+        res.columnNames() shouldBe listOf("Name")
+        df.select { name named "Name" } shouldBe res
+        df.select { it["name"] named "Name" } shouldBe res
+    }
+
+    @Test
+    fun `select with map and rename`() {
+        val res = typed.select { name.map { it.lowercase() } named "Name" }
+        res.columnNames() shouldBe listOf("Name")
+        res["Name"].values() shouldBe typed.name.values().map { it.lowercase() }
+        df.select { name.map { it.lowercase() } named "Name" } shouldBe res
+        df.select { it[Person::name].map { it.lowercase() } named "Name" } shouldBe res
+        df.select { "name"<String>().map { it.lowercase() } named "Name" } shouldBe res
+    }
+
+    @Test
+    fun `get column with map`() {
+        val converted = name.map { it.lowercase() }
+        val res = df[converted]
+        res.values() shouldBe typed.name.values().map { it.lowercase() }
+    }
+
+    @Test
+    fun `get column by accessor`() {
+        val res = df[0..1][name]
+        res.size() shouldBe 2
+    }
+
+    @Test
+    fun `groupBy`() {
+        fun AnyFrame.check() {
+            nrow shouldBe 3
+            this["name"].toList() shouldBe listOf("Alice", "Bob", "Charlie")
+            this["n"].toList() shouldBe listOf(2, 2, 3)
+            this["old count"].toList() shouldBe listOf(0, 2, 2)
+            this["median age"].toList() shouldBe listOf(17, 37, 30)
+            this["min age"].toList() shouldBe listOf(15, 30, 20)
+            this["oldest origin"].toList() shouldBe listOf(null, "Dubai", "Milan")
+            this["youngest origin"].toList() shouldBe listOf("London", "Tokyo", "Moscow")
+            this["all with weights"].toList() shouldBe listOf(true, true, false)
+            val cities = getColumnGroup("city")
+            cities["from London"].toList() shouldBe listOf(1, 0, 0)
+            cities["from Dubai"].toList() shouldBe listOf(0, 1, 0)
+            cities["from Moscow"].toList() shouldBe listOf(0, 0, 2)
+            cities["from Milan"].toList() shouldBe listOf(0, 0, 1)
+            cities["from Tokyo"].toList() shouldBe listOf(0, 1, 0)
+            cities["from null"].toList() shouldBe listOf(1, 0, 0)
+            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()
+    }
+
+    @Test
+    fun `groupBy meanOf`() {
+        typed.groupBy { name }.meanOf { age * 2 } shouldBe typed.groupBy { name }
+            .aggregate { mean { age } * 2 into "mean" }
+    }
+
+    @Test
+    fun `min`() {
+        val expected = 15
+
+        fun Any?.check() = this shouldBe expected
+
+        typed.minOf { age }.check()
+        typed.min { it.age }.check()
+        typed.age.min().check()
+
+        df.min { age }.check()
+        df.min(age).check()
+        df[age].min().check()
+
+        df.min { "age"<Int>() }.check()
+        df.min("age").check()
+        df["age"].cast<Int>().min().check()
+    }
+
+    @Test
+    fun `nullable max`() {
+        val expected = 90
+
+        fun Int?.check() = this shouldBe expected
+
+        typed.max { weight }.check()
+        typed.max { it.weight }.check()
+        typed.weight.max().check()
+
+        df.max { weight }.check()
+        df.max(weight).check()
+        df[weight].max().check()
+
+        df.max { "weight"<Int?>() }.check()
+        df["weight"].cast<Int?>().max().check()
+        (df.max("weight") as Int?).check()
+    }
+
+    @Test
+    fun `nullable minBy`() {
+        val expected = "Alice"
+
+        fun AnyRow?.check() = this!![name] shouldBe expected
+
+        typed.dropNulls { weight }.minBy { weight }.check()
+        typed.dropNulls { it.weight }.minBy { it.weight }.check()
+        typed.minBy { weight }.check()
+
+        df.dropNulls(weight).minBy(weight).check()
+        df.minBy(weight).check()
+
+        df.dropNulls("weight").minBy { "weight"<Int?>() }.check()
+        df.dropNulls("weight").minBy("weight").check()
+        df.minBy("weight").check()
+    }
+
+    @Test
+    fun `maxBy`() {
+        val expected = "Bob"
+
+        fun AnyRow?.check() = this!![name] shouldBe expected
+
+        typed.maxBy { age }.check()
+        typed.maxBy { it.age }.check()
+        typed.maxBy(typed.age).check()
+
+        df.maxBy { age() }.check()
+        df.maxBy(age).check()
+
+        df.maxBy { "age"<Int>() }.check()
+        df.maxBy("age").check()
+    }
+
+    @Test
+    fun `add one column`() {
+        val now = 2020
+        val expected = typed.rows().map { now - it.age }
+
+        fun AnyFrame.check() = this["year"].toList() shouldBe expected
+
+        typed.add("year") { now - age }.check()
+        typed.add("year") { now - it.age }.check()
+
+        df.add("year") { now - age }.check()
+
+        df.add("year") { now - "age"<Int>() }.check()
+    }
+
+    @Test
+    fun `add several columns`() {
+        val now = 2020
+        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 }
+            }
+            group {
+                g from {
+                    add(age.map { now - it }.named("h"))
+                }
+            } into "e"
+        }.remove { allBefore("a") }
+
+        df.columnNames() shouldBe listOf("a", "b", "c", "d", "e")
+        df["d"].kind() shouldBe ColumnKind.Group
+        df["e"].kind() shouldBe ColumnKind.Group
+        df.getColumnGroup("d").columnNames() shouldBe listOf("f")
+        df.getColumnGroup("e").getColumnGroup("g").columnNames() shouldBe listOf("h")
+        val cols = df.getColumns { allDfs() }
+        cols.size shouldBe 5
+        cols.forEach {
+            it.toList() shouldBe expected
+        }
+    }
+
+    @Test
+    fun `remove one column`() {
+        val expected = listOf("name", "city", "weight")
+        fun check(body: () -> AnyFrame) = body().columnNames() shouldBe expected
+
+        check { typed - { age } }
+        check { typed - { it.age } }
+        check { typed.remove { age } }
+        check { typed.remove { it.age } }
+
+        check { df - { age } }
+        check { df - age }
+        check { df.remove(age) }
+
+        check { df - "age" }
+        check { df.remove("age") }
+    }
+
+    @Test
+    fun `remove two columns`() {
+        val expected = listOf("name", "city")
+        fun check(body: () -> AnyFrame) = body().columnNames() shouldBe expected
+
+        check { typed - { age and weight } }
+        check { typed - { it.age and it.weight } }
+        check { typed - { age } - { weight } }
+        check { typed - { it.age } - { it.weight } }
+        check { typed.remove { age and weight } }
+        check { typed.remove { it.age and it.weight } }
+
+        check { df - { age and weight } }
+        check { df - age - weight }
+        check { df - { age } - { weight } }
+        check { df.remove(age, weight) }
+
+        check { df - { "age" and "weight" } }
+        check { df - "age" - "weight" }
+        check { df.remove("age", "weight") }
+    }
+
+    @Test
+    fun `merge similar dataframes`() {
+        val res = typed.concat(typed, typed)
+        res.name.size() shouldBe 3 * typed.nrow
+        res.rows().forEach { it.values() shouldBe typed[it.index % typed.nrow].values() }
+    }
+
+    @Test
+    fun `merge different dataframes`() {
+        val height by column<Int>()
+        val heightOrNull = height.nullable()
+
+        val other = dataFrameOf(name, height)(
+            "Bill",
+            135,
+            "Charlie",
+            160
+        ).cast<Unit>()
+
+        val res = typed.concat(other)
+        res.nrow shouldBe typed.nrow + other.nrow
+        res.take(typed.nrow).rows().forEach { it[heightOrNull] == null }
+        val q = res.takeLast(other.nrow)
+        q.rows().forEach { it[name] shouldBe other[it.index][name] }
+        q.rows().forEach { it[heightOrNull] shouldBe other[it.index][height] }
+    }
+
+    @Test
+    fun `row to frame`() {
+        typed[1].toDataFrame().name.size() shouldBe 1
+    }
+
+    @Test
+    fun `compare comparable`() {
+        val new = df.add("date") { LocalDate.now().minusDays(index.toLong()) }
+        val date by column<LocalDate>()
+        new.filter { date >= LocalDate.now().minusDays(3) }.nrow shouldBe 4
+    }
+
+    @Test
+    fun `union dataframes with different type of the same column`() {
+        val df2 = dataFrameOf("age")(32.6, 56.3, null)
+        df2["age"].type() shouldBe typeOf<Double?>()
+        val merged = df.concat(df2)
+        merged["age"].type() shouldBe typeOf<Number?>()
+        val updated = merged.convert("age") { "age"<Number?>()?.toDouble() }
+        updated["age"].type() shouldBe typeOf<Double?>()
+    }
+
+    @Test
+    fun `distinct`() {
+        val expected = 6
+        typed.countDistinct { name and city } shouldBe expected
+        typed.select { name and city }.distinct().nrow shouldBe expected
+        typed.select { name and city }.countDistinct() shouldBe expected
+        val d = typed.distinct { name and city }
+        d.nrow shouldBe expected
+        d.ncol shouldBe 2
+    }
+
+    @Test
+    fun `distinct by`() {
+        typed.distinctBy { name }.nrow shouldBe 3
+        typed.distinctBy { name and city }.nrow shouldBe 6
+        typed.distinctBy { expr { age / 10 } }.nrow shouldBe 4
+        typed.distinctBy { age / 10 }.nrow shouldBe 4
+        typed.distinctBy { expr { city?.get(0) } }.nrow shouldBe 5
+    }
+
+    @Test
+    fun `addRow`() {
+        val res = typed.append("Bob", null, "Paris", null)
+        res.nrow shouldBe typed.nrow + 1
+        res.name.type() shouldBe typeOf<String>()
+        res.age.type() shouldBe typeOf<Int?>()
+        res.city.type() shouldBe typeOf<String?>()
+        res.weight.type() shouldBe typeOf<Int?>()
+
+        val row = res.last()
+        row.name shouldBe "Bob"
+        row["age"] shouldBe null
+        row.city shouldBe "Paris"
+        row.weight shouldBe null
+    }
+
+    @Test
+    fun `rename`() {
+        fun AnyFrame.check() {
+            this["name2"].toList() shouldBe typed.name.toList()
+            this["age2"].toList() shouldBe typed.age.toList()
+            this.columnNames() shouldBe listOf("name2", "age2", "city", "weight")
+            this.getColumnOrNull("age") shouldBe null
+        }
+        typed.rename("name" to "name2", "age" to "age2").check()
+        typed.rename { name and age }.into("name2", "age2").check()
+        typed.rename { name and age }.into { it.name + "2" }.check()
+    }
+
+    @Test
+    fun `select with rename`() {
+        val expected = typed.select { name and age }.rename { all() }.into { it.name + 2 }
+        typed.select { name into "name2" and age.into("age2") } shouldBe expected
+    }
+
+    @Test
+    fun `nunique`() {
+        typed.name.countDistinct() shouldBe 3
+    }
+
+    @Test
+    fun `encode names`() {
+        val encoding = typed.name.distinct().addId("name_id")
+        val res = typed.leftJoin(encoding)
+        res["name_id"].toList() shouldBe listOf(0, 1, 2, 2, 1, 0, 2)
+    }
+
+    @Test
+    fun `pivot matches`() {
+        val pivoted = typed.pivot { city }.groupBy { name and age and weight }.matches()
+        pivoted.ncol shouldBe 4
+        typed.ncol + typed.city.countDistinct() - 1
+        val data = pivoted.getColumnGroup("city")
+        for (row in 0 until typed.nrow) {
+            val city = typed[row][city].toString()
+            data[city][row] shouldBe true
+            for (col in 0 until data.ncol) {
+                val column = data.getColumn(col)
+                val pivotedValue = column.cast<Boolean>()[row]
+                val colName = column.name()
+                pivotedValue shouldBe (colName == city)
+            }
+        }
+    }
+
+    @Test
+    fun `pivot matches equality`() {
+        val res1 = typed.pivot { city }.groupBy { name }.matches()
+        val res2 = typed.groupBy { name }.pivot { city }.matches()
+        val res3 = typed.groupBy { name }.aggregate {
+            pivot { city }.matches()
+        }
+        res2 shouldBe res1
+        res3 shouldBe res1
+    }
+
+    @Test
+    fun `pivot matches with conversion`() {
+        val filtered = typed.dropNulls { city }
+        val res = filtered.pivot(inward = false) { city.lowercase() }.groupBy { name and age }.matches()
+        val cities = filtered.city.toList().map { it!!.lowercase() }
+        val gathered =
+            res.gather { colsOf<Boolean> { cities.contains(it.name()) } }.where { it }.keysInto("city")
+        val expected = filtered.select { name and age and city.map { it!!.lowercase() } }.moveToRight { city }
+        gathered shouldBe expected
+    }
+
+    @Test
+    fun `pivot matches distinct rows`() {
+        val res = typed.pivot(inward = false) { city }.groupBy { name and age }.matches()
+        res.ncol shouldBe 2 + typed.city.countDistinct()
+        for (i in 0 until typed.nrow) {
+            val city = typed[i][city]
+            for (j in typed.ncol until res.ncol) {
+                val col = res.getColumn(j)
+                col.cast<Boolean>().get(i) shouldBe (col.name() == city.toString())
+            }
+        }
+    }
+
+    @Test
+    fun `pivot matches merged rows`() {
+        val selected = typed.select { name and city }
+        val res = typed.pivot(inward = false) { city }.groupBy { name }.matches()
+
+        res.ncol shouldBe selected.city.countDistinct() + 1
+        res.nrow shouldBe selected.name.countDistinct()
+        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()
+
+        pairs shouldBe typed.rows().map { it.name to it.city.toString() }.toSet()
+    }
+
+    @Test
+    fun `pivot to matrix`() {
+        val other by column<String>()
+        val others = other.cast<List<String>>()
+        val sum by column<Int>()
+
+        val names = typed.name.distinct().toList()
+
+        val src = typed.select { name }
+            .add(others) { names }
+            .split { others }.intoRows()
+            .add(sum) { name.length + other().length }
+
+        val matrix = src.pivot { other }.groupBy { name }.with { sum }
+        matrix.getColumnGroup(other.name()).ncol shouldBe names.size
+    }
+
+    @Test
+    fun `gather bool`() {
+        val pivoted = typed.pivot { city }.groupBy { name }.matches()
+        val res = pivoted.gather { dfsOf<Boolean>() }.where { it }.keysInto("city")
+        val sorted = res.sortBy { name and city }
+        sorted shouldBe typed.select { name and city.map { it.toString() } }.distinct().sortBy { name and city }
+    }
+
+    @Test
+    fun `gather nothing`() {
+        val gat = typed.gather { city and name }
+
+        gat.where { false }
+            .into("key", "value").print()
+    }
+
+    @Test
+    fun `merge rows keep nulls`() {
+        val merged = typed.select { name and city }.implode(dropNA = false) { city }
+
+        val cityList = column<List<String?>>().named("city")
+        merged[cityList].sumOf { it.size } shouldBe typed.city.size
+        merged[cityList].type() shouldBe typeOf<List<String?>>()
+
+        val expected = typed.groupBy { name }.aggregate { it.city.toSet() into "city" }
+        val actual = merged.convert(cityList).with { it.toSet() }
+
+        actual shouldBe expected
+
+        // check that default value for 'dropNulls' is false
+        typed.select { name and city }.implode { city } shouldBe merged
+    }
+
+    @Test
+    fun `merge rows drop nulls`() {
+        val merged = typed.select { name and city }.implode(dropNA = true) { city }
+
+        val cityList = column<List<String>>().named("city")
+        merged[cityList].sumOf { it.size } shouldBe typed.city.dropNulls().size
+        merged[cityList].type() shouldBe typeOf<List<String>>()
+
+        val expected =
+            typed.dropNulls { city }.groupBy { name }.aggregate { it.city.toSet() as Set<String> into "city" }
+        val actual = merged.convert { cityList }.with { it.toSet() }
+
+        actual shouldBe expected
+    }
+
+    @Test
+    fun splitRows() {
+        val selected = typed.select { name and city }
+        val nested = selected.implode(dropNA = false) { city }
+        val mergedCity = column<List<String?>>("city")
+        val res = nested.split { mergedCity }.intoRows()
+        res.sortBy { name } shouldBe selected.sortBy { name }
+    }
+
+    @Test
+    fun mergeCols() {
+        val merged = typed.merge { age and city and weight }.into("info")
+        merged.ncol shouldBe 2
+        merged.nrow shouldBe typed.nrow
+        for (row in 0 until typed.nrow) {
+            val list = merged[row]["info"] as List<Any?>
+            list.size shouldBe 3
+            list[0] shouldBe typed.age[row]
+            list[1] shouldBe typed.city[row]
+            list[2] shouldBe typed.weight[row]
+        }
+    }
+
+    @Test
+    fun joinColsToString() {
+        val merged = typed.merge { age and city and weight }.by(", ").into("info")
+        merged.ncol shouldBe 2
+        merged.nrow shouldBe typed.nrow
+        for (row in 0 until typed.nrow) {
+            val joined = merged[row]["info"] as String
+            joined shouldBe typed.age[row].toString() + ", " + typed.city[row] + ", " + typed.weight[row]
+        }
+    }
+
+    @Test
+    fun mergeIntoList() {
+        val parsed = typed
+            .merge { age and city and weight }.by(", ").intoList()
+            .toDataFrame { "data" from { it } }
+            .split("data").by(", ").into(age, city, weight)
+            .parse(ParserOptions(nullStrings = setOf("null")))
+
+        val expected = typed[age, city, weight]
+        parsed shouldBe expected
+    }
+
+    @Test
+    fun mergeColsCustom() {
+        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"
+    }
+
+    @Test
+    fun mergeColsCustom2() {
+        val merged = typed.merge { name and city and age }.by { "$name from $city aged $age" }.into("info")
+        merged.ncol shouldBe 2
+        merged.nrow shouldBe typed.nrow
+        merged[0]["info"] shouldBe "Alice from London aged 15"
+    }
+
+    @Test
+    fun splitCol() {
+        val merged = typed.merge { age and city and weight }.into("info")
+        val info by column<List<Any>>()
+        val res = merged.split(info).into("age", "city", "weight")
+        res shouldBe typed
+    }
+
+    @Test
+    fun splitMergeFrameCol() {
+        val groups by frameColumn()
+        val grouped = typed.groupBy { name }.into(groups)
+        val split = grouped.split(groups).into { "rec$it" }
+        val merged = split.merge { drop(1) }.notNull().into(groups)
+        merged shouldBe grouped
+    }
+
+    @Test
+    fun splitStringCol() {
+        val merged = typed.merge { age and city and weight }.by(" - ").into("info")
+        val info by column<String>()
+        val res = merged.split { info }.by("-").into("age", "city", "weight")
+        val expected = typed.convert { age and city and weight }.with { it.toString() }
+        res shouldBe expected
+    }
+
+    @Test
+    fun splitStringCol2() {
+        val merged = typed.merge { age and city and weight }.by(",").into("info")
+        val info by column<String>()
+        val res = merged.split(info).into("age", "city", "weight")
+        val expected = typed.convert { age and city and weight }.with { it.toString() }
+        res shouldBe expected
+    }
+
+    @Test
+    fun splitStringColGenerateNames() {
+        val merged = typed.merge { age and city and weight }.by(",").into("info")
+        val info by column<String>()
+        val res = merged.split(info).into("age") { "extra$it" }
+        res.columnNames() shouldBe listOf("name", "age", "extra1", "extra2")
+    }
+
+    @Test
+    fun splitStringColWithDefaultgenerator() {
+        val merged = typed.merge { age and city and weight }.by(",").into("info")
+        val info by column<String>()
+        val res = merged.split(info).into("age")
+        res.columnNames() shouldBe listOf("name", "age", "split1", "split2")
+    }
+
+    @Test
+    fun splitAgeIntoDigits() {
+        fun digits(num: Int) = sequence {
+            var k = num
+            while (k > 0) {
+                yield(k % 10)
+                k /= 10
+            }
+        }.toList()
+
+        val res = typed.split { age }.by { digits(it) }.into { "digit$it" }
+    }
+
+    @Test
+    fun splitStringCol3() {
+        val merged = typed.merge { age and city and weight }.by(", ").into("info")
+        val info by column<String?>()
+        val res = merged.split(info).by(",").into("age", "city", "weight")
+        val expected = typed.convert { age and city and weight }.with { it.toString() }
+        res shouldBe expected
+    }
+
+    @Test
+    fun splitStringCols() {
+        val merged = typed.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")
+        val expected = typed.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" }
+        res.sumOf { values().count { it == "--" } } shouldBe 7
+    }
+
+    @Test
+    fun `merge cols with conversion`() {
+        val pivoted = typed.groupBy { name }.pivot { city }.count()
+        val res = pivoted.merge { city.colsOf<Int>() }.by { it.filterNotNull().sum() }.into("cities")
+        val expected = typed.select { name and city }.groupBy { name }.count("cities")
+        res shouldBe expected
+    }
+
+    @Test
+    fun `generic column type`() {
+        val d = typed.convert { city }.with { it?.toCharArray()?.toList() ?: emptyList() }
+        println(d.city.type())
+    }
+
+    @Test
+    fun `column group by`() {
+        fun DataFrame<Person>.check() {
+            ncol shouldBe 3
+            nrow shouldBe typed.nrow
+            columnNames() shouldBe listOf("name", "Int", "String")
+            val intGroup = this["Int"].asColumnGroup()
+            intGroup.columnNames() shouldBe listOf("age", "weight")
+
+            val res = listOf(
+                this.name,
+                this["Int"]["age"],
+                this["String"]["city"],
+                this["Int"]["weight"]
+            ).toDataFrame().cast<Person>()
+            res shouldBe typed
+        }
+        typed.group { cols { it != name } }.into { it.type.jvmErasure.simpleName!! }.check()
+        typed.group { age and city and weight }.into { it.type.jvmErasure.simpleName!! }.check()
+    }
+
+    @Test
+    fun `column group`() {
+        val grouped = typed.move { age and name and city }.under("info")
+        grouped.ncol shouldBe 2
+        grouped.columnNames() shouldBe listOf("info", "weight")
+        val res = listOf(
+            grouped["info"]["name"],
+            grouped["info"]["age"],
+            grouped["info"]["city"],
+            grouped.weight
+        ).toDataFrame().cast<Person>()
+        res shouldBe typed
+    }
+
+    @Test
+    fun `column ungroup`() {
+        val info by columnGroup()
+        val res = typed.move { age and city }.under("info").ungroup { info }
+        res shouldBe typed
+    }
+
+    @Test
+    fun `empty group by`() {
+        val ungrouped = typed.filter { false }.groupBy { name }.concat()
+        ungrouped.nrow shouldBe 0
+        ungrouped.ncol shouldBe 0
+    }
+
+    @Test
+    fun `column stats`() {
+        typed.age.mean() shouldBe typed.age.toList().mean()
+        typed.age.min() shouldBe typed.age.toList().minOrNull()
+        typed.age.max() shouldBe typed.age.toList().maxOrNull()
+        typed.age.sum() shouldBe typed.age.toList().sum()
+    }
+
+    @Test
+    fun `row to string`() {
+        typed[0].toString() shouldBe "{ name:Alice, age:15, city:London, weight:54 }"
+    }
+
+    @Test
+    fun `range slice`() {
+        typed[3..5].name.toList() shouldBe typed.name.toList().subList(3, 6)
+    }
+
+    @Test
+    fun `range slice two times`() {
+        typed[3..5][1..2].name.toList() shouldBe typed.name.toList().subList(4, 6)
+    }
+
+    @Test
+    fun `move to position`() {
+        typed.getColumn(1) shouldBe typed.age
+        val moved = typed.move { age }.to(2)
+        moved.getColumn(2) shouldBe typed.age
+        moved.ncol shouldBe typed.ncol
+    }
+
+    @Test
+    fun `forEachIn`() {
+        val pivoted = typed.pivot(inward = true) { city }.groupBy { name and weight }.with { age }
+        val sum = pivoted.select { "city".all() }.values().filterNotNull().sumOf { it as Int }
+        sum shouldBe typed.age.sum()
+    }
+
+    @Test
+    fun `parse`() {
+        val toStr = typed.convert { weight }.notNull { it.toString() }
+        val weightStr = "weight".toColumnOf<String?>()
+        val parsed = toStr.convert { weightStr }.toInt()
+        parsed shouldBe typed
+    }
+
+    @Test
+    fun digitize() {
+        val a = 20
+        val b = 40
+        val expected = typed.age.toList().map {
+            when {
+                it < a -> 0
+                it < b -> 1
+                else -> 2
+            }
+        }
+        typed.age.digitize(a, b).toList() shouldBe expected
+
+        val expectedRight = typed.age.toList().map {
+            when {
+                it <= a -> 0
+                it <= b -> 1
+                else -> 2
+            }
+        }
+        typed.age.digitize(a, b, right = true).toList() shouldBe expectedRight
+    }
+
+    @Test
+    fun corr() {
+        val fixed = typed.fillNulls { weight }.withValue(60)
+        val res = fixed.corr()
+        res.ncol shouldBe 3
+        res.nrow shouldBe 2
+        res["age"][0] shouldBe 1.0
+        res["weight"][0] shouldBe res["age"][1]
+        res["weight"][0] as Double should ToleranceMatcher(0.9, 1.0)
+    }
+
+    @Test
+    fun `aggregate into grouped column`() {
+        val d = typed.groupBy { name }.aggregate {
+            val row = meanFor { age and weight }
+            row into "mean"
+        }
+        d.ncol shouldBe 2
+        d["mean"].isColumnGroup() shouldBe true
+        val mean = d.getColumnGroup("mean")
+        mean.ncol shouldBe 2
+        mean.columnNames() shouldBe listOf("age", "weight")
+        mean.columns().forEach {
+            it.type() shouldBe typeOf<Double>()
+        }
+    }
+
+    @Test
+    fun `mean for all columns`() {
+        val d = typed.groupBy { name }.mean()
+        d.columnNames() shouldBe listOf("name", "age", "weight")
+        d.nrow shouldBe typed.name.countDistinct()
+        d["age"].type() shouldBe typeOf<Double>()
+        d["weight"].type() shouldBe typeOf<Double>()
+    }
+
+    @Test
+    fun `aggregate into table column`() {
+        val d = typed.groupBy { name }.aggregate {
+            val row = select { age and weight }
+            row into "info"
+        }
+        d.ncol shouldBe 2
+        d["info"].isFrameColumn() shouldBe true
+        val info = d.getFrameColumn("info")
+        info.forEach {
+            it.ncol shouldBe 2
+            it.columnNames() shouldBe listOf("age", "weight")
+            it.columns().forEach {
+                it.typeClass shouldBe Int::class
+            }
+        }
+    }
+
+    @Test
+    fun `union table columns`() {
+        val grouped = typed.addId("id").groupBy { name }.toDataFrame()
+        val dfs = (0 until grouped.nrow).map {
+            grouped[it..it]
+        }
+        val dst = dfs.concat().asGroupBy().concat().sortBy("id").remove("id")
+        dst shouldBe typed
+    }
+
+    @Test
+    fun `columns sum`() {
+        val name by columnOf("Alice", "Bob", "Charlie")
+        val age by columnOf(15, 20, 24)
+        val df = dataFrameOf(name, age)
+
+        df.columnNames() shouldBe listOf("name", "age")
+        df.nrow shouldBe 3
+    }
+
+    @Test
+    fun convert1() {
+        val res = typed.convert { age }.to<Double>()
+        res.age.typeClass shouldBe Double::class
+        res["age"].all { it is Double } shouldBe true
+    }
+
+    @Test
+    fun convert2() {
+        val res = typed.convert { weight }.to<BigDecimal?>()
+        res.weight.typeClass shouldBe BigDecimal::class
+        res["weight"].all { it == null || it is BigDecimal } shouldBe true
+    }
+
+    @Test
+    fun convert3() {
+        val res = typed.convert { all() }.to<String?>()
+        res.columns().forEach { it.typeClass shouldBe String::class }
+        res.columns().map { it.hasNulls() } shouldBe typed.columns().map { it.hasNulls() }
+    }
+
+    @Test
+    fun replace() {
+        val res = typed.replace { age }.with(2021 - typed.age)
+        val expected = typed.update { age }.with { 2021 - age }
+        res shouldBe expected
+    }
+
+    @Test
+    fun `replace with rename`() {
+        val res = typed.replace { age }.with { it.rename("age2") }
+        res shouldBe typed.rename { age }.into("age2")
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `replace exception`() {
+        typed.replace { colsOf<Int?>() }.with(typed.name)
+    }
+
+    @Test
+    fun `replace two columns`() {
+        val res = typed.replace { age and weight }.with(typed.age * 2, typed.weight * 2)
+        val expected = typed.update { age and weight }.with { it?.times(2) }
+        res shouldBe expected
+    }
+
+    @Test
+    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")
+        res shouldBe expected
+    }
+
+    @Test
+    fun `add dataframe`() {
+        val first = typed.select { name and age }
+        val second = typed.select { city and weight }
+        first.add(second) shouldBe typed
+        first.addAll(second.columns()) shouldBe typed
+        first + second.columns() shouldBe typed
+    }
+
+    @Test
+    fun explodeLists() {
+        val df = dataFrameOf("lists")(listOf(1, 2), listOf(3))
+
+        df.explode("lists") shouldBe dataFrameOf("lists")(1, 2, 3)
+    }
+
+    @Test
+    fun splitUnequalLists() {
+        val values by columnOf(1, 2, 3, 4)
+        val list1 by columnOf(listOf(1, 2, 3), listOf(), listOf(1, 2), null)
+        val list2 by columnOf(listOf(1, 2), listOf(1, 2), listOf(1, 2), listOf(1))
+        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
+        )
+        res shouldBe expected
+    }
+
+    @Test
+    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()
+        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"
+        )
+        res shouldBe expected
+    }
+
+    @Test
+    fun `update nullable column with not null`() {
+        val df = dataFrameOf("name", "value")("Alice", 1, null, 2)
+        df.update("name").at(0).withValue("ALICE")
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `update with wrong type`() {
+        typed.update("age").with { "string" }
+    }
+
+    @Test
+    fun `update with null`() {
+        val updated = typed.update { age }.at(2).withNull()
+        updated.age[2] shouldBe null
+        updated.age.hasNulls shouldBe true
+    }
+
+    @Test
+    fun `update with two conditions`() {
+        fun DataFrame<Person>.check() = indices { age == 100 } shouldBe listOf(1, 3)
+
+        typed.update { age }.at(1..3).where { it > 20 }.with { 100 }.check()
+        typed.update { age }.where { it > 20 }.at(1..3).with { 100 }.check()
+    }
+
+    @Test
+    fun `update nulls`() {
+        typed.update { weight }.where { it == null }.with { 15 }.weight.hasNulls shouldBe false
+    }
+
+    @Test
+    fun `mean all columns`() {
+        typed.mean().values() shouldBe listOf(typed.age.mean(), typed.weight.mean())
+    }
+
+    @Test
+    fun `mean by string`() {
+        typed.mean("weight") shouldBe typed.weight.mean()
+    }
+
+    @Test
+    fun `create column with single string value`() {
+        val frameCol by columnOf(typed, null, typed)
+        frameCol.kind() shouldBe ColumnKind.Frame
+        frameCol.name() shouldBe "frameCol"
+
+        val mapCol by columnOf(typed.name, typed.city)
+        mapCol.kind() shouldBe ColumnKind.Group
+        mapCol.name() shouldBe "mapCol"
+
+        val valueCol = columnOf("Alice") named "person"
+        valueCol.kind() shouldBe ColumnKind.Value
+        valueCol.name() shouldBe "person"
+    }
+
+    @Test
+    fun `append many`() {
+        val res = typed.append(
+            "John",
+            22,
+            "New York",
+            46,
+            "Philip",
+            25,
+            "Chelyabinsk",
+            36
+        )
+        res.nrow shouldBe typed.nrow + 2
+    }
+
+    @Test
+    fun `append wrong number of arguments`() {
+        shouldThrow<IllegalStateException> {
+            dataFrameOf("name", "age")(
+                "Alice", 15,
+                "Bob", 20
+            )
+                .append("John")
+        }
+    }
+
+    @Test
+    fun `first last`() {
+        typed.first() shouldBe typed[0]
+        typed.last() shouldBe typed[typed.nrow - 1]
+        typed.city.first() shouldBe typed[0].city
+        typed.city.last() shouldBe typed[typed.nrow - 1].city
+    }
+
+    @Test
+    fun `select several rows`() {
+        df[2, 5].nrow shouldBe 2
+        df[0, 3, 5] shouldBe df[listOf(0, 3, 5)]
+        df[3, 5][name, age] shouldBe df[name, age][3, 5]
+    }
+
+    @Test
+    fun `select several column values`() {
+        typed.name[2, 5, 6] shouldBe typed.name[listOf(2, 5, 6)]
+    }
+
+    @Test
+    fun `get by column accessors`() {
+        val animal by columnOf("cat", "snake", "dog")
+        val age by columnOf(2.5, 3.0, 0.5)
+        val visits by columnOf(1, 3, 2)
+
+        val df = dataFrameOf(animal, age, visits)
+
+        val d1 = df[1..1][animal, age]
+        d1.ncol shouldBe 2
+        d1.nrow shouldBe 1
+
+        val d2 = df[0..1]["animal", "age"]
+        d2.ncol shouldBe 2
+        d2.nrow shouldBe 2
+
+        val r1 = df[1][animal, age]
+        r1.values() shouldBe d1.single().values()
+
+        val r2 = df[0]["animal", "age"]
+        r2 shouldBe df[animal, age][0]
+    }
+
+    @Test
+    fun between() {
+        typed.filter { age.between(20, 40, false) }.nrow shouldBe 2
+
+        typed.filter { age in 20..40 }.nrow shouldBe 5
+
+        typed.age.between(20, 40).count { it } shouldBe 5
+    }
+
+    @Test
+    fun iterators() {
+        var counter = 0
+        for (a in df) counter++
+        counter shouldBe df.nrow
+
+        var ageSum = 0
+        for (a in typed.age)
+            ageSum += a
+
+        ageSum shouldBe typed.age.sum()
+    }
+
+    @Test
+    fun `create with random`() {
+        val df = dataFrameOf('a'..'f').randomInt(3)
+        df.nrow shouldBe 3
+        df.ncol shouldBe ('a'..'f').count()
+        df.columns().forEach { it.type() shouldBe typeOf<Int>() }
+    }
+
+    @Test
+    fun `create with list builder`() {
+        val df = dataFrameOf(4..10 step 2) { h -> List(10) { h } }
+        df.nrow shouldBe 10
+        df.ncol shouldBe 4
+        df.columns().forEach { col -> col.forEach { it shouldBe col.name().toInt() } }
+    }
+
+    @Test
+    fun `create with vararg header and builder`() {
+        val df = dataFrameOf("first", "secon", "third") { name -> name.toCharArray().toList() }
+        df.nrow shouldBe 5
+        df.ncol shouldBe 3
+        df.columns().forEach { col -> col.name() shouldBe col.values().joinToString("") }
+    }
+
+    @Test
+    fun `create with vararg doubles and fill equal`() {
+        val df = dataFrameOf(1.0.toString(), 2.5.toString()).fill(5, true)
+        df.nrow shouldBe 5
+        df.ncol shouldBe 2
+        df.columns().forEach { col -> col.forEach { it shouldBe true } }
+    }
+
+    @Test
+    fun `create with list of names and fill nulls`() {
+        val names = listOf("first", "second")
+        val df = dataFrameOf(names).nulls<Double>(10)
+        df.nrow shouldBe 10
+        df.ncol shouldBe 2
+        df.columns().forEach { col -> (col.type() == typeOf<Double?>() && col.allNulls()) shouldBe true }
+    }
+
+    @Test
+    fun `create with list of names and fill true`() {
+        val first by column<Boolean>()
+        val second by column<Boolean>()
+        val df = dataFrameOf(first, second).fill(5) { true }
+        df.nrow shouldBe 5
+        df.ncol shouldBe 2
+        df.columns().forEach { col -> (col.type() == typeOf<Boolean>() && col.all { it == true }) shouldBe true }
+    }
+
+    @Test
+    fun `create with int range header and int range data `() {
+        val df = dataFrameOf(1..5) { 1..5 }
+        df.nrow shouldBe 5
+        df.ncol shouldBe 5
+        df.columns().forEach { col -> col.forEachIndexed { row, value -> value shouldBe row + 1 } }
+    }
+
+    @Test
+    fun `get typed column by name`() {
+        val col = df.getColumn("name").cast<String>()
+        col[0].substring(0, 3) shouldBe "Ali"
+    }
+
+    @Test
+    fun `select all after`() {
+        typed.select { allAfter(age) } shouldBe typed.select { city and weight }
+        typed.select { allSince(age) } shouldBe typed.select { age and city and weight }
+        typed.select { allBefore(age) } shouldBe typed.select { name }
+        typed.select { allUntil(age) } shouldBe typed.select { name and age }
+    }
+
+    @Test
+    fun `cols of type`() {
+        val stringCols = typed.select { colsOf<String?>() }
+        stringCols.columnNames() shouldBe listOf("name", "city")
+    }
+
+    @Test
+    fun `get row value by expression`() {
+        val expression: RowExpression<Person, Int> = { it.age * 2 }
+        val added = typed.add("new") { it[expression] }
+        added shouldBe typed.add("new") { age * 2 }
+    }
+
+    @Test
+    fun `render nested data frames to string`() {
+        val rendered = typed.drop(1).groupBy { name }.groups.asIterable()
+            .joinToString("\n") { renderValueForStdout(it).truncatedContent }
+        rendered shouldBe """
+            [2 x 4]
+            [3 x 4]
+            [1 x 4] { name:Alice, age:20, weight:55 }
+        """.trimIndent()
+    }
+
+    @Test
+    fun `drop where any na`() {
+        val updated = typed.convert { weight }.with { if (name == "Alice") Double.NaN else it?.toDouble() }
+        val expected = updated.count { city != null && !("weight"<Double?>()?.isNaN() ?: true) }
+
+        fun AnyFrame.check() = nrow shouldBe expected
+
+        updated.dropNA { city and weight }.check()
+        updated.dropNA(city, weight).check()
+        updated.dropNA("city", "weight").check()
+        updated.dropNA(Person::city, Person::weight).check()
+    }
+
+    @Test
+    fun `drop where all na`() {
+        val updated = typed.convert { weight }.with { if (name == "Alice") Double.NaN else it?.toDouble() }
+        val expected = updated.count { city != null || !("weight"<Double?>()?.isNaN() ?: true) }
+
+        fun AnyFrame.check() = nrow shouldBe expected
+
+        updated.dropNA(whereAllNA = true) { city and weight }.check()
+        updated.dropNA(city, weight, whereAllNA = true).check()
+        updated.dropNA("city", "weight", whereAllNA = true).check()
+        updated.dropNA(Person::city, Person::weight, whereAllNA = true).check()
+    }
+
+    @Test
+    fun sortWith() {
+        typed.sortWith { r1, r2 ->
+            when {
+                r1.name < r2.name -> -1
+                r1.name > r2.name -> 1
+                else -> -r1.age.compareTo(r2.age)
+            }
+        } shouldBe typed.sortBy { name and age.desc() }
+
+        val comparator = Comparator<DataRow<Person>> { r1, r2 -> -r1.name.compareTo(r2.name) }
+        typed.sortWith(comparator) shouldBe typed.sortByDesc { name }
+    }
+
+    @Test
+    fun sortByDescDesc() {
+        typed.sortByDesc { name.desc() and age } shouldBe typed.sortBy { name and age.desc() }
+    }
+
+    @Test
+    fun `get column by columnRef with data`() {
+        val col by columnOf(1, 2, 3)
+        val df = col.toDataFrame()
+        df[1..2][col].values() shouldBe listOf(2, 3)
+    }
+
+    @Test
+    fun `get by column`() {
+        typed[1..2][{ typed.age }].size() shouldBe typed.age.size()
+    }
+
+    @Test
+    fun `null column test`() {
+        val df = dataFrameOf("col")(null, null)
+        df["col"].kind() shouldBe ColumnKind.Value
+        df["col"].type() shouldBe nothingType(true)
+    }
+
+    @Test
+    fun `groupBy with map`() {
+        typed.groupBy { name.map { it.lowercase() } }.toDataFrame().name.values() shouldBe typed.name.distinct()
+            .lowercase()
+            .values()
+    }
+
+    @Test
+    fun `groupBy none`() {
+        val grouped = typed.groupBy { none() }
+        grouped.keys.ncol shouldBe 0
+        grouped.groups.size shouldBe 1
+        val values = grouped.values()
+        values.nrow shouldBe 1
+        values.columns().forEach {
+            it.typeClass shouldBe List::class
+            (it[0] as List<*>).size shouldBe typed.nrow
+        }
+        values.explode() shouldBe typed
+    }
+
+    @Test
+    fun `pivot max`() {
+        val pivoted = typed.pivot(inward = false) { city }.groupBy { name }.max { age }
+        pivoted.single { name == "Charlie" }["Moscow"] shouldBe 30
+    }
+
+    @Test
+    fun `pivot all values`() {
+        val pivoted = typed.pivot(inward = false) { city }.groupBy { name }.values()
+        pivoted.ncol shouldBe 1 + typed.city.countDistinct()
+        pivoted.columns().drop(1).forEach {
+            it.kind() shouldBe ColumnKind.Group
+            it.asColumnGroup().columnNames() shouldBe listOf("age", "weight")
+        }
+    }
+
+    @Test
+    fun `pivot mean values`() {
+        val pivoted = typed.pivot { city }.groupBy { name }.mean()
+        pivoted.getColumnGroup(1).columns().forEach {
+            it.kind() shouldBe ColumnKind.Group
+            val group = it.asColumnGroup()
+            group.columnNames() shouldBe listOf("age", "weight")
+            group.columns().forEach {
+                it.type() shouldBe typeOf<Double?>()
+            }
+        }
+    }
+
+    @Test
+    fun `aggregate dataframe with pivot`() {
+        val summary = typed.aggregate {
+            count() into "count"
+            pivot { name }.max { age }
+            sum { weight } into "total weight"
+        }
+        val expected = dataFrameOf("count", "Alice", "Bob", "Charlie", "total weight")(7, 20, 45, 40, 354)
+        summary shouldBe expected.group { cols(1..3) }.into("name")[0]
+    }
+
+    @Test
+    fun `pivot grouped max`() {
+        val pivoted = typed.pivot { name }.groupBy { city }.max()
+        pivoted.getColumnGroup("name").columns().forEach {
+            it.kind() shouldBe ColumnKind.Group
+            val group = it.asColumnGroup()
+            group.columnNames() shouldBe listOf("age", "weight")
+        }
+    }
+
+    @Test
+    fun `find the longest string`() {
+        val longestCityName = "Taumatawhakatangihangakoauauotamateaturipukakapikimaungahoronukupokaiwhenuakitanatahu"
+        val updated = typed.update { city }.where { it == "Dubai" }.withValue(longestCityName)
+        updated.valuesNotNull { colsOf<String?>() }.maxByOrNull { it.length } shouldBe longestCityName
+    }
+
+    @Test
+    fun `sort by expression`() {
+        val sorted = typed.sortBy { expr { name.length }.desc() }
+        sorted.name.values() shouldBe typed.name.values().sortedByDescending { it.length }
+    }
+
+    @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 }
+    }
+
+    @Test
+    fun `grouped sort by key`() {
+        val sorted = typed.groupBy { name }.sortByKey()
+        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() }
+        grouped[g.name].kind() shouldBe ColumnKind.Group
+    }
+
+    @Test
+    fun `filter GroupBy by groups`() {
+        val grouped = typed.groupBy { name }
+        val filtered = grouped.filter { group.nrow > 2 }.concat()
+        filtered shouldBe typed.filter { name == "Charlie" }
+    }
+
+    @Test
+    fun `split inplace`() {
+        val split = typed.split { name }.by { it.toCharArray().asIterable() }.inplace()
+        split["name"] shouldBe typed.name.map { it.toCharArray().toList() }
+    }
+
+    @Test
+    fun `split into rows with transform`() {
+        val split = typed.split { city }.by { it.toCharArray().toList() }.intoRows()
+        split.nrow shouldBe typed.city.sumOf { it?.length ?: 0 }
+    }
+
+    @Test
+    fun `render to string`() {
+        val expected = """
+                 name age   city weight
+            0   Alice  15 London     54
+            1     Bob  45  Dubai     87
+            2 Charlie  20 Moscow   null
+            3 Charlie  40  Milan   null
+            4     Bob  30  Tokyo     68
+            5   Alice  20   null     55
+            6 Charlie  30 Moscow     90
+        """.trimIndent()
+
+        typed.toString().trimIndent() shouldBe expected
+    }
+
+    @Test
+    fun `isNumber`() {
+        typed.age.isNumber() shouldBe true
+        typed.weight.isNumber() shouldBe true
+    }
+
+    @Test
+    fun `pivot null to default`() {
+        val pivoted = typed.groupBy { name }.pivot { city }.default(0).min { weight }
+        pivoted.columns().forEach {
+            it.hasNulls() shouldBe false
+        }
+    }
+
+    @Test
+    fun `iterable to column`() {
+        val ref by column<String>()
+        val col = listOf("a", null).toColumn(ref)
+        col.hasNulls() shouldBe true
+    }
+
+    @Test
+    fun `columnAccessor map linear`() {
+        // SampleStart
+        val age by column<Int>()
+        var counter = 0
+        val year by age.map {
+            counter++
+            2021 - it
+        }
+        df.filter { year > 2000 }.nrow shouldBe 3
+        counter shouldBe df.nrow
+        // SampleEnd
+    }
+
+    @Test
+    fun convertTo() {
+        data class Target(
+            val name: String,
+            val age: Int,
+            val city: String?,
+            val weight: Int?,
+        )
+
+        df.convertTo<Target>() shouldBe df
+        df.convert { age }.toStr().convertTo<Target>() shouldBe df
+        df.add("col") { 1 }.convertTo<Target>(ExcessiveColumns.Remove) shouldBe df
+
+        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()
+
+        shouldThrow<IllegalArgumentException> {
+            df.remove { age }.convertTo<Target>()
+        }
+
+        df.remove { age }.convertTo<Target> {
+            fill { age }.with { -1 }
+        } shouldBe df.update { age }.with { -1 }.move { age }.toRight()
+
+        shouldThrow<TypeConversionException> {
+            df.update { name }.at(2).withNull().convertTo<Target>()
+        }
+
+        shouldThrow<IllegalArgumentException> {
+            df.convert { age }.toStr().convertToImpl(
+                typeOf<Target>(),
+                allowConversion = false,
+                ExcessiveColumns.Remove
+            )
+        }
+
+        shouldThrow<ExcessiveColumnsException> {
+            df.add("col") { 1 }.convertTo<Target>(ExcessiveColumns.Fail) shouldBe df
+        }
+
+        val list = df.toListOf<Target>()
+        list shouldBe df.convertTo<Target>().toList()
+
+        val listDf = list.toDataFrame()
+        listDf shouldBe df
+        listDf.toList() shouldBe list
+    }
+
+    @Test
+    fun typedFrameColumn() {
+        @DataSchema
+        data class Student(val name: String, val age: Int, val weight: Int?)
+
+        @DataSchema
+        data class Target(val city: String?, val students: List<Student>)
+
+        val grouped = df.groupBy { city }.toDataFrame("students")
+
+        val list = grouped.toListOf<Target>()
+        list shouldBe grouped.convertTo<Target>().toList()
+
+        val listDf = list.toDataFrame(maxDepth = 2)
+        listDf shouldBe grouped.update { getFrameColumn("students") }.with { it.remove("city") }
+
+        listDf.toList() shouldBe list
+    }
+
+    @Test
+    fun reorderColumns() {
+        typed.reorderColumnsByName().columnNames() shouldBe typed.columnNames().sorted()
+        val grouped = typed.groupBy { city }.into("a").reorderColumnsByName()
+        grouped.columnNames() shouldBe listOf("a", "city")
+        grouped.getFrameColumn("a")[0].columnNames() shouldBe typed.columnNames().sorted()
+    }
+
+    @Test
+    fun typedColumnGroup() {
+        @DataSchema
+        data class Info(val age: Int, val weight: Int?)
+
+        @DataSchema
+        data class Target(val name: String, val info: Info, val city: String?)
+
+        val grouped = typed.group { age and weight }.into("info")
+
+        val list = grouped.toListOf<Target>()
+        list shouldBe grouped.convertTo<Target>().toList()
+
+        val listDf = list.toDataFrame(maxDepth = 2)
+        listDf shouldBe grouped
+        listDf.toList() shouldBe list
+    }
+
+    @Test
+    fun splitWithRegex() {
+        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)
+    }
+
+    @Test
+    fun splitIntoThisAndNewColumn() {
+        val split = typed.split { name }.by { listOf(it.dropLast(1), it.last()) }.into("name", "lastChar")
+        split.columnNames().sorted() shouldBe (typed.columnNames() + "lastChar").sorted()
+    }
+
+    @Test
+    fun groupByAggregateSingleColumn() {
+        val agg = typed.groupBy { name }.aggregate { city into "city" }
+        agg shouldBe typed.groupBy { name }.values { city }
+        agg["city"].type shouldBe typeOf<List<String?>>()
+    }
+
+    @Test
+    fun implodeWithNulls() {
+        val merged = typed.update { weight }.where { name == "Charlie" }.withNull()
+            .select { name and weight }
+            .implode(dropNA = true) { weight }
+
+        merged["weight"].type() shouldBe typeOf<List<Int>>()
+    }
+
+    @Test
+    fun updateWithZero() {
+        val updated = typed
+            .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" }
+        filtered.nrow shouldBe 3
+        filtered.age.forEach {
+            it shouldBe 0
+        }
+        filtered["weight"].forEach {
+            it shouldBe .0
+        }
+    }
+
+    @Test
+    fun map() {
+        val mapped = typed.mapToFrame {
+            name into "name"
+            "year" from 2021 - age
+            "CITY" from { city?.uppercase() }
+        }
+        mapped.columnNames() shouldBe listOf("name", "year", "CITY")
+    }
+
+    @Test
+    fun `groupByGroup name clash`() {
+        val groupName = GroupBy.groupedColumnAccessor.name()
+        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().describe()
+        desc.nrow shouldBe typed.ncol + 1
+        desc.print()
+    }
+
+    @Test
+    fun `index by column accessor`() {
+        val col = listOf(1, 2, 3, 4, 5).toColumn("name")
+        col.toDataFrame()[1..2][col].size shouldBe 2
+
+        val col2 = columnOf(1, 2, 3, 4, 5) named "name"
+        col2.toDataFrame()[1..2][col2].size shouldBe 2
+
+        val col3 by columnOf(1, 2, 3, 4, 5)
+        col3.toDataFrame()[1..2][col3].size shouldBe 2
+
+        val col4 by listOf(1, 2, 3, 4, 5).toColumn()
+        col4.toDataFrame()[1..2][col4].size shouldBe 2
+    }
+
+    @Test
+    fun `take drop in columns selector`() {
+        typed.select { take(3) } shouldBe typed.select { cols(0..2) }
+        typed.select { takeLast(2) } shouldBe typed.select { cols(2..3) }
+        typed.select { drop(1) } shouldBe typed.select { cols(1..3) }
+        typed.select { dropLast(1) } shouldBe typed.select { cols(0..2) }
+    }
+
+    @Test
+    fun `except in columns selector`() {
+        typed.select { except { age and weight } } shouldBe typed.select { name and city }
+
+        typed.group { age and weight }.into("info")
+            .select { dropLast(1) except { "info"["age"] } } shouldBe typed.select { name and weight }
+    }
+
+    @Test
+    fun `get by empty path`() {
+        val all = typed[pathOf()]
+
+        all.asColumnGroup().asDataFrame().columns() shouldBe typed.columns()
+
+        typed.getColumn { emptyPath() } shouldBe all
+    }
+
+    @Test
+    fun `update frame column to null`() {
+        val grouped = typed.groupBy { name }.toDataFrame("group")
+        grouped["group"].kind shouldBe ColumnKind.Frame
+        val updated = grouped.update("group").at(2).withNull()
+        updated["group"].kind shouldBe ColumnKind.Value
+    }
+
+    @Test
+    fun `merge into same name`() {
+        typed.merge { name and city }.into("age") shouldBe
+            typed.merge { name and city }.into("data").remove("age").rename("data" to "age")
+    }
+
+    @Test
+    fun `groupBy sort`() {
+        typed.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()
+    }
+
+    @Test
+    fun `takedrop for column`() {
+        typed.age.take(2) shouldBe typed.age[0..1]
+        typed.age.drop(2) shouldBe typed.age[2 until typed.nrow]
+        typed.age.takeLast(2) shouldBe typed.age.drop(typed.nrow - 2)
+        typed.age.dropLast(2) shouldBe typed.age.take(typed.nrow - 2)
+    }
+
+    @Test
+    fun `transpose row`() {
+        typed.select { age and weight }[1].transpose().maxBy { it.value as Int? }.name shouldBe "weight"
+        typed[2].transpose().dropNulls { value }.name.toList() shouldBe listOf("name", "age", "city")
+    }
+
+    @Test
+    fun xs() {
+        typed.xs("Charlie") shouldBe typed.filter { name == "Charlie" }.remove { name }
+        typed.xs("Charlie", 20).nrow shouldBe 1
+        typed.xs(20) { age }.nrow shouldBe 2
+        shouldThrow<java.lang.IllegalArgumentException> {
+            typed.xs(20) { age and weight }
+        }
+        shouldThrow<java.lang.IllegalArgumentException> {
+            typed.xs("Charlie", 20) { name }
+        }
+        shouldThrow<java.lang.IllegalArgumentException> {
+            typed.xs("Charlie", 20, "Moscow", null, 1)
+        }
+    }
+
+    @Test
+    fun `groupBy xs`() {
+        typed.groupBy { name }.xs("Charlie").concat() shouldBe typed.xs("Charlie")
+        typed.groupBy { name }.xs("Moscow") { city }.concat().print()
+    }
+
+    @Test
+    fun getMissingColumn() {
+        val col = typed.getColumnsImpl(UnresolvedColumnsPolicy.Create) { "unknown"<Int>() }
+        col.size shouldBe 1
+        col[0].name shouldBe "unknown"
+        col[0].isMissingColumn() shouldBe true
+    }
+
+    @Test
+    fun getMissingColumn2() {
+        val col = typed.remove { city }.getColumnsImpl(UnresolvedColumnsPolicy.Create) { city }
+        col.size shouldBe 1
+        col[0].name shouldBe typed.city.name()
+        col[0].isMissingColumn() shouldBe true
+    }
+
+    @Test
+    fun `groupBy into accessor or kproperty`() {
+        val n by column<Int>()
+
+        data class Data(@ColumnName("total") val count: Int)
+
+        typed.groupBy { name }.aggregate {
+            count() into n
+            count() into Data::count
+        } shouldBe typed.groupBy { name }.count(n.name())
+            .add("total") { "n"<Int>() }
+    }
+
+    @Test
+    fun `aggregate null row`() {
+        val aggregated = typed.groupBy { name }.aggregate {
+            (if (name.first().startsWith("A")) first() else null) into "agg"
+        }["agg"]
+
+        aggregated.kind shouldBe ColumnKind.Group
+        aggregated.size shouldBe 3
+        aggregated.count { it.isNA } shouldBe 2
+    }
+
+    @Test
+    fun takeWhile() {
+        typed.takeWhile { weight != null } shouldBe typed[0..1]
+        typed.takeWhile { true } shouldBe typed
+    }
+
+    @Test
+    fun dropWhile() {
+        typed.dropWhile { weight != null } shouldBe typed.drop(2)
+        typed.dropWhile { false } shouldBe typed
+    }
+
+    @Test
+    fun takeLast() {
+        typed.takeLast(2) shouldBe typed[5..6]
+        shouldThrow<IllegalArgumentException> {
+            typed.takeLast(-1)
+        }
+        typed.takeLast(20) shouldBe typed
+    }
+
+    @Test
+    fun dropLast() {
+        typed.dropLast(2) shouldBe typed[0..4]
+        shouldThrow<IllegalArgumentException> {
+            typed.dropLast(-1)
+        }
+        typed.dropLast(20) shouldBe typed.take(0)
+    }
+
+    @Test
+    fun drop() {
+        typed.drop(2) shouldBe typed[2..6]
+        shouldThrow<IllegalArgumentException> {
+            typed.drop(-1)
+        }
+        typed.drop(typed.nrow) shouldBe typed.filter { false }
+        typed.drop(20) shouldBe typed.filter { false }
+    }
+
+    @Test
+    fun take() {
+        typed.take(2) shouldBe typed[0..1]
+        shouldThrow<IllegalArgumentException> {
+            typed.take(-1)
+        }
+        typed.take(typed.nrow) shouldBe typed
+        typed.take(20) shouldBe typed
+    }
+
+    @Test
+    fun `select into accessor`() {
+        val newName by column<String>()
+        typed.select { name into newName and age }.columnNames() shouldBe listOf("newName", "age")
+    }
+}
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
new file mode 100644
index 000000000..d76ad386c
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataFrameTreeTests.kt
@@ -0,0 +1,737 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import io.kotest.assertions.fail
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.shouldNotBe
+import org.jetbrains.dataframe.impl.codeGen.CodeGenerator
+import org.jetbrains.dataframe.impl.codeGen.InterfaceGenerationMode
+import org.jetbrains.dataframe.impl.codeGen.generate
+import org.jetbrains.kotlinx.dataframe.*
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.GroupBy
+import org.jetbrains.kotlinx.dataframe.api.GroupWithKey
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.addId
+import org.jetbrains.kotlinx.dataframe.api.after
+import org.jetbrains.kotlinx.dataframe.api.append
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.asDataFrame
+import org.jetbrains.kotlinx.dataframe.api.asGroupBy
+import org.jetbrains.kotlinx.dataframe.api.at
+import org.jetbrains.kotlinx.dataframe.api.by
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnGroup
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.columnsCount
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.count
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.dfsOf
+import org.jetbrains.kotlinx.dataframe.api.distinct
+import org.jetbrains.kotlinx.dataframe.api.dropNulls
+import org.jetbrains.kotlinx.dataframe.api.duplicate
+import org.jetbrains.kotlinx.dataframe.api.duplicateRows
+import org.jetbrains.kotlinx.dataframe.api.emptyDataFrame
+import org.jetbrains.kotlinx.dataframe.api.explode
+import org.jetbrains.kotlinx.dataframe.api.expr
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.forEach
+import org.jetbrains.kotlinx.dataframe.api.frameColumn
+import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.getColumnPath
+import org.jetbrains.kotlinx.dataframe.api.getColumnWithPath
+import org.jetbrains.kotlinx.dataframe.api.getColumns
+import org.jetbrains.kotlinx.dataframe.api.getValue
+import org.jetbrains.kotlinx.dataframe.api.group
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.implode
+import org.jetbrains.kotlinx.dataframe.api.indices
+import org.jetbrains.kotlinx.dataframe.api.insert
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.intoRows
+import org.jetbrains.kotlinx.dataframe.api.inward
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.isEmpty
+import org.jetbrains.kotlinx.dataframe.api.isFrameColumn
+import org.jetbrains.kotlinx.dataframe.api.join
+import org.jetbrains.kotlinx.dataframe.api.last
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.max
+import org.jetbrains.kotlinx.dataframe.api.maxBy
+import org.jetbrains.kotlinx.dataframe.api.median
+import org.jetbrains.kotlinx.dataframe.api.minus
+import org.jetbrains.kotlinx.dataframe.api.move
+import org.jetbrains.kotlinx.dataframe.api.moveTo
+import org.jetbrains.kotlinx.dataframe.api.moveToLeft
+import org.jetbrains.kotlinx.dataframe.api.moveToRight
+import org.jetbrains.kotlinx.dataframe.api.pathOf
+import org.jetbrains.kotlinx.dataframe.api.perRowCol
+import org.jetbrains.kotlinx.dataframe.api.pivot
+import org.jetbrains.kotlinx.dataframe.api.remove
+import org.jetbrains.kotlinx.dataframe.api.rename
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.jetbrains.kotlinx.dataframe.api.single
+import org.jetbrains.kotlinx.dataframe.api.sortBy
+import org.jetbrains.kotlinx.dataframe.api.split
+import org.jetbrains.kotlinx.dataframe.api.sumOf
+import org.jetbrains.kotlinx.dataframe.api.toColumnAccessor
+import org.jetbrains.kotlinx.dataframe.api.toTop
+import org.jetbrains.kotlinx.dataframe.api.under
+import org.jetbrains.kotlinx.dataframe.api.ungroup
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.api.values
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.api.withNull
+import org.jetbrains.kotlinx.dataframe.api.xs
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
+import org.jetbrains.kotlinx.dataframe.columns.depth
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class DataFrameTreeTests : BaseTest() {
+
+    @DataSchema
+    interface NameAndCity {
+        val name: String
+        val city: String?
+    }
+
+    @DataSchema
+    interface GroupedPerson {
+        val nameAndCity: DataRow<NameAndCity>
+        val age: Int
+        val weight: Int?
+    }
+
+    val df2 = df.move { name and city }.under("nameAndCity")
+    val typed2 = df2.cast<GroupedPerson>()
+
+    val nameAndCity by columnGroup()
+    val nameInGroup = nameAndCity.column<String>("name")
+
+    @Test
+    fun create() {
+        val nameAndCity by columnOf(typed.name, typed.city)
+        val df3 = dataFrameOf(nameAndCity, typed.age, typed.weight)
+        df3 shouldBe df2
+    }
+
+    @Test
+    fun createFrameColumn() {
+        val rowsColumn by columnOf(typed[0..3], typed[4..5], typed[6..6])
+        val df = dataFrameOf(rowsColumn).asGroupBy { rowsColumn }
+        val res = df.concat()
+        res shouldBe typed
+    }
+
+    @Test
+    fun createFrameColumn2() {
+        val id by column(typed.indices())
+        val groups by id.map { typed[it..it] }
+        val df = dataFrameOf(id, groups)
+        df.rowsCount() shouldBe typed.rowsCount()
+        df.forEach {
+            val rowId = it[id]
+            groups() shouldBe typed[rowId..rowId]
+        }
+    }
+
+    @Test
+    fun `select dfs under group`() {
+        df2.select { nameAndCity.dfsOf<String>() } shouldBe typed2.select { nameAndCity.name }
+        df2.select { nameAndCity.dfsOf<String?>() } shouldBe typed2.select { nameAndCity.name and nameAndCity.city }
+    }
+
+    @Test
+    fun `selects`() {
+        df2.select { nameAndCity.cols() } shouldBe typed2.nameAndCity.select { all() }
+        df2.select { nameAndCity.cols { !it.hasNulls() } } shouldBe typed2.select { nameAndCity.name }
+        df2.select { nameAndCity.cols(0..1) } shouldBe typed2.nameAndCity.select { all() }
+        df2.select { nameAndCity.col(1) } shouldBe typed2.select { nameAndCity.city }
+        df2.select { nameAndCity["city"] } shouldBe typed2.select { nameAndCity.city }
+        df2.select { nameAndCity.cols("city", "name") } shouldBe typed2.select { nameAndCity.city and nameAndCity.name }
+        df2.select { nameAndCity.cols(name, city) } shouldBe typed2.select { nameAndCity.all() }
+        df2.select { nameAndCity[name] } shouldBe typed2.nameAndCity.select { name }
+        df2.select { nameAndCity.cols().drop(1) } shouldBe typed2.nameAndCity.select { city }
+
+        typed2.select { nameAndCity.cols() } shouldBe typed2.nameAndCity.select { all() }
+        typed2.select { nameAndCity.cols { !it.hasNulls() } } shouldBe typed2.select { nameAndCity.name }
+        typed2.select { nameAndCity.cols(0..1) } shouldBe typed2.nameAndCity.select { all() }
+        typed2.select { nameAndCity.col(1) } shouldBe typed2.select { nameAndCity.city }
+        typed2.select { nameAndCity["city"] } shouldBe typed2.select { nameAndCity.city }
+        typed2.select { nameAndCity.cols("city", "name") } shouldBe typed2.select { nameAndCity.city and nameAndCity.name }
+        typed2.select { nameAndCity.cols(name, city) } shouldBe typed2.select { nameAndCity.all() }
+        typed2.select { nameAndCity[name] } shouldBe typed2.nameAndCity.select { name }
+        typed2.select { nameAndCity.cols().drop(1) } shouldBe typed2.nameAndCity.select { city }
+
+        df2.select { col(1) } shouldBe typed2.select { age }
+        df2.select { nameInGroup } shouldBe typed2.nameAndCity.select { name }
+
+        df2[nameInGroup] shouldBe typed2.nameAndCity.name
+    }
+
+    @Test
+    fun getColumnPath() {
+        typed2.getColumnPath { nameAndCity["city"] }.size shouldBe 2
+        typed2.getColumnPath { nameAndCity.col(1) }.size shouldBe 2
+    }
+
+    @Test
+    fun `group indexing`() {
+        df2[nameAndCity][city] shouldBe typed.city
+        typed2.nameAndCity.city shouldBe typed.city
+        df2["nameAndCity"]["city"] shouldBe typed.city
+    }
+
+    @Test
+    fun `convert column group`() {
+        val expected = typed.select { city.rename("nameAndCity") and age and weight }
+
+        df2.convert { nameAndCity }.with { it[city] } shouldBe expected
+        df2.convert { nameAndCity }.with { this[nameAndCity][city] } shouldBe expected
+        typed2.convert { nameAndCity }.with { nameAndCity.city } shouldBe expected
+        typed2.convert { nameAndCity }.with { it.city } shouldBe expected
+    }
+
+    @Test
+    fun `slice`() {
+        val expected = typed[0..2].name
+        val actual = typed2[0..2].nameAndCity.name
+        actual shouldBe expected
+    }
+
+    @Test
+    fun `filter`() {
+        val expected = typed.filter { city == null }.select { weight }
+        typed2.filter { nameAndCity.city == null }.select { weight } shouldBe expected
+        df2.filter { it[nameAndCity][city] == null }.select { weight } shouldBe expected
+    }
+
+    @Test
+    fun `select`() {
+        val expected = typed.select { name and age }
+        typed2.select { nameAndCity.name and age } shouldBe expected
+        df2.select { it[nameAndCity][name] and age } shouldBe expected
+    }
+
+    @Test
+    fun `sort`() {
+        val expected = typed.sortBy { name and age }.moveTo(1) { city }
+        typed2.sortBy { nameAndCity.name and age }.ungroup { nameAndCity } shouldBe expected
+    }
+
+    @Test
+    fun `move`() {
+        val actual = typed2.move { nameAndCity.name }.into("name")
+        actual.columnNames() shouldBe listOf("nameAndCity", "name", "age", "weight")
+        actual.getColumnGroup("nameAndCity").columnNames() shouldBe listOf("city")
+    }
+
+    @Test
+    fun `groupBy`() {
+        val expected = typed.groupBy { name }.max { age }
+        typed2.groupBy { nameAndCity.name }.max { age } shouldBe expected
+    }
+
+    @Test
+    fun `distinct`() {
+        val duplicated = typed2.concat(typed2)
+        duplicated.rowsCount() shouldBe typed2.rowsCount() * 2
+        val dist = duplicated.nameAndCity.distinct()
+        dist shouldBe typed2.nameAndCity.distinct()
+        dist.rowsCount() shouldBe typed2.rowsCount() - 1
+    }
+
+    @Test
+    fun selectDfs() {
+        val cols = typed2.select { dfs { it.hasNulls } }
+        cols shouldBe typed2.select { nameAndCity.city and weight }
+    }
+
+    @Test
+    fun `get child column by accessor`() {
+        val cityCol by column<String?>("city")
+        val selected = typed2.getColumnWithPath {
+            val g = nameAndCity
+            val c = g.get(cityCol)
+            c
+        }
+        selected.path shouldBe pathOf("nameAndCity", "city")
+    }
+
+    @Test
+    fun splitRows() {
+        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 expected = selected.sortBy { nameAndCity.name }
+        val actual = res.sortBy { nameAndCity.name }
+        actual shouldBe expected
+    }
+
+    @Test
+    fun pivot() {
+        val modified = df.append("Alice", 55, "Moscow", 100)
+        val df2 = modified.move { name and city }.under("nameAndCity")
+        val typed2 = df2.cast<GroupedPerson>()
+
+        fun <T, G, R> GroupBy<T, G>.map(body: Selector<GroupWithKey<T, G>, R>): List<R> = keys.rows().mapIndexedNotNull { index, row ->
+            val group = groups[index]
+            val g = GroupWithKey(row, group)
+            body(g, g)
+        }
+
+        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>()).toMap()
+
+        fun <T> DataFrame<T>.check() {
+            columnsCount() shouldBe 2
+            val cities = getColumnGroup("nameAndCity").getColumnGroup("city")
+            cities.columnsCount() shouldBe typed2.nameAndCity.city.countDistinct()
+            this[name] shouldBe typed.name.distinct()
+            val data = cities.columns()
+            data.forEach {
+                if (it.name() == "Moscow") it.type() shouldBe typeOf<List<Int>>()
+                else it.type() shouldBe typeOf<Int?>()
+            }
+
+            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()
+    }
+
+    @Test
+    fun `pivot grouped column`() {
+        val grouped = typed.group { age and weight }.into("info")
+        val pivoted = grouped.pivot { city }.groupBy { name }.values("info")
+        pivoted.columnsCount() shouldBe 2
+
+        val expected =
+            typed.rows().groupBy { it.name to (it.city ?: "null") }.mapValues { it.value.map { it.age to it.weight } }
+        val dataCols = pivoted.getColumns { col(1).all() }
+
+        dataCols.forEach { (it.isColumnGroup() || it.isFrameColumn()) shouldBe true }
+
+        val names = pivoted.name
+        dataCols.forEach { col ->
+            val city = col.name()
+            pivoted.indices().forEach { row ->
+                val name = names[row]
+                val value = col[row]
+                val expValues = expected[name to city]
+                when {
+                    expValues == null -> when (value) {
+                        null -> {
+                        }
+                        is AnyRow -> value.isEmpty() shouldBe true
+                        is AnyFrame -> value.columnsCount() shouldBe 0
+                    }
+                    expValues.size == 1 -> {
+                        value shouldNotBe null
+                        val single =
+                            if (value is AnyRow) value else if (value is AnyFrame) value[0] else fail("invalid value type")
+                        single.columnsCount() shouldBe 2
+                        single.getValue<Int>("age") to single.getValue<Int?>("weight") shouldBe expValues[0]
+                    }
+                    else -> {
+                        val df = value as? AnyFrame
+                        df shouldNotBe null
+                        df!!.rows().map { it["age"] as Int to it["weight"] as Int? }
+                            .sortedBy { it.first } shouldBe expValues.sortedBy { it.first }
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun splitCols() {
+        val split = typed2.split { nameAndCity.name }.by { it.toCharArray().toList() }.inward { "char$it" }
+        split.columnNames() shouldBe typed2.columnNames()
+        split.rowsCount() shouldBe typed2.rowsCount()
+        split.nameAndCity.columnNames() shouldBe typed2.nameAndCity.columnNames()
+        val nameGroup = split.nameAndCity.name.asColumnGroup()
+        nameGroup.name() shouldBe "name"
+        nameGroup.columnsCount() shouldBe typed2.nameAndCity.name.map { it.length }.max()
+        nameGroup.columnNames() shouldBe (1..nameGroup.columnsCount()).map { "char$it" }
+    }
+
+    @Test
+    fun `split into rows`() {
+        val split = typed2.split { nameAndCity.name }.by { it.toCharArray().toList() }.intoRows()
+        val merged = split.implode { nameAndCity.name }
+        val joined = merged.convert { nameAndCity.name }.cast<List<Char>>().with { it.joinToString("") }
+        joined shouldBe typed2
+    }
+
+    @Test
+    fun `all except`() {
+        val info by columnGroup()
+        val moved = typed.group { except(name) }.into(info)
+        val actual = moved.select { except(info) }
+        actual shouldBe typed.select { name }
+    }
+
+    @Test
+    fun `move and group`() {
+        val info by columnGroup()
+        val moved = typed.group { except(name) }.into(info)
+        val grouped = moved.groupBy { except(info) }.toDataFrame()
+        grouped.rowsCount() shouldBe typed.name.countDistinct()
+    }
+
+    @Test
+    fun `merge rows into table`() {
+        val info by columnGroup()
+        val moved = typed.group { except(name) }.into(info)
+        val merged = moved.implode { info }
+        val grouped = typed.groupBy { name }.updateGroups { remove { name } }
+        val expected = grouped.toDataFrame().rename(grouped.groups).into(info)
+        merged shouldBe expected
+    }
+
+    @Test
+    fun `update grouped column to table`() {
+        val info by columnGroup()
+        val grouped = typed.group { age and weight }.into(info)
+        val updated = grouped.convert(info).perRowCol { row, column -> column.asColumnGroup().asDataFrame() }
+        val col = updated[info.name()]
+        col.kind() shouldBe ColumnKind.Frame
+        val table = col as FrameColumn<*>
+        table.schema.value.columns.map { it.key }.sorted() shouldBe typed.select { age and weight }.columnNames()
+            .sorted()
+    }
+
+    @Test
+    fun extensionPropertiesTest() {
+        val code = CodeGenerator.create().generate<GroupedPerson>(
+            interfaceMode = InterfaceGenerationMode.None,
+            extensionProperties = true
+        ).declarations
+        val columnsContainer = ColumnsContainer::class.qualifiedName
+        val dataFrameRowBase = DataRow::class.qualifiedName
+        val dataFrameRow = DataRow::class.qualifiedName
+        val className = GroupedPerson::class.qualifiedName
+        val shortName = GroupedPerson::class.simpleName!!
+        val nameAndCity = NameAndCity::class.qualifiedName
+        val groupedColumn = ColumnGroup::class.qualifiedName
+        val columnData = DataColumn::class.qualifiedName
+        val expected = """
+            val $columnsContainer<$className>.age: $columnData<kotlin.Int> @JvmName("${shortName}_age") get() = this["age"] as $columnData<kotlin.Int>
+            val $dataFrameRowBase<$className>.age: kotlin.Int @JvmName("${shortName}_age") get() = this["age"] as kotlin.Int
+            val $columnsContainer<$className?>.age: $columnData<kotlin.Int?> @JvmName("Nullable${shortName}_age") get() = this["age"] as $columnData<kotlin.Int?>
+            val $dataFrameRowBase<$className?>.age: kotlin.Int? @JvmName("Nullable${shortName}_age") get() = this["age"] as kotlin.Int?
+            val $columnsContainer<$className>.nameAndCity: $groupedColumn<$nameAndCity> @JvmName("${shortName}_nameAndCity") get() = this["nameAndCity"] as $groupedColumn<$nameAndCity>
+            val $dataFrameRowBase<$className>.nameAndCity: $dataFrameRow<$nameAndCity> @JvmName("${shortName}_nameAndCity") get() = this["nameAndCity"] as $dataFrameRow<$nameAndCity>
+            val $columnsContainer<$className?>.nameAndCity: $groupedColumn<$nameAndCity?> @JvmName("Nullable${shortName}_nameAndCity") get() = this["nameAndCity"] as $groupedColumn<$nameAndCity?>
+            val $dataFrameRowBase<$className?>.nameAndCity: $dataFrameRow<$nameAndCity?> @JvmName("Nullable${shortName}_nameAndCity") get() = this["nameAndCity"] as $dataFrameRow<$nameAndCity?>
+            val $columnsContainer<$className>.weight: $columnData<kotlin.Int?> @JvmName("${shortName}_weight") get() = this["weight"] as $columnData<kotlin.Int?>
+            val $dataFrameRowBase<$className>.weight: kotlin.Int? @JvmName("${shortName}_weight") get() = this["weight"] as kotlin.Int?
+            val $columnsContainer<$className?>.weight: $columnData<kotlin.Int?> @JvmName("Nullable${shortName}_weight") get() = this["weight"] as $columnData<kotlin.Int?>
+            val $dataFrameRowBase<$className?>.weight: kotlin.Int? @JvmName("Nullable${shortName}_weight") get() = this["weight"] as kotlin.Int?
+        """.trimIndent()
+        code shouldBe expected
+    }
+
+    @Test
+    fun parentColumnTest() {
+        val res = typed2.move { dfs { it.depth > 0 } }.toTop { it.parentName + "-" + it.name }
+        res.columnsCount() shouldBe 4
+        res.columnNames() shouldBe listOf("nameAndCity-name", "nameAndCity-city", "age", "weight")
+    }
+
+    @Test
+    fun `group cols`() {
+        val joined = typed2.move { allDfs() }.into { pathOf(it.path.joinToString(".")) }
+        val grouped = joined.group { nameContains(".") }.into { it.name().substringBefore(".") }
+        val expected = typed2.rename { nameAndCity.all() }.into { it.path.joinToString(".") }
+        grouped shouldBe expected
+    }
+
+    @Test
+    fun `group into column`() {
+        val grouped = typed2.group { age }.into { nameAndCity }
+        grouped.nameAndCity.columnsCount() shouldBe 3
+        grouped.columnsCount() shouldBe 2
+    }
+
+    @Test
+    fun rename() {
+        val res = typed2.rename { nameAndCity.all() }.into { it.name().capitalize() }
+        res.nameAndCity.columnNames() shouldBe typed2.nameAndCity.columnNames().map { it.capitalize() }
+    }
+
+    @Test
+    fun moveAfter() {
+        val moved = typed2.move { age }.after { nameAndCity.name }
+        moved.columnsCount() shouldBe 2
+        moved.nameAndCity.columnsCount() shouldBe 3
+        moved.nameAndCity.select { all() } shouldBe dataFrameOf(
+            typed2.nameAndCity.name,
+            typed2.age,
+            typed2.nameAndCity.city
+        )
+    }
+
+    @Test
+    fun moveAfter2() {
+        val moved = typed2.move { nameAndCity.name }.after { age }
+        moved.columnsCount() shouldBe 4
+        moved.nameAndCity.columnsCount() shouldBe 1
+        moved.remove { nameAndCity } shouldBe typed2.select { age and nameAndCity.name and weight }
+    }
+
+    @Test
+    fun splitFrameColumnsIntoRows() {
+        val grouped = typed.groupBy { city }
+        val groupCol = grouped.groups.name()
+        val plain = grouped.toDataFrame()
+        val res =
+            plain.split(grouped.groups).intoRows().remove { it[groupCol]["city"] }.ungroup(groupCol).sortBy { name and age }
+        res shouldBe typed.sortBy { name and age }.moveToLeft { city }
+    }
+
+    @Test
+    fun splitFrameColumnIntoColumns() {
+        val grouped = typed.groupBy { city }
+        val groupCol = grouped.groups.name()
+        val plain = grouped.toDataFrame()
+        val res =
+            plain.split(grouped.groups).intoRows().remove { it[groupCol]["city"] }.ungroup(groupCol).sortBy { name and age }
+        res shouldBe typed.sortBy { name and age }.moveToLeft { city }
+    }
+
+    @Test
+    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 res = plain.explode(dropEmpty = false) { groupCol }
+        val expected = plain[groupCol.name()].sumOf { Math.max((it as AnyFrame?)?.rowsCount() ?: 0, 1) }
+        res.rowsCount() shouldBe expected
+    }
+
+    @Test
+    fun `join with left path`() {
+        val joined = (typed2 - { weight }).join(typed - { city }) { nameAndCity.name.match(right.name) and age }
+        joined shouldBe typed2
+    }
+
+    @Test
+    fun `join with right path`() {
+        val joined = (typed - { city }).join(typed2 - { weight }) { name.match(right.nameAndCity.name) and age }
+        val expected = typed.moveToRight { city }.move { city }.under("nameAndCity")
+        joined shouldBe expected
+    }
+
+    @Test
+    fun `join by map column`() {
+        val nameAndAge by columnGroup()
+        val cityFirst by nameAndAge.column<Char?>()
+        val grouped = typed.group { name and age }.into(nameAndAge).add(cityFirst) { city?.get(0) }
+        grouped[nameAndAge].columnsCount() shouldBe 3
+
+        val left = grouped - { weight }
+        val right = grouped - { city }
+        val joined = left.join(right) { nameAndAge }
+        joined shouldBe grouped
+    }
+
+    @Test
+    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 } }
+        val groupCol = left.groups.toColumnAccessor()
+        val joined = left.toDataFrame().join(right.toDataFrame()) { groupCol }
+        joined.columnsCount() shouldBe 3
+        val name1 by column<String>()
+        joined.columnNames() shouldBe listOf(typed.name.name(), groupCol.name(), name1.name())
+        joined[groupCol].kind() shouldBe ColumnKind.Frame
+        joined.select { cols(0, 1) } shouldBe left.toDataFrame()
+        joined.select { cols(2, 1) }.rename(name1).into(typed.name) shouldBe right.toDataFrame()
+        joined.name shouldBe left.keys.name
+        joined.forEach { it[name1] shouldBe it.name.reversed() }
+    }
+
+    @Test
+    fun `add frame column`() {
+        val frameCol by frameColumn()
+        val added = typed2.add(frameCol) { nameAndCity.duplicate(3) }
+        added[frameCol].kind() shouldBe ColumnKind.Frame
+        added[frameCol].forEach { it.rowsCount() shouldBe 3 }
+    }
+
+    @Test
+    fun `insert column`() {
+        val colName = "reversed"
+        fun DataFrame<GroupedPerson>.check() {
+            nameAndCity.columnsCount() shouldBe 3
+            nameAndCity.columnNames() shouldBe listOf(
+                typed2.nameAndCity.name.name(),
+                colName,
+                typed2.nameAndCity.city.name()
+            )
+        }
+
+        typed2.insert(colName) { nameAndCity.name.reversed() }.after { nameAndCity.name }.check()
+    }
+
+    @Test
+    fun append() {
+        val res = typed2.append(listOf("Bill", "San Francisco"), null, 66)
+        res.rowsCount() shouldBe typed2.rowsCount() + 1
+        res.nameAndCity.last().values() shouldBe listOf("Bill", "San Francisco")
+        res.age.hasNulls() shouldBe true
+    }
+
+    @Test
+    fun `append nulls`() {
+        val res = typed2.append(null, null, null)
+        res.rowsCount() shouldBe typed2.rowsCount() + 1
+        res.nameAndCity.last().values() shouldBe listOf(null, null)
+        res.age.hasNulls() shouldBe true
+        res.nameAndCity.name.hasNulls() shouldBe true
+    }
+
+    @Test
+    fun `create data frame from map column`() {
+        val df = dataFrameOf(typed.name, typed2.nameAndCity)
+        df.rowsCount() shouldBe typed.rowsCount()
+    }
+
+    @Test
+    fun `column group properties`() {
+        typed2.nameAndCity.name() shouldBe "nameAndCity"
+        val renamed = typed2.nameAndCity.rename("newName")
+        renamed.name() shouldBe "newName"
+        renamed.select { name } shouldBe typed2.select { nameAndCity.name }
+        renamed.filter { name.startsWith("A") }.rowsCount() shouldBe typed.count { name.startsWith("A") }
+    }
+
+    @Test
+    fun `distinct at column group`() {
+        typed2.nameAndCity.distinct().filter { name.startsWith("A") }.columns() shouldBe typed.select { name and city }.distinct()
+            .filter { name.startsWith("A") }.columns()
+    }
+
+    @Test
+    fun `check column path`() {
+        typed2.getColumnPath { nameAndCity.name }.size shouldBe 2
+    }
+
+    @Test
+    fun `filter not null without arguments`() {
+        typed2.dropNulls() shouldBe typed.dropNulls { weight }.group { name and city }.into("nameAndCity")
+    }
+
+    @Test
+    fun `select group`() {
+        val groupCol = typed2[nameAndCity]
+        typed2.select { groupCol and age }.columnNames() shouldBe listOf("nameAndCity", "age")
+    }
+
+    @Test
+    fun `select columns range`() {
+        val added = typed2.move { age }.after { nameAndCity.name }
+        val expected = typed2.select { nameAndCity.name and age and nameAndCity.city }
+
+        added.select { nameAndCity.name..nameAndCity.city } shouldBe expected
+
+        shouldThrow<IllegalArgumentException> {
+            added.select { nameAndCity.name..weight }
+        }
+
+        shouldThrow<IllegalArgumentException> {
+            added.select { weight..nameAndCity.name }
+        }
+
+        added.select { nameAndCity.city..nameAndCity.name }.isEmpty() shouldBe true
+
+        added.select { nameAndCity.select { name..city } } shouldBe expected
+    }
+
+    @Test
+    fun groupByAggregateSingleColumn() {
+        val agg = typed2.groupBy { age }.aggregate { nameAndCity into "nameAndCity" }
+        agg["nameAndCity"].kind() shouldBe ColumnKind.Frame
+        typed2.groupBy { age }.aggregate { nameAndCity.asDataFrame() into "nameAndCity" } shouldBe agg
+        typed2.groupBy { age }.values { nameAndCity } shouldBe agg
+    }
+
+    @Test
+    fun `xs nested columns`() {
+        typed2.xs("Bob", "Tokyo").rowsCount() shouldBe 1
+    }
+
+    @Test
+    fun `duplicate dataframe`() {
+        typed2.duplicate(2) shouldBe columnOf(typed2, typed2)
+    }
+
+    @Test
+    fun `duplicate row`() {
+        typed2[2].duplicate(2) shouldBe typed2[2, 2]
+    }
+
+    @Test
+    fun `duplicate selected rows`() {
+        typed2.duplicateRows(2) { nameAndCity.name == "Alice" } shouldBe typed2[0, 0, 1, 2, 3, 4, 5, 5, 6]
+    }
+
+    @Test
+    fun `duplicate all rows`() {
+        typed2.duplicateRows(2) shouldBe typed2.addId("id").let {
+            it.concat(it).sortBy("id").remove("id")
+        }
+    }
+
+    @Test
+    fun `select column group`() {
+        typed2.aggregate {
+            nameAndCity()[2..3].name.distinct().single() into "name"
+        }["name"] shouldBe "Charlie"
+    }
+
+    @Test
+    fun `select frame column`() {
+        val group by frameColumn<GroupedPerson>()
+
+        typed2
+            .groupBy { expr { age > 30 } into "isOld" }.into(group)
+            .aggregate {
+                group().maxBy { rowsCount() }.weight.median() into "m"
+            }["m"] shouldBe 61
+    }
+
+    @Test
+    fun `column group as DataFrame`() {
+        val a: DataFrame<NameAndCity> = typed2["nameAndCity"].cast<DataRow<NameAndCity>>().asDataFrame()
+        val b: DataFrame<NameAndCity> = typed2[nameAndCity].cast<NameAndCity>().asDataFrame()
+    }
+}
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
new file mode 100644
index 000000000..d8ded86c8
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataRowTests.kt
@@ -0,0 +1,108 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.by
+import org.jetbrains.kotlinx.dataframe.api.columnNames
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.diff
+import org.jetbrains.kotlinx.dataframe.api.drop
+import org.jetbrains.kotlinx.dataframe.api.dropLast
+import org.jetbrains.kotlinx.dataframe.api.first
+import org.jetbrains.kotlinx.dataframe.api.intoList
+import org.jetbrains.kotlinx.dataframe.api.mapToColumn
+import org.jetbrains.kotlinx.dataframe.api.merge
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.api.namedValues
+import org.jetbrains.kotlinx.dataframe.api.namedValuesOf
+import org.jetbrains.kotlinx.dataframe.api.next
+import org.jetbrains.kotlinx.dataframe.api.prev
+import org.jetbrains.kotlinx.dataframe.api.relative
+import org.jetbrains.kotlinx.dataframe.api.rowMean
+import org.jetbrains.kotlinx.dataframe.api.rowStd
+import org.jetbrains.kotlinx.dataframe.api.rowSum
+import org.jetbrains.kotlinx.dataframe.api.toDouble
+import org.jetbrains.kotlinx.dataframe.api.transposeTo
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.api.value
+import org.jetbrains.kotlinx.dataframe.api.valuesOf
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.junit.Test
+import kotlin.math.sqrt
+
+class DataRowTests : BaseTest() {
+
+    @Test
+    fun prevNext() {
+        typed.update { age }.with { prev()?.age }.age.drop(1) shouldBe typed.age.dropLast(1)
+        typed.update { age }.with { next()?.age }.age.dropLast(1) shouldBe typed.age.drop(1)
+    }
+
+    @Test
+    fun diff() {
+        typed.update { age }.with { diff { age } }.age.drop(1).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 }
+    }
+
+    @Test
+    fun std() {
+        typed.mapToColumn("std") { rowStd(skipNA = true, ddof = 0) }.values() shouldBe typed.age.values()
+            .zip(typed.weight.values()) { a, b ->
+                if (b == null) .0
+                else {
+                    val mean = (a + b) / 2.0
+                    sqrt(((a - mean) * (a - mean) + (b - mean) * (b - mean)) / 2)
+                }
+            }
+    }
+
+    @Test
+    fun sum() {
+        typed.convert { weight }.toDouble()
+            .mapToColumn("sum") { rowSum() }.values() shouldBe typed.age.values().zip(typed.weight.values()) { a, b -> a + (b ?: 0).toDouble() }
+    }
+
+    @Test
+    fun namedValuesOf() {
+        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()
+    }
+
+    @Test
+    fun namedValuesFilter() {
+        typed.mapToColumn("vals") {
+            namedValues().firstOrNull { it.value == null }?.name
+        } shouldBe typed.mapToColumn("vals") {
+            val firstNullIndex = values().indexOfFirst { it == null }
+            if (firstNullIndex == -1) null else columnNames()[firstNullIndex]
+        }
+    }
+
+    @Test
+    fun transposeTo() {
+        val df = dataFrameOf("a", "b")(1, 2).first().transposeTo<Int>()
+        df.name.toList() shouldBe listOf("a", "b")
+        df.value.toList() shouldBe listOf(1, 2)
+    }
+
+    @Test
+    fun relativeTest() {
+        typed[1].relative(0..0) shouldBe typed[1..1]
+        typed[1].relative(-2..2) shouldBe typed[0..3]
+        typed[1].relative(listOf(2, -1, -3, 0)) shouldBe typed[3, 0, 1]
+    }
+}
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
new file mode 100644
index 000000000..74bd041bf
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/FormattingTests.kt
@@ -0,0 +1,49 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.string.shouldContain
+import org.jetbrains.kotlinx.dataframe.api.FormattingDSL
+import org.jetbrains.kotlinx.dataframe.api.FormattingDSL.gray
+import org.jetbrains.kotlinx.dataframe.api.FormattingDSL.green
+import org.jetbrains.kotlinx.dataframe.api.FormattingDSL.red
+import org.jetbrains.kotlinx.dataframe.api.and
+import org.jetbrains.kotlinx.dataframe.api.colsOf
+import org.jetbrains.kotlinx.dataframe.api.format
+import org.jetbrains.kotlinx.dataframe.api.linearBg
+import org.jetbrains.kotlinx.dataframe.api.where
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.impl.api.encode
+import org.jetbrains.kotlinx.dataframe.impl.api.linearGradient
+import org.jetbrains.kotlinx.dataframe.index
+import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.junit.Test
+
+class FormattingTests : BaseTest() {
+
+    @Test
+    fun `conditional formatting`() {
+        val formattedFrame = typed.format { colsOf<Int>() }.with {
+            if (it > 10) background(white) and bold and italic
+            else textColor(linear(it, 30.5 to red, 50 to green)) and underline
+        }
+
+        val formatter = formattedFrame.formatter!!
+        for (row in 0 until typed.nrow)
+            FormattingDSL.formatter(typed[row], typed.age)!!.attributes().size shouldBe if (typed[row].age > 10) 3 else 2
+
+        formattedFrame.toHTML(DisplayConfiguration.DEFAULT).toString() shouldContain "font-style:italic"
+    }
+
+    @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) }.formatter!!
+
+        for (row in 0 until typed.nrow step 2)
+            FormattingDSL.formatter(typed[row], typed.age)!!.attributes() shouldBe listOf("background-color" to gray.encode())
+
+        for (row in 1 until typed.nrow step 2)
+            FormattingDSL.formatter(typed[row], typed.age)!!.attributes() shouldBe listOf("background-color" to linearGradient(typed[row].age.toDouble(), 20.0, green, 80.0, red).encode())
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/HtmlRenderingTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/HtmlRenderingTests.kt
new file mode 100644
index 000000000..ff5530101
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/HtmlRenderingTests.kt
@@ -0,0 +1,43 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import io.kotest.matchers.shouldNotBe
+import io.kotest.matchers.string.shouldContain
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.group
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.parse
+import org.jetbrains.kotlinx.dataframe.io.html
+import org.jetbrains.kotlinx.dataframe.io.initHtml
+import org.jetbrains.kotlinx.dataframe.io.toHTML
+import org.jetbrains.kotlinx.jupyter.findNthSubstring
+import org.junit.Ignore
+import org.junit.Test
+import java.awt.Desktop
+import java.io.File
+
+class HtmlRenderingTests : BaseTest() {
+
+    fun AnyFrame.browse() {
+        val file = File("temp.html") // File.createTempFile("df_rendering", ".html")
+        file.writeText(toHTML(extraHtml = initHtml()).toString())
+        val uri = file.toURI()
+        val desktop = Desktop.getDesktop()
+        desktop.browse(uri)
+    }
+
+    @Ignore
+    @Test
+    fun test() {
+        typed.group { name and age }.into("temp").browse()
+    }
+
+    @Test
+    fun `render url`() {
+        val address = "http://www.google.com"
+        val df = dataFrameOf("url")(address).parse()
+        val html = df.html()
+        html shouldContain "href"
+        html.findNthSubstring(address, 2) shouldNotBe -1
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/JoinTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/JoinTests.kt
new file mode 100644
index 000000000..47fa300d4
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/JoinTests.kt
@@ -0,0 +1,121 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.addId
+import org.jetbrains.kotlinx.dataframe.api.all
+import org.jetbrains.kotlinx.dataframe.api.append
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.count
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.distinct
+import org.jetbrains.kotlinx.dataframe.api.excludeJoin
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.filterJoin
+import org.jetbrains.kotlinx.dataframe.api.fullJoin
+import org.jetbrains.kotlinx.dataframe.api.innerJoin
+import org.jetbrains.kotlinx.dataframe.api.leftJoin
+import org.jetbrains.kotlinx.dataframe.api.remove
+import org.jetbrains.kotlinx.dataframe.api.rightJoin
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.junit.Test
+
+class JoinTests : BaseTest() {
+
+    val df2 = dataFrameOf("name", "origin", "grade", "age")(
+        "Alice", "London", 3, "young",
+        "Alice", "London", 5, "old",
+        "Bob", "Tokyo", 4, "young",
+        "Bob", "Paris", 5, "old",
+        "Charlie", "Moscow", 1, "young",
+        "Charlie", "Moscow", 2, "old",
+        "Bob", "Paris", 4, null
+    )
+
+// Generated Code
+
+    @DataSchema
+    interface Person2 {
+        val name: String
+        val origin: String?
+        val grade: Int
+    }
+
+    val typed2: DataFrame<Person2> = df2.cast()
+
+    @Test
+    fun `inner join`() {
+        val res = typed.innerJoin(typed2) { name and it.city.match(right.origin) }
+        res.columnsCount() shouldBe 6
+        res.rowsCount() shouldBe 7
+        res["age1"].hasNulls() shouldBe false
+        res.count { name == "Charlie" && city == "Moscow" } shouldBe 4
+        res.select { city and name }.distinct().rowsCount() shouldBe 3
+        res[Person2::grade].hasNulls() shouldBe false
+    }
+
+    @Test
+    fun `left join`() {
+        val res = typed.leftJoin(typed2) { name and it.city.match(right.origin) }
+
+        res.columnsCount() shouldBe 6
+        res.rowsCount() shouldBe 10
+        res["age1"].hasNulls() shouldBe true
+        res.select { city and name }.distinct().rowsCount() shouldBe 6
+        res.count { it["grade"] == null } shouldBe 3
+        res.age.hasNulls() shouldBe false
+    }
+
+    @Test
+    fun `right join`() {
+        val res = typed.rightJoin(typed2) { name and it.city.match(right.origin) }
+
+        res.columnsCount() shouldBe 6
+        res.rowsCount() shouldBe 9
+        res["age1"].hasNulls() shouldBe true
+        res.select { city and name }.distinct().rowsCount() shouldBe 4
+        res[Person2::grade].hasNulls() shouldBe false
+        res.age.hasNulls() shouldBe true
+        val newEntries = res.filter { it["age"] == null }
+        newEntries.rowsCount() shouldBe 2
+        newEntries.all { name == "Bob" && city == "Paris" && weight == null } shouldBe true
+    }
+
+    @Test
+    fun `outer join`() {
+        val res = typed.fullJoin(typed2) { name and it.city.match(right.origin) }
+        println(res)
+        res.columnsCount() shouldBe 6
+        res.rowsCount() shouldBe 12
+        res.name.hasNulls() shouldBe false
+        res.columns().filter { it != res.name }.all { it.hasNulls() } shouldBe true
+        res.select { city and name }.distinct().rowsCount() shouldBe 7
+        val distinct = res.select { name and age and city and weight }.distinct()
+        val expected = typed.append("Bob", null, "Paris", null)
+        distinct shouldBe expected
+    }
+
+    @Test
+    fun `filter join`() {
+        val res = typed.filterJoin(typed2) { city.match(right.origin) }
+        val expected = typed.innerJoin(typed2.select { origin }) { city.match(right.origin) }
+        res shouldBe expected
+    }
+
+    @Test
+    fun `filter not join`() {
+        val res = typed.excludeJoin(typed2) { city.match(right.origin) }
+        res.rowsCount() shouldBe 3
+        res.city.toSet() shouldBe typed.city.toSet() - typed2.origin.toSet()
+
+        val indexColumn = column<Int>("__index__")
+        val withIndex = typed.addId(indexColumn)
+        val joined = withIndex.filterJoin(typed2) { city.match(right.origin) }
+        val joinedIndices = joined[indexColumn].toSet()
+        val expected = withIndex.filter { !joinedIndices.contains(it[indexColumn]) }.remove(indexColumn)
+
+        res shouldBe expected
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/PivotTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/PivotTests.kt
new file mode 100644
index 000000000..5dea9d318
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/PivotTests.kt
@@ -0,0 +1,514 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.Infer
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.associate
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.column
+import org.jetbrains.kotlinx.dataframe.api.columnNames
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.columnsCount
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.count
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.drop
+import org.jetbrains.kotlinx.dataframe.api.dropNulls
+import org.jetbrains.kotlinx.dataframe.api.explodeLists
+import org.jetbrains.kotlinx.dataframe.api.expr
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.first
+import org.jetbrains.kotlinx.dataframe.api.frames
+import org.jetbrains.kotlinx.dataframe.api.gather
+import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.getColumns
+import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
+import org.jetbrains.kotlinx.dataframe.api.group
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.groupByOther
+import org.jetbrains.kotlinx.dataframe.api.implode
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.isList
+import org.jetbrains.kotlinx.dataframe.api.join
+import org.jetbrains.kotlinx.dataframe.api.last
+import org.jetbrains.kotlinx.dataframe.api.map
+import org.jetbrains.kotlinx.dataframe.api.mapKeys
+import org.jetbrains.kotlinx.dataframe.api.mapValues
+import org.jetbrains.kotlinx.dataframe.api.matches
+import org.jetbrains.kotlinx.dataframe.api.named
+import org.jetbrains.kotlinx.dataframe.api.notNull
+import org.jetbrains.kotlinx.dataframe.api.pivot
+import org.jetbrains.kotlinx.dataframe.api.print
+import org.jetbrains.kotlinx.dataframe.api.remove
+import org.jetbrains.kotlinx.dataframe.api.replace
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.api.sortBy
+import org.jetbrains.kotlinx.dataframe.api.sumOf
+import org.jetbrains.kotlinx.dataframe.api.toInt
+import org.jetbrains.kotlinx.dataframe.api.ungroup
+import org.jetbrains.kotlinx.dataframe.api.update
+import org.jetbrains.kotlinx.dataframe.api.values
+import org.jetbrains.kotlinx.dataframe.api.where
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
+import org.jetbrains.kotlinx.dataframe.impl.asList
+import org.jetbrains.kotlinx.dataframe.impl.nothingType
+import org.jetbrains.kotlinx.dataframe.io.renderToString
+import org.jetbrains.kotlinx.dataframe.typeClass
+import org.junit.Test
+import java.util.AbstractSet
+import kotlin.reflect.KClass
+import kotlin.reflect.typeOf
+
+class PivotTests {
+
+    val df = dataFrameOf(
+        "name", "key", "value"
+    )(
+        "Alice", "age", 15,
+        "Alice", "city", "London",
+        "Alice", "weight", 54,
+        "Bob", "age", 45,
+        "Bob", "weight", 87,
+        "Charlie", "age", 20,
+        "Charlie", "city", "Moscow",
+        "Charlie", "weight", null,
+        "Alice", "age", 55,
+    )
+
+    val defaultExpected = dataFrameOf(
+        "name", "age", "city", "weight",
+    )(
+        "Alice", listOf(15, 55), "London", 54,
+        "Bob", listOf(45), "-", 87,
+        "Charlie", listOf(20), "Moscow", "-",
+    )
+
+// Generated Code
+
+    @DataSchema
+    interface Person {
+        val name: String
+        val key: String
+        val value: Any?
+    }
+
+    val typed: DataFrame<Person> = df.cast()
+
+    val name by column<String>()
+    val key by column<String>()
+    val value by column<Any?>()
+
+// Tests
+
+    val keyConverter: (String) -> String = { "__$it" }
+    val valueConverter: (Any?) -> Any? = { (it as? Int)?.toDouble() ?: it }
+
+    val expectedFiltered = typed.dropNulls { value }.sortBy { name and key }
+
+    @Test
+    fun `pivot matches`() {
+        val filtered = typed.drop(1)
+        val res = filtered.pivot(inward = false) { key }.groupBy { name }.matches()
+        res.columnsCount() shouldBe 1 + filtered.key.countDistinct()
+        res.rowsCount() shouldBe filtered.name.countDistinct()
+
+        val expected = filtered.rows().map { (it.name to it.key) }.toSet()
+        val actual = res.columns().subList(1, res.columnsCount()).flatMap {
+            val columnName = it.name()
+            res.rows().map {
+                val value = it[columnName] as Boolean
+                if (value) {
+                    (it.name to columnName)
+                } else null
+            }.filterNotNull()
+        }.toSet()
+
+        actual shouldBe expected
+        res["age"].type() shouldBe typeOf<Boolean>()
+        res["city"].type() shouldBe typeOf<Boolean>()
+        res["weight"].type() shouldBe typeOf<Boolean>()
+    }
+
+    @Test
+    fun `simple pivot`() {
+        val res = typed.pivot { key }.groupBy { name }.values { value default "-" }
+
+        res.columnsCount() shouldBe 2
+        res.rowsCount() shouldBe typed.name.countDistinct()
+
+        val data = res.getColumnGroup("key")
+
+        data["age"].type() shouldBe typeOf<List<Int>>()
+        data["city"].type() shouldBe typeOf<String>()
+        data["weight"].type() shouldBe typeOf<Comparable<Any>>()
+
+        res.renderToString(columnTypes = true, title = true) shouldBe
+            defaultExpected.group { drop(1) }.into("key").renderToString(columnTypes = true, title = true)
+
+        typed.pivot { key }.groupBy { name }.default("-").values { value } shouldBe res
+        typed.pivot { key }.groupBy { name }.default("-").with { value } shouldBe res
+        df.pivot { key }.groupBy { name }.default("-").values { value } shouldBe res
+        df.pivot(key).groupBy(name).default("-").values(value) shouldBe res
+        df.pivot(key).groupBy(name).default("-").with { value } shouldBe res
+        typed.groupBy { name }.pivot { key }.default("-").values { value } shouldBe res
+
+        typed.pivot { key }.groupBy { name }.default("-").with { value.toString() }
+    }
+
+    @Test
+    fun `pivot with transform`() {
+        val pivoted = typed.pivot { key.map { "_$it" } }.groupBy { name }.with { value }
+        pivoted.getColumns { "key".all() }.map { it.name() }.toSet() shouldBe typed.key.distinct().map { "_$it" }
+            .toSet()
+    }
+
+    @Test
+    fun `pivot with index transform`() {
+        val pivoted = typed.pivot { key }.groupBy { name.map { "_$it" } }.with { value }
+        pivoted.name shouldBe typed.name.distinct().map { "_$it" }
+    }
+
+    @Test
+    fun `pivot with value map`() {
+        val pivoted = typed.pivot(inward = false) { key }.groupBy { name }.values { value.map { "_$it" } }
+
+        pivoted shouldBe dataFrameOf("name", "age", "city", "weight")(
+            "Alice", listOf("_15", "_55"), "_London", "_54",
+            "Bob", listOf("_45"), null, "_87",
+            "Charlie", listOf("_20"), "_Moscow", "_null"
+        )
+    }
+
+    @Test
+    fun `pivot two values`() {
+        val pivoted = typed.pivot(inward = false) { key }.groupBy { name }
+            .values { value and (expr { value?.toString() } into "str") default "-" }
+
+        val expected = defaultExpected.replace("age", "city", "weight").with {
+            columnOf(
+                it named "value",
+                it.map(Infer.Type) {
+                    if (it is List<*>) it.map { it?.toString() }.asList()
+                    else it?.toString()
+                } named "str"
+            ) named it.name()
+        }
+
+        pivoted.renderToString(title = true, columnTypes = true) shouldBe expected.renderToString(
+            title = true,
+            columnTypes = true
+        )
+    }
+
+    @Test
+    fun `pivot two values group by value`() {
+        val type by column<KClass<*>?>()
+        val pivoted = typed.add(type) { value?.javaClass?.kotlin }
+            .pivot { key }.groupBy { name }.values(separate = true) { value and type }
+        pivoted.columnsCount() shouldBe 3
+    }
+
+    @Test
+    fun `pivot two columns with then`() {
+        val pivoted = typed
+            .add("index") { 1 }
+            .pivot(inward = false) { name then key }
+            .groupBy("index")
+            .with { value }
+
+        pivoted.columnNames() shouldBe listOf("index") + typed.name.distinct().values()
+        pivoted.rowsCount() shouldBe 1
+
+        val keys = typed.key.distinct().values()
+        pivoted.columns().drop(1).forEach {
+            val group = it.asColumnGroup()
+            group.columnNames() shouldBe if (it.name() == "Bob") keys - "city" else keys
+        }
+
+        val leafColumns = pivoted.getColumnsWithPaths { all().drop(1).allDfs() }
+        leafColumns.size shouldBe typed.name.countDistinct() * typed.key.countDistinct() - 1
+        leafColumns.forEach { it.path.size shouldBe 2 }
+
+        val data = leafColumns.associate { it.path[0] to it.path[1] to it.data[0] }
+        val expected = typed.associate { name to key to value }.toMutableMap()
+        expected["Alice" to "age"] = listOf(15, 55)
+        data shouldBe expected
+
+        val pivotedNoIndex = typed.pivot { name then key }.with { value }
+        pivotedNoIndex shouldBe pivoted.remove("index")[0]
+    }
+
+    @Test
+    fun `pivot two columns with and`() {
+        val withIndex = typed.add("index") { 1 }
+        val pivoted = withIndex.pivot { name and key }.groupBy("index").with { value }
+        pivoted shouldBe
+            withIndex.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 }
+        pivotedNoIndex shouldBe pivoted.remove("index")[0]
+    }
+
+    @Test
+    fun `pivot with two index columns`() {
+        val pivoted = typed.dropNulls { 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")
+            .implode("Int", dropNA = true)
+            .group("Int", "String").into("value")
+
+        pivoted shouldBe expected
+    }
+
+    @Test
+    fun `pivot two values without groupBy`() {
+        typed.print(columnTypes = true)
+        val pivotedRow = typed
+            .pivot { name then key }
+            .values { value and (value.map { it?.javaClass?.kotlin } into "type") }
+
+        val pivotedDf = pivotedRow.df()
+        pivotedRow.columnsCount() shouldBe typed.name.countDistinct()
+
+        val nullGroup = pivotedDf["Charlie"]["weight"].asColumnGroup()
+        nullGroup.columnNames() shouldBe listOf("value", "type")
+//        nullGroup.columnTypes() shouldBe listOf(typeOf<Comparable<*>?>(), typeOf<KClass<Any>?>())
+        nullGroup.columnTypes() shouldBe listOf(nothingType(true), nothingType(true))
+
+        val cols = pivotedDf.getColumnsWithPaths { all().allDfs() }
+        cols.size shouldBe 2 * typed.name.countDistinct() * typed.key.countDistinct() - 2
+
+        cols.forEach {
+            when {
+                it.isList() -> it.path().dropLast(1) shouldBe listOf("Alice", "age")
+                it.hasNulls() -> {
+                    it.path().dropLast(1) shouldBe listOf("Charlie", "weight")
+                }
+
+                it.name() == "type" -> it.typeClass shouldBe KClass::class
+                else -> it.name() shouldBe "value"
+            }
+        }
+        pivotedRow.getColumnGroup("Bob").getColumnGroup("weight")["value"] shouldBe 87
+    }
+
+    @Test
+    fun `pivot two values without index group by value`() {
+        val pivoted = typed.pivot { name }.values(separate = true) { key and value }
+        pivoted.df().columnNames() shouldBe listOf("key", "value")
+        (pivoted.getColumnGroup("key")["Alice"] as List<String>).size shouldBe 4
+        pivoted.df().getColumnGroup("value")["Bob"].type() shouldBe typeOf<List<Int>>()
+        pivoted.getColumnGroup("value")["Bob"] shouldBe listOf(45, 87)
+    }
+
+    @Test
+    fun `pivot in group aggregator`() {
+        val pivoted = typed.groupBy { name }.aggregate {
+            pivot { key }.with { value } into "key"
+        }
+        pivoted.columnsCount() shouldBe 2
+        pivoted.print()
+        pivoted.ungroup("key") shouldBe typed.pivot(inward = false) { key }.groupBy { name }.with { value }
+    }
+
+    @Test
+    fun `equal pivots`() {
+        val expected = typed.pivot { key }.groupBy { name }.with { value }
+        typed.groupBy { name }.pivot { key }.values { value } shouldBe expected
+        val pivoted = typed.groupBy { name }.aggregate {
+            pivot { key }.with { value }
+        }
+        pivoted.print()
+        pivoted shouldBe expected
+    }
+
+    @Test
+    fun gather() {
+        val res = typed.pivot(inward = false) { key }.groupBy { name }.with { value }
+        val gathered = res.gather { drop(1) }.notNull().into("key", "value")
+        gathered shouldBe typed.dropNulls { value }.sortBy { name and "key" }
+    }
+
+    @Test
+    fun `gather with filter`() {
+        val pivoted = typed.pivot { key }.groupBy { name }.with { value }
+        val gathered = pivoted.gather { "key".all() }.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
+    }
+
+    @Test
+    fun `grouped pivot with key and value conversions`() {
+        val grouped = typed.groupBy { name }
+
+        val pivoted = grouped.pivot(inward = false) { key.map(transform = keyConverter) }.with { valueConverter(value) }
+
+        val pivoted2 = grouped.aggregate {
+            pivot(inward = false) { key.map(transform = keyConverter) }.with { valueConverter(value) }
+        }
+
+        val pivoted3 =
+            typed.pivot(inward = false) { key.map(transform = keyConverter) }.groupBy { name }
+                .values { value.map(transform = valueConverter) }
+
+        pivoted2 shouldBe pivoted
+        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)
+        val expected = expectedFiltered.update { key }.with { keyConverter(it) }
+            .convert { value }.with { valueConverter(it) as? Comparable<*> }
+        gathered shouldBe expected
+    }
+
+    @Test
+    fun `gather with value conversion`() {
+        val pivoted = typed.pivot { key }.groupBy { name }.with { valueConverter(value) }
+        val gathered =
+            pivoted.gather { "key".all() }.explodeLists().notNull().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"] }.gather { "key".all() }.explodeLists().notNull().cast<Double>()
+            .mapValues { it.toInt() }.into("key", "value")
+        val expected = typed.filter { key != "city" && value != null }.convert { value }.toInt().sortBy { name and key }
+        gathered shouldBe expected
+    }
+
+    @Test
+    fun `gather with name conversion`() {
+        val pivoted = typed.pivot { key.map(transform = keyConverter) }.groupBy { name }.with { value }
+        val gathered = pivoted.gather { "key".all() }.notNull().mapKeys { it.substring(2) }.into("key", "value")
+        gathered shouldBe expectedFiltered
+    }
+
+    @Test
+    fun `type arguments inference in pivot with index`() {
+        val id by columnOf(1, 1, 2, 2)
+        val name by columnOf("set", "list", "set", "list")
+        val data by columnOf(setOf(1), listOf(1), setOf(2), listOf(2))
+        val df = dataFrameOf(id, name, data)
+        df[data].type() shouldBe typeOf<Collection<Int>>()
+        val pivoted = df.pivot(inward = false) { name }.groupBy { id }.values { data }
+        pivoted.rowsCount() shouldBe 2
+        pivoted.columnsCount() shouldBe 3
+        pivoted["set"].type() shouldBe typeOf<AbstractSet<Int>>()
+        pivoted["list"].type() shouldBe typeOf<List<Int>>()
+    }
+
+    @Test
+    fun `type arguments inference in pivot`() {
+        val name by columnOf("set", "list")
+        val data by columnOf(setOf(1), listOf(1))
+        val df = dataFrameOf(name, data)
+        df[data].type() shouldBe typeOf<Collection<Int>>()
+        val pivoted = df.pivot { name }.values { data }
+        pivoted.columnsCount() shouldBe 2
+        pivoted.df()["set"].type() shouldBe typeOf<AbstractSet<Int>>()
+        pivoted.df()["list"].type() shouldBe typeOf<List<Int>>()
+    }
+
+    @Test
+    fun `pivot with grouping`() {
+        val pivoted = typed.pivot(inward = true) { key }.groupBy { name }.with { value }
+        pivoted.columnNames() shouldBe listOf("name", "key")
+        pivoted["key"].asColumnGroup().columnNames() shouldBe typed.key.distinct().values()
+    }
+
+    @Test
+    fun `pivot matches yes no`() {
+        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
+    }
+
+    @Test
+    fun `pivot aggregate into`() {
+        val pivoted = typed.pivot(inward = false) { key }.groupBy { name }.aggregate {
+            value.first() into "value"
+        }
+        pivoted.columns().drop(1).forEach {
+            it.kind() shouldBe ColumnKind.Group
+            it.asColumnGroup().columnNames() shouldBe listOf("value")
+        }
+    }
+
+    @Test
+    fun `pivot aggregate several into`() {
+        val pivoted = typed.pivot { key }.groupBy { name }.aggregate {
+            value.first() into "first value"
+            value.last() into "last value"
+            "unused"
+        }
+        pivoted.getColumnGroup("key").columns().forEach {
+            it.kind() shouldBe ColumnKind.Group
+            it.asColumnGroup().columnNames() shouldBe listOf("first value", "last value")
+        }
+    }
+
+    @Test
+    fun `pivot two value columns into one name`() {
+        val type by column<KClass<*>>()
+
+        val pivoted =
+            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 {
+            val group = it.asColumnGroup()
+            group.columnNames() shouldBe listOf("data")
+            group["data"].asColumnGroup().columnNames() shouldBe listOf("value", "type")
+            group["data"]["type"].hasNulls() shouldBe false
+        }
+    }
+
+    @Test
+    fun `pivot one value without index`() {
+        val pivoted = typed.pivot { name then key }.with { value }
+        pivoted.columnNames() shouldBe typed.name.distinct().values()
+        pivoted.df()["Alice"].asColumnGroup().columnNames() shouldBe typed.key.distinct().values()
+        pivoted.df()["Bob"].asColumnGroup().columnNames() shouldBe listOf("age", "weight")
+        pivoted.df()["Charlie"].asColumnGroup().columnNames() shouldBe typed.key.distinct().values()
+        pivoted.df()["Alice"]["age"].type() shouldBe typeOf<List<Int>>()
+        pivoted.df()["Charlie"]["weight"].type() shouldBe nothingType(true)
+    }
+
+    @Test
+    fun `pivot plain`() {
+        val pivoted = typed.pivot { name }.frames()
+        pivoted.columnNames() shouldBe typed.name.distinct().toList()
+        pivoted["Bob"] shouldBe typed.filter { name == "Bob" }
+    }
+
+    @Test
+    fun `pivot columns inward`() {
+        typed.pivot(inward = true) { name }.count().columnsCount() shouldBe 1
+        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()
+            .columnsCount() shouldBe typed.name.countDistinct() + typed.key.countDistinct()
+        typed.pivot(inward = true) { name and key }.count() shouldBe typed.pivot { name and key }.count()
+    }
+
+    @Test
+    fun `pivot from group`() {
+        val pivoted = typed.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/Base.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/Base.kt
new file mode 100644
index 000000000..42fcef20f
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/Base.kt
@@ -0,0 +1,35 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person2
+
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.group
+import org.jetbrains.kotlinx.dataframe.api.into
+
+open class Base {
+    val df = dataFrameOf("firstName", "lastName", "age", "city", "weight")(
+        "Alice", "Cooper", 15, "London", 54,
+        "Bob", "Dylan", 45, "Dubai", 87,
+        "Mark", "Antony", 20, "Moscow", null,
+        "Mark", "Avrely", 40, "Milan", null,
+        "Bob", "Marley", 30, "Tokyo", 68,
+        "Alice", "Lindt", 20, null, 55,
+        "Mark", "Petrov", 30, "Moscow", 90
+    ).group("firstName", "lastName").into("name")
+        .cast<Person>()
+
+    @DataSchema
+    interface FullName {
+        val firstName: String
+        val lastName: String
+    }
+
+    @DataSchema
+    interface Person {
+        val name: DataRow<FullName>
+        val age: Int
+        val city: String?
+        val weight: Int?
+    }
+}
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
new file mode 100644
index 000000000..76c49773e
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/merge.kt
@@ -0,0 +1,20 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person2
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.by
+import org.jetbrains.kotlinx.dataframe.api.into
+import org.jetbrains.kotlinx.dataframe.api.merge
+import org.jetbrains.kotlinx.dataframe.api.remove
+import org.jetbrains.kotlinx.dataframe.api.rename
+import org.junit.Test
+
+class MergeTests : Base() {
+
+    @Test
+    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")
+            .remove { name }.rename("name2" to "name")
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/replace.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/replace.kt
new file mode 100644
index 000000000..8e34ef67c
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person2/replace.kt
@@ -0,0 +1,21 @@
+package org.jetbrains.kotlinx.dataframe.testSets.person2
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.byDesc
+import org.jetbrains.kotlinx.dataframe.api.reorder
+import org.jetbrains.kotlinx.dataframe.api.replace
+import org.jetbrains.kotlinx.dataframe.api.select
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.junit.Test
+
+class ReplaceTests : Base() {
+
+    @Test
+    fun `reorder columns in group`() {
+        val reordered = df.replace { name }.with {
+            it.asColumnGroup().select { lastName and firstName }.asColumnGroup(it.name())
+        }
+        reordered shouldBe df.reorder { name.firstName and name.lastName }.byDesc { it.name() }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/weather/SeriesTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/weather/SeriesTests.kt
new file mode 100644
index 000000000..d906cc021
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/weather/SeriesTests.kt
@@ -0,0 +1,74 @@
+package org.jetbrains.kotlinx.dataframe.testSets.weather
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.concat
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.diff
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.movingAverage
+import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.api.sortBy
+import org.junit.Test
+
+class SeriesTests {
+
+    val df = dataFrameOf("city", "day", "temp")(
+        "Moscow", 1, 14,
+        "London", 1, 10,
+        "Moscow", 3, 18,
+        "London", 3, 16,
+        "Moscow", 6, 16,
+        "London", 6, 23,
+        "Moscow", 4, 13,
+        "London", 4, 22,
+        "Moscow", 2, 20,
+        "London", 2, 15,
+        "Moscow", 5, 10,
+        "London", 5, 18
+    )
+
+    // Generated code
+
+    @DataSchema
+    interface Weather {
+        val city: String
+        val day: Int
+        val temp: Int
+    }
+
+    val typed = df.cast<Weather>()
+
+    @Test
+    fun `diff test`() {
+        val withDiff = typed
+            .sortBy { city and day }
+            .groupBy { city }
+            .add("diff") { diff { temp } ?: 0 }
+            .concat()
+
+        val srcData = typed.rows().map { (it.city to it.day) to it.temp }.toMap()
+        val expected = typed.sortBy { city and day }.rows().map { row -> srcData[row.city to (row.day - 1)]?.let { row.temp - it } ?: 0 }
+        withDiff["diff"].toList() shouldBe expected
+    }
+
+    @Test
+    fun `movingAverage`() {
+        val k = 3
+        val withMa = typed
+            .groupBy { city }
+            .sortBy { city and day }
+            .add("ma_temp") { it.movingAverage(k) { it.temp } }
+            .concat()
+
+        val srcData = typed.rows().map { (it.city to it.day) to it.temp }.toMap()
+        val expected = typed
+            .sortBy { city and day }
+            .rows()
+            .map { row -> (0 until k).map { srcData[row.city to row.day - it] }.filterNotNull().let { it.sum().toDouble() / it.size } }
+
+        withMa["ma_temp"].toList() shouldBe expected
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/types/DoubleTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/types/DoubleTests.kt
new file mode 100644
index 000000000..9c81304aa
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/types/DoubleTests.kt
@@ -0,0 +1,21 @@
+package org.jetbrains.kotlinx.dataframe.types
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.columnOf
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.isNaN
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.junit.Test
+
+class DoubleTests {
+
+    @Test
+    fun `filter not null with nans`() {
+        val age by columnOf(2.3, Double.NaN, 1.0, "asd", 3, 'a')
+        val df = dataFrameOf(age)
+        df.filter { age() == Double.NaN }.nrow shouldBe 1
+        df.filter { age().isNaN }.nrow shouldBe 1
+        df.filter { it[age].isNaN }.nrow shouldBe 1
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/types/TypeProjectionTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/types/TypeProjectionTests.kt
new file mode 100644
index 000000000..77deb59c3
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/types/TypeProjectionTests.kt
@@ -0,0 +1,58 @@
+package org.jetbrains.kotlinx.dataframe.types
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnGroupWithParent
+import org.jetbrains.kotlinx.dataframe.impl.commonType
+import org.jetbrains.kotlinx.dataframe.impl.createTypeUsing
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class TypeProjectionTests {
+    class TypeInferenceTest1 {
+        interface A<T>
+        interface X<T> : A<List<T>>
+
+        @Test
+        fun test() {
+            X::class.createTypeUsing<A<List<Int>>>() shouldBe typeOf<X<Int>>()
+            A::class.createTypeUsing<X<Int>>() shouldBe typeOf<A<List<Int>>>()
+        }
+    }
+
+    class TypeInferenceTest2 {
+        interface A<out T>
+        interface B<T> : A<A<T>>
+        interface C<T> : A<B<T>>
+        interface D<T>
+        interface X<T : Number, V : Number> : C<T>, D<V>
+
+        @Test
+        fun test() {
+            X::class.createTypeUsing<A<A<A<Int>>>>() shouldBe typeOf<X<Int, *>>()
+            A::class.createTypeUsing<X<Double, Int>?>() shouldBe typeOf<A<B<Double>>?>()
+        }
+    }
+
+    @Test
+    fun `collection to list projection`() {
+        List::class.createTypeUsing<Collection<Int>?>() shouldBe typeOf<List<Int>?>()
+        Collection::class.createTypeUsing<List<Int>>() shouldBe typeOf<Collection<Int>>()
+    }
+
+    @Test
+    fun `column group projections`() {
+        ColumnGroup::class.createTypeUsing<ColumnReference<DataRow<Int>>>() shouldBe typeOf<ColumnGroup<Int>>()
+        SingleColumn::class.createTypeUsing<ColumnGroupWithParent<Int>>() shouldBe typeOf<SingleColumn<DataRow<Int>>>()
+    }
+
+    @Test
+    fun `common type tests`() {
+        listOf(typeOf<List<Int>>(), typeOf<Set<Double?>>()).commonType() shouldBe typeOf<Collection<Number?>>()
+        listOf(typeOf<List<Int>>(), typeOf<Set<*>>()).commonType() shouldBe typeOf<Collection<Any?>>()
+        listOf(typeOf<List<Int>>(), typeOf<Set<*>?>()).commonType() shouldBe typeOf<Collection<Any?>?>()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/types/UtilTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/types/UtilTests.kt
new file mode 100644
index 000000000..b179b779f
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/types/UtilTests.kt
@@ -0,0 +1,253 @@
+package org.jetbrains.kotlinx.dataframe.types
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.impl.commonParent
+import org.jetbrains.kotlinx.dataframe.impl.commonParents
+import org.jetbrains.kotlinx.dataframe.impl.commonType
+import org.jetbrains.kotlinx.dataframe.impl.commonTypeListifyValues
+import org.jetbrains.kotlinx.dataframe.impl.createType
+import org.jetbrains.kotlinx.dataframe.impl.guessValueType
+import org.jetbrains.kotlinx.dataframe.impl.nothingType
+import org.junit.Test
+import java.io.Serializable
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+class UtilTests {
+
+    @Test
+    fun commonParentsTests() {
+        commonParents(Int::class, Int::class) shouldBe listOf(Int::class)
+        commonParents(Double::class, Int::class) shouldBe listOf(Comparable::class, Number::class)
+        commonParents(Int::class, String::class) shouldBe listOf(Comparable::class, Serializable::class)
+        commonParents(IllegalArgumentException::class, UnsupportedOperationException::class) shouldBe
+            listOf(RuntimeException::class)
+        commonParents(Nothing::class, Nothing::class) shouldBe listOf(Nothing::class)
+        commonParents() shouldBe emptyList()
+        commonParents(List::class, Set::class) shouldBe listOf(Collection::class)
+    }
+
+    @Test
+    fun commonParentTests() {
+        commonParent(Int::class, Int::class) shouldBe Int::class
+        commonParent(Double::class, Int::class) shouldBe Number::class
+        commonParent(Int::class, String::class) shouldBe Comparable::class
+        commonParent(String::class, Int::class) shouldBe Comparable::class
+        commonParent(Nothing::class, Nothing::class) shouldBe Nothing::class
+        commonParent(Int::class, Nothing::class) shouldBe Int::class
+        commonParent() shouldBe null
+        commonParent(List::class, Map::class) shouldBe Any::class
+        commonParent(List::class, Set::class) shouldBe Collection::class
+    }
+
+    @Test
+    fun `createType test`() {
+        emptyList<KClass<*>>().createType(nullable = false) shouldBe typeOf<Any>()
+        emptyList<KClass<*>>().createType(nullable = true) shouldBe typeOf<Any?>()
+
+        listOf(Nothing::class).createType(nullable = false) shouldBe nothingType(nullable = false)
+        listOf(Nothing::class).createType(nullable = true) shouldBe nothingType(nullable = true)
+    }
+
+    @Test
+    fun `commonType classes test`() {
+        emptyList<KClass<*>>().commonType(false, typeOf<List<Int>>()) shouldBe typeOf<List<Int>>()
+        emptyList<KClass<*>>().commonType(true, typeOf<List<Int>>()) shouldBe typeOf<List<Int>?>()
+
+        listOf(Nothing::class).commonType(false) shouldBe nothingType(nullable = false)
+        listOf(Nothing::class).commonType(true) shouldBe nothingType(nullable = true)
+    }
+
+    @Test
+    fun `guessValueType no listification`() {
+        guessValueType(sequenceOf(1, 2)) shouldBe typeOf<Int>()
+        guessValueType(sequenceOf(1, 2, null)) shouldBe typeOf<Int?>()
+
+        guessValueType(sequenceOf(1, 2.0)) shouldBe typeOf<Number>()
+        guessValueType(sequenceOf(1, 2.0, null)) shouldBe typeOf<Number?>()
+
+        guessValueType(sequenceOf(1, 2.0, "a")) shouldBe typeOf<Comparable<*>>()
+        guessValueType(sequenceOf(1, 2.0, "a", null)) shouldBe typeOf<Comparable<*>?>()
+
+        guessValueType(sequenceOf(1, 2.0, "a", listOf(1, 2))) shouldBe typeOf<Any>()
+        guessValueType(sequenceOf(1, 2.0, "a", null, listOf(1, 2))) shouldBe typeOf<Any?>()
+
+        guessValueType(sequenceOf(null, null)) shouldBe nothingType(nullable = true)
+
+        guessValueType(sequenceOf(listOf<Int?>(null))) shouldBe typeOf<List<Nothing?>>()
+        guessValueType(sequenceOf(emptyList<Int>())) shouldBe typeOf<List<Nothing>>()
+        guessValueType(sequenceOf(listOf<Int?>(null), emptyList<Int>())) shouldBe typeOf<List<Nothing?>>()
+        guessValueType(sequenceOf(emptyList<Int>(), null)) shouldBe typeOf<List<Nothing>?>()
+
+        guessValueType(sequenceOf(listOf(1), emptyList())) shouldBe typeOf<List<Int>>()
+        guessValueType(sequenceOf(listOf(1, null), emptyList())) shouldBe typeOf<List<Int?>>()
+        guessValueType(sequenceOf(listOf(1), listOf(null))) shouldBe typeOf<List<Int?>>()
+
+        guessValueType(sequenceOf(1, emptyList<Any?>())) shouldBe typeOf<Any>()
+
+        guessValueType(sequenceOf(1, 2, listOf(1), emptySet<Any>())) shouldBe typeOf<Any>()
+        guessValueType(sequenceOf(listOf(1), setOf(1.0, 2.0))) shouldBe typeOf<Collection<Number>>()
+    }
+
+    @Test
+    fun `guessValueType with listification`() {
+        guessValueType(sequenceOf(1, 2), listifyValues = true) shouldBe typeOf<Int>()
+        guessValueType(sequenceOf(1, 2, null), listifyValues = true) shouldBe typeOf<Int?>()
+
+        guessValueType(sequenceOf(1, 2.0), listifyValues = true) shouldBe typeOf<Number>()
+        guessValueType(sequenceOf(1, 2.0, null), listifyValues = true) shouldBe typeOf<Number?>()
+
+        guessValueType(sequenceOf(1, 2.0, "a"), listifyValues = true) shouldBe typeOf<Comparable<*>>()
+        guessValueType(sequenceOf(1, 2.0, "a", null), listifyValues = true) shouldBe typeOf<Comparable<*>?>()
+
+        guessValueType(sequenceOf(1, 2, listOf(1)), listifyValues = true) shouldBe typeOf<List<Int>>()
+        guessValueType(sequenceOf(1, 2, listOf(1), null), listifyValues = true) shouldBe typeOf<List<Int>>()
+        guessValueType(sequenceOf(1, 2, listOf(1, null)), listifyValues = true) shouldBe typeOf<List<Int?>>()
+        guessValueType(sequenceOf(1, 2, listOf(1, null), null), listifyValues = true) shouldBe typeOf<List<Int?>>()
+
+        guessValueType(sequenceOf(1, 2, listOf(null)), listifyValues = true) shouldBe typeOf<List<Int?>>()
+        guessValueType(sequenceOf(1, 2, listOf(null), null), listifyValues = true) shouldBe typeOf<List<Int?>>()
+
+        guessValueType(sequenceOf(emptyList<Int>()), listifyValues = true) shouldBe typeOf<List<Nothing>>()
+        guessValueType(sequenceOf(emptyList<Int>(), null), listifyValues = true) shouldBe typeOf<List<Nothing>>()
+        guessValueType(sequenceOf(listOf(null)), listifyValues = true) shouldBe typeOf<List<Nothing?>>()
+        guessValueType(sequenceOf(listOf(null), null), listifyValues = true) shouldBe typeOf<List<Nothing?>>()
+
+        guessValueType(
+            values = sequenceOf(1, 2, listOf(1), emptySet<Any>()),
+            listifyValues = true,
+        ) shouldBe typeOf<Any>()
+        guessValueType(
+            values = sequenceOf(1, 2, listOf(1), null, emptySet<Any>()),
+            listifyValues = true,
+        ) shouldBe typeOf<Any?>()
+        guessValueType(
+            values = sequenceOf(1, 2, listOf(1, null), emptySet<Any>()),
+            listifyValues = true,
+        ) shouldBe typeOf<Any>()
+        guessValueType(
+            values = sequenceOf(1, 2, listOf(1, null), null, emptySet<Any>()),
+            listifyValues = true,
+        ) shouldBe typeOf<Any?>()
+
+        guessValueType(
+            values = sequenceOf(1, 2, listOf(null), emptySet<Any>()),
+            listifyValues = true,
+        ) shouldBe typeOf<Any>()
+        guessValueType(
+            values = sequenceOf(1, 2, listOf(null), null, emptySet<Any>()),
+            listifyValues = true,
+        ) shouldBe typeOf<Any?>()
+
+        guessValueType(
+            values = sequenceOf(emptyList(), emptySet<Any>()),
+            listifyValues = true,
+        ) shouldBe typeOf<Collection<Nothing>>()
+        guessValueType(
+            values = sequenceOf(emptyList<Int>(), null, emptySet<Any>()),
+            listifyValues = true,
+        ) shouldBe typeOf<Collection<Nothing>?>()
+        guessValueType(
+            values = sequenceOf(listOf(null), emptySet<Any>()),
+            listifyValues = true,
+        ) shouldBe typeOf<Collection<Nothing?>>()
+        guessValueType(
+            values = sequenceOf(listOf(null), null, emptySet<Any>()),
+            listifyValues = true,
+        ) shouldBe typeOf<Collection<Nothing?>?>()
+    }
+
+    @Test
+    fun `commonType ktypes test`() {
+        listOf(typeOf<Int>(), typeOf<Int>()).commonType() shouldBe typeOf<Int>()
+        listOf(typeOf<Int>(), typeOf<Int?>()).commonType() shouldBe typeOf<Int?>()
+        listOf(typeOf<Int>(), nothingType(true)).commonType() shouldBe typeOf<Int?>()
+        listOf(typeOf<Int>(), nothingType(false)).commonType() shouldBe typeOf<Int>()
+        listOf(typeOf<List<Int>>(), typeOf<List<String>>()).commonType() shouldBe typeOf<List<Comparable<Any>>>()
+        listOf(typeOf<List<Int>>(), typeOf<Set<String>>()).commonType() shouldBe typeOf<Collection<Comparable<Any>>>()
+        listOf(typeOf<List<Nothing>>(), typeOf<Set<Nothing>>()).commonType() shouldBe typeOf<Collection<Nothing>>()
+        listOf(nothingType(false)).commonType() shouldBe nothingType(false)
+        listOf(nothingType(true)).commonType() shouldBe nothingType(true)
+        listOf<KType>().commonType() shouldBe typeOf<Any>()
+    }
+
+    @Test
+    fun `commonTypeListifyValues test`() {
+        listOf<KType>().commonTypeListifyValues() shouldBe typeOf<Any>()
+        listOf(typeOf<Int>(), typeOf<Int>()).commonTypeListifyValues() shouldBe typeOf<Int>()
+        listOf(typeOf<Int>(), typeOf<Int?>()).commonTypeListifyValues() shouldBe typeOf<Int?>()
+        listOf(typeOf<Int>(), nothingType(true)).commonTypeListifyValues() shouldBe typeOf<Int?>()
+        listOf(typeOf<Int>(), nothingType(false)).commonTypeListifyValues() shouldBe typeOf<Int>()
+        listOf(typeOf<Int>(), typeOf<Double>(), nothingType(true)).commonTypeListifyValues() shouldBe typeOf<Number?>()
+        listOf(
+            typeOf<List<Int>>(),
+            typeOf<List<String>>()
+        ).commonTypeListifyValues() shouldBe typeOf<List<out Comparable<Any>>>()
+        listOf(
+            typeOf<List<Int>>(),
+            typeOf<Set<String>>()
+        ).commonTypeListifyValues() shouldBe typeOf<Collection<Comparable<Any>>>()
+
+        listOf(
+            typeOf<Int>(),
+            typeOf<List<Int>>(),
+        ).commonTypeListifyValues() shouldBe typeOf<List<Int>>()
+
+        listOf(
+            typeOf<Int>(),
+            typeOf<List<Int>>(),
+            nothingType(true),
+        ).commonTypeListifyValues() shouldBe typeOf<List<Int>>()
+
+        listOf(
+            typeOf<Int>(),
+            typeOf<List<Int?>>(),
+            nothingType(true),
+        ).commonTypeListifyValues() shouldBe typeOf<List<Int?>>()
+
+        listOf(
+            typeOf<List<Nothing>>(),
+            typeOf<List<Nothing>>(),
+        ).commonTypeListifyValues() shouldBe typeOf<List<Nothing>>()
+
+        listOf(
+            typeOf<List<Nothing>>(),
+            nothingType(true),
+        ).commonTypeListifyValues() shouldBe typeOf<List<Nothing>>()
+
+        listOf(
+            typeOf<Int>(),
+            typeOf<List<Int>>(),
+            typeOf<Set<Any>>(),
+        ).commonTypeListifyValues() shouldBe typeOf<Any>()
+
+        listOf(
+            typeOf<Int>(),
+            typeOf<List<Int>>(),
+            typeOf<Set<Any>>(),
+            nothingType(true),
+        ).commonTypeListifyValues() shouldBe typeOf<Any?>()
+
+        listOf(
+            typeOf<List<Nothing>>(),
+            typeOf<Set<Nothing>>(),
+        ).commonTypeListifyValues() shouldBe typeOf<Collection<Nothing>>()
+
+        listOf(
+            typeOf<List<Nothing>>(),
+            typeOf<Set<Nothing>>(),
+            nothingType(true)
+        ).commonTypeListifyValues() shouldBe typeOf<Collection<Nothing>?>()
+
+        listOf(
+            typeOf<List<Nothing?>>(),
+            typeOf<Set<Nothing>>(),
+        ).commonTypeListifyValues() shouldBe typeOf<Collection<Nothing?>>()
+
+        listOf(
+            typeOf<List<Nothing?>>(),
+            typeOf<Set<Nothing>?>(),
+        ).commonTypeListifyValues() shouldBe typeOf<Collection<Nothing?>?>()
+    }
+}
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
index e508110de..64617b834 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
@@ -1,7 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.documentation
 
 import org.jetbrains.kotlinx.dataframe.documentation.AccessApi.*
-import org.jetbrains.kotlinx.dataframe.documentation.samples.ApiLevels as ApiLevelsSample
 
 /**
  * ## Access APIs
@@ -39,7 +38,7 @@ internal interface AccessApi {
      * For more information: {@include [DocumentationUrls.AccessApis.StringApi]}
      *
      * For example:
-     * @sample [ApiLevelsSample.strings]
+     * @sample [org.jetbrains.kotlinx.dataframe.samples.api.ApiLevels.strings]
      */
     interface StringApi
 
@@ -54,7 +53,7 @@ internal interface AccessApi {
      * For more information: {@include [DocumentationUrls.AccessApis.ColumnAccessorsApi]}
      *
      * For example:
-     * @sample [ApiLevelsSample.accessors3]
+     * @sample [org.jetbrains.kotlinx.dataframe.samples.api.ApiLevels.accessors3]
      */
     interface ColumnAccessorsApi
 
@@ -71,7 +70,7 @@ internal interface AccessApi {
      * For more information: {@include [DocumentationUrls.AccessApis.KPropertiesApi]}
      *
      * For example:
-     * @sample [ApiLevelsSample.kproperties1]
+     * @sample [org.jetbrains.kotlinx.dataframe.samples.api.ApiLevels.kproperties1]
      */
     interface KPropertiesApi
 
@@ -86,7 +85,7 @@ internal interface AccessApi {
      * For more information: {@include [DocumentationUrls.AccessApis.ExtensionPropertiesApi]}
      *
      * For example:
-     * @sample [ApiLevelsSample.extensionProperties1]
+     * @sample [org.jetbrains.kotlinx.dataframe.samples.api.ApiLevels.extensionProperties1]
      */
     interface ExtensionPropertiesApi
 
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/samples/ApiLevels.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/samples/ApiLevels.kt
deleted file mode 100644
index 81c553b0c..000000000
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/samples/ApiLevels.kt
+++ /dev/null
@@ -1,146 +0,0 @@
-@file:Suppress("RemoveExplicitTypeArguments")
-
-package org.jetbrains.kotlinx.dataframe.documentation.samples
-
-import org.jetbrains.kotlinx.dataframe.ColumnsContainer
-import org.jetbrains.kotlinx.dataframe.DataColumn
-import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.DataRow
-import org.jetbrains.kotlinx.dataframe.annotations.ColumnName
-import org.jetbrains.kotlinx.dataframe.api.add
-import org.jetbrains.kotlinx.dataframe.api.cast
-import org.jetbrains.kotlinx.dataframe.api.column
-import org.jetbrains.kotlinx.dataframe.api.dropNulls
-import org.jetbrains.kotlinx.dataframe.api.filter
-import org.jetbrains.kotlinx.dataframe.api.toListOf
-import org.jetbrains.kotlinx.dataframe.io.read
-
-internal interface ApiLevels {
-
-    fun strings() {
-        // SampleStart
-        DataFrame.read("titanic.csv")
-            .add("lastName") { "name"<String>().split(",").last() }
-            .dropNulls("age")
-            .filter {
-                "survived"<Boolean>() &&
-                    "home"<String>().endsWith("NY") &&
-                    "age"<Int>() in 10..20
-            }
-        // SampleEnd
-    }
-
-    fun accessors1() {
-        // SampleStart
-        val survived by column<Boolean>() // accessor for Boolean column with name 'survived'
-        val home by column<String>()
-        val age by column<Int?>()
-        val name by column<String>()
-        val lastName by column<String>()
-        // SampleEnd
-    }
-
-    fun accessors2() {
-        // SampleStart
-        val survived by column<Boolean>()
-        val home by column<String>()
-        val age by column<Int?>()
-        val name by column<String>()
-        val lastName by column<String>()
-
-        DataFrame.read("titanic.csv")
-            .add(lastName) { name().split(",").last() }
-            .dropNulls { age }
-            .filter { survived() && home().endsWith("NY") && age()!! in 10..20 }
-        // SampleEnd
-    }
-
-    fun accessors3() {
-        // SampleStart
-        val survived by column<Boolean>()
-        val home by column<String>()
-        val age by column<Int?>()
-        val name by column<String>()
-        val lastName by column<String>()
-
-        DataFrame.read("titanic.csv")
-            .add(lastName) { name().split(",").last() }
-            .dropNulls { age }
-            .filter { survived() && home().endsWith("NY") && age()!! in 10..20 }
-        // SampleEnd
-    }
-
-    fun kproperties1() {
-        // SampleStart
-        data class Passenger(
-            val survived: Boolean,
-            val home: String,
-            val age: Int,
-            val lastName: String
-        )
-
-        val passengers = DataFrame.read("titanic.csv")
-            .add(Passenger::lastName) { "name"<String>().split(",").last() }
-            .dropNulls(Passenger::age)
-            .filter {
-                it[Passenger::survived] &&
-                    it[Passenger::home].endsWith("NY") &&
-                    it[Passenger::age] in 10..20
-            }
-            .toListOf<Passenger>()
-        // SampleEnd
-    }
-
-    fun kproperties2() {
-        // SampleStart
-        data class Passenger(
-            @ColumnName("survived") val isAlive: Boolean,
-            @ColumnName("home") val city: String,
-            val name: String
-        )
-
-        val passengers = DataFrame.read("titanic.csv")
-            .filter { it.get(Passenger::city).endsWith("NY") }
-            .toListOf<Passenger>()
-        // SampleEnd
-    }
-
-    //    @DataSchema
-    interface TitanicPassenger {
-        val survived: Boolean
-        val home: String
-        val age: Int
-        val name: String
-    }
-
-    fun extensionProperties2() {
-        // SampleStart
-        val df = DataFrame.read("titanic.csv").cast<TitanicPassenger>()
-
-        df.add("lastName") { name.split(",").last() }
-            .dropNulls { age }
-            .filter { survived && home.endsWith("NY") && age in 10..20 }
-        // SampleEnd
-    }
-
-    fun extensionProperties1() {
-        val df = DataFrame.read("titanic.csv")
-    }
-}
-
-internal val ColumnsContainer<ApiLevels.TitanicPassenger>.age: DataColumn<Int> @JvmName("TitanicPassenger_age") get() = this["age"] as DataColumn<Int>
-internal val DataRow<ApiLevels.TitanicPassenger>.age: Int @JvmName("TitanicPassenger_age") get() = this["age"] as Int
-internal val ColumnsContainer<ApiLevels.TitanicPassenger?>.age: DataColumn<Int?> @JvmName("NullableTitanicPassenger_age") get() = this["age"] as DataColumn<Int?>
-internal val DataRow<ApiLevels.TitanicPassenger?>.age: Int? @JvmName("NullableTitanicPassenger_age") get() = this["age"] as Int?
-internal val ColumnsContainer<ApiLevels.TitanicPassenger>.home: DataColumn<String> @JvmName("TitanicPassenger_home") get() = this["home"] as DataColumn<String>
-internal val DataRow<ApiLevels.TitanicPassenger>.home: String @JvmName("TitanicPassenger_home") get() = this["home"] as String
-internal val ColumnsContainer<ApiLevels.TitanicPassenger?>.home: DataColumn<String?> @JvmName("NullableTitanicPassenger_home") get() = this["home"] as DataColumn<String?>
-internal val DataRow<ApiLevels.TitanicPassenger?>.home: String? @JvmName("NullableTitanicPassenger_home") get() = this["home"] as String?
-internal val ColumnsContainer<ApiLevels.TitanicPassenger>.name: DataColumn<String> @JvmName("TitanicPassenger_name") get() = this["name"] as DataColumn<String>
-internal val DataRow<ApiLevels.TitanicPassenger>.name: String @JvmName("TitanicPassenger_name") get() = this["name"] as String
-internal val ColumnsContainer<ApiLevels.TitanicPassenger?>.name: DataColumn<String?> @JvmName("NullableTitanicPassenger_name") get() = this["name"] as DataColumn<String?>
-internal val DataRow<ApiLevels.TitanicPassenger?>.name: String? @JvmName("NullableTitanicPassenger_name") get() = this["name"] as String?
-internal val ColumnsContainer<ApiLevels.TitanicPassenger>.survived: DataColumn<Boolean> @JvmName("TitanicPassenger_survived") get() = this["survived"] as DataColumn<Boolean>
-internal val DataRow<ApiLevels.TitanicPassenger>.survived: Boolean @JvmName("TitanicPassenger_survived") get() = this["survived"] as Boolean
-internal val ColumnsContainer<ApiLevels.TitanicPassenger?>.survived: DataColumn<Boolean?> @JvmName("NullableTitanicPassenger_survived") get() = this["survived"] as DataColumn<Boolean?>
-internal val DataRow<ApiLevels.TitanicPassenger?>.survived: Boolean? @JvmName("NullableTitanicPassenger_survived") get() = this["survived"] as Boolean?

From 3aa5f2278df1c3161f3c448b3bbc1cb6d523ce10 Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Mon, 27 Mar 2023 14:25:31 +0200
Subject: [PATCH 50/50] final update from master

---
 .../kotlinx/dataframe/api/toDataFrame.kt      | 78 +++++++++++++++++++
 .../dataframe/documentation/AccessApi.kt      |  2 +-
 .../kotlinx/dataframe/api/toDataFrame.kt      | 27 +++++++
 .../kotlinx/dataframe/samples/api/Create.kt   | 13 ++++
 .../dataframe/documentation/AccessApi.kt      |  2 +-
 5 files changed, 120 insertions(+), 2 deletions(-)

diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
index 89d7581a2..444661f8b 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
@@ -7,6 +7,7 @@ import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
 import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
 import org.jetbrains.kotlinx.dataframe.impl.ColumnNameGenerator
 import org.jetbrains.kotlinx.dataframe.impl.api.createDataFrameImpl
@@ -190,6 +191,83 @@ public abstract class CreateDataFrameDsl<T> : TraversePropertiesDsl {
 
 // endregion
 
+// region toDataFrame overloads for built-in types
+
+/*
+Without overloads Iterable<String>.toDataFrame produces unexpected result
+
+
+```
+val string = listOf("aaa", "aa", null)
+string.toDataFrame()
+```
+=>
+  length
+0    3
+1    2
+2 null
+ */
+
+@JvmName("toDataFrameByte")
+public inline fun <reified B : Byte?> Iterable<B>.toDataFrame(): DataFrame<ValueProperty<B>> = toDataFrame {
+    ValueProperty<B>::value from { it }
+}.cast()
+
+@JvmName("toDataFrameShort")
+public inline fun <reified S : Short?> Iterable<S>.toDataFrame(): DataFrame<ValueProperty<S>> = toDataFrame {
+    ValueProperty<S>::value from { it }
+}.cast()
+
+@JvmName("toDataFrameInt")
+public inline fun <reified I : Int?> Iterable<I>.toDataFrame(): DataFrame<ValueProperty<I>> = toDataFrame {
+    ValueProperty<I>::value from { it }
+}.cast()
+
+@JvmName("toDataFrameLong")
+public inline fun <reified L : Long?> Iterable<L>.toDataFrame(): DataFrame<ValueProperty<L>> = toDataFrame {
+    ValueProperty<L>::value from { it }
+}.cast()
+
+@JvmName("toDataFrameString")
+public inline fun <reified S : String?> Iterable<S>.toDataFrame(): DataFrame<ValueProperty<S>> = toDataFrame {
+    ValueProperty<S>::value from { it }
+}.cast()
+
+@JvmName("toDataFrameChar")
+public inline fun <reified C : Char?> Iterable<C>.toDataFrame(): DataFrame<ValueProperty<C>> = toDataFrame {
+    ValueProperty<C>::value from { it }
+}.cast()
+
+@JvmName("toDataFrameBoolean")
+public inline fun <reified B : Boolean?> Iterable<B>.toDataFrame(): DataFrame<ValueProperty<B>> = toDataFrame {
+    ValueProperty<B>::value from { it }
+}.cast()
+
+@JvmName("toDataFrameUByte")
+public inline fun <reified U : UByte?> Iterable<U>.toDataFrame(): DataFrame<ValueProperty<U>> = toDataFrame {
+    ValueProperty<U>::value from { it }
+}.cast()
+
+@JvmName("toDataFrameUShort")
+public inline fun <reified U : UShort?> Iterable<U>.toDataFrame(): DataFrame<ValueProperty<U>> = toDataFrame {
+    ValueProperty<U>::value from { it }
+}.cast()
+
+@JvmName("toDataFrameUInt")
+public inline fun <reified U : UInt?> Iterable<U>.toDataFrame(): DataFrame<ValueProperty<U>> = toDataFrame {
+    ValueProperty<U>::value from { it }
+}.cast()
+
+@JvmName("toDataFrameULong")
+public inline fun <reified U : ULong?> Iterable<U>.toDataFrame(): DataFrame<ValueProperty<U>> = toDataFrame {
+    ValueProperty<U>::value from { it }
+}.cast()
+
+@DataSchema
+public interface ValueProperty<T> {
+    public val value: T
+}
+
 // region Create DataFrame from Map
 
 public fun Map<String, Iterable<Any?>>.toDataFrame(): AnyFrame {
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
index 69db29b08..a92955347 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
@@ -132,4 +132,4 @@ internal interface AccessApi {
 }
 
 /** [Access API][AccessApi] */
-public const val AccessApiLink: Int = 0
+internal interface AccessApiLink
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
index 632355356..5861975a9 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
@@ -3,10 +3,12 @@ package org.jetbrains.kotlinx.dataframe.api
 import io.kotest.matchers.shouldBe
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.alsoDebug
 import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
 import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
 import org.jetbrains.kotlinx.dataframe.kind
 import org.jetbrains.kotlinx.dataframe.type
+import org.junit.Ignore
 import org.junit.Test
 import kotlin.reflect.typeOf
 
@@ -197,4 +199,29 @@ class CreateDataFrameTests {
 
         df["name"][0] shouldBe name
     }
+
+    @Test
+    fun builtInTypes() {
+        val string = listOf("aaa", "aa", null)
+        string.toDataFrame().also { it.print() } shouldBe dataFrameOf("value")(*string.toTypedArray())
+
+        val int = listOf(1, 2, 3)
+        int.toDataFrame().alsoDebug() shouldBe dataFrameOf("value")(*int.toTypedArray())
+    }
+
+    @Ignore
+    @Test
+    fun generateBuiltInsOverrides() {
+        listOf("Byte", "Short", "Int", "Long", "String", "Char", "Boolean", "UByte", "UShort", "UInt", "ULong").forEach { type ->
+            val typeParameter = type.first()
+            val func = """
+            @JvmName("toDataFrame$type")
+            public inline fun <reified $typeParameter : $type?> Iterable<$typeParameter>.toDataFrame(): DataFrame<ValueProperty<$typeParameter>> = toDataFrame {
+                ValueProperty<$typeParameter>::value from { it }
+            }.cast()
+            """.trimIndent()
+            println(func)
+            println()
+        }
+    }
 }
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Create.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Create.kt
index a6168fe98..347baccd5 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Create.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Create.kt
@@ -1,7 +1,9 @@
 package org.jetbrains.kotlinx.dataframe.samples.api
 
 import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.api.Infer
+import org.jetbrains.kotlinx.dataframe.api.ValueProperty
 import org.jetbrains.kotlinx.dataframe.api.add
 import org.jetbrains.kotlinx.dataframe.api.column
 import org.jetbrains.kotlinx.dataframe.api.columnGroup
@@ -18,6 +20,7 @@ import org.jetbrains.kotlinx.dataframe.api.sortBy
 import org.jetbrains.kotlinx.dataframe.api.toColumn
 import org.jetbrains.kotlinx.dataframe.api.toColumnOf
 import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.api.value
 import org.jetbrains.kotlinx.dataframe.api.withValues
 import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
 import org.jetbrains.kotlinx.dataframe.kind
@@ -314,6 +317,16 @@ class Create : TestBase() {
         df["age"].type() shouldBe typeOf<Int>()
     }
 
+    @Test
+    fun readDataFrameFromValues() {
+        // SampleStart
+        val names = listOf("Alice", "Bob", "Charlie")
+        val df: DataFrame<ValueProperty<String>> = names.toDataFrame()
+        df.add("length") { value.length }
+        // SampleEnd
+        df.value.toList() shouldBe names
+    }
+
     @Test
     fun readDataFrameFromObject() {
         // SampleStart
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
index 64617b834..032a10cf1 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt
@@ -94,4 +94,4 @@ internal interface AccessApi {
 }
 
 /** [Access API][AccessApi] */
-public const val AccessApiLink: Int = 0
+internal interface AccessApiLink