From 0ae5b3161437b58d37bbe4d1589a678a5092b4cd Mon Sep 17 00:00:00 2001
From: Jolan Rensen <jolan.rensen@jetbrains.com>
Date: Mon, 8 Sep 2025 20:33:50 +0200
Subject: [PATCH 01/16] apply DefinitelyNotNullable patch for notebooks only:
 #1116

---
 .../jetbrains/kotlinx/dataframe/api/max.kt    | 211 +++++++++---------
 .../jetbrains/kotlinx/dataframe/api/median.kt | 148 ++++++------
 .../jetbrains/kotlinx/dataframe/api/min.kt    | 203 ++++++++---------
 .../kotlinx/dataframe/api/percentile.kt       | 156 +++++++------
 4 files changed, 350 insertions(+), 368 deletions(-)

diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt
index d1ff0cd1e2..f4ae1ce7db 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt
@@ -13,6 +13,7 @@ import org.jetbrains.kotlinx.dataframe.annotations.Refine
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 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.intraComparableColumns
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateByOrNull
@@ -35,25 +36,25 @@ public fun <T : Comparable<T>> DataColumn<T?>.max(skipNaN: Boolean = skipNaNDefa
 public fun <T : Comparable<T>> DataColumn<T?>.maxOrNull(skipNaN: Boolean = skipNaNDefault): T? =
     Aggregators.max<T>(skipNaN).aggregateSingleColumn(this)
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxBy(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T & Any = maxByOrNull(skipNaN, selector).suggestIfNull("maxBy")
+): T = maxByOrNull(skipNaN, selector).suggestIfNull("maxBy")
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxByOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T? = Aggregators.max<R>(skipNaN).aggregateByOrNull(this, selector)
+): T? = Aggregators.max.invoke(skipNaN).cast<R>().aggregateByOrNull(this, selector)
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxOf(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): R & Any = maxOfOrNull(skipNaN, selector).suggestIfNull("maxOf")
+): R = maxOfOrNull(skipNaN, selector).suggestIfNull("maxOf")
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxOfOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): R? = Aggregators.max<R>(skipNaN).aggregateOf(this, selector)
+): R? = Aggregators.max.invoke(skipNaN).cast<R>().aggregateOf(this, selector)
 
 // endregion
 
@@ -103,61 +104,61 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.maxFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = maxFor(skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(
+public fun <T, C : Comparable<*>?> DataFrame<T>.max(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): C & Any = maxOrNull(skipNaN, columns).suggestIfNull("max")
+): C = maxOrNull(skipNaN, columns).suggestIfNull("max")
 
 public fun <T> DataFrame<T>.max(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Comparable<Any> =
     maxOrNull(*columns, skipNaN = skipNaN).suggestIfNull("max")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(
+public fun <T, C : Comparable<*>?> DataFrame<T>.max(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): C & Any = maxOrNull(*columns, skipNaN = skipNaN).suggestIfNull("max")
+): C = maxOrNull(*columns, skipNaN = skipNaN).suggestIfNull("max")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(
+public fun <T, C : Comparable<*>?> DataFrame<T>.max(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
-): C & Any = maxOrNull(*columns, skipNaN = skipNaN).suggestIfNull("max")
+): C = maxOrNull(*columns, skipNaN = skipNaN).suggestIfNull("max")
 
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): C? = Aggregators.max<C>(skipNaN).aggregateAll(this, columns)
+): C? = Aggregators.max.invoke(skipNaN).cast<C>().aggregateAll(this, columns)
 
 public fun <T> DataFrame<T>.maxOrNull(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Comparable<Any>? =
     maxOrNull(skipNaN) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): C? = maxOrNull(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): C? = maxOrNull(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxOf(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): C & Any = maxOfOrNull(skipNaN, expression).suggestIfNull("maxOf")
+): C = maxOfOrNull(skipNaN, expression).suggestIfNull("maxOf")
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxOfOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): C? = Aggregators.max<C>(skipNaN).aggregateOf(this, expression)
+): C? = Aggregators.max.invoke(skipNaN).cast<C>().aggregateOf(this, expression)
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T> = maxByOrNull(skipNaN, expression).suggestIfNull("maxBy")
@@ -167,36 +168,36 @@ public fun <T> DataFrame<T>.maxBy(column: String, skipNaN: Boolean = skipNaNDefa
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = maxByOrNull(column, skipNaN).suggestIfNull("maxBy")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = maxByOrNull(column, skipNaN).suggestIfNull("maxBy")
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataRow<T>? = Aggregators.max<C>(skipNaN).aggregateByOrNull(this, expression)
+): DataRow<T>? = Aggregators.max.invoke(skipNaN).cast<C>().aggregateByOrNull(this, expression)
 
 public fun <T> DataFrame<T>.maxByOrNull(column: String, skipNaN: Boolean = skipNaNDefault): DataRow<T>? =
     maxByOrNull(column.toColumnOf<Comparable<Any>?>(), skipNaN)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): DataRow<T>? = Aggregators.max<C>(skipNaN).aggregateByOrNull(this, column)
+): DataRow<T>? = Aggregators.max.invoke(skipNaN).cast<C>().aggregateByOrNull(this, column)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T>? = maxByOrNull(column.toColumnAccessor(), skipNaN)
@@ -240,7 +241,7 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C?>,
-): DataFrame<T> = Aggregators.max<C>(skipNaN).aggregateAll(this, name, columns)
+): DataFrame<T> = Aggregators.max.invoke(skipNaN).cast<C>().aggregateAll(this, name, columns)
 
 public fun <T> Grouped<T>.max(
     vararg columns: String,
@@ -250,7 +251,7 @@ public fun <T> Grouped<T>.max(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
+public fun <T, C : Comparable<*>?> Grouped<T>.max(
     vararg columns: ColumnReference<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -258,7 +259,7 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
+public fun <T, C : Comparable<*>?> Grouped<T>.max(
     vararg columns: KProperty<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -266,21 +267,21 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
 
 @Refine
 @Interpretable("GroupByMaxOf")
-public inline fun <T, reified C : Comparable<C & Any>?> Grouped<T>.maxOf(
+public inline fun <T, reified C : Comparable<*>?> Grouped<T>.maxOf(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataFrame<T> = Aggregators.max<C>(skipNaN).aggregateOf(this, name, expression)
+): DataFrame<T> = Aggregators.max.invoke(skipNaN).cast<C>().aggregateOf(this, name, expression)
 
 @Interpretable("GroupByReduceExpression")
-public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.maxBy(
+public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.maxBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<G, R>,
 ): ReducedGroupBy<T, G> = reduce { maxByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.maxBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.maxBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = reduce { maxByOrNull(column, skipNaN) }
@@ -290,7 +291,7 @@ public fun <T, G> GroupBy<T, G>.maxBy(column: String, skipNaN: Boolean = skipNaN
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.maxBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.maxBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = maxBy(column.toColumnAccessor(), skipNaN)
@@ -330,41 +331,43 @@ public fun <T, R : Comparable<*>?> Pivot<T>.maxFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = maxFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(
+public fun <T, R : Comparable<*>?> Pivot<T>.max(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, R>,
-): DataRow<T> = delegate { max(skipNaN, columns) }
+): DataRow<T> = delegate { maxFor(separate = false, skipNaN, columns) }
 
-public fun <T> Pivot<T>.max(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataRow<T> =
-    max(skipNaN) { columns.toComparableColumns() }
+public fun <T, R : Comparable<*>?> Pivot<T>.max(
+    vararg columns: String,
+    skipNaN: Boolean = skipNaNDefault,
+): DataRow<T> = max(skipNaN) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(
+public fun <T, R : Comparable<*>?> Pivot<T>.max(
     vararg columns: ColumnReference<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = max(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(
+public fun <T, R : Comparable<*>?> Pivot<T>.max(
     vararg columns: KProperty<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = max(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.maxOf(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.maxOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): DataRow<T> = delegate { maxOf(skipNaN, rowExpression) }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.maxBy(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.maxBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivot<T> = reduce { maxByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.maxBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = reduce { maxByOrNull(column, skipNaN) }
@@ -374,7 +377,7 @@ public fun <T> Pivot<T>.maxBy(column: String, skipNaN: Boolean = skipNaNDefault)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.maxBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = maxBy(column.toColumnAccessor(), skipNaN)
@@ -414,39 +417,39 @@ public fun <T, R : Comparable<*>?> PivotGroupBy<T>.maxFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = maxFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, R>,
-): DataFrame<T> = Aggregators.max<R>(skipNaN).aggregateAll(this, columns)
+): DataFrame<T> = Aggregators.max.invoke(skipNaN).cast<R>().aggregateAll(this, columns)
 
 public fun <T> PivotGroupBy<T>.max(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T> =
     max(skipNaN) { columns.toComparableColumns() }
 
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(
     vararg columns: ColumnReference<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = max(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(
     vararg columns: KProperty<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = max(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.maxOf(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.maxOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): DataFrame<T> = aggregate { maxOf(skipNaN, rowExpression) }
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.maxBy(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.maxBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivotGroupBy<T> = reduce { maxByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.maxBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = reduce { maxByOrNull(column, skipNaN) }
@@ -456,7 +459,7 @@ public fun <T> PivotGroupBy<T>.maxBy(column: String, skipNaN: Boolean = skipNaND
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.maxBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = maxBy(column.toColumnAccessor(), skipNaN)
@@ -473,26 +476,26 @@ public fun <T : Comparable<T>> DataColumn<T?>.max(): T = max(skipNaN = skipNaNDe
 public fun <T : Comparable<T>> DataColumn<T?>.maxOrNull(): T? = maxOrNull(skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxBy(noinline selector: (T) -> R): T & Any =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxBy(noinline selector: (T) -> R): T =
     maxBy(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxByOrNull(noinline selector: (T) -> R): T? =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxByOrNull(noinline selector: (T) -> R): T? =
     maxByOrNull(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxOf(crossinline selector: (T) -> R): R & Any =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxOf(crossinline selector: (T) -> R): R =
     maxOf(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxOfOrNull(crossinline selector: (T) -> R): R? =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxOfOrNull(crossinline selector: (T) -> R): R? =
     maxOfOrNull(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public inline fun <reified T : Comparable<T>> AnyRow.rowMaxOfOrNull(): T? = rowMaxOfOrNull<T>(skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <reified T : Comparable<T & Any>?> AnyRow.rowMaxOf(): T & Any = rowMaxOf(skipNaN = skipNaNDefault)
+public inline fun <reified T : Comparable<T>> AnyRow.rowMaxOf(): T = rowMaxOf(skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public fun <T> DataFrame<T>.max(): DataRow<T> = max(skipNaN = skipNaNDefault)
@@ -516,7 +519,7 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.maxFor(vararg columns: KProperty
     maxFor(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(columns: ColumnsSelector<T, C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.max(columns: ColumnsSelector<T, C>): C =
     max(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -525,16 +528,16 @@ public fun <T> DataFrame<T>.max(vararg columns: String): Comparable<Any> =
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(vararg columns: ColumnReference<C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.max(vararg columns: ColumnReference<C>): C =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(vararg columns: KProperty<C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.max(vararg columns: KProperty<C>): C =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(columns: ColumnsSelector<T, C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(columns: ColumnsSelector<T, C>): C? =
     maxOrNull(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -543,26 +546,25 @@ public fun <T> DataFrame<T>.maxOrNull(vararg columns: String): Comparable<Any>?
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(vararg columns: ColumnReference<C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(vararg columns: ColumnReference<C>): C? =
     maxOrNull(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(vararg columns: KProperty<C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(vararg columns: KProperty<C>): C? =
     maxOrNull(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxOf(
-    crossinline expression: RowExpression<T, C>,
-): C & Any = maxOf(skipNaN = skipNaNDefault, expression = expression)
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxOf(crossinline expression: RowExpression<T, C>): C =
+    maxOf(skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxOfOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxOfOrNull(
     crossinline expression: RowExpression<T, C>,
 ): C? = maxOfOrNull(skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T> = maxBy(skipNaN = skipNaNDefault, expression = expression)
 
@@ -571,16 +573,16 @@ public fun <T> DataFrame<T>.maxBy(column: String): DataRow<T> = maxBy(column, sk
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(column: ColumnReference<C>): DataRow<T> =
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(column: ColumnReference<C>): DataRow<T> =
     maxBy(column, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(column: KProperty<C>): DataRow<T> =
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(column: KProperty<C>): DataRow<T> =
     maxBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T>? = maxByOrNull(skipNaN = skipNaNDefault, expression = expression)
 
@@ -589,13 +591,12 @@ public fun <T> DataFrame<T>.maxByOrNull(column: String): DataRow<T>? = maxByOrNu
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(
-    column: ColumnReference<C>,
-): DataRow<T>? = maxByOrNull(column, skipNaN = skipNaNDefault)
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(column: ColumnReference<C>): DataRow<T>? =
+    maxByOrNull(column, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(column: KProperty<C>): DataRow<T>? =
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(column: KProperty<C>): DataRow<T>? =
     maxByOrNull(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -620,7 +621,7 @@ public fun <T, C : Comparable<*>?> Grouped<T>.maxFor(vararg columns: KProperty<C
     maxFor(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
+public fun <T, C : Comparable<*>?> Grouped<T>.max(
     name: String? = null,
     columns: ColumnsSelector<T, C?>,
 ): DataFrame<T> = max(name, skipNaN = skipNaNDefault, columns = columns)
@@ -631,32 +632,30 @@ public fun <T> Grouped<T>.max(vararg columns: String, name: String? = null): Dat
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
+public fun <T, C : Comparable<*>?> Grouped<T>.max(
     vararg columns: ColumnReference<C>,
     name: String? = null,
 ): DataFrame<T> = max(columns = columns, name = name, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
-    vararg columns: KProperty<C>,
-    name: String? = null,
-): DataFrame<T> = max(columns = columns, name = name, skipNaN = skipNaNDefault)
+public fun <T, C : Comparable<*>?> Grouped<T>.max(vararg columns: KProperty<C>, name: String? = null): DataFrame<T> =
+    max(columns = columns, name = name, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> Grouped<T>.maxOf(
+public inline fun <T, reified C : Comparable<*>?> Grouped<T>.maxOf(
     name: String? = null,
     crossinline expression: RowExpression<T, C>,
 ): DataFrame<T> = maxOf(name, skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.maxBy(
+public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.maxBy(
     crossinline rowExpression: RowExpression<G, R>,
 ): ReducedGroupBy<T, G> = maxBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.maxBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.maxBy(
     column: ColumnReference<C>,
 ): ReducedGroupBy<T, G> = maxBy(column, skipNaN = skipNaNDefault)
 
@@ -665,9 +664,8 @@ public fun <T, G> GroupBy<T, G>.maxBy(column: String): ReducedGroupBy<T, G> = ma
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.maxBy(
-    column: KProperty<C>,
-): ReducedGroupBy<T, G> = maxBy(column, skipNaN = skipNaNDefault)
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.maxBy(column: KProperty<C>): ReducedGroupBy<T, G> =
+    maxBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public fun <T> Pivot<T>.max(separate: Boolean = false): DataRow<T> = max(separate, skipNaN = skipNaNDefault)
@@ -697,32 +695,32 @@ public fun <T, R : Comparable<*>?> Pivot<T>.maxFor(
 ): DataRow<T> = maxFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(columns: ColumnsSelector<T, R>): DataRow<T> =
+public fun <T, R : Comparable<*>?> Pivot<T>.max(columns: ColumnsSelector<T, R>): DataRow<T> =
     max(skipNaN = skipNaNDefault, columns = columns)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(vararg columns: ColumnReference<R>): DataRow<T> =
+public fun <T, R : Comparable<*>?> Pivot<T>.max(vararg columns: ColumnReference<R>): DataRow<T> =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(vararg columns: KProperty<R>): DataRow<T> =
+public fun <T, R : Comparable<*>?> Pivot<T>.max(vararg columns: KProperty<R>): DataRow<T> =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.maxOf(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.maxOf(
     crossinline rowExpression: RowExpression<T, R>,
 ): DataRow<T> = maxOf(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.maxBy(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.maxBy(
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivot<T> = maxBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.maxBy(column: ColumnReference<C>): ReducedPivot<T> =
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.maxBy(column: ColumnReference<C>): ReducedPivot<T> =
     maxBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -730,7 +728,7 @@ public fun <T> Pivot<T>.maxBy(column: String): ReducedPivot<T> = maxBy(column, s
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.maxBy(column: KProperty<C>): ReducedPivot<T> =
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.maxBy(column: KProperty<C>): ReducedPivot<T> =
     maxBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -761,7 +759,7 @@ public fun <T, R : Comparable<*>?> PivotGroupBy<T>.maxFor(
 ): DataFrame<T> = maxFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(columns: ColumnsSelector<T, R>): DataFrame<T> =
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(columns: ColumnsSelector<T, R>): DataFrame<T> =
     max(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -769,27 +767,27 @@ public fun <T> PivotGroupBy<T>.max(vararg columns: String): DataFrame<T> =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(vararg columns: ColumnReference<R>): DataFrame<T> =
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(vararg columns: ColumnReference<R>): DataFrame<T> =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(vararg columns: KProperty<R>): DataFrame<T> =
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(vararg columns: KProperty<R>): DataFrame<T> =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.maxOf(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.maxOf(
     crossinline rowExpression: RowExpression<T, R>,
 ): DataFrame<T> = maxOf(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.maxBy(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.maxBy(
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivotGroupBy<T> = maxBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.maxBy(
     column: ColumnReference<C>,
 ): ReducedPivotGroupBy<T> = maxBy(column, skipNaN = skipNaNDefault)
 
@@ -798,8 +796,7 @@ public fun <T> PivotGroupBy<T>.maxBy(column: String): ReducedPivotGroupBy<T> = m
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.maxBy(
-    column: KProperty<C>,
-): ReducedPivotGroupBy<T> = maxBy(column, skipNaN = skipNaNDefault)
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.maxBy(column: KProperty<C>): ReducedPivotGroupBy<T> =
+    maxBy(column, skipNaN = skipNaNDefault)
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt
index 576a17ea18..e790dece4d 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt
@@ -15,6 +15,8 @@ import org.jetbrains.kotlinx.dataframe.annotations.Refine
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 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.aggregators.cast2
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.intraComparableColumns
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateByOrNull
@@ -47,61 +49,58 @@ import kotlin.reflect.KProperty
 
 // region DataColumn
 
-public fun <T : Comparable<T & Any>?> DataColumn<T>.median(): T & Any = medianOrNull().suggestIfNull("median")
+public fun <T : Comparable<*>?> DataColumn<T>.median(): T = medianOrNull().suggestIfNull("median")
 
-public fun <T : Comparable<T & Any>?> DataColumn<T>.medianOrNull(): T? =
-    Aggregators.medianComparables<T>().aggregateSingleColumn(this)
+public fun <T : Comparable<*>?> DataColumn<T>.medianOrNull(): T? =
+    Aggregators.median(skipNaNDefault).cast<T>().aggregateSingleColumn(this)
 
 public fun <T> DataColumn<T>.median(
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where T : Comparable<T & Any>?, T : Number? = medianOrNull(skipNaN = skipNaN).suggestIfNull("median")
+    where T : Comparable<*>?, T : Number? = medianOrNull(skipNaN = skipNaN).suggestIfNull("median")
 
 public fun <T> DataColumn<T>.medianOrNull(
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where T : Comparable<T & Any>?, T : Number? =
-    Aggregators.medianNumbers<T>(skipNaN).aggregateSingleColumn(this)
+    where T : Comparable<*>?, T : Number? =
+    Aggregators.median(skipNaN).cast2<T & Any, Double?>().aggregateSingleColumn(this)
 
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.medianBy(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.medianBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T & Any = medianByOrNull(skipNaN, selector).suggestIfNull("medianBy")
+): T = medianByOrNull(skipNaN, selector).suggestIfNull("medianBy")
 
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.medianByOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.medianByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T? = Aggregators.medianCommon<R>(skipNaN).aggregateByOrNull(this, selector)
+): T? = Aggregators.median(skipNaN).cast<R>().aggregateByOrNull(this, selector)
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.medianOf(
-    crossinline expression: (T) -> R,
-): R & Any = medianOfOrNull(expression).suggestIfNull("medianOf")
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.medianOf(crossinline expression: (T) -> R): R =
+    medianOfOrNull(expression).suggestIfNull("medianOf")
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.medianOfOrNull(
-    crossinline expression: (T) -> R,
-): R? = Aggregators.medianComparables<R>().aggregateOf(this, expression)
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.medianOfOrNull(crossinline expression: (T) -> R): R? =
+    Aggregators.median(skipNaNDefault).cast<R>().aggregateOf(this, expression)
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataColumn<T>.medianOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: (T) -> R,
 ): Double
-    where R : Comparable<R & Any>?, R : Number? =
-    medianOfOrNull(skipNaN, expression).suggestIfNull("medianOf")
+    where R : Comparable<*>?, R : Number? = medianOfOrNull(skipNaN, expression).suggestIfNull("medianOf")
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataColumn<T>.medianOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: (T) -> R,
 ): Double?
-    where R : Comparable<R & Any>?, R : Number? =
-    Aggregators.medianNumbers<R>(skipNaN).aggregateOf(this, expression)
+    where R : Comparable<*>?, R : Number? =
+    Aggregators.median(skipNaN).cast2<R & Any, Double?>().aggregateOf(this, expression)
 
 // endregion
 
@@ -164,21 +163,21 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.medianFor(
 
 // TODO, requires explicit type C due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.median(columns: ColumnsSelector<T, C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.median(columns: ColumnsSelector<T, C>): C =
     medianOrNull(columns).suggestIfNull("median")
 
 // TODO, requires explicit type C due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
 @Suppress("UNCHECKED_CAST")
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.medianOrNull(columns: ColumnsSelector<T, C>): C? =
-    Aggregators.medianComparables<C>().aggregateAll(this, columns)
+public fun <T, C : Comparable<*>?> DataFrame<T>.medianOrNull(columns: ColumnsSelector<T, C>): C? =
+    Aggregators.median(skipNaNDefault).cast<C>().aggregateAll(this, columns)
 
 @OverloadResolutionByLambdaReturnType
 public fun <T, C> DataFrame<T>.median(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
 ): Double
-    where C : Number?, C : Comparable<C & Any>? = medianOrNull(skipNaN, columns).suggestIfNull("median")
+    where C : Number?, C : Comparable<*>? = medianOrNull(skipNaN, columns).suggestIfNull("median")
 
 @OverloadResolutionByLambdaReturnType
 @Suppress("UNCHECKED_CAST")
@@ -186,8 +185,8 @@ public fun <T, C> DataFrame<T>.medianOrNull(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
 ): Double?
-    where C : Comparable<C & Any>?, C : Number? =
-    Aggregators.medianNumbers<C>(skipNaN).aggregateAll(this, columns)
+    where C : Comparable<*>?, C : Number? =
+    Aggregators.median(skipNaN).cast2<C & Any, Double?>().aggregateAll(this, columns)
 
 public fun <T> DataFrame<T>.median(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Any =
     medianOrNull(*columns, skipNaN = skipNaN).suggestIfNull("median")
@@ -197,12 +196,12 @@ public fun <T> DataFrame<T>.medianOrNull(vararg columns: String, skipNaN: Boolea
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.median(vararg columns: ColumnReference<C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.median(vararg columns: ColumnReference<C>): C =
     medianOrNull(*columns).suggestIfNull("median")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.medianOrNull(vararg columns: ColumnReference<C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.medianOrNull(vararg columns: ColumnReference<C>): C? =
     medianOrNull<T, C> { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
@@ -211,8 +210,7 @@ public fun <T, C> DataFrame<T>.median(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where C : Comparable<C & Any>?, C : Number? =
-    medianOrNull(*columns, skipNaN = skipNaN).suggestIfNull("median")
+    where C : Comparable<*>?, C : Number? = medianOrNull(*columns, skipNaN = skipNaN).suggestIfNull("median")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
@@ -220,16 +218,16 @@ public fun <T, C> DataFrame<T>.medianOrNull(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where C : Comparable<C & Any>?, C : Number? = medianOrNull(skipNaN) { columns.toColumnSet() }
+    where C : Comparable<*>?, C : Number? = medianOrNull(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.median(vararg columns: KProperty<C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.median(vararg columns: KProperty<C>): C =
     medianOrNull(*columns).suggestIfNull("median")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.medianOrNull(vararg columns: KProperty<C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.medianOrNull(vararg columns: KProperty<C>): C? =
     medianOrNull<T, C> { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
@@ -238,8 +236,7 @@ public fun <T, C> DataFrame<T>.median(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where C : Comparable<C & Any>?, C : Number? =
-    medianOrNull(*columns, skipNaN = skipNaN).suggestIfNull("median")
+    where C : Comparable<*>?, C : Number? = medianOrNull(*columns, skipNaN = skipNaN).suggestIfNull("median")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
@@ -247,37 +244,36 @@ public fun <T, C> DataFrame<T>.medianOrNull(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where C : Comparable<C & Any>?, C : Number? = medianOrNull(skipNaN) { columns.toColumnSet() }
+    where C : Comparable<*>?, C : Number? = medianOrNull(skipNaN) { columns.toColumnSet() }
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataFrame<T>.medianOf(
+public inline fun <T, reified R : Comparable<*>?> DataFrame<T>.medianOf(
     crossinline expression: RowExpression<T, R>,
-): R & Any = medianOfOrNull(expression).suggestIfNull("medianOf")
+): R = medianOfOrNull(expression).suggestIfNull("medianOf")
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataFrame<T>.medianOfOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataFrame<T>.medianOfOrNull(
     crossinline expression: RowExpression<T, R>,
-): R? = Aggregators.medianComparables<R>().aggregateOf(this, expression)
+): R? = Aggregators.median(skipNaNDefault).cast<R>().aggregateOf(this, expression)
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataFrame<T>.medianOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): Double
-    where R : Comparable<R & Any>?, R : Number? =
-    medianOfOrNull(skipNaN, expression).suggestIfNull("medianOf")
+    where R : Comparable<*>?, R : Number? = medianOfOrNull(skipNaN, expression).suggestIfNull("medianOf")
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataFrame<T>.medianOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): Double?
-    where R : Comparable<R & Any>?, R : Number? =
-    Aggregators.medianNumbers<R>(skipNaN).aggregateOf(this, expression)
+    where R : Comparable<*>?, R : Number? =
+    Aggregators.median(skipNaN).cast2<R & Any, Double?>().aggregateOf(this, expression)
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T> = medianByOrNull(skipNaN, expression).suggestIfNull("medianBy")
@@ -287,36 +283,36 @@ public fun <T> DataFrame<T>.medianBy(column: String, skipNaN: Boolean = skipNaND
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = medianByOrNull(column, skipNaN).suggestIfNull("medianBy")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = medianByOrNull(column, skipNaN).suggestIfNull("medianBy")
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataRow<T>? = Aggregators.medianCommon<C>(skipNaN).aggregateByOrNull(this, expression)
+): DataRow<T>? = Aggregators.median(skipNaN).cast<C>().aggregateByOrNull(this, expression)
 
 public fun <T> DataFrame<T>.medianByOrNull(column: String, skipNaN: Boolean = skipNaNDefault): DataRow<T>? =
     medianByOrNull(column.toColumnOf<Comparable<Any>?>(), skipNaN)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianByOrNull(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): DataRow<T>? = Aggregators.medianCommon<C>(skipNaN).aggregateByOrNull(this, column)
+): DataRow<T>? = Aggregators.median(skipNaN).cast<C>().aggregateByOrNull(this, column)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianByOrNull(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T>? = medianByOrNull(column.toColumnAccessor(), skipNaN)
@@ -358,7 +354,7 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.median(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): DataFrame<T> = Aggregators.medianCommon<C>(skipNaN).aggregateAll(this, name, columns)
+): DataFrame<T> = Aggregators.median(skipNaN).cast<C>().aggregateAll(this, name, columns)
 
 public fun <T> Grouped<T>.median(
     vararg columns: String,
@@ -368,7 +364,7 @@ public fun <T> Grouped<T>.median(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.median(
+public fun <T, C : Comparable<*>?> Grouped<T>.median(
     vararg columns: ColumnReference<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -376,7 +372,7 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.median(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.median(
+public fun <T, C : Comparable<*>?> Grouped<T>.median(
     vararg columns: KProperty<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -384,21 +380,21 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.median(
 
 @Refine
 @Interpretable("GroupByMedianOf")
-public inline fun <T, reified R : Comparable<R & Any>?> Grouped<T>.medianOf(
+public inline fun <T, reified R : Comparable<*>?> Grouped<T>.medianOf(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
-): DataFrame<T> = Aggregators.medianCommon<R>(skipNaN).aggregateOf(this, name, expression)
+): DataFrame<T> = Aggregators.median(skipNaN).cast<R>().aggregateOf(this, name, expression)
 
 @Interpretable("GroupByReduceExpression") // TODO?
-public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.medianBy(
+public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.medianBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<G, R>,
 ): ReducedGroupBy<T, G> = reduce { medianByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.medianBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.medianBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = reduce { medianByOrNull(column, skipNaN) }
@@ -408,7 +404,7 @@ public fun <T, G> GroupBy<T, G>.medianBy(column: String, skipNaN: Boolean = skip
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.medianBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.medianBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = medianBy(column.toColumnAccessor(), skipNaN)
@@ -448,7 +444,7 @@ public fun <T, C : Comparable<*>?> Pivot<T>.medianFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = medianFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.median(
+public fun <T, C : Comparable<*>?> Pivot<T>.median(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
 ): DataRow<T> = delegate { median(skipNaN, columns) }
@@ -458,31 +454,31 @@ public fun <T> Pivot<T>.median(vararg columns: String, skipNaN: Boolean = skipNa
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.median(
+public fun <T, C : Comparable<*>?> Pivot<T>.median(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = median(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.median(
+public fun <T, C : Comparable<*>?> Pivot<T>.median(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = median(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.medianOf(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.medianOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): DataRow<T> = delegate { medianOf(skipNaN, expression) }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.medianBy(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.medianBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivot<T> = reduce { medianByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.medianBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.medianBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = reduce { medianByOrNull(column, skipNaN) }
@@ -492,7 +488,7 @@ public fun <T> Pivot<T>.medianBy(column: String, skipNaN: Boolean = skipNaNDefau
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.medianBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.medianBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = medianBy(column.toColumnAccessor(), skipNaN)
@@ -531,41 +527,41 @@ public fun <T, C : Comparable<*>?> PivotGroupBy<T>.medianFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = medianFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.median(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.median(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): DataFrame<T> = Aggregators.medianCommon<C>(skipNaN).aggregateAll(this, columns)
+): DataFrame<T> = Aggregators.median(skipNaN).cast<C>().aggregateAll(this, columns)
 
 public fun <T> PivotGroupBy<T>.median(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T> =
     median(skipNaN) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.median(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.median(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = median(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.median(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.median(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = median(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.medianOf(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.medianOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
-): DataFrame<T> = Aggregators.medianCommon<R>(skipNaN).aggregateOf(this, expression)
+): DataFrame<T> = Aggregators.median(skipNaN).cast<R>().aggregateOf(this, expression)
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.medianBy(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.medianBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivotGroupBy<T> = reduce { medianByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.medianBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.medianBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = reduce { medianByOrNull(column, skipNaN) }
@@ -575,7 +571,7 @@ public fun <T> PivotGroupBy<T>.medianBy(column: String, skipNaN: Boolean = skipN
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.medianBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.medianBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = medianBy(column.toColumnAccessor(), skipNaN)
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt
index 6246e7205c..6621497f27 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt
@@ -13,6 +13,7 @@ import org.jetbrains.kotlinx.dataframe.annotations.Refine
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 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.intraComparableColumns
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateByOrNull
@@ -35,25 +36,25 @@ public fun <T : Comparable<T>> DataColumn<T?>.min(skipNaN: Boolean = skipNaNDefa
 public fun <T : Comparable<T>> DataColumn<T?>.minOrNull(skipNaN: Boolean = skipNaNDefault): T? =
     Aggregators.min<T>(skipNaN).aggregateSingleColumn(this)
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minBy(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T & Any = minByOrNull(skipNaN, selector).suggestIfNull("minBy")
+): T = minByOrNull(skipNaN, selector).suggestIfNull("minBy")
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minByOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T? = Aggregators.min<R>(skipNaN).aggregateByOrNull(this, selector)
+): T? = Aggregators.min.invoke(skipNaN).cast<R>().aggregateByOrNull(this, selector)
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minOf(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): R & Any = minOfOrNull(skipNaN, selector).suggestIfNull("minOf")
+): R = minOfOrNull(skipNaN, selector).suggestIfNull("minOf")
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minOfOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): R? = Aggregators.min<R>(skipNaN).aggregateOf(this, selector)
+): R? = Aggregators.min.invoke(skipNaN).cast<R>().aggregateOf(this, selector)
 
 // endregion
 
@@ -103,61 +104,61 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.minFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = minFor(skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(
+public fun <T, C : Comparable<*>?> DataFrame<T>.min(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): C & Any = minOrNull(skipNaN, columns).suggestIfNull("min")
+): C = minOrNull(skipNaN, columns).suggestIfNull("min")
 
 public fun <T> DataFrame<T>.min(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Comparable<Any> =
     minOrNull(*columns, skipNaN = skipNaN).suggestIfNull("min")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(
+public fun <T, C : Comparable<*>?> DataFrame<T>.min(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): C & Any = minOrNull(*columns, skipNaN = skipNaN).suggestIfNull("min")
+): C = minOrNull(*columns, skipNaN = skipNaN).suggestIfNull("min")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(
+public fun <T, C : Comparable<*>?> DataFrame<T>.min(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
-): C & Any = minOrNull(*columns, skipNaN = skipNaN).suggestIfNull("min")
+): C = minOrNull(*columns, skipNaN = skipNaN).suggestIfNull("min")
 
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): C? = Aggregators.min<C>(skipNaN).aggregateAll(this, columns)
+): C? = Aggregators.min.invoke(skipNaN).cast<C>().aggregateAll(this, columns)
 
 public fun <T> DataFrame<T>.minOrNull(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Comparable<Any>? =
     minOrNull(skipNaN) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): C? = minOrNull(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): C? = minOrNull(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minOf(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): C & Any = minOfOrNull(skipNaN, expression).suggestIfNull("minOf")
+): C = minOfOrNull(skipNaN, expression).suggestIfNull("minOf")
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minOfOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): C? = Aggregators.min<C>(skipNaN).aggregateOf(this, expression)
+): C? = Aggregators.min.invoke(skipNaN).cast<C>().aggregateOf(this, expression)
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T> = minByOrNull(skipNaN, expression).suggestIfNull("minBy")
@@ -167,36 +168,36 @@ public fun <T> DataFrame<T>.minBy(column: String, skipNaN: Boolean = skipNaNDefa
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = minByOrNull(column, skipNaN).suggestIfNull("minBy")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = minByOrNull(column, skipNaN).suggestIfNull("minBy")
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataRow<T>? = Aggregators.min<C>(skipNaN).aggregateByOrNull(this, expression)
+): DataRow<T>? = Aggregators.min.invoke(skipNaN).cast<C>().aggregateByOrNull(this, expression)
 
 public fun <T> DataFrame<T>.minByOrNull(column: String, skipNaN: Boolean = skipNaNDefault): DataRow<T>? =
     minByOrNull(column.toColumnOf<Comparable<Any>?>(), skipNaN)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): DataRow<T>? = Aggregators.min<C>(skipNaN).aggregateByOrNull(this, column)
+): DataRow<T>? = Aggregators.min.invoke(skipNaN).cast<C>().aggregateByOrNull(this, column)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T>? = minByOrNull(column.toColumnAccessor(), skipNaN)
@@ -240,7 +241,7 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C?>,
-): DataFrame<T> = Aggregators.min<C>(skipNaN).aggregateAll(this, name, columns)
+): DataFrame<T> = Aggregators.min.invoke(skipNaN).cast<C>().aggregateAll(this, name, columns)
 
 public fun <T> Grouped<T>.min(
     vararg columns: String,
@@ -250,7 +251,7 @@ public fun <T> Grouped<T>.min(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
+public fun <T, C : Comparable<*>?> Grouped<T>.min(
     vararg columns: ColumnReference<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -258,7 +259,7 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
+public fun <T, C : Comparable<*>?> Grouped<T>.min(
     vararg columns: KProperty<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -266,21 +267,21 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
 
 @Refine
 @Interpretable("GroupByMinOf")
-public inline fun <T, reified C : Comparable<C & Any>?> Grouped<T>.minOf(
+public inline fun <T, reified C : Comparable<*>?> Grouped<T>.minOf(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataFrame<T> = Aggregators.min<C>(skipNaN).aggregateOf(this, name, expression)
+): DataFrame<T> = Aggregators.min.invoke(skipNaN).cast<C>().aggregateOf(this, name, expression)
 
 @Interpretable("GroupByReduceExpression")
-public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.minBy(
+public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.minBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<G, R>,
 ): ReducedGroupBy<T, G> = reduce { minByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.minBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.minBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = reduce { minByOrNull(column, skipNaN) }
@@ -290,7 +291,7 @@ public fun <T, G> GroupBy<T, G>.minBy(column: String, skipNaN: Boolean = skipNaN
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.minBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.minBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = minBy(column.toColumnAccessor(), skipNaN)
@@ -330,7 +331,7 @@ public fun <T, R : Comparable<*>?> Pivot<T>.minFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = minFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(
+public fun <T, R : Comparable<*>?> Pivot<T>.min(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, R>,
 ): DataRow<T> = delegate { min(skipNaN, columns) }
@@ -340,31 +341,31 @@ public fun <T> Pivot<T>.min(vararg columns: String, skipNaN: Boolean = skipNaNDe
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(
+public fun <T, R : Comparable<*>?> Pivot<T>.min(
     vararg columns: ColumnReference<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = min(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(
+public fun <T, R : Comparable<*>?> Pivot<T>.min(
     vararg columns: KProperty<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = min(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.minOf(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.minOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): DataRow<T> = delegate { minOf(skipNaN, rowExpression) }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.minBy(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.minBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivot<T> = reduce { minByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.minBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = reduce { minByOrNull(column, skipNaN) }
@@ -374,7 +375,7 @@ public fun <T> Pivot<T>.minBy(column: String, skipNaN: Boolean = skipNaNDefault)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.minBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = minBy(column.toColumnAccessor(), skipNaN)
@@ -414,39 +415,39 @@ public fun <T, R : Comparable<*>?> PivotGroupBy<T>.minFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = minFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, R>,
-): DataFrame<T> = Aggregators.min<R>(skipNaN).aggregateAll(this, columns)
+): DataFrame<T> = Aggregators.min.invoke(skipNaN).cast<R>().aggregateAll(this, columns)
 
 public fun <T> PivotGroupBy<T>.min(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T> =
     min(skipNaN) { columns.toComparableColumns() }
 
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(
     vararg columns: ColumnReference<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = min(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(
     vararg columns: KProperty<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = min(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.minOf(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.minOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): DataFrame<T> = aggregate { minOf(skipNaN, rowExpression) }
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.minBy(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.minBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivotGroupBy<T> = reduce { minByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.minBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = reduce { minByOrNull(column, skipNaN) }
@@ -456,7 +457,7 @@ public fun <T> PivotGroupBy<T>.minBy(column: String, skipNaN: Boolean = skipNaND
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.minBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = minBy(column.toColumnAccessor(), skipNaN)
@@ -473,26 +474,26 @@ public fun <T : Comparable<T>> DataColumn<T?>.min(): T = min(skipNaN = skipNaNDe
 public fun <T : Comparable<T>> DataColumn<T?>.minOrNull(): T? = minOrNull(skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minBy(noinline selector: (T) -> R): T & Any =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minBy(noinline selector: (T) -> R): T =
     minBy(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minByOrNull(noinline selector: (T) -> R): T? =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minByOrNull(noinline selector: (T) -> R): T? =
     minByOrNull(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minOf(crossinline selector: (T) -> R): R & Any =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minOf(crossinline selector: (T) -> R): R =
     minOf(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minOfOrNull(crossinline selector: (T) -> R): R? =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minOfOrNull(crossinline selector: (T) -> R): R? =
     minOfOrNull(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public inline fun <reified T : Comparable<T>> AnyRow.rowMinOfOrNull(): T? = rowMinOfOrNull<T>(skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <reified T : Comparable<T & Any>?> AnyRow.rowMinOf(): T & Any = rowMinOf(skipNaN = skipNaNDefault)
+public inline fun <reified T : Comparable<T>> AnyRow.rowMinOf(): T = rowMinOf(skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public fun <T> DataFrame<T>.min(): DataRow<T> = min(skipNaN = skipNaNDefault)
@@ -516,7 +517,7 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.minFor(vararg columns: KProperty
     minFor(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(columns: ColumnsSelector<T, C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.min(columns: ColumnsSelector<T, C>): C =
     min(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -525,16 +526,16 @@ public fun <T> DataFrame<T>.min(vararg columns: String): Comparable<Any> =
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(vararg columns: ColumnReference<C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.min(vararg columns: ColumnReference<C>): C =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(vararg columns: KProperty<C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.min(vararg columns: KProperty<C>): C =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(columns: ColumnsSelector<T, C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(columns: ColumnsSelector<T, C>): C? =
     minOrNull(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -543,26 +544,25 @@ public fun <T> DataFrame<T>.minOrNull(vararg columns: String): Comparable<Any>?
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(vararg columns: ColumnReference<C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(vararg columns: ColumnReference<C>): C? =
     minOrNull(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(vararg columns: KProperty<C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(vararg columns: KProperty<C>): C? =
     minOrNull(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minOf(
-    crossinline expression: RowExpression<T, C>,
-): C & Any = minOf(skipNaN = skipNaNDefault, expression = expression)
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minOf(crossinline expression: RowExpression<T, C>): C =
+    minOf(skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minOfOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minOfOrNull(
     crossinline expression: RowExpression<T, C>,
 ): C? = minOfOrNull(skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T> = minBy(skipNaN = skipNaNDefault, expression = expression)
 
@@ -571,16 +571,16 @@ public fun <T> DataFrame<T>.minBy(column: String): DataRow<T> = minBy(column, sk
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(column: ColumnReference<C>): DataRow<T> =
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(column: ColumnReference<C>): DataRow<T> =
     minBy(column, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(column: KProperty<C>): DataRow<T> =
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(column: KProperty<C>): DataRow<T> =
     minBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T>? = minByOrNull(skipNaN = skipNaNDefault, expression = expression)
 
@@ -589,13 +589,12 @@ public fun <T> DataFrame<T>.minByOrNull(column: String): DataRow<T>? = minByOrNu
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(
-    column: ColumnReference<C>,
-): DataRow<T>? = minByOrNull(column, skipNaN = skipNaNDefault)
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(column: ColumnReference<C>): DataRow<T>? =
+    minByOrNull(column, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(column: KProperty<C>): DataRow<T>? =
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(column: KProperty<C>): DataRow<T>? =
     minByOrNull(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -620,7 +619,7 @@ public fun <T, C : Comparable<*>?> Grouped<T>.minFor(vararg columns: KProperty<C
     minFor(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
+public fun <T, C : Comparable<*>?> Grouped<T>.min(
     name: String? = null,
     columns: ColumnsSelector<T, C?>,
 ): DataFrame<T> = min(name, skipNaN = skipNaNDefault, columns = columns)
@@ -631,32 +630,30 @@ public fun <T> Grouped<T>.min(vararg columns: String, name: String? = null): Dat
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
+public fun <T, C : Comparable<*>?> Grouped<T>.min(
     vararg columns: ColumnReference<C>,
     name: String? = null,
 ): DataFrame<T> = min(columns = columns, name = name, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
-    vararg columns: KProperty<C>,
-    name: String? = null,
-): DataFrame<T> = min(columns = columns, name = name, skipNaN = skipNaNDefault)
+public fun <T, C : Comparable<*>?> Grouped<T>.min(vararg columns: KProperty<C>, name: String? = null): DataFrame<T> =
+    min(columns = columns, name = name, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> Grouped<T>.minOf(
+public inline fun <T, reified C : Comparable<*>?> Grouped<T>.minOf(
     name: String? = null,
     crossinline expression: RowExpression<T, C>,
 ): DataFrame<T> = minOf(name, skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.minBy(
+public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.minBy(
     crossinline rowExpression: RowExpression<G, R>,
 ): ReducedGroupBy<T, G> = minBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.minBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.minBy(
     column: ColumnReference<C>,
 ): ReducedGroupBy<T, G> = minBy(column, skipNaN = skipNaNDefault)
 
@@ -665,9 +662,8 @@ public fun <T, G> GroupBy<T, G>.minBy(column: String): ReducedGroupBy<T, G> = mi
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.minBy(
-    column: KProperty<C>,
-): ReducedGroupBy<T, G> = minBy(column, skipNaN = skipNaNDefault)
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.minBy(column: KProperty<C>): ReducedGroupBy<T, G> =
+    minBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public fun <T> Pivot<T>.min(separate: Boolean = false): DataRow<T> = min(separate, skipNaN = skipNaNDefault)
@@ -697,32 +693,32 @@ public fun <T, R : Comparable<*>?> Pivot<T>.minFor(
 ): DataRow<T> = minFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(columns: ColumnsSelector<T, R>): DataRow<T> =
+public fun <T, R : Comparable<*>?> Pivot<T>.min(columns: ColumnsSelector<T, R>): DataRow<T> =
     min(skipNaN = skipNaNDefault, columns = columns)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(vararg columns: ColumnReference<R>): DataRow<T> =
+public fun <T, R : Comparable<*>?> Pivot<T>.min(vararg columns: ColumnReference<R>): DataRow<T> =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(vararg columns: KProperty<R>): DataRow<T> =
+public fun <T, R : Comparable<*>?> Pivot<T>.min(vararg columns: KProperty<R>): DataRow<T> =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.minOf(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.minOf(
     crossinline rowExpression: RowExpression<T, R>,
 ): DataRow<T> = minOf(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.minBy(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.minBy(
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivot<T> = minBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.minBy(column: ColumnReference<C>): ReducedPivot<T> =
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.minBy(column: ColumnReference<C>): ReducedPivot<T> =
     minBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -730,7 +726,7 @@ public fun <T> Pivot<T>.minBy(column: String): ReducedPivot<T> = minBy(column, s
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.minBy(column: KProperty<C>): ReducedPivot<T> =
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.minBy(column: KProperty<C>): ReducedPivot<T> =
     minBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -761,7 +757,7 @@ public fun <T, R : Comparable<*>?> PivotGroupBy<T>.minFor(
 ): DataFrame<T> = minFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(columns: ColumnsSelector<T, R>): DataFrame<T> =
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(columns: ColumnsSelector<T, R>): DataFrame<T> =
     min(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -769,27 +765,27 @@ public fun <T> PivotGroupBy<T>.min(vararg columns: String): DataFrame<T> =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(vararg columns: ColumnReference<R>): DataFrame<T> =
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(vararg columns: ColumnReference<R>): DataFrame<T> =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(vararg columns: KProperty<R>): DataFrame<T> =
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(vararg columns: KProperty<R>): DataFrame<T> =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.minOf(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.minOf(
     crossinline rowExpression: RowExpression<T, R>,
 ): DataFrame<T> = minOf(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.minBy(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.minBy(
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivotGroupBy<T> = minBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.minBy(
     column: ColumnReference<C>,
 ): ReducedPivotGroupBy<T> = minBy(column, skipNaN = skipNaNDefault)
 
@@ -798,8 +794,7 @@ public fun <T> PivotGroupBy<T>.minBy(column: String): ReducedPivotGroupBy<T> = m
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.minBy(
-    column: KProperty<C>,
-): ReducedPivotGroupBy<T> = minBy(column, skipNaN = skipNaNDefault)
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.minBy(column: KProperty<C>): ReducedPivotGroupBy<T> =
+    minBy(column, skipNaN = skipNaNDefault)
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/percentile.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/percentile.kt
index be666a8448..76e22c6847 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/percentile.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/percentile.kt
@@ -15,6 +15,8 @@ import org.jetbrains.kotlinx.dataframe.annotations.Refine
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 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.aggregators.cast2
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.intraComparableColumns
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateByOrNull
@@ -48,53 +50,53 @@ import kotlin.reflect.KProperty
 
 // region DataColumn
 
-public fun <T : Comparable<T & Any>?> DataColumn<T>.percentile(percentile: Double): T & Any =
+public fun <T : Comparable<*>?> DataColumn<T>.percentile(percentile: Double): T =
     percentileOrNull(percentile).suggestIfNull("percentile")
 
-public fun <T : Comparable<T & Any>?> DataColumn<T>.percentileOrNull(percentile: Double): T? =
-    Aggregators.percentileComparables<T>(percentile).aggregateSingleColumn(this)
+public fun <T : Comparable<*>?> DataColumn<T>.percentileOrNull(percentile: Double): T? =
+    Aggregators.percentile(percentile, skipNaNDefault).cast<T>().aggregateSingleColumn(this)
 
 public fun <T> DataColumn<T>.percentile(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where T : Comparable<T & Any>?, T : Number? =
+    where T : Comparable<*>?, T : Number? =
     percentileOrNull(percentile = percentile, skipNaN = skipNaN).suggestIfNull("percentile")
 
 public fun <T> DataColumn<T>.percentileOrNull(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where T : Comparable<T & Any>?, T : Number? =
-    Aggregators.percentileNumbers<T>(percentile, skipNaN).aggregateSingleColumn(this)
+    where T : Comparable<*>?, T : Number? =
+    Aggregators.percentile(percentile, skipNaN).cast2<T & Any, Double?>().aggregateSingleColumn(this)
 
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.percentileBy(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.percentileBy(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T & Any = percentileByOrNull(percentile, skipNaN, selector).suggestIfNull("percentileBy")
+): T = percentileByOrNull(percentile, skipNaN, selector).suggestIfNull("percentileBy")
 
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.percentileByOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.percentileByOrNull(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T? = Aggregators.percentileCommon<R>(percentile, skipNaN).aggregateByOrNull(this, selector)
+): T? = Aggregators.percentile(percentile, skipNaN).cast<R>().aggregateByOrNull(this, selector)
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.percentileOf(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.percentileOf(
     percentile: Double,
     crossinline expression: (T) -> R,
-): R & Any = percentileOfOrNull(percentile, expression).suggestIfNull("percentileOf")
+): R = percentileOfOrNull(percentile, expression).suggestIfNull("percentileOf")
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.percentileOfOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.percentileOfOrNull(
     percentile: Double,
     crossinline expression: (T) -> R,
-): R? = Aggregators.percentileComparables<R>(percentile).aggregateOf(this, expression)
+): R? = Aggregators.percentile(percentile, skipNaNDefault).cast<R>().aggregateOf(this, expression)
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataColumn<T>.percentileOf(
@@ -102,7 +104,7 @@ public inline fun <T, reified R> DataColumn<T>.percentileOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: (T) -> R,
 ): Double
-    where R : Comparable<R & Any>?, R : Number? =
+    where R : Comparable<*>?, R : Number? =
     percentileOfOrNull(percentile, skipNaN, expression).suggestIfNull("percentileOf")
 
 @OverloadResolutionByLambdaReturnType
@@ -111,8 +113,8 @@ public inline fun <T, reified R> DataColumn<T>.percentileOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: (T) -> R,
 ): Double?
-    where R : Comparable<R & Any>?, R : Number? =
-    Aggregators.percentileNumbers<R>(percentile, skipNaN).aggregateOf(this, expression)
+    where R : Comparable<*>?, R : Number? =
+    Aggregators.percentile(percentile, skipNaN).cast2<R & Any, Double?>().aggregateOf(this, expression)
 
 // endregion
 
@@ -184,18 +186,16 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.percentileFor(
 
 // TODO, requires explicit type C due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentile(
-    percentile: Double,
-    columns: ColumnsSelector<T, C>,
-): C & Any = percentileOrNull(percentile, columns).suggestIfNull("percentile")
+public fun <T, C : Comparable<*>?> DataFrame<T>.percentile(percentile: Double, columns: ColumnsSelector<T, C>): C =
+    percentileOrNull(percentile, columns).suggestIfNull("percentile")
 
 // TODO, requires explicit type C due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
 @Suppress("UNCHECKED_CAST")
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentileOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.percentileOrNull(
     percentile: Double,
     columns: ColumnsSelector<T, C>,
-): C? = Aggregators.percentileComparables<C>(percentile).aggregateAll(this, columns)
+): C? = Aggregators.percentile(percentile, skipNaNDefault).cast<C>().aggregateAll(this, columns)
 
 @OverloadResolutionByLambdaReturnType
 public fun <T, C> DataFrame<T>.percentile(
@@ -203,7 +203,7 @@ public fun <T, C> DataFrame<T>.percentile(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
 ): Double
-    where C : Number?, C : Comparable<C & Any>? =
+    where C : Number?, C : Comparable<*>? =
     percentileOrNull(percentile, skipNaN, columns).suggestIfNull("percentile")
 
 @OverloadResolutionByLambdaReturnType
@@ -213,8 +213,8 @@ public fun <T, C> DataFrame<T>.percentileOrNull(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
 ): Double?
-    where C : Comparable<C & Any>?, C : Number? =
-    Aggregators.percentileNumbers<C>(percentile, skipNaN).aggregateAll(this, columns)
+    where C : Comparable<*>?, C : Number? =
+    Aggregators.percentile(percentile, skipNaN).cast2<C & Any, Double?>().aggregateAll(this, columns)
 
 public fun <T> DataFrame<T>.percentile(
     percentile: Double,
@@ -231,14 +231,12 @@ public fun <T> DataFrame<T>.percentileOrNull(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentile(
-    percentile: Double,
-    vararg columns: ColumnReference<C>,
-): C & Any = percentileOrNull(percentile, *columns).suggestIfNull("percentile")
+public fun <T, C : Comparable<*>?> DataFrame<T>.percentile(percentile: Double, vararg columns: ColumnReference<C>): C =
+    percentileOrNull(percentile, *columns).suggestIfNull("percentile")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentileOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.percentileOrNull(
     percentile: Double,
     vararg columns: ColumnReference<C>,
 ): C? = percentileOrNull<T, C>(percentile) { columns.toColumnSet() }
@@ -250,7 +248,7 @@ public fun <T, C> DataFrame<T>.percentile(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where C : Comparable<C & Any>?, C : Number? =
+    where C : Comparable<*>?, C : Number? =
     percentileOrNull(percentile, *columns, skipNaN = skipNaN).suggestIfNull("percentile")
 
 @Deprecated(DEPRECATED_ACCESS_API)
@@ -260,19 +258,16 @@ public fun <T, C> DataFrame<T>.percentileOrNull(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where C : Comparable<C & Any>?, C : Number? =
-    percentileOrNull(percentile, skipNaN) { columns.toColumnSet() }
+    where C : Comparable<*>?, C : Number? = percentileOrNull(percentile, skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentile(
-    percentile: Double,
-    vararg columns: KProperty<C>,
-): C & Any = percentileOrNull(percentile, *columns).suggestIfNull("percentile")
+public fun <T, C : Comparable<*>?> DataFrame<T>.percentile(percentile: Double, vararg columns: KProperty<C>): C =
+    percentileOrNull(percentile, *columns).suggestIfNull("percentile")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentileOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.percentileOrNull(
     percentile: Double,
     vararg columns: KProperty<C>,
 ): C? = percentileOrNull<T, C>(percentile) { columns.toColumnSet() }
@@ -284,7 +279,7 @@ public fun <T, C> DataFrame<T>.percentile(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where C : Comparable<C & Any>?, C : Number? =
+    where C : Comparable<*>?, C : Number? =
     percentileOrNull(percentile, *columns, skipNaN = skipNaN).suggestIfNull("percentile")
 
 @Deprecated(DEPRECATED_ACCESS_API)
@@ -294,22 +289,21 @@ public fun <T, C> DataFrame<T>.percentileOrNull(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where C : Comparable<C & Any>?, C : Number? =
-    percentileOrNull(percentile, skipNaN) { columns.toColumnSet() }
+    where C : Comparable<*>?, C : Number? = percentileOrNull(percentile, skipNaN) { columns.toColumnSet() }
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataFrame<T>.percentileOf(
+public inline fun <T, reified R : Comparable<*>?> DataFrame<T>.percentileOf(
     percentile: Double,
     crossinline expression: RowExpression<T, R>,
-): R & Any = percentileOfOrNull(percentile, expression).suggestIfNull("percentileOf")
+): R = percentileOfOrNull(percentile, expression).suggestIfNull("percentileOf")
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataFrame<T>.percentileOfOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataFrame<T>.percentileOfOrNull(
     percentile: Double,
     crossinline expression: RowExpression<T, R>,
-): R? = Aggregators.percentileComparables<R>(percentile).aggregateOf(this, expression)
+): R? = Aggregators.percentile(percentile, skipNaNDefault).cast<R>().aggregateOf(this, expression)
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataFrame<T>.percentileOf(
@@ -317,7 +311,7 @@ public inline fun <T, reified R> DataFrame<T>.percentileOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): Double
-    where R : Comparable<R & Any>?, R : Number? =
+    where R : Comparable<*>?, R : Number? =
     percentileOfOrNull(percentile, skipNaN, expression).suggestIfNull("percentileOf")
 
 @OverloadResolutionByLambdaReturnType
@@ -326,10 +320,10 @@ public inline fun <T, reified R> DataFrame<T>.percentileOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): Double?
-    where R : Comparable<R & Any>?, R : Number? =
-    Aggregators.percentileNumbers<R>(percentile, skipNaN).aggregateOf(this, expression)
+    where R : Comparable<*>?, R : Number? =
+    Aggregators.percentile(percentile, skipNaN).cast2<R & Any, Double?>().aggregateOf(this, expression)
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileBy(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
@@ -343,7 +337,7 @@ public fun <T> DataFrame<T>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileBy(
     percentile: Double,
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -351,17 +345,17 @@ public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileB
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileBy(
     percentile: Double,
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = percentileByOrNull(percentile, column, skipNaN).suggestIfNull("percentileBy")
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileByOrNull(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataRow<T>? = Aggregators.percentileCommon<C>(percentile, skipNaN).aggregateByOrNull(this, expression)
+): DataRow<T>? = Aggregators.percentile(percentile, skipNaN).cast<C>().aggregateByOrNull(this, expression)
 
 public fun <T> DataFrame<T>.percentileByOrNull(
     percentile: Double,
@@ -371,15 +365,15 @@ public fun <T> DataFrame<T>.percentileByOrNull(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileByOrNull(
     percentile: Double,
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): DataRow<T>? = Aggregators.percentileCommon<C>(percentile, skipNaN).aggregateByOrNull(this, column)
+): DataRow<T>? = Aggregators.percentile(percentile, skipNaN).cast<C>().aggregateByOrNull(this, column)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileByOrNull(
     percentile: Double,
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -427,7 +421,7 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): DataFrame<T> = Aggregators.percentileCommon<C>(percentile, skipNaN).aggregateAll(this, name, columns)
+): DataFrame<T> = Aggregators.percentile(percentile, skipNaN).cast<C>().aggregateAll(this, name, columns)
 
 public fun <T> Grouped<T>.percentile(
     percentile: Double,
@@ -438,7 +432,7 @@ public fun <T> Grouped<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(
+public fun <T, C : Comparable<*>?> Grouped<T>.percentile(
     percentile: Double,
     vararg columns: ColumnReference<C>,
     name: String? = null,
@@ -447,7 +441,7 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(
+public fun <T, C : Comparable<*>?> Grouped<T>.percentile(
     percentile: Double,
     vararg columns: KProperty<C>,
     name: String? = null,
@@ -456,15 +450,15 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(
 
 @Refine
 @Interpretable("GroupByPercentileOf")
-public inline fun <T, reified R : Comparable<R & Any>?> Grouped<T>.percentileOf(
+public inline fun <T, reified R : Comparable<*>?> Grouped<T>.percentileOf(
     percentile: Double,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
-): DataFrame<T> = Aggregators.percentileCommon<R>(percentile, skipNaN).aggregateOf(this, name, expression)
+): DataFrame<T> = Aggregators.percentile(percentile, skipNaN).cast<R>().aggregateOf(this, name, expression)
 
 @Interpretable("GroupByReduceExpression") // TODO?
-public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.percentileBy(
+public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.percentileBy(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<G, R>,
@@ -472,7 +466,7 @@ public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.percent
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.percentileBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.percentileBy(
     percentile: Double,
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -486,7 +480,7 @@ public fun <T, G> GroupBy<T, G>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.percentileBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.percentileBy(
     percentile: Double,
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -534,7 +528,7 @@ public fun <T, C : Comparable<*>?> Pivot<T>.percentileFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = percentileFor(percentile, separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.percentile(
+public fun <T, C : Comparable<*>?> Pivot<T>.percentile(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
@@ -548,7 +542,7 @@ public fun <T> Pivot<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.percentile(
+public fun <T, C : Comparable<*>?> Pivot<T>.percentile(
     percentile: Double,
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -556,19 +550,19 @@ public fun <T, C : Comparable<C & Any>?> Pivot<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.percentile(
+public fun <T, C : Comparable<*>?> Pivot<T>.percentile(
     percentile: Double,
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = percentile(percentile, skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.percentileOf(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.percentileOf(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): DataRow<T> = delegate { percentileOf(percentile, skipNaN, expression) }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.percentileBy(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.percentileBy(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
@@ -576,7 +570,7 @@ public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.percentileBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.percentileBy(
     percentile: Double,
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -590,7 +584,7 @@ public fun <T> Pivot<T>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.percentileBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.percentileBy(
     percentile: Double,
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -637,11 +631,11 @@ public fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentileFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = percentileFor(percentile, separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.percentile(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentile(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): DataFrame<T> = Aggregators.percentileCommon<C>(percentile, skipNaN).aggregateAll(this, columns)
+): DataFrame<T> = Aggregators.percentile(percentile, skipNaN).cast<C>().aggregateAll(this, columns)
 
 public fun <T> PivotGroupBy<T>.percentile(
     percentile: Double,
@@ -651,7 +645,7 @@ public fun <T> PivotGroupBy<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.percentile(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentile(
     percentile: Double,
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -659,19 +653,19 @@ public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.percentile(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentile(
     percentile: Double,
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = percentile(percentile, skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.percentileOf(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.percentileOf(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
-): DataFrame<T> = Aggregators.percentileCommon<R>(percentile, skipNaN).aggregateOf(this, expression)
+): DataFrame<T> = Aggregators.percentile(percentile, skipNaN).cast<R>().aggregateOf(this, expression)
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.percentileBy(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.percentileBy(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
@@ -679,7 +673,7 @@ public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.percenti
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.percentileBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.percentileBy(
     percentile: Double,
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -693,7 +687,7 @@ public fun <T> PivotGroupBy<T>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.percentileBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.percentileBy(
     percentile: Double,
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,

From 421140a43c9ed0ba25ca7cbdca67a1869faf18f3 Mon Sep 17 00:00:00 2001
From: "andrei.kislitsyn" <kisandy@yandex.ru>
Date: Tue, 25 Nov 2025 17:28:37 +0400
Subject: [PATCH 02/16] Revert "apply DefinitelyNotNullable patch for notebooks
 only: #1116"

This reverts commit 0ae5b3161437b58d37bbe4d1589a678a5092b4cd.
---
 .../jetbrains/kotlinx/dataframe/api/max.kt    | 211 +++++++++---------
 .../jetbrains/kotlinx/dataframe/api/median.kt | 148 ++++++------
 .../jetbrains/kotlinx/dataframe/api/min.kt    | 203 +++++++++--------
 .../kotlinx/dataframe/api/percentile.kt       | 156 ++++++-------
 4 files changed, 368 insertions(+), 350 deletions(-)

diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt
index f4ae1ce7db..d1ff0cd1e2 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt
@@ -13,7 +13,6 @@ import org.jetbrains.kotlinx.dataframe.annotations.Refine
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 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.intraComparableColumns
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateByOrNull
@@ -36,25 +35,25 @@ public fun <T : Comparable<T>> DataColumn<T?>.max(skipNaN: Boolean = skipNaNDefa
 public fun <T : Comparable<T>> DataColumn<T?>.maxOrNull(skipNaN: Boolean = skipNaNDefault): T? =
     Aggregators.max<T>(skipNaN).aggregateSingleColumn(this)
 
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxBy(
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T = maxByOrNull(skipNaN, selector).suggestIfNull("maxBy")
+): T & Any = maxByOrNull(skipNaN, selector).suggestIfNull("maxBy")
 
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxByOrNull(
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T? = Aggregators.max.invoke(skipNaN).cast<R>().aggregateByOrNull(this, selector)
+): T? = Aggregators.max<R>(skipNaN).aggregateByOrNull(this, selector)
 
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxOf(
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): R = maxOfOrNull(skipNaN, selector).suggestIfNull("maxOf")
+): R & Any = maxOfOrNull(skipNaN, selector).suggestIfNull("maxOf")
 
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxOfOrNull(
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): R? = Aggregators.max.invoke(skipNaN).cast<R>().aggregateOf(this, selector)
+): R? = Aggregators.max<R>(skipNaN).aggregateOf(this, selector)
 
 // endregion
 
@@ -104,61 +103,61 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.maxFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = maxFor(skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<*>?> DataFrame<T>.max(
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): C = maxOrNull(skipNaN, columns).suggestIfNull("max")
+): C & Any = maxOrNull(skipNaN, columns).suggestIfNull("max")
 
 public fun <T> DataFrame<T>.max(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Comparable<Any> =
     maxOrNull(*columns, skipNaN = skipNaN).suggestIfNull("max")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> DataFrame<T>.max(
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): C = maxOrNull(*columns, skipNaN = skipNaN).suggestIfNull("max")
+): C & Any = maxOrNull(*columns, skipNaN = skipNaN).suggestIfNull("max")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> DataFrame<T>.max(
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
-): C = maxOrNull(*columns, skipNaN = skipNaN).suggestIfNull("max")
+): C & Any = maxOrNull(*columns, skipNaN = skipNaN).suggestIfNull("max")
 
-public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): C? = Aggregators.max.invoke(skipNaN).cast<C>().aggregateAll(this, columns)
+): C? = Aggregators.max<C>(skipNaN).aggregateAll(this, columns)
 
 public fun <T> DataFrame<T>.maxOrNull(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Comparable<Any>? =
     maxOrNull(skipNaN) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): C? = maxOrNull(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): C? = maxOrNull(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxOf(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): C = maxOfOrNull(skipNaN, expression).suggestIfNull("maxOf")
+): C & Any = maxOfOrNull(skipNaN, expression).suggestIfNull("maxOf")
 
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxOfOrNull(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): C? = Aggregators.max.invoke(skipNaN).cast<C>().aggregateOf(this, expression)
+): C? = Aggregators.max<C>(skipNaN).aggregateOf(this, expression)
 
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T> = maxByOrNull(skipNaN, expression).suggestIfNull("maxBy")
@@ -168,36 +167,36 @@ public fun <T> DataFrame<T>.maxBy(column: String, skipNaN: Boolean = skipNaNDefa
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = maxByOrNull(column, skipNaN).suggestIfNull("maxBy")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = maxByOrNull(column, skipNaN).suggestIfNull("maxBy")
 
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataRow<T>? = Aggregators.max.invoke(skipNaN).cast<C>().aggregateByOrNull(this, expression)
+): DataRow<T>? = Aggregators.max<C>(skipNaN).aggregateByOrNull(this, expression)
 
 public fun <T> DataFrame<T>.maxByOrNull(column: String, skipNaN: Boolean = skipNaNDefault): DataRow<T>? =
     maxByOrNull(column.toColumnOf<Comparable<Any>?>(), skipNaN)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): DataRow<T>? = Aggregators.max.invoke(skipNaN).cast<C>().aggregateByOrNull(this, column)
+): DataRow<T>? = Aggregators.max<C>(skipNaN).aggregateByOrNull(this, column)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T>? = maxByOrNull(column.toColumnAccessor(), skipNaN)
@@ -241,7 +240,7 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C?>,
-): DataFrame<T> = Aggregators.max.invoke(skipNaN).cast<C>().aggregateAll(this, name, columns)
+): DataFrame<T> = Aggregators.max<C>(skipNaN).aggregateAll(this, name, columns)
 
 public fun <T> Grouped<T>.max(
     vararg columns: String,
@@ -251,7 +250,7 @@ public fun <T> Grouped<T>.max(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> Grouped<T>.max(
+public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
     vararg columns: ColumnReference<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -259,7 +258,7 @@ public fun <T, C : Comparable<*>?> Grouped<T>.max(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> Grouped<T>.max(
+public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
     vararg columns: KProperty<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -267,21 +266,21 @@ public fun <T, C : Comparable<*>?> Grouped<T>.max(
 
 @Refine
 @Interpretable("GroupByMaxOf")
-public inline fun <T, reified C : Comparable<*>?> Grouped<T>.maxOf(
+public inline fun <T, reified C : Comparable<C & Any>?> Grouped<T>.maxOf(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataFrame<T> = Aggregators.max.invoke(skipNaN).cast<C>().aggregateOf(this, name, expression)
+): DataFrame<T> = Aggregators.max<C>(skipNaN).aggregateOf(this, name, expression)
 
 @Interpretable("GroupByReduceExpression")
-public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.maxBy(
+public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.maxBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<G, R>,
 ): ReducedGroupBy<T, G> = reduce { maxByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.maxBy(
+public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.maxBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = reduce { maxByOrNull(column, skipNaN) }
@@ -291,7 +290,7 @@ public fun <T, G> GroupBy<T, G>.maxBy(column: String, skipNaN: Boolean = skipNaN
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.maxBy(
+public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.maxBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = maxBy(column.toColumnAccessor(), skipNaN)
@@ -331,43 +330,41 @@ public fun <T, R : Comparable<*>?> Pivot<T>.maxFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = maxFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, R : Comparable<*>?> Pivot<T>.max(
+public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, R>,
-): DataRow<T> = delegate { maxFor(separate = false, skipNaN, columns) }
+): DataRow<T> = delegate { max(skipNaN, columns) }
 
-public fun <T, R : Comparable<*>?> Pivot<T>.max(
-    vararg columns: String,
-    skipNaN: Boolean = skipNaNDefault,
-): DataRow<T> = max(skipNaN) { columns.toComparableColumns() }
+public fun <T> Pivot<T>.max(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataRow<T> =
+    max(skipNaN) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<*>?> Pivot<T>.max(
+public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(
     vararg columns: ColumnReference<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = max(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<*>?> Pivot<T>.max(
+public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(
     vararg columns: KProperty<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = max(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<*>?> Pivot<T>.maxOf(
+public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.maxOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): DataRow<T> = delegate { maxOf(skipNaN, rowExpression) }
 
-public inline fun <T, reified R : Comparable<*>?> Pivot<T>.maxBy(
+public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.maxBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivot<T> = reduce { maxByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> Pivot<T>.maxBy(
+public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.maxBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = reduce { maxByOrNull(column, skipNaN) }
@@ -377,7 +374,7 @@ public fun <T> Pivot<T>.maxBy(column: String, skipNaN: Boolean = skipNaNDefault)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> Pivot<T>.maxBy(
+public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.maxBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = maxBy(column.toColumnAccessor(), skipNaN)
@@ -417,39 +414,39 @@ public fun <T, R : Comparable<*>?> PivotGroupBy<T>.maxFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = maxFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(
+public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, R>,
-): DataFrame<T> = Aggregators.max.invoke(skipNaN).cast<R>().aggregateAll(this, columns)
+): DataFrame<T> = Aggregators.max<R>(skipNaN).aggregateAll(this, columns)
 
 public fun <T> PivotGroupBy<T>.max(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T> =
     max(skipNaN) { columns.toComparableColumns() }
 
-public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(
+public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(
     vararg columns: ColumnReference<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = max(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(
+public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(
     vararg columns: KProperty<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = max(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.maxOf(
+public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.maxOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): DataFrame<T> = aggregate { maxOf(skipNaN, rowExpression) }
 
-public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.maxBy(
+public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.maxBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivotGroupBy<T> = reduce { maxByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.maxBy(
+public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.maxBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = reduce { maxByOrNull(column, skipNaN) }
@@ -459,7 +456,7 @@ public fun <T> PivotGroupBy<T>.maxBy(column: String, skipNaN: Boolean = skipNaND
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.maxBy(
+public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.maxBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = maxBy(column.toColumnAccessor(), skipNaN)
@@ -476,26 +473,26 @@ public fun <T : Comparable<T>> DataColumn<T?>.max(): T = max(skipNaN = skipNaNDe
 public fun <T : Comparable<T>> DataColumn<T?>.maxOrNull(): T? = maxOrNull(skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxBy(noinline selector: (T) -> R): T =
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxBy(noinline selector: (T) -> R): T & Any =
     maxBy(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxByOrNull(noinline selector: (T) -> R): T? =
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxByOrNull(noinline selector: (T) -> R): T? =
     maxByOrNull(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxOf(crossinline selector: (T) -> R): R =
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxOf(crossinline selector: (T) -> R): R & Any =
     maxOf(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxOfOrNull(crossinline selector: (T) -> R): R? =
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxOfOrNull(crossinline selector: (T) -> R): R? =
     maxOfOrNull(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public inline fun <reified T : Comparable<T>> AnyRow.rowMaxOfOrNull(): T? = rowMaxOfOrNull<T>(skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <reified T : Comparable<T>> AnyRow.rowMaxOf(): T = rowMaxOf(skipNaN = skipNaNDefault)
+public inline fun <reified T : Comparable<T & Any>?> AnyRow.rowMaxOf(): T & Any = rowMaxOf(skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public fun <T> DataFrame<T>.max(): DataRow<T> = max(skipNaN = skipNaNDefault)
@@ -519,7 +516,7 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.maxFor(vararg columns: KProperty
     maxFor(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<*>?> DataFrame<T>.max(columns: ColumnsSelector<T, C>): C =
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(columns: ColumnsSelector<T, C>): C & Any =
     max(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -528,16 +525,16 @@ public fun <T> DataFrame<T>.max(vararg columns: String): Comparable<Any> =
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<*>?> DataFrame<T>.max(vararg columns: ColumnReference<C>): C =
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(vararg columns: ColumnReference<C>): C & Any =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<*>?> DataFrame<T>.max(vararg columns: KProperty<C>): C =
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(vararg columns: KProperty<C>): C & Any =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(columns: ColumnsSelector<T, C>): C? =
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(columns: ColumnsSelector<T, C>): C? =
     maxOrNull(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -546,25 +543,26 @@ public fun <T> DataFrame<T>.maxOrNull(vararg columns: String): Comparable<Any>?
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(vararg columns: ColumnReference<C>): C? =
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(vararg columns: ColumnReference<C>): C? =
     maxOrNull(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(vararg columns: KProperty<C>): C? =
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(vararg columns: KProperty<C>): C? =
     maxOrNull(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxOf(crossinline expression: RowExpression<T, C>): C =
-    maxOf(skipNaN = skipNaNDefault, expression = expression)
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxOf(
+    crossinline expression: RowExpression<T, C>,
+): C & Any = maxOf(skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxOfOrNull(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxOfOrNull(
     crossinline expression: RowExpression<T, C>,
 ): C? = maxOfOrNull(skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T> = maxBy(skipNaN = skipNaNDefault, expression = expression)
 
@@ -573,16 +571,16 @@ public fun <T> DataFrame<T>.maxBy(column: String): DataRow<T> = maxBy(column, sk
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(column: ColumnReference<C>): DataRow<T> =
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(column: ColumnReference<C>): DataRow<T> =
     maxBy(column, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(column: KProperty<C>): DataRow<T> =
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(column: KProperty<C>): DataRow<T> =
     maxBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T>? = maxByOrNull(skipNaN = skipNaNDefault, expression = expression)
 
@@ -591,12 +589,13 @@ public fun <T> DataFrame<T>.maxByOrNull(column: String): DataRow<T>? = maxByOrNu
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(column: ColumnReference<C>): DataRow<T>? =
-    maxByOrNull(column, skipNaN = skipNaNDefault)
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(
+    column: ColumnReference<C>,
+): DataRow<T>? = maxByOrNull(column, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(column: KProperty<C>): DataRow<T>? =
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(column: KProperty<C>): DataRow<T>? =
     maxByOrNull(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -621,7 +620,7 @@ public fun <T, C : Comparable<*>?> Grouped<T>.maxFor(vararg columns: KProperty<C
     maxFor(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<*>?> Grouped<T>.max(
+public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
     name: String? = null,
     columns: ColumnsSelector<T, C?>,
 ): DataFrame<T> = max(name, skipNaN = skipNaNDefault, columns = columns)
@@ -632,30 +631,32 @@ public fun <T> Grouped<T>.max(vararg columns: String, name: String? = null): Dat
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<*>?> Grouped<T>.max(
+public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
     vararg columns: ColumnReference<C>,
     name: String? = null,
 ): DataFrame<T> = max(columns = columns, name = name, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<*>?> Grouped<T>.max(vararg columns: KProperty<C>, name: String? = null): DataFrame<T> =
-    max(columns = columns, name = name, skipNaN = skipNaNDefault)
+public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
+    vararg columns: KProperty<C>,
+    name: String? = null,
+): DataFrame<T> = max(columns = columns, name = name, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> Grouped<T>.maxOf(
+public inline fun <T, reified C : Comparable<C & Any>?> Grouped<T>.maxOf(
     name: String? = null,
     crossinline expression: RowExpression<T, C>,
 ): DataFrame<T> = maxOf(name, skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.maxBy(
+public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.maxBy(
     crossinline rowExpression: RowExpression<G, R>,
 ): ReducedGroupBy<T, G> = maxBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.maxBy(
+public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.maxBy(
     column: ColumnReference<C>,
 ): ReducedGroupBy<T, G> = maxBy(column, skipNaN = skipNaNDefault)
 
@@ -664,8 +665,9 @@ public fun <T, G> GroupBy<T, G>.maxBy(column: String): ReducedGroupBy<T, G> = ma
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.maxBy(column: KProperty<C>): ReducedGroupBy<T, G> =
-    maxBy(column, skipNaN = skipNaNDefault)
+public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.maxBy(
+    column: KProperty<C>,
+): ReducedGroupBy<T, G> = maxBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public fun <T> Pivot<T>.max(separate: Boolean = false): DataRow<T> = max(separate, skipNaN = skipNaNDefault)
@@ -695,32 +697,32 @@ public fun <T, R : Comparable<*>?> Pivot<T>.maxFor(
 ): DataRow<T> = maxFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<*>?> Pivot<T>.max(columns: ColumnsSelector<T, R>): DataRow<T> =
+public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(columns: ColumnsSelector<T, R>): DataRow<T> =
     max(skipNaN = skipNaNDefault, columns = columns)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<*>?> Pivot<T>.max(vararg columns: ColumnReference<R>): DataRow<T> =
+public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(vararg columns: ColumnReference<R>): DataRow<T> =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<*>?> Pivot<T>.max(vararg columns: KProperty<R>): DataRow<T> =
+public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(vararg columns: KProperty<R>): DataRow<T> =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<*>?> Pivot<T>.maxOf(
+public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.maxOf(
     crossinline rowExpression: RowExpression<T, R>,
 ): DataRow<T> = maxOf(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<*>?> Pivot<T>.maxBy(
+public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.maxBy(
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivot<T> = maxBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> Pivot<T>.maxBy(column: ColumnReference<C>): ReducedPivot<T> =
+public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.maxBy(column: ColumnReference<C>): ReducedPivot<T> =
     maxBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -728,7 +730,7 @@ public fun <T> Pivot<T>.maxBy(column: String): ReducedPivot<T> = maxBy(column, s
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> Pivot<T>.maxBy(column: KProperty<C>): ReducedPivot<T> =
+public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.maxBy(column: KProperty<C>): ReducedPivot<T> =
     maxBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -759,7 +761,7 @@ public fun <T, R : Comparable<*>?> PivotGroupBy<T>.maxFor(
 ): DataFrame<T> = maxFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(columns: ColumnsSelector<T, R>): DataFrame<T> =
+public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(columns: ColumnsSelector<T, R>): DataFrame<T> =
     max(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -767,27 +769,27 @@ public fun <T> PivotGroupBy<T>.max(vararg columns: String): DataFrame<T> =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(vararg columns: ColumnReference<R>): DataFrame<T> =
+public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(vararg columns: ColumnReference<R>): DataFrame<T> =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(vararg columns: KProperty<R>): DataFrame<T> =
+public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(vararg columns: KProperty<R>): DataFrame<T> =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.maxOf(
+public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.maxOf(
     crossinline rowExpression: RowExpression<T, R>,
 ): DataFrame<T> = maxOf(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.maxBy(
+public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.maxBy(
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivotGroupBy<T> = maxBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.maxBy(
+public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.maxBy(
     column: ColumnReference<C>,
 ): ReducedPivotGroupBy<T> = maxBy(column, skipNaN = skipNaNDefault)
 
@@ -796,7 +798,8 @@ public fun <T> PivotGroupBy<T>.maxBy(column: String): ReducedPivotGroupBy<T> = m
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.maxBy(column: KProperty<C>): ReducedPivotGroupBy<T> =
-    maxBy(column, skipNaN = skipNaNDefault)
+public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.maxBy(
+    column: KProperty<C>,
+): ReducedPivotGroupBy<T> = maxBy(column, skipNaN = skipNaNDefault)
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt
index e790dece4d..576a17ea18 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt
@@ -15,8 +15,6 @@ import org.jetbrains.kotlinx.dataframe.annotations.Refine
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 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.aggregators.cast2
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.intraComparableColumns
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateByOrNull
@@ -49,58 +47,61 @@ import kotlin.reflect.KProperty
 
 // region DataColumn
 
-public fun <T : Comparable<*>?> DataColumn<T>.median(): T = medianOrNull().suggestIfNull("median")
+public fun <T : Comparable<T & Any>?> DataColumn<T>.median(): T & Any = medianOrNull().suggestIfNull("median")
 
-public fun <T : Comparable<*>?> DataColumn<T>.medianOrNull(): T? =
-    Aggregators.median(skipNaNDefault).cast<T>().aggregateSingleColumn(this)
+public fun <T : Comparable<T & Any>?> DataColumn<T>.medianOrNull(): T? =
+    Aggregators.medianComparables<T>().aggregateSingleColumn(this)
 
 public fun <T> DataColumn<T>.median(
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where T : Comparable<*>?, T : Number? = medianOrNull(skipNaN = skipNaN).suggestIfNull("median")
+    where T : Comparable<T & Any>?, T : Number? = medianOrNull(skipNaN = skipNaN).suggestIfNull("median")
 
 public fun <T> DataColumn<T>.medianOrNull(
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where T : Comparable<*>?, T : Number? =
-    Aggregators.median(skipNaN).cast2<T & Any, Double?>().aggregateSingleColumn(this)
+    where T : Comparable<T & Any>?, T : Number? =
+    Aggregators.medianNumbers<T>(skipNaN).aggregateSingleColumn(this)
 
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.medianBy(
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.medianBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T = medianByOrNull(skipNaN, selector).suggestIfNull("medianBy")
+): T & Any = medianByOrNull(skipNaN, selector).suggestIfNull("medianBy")
 
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.medianByOrNull(
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.medianByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T? = Aggregators.median(skipNaN).cast<R>().aggregateByOrNull(this, selector)
+): T? = Aggregators.medianCommon<R>(skipNaN).aggregateByOrNull(this, selector)
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.medianOf(crossinline expression: (T) -> R): R =
-    medianOfOrNull(expression).suggestIfNull("medianOf")
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.medianOf(
+    crossinline expression: (T) -> R,
+): R & Any = medianOfOrNull(expression).suggestIfNull("medianOf")
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.medianOfOrNull(crossinline expression: (T) -> R): R? =
-    Aggregators.median(skipNaNDefault).cast<R>().aggregateOf(this, expression)
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.medianOfOrNull(
+    crossinline expression: (T) -> R,
+): R? = Aggregators.medianComparables<R>().aggregateOf(this, expression)
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataColumn<T>.medianOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: (T) -> R,
 ): Double
-    where R : Comparable<*>?, R : Number? = medianOfOrNull(skipNaN, expression).suggestIfNull("medianOf")
+    where R : Comparable<R & Any>?, R : Number? =
+    medianOfOrNull(skipNaN, expression).suggestIfNull("medianOf")
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataColumn<T>.medianOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: (T) -> R,
 ): Double?
-    where R : Comparable<*>?, R : Number? =
-    Aggregators.median(skipNaN).cast2<R & Any, Double?>().aggregateOf(this, expression)
+    where R : Comparable<R & Any>?, R : Number? =
+    Aggregators.medianNumbers<R>(skipNaN).aggregateOf(this, expression)
 
 // endregion
 
@@ -163,21 +164,21 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.medianFor(
 
 // TODO, requires explicit type C due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public fun <T, C : Comparable<*>?> DataFrame<T>.median(columns: ColumnsSelector<T, C>): C =
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.median(columns: ColumnsSelector<T, C>): C & Any =
     medianOrNull(columns).suggestIfNull("median")
 
 // TODO, requires explicit type C due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
 @Suppress("UNCHECKED_CAST")
-public fun <T, C : Comparable<*>?> DataFrame<T>.medianOrNull(columns: ColumnsSelector<T, C>): C? =
-    Aggregators.median(skipNaNDefault).cast<C>().aggregateAll(this, columns)
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.medianOrNull(columns: ColumnsSelector<T, C>): C? =
+    Aggregators.medianComparables<C>().aggregateAll(this, columns)
 
 @OverloadResolutionByLambdaReturnType
 public fun <T, C> DataFrame<T>.median(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
 ): Double
-    where C : Number?, C : Comparable<*>? = medianOrNull(skipNaN, columns).suggestIfNull("median")
+    where C : Number?, C : Comparable<C & Any>? = medianOrNull(skipNaN, columns).suggestIfNull("median")
 
 @OverloadResolutionByLambdaReturnType
 @Suppress("UNCHECKED_CAST")
@@ -185,8 +186,8 @@ public fun <T, C> DataFrame<T>.medianOrNull(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
 ): Double?
-    where C : Comparable<*>?, C : Number? =
-    Aggregators.median(skipNaN).cast2<C & Any, Double?>().aggregateAll(this, columns)
+    where C : Comparable<C & Any>?, C : Number? =
+    Aggregators.medianNumbers<C>(skipNaN).aggregateAll(this, columns)
 
 public fun <T> DataFrame<T>.median(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Any =
     medianOrNull(*columns, skipNaN = skipNaN).suggestIfNull("median")
@@ -196,12 +197,12 @@ public fun <T> DataFrame<T>.medianOrNull(vararg columns: String, skipNaN: Boolea
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> DataFrame<T>.median(vararg columns: ColumnReference<C>): C =
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.median(vararg columns: ColumnReference<C>): C & Any =
     medianOrNull(*columns).suggestIfNull("median")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> DataFrame<T>.medianOrNull(vararg columns: ColumnReference<C>): C? =
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.medianOrNull(vararg columns: ColumnReference<C>): C? =
     medianOrNull<T, C> { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
@@ -210,7 +211,8 @@ public fun <T, C> DataFrame<T>.median(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where C : Comparable<*>?, C : Number? = medianOrNull(*columns, skipNaN = skipNaN).suggestIfNull("median")
+    where C : Comparable<C & Any>?, C : Number? =
+    medianOrNull(*columns, skipNaN = skipNaN).suggestIfNull("median")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
@@ -218,16 +220,16 @@ public fun <T, C> DataFrame<T>.medianOrNull(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where C : Comparable<*>?, C : Number? = medianOrNull(skipNaN) { columns.toColumnSet() }
+    where C : Comparable<C & Any>?, C : Number? = medianOrNull(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> DataFrame<T>.median(vararg columns: KProperty<C>): C =
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.median(vararg columns: KProperty<C>): C & Any =
     medianOrNull(*columns).suggestIfNull("median")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> DataFrame<T>.medianOrNull(vararg columns: KProperty<C>): C? =
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.medianOrNull(vararg columns: KProperty<C>): C? =
     medianOrNull<T, C> { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
@@ -236,7 +238,8 @@ public fun <T, C> DataFrame<T>.median(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where C : Comparable<*>?, C : Number? = medianOrNull(*columns, skipNaN = skipNaN).suggestIfNull("median")
+    where C : Comparable<C & Any>?, C : Number? =
+    medianOrNull(*columns, skipNaN = skipNaN).suggestIfNull("median")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
@@ -244,36 +247,37 @@ public fun <T, C> DataFrame<T>.medianOrNull(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where C : Comparable<*>?, C : Number? = medianOrNull(skipNaN) { columns.toColumnSet() }
+    where C : Comparable<C & Any>?, C : Number? = medianOrNull(skipNaN) { columns.toColumnSet() }
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<*>?> DataFrame<T>.medianOf(
+public inline fun <T, reified R : Comparable<R & Any>?> DataFrame<T>.medianOf(
     crossinline expression: RowExpression<T, R>,
-): R = medianOfOrNull(expression).suggestIfNull("medianOf")
+): R & Any = medianOfOrNull(expression).suggestIfNull("medianOf")
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<*>?> DataFrame<T>.medianOfOrNull(
+public inline fun <T, reified R : Comparable<R & Any>?> DataFrame<T>.medianOfOrNull(
     crossinline expression: RowExpression<T, R>,
-): R? = Aggregators.median(skipNaNDefault).cast<R>().aggregateOf(this, expression)
+): R? = Aggregators.medianComparables<R>().aggregateOf(this, expression)
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataFrame<T>.medianOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): Double
-    where R : Comparable<*>?, R : Number? = medianOfOrNull(skipNaN, expression).suggestIfNull("medianOf")
+    where R : Comparable<R & Any>?, R : Number? =
+    medianOfOrNull(skipNaN, expression).suggestIfNull("medianOf")
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataFrame<T>.medianOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): Double?
-    where R : Comparable<*>?, R : Number? =
-    Aggregators.median(skipNaN).cast2<R & Any, Double?>().aggregateOf(this, expression)
+    where R : Comparable<R & Any>?, R : Number? =
+    Aggregators.medianNumbers<R>(skipNaN).aggregateOf(this, expression)
 
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianBy(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T> = medianByOrNull(skipNaN, expression).suggestIfNull("medianBy")
@@ -283,36 +287,36 @@ public fun <T> DataFrame<T>.medianBy(column: String, skipNaN: Boolean = skipNaND
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianBy(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = medianByOrNull(column, skipNaN).suggestIfNull("medianBy")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianBy(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = medianByOrNull(column, skipNaN).suggestIfNull("medianBy")
 
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianByOrNull(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataRow<T>? = Aggregators.median(skipNaN).cast<C>().aggregateByOrNull(this, expression)
+): DataRow<T>? = Aggregators.medianCommon<C>(skipNaN).aggregateByOrNull(this, expression)
 
 public fun <T> DataFrame<T>.medianByOrNull(column: String, skipNaN: Boolean = skipNaNDefault): DataRow<T>? =
     medianByOrNull(column.toColumnOf<Comparable<Any>?>(), skipNaN)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianByOrNull(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianByOrNull(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): DataRow<T>? = Aggregators.median(skipNaN).cast<C>().aggregateByOrNull(this, column)
+): DataRow<T>? = Aggregators.medianCommon<C>(skipNaN).aggregateByOrNull(this, column)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianByOrNull(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianByOrNull(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T>? = medianByOrNull(column.toColumnAccessor(), skipNaN)
@@ -354,7 +358,7 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.median(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): DataFrame<T> = Aggregators.median(skipNaN).cast<C>().aggregateAll(this, name, columns)
+): DataFrame<T> = Aggregators.medianCommon<C>(skipNaN).aggregateAll(this, name, columns)
 
 public fun <T> Grouped<T>.median(
     vararg columns: String,
@@ -364,7 +368,7 @@ public fun <T> Grouped<T>.median(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> Grouped<T>.median(
+public fun <T, C : Comparable<C & Any>?> Grouped<T>.median(
     vararg columns: ColumnReference<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -372,7 +376,7 @@ public fun <T, C : Comparable<*>?> Grouped<T>.median(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> Grouped<T>.median(
+public fun <T, C : Comparable<C & Any>?> Grouped<T>.median(
     vararg columns: KProperty<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -380,21 +384,21 @@ public fun <T, C : Comparable<*>?> Grouped<T>.median(
 
 @Refine
 @Interpretable("GroupByMedianOf")
-public inline fun <T, reified R : Comparable<*>?> Grouped<T>.medianOf(
+public inline fun <T, reified R : Comparable<R & Any>?> Grouped<T>.medianOf(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
-): DataFrame<T> = Aggregators.median(skipNaN).cast<R>().aggregateOf(this, name, expression)
+): DataFrame<T> = Aggregators.medianCommon<R>(skipNaN).aggregateOf(this, name, expression)
 
 @Interpretable("GroupByReduceExpression") // TODO?
-public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.medianBy(
+public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.medianBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<G, R>,
 ): ReducedGroupBy<T, G> = reduce { medianByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.medianBy(
+public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.medianBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = reduce { medianByOrNull(column, skipNaN) }
@@ -404,7 +408,7 @@ public fun <T, G> GroupBy<T, G>.medianBy(column: String, skipNaN: Boolean = skip
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.medianBy(
+public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.medianBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = medianBy(column.toColumnAccessor(), skipNaN)
@@ -444,7 +448,7 @@ public fun <T, C : Comparable<*>?> Pivot<T>.medianFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = medianFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<*>?> Pivot<T>.median(
+public fun <T, C : Comparable<C & Any>?> Pivot<T>.median(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
 ): DataRow<T> = delegate { median(skipNaN, columns) }
@@ -454,31 +458,31 @@ public fun <T> Pivot<T>.median(vararg columns: String, skipNaN: Boolean = skipNa
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> Pivot<T>.median(
+public fun <T, C : Comparable<C & Any>?> Pivot<T>.median(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = median(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> Pivot<T>.median(
+public fun <T, C : Comparable<C & Any>?> Pivot<T>.median(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = median(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<*>?> Pivot<T>.medianOf(
+public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.medianOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): DataRow<T> = delegate { medianOf(skipNaN, expression) }
 
-public inline fun <T, reified R : Comparable<*>?> Pivot<T>.medianBy(
+public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.medianBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivot<T> = reduce { medianByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> Pivot<T>.medianBy(
+public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.medianBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = reduce { medianByOrNull(column, skipNaN) }
@@ -488,7 +492,7 @@ public fun <T> Pivot<T>.medianBy(column: String, skipNaN: Boolean = skipNaNDefau
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> Pivot<T>.medianBy(
+public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.medianBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = medianBy(column.toColumnAccessor(), skipNaN)
@@ -527,41 +531,41 @@ public fun <T, C : Comparable<*>?> PivotGroupBy<T>.medianFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = medianFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<*>?> PivotGroupBy<T>.median(
+public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.median(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): DataFrame<T> = Aggregators.median(skipNaN).cast<C>().aggregateAll(this, columns)
+): DataFrame<T> = Aggregators.medianCommon<C>(skipNaN).aggregateAll(this, columns)
 
 public fun <T> PivotGroupBy<T>.median(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T> =
     median(skipNaN) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> PivotGroupBy<T>.median(
+public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.median(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = median(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> PivotGroupBy<T>.median(
+public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.median(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = median(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.medianOf(
+public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.medianOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
-): DataFrame<T> = Aggregators.median(skipNaN).cast<R>().aggregateOf(this, expression)
+): DataFrame<T> = Aggregators.medianCommon<R>(skipNaN).aggregateOf(this, expression)
 
-public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.medianBy(
+public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.medianBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivotGroupBy<T> = reduce { medianByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.medianBy(
+public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.medianBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = reduce { medianByOrNull(column, skipNaN) }
@@ -571,7 +575,7 @@ public fun <T> PivotGroupBy<T>.medianBy(column: String, skipNaN: Boolean = skipN
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.medianBy(
+public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.medianBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = medianBy(column.toColumnAccessor(), skipNaN)
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt
index 6621497f27..6246e7205c 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt
@@ -13,7 +13,6 @@ import org.jetbrains.kotlinx.dataframe.annotations.Refine
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 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.intraComparableColumns
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateByOrNull
@@ -36,25 +35,25 @@ public fun <T : Comparable<T>> DataColumn<T?>.min(skipNaN: Boolean = skipNaNDefa
 public fun <T : Comparable<T>> DataColumn<T?>.minOrNull(skipNaN: Boolean = skipNaNDefault): T? =
     Aggregators.min<T>(skipNaN).aggregateSingleColumn(this)
 
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minBy(
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T = minByOrNull(skipNaN, selector).suggestIfNull("minBy")
+): T & Any = minByOrNull(skipNaN, selector).suggestIfNull("minBy")
 
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minByOrNull(
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T? = Aggregators.min.invoke(skipNaN).cast<R>().aggregateByOrNull(this, selector)
+): T? = Aggregators.min<R>(skipNaN).aggregateByOrNull(this, selector)
 
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minOf(
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): R = minOfOrNull(skipNaN, selector).suggestIfNull("minOf")
+): R & Any = minOfOrNull(skipNaN, selector).suggestIfNull("minOf")
 
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minOfOrNull(
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): R? = Aggregators.min.invoke(skipNaN).cast<R>().aggregateOf(this, selector)
+): R? = Aggregators.min<R>(skipNaN).aggregateOf(this, selector)
 
 // endregion
 
@@ -104,61 +103,61 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.minFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = minFor(skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<*>?> DataFrame<T>.min(
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): C = minOrNull(skipNaN, columns).suggestIfNull("min")
+): C & Any = minOrNull(skipNaN, columns).suggestIfNull("min")
 
 public fun <T> DataFrame<T>.min(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Comparable<Any> =
     minOrNull(*columns, skipNaN = skipNaN).suggestIfNull("min")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> DataFrame<T>.min(
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): C = minOrNull(*columns, skipNaN = skipNaN).suggestIfNull("min")
+): C & Any = minOrNull(*columns, skipNaN = skipNaN).suggestIfNull("min")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> DataFrame<T>.min(
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
-): C = minOrNull(*columns, skipNaN = skipNaN).suggestIfNull("min")
+): C & Any = minOrNull(*columns, skipNaN = skipNaN).suggestIfNull("min")
 
-public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): C? = Aggregators.min.invoke(skipNaN).cast<C>().aggregateAll(this, columns)
+): C? = Aggregators.min<C>(skipNaN).aggregateAll(this, columns)
 
 public fun <T> DataFrame<T>.minOrNull(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Comparable<Any>? =
     minOrNull(skipNaN) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): C? = minOrNull(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): C? = minOrNull(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minOf(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): C = minOfOrNull(skipNaN, expression).suggestIfNull("minOf")
+): C & Any = minOfOrNull(skipNaN, expression).suggestIfNull("minOf")
 
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minOfOrNull(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): C? = Aggregators.min.invoke(skipNaN).cast<C>().aggregateOf(this, expression)
+): C? = Aggregators.min<C>(skipNaN).aggregateOf(this, expression)
 
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T> = minByOrNull(skipNaN, expression).suggestIfNull("minBy")
@@ -168,36 +167,36 @@ public fun <T> DataFrame<T>.minBy(column: String, skipNaN: Boolean = skipNaNDefa
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = minByOrNull(column, skipNaN).suggestIfNull("minBy")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = minByOrNull(column, skipNaN).suggestIfNull("minBy")
 
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataRow<T>? = Aggregators.min.invoke(skipNaN).cast<C>().aggregateByOrNull(this, expression)
+): DataRow<T>? = Aggregators.min<C>(skipNaN).aggregateByOrNull(this, expression)
 
 public fun <T> DataFrame<T>.minByOrNull(column: String, skipNaN: Boolean = skipNaNDefault): DataRow<T>? =
     minByOrNull(column.toColumnOf<Comparable<Any>?>(), skipNaN)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): DataRow<T>? = Aggregators.min.invoke(skipNaN).cast<C>().aggregateByOrNull(this, column)
+): DataRow<T>? = Aggregators.min<C>(skipNaN).aggregateByOrNull(this, column)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T>? = minByOrNull(column.toColumnAccessor(), skipNaN)
@@ -241,7 +240,7 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C?>,
-): DataFrame<T> = Aggregators.min.invoke(skipNaN).cast<C>().aggregateAll(this, name, columns)
+): DataFrame<T> = Aggregators.min<C>(skipNaN).aggregateAll(this, name, columns)
 
 public fun <T> Grouped<T>.min(
     vararg columns: String,
@@ -251,7 +250,7 @@ public fun <T> Grouped<T>.min(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> Grouped<T>.min(
+public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
     vararg columns: ColumnReference<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -259,7 +258,7 @@ public fun <T, C : Comparable<*>?> Grouped<T>.min(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> Grouped<T>.min(
+public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
     vararg columns: KProperty<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -267,21 +266,21 @@ public fun <T, C : Comparable<*>?> Grouped<T>.min(
 
 @Refine
 @Interpretable("GroupByMinOf")
-public inline fun <T, reified C : Comparable<*>?> Grouped<T>.minOf(
+public inline fun <T, reified C : Comparable<C & Any>?> Grouped<T>.minOf(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataFrame<T> = Aggregators.min.invoke(skipNaN).cast<C>().aggregateOf(this, name, expression)
+): DataFrame<T> = Aggregators.min<C>(skipNaN).aggregateOf(this, name, expression)
 
 @Interpretable("GroupByReduceExpression")
-public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.minBy(
+public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.minBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<G, R>,
 ): ReducedGroupBy<T, G> = reduce { minByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.minBy(
+public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.minBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = reduce { minByOrNull(column, skipNaN) }
@@ -291,7 +290,7 @@ public fun <T, G> GroupBy<T, G>.minBy(column: String, skipNaN: Boolean = skipNaN
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.minBy(
+public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.minBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = minBy(column.toColumnAccessor(), skipNaN)
@@ -331,7 +330,7 @@ public fun <T, R : Comparable<*>?> Pivot<T>.minFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = minFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, R : Comparable<*>?> Pivot<T>.min(
+public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, R>,
 ): DataRow<T> = delegate { min(skipNaN, columns) }
@@ -341,31 +340,31 @@ public fun <T> Pivot<T>.min(vararg columns: String, skipNaN: Boolean = skipNaNDe
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<*>?> Pivot<T>.min(
+public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(
     vararg columns: ColumnReference<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = min(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<*>?> Pivot<T>.min(
+public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(
     vararg columns: KProperty<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = min(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<*>?> Pivot<T>.minOf(
+public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.minOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): DataRow<T> = delegate { minOf(skipNaN, rowExpression) }
 
-public inline fun <T, reified R : Comparable<*>?> Pivot<T>.minBy(
+public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.minBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivot<T> = reduce { minByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> Pivot<T>.minBy(
+public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.minBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = reduce { minByOrNull(column, skipNaN) }
@@ -375,7 +374,7 @@ public fun <T> Pivot<T>.minBy(column: String, skipNaN: Boolean = skipNaNDefault)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> Pivot<T>.minBy(
+public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.minBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = minBy(column.toColumnAccessor(), skipNaN)
@@ -415,39 +414,39 @@ public fun <T, R : Comparable<*>?> PivotGroupBy<T>.minFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = minFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(
+public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, R>,
-): DataFrame<T> = Aggregators.min.invoke(skipNaN).cast<R>().aggregateAll(this, columns)
+): DataFrame<T> = Aggregators.min<R>(skipNaN).aggregateAll(this, columns)
 
 public fun <T> PivotGroupBy<T>.min(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T> =
     min(skipNaN) { columns.toComparableColumns() }
 
-public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(
+public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(
     vararg columns: ColumnReference<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = min(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(
+public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(
     vararg columns: KProperty<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = min(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.minOf(
+public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.minOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): DataFrame<T> = aggregate { minOf(skipNaN, rowExpression) }
 
-public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.minBy(
+public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.minBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivotGroupBy<T> = reduce { minByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.minBy(
+public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.minBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = reduce { minByOrNull(column, skipNaN) }
@@ -457,7 +456,7 @@ public fun <T> PivotGroupBy<T>.minBy(column: String, skipNaN: Boolean = skipNaND
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.minBy(
+public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.minBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = minBy(column.toColumnAccessor(), skipNaN)
@@ -474,26 +473,26 @@ public fun <T : Comparable<T>> DataColumn<T?>.min(): T = min(skipNaN = skipNaNDe
 public fun <T : Comparable<T>> DataColumn<T?>.minOrNull(): T? = minOrNull(skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minBy(noinline selector: (T) -> R): T =
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minBy(noinline selector: (T) -> R): T & Any =
     minBy(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minByOrNull(noinline selector: (T) -> R): T? =
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minByOrNull(noinline selector: (T) -> R): T? =
     minByOrNull(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minOf(crossinline selector: (T) -> R): R =
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minOf(crossinline selector: (T) -> R): R & Any =
     minOf(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minOfOrNull(crossinline selector: (T) -> R): R? =
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minOfOrNull(crossinline selector: (T) -> R): R? =
     minOfOrNull(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public inline fun <reified T : Comparable<T>> AnyRow.rowMinOfOrNull(): T? = rowMinOfOrNull<T>(skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <reified T : Comparable<T>> AnyRow.rowMinOf(): T = rowMinOf(skipNaN = skipNaNDefault)
+public inline fun <reified T : Comparable<T & Any>?> AnyRow.rowMinOf(): T & Any = rowMinOf(skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public fun <T> DataFrame<T>.min(): DataRow<T> = min(skipNaN = skipNaNDefault)
@@ -517,7 +516,7 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.minFor(vararg columns: KProperty
     minFor(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<*>?> DataFrame<T>.min(columns: ColumnsSelector<T, C>): C =
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(columns: ColumnsSelector<T, C>): C & Any =
     min(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -526,16 +525,16 @@ public fun <T> DataFrame<T>.min(vararg columns: String): Comparable<Any> =
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<*>?> DataFrame<T>.min(vararg columns: ColumnReference<C>): C =
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(vararg columns: ColumnReference<C>): C & Any =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<*>?> DataFrame<T>.min(vararg columns: KProperty<C>): C =
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(vararg columns: KProperty<C>): C & Any =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(columns: ColumnsSelector<T, C>): C? =
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(columns: ColumnsSelector<T, C>): C? =
     minOrNull(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -544,25 +543,26 @@ public fun <T> DataFrame<T>.minOrNull(vararg columns: String): Comparable<Any>?
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(vararg columns: ColumnReference<C>): C? =
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(vararg columns: ColumnReference<C>): C? =
     minOrNull(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(vararg columns: KProperty<C>): C? =
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(vararg columns: KProperty<C>): C? =
     minOrNull(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minOf(crossinline expression: RowExpression<T, C>): C =
-    minOf(skipNaN = skipNaNDefault, expression = expression)
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minOf(
+    crossinline expression: RowExpression<T, C>,
+): C & Any = minOf(skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minOfOrNull(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minOfOrNull(
     crossinline expression: RowExpression<T, C>,
 ): C? = minOfOrNull(skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T> = minBy(skipNaN = skipNaNDefault, expression = expression)
 
@@ -571,16 +571,16 @@ public fun <T> DataFrame<T>.minBy(column: String): DataRow<T> = minBy(column, sk
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(column: ColumnReference<C>): DataRow<T> =
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(column: ColumnReference<C>): DataRow<T> =
     minBy(column, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(column: KProperty<C>): DataRow<T> =
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(column: KProperty<C>): DataRow<T> =
     minBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T>? = minByOrNull(skipNaN = skipNaNDefault, expression = expression)
 
@@ -589,12 +589,13 @@ public fun <T> DataFrame<T>.minByOrNull(column: String): DataRow<T>? = minByOrNu
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(column: ColumnReference<C>): DataRow<T>? =
-    minByOrNull(column, skipNaN = skipNaNDefault)
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(
+    column: ColumnReference<C>,
+): DataRow<T>? = minByOrNull(column, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(column: KProperty<C>): DataRow<T>? =
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(column: KProperty<C>): DataRow<T>? =
     minByOrNull(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -619,7 +620,7 @@ public fun <T, C : Comparable<*>?> Grouped<T>.minFor(vararg columns: KProperty<C
     minFor(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<*>?> Grouped<T>.min(
+public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
     name: String? = null,
     columns: ColumnsSelector<T, C?>,
 ): DataFrame<T> = min(name, skipNaN = skipNaNDefault, columns = columns)
@@ -630,30 +631,32 @@ public fun <T> Grouped<T>.min(vararg columns: String, name: String? = null): Dat
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<*>?> Grouped<T>.min(
+public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
     vararg columns: ColumnReference<C>,
     name: String? = null,
 ): DataFrame<T> = min(columns = columns, name = name, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<*>?> Grouped<T>.min(vararg columns: KProperty<C>, name: String? = null): DataFrame<T> =
-    min(columns = columns, name = name, skipNaN = skipNaNDefault)
+public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
+    vararg columns: KProperty<C>,
+    name: String? = null,
+): DataFrame<T> = min(columns = columns, name = name, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> Grouped<T>.minOf(
+public inline fun <T, reified C : Comparable<C & Any>?> Grouped<T>.minOf(
     name: String? = null,
     crossinline expression: RowExpression<T, C>,
 ): DataFrame<T> = minOf(name, skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.minBy(
+public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.minBy(
     crossinline rowExpression: RowExpression<G, R>,
 ): ReducedGroupBy<T, G> = minBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.minBy(
+public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.minBy(
     column: ColumnReference<C>,
 ): ReducedGroupBy<T, G> = minBy(column, skipNaN = skipNaNDefault)
 
@@ -662,8 +665,9 @@ public fun <T, G> GroupBy<T, G>.minBy(column: String): ReducedGroupBy<T, G> = mi
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.minBy(column: KProperty<C>): ReducedGroupBy<T, G> =
-    minBy(column, skipNaN = skipNaNDefault)
+public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.minBy(
+    column: KProperty<C>,
+): ReducedGroupBy<T, G> = minBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public fun <T> Pivot<T>.min(separate: Boolean = false): DataRow<T> = min(separate, skipNaN = skipNaNDefault)
@@ -693,32 +697,32 @@ public fun <T, R : Comparable<*>?> Pivot<T>.minFor(
 ): DataRow<T> = minFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<*>?> Pivot<T>.min(columns: ColumnsSelector<T, R>): DataRow<T> =
+public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(columns: ColumnsSelector<T, R>): DataRow<T> =
     min(skipNaN = skipNaNDefault, columns = columns)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<*>?> Pivot<T>.min(vararg columns: ColumnReference<R>): DataRow<T> =
+public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(vararg columns: ColumnReference<R>): DataRow<T> =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<*>?> Pivot<T>.min(vararg columns: KProperty<R>): DataRow<T> =
+public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(vararg columns: KProperty<R>): DataRow<T> =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<*>?> Pivot<T>.minOf(
+public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.minOf(
     crossinline rowExpression: RowExpression<T, R>,
 ): DataRow<T> = minOf(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<*>?> Pivot<T>.minBy(
+public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.minBy(
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivot<T> = minBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> Pivot<T>.minBy(column: ColumnReference<C>): ReducedPivot<T> =
+public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.minBy(column: ColumnReference<C>): ReducedPivot<T> =
     minBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -726,7 +730,7 @@ public fun <T> Pivot<T>.minBy(column: String): ReducedPivot<T> = minBy(column, s
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> Pivot<T>.minBy(column: KProperty<C>): ReducedPivot<T> =
+public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.minBy(column: KProperty<C>): ReducedPivot<T> =
     minBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -757,7 +761,7 @@ public fun <T, R : Comparable<*>?> PivotGroupBy<T>.minFor(
 ): DataFrame<T> = minFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(columns: ColumnsSelector<T, R>): DataFrame<T> =
+public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(columns: ColumnsSelector<T, R>): DataFrame<T> =
     min(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -765,27 +769,27 @@ public fun <T> PivotGroupBy<T>.min(vararg columns: String): DataFrame<T> =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(vararg columns: ColumnReference<R>): DataFrame<T> =
+public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(vararg columns: ColumnReference<R>): DataFrame<T> =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(vararg columns: KProperty<R>): DataFrame<T> =
+public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(vararg columns: KProperty<R>): DataFrame<T> =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.minOf(
+public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.minOf(
     crossinline rowExpression: RowExpression<T, R>,
 ): DataFrame<T> = minOf(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.minBy(
+public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.minBy(
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivotGroupBy<T> = minBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.minBy(
+public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.minBy(
     column: ColumnReference<C>,
 ): ReducedPivotGroupBy<T> = minBy(column, skipNaN = skipNaNDefault)
 
@@ -794,7 +798,8 @@ public fun <T> PivotGroupBy<T>.minBy(column: String): ReducedPivotGroupBy<T> = m
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.minBy(column: KProperty<C>): ReducedPivotGroupBy<T> =
-    minBy(column, skipNaN = skipNaNDefault)
+public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.minBy(
+    column: KProperty<C>,
+): ReducedPivotGroupBy<T> = minBy(column, skipNaN = skipNaNDefault)
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/percentile.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/percentile.kt
index 76e22c6847..be666a8448 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/percentile.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/percentile.kt
@@ -15,8 +15,6 @@ import org.jetbrains.kotlinx.dataframe.annotations.Refine
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 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.aggregators.cast2
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.intraComparableColumns
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateByOrNull
@@ -50,53 +48,53 @@ import kotlin.reflect.KProperty
 
 // region DataColumn
 
-public fun <T : Comparable<*>?> DataColumn<T>.percentile(percentile: Double): T =
+public fun <T : Comparable<T & Any>?> DataColumn<T>.percentile(percentile: Double): T & Any =
     percentileOrNull(percentile).suggestIfNull("percentile")
 
-public fun <T : Comparable<*>?> DataColumn<T>.percentileOrNull(percentile: Double): T? =
-    Aggregators.percentile(percentile, skipNaNDefault).cast<T>().aggregateSingleColumn(this)
+public fun <T : Comparable<T & Any>?> DataColumn<T>.percentileOrNull(percentile: Double): T? =
+    Aggregators.percentileComparables<T>(percentile).aggregateSingleColumn(this)
 
 public fun <T> DataColumn<T>.percentile(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where T : Comparable<*>?, T : Number? =
+    where T : Comparable<T & Any>?, T : Number? =
     percentileOrNull(percentile = percentile, skipNaN = skipNaN).suggestIfNull("percentile")
 
 public fun <T> DataColumn<T>.percentileOrNull(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where T : Comparable<*>?, T : Number? =
-    Aggregators.percentile(percentile, skipNaN).cast2<T & Any, Double?>().aggregateSingleColumn(this)
+    where T : Comparable<T & Any>?, T : Number? =
+    Aggregators.percentileNumbers<T>(percentile, skipNaN).aggregateSingleColumn(this)
 
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.percentileBy(
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.percentileBy(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T = percentileByOrNull(percentile, skipNaN, selector).suggestIfNull("percentileBy")
+): T & Any = percentileByOrNull(percentile, skipNaN, selector).suggestIfNull("percentileBy")
 
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.percentileByOrNull(
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.percentileByOrNull(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T? = Aggregators.percentile(percentile, skipNaN).cast<R>().aggregateByOrNull(this, selector)
+): T? = Aggregators.percentileCommon<R>(percentile, skipNaN).aggregateByOrNull(this, selector)
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.percentileOf(
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.percentileOf(
     percentile: Double,
     crossinline expression: (T) -> R,
-): R = percentileOfOrNull(percentile, expression).suggestIfNull("percentileOf")
+): R & Any = percentileOfOrNull(percentile, expression).suggestIfNull("percentileOf")
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.percentileOfOrNull(
+public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.percentileOfOrNull(
     percentile: Double,
     crossinline expression: (T) -> R,
-): R? = Aggregators.percentile(percentile, skipNaNDefault).cast<R>().aggregateOf(this, expression)
+): R? = Aggregators.percentileComparables<R>(percentile).aggregateOf(this, expression)
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataColumn<T>.percentileOf(
@@ -104,7 +102,7 @@ public inline fun <T, reified R> DataColumn<T>.percentileOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: (T) -> R,
 ): Double
-    where R : Comparable<*>?, R : Number? =
+    where R : Comparable<R & Any>?, R : Number? =
     percentileOfOrNull(percentile, skipNaN, expression).suggestIfNull("percentileOf")
 
 @OverloadResolutionByLambdaReturnType
@@ -113,8 +111,8 @@ public inline fun <T, reified R> DataColumn<T>.percentileOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: (T) -> R,
 ): Double?
-    where R : Comparable<*>?, R : Number? =
-    Aggregators.percentile(percentile, skipNaN).cast2<R & Any, Double?>().aggregateOf(this, expression)
+    where R : Comparable<R & Any>?, R : Number? =
+    Aggregators.percentileNumbers<R>(percentile, skipNaN).aggregateOf(this, expression)
 
 // endregion
 
@@ -186,16 +184,18 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.percentileFor(
 
 // TODO, requires explicit type C due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public fun <T, C : Comparable<*>?> DataFrame<T>.percentile(percentile: Double, columns: ColumnsSelector<T, C>): C =
-    percentileOrNull(percentile, columns).suggestIfNull("percentile")
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentile(
+    percentile: Double,
+    columns: ColumnsSelector<T, C>,
+): C & Any = percentileOrNull(percentile, columns).suggestIfNull("percentile")
 
 // TODO, requires explicit type C due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
 @Suppress("UNCHECKED_CAST")
-public fun <T, C : Comparable<*>?> DataFrame<T>.percentileOrNull(
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentileOrNull(
     percentile: Double,
     columns: ColumnsSelector<T, C>,
-): C? = Aggregators.percentile(percentile, skipNaNDefault).cast<C>().aggregateAll(this, columns)
+): C? = Aggregators.percentileComparables<C>(percentile).aggregateAll(this, columns)
 
 @OverloadResolutionByLambdaReturnType
 public fun <T, C> DataFrame<T>.percentile(
@@ -203,7 +203,7 @@ public fun <T, C> DataFrame<T>.percentile(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
 ): Double
-    where C : Number?, C : Comparable<*>? =
+    where C : Number?, C : Comparable<C & Any>? =
     percentileOrNull(percentile, skipNaN, columns).suggestIfNull("percentile")
 
 @OverloadResolutionByLambdaReturnType
@@ -213,8 +213,8 @@ public fun <T, C> DataFrame<T>.percentileOrNull(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
 ): Double?
-    where C : Comparable<*>?, C : Number? =
-    Aggregators.percentile(percentile, skipNaN).cast2<C & Any, Double?>().aggregateAll(this, columns)
+    where C : Comparable<C & Any>?, C : Number? =
+    Aggregators.percentileNumbers<C>(percentile, skipNaN).aggregateAll(this, columns)
 
 public fun <T> DataFrame<T>.percentile(
     percentile: Double,
@@ -231,12 +231,14 @@ public fun <T> DataFrame<T>.percentileOrNull(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> DataFrame<T>.percentile(percentile: Double, vararg columns: ColumnReference<C>): C =
-    percentileOrNull(percentile, *columns).suggestIfNull("percentile")
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentile(
+    percentile: Double,
+    vararg columns: ColumnReference<C>,
+): C & Any = percentileOrNull(percentile, *columns).suggestIfNull("percentile")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> DataFrame<T>.percentileOrNull(
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentileOrNull(
     percentile: Double,
     vararg columns: ColumnReference<C>,
 ): C? = percentileOrNull<T, C>(percentile) { columns.toColumnSet() }
@@ -248,7 +250,7 @@ public fun <T, C> DataFrame<T>.percentile(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where C : Comparable<*>?, C : Number? =
+    where C : Comparable<C & Any>?, C : Number? =
     percentileOrNull(percentile, *columns, skipNaN = skipNaN).suggestIfNull("percentile")
 
 @Deprecated(DEPRECATED_ACCESS_API)
@@ -258,16 +260,19 @@ public fun <T, C> DataFrame<T>.percentileOrNull(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where C : Comparable<*>?, C : Number? = percentileOrNull(percentile, skipNaN) { columns.toColumnSet() }
+    where C : Comparable<C & Any>?, C : Number? =
+    percentileOrNull(percentile, skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> DataFrame<T>.percentile(percentile: Double, vararg columns: KProperty<C>): C =
-    percentileOrNull(percentile, *columns).suggestIfNull("percentile")
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentile(
+    percentile: Double,
+    vararg columns: KProperty<C>,
+): C & Any = percentileOrNull(percentile, *columns).suggestIfNull("percentile")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> DataFrame<T>.percentileOrNull(
+public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentileOrNull(
     percentile: Double,
     vararg columns: KProperty<C>,
 ): C? = percentileOrNull<T, C>(percentile) { columns.toColumnSet() }
@@ -279,7 +284,7 @@ public fun <T, C> DataFrame<T>.percentile(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where C : Comparable<*>?, C : Number? =
+    where C : Comparable<C & Any>?, C : Number? =
     percentileOrNull(percentile, *columns, skipNaN = skipNaN).suggestIfNull("percentile")
 
 @Deprecated(DEPRECATED_ACCESS_API)
@@ -289,21 +294,22 @@ public fun <T, C> DataFrame<T>.percentileOrNull(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where C : Comparable<*>?, C : Number? = percentileOrNull(percentile, skipNaN) { columns.toColumnSet() }
+    where C : Comparable<C & Any>?, C : Number? =
+    percentileOrNull(percentile, skipNaN) { columns.toColumnSet() }
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<*>?> DataFrame<T>.percentileOf(
+public inline fun <T, reified R : Comparable<R & Any>?> DataFrame<T>.percentileOf(
     percentile: Double,
     crossinline expression: RowExpression<T, R>,
-): R = percentileOfOrNull(percentile, expression).suggestIfNull("percentileOf")
+): R & Any = percentileOfOrNull(percentile, expression).suggestIfNull("percentileOf")
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<*>?> DataFrame<T>.percentileOfOrNull(
+public inline fun <T, reified R : Comparable<R & Any>?> DataFrame<T>.percentileOfOrNull(
     percentile: Double,
     crossinline expression: RowExpression<T, R>,
-): R? = Aggregators.percentile(percentile, skipNaNDefault).cast<R>().aggregateOf(this, expression)
+): R? = Aggregators.percentileComparables<R>(percentile).aggregateOf(this, expression)
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataFrame<T>.percentileOf(
@@ -311,7 +317,7 @@ public inline fun <T, reified R> DataFrame<T>.percentileOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): Double
-    where R : Comparable<*>?, R : Number? =
+    where R : Comparable<R & Any>?, R : Number? =
     percentileOfOrNull(percentile, skipNaN, expression).suggestIfNull("percentileOf")
 
 @OverloadResolutionByLambdaReturnType
@@ -320,10 +326,10 @@ public inline fun <T, reified R> DataFrame<T>.percentileOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): Double?
-    where R : Comparable<*>?, R : Number? =
-    Aggregators.percentile(percentile, skipNaN).cast2<R & Any, Double?>().aggregateOf(this, expression)
+    where R : Comparable<R & Any>?, R : Number? =
+    Aggregators.percentileNumbers<R>(percentile, skipNaN).aggregateOf(this, expression)
 
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileBy(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileBy(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
@@ -337,7 +343,7 @@ public fun <T> DataFrame<T>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileBy(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileBy(
     percentile: Double,
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -345,17 +351,17 @@ public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileBy(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileBy(
     percentile: Double,
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = percentileByOrNull(percentile, column, skipNaN).suggestIfNull("percentileBy")
 
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileByOrNull(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileByOrNull(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataRow<T>? = Aggregators.percentile(percentile, skipNaN).cast<C>().aggregateByOrNull(this, expression)
+): DataRow<T>? = Aggregators.percentileCommon<C>(percentile, skipNaN).aggregateByOrNull(this, expression)
 
 public fun <T> DataFrame<T>.percentileByOrNull(
     percentile: Double,
@@ -365,15 +371,15 @@ public fun <T> DataFrame<T>.percentileByOrNull(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileByOrNull(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileByOrNull(
     percentile: Double,
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): DataRow<T>? = Aggregators.percentile(percentile, skipNaN).cast<C>().aggregateByOrNull(this, column)
+): DataRow<T>? = Aggregators.percentileCommon<C>(percentile, skipNaN).aggregateByOrNull(this, column)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileByOrNull(
+public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileByOrNull(
     percentile: Double,
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -421,7 +427,7 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): DataFrame<T> = Aggregators.percentile(percentile, skipNaN).cast<C>().aggregateAll(this, name, columns)
+): DataFrame<T> = Aggregators.percentileCommon<C>(percentile, skipNaN).aggregateAll(this, name, columns)
 
 public fun <T> Grouped<T>.percentile(
     percentile: Double,
@@ -432,7 +438,7 @@ public fun <T> Grouped<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> Grouped<T>.percentile(
+public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(
     percentile: Double,
     vararg columns: ColumnReference<C>,
     name: String? = null,
@@ -441,7 +447,7 @@ public fun <T, C : Comparable<*>?> Grouped<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> Grouped<T>.percentile(
+public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(
     percentile: Double,
     vararg columns: KProperty<C>,
     name: String? = null,
@@ -450,15 +456,15 @@ public fun <T, C : Comparable<*>?> Grouped<T>.percentile(
 
 @Refine
 @Interpretable("GroupByPercentileOf")
-public inline fun <T, reified R : Comparable<*>?> Grouped<T>.percentileOf(
+public inline fun <T, reified R : Comparable<R & Any>?> Grouped<T>.percentileOf(
     percentile: Double,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
-): DataFrame<T> = Aggregators.percentile(percentile, skipNaN).cast<R>().aggregateOf(this, name, expression)
+): DataFrame<T> = Aggregators.percentileCommon<R>(percentile, skipNaN).aggregateOf(this, name, expression)
 
 @Interpretable("GroupByReduceExpression") // TODO?
-public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.percentileBy(
+public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.percentileBy(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<G, R>,
@@ -466,7 +472,7 @@ public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.percentileBy(
+public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.percentileBy(
     percentile: Double,
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -480,7 +486,7 @@ public fun <T, G> GroupBy<T, G>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.percentileBy(
+public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.percentileBy(
     percentile: Double,
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -528,7 +534,7 @@ public fun <T, C : Comparable<*>?> Pivot<T>.percentileFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = percentileFor(percentile, separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<*>?> Pivot<T>.percentile(
+public fun <T, C : Comparable<C & Any>?> Pivot<T>.percentile(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
@@ -542,7 +548,7 @@ public fun <T> Pivot<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> Pivot<T>.percentile(
+public fun <T, C : Comparable<C & Any>?> Pivot<T>.percentile(
     percentile: Double,
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -550,19 +556,19 @@ public fun <T, C : Comparable<*>?> Pivot<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> Pivot<T>.percentile(
+public fun <T, C : Comparable<C & Any>?> Pivot<T>.percentile(
     percentile: Double,
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = percentile(percentile, skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<*>?> Pivot<T>.percentileOf(
+public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.percentileOf(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): DataRow<T> = delegate { percentileOf(percentile, skipNaN, expression) }
 
-public inline fun <T, reified R : Comparable<*>?> Pivot<T>.percentileBy(
+public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.percentileBy(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
@@ -570,7 +576,7 @@ public inline fun <T, reified R : Comparable<*>?> Pivot<T>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> Pivot<T>.percentileBy(
+public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.percentileBy(
     percentile: Double,
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -584,7 +590,7 @@ public fun <T> Pivot<T>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> Pivot<T>.percentileBy(
+public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.percentileBy(
     percentile: Double,
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -631,11 +637,11 @@ public fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentileFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = percentileFor(percentile, separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentile(
+public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.percentile(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): DataFrame<T> = Aggregators.percentile(percentile, skipNaN).cast<C>().aggregateAll(this, columns)
+): DataFrame<T> = Aggregators.percentileCommon<C>(percentile, skipNaN).aggregateAll(this, columns)
 
 public fun <T> PivotGroupBy<T>.percentile(
     percentile: Double,
@@ -645,7 +651,7 @@ public fun <T> PivotGroupBy<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentile(
+public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.percentile(
     percentile: Double,
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -653,19 +659,19 @@ public fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentile(
+public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.percentile(
     percentile: Double,
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = percentile(percentile, skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.percentileOf(
+public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.percentileOf(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
-): DataFrame<T> = Aggregators.percentile(percentile, skipNaN).cast<R>().aggregateOf(this, expression)
+): DataFrame<T> = Aggregators.percentileCommon<R>(percentile, skipNaN).aggregateOf(this, expression)
 
-public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.percentileBy(
+public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.percentileBy(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
@@ -673,7 +679,7 @@ public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.percentileBy(
+public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.percentileBy(
     percentile: Double,
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -687,7 +693,7 @@ public fun <T> PivotGroupBy<T>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.percentileBy(
+public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.percentileBy(
     percentile: Double,
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,

From a1dca1624588253deb8af74dc98a98151c7ffe49 Mon Sep 17 00:00:00 2001
From: "andrei.kislitsyn" <kisandy@yandex.ru>
Date: Tue, 25 Nov 2025 17:28:48 +0400
Subject: [PATCH 03/16] apply DefinitelyNotNullable patch for notebooks only:
 #1116

---
 .../jetbrains/kotlinx/dataframe/api/max.kt    | 213 +++++++++---------
 .../jetbrains/kotlinx/dataframe/api/median.kt | 150 ++++++------
 .../jetbrains/kotlinx/dataframe/api/min.kt    | 205 ++++++++---------
 .../kotlinx/dataframe/api/percentile.kt       | 158 +++++++------
 4 files changed, 354 insertions(+), 372 deletions(-)

diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt
index d1ff0cd1e2..75d0827220 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt
@@ -13,6 +13,7 @@ import org.jetbrains.kotlinx.dataframe.annotations.Refine
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 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.intraComparableColumns
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateByOrNull
@@ -35,25 +36,25 @@ public fun <T : Comparable<T>> DataColumn<T?>.max(skipNaN: Boolean = skipNaNDefa
 public fun <T : Comparable<T>> DataColumn<T?>.maxOrNull(skipNaN: Boolean = skipNaNDefault): T? =
     Aggregators.max<T>(skipNaN).aggregateSingleColumn(this)
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxBy(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T & Any = maxByOrNull(skipNaN, selector).suggestIfNull("maxBy")
+): T = maxByOrNull(skipNaN, selector).suggestIfNull("maxBy")
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxByOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T? = Aggregators.max<R>(skipNaN).aggregateByOrNull(this, selector)
+): T? = Aggregators.max.invoke(skipNaN).cast<R>().aggregateByOrNull(this, selector)
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxOf(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): R & Any = maxOfOrNull(skipNaN, selector).suggestIfNull("maxOf")
+): R = maxOfOrNull(skipNaN, selector).suggestIfNull("maxOf")
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxOfOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): R? = Aggregators.max<R>(skipNaN).aggregateOf(this, selector)
+): R? = Aggregators.max.invoke(skipNaN).cast<R>().aggregateOf(this, selector)
 
 // endregion
 
@@ -103,61 +104,61 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.maxFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = maxFor(skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(
+public fun <T, C : Comparable<*>?> DataFrame<T>.max(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): C & Any = maxOrNull(skipNaN, columns).suggestIfNull("max")
+): C = maxOrNull(skipNaN, columns).suggestIfNull("max")
 
 public fun <T> DataFrame<T>.max(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Comparable<Any> =
     maxOrNull(*columns, skipNaN = skipNaN).suggestIfNull("max")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(
+public fun <T, C : Comparable<*>?> DataFrame<T>.max(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): C & Any = maxOrNull(*columns, skipNaN = skipNaN).suggestIfNull("max")
+): C = maxOrNull(*columns, skipNaN = skipNaN).suggestIfNull("max")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(
+public fun <T, C : Comparable<*>?> DataFrame<T>.max(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
-): C & Any = maxOrNull(*columns, skipNaN = skipNaN).suggestIfNull("max")
+): C = maxOrNull(*columns, skipNaN = skipNaN).suggestIfNull("max")
 
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): C? = Aggregators.max<C>(skipNaN).aggregateAll(this, columns)
+): C? = Aggregators.max.invoke(skipNaN).cast<C>().aggregateAll(this, columns)
 
 public fun <T> DataFrame<T>.maxOrNull(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Comparable<Any>? =
     maxOrNull(skipNaN) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): C? = maxOrNull(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): C? = maxOrNull(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxOf(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): C & Any = maxOfOrNull(skipNaN, expression).suggestIfNull("maxOf")
+): C = maxOfOrNull(skipNaN, expression).suggestIfNull("maxOf")
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxOfOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): C? = Aggregators.max<C>(skipNaN).aggregateOf(this, expression)
+): C? = Aggregators.max.invoke(skipNaN).cast<C>().aggregateOf(this, expression)
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T> = maxByOrNull(skipNaN, expression).suggestIfNull("maxBy")
@@ -167,36 +168,36 @@ public fun <T> DataFrame<T>.maxBy(column: String, skipNaN: Boolean = skipNaNDefa
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = maxByOrNull(column, skipNaN).suggestIfNull("maxBy")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = maxByOrNull(column, skipNaN).suggestIfNull("maxBy")
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataRow<T>? = Aggregators.max<C>(skipNaN).aggregateByOrNull(this, expression)
+): DataRow<T>? = Aggregators.max.invoke(skipNaN).cast<C>().aggregateByOrNull(this, expression)
 
 public fun <T> DataFrame<T>.maxByOrNull(column: String, skipNaN: Boolean = skipNaNDefault): DataRow<T>? =
     maxByOrNull(column.toColumnOf<Comparable<Any>?>(), skipNaN)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): DataRow<T>? = Aggregators.max<C>(skipNaN).aggregateByOrNull(this, column)
+): DataRow<T>? = Aggregators.max.invoke(skipNaN).cast<C>().aggregateByOrNull(this, column)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T>? = maxByOrNull(column.toColumnAccessor(), skipNaN)
@@ -236,11 +237,11 @@ public fun <T, C : Comparable<*>?> Grouped<T>.maxFor(
 
 @Refine
 @Interpretable("GroupByMax2")
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
+public fun <T, C : Comparable<*>?> Grouped<T>.max(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C?>,
-): DataFrame<T> = Aggregators.max<C>(skipNaN).aggregateAll(this, name, columns)
+): DataFrame<T> = Aggregators.max.invoke(skipNaN).cast<C>().aggregateAll(this, name, columns)
 
 public fun <T> Grouped<T>.max(
     vararg columns: String,
@@ -250,7 +251,7 @@ public fun <T> Grouped<T>.max(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
+public fun <T, C : Comparable<*>?> Grouped<T>.max(
     vararg columns: ColumnReference<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -258,7 +259,7 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
+public fun <T, C : Comparable<*>?> Grouped<T>.max(
     vararg columns: KProperty<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -266,21 +267,21 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
 
 @Refine
 @Interpretable("GroupByMaxOf")
-public inline fun <T, reified C : Comparable<C & Any>?> Grouped<T>.maxOf(
+public inline fun <T, reified C : Comparable<*>?> Grouped<T>.maxOf(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataFrame<T> = Aggregators.max<C>(skipNaN).aggregateOf(this, name, expression)
+): DataFrame<T> = Aggregators.max.invoke(skipNaN).cast<C>().aggregateOf(this, name, expression)
 
 @Interpretable("GroupByReduceExpression")
-public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.maxBy(
+public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.maxBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<G, R>,
 ): ReducedGroupBy<T, G> = reduce { maxByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.maxBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.maxBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = reduce { maxByOrNull(column, skipNaN) }
@@ -290,7 +291,7 @@ public fun <T, G> GroupBy<T, G>.maxBy(column: String, skipNaN: Boolean = skipNaN
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.maxBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.maxBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = maxBy(column.toColumnAccessor(), skipNaN)
@@ -330,41 +331,43 @@ public fun <T, R : Comparable<*>?> Pivot<T>.maxFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = maxFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(
+public fun <T, R : Comparable<*>?> Pivot<T>.max(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, R>,
-): DataRow<T> = delegate { max(skipNaN, columns) }
+): DataRow<T> = delegate { maxFor(separate = false, skipNaN, columns) }
 
-public fun <T> Pivot<T>.max(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataRow<T> =
-    max(skipNaN) { columns.toComparableColumns() }
+public fun <T, R : Comparable<*>?> Pivot<T>.max(
+    vararg columns: String,
+    skipNaN: Boolean = skipNaNDefault,
+): DataRow<T> = max(skipNaN) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(
+public fun <T, R : Comparable<*>?> Pivot<T>.max(
     vararg columns: ColumnReference<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = max(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(
+public fun <T, R : Comparable<*>?> Pivot<T>.max(
     vararg columns: KProperty<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = max(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.maxOf(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.maxOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): DataRow<T> = delegate { maxOf(skipNaN, rowExpression) }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.maxBy(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.maxBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivot<T> = reduce { maxByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.maxBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = reduce { maxByOrNull(column, skipNaN) }
@@ -374,7 +377,7 @@ public fun <T> Pivot<T>.maxBy(column: String, skipNaN: Boolean = skipNaNDefault)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.maxBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = maxBy(column.toColumnAccessor(), skipNaN)
@@ -414,39 +417,39 @@ public fun <T, R : Comparable<*>?> PivotGroupBy<T>.maxFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = maxFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, R>,
-): DataFrame<T> = Aggregators.max<R>(skipNaN).aggregateAll(this, columns)
+): DataFrame<T> = Aggregators.max.invoke(skipNaN).cast<R>().aggregateAll(this, columns)
 
 public fun <T> PivotGroupBy<T>.max(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T> =
     max(skipNaN) { columns.toComparableColumns() }
 
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(
     vararg columns: ColumnReference<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = max(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(
     vararg columns: KProperty<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = max(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.maxOf(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.maxOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): DataFrame<T> = aggregate { maxOf(skipNaN, rowExpression) }
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.maxBy(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.maxBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivotGroupBy<T> = reduce { maxByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.maxBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = reduce { maxByOrNull(column, skipNaN) }
@@ -456,7 +459,7 @@ public fun <T> PivotGroupBy<T>.maxBy(column: String, skipNaN: Boolean = skipNaND
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.maxBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = maxBy(column.toColumnAccessor(), skipNaN)
@@ -473,26 +476,26 @@ public fun <T : Comparable<T>> DataColumn<T?>.max(): T = max(skipNaN = skipNaNDe
 public fun <T : Comparable<T>> DataColumn<T?>.maxOrNull(): T? = maxOrNull(skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxBy(noinline selector: (T) -> R): T & Any =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxBy(noinline selector: (T) -> R): T =
     maxBy(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxByOrNull(noinline selector: (T) -> R): T? =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxByOrNull(noinline selector: (T) -> R): T? =
     maxByOrNull(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxOf(crossinline selector: (T) -> R): R & Any =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxOf(crossinline selector: (T) -> R): R =
     maxOf(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxOfOrNull(crossinline selector: (T) -> R): R? =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxOfOrNull(crossinline selector: (T) -> R): R? =
     maxOfOrNull(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public inline fun <reified T : Comparable<T>> AnyRow.rowMaxOfOrNull(): T? = rowMaxOfOrNull<T>(skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <reified T : Comparable<T & Any>?> AnyRow.rowMaxOf(): T & Any = rowMaxOf(skipNaN = skipNaNDefault)
+public inline fun <reified T : Comparable<T>> AnyRow.rowMaxOf(): T = rowMaxOf(skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public fun <T> DataFrame<T>.max(): DataRow<T> = max(skipNaN = skipNaNDefault)
@@ -516,7 +519,7 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.maxFor(vararg columns: KProperty
     maxFor(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(columns: ColumnsSelector<T, C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.max(columns: ColumnsSelector<T, C>): C =
     max(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -525,16 +528,16 @@ public fun <T> DataFrame<T>.max(vararg columns: String): Comparable<Any> =
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(vararg columns: ColumnReference<C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.max(vararg columns: ColumnReference<C>): C =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(vararg columns: KProperty<C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.max(vararg columns: KProperty<C>): C =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(columns: ColumnsSelector<T, C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(columns: ColumnsSelector<T, C>): C? =
     maxOrNull(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -543,26 +546,25 @@ public fun <T> DataFrame<T>.maxOrNull(vararg columns: String): Comparable<Any>?
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(vararg columns: ColumnReference<C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(vararg columns: ColumnReference<C>): C? =
     maxOrNull(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(vararg columns: KProperty<C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(vararg columns: KProperty<C>): C? =
     maxOrNull(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxOf(
-    crossinline expression: RowExpression<T, C>,
-): C & Any = maxOf(skipNaN = skipNaNDefault, expression = expression)
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxOf(crossinline expression: RowExpression<T, C>): C =
+    maxOf(skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxOfOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxOfOrNull(
     crossinline expression: RowExpression<T, C>,
 ): C? = maxOfOrNull(skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T> = maxBy(skipNaN = skipNaNDefault, expression = expression)
 
@@ -571,16 +573,16 @@ public fun <T> DataFrame<T>.maxBy(column: String): DataRow<T> = maxBy(column, sk
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(column: ColumnReference<C>): DataRow<T> =
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(column: ColumnReference<C>): DataRow<T> =
     maxBy(column, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(column: KProperty<C>): DataRow<T> =
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(column: KProperty<C>): DataRow<T> =
     maxBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T>? = maxByOrNull(skipNaN = skipNaNDefault, expression = expression)
 
@@ -589,13 +591,12 @@ public fun <T> DataFrame<T>.maxByOrNull(column: String): DataRow<T>? = maxByOrNu
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(
-    column: ColumnReference<C>,
-): DataRow<T>? = maxByOrNull(column, skipNaN = skipNaNDefault)
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(column: ColumnReference<C>): DataRow<T>? =
+    maxByOrNull(column, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(column: KProperty<C>): DataRow<T>? =
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(column: KProperty<C>): DataRow<T>? =
     maxByOrNull(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -620,7 +621,7 @@ public fun <T, C : Comparable<*>?> Grouped<T>.maxFor(vararg columns: KProperty<C
     maxFor(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
+public fun <T, C : Comparable<*>?> Grouped<T>.max(
     name: String? = null,
     columns: ColumnsSelector<T, C?>,
 ): DataFrame<T> = max(name, skipNaN = skipNaNDefault, columns = columns)
@@ -631,32 +632,30 @@ public fun <T> Grouped<T>.max(vararg columns: String, name: String? = null): Dat
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
+public fun <T, C : Comparable<*>?> Grouped<T>.max(
     vararg columns: ColumnReference<C>,
     name: String? = null,
 ): DataFrame<T> = max(columns = columns, name = name, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
-    vararg columns: KProperty<C>,
-    name: String? = null,
-): DataFrame<T> = max(columns = columns, name = name, skipNaN = skipNaNDefault)
+public fun <T, C : Comparable<*>?> Grouped<T>.max(vararg columns: KProperty<C>, name: String? = null): DataFrame<T> =
+    max(columns = columns, name = name, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> Grouped<T>.maxOf(
+public inline fun <T, reified C : Comparable<*>?> Grouped<T>.maxOf(
     name: String? = null,
     crossinline expression: RowExpression<T, C>,
 ): DataFrame<T> = maxOf(name, skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.maxBy(
+public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.maxBy(
     crossinline rowExpression: RowExpression<G, R>,
 ): ReducedGroupBy<T, G> = maxBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.maxBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.maxBy(
     column: ColumnReference<C>,
 ): ReducedGroupBy<T, G> = maxBy(column, skipNaN = skipNaNDefault)
 
@@ -665,9 +664,8 @@ public fun <T, G> GroupBy<T, G>.maxBy(column: String): ReducedGroupBy<T, G> = ma
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.maxBy(
-    column: KProperty<C>,
-): ReducedGroupBy<T, G> = maxBy(column, skipNaN = skipNaNDefault)
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.maxBy(column: KProperty<C>): ReducedGroupBy<T, G> =
+    maxBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public fun <T> Pivot<T>.max(separate: Boolean = false): DataRow<T> = max(separate, skipNaN = skipNaNDefault)
@@ -697,32 +695,32 @@ public fun <T, R : Comparable<*>?> Pivot<T>.maxFor(
 ): DataRow<T> = maxFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(columns: ColumnsSelector<T, R>): DataRow<T> =
+public fun <T, R : Comparable<*>?> Pivot<T>.max(columns: ColumnsSelector<T, R>): DataRow<T> =
     max(skipNaN = skipNaNDefault, columns = columns)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(vararg columns: ColumnReference<R>): DataRow<T> =
+public fun <T, R : Comparable<*>?> Pivot<T>.max(vararg columns: ColumnReference<R>): DataRow<T> =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(vararg columns: KProperty<R>): DataRow<T> =
+public fun <T, R : Comparable<*>?> Pivot<T>.max(vararg columns: KProperty<R>): DataRow<T> =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.maxOf(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.maxOf(
     crossinline rowExpression: RowExpression<T, R>,
 ): DataRow<T> = maxOf(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.maxBy(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.maxBy(
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivot<T> = maxBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.maxBy(column: ColumnReference<C>): ReducedPivot<T> =
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.maxBy(column: ColumnReference<C>): ReducedPivot<T> =
     maxBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -730,7 +728,7 @@ public fun <T> Pivot<T>.maxBy(column: String): ReducedPivot<T> = maxBy(column, s
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.maxBy(column: KProperty<C>): ReducedPivot<T> =
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.maxBy(column: KProperty<C>): ReducedPivot<T> =
     maxBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -761,7 +759,7 @@ public fun <T, R : Comparable<*>?> PivotGroupBy<T>.maxFor(
 ): DataFrame<T> = maxFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(columns: ColumnsSelector<T, R>): DataFrame<T> =
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(columns: ColumnsSelector<T, R>): DataFrame<T> =
     max(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -769,27 +767,27 @@ public fun <T> PivotGroupBy<T>.max(vararg columns: String): DataFrame<T> =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(vararg columns: ColumnReference<R>): DataFrame<T> =
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(vararg columns: ColumnReference<R>): DataFrame<T> =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(vararg columns: KProperty<R>): DataFrame<T> =
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(vararg columns: KProperty<R>): DataFrame<T> =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.maxOf(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.maxOf(
     crossinline rowExpression: RowExpression<T, R>,
 ): DataFrame<T> = maxOf(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.maxBy(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.maxBy(
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivotGroupBy<T> = maxBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.maxBy(
     column: ColumnReference<C>,
 ): ReducedPivotGroupBy<T> = maxBy(column, skipNaN = skipNaNDefault)
 
@@ -798,8 +796,7 @@ public fun <T> PivotGroupBy<T>.maxBy(column: String): ReducedPivotGroupBy<T> = m
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.maxBy(
-    column: KProperty<C>,
-): ReducedPivotGroupBy<T> = maxBy(column, skipNaN = skipNaNDefault)
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.maxBy(column: KProperty<C>): ReducedPivotGroupBy<T> =
+    maxBy(column, skipNaN = skipNaNDefault)
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt
index 576a17ea18..610d123a8c 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt
@@ -15,6 +15,8 @@ import org.jetbrains.kotlinx.dataframe.annotations.Refine
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 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.aggregators.cast2
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.intraComparableColumns
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateByOrNull
@@ -47,61 +49,58 @@ import kotlin.reflect.KProperty
 
 // region DataColumn
 
-public fun <T : Comparable<T & Any>?> DataColumn<T>.median(): T & Any = medianOrNull().suggestIfNull("median")
+public fun <T : Comparable<*>?> DataColumn<T>.median(): T = medianOrNull().suggestIfNull("median")
 
-public fun <T : Comparable<T & Any>?> DataColumn<T>.medianOrNull(): T? =
-    Aggregators.medianComparables<T>().aggregateSingleColumn(this)
+public fun <T : Comparable<*>?> DataColumn<T>.medianOrNull(): T? =
+    Aggregators.median(skipNaNDefault).cast<T>().aggregateSingleColumn(this)
 
 public fun <T> DataColumn<T>.median(
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where T : Comparable<T & Any>?, T : Number? = medianOrNull(skipNaN = skipNaN).suggestIfNull("median")
+    where T : Comparable<*>?, T : Number? = medianOrNull(skipNaN = skipNaN).suggestIfNull("median")
 
 public fun <T> DataColumn<T>.medianOrNull(
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where T : Comparable<T & Any>?, T : Number? =
-    Aggregators.medianNumbers<T>(skipNaN).aggregateSingleColumn(this)
+    where T : Comparable<*>?, T : Number? =
+    Aggregators.median(skipNaN).cast2<T & Any, Double?>().aggregateSingleColumn(this)
 
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.medianBy(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.medianBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T & Any = medianByOrNull(skipNaN, selector).suggestIfNull("medianBy")
+): T = medianByOrNull(skipNaN, selector).suggestIfNull("medianBy")
 
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.medianByOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.medianByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T? = Aggregators.medianCommon<R>(skipNaN).aggregateByOrNull(this, selector)
+): T? = Aggregators.median(skipNaN).cast<R>().aggregateByOrNull(this, selector)
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.medianOf(
-    crossinline expression: (T) -> R,
-): R & Any = medianOfOrNull(expression).suggestIfNull("medianOf")
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.medianOf(crossinline expression: (T) -> R): R =
+    medianOfOrNull(expression).suggestIfNull("medianOf")
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.medianOfOrNull(
-    crossinline expression: (T) -> R,
-): R? = Aggregators.medianComparables<R>().aggregateOf(this, expression)
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.medianOfOrNull(crossinline expression: (T) -> R): R? =
+    Aggregators.median(skipNaNDefault).cast<R>().aggregateOf(this, expression)
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataColumn<T>.medianOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: (T) -> R,
 ): Double
-    where R : Comparable<R & Any>?, R : Number? =
-    medianOfOrNull(skipNaN, expression).suggestIfNull("medianOf")
+    where R : Comparable<*>?, R : Number? = medianOfOrNull(skipNaN, expression).suggestIfNull("medianOf")
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataColumn<T>.medianOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: (T) -> R,
 ): Double?
-    where R : Comparable<R & Any>?, R : Number? =
-    Aggregators.medianNumbers<R>(skipNaN).aggregateOf(this, expression)
+    where R : Comparable<*>?, R : Number? =
+    Aggregators.median(skipNaN).cast2<R & Any, Double?>().aggregateOf(this, expression)
 
 // endregion
 
@@ -164,21 +163,21 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.medianFor(
 
 // TODO, requires explicit type C due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.median(columns: ColumnsSelector<T, C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.median(columns: ColumnsSelector<T, C>): C =
     medianOrNull(columns).suggestIfNull("median")
 
 // TODO, requires explicit type C due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
 @Suppress("UNCHECKED_CAST")
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.medianOrNull(columns: ColumnsSelector<T, C>): C? =
-    Aggregators.medianComparables<C>().aggregateAll(this, columns)
+public fun <T, C : Comparable<*>?> DataFrame<T>.medianOrNull(columns: ColumnsSelector<T, C>): C? =
+    Aggregators.median(skipNaNDefault).cast<C>().aggregateAll(this, columns)
 
 @OverloadResolutionByLambdaReturnType
 public fun <T, C> DataFrame<T>.median(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
 ): Double
-    where C : Number?, C : Comparable<C & Any>? = medianOrNull(skipNaN, columns).suggestIfNull("median")
+    where C : Number?, C : Comparable<*>? = medianOrNull(skipNaN, columns).suggestIfNull("median")
 
 @OverloadResolutionByLambdaReturnType
 @Suppress("UNCHECKED_CAST")
@@ -186,8 +185,8 @@ public fun <T, C> DataFrame<T>.medianOrNull(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
 ): Double?
-    where C : Comparable<C & Any>?, C : Number? =
-    Aggregators.medianNumbers<C>(skipNaN).aggregateAll(this, columns)
+    where C : Comparable<*>?, C : Number? =
+    Aggregators.median(skipNaN).cast2<C & Any, Double?>().aggregateAll(this, columns)
 
 public fun <T> DataFrame<T>.median(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Any =
     medianOrNull(*columns, skipNaN = skipNaN).suggestIfNull("median")
@@ -197,12 +196,12 @@ public fun <T> DataFrame<T>.medianOrNull(vararg columns: String, skipNaN: Boolea
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.median(vararg columns: ColumnReference<C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.median(vararg columns: ColumnReference<C>): C =
     medianOrNull(*columns).suggestIfNull("median")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.medianOrNull(vararg columns: ColumnReference<C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.medianOrNull(vararg columns: ColumnReference<C>): C? =
     medianOrNull<T, C> { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
@@ -211,8 +210,7 @@ public fun <T, C> DataFrame<T>.median(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where C : Comparable<C & Any>?, C : Number? =
-    medianOrNull(*columns, skipNaN = skipNaN).suggestIfNull("median")
+    where C : Comparable<*>?, C : Number? = medianOrNull(*columns, skipNaN = skipNaN).suggestIfNull("median")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
@@ -220,16 +218,16 @@ public fun <T, C> DataFrame<T>.medianOrNull(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where C : Comparable<C & Any>?, C : Number? = medianOrNull(skipNaN) { columns.toColumnSet() }
+    where C : Comparable<*>?, C : Number? = medianOrNull(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.median(vararg columns: KProperty<C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.median(vararg columns: KProperty<C>): C =
     medianOrNull(*columns).suggestIfNull("median")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.medianOrNull(vararg columns: KProperty<C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.medianOrNull(vararg columns: KProperty<C>): C? =
     medianOrNull<T, C> { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
@@ -238,8 +236,7 @@ public fun <T, C> DataFrame<T>.median(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where C : Comparable<C & Any>?, C : Number? =
-    medianOrNull(*columns, skipNaN = skipNaN).suggestIfNull("median")
+    where C : Comparable<*>?, C : Number? = medianOrNull(*columns, skipNaN = skipNaN).suggestIfNull("median")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
@@ -247,37 +244,36 @@ public fun <T, C> DataFrame<T>.medianOrNull(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where C : Comparable<C & Any>?, C : Number? = medianOrNull(skipNaN) { columns.toColumnSet() }
+    where C : Comparable<*>?, C : Number? = medianOrNull(skipNaN) { columns.toColumnSet() }
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataFrame<T>.medianOf(
+public inline fun <T, reified R : Comparable<*>?> DataFrame<T>.medianOf(
     crossinline expression: RowExpression<T, R>,
-): R & Any = medianOfOrNull(expression).suggestIfNull("medianOf")
+): R = medianOfOrNull(expression).suggestIfNull("medianOf")
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataFrame<T>.medianOfOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataFrame<T>.medianOfOrNull(
     crossinline expression: RowExpression<T, R>,
-): R? = Aggregators.medianComparables<R>().aggregateOf(this, expression)
+): R? = Aggregators.median(skipNaNDefault).cast<R>().aggregateOf(this, expression)
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataFrame<T>.medianOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): Double
-    where R : Comparable<R & Any>?, R : Number? =
-    medianOfOrNull(skipNaN, expression).suggestIfNull("medianOf")
+    where R : Comparable<*>?, R : Number? = medianOfOrNull(skipNaN, expression).suggestIfNull("medianOf")
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataFrame<T>.medianOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): Double?
-    where R : Comparable<R & Any>?, R : Number? =
-    Aggregators.medianNumbers<R>(skipNaN).aggregateOf(this, expression)
+    where R : Comparable<*>?, R : Number? =
+    Aggregators.median(skipNaN).cast2<R & Any, Double?>().aggregateOf(this, expression)
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T> = medianByOrNull(skipNaN, expression).suggestIfNull("medianBy")
@@ -287,36 +283,36 @@ public fun <T> DataFrame<T>.medianBy(column: String, skipNaN: Boolean = skipNaND
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = medianByOrNull(column, skipNaN).suggestIfNull("medianBy")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = medianByOrNull(column, skipNaN).suggestIfNull("medianBy")
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataRow<T>? = Aggregators.medianCommon<C>(skipNaN).aggregateByOrNull(this, expression)
+): DataRow<T>? = Aggregators.median(skipNaN).cast<C>().aggregateByOrNull(this, expression)
 
 public fun <T> DataFrame<T>.medianByOrNull(column: String, skipNaN: Boolean = skipNaNDefault): DataRow<T>? =
     medianByOrNull(column.toColumnOf<Comparable<Any>?>(), skipNaN)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianByOrNull(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): DataRow<T>? = Aggregators.medianCommon<C>(skipNaN).aggregateByOrNull(this, column)
+): DataRow<T>? = Aggregators.median(skipNaN).cast<C>().aggregateByOrNull(this, column)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianByOrNull(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T>? = medianByOrNull(column.toColumnAccessor(), skipNaN)
@@ -354,11 +350,11 @@ public fun <T, C : Comparable<*>?> Grouped<T>.medianFor(
 
 @Refine
 @Interpretable("GroupByMedian2")
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.median(
+public fun <T, C : Comparable<*>?> Grouped<T>.median(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): DataFrame<T> = Aggregators.medianCommon<C>(skipNaN).aggregateAll(this, name, columns)
+): DataFrame<T> = Aggregators.median(skipNaN).cast<C>().aggregateAll(this, name, columns)
 
 public fun <T> Grouped<T>.median(
     vararg columns: String,
@@ -368,7 +364,7 @@ public fun <T> Grouped<T>.median(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.median(
+public fun <T, C : Comparable<*>?> Grouped<T>.median(
     vararg columns: ColumnReference<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -376,7 +372,7 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.median(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.median(
+public fun <T, C : Comparable<*>?> Grouped<T>.median(
     vararg columns: KProperty<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -384,21 +380,21 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.median(
 
 @Refine
 @Interpretable("GroupByMedianOf")
-public inline fun <T, reified R : Comparable<R & Any>?> Grouped<T>.medianOf(
+public inline fun <T, reified R : Comparable<*>?> Grouped<T>.medianOf(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
-): DataFrame<T> = Aggregators.medianCommon<R>(skipNaN).aggregateOf(this, name, expression)
+): DataFrame<T> = Aggregators.median(skipNaN).cast<R>().aggregateOf(this, name, expression)
 
 @Interpretable("GroupByReduceExpression") // TODO?
-public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.medianBy(
+public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.medianBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<G, R>,
 ): ReducedGroupBy<T, G> = reduce { medianByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.medianBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.medianBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = reduce { medianByOrNull(column, skipNaN) }
@@ -408,7 +404,7 @@ public fun <T, G> GroupBy<T, G>.medianBy(column: String, skipNaN: Boolean = skip
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.medianBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.medianBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = medianBy(column.toColumnAccessor(), skipNaN)
@@ -448,7 +444,7 @@ public fun <T, C : Comparable<*>?> Pivot<T>.medianFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = medianFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.median(
+public fun <T, C : Comparable<*>?> Pivot<T>.median(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
 ): DataRow<T> = delegate { median(skipNaN, columns) }
@@ -458,31 +454,31 @@ public fun <T> Pivot<T>.median(vararg columns: String, skipNaN: Boolean = skipNa
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.median(
+public fun <T, C : Comparable<*>?> Pivot<T>.median(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = median(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.median(
+public fun <T, C : Comparable<*>?> Pivot<T>.median(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = median(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.medianOf(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.medianOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): DataRow<T> = delegate { medianOf(skipNaN, expression) }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.medianBy(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.medianBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivot<T> = reduce { medianByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.medianBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.medianBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = reduce { medianByOrNull(column, skipNaN) }
@@ -492,7 +488,7 @@ public fun <T> Pivot<T>.medianBy(column: String, skipNaN: Boolean = skipNaNDefau
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.medianBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.medianBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = medianBy(column.toColumnAccessor(), skipNaN)
@@ -531,41 +527,41 @@ public fun <T, C : Comparable<*>?> PivotGroupBy<T>.medianFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = medianFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.median(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.median(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): DataFrame<T> = Aggregators.medianCommon<C>(skipNaN).aggregateAll(this, columns)
+): DataFrame<T> = Aggregators.median(skipNaN).cast<C>().aggregateAll(this, columns)
 
 public fun <T> PivotGroupBy<T>.median(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T> =
     median(skipNaN) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.median(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.median(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = median(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.median(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.median(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = median(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.medianOf(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.medianOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
-): DataFrame<T> = Aggregators.medianCommon<R>(skipNaN).aggregateOf(this, expression)
+): DataFrame<T> = Aggregators.median(skipNaN).cast<R>().aggregateOf(this, expression)
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.medianBy(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.medianBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivotGroupBy<T> = reduce { medianByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.medianBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.medianBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = reduce { medianByOrNull(column, skipNaN) }
@@ -575,7 +571,7 @@ public fun <T> PivotGroupBy<T>.medianBy(column: String, skipNaN: Boolean = skipN
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.medianBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.medianBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = medianBy(column.toColumnAccessor(), skipNaN)
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt
index 6246e7205c..ebd30a44e5 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt
@@ -13,6 +13,7 @@ import org.jetbrains.kotlinx.dataframe.annotations.Refine
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 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.intraComparableColumns
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateByOrNull
@@ -35,25 +36,25 @@ public fun <T : Comparable<T>> DataColumn<T?>.min(skipNaN: Boolean = skipNaNDefa
 public fun <T : Comparable<T>> DataColumn<T?>.minOrNull(skipNaN: Boolean = skipNaNDefault): T? =
     Aggregators.min<T>(skipNaN).aggregateSingleColumn(this)
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minBy(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T & Any = minByOrNull(skipNaN, selector).suggestIfNull("minBy")
+): T = minByOrNull(skipNaN, selector).suggestIfNull("minBy")
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minByOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T? = Aggregators.min<R>(skipNaN).aggregateByOrNull(this, selector)
+): T? = Aggregators.min.invoke(skipNaN).cast<R>().aggregateByOrNull(this, selector)
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minOf(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): R & Any = minOfOrNull(skipNaN, selector).suggestIfNull("minOf")
+): R = minOfOrNull(skipNaN, selector).suggestIfNull("minOf")
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minOfOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): R? = Aggregators.min<R>(skipNaN).aggregateOf(this, selector)
+): R? = Aggregators.min.invoke(skipNaN).cast<R>().aggregateOf(this, selector)
 
 // endregion
 
@@ -103,61 +104,61 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.minFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = minFor(skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(
+public fun <T, C : Comparable<*>?> DataFrame<T>.min(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): C & Any = minOrNull(skipNaN, columns).suggestIfNull("min")
+): C = minOrNull(skipNaN, columns).suggestIfNull("min")
 
 public fun <T> DataFrame<T>.min(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Comparable<Any> =
     minOrNull(*columns, skipNaN = skipNaN).suggestIfNull("min")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(
+public fun <T, C : Comparable<*>?> DataFrame<T>.min(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): C & Any = minOrNull(*columns, skipNaN = skipNaN).suggestIfNull("min")
+): C = minOrNull(*columns, skipNaN = skipNaN).suggestIfNull("min")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(
+public fun <T, C : Comparable<*>?> DataFrame<T>.min(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
-): C & Any = minOrNull(*columns, skipNaN = skipNaN).suggestIfNull("min")
+): C = minOrNull(*columns, skipNaN = skipNaN).suggestIfNull("min")
 
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): C? = Aggregators.min<C>(skipNaN).aggregateAll(this, columns)
+): C? = Aggregators.min.invoke(skipNaN).cast<C>().aggregateAll(this, columns)
 
 public fun <T> DataFrame<T>.minOrNull(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Comparable<Any>? =
     minOrNull(skipNaN) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): C? = minOrNull(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): C? = minOrNull(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minOf(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): C & Any = minOfOrNull(skipNaN, expression).suggestIfNull("minOf")
+): C = minOfOrNull(skipNaN, expression).suggestIfNull("minOf")
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minOfOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): C? = Aggregators.min<C>(skipNaN).aggregateOf(this, expression)
+): C? = Aggregators.min.invoke(skipNaN).cast<C>().aggregateOf(this, expression)
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T> = minByOrNull(skipNaN, expression).suggestIfNull("minBy")
@@ -167,36 +168,36 @@ public fun <T> DataFrame<T>.minBy(column: String, skipNaN: Boolean = skipNaNDefa
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = minByOrNull(column, skipNaN).suggestIfNull("minBy")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = minByOrNull(column, skipNaN).suggestIfNull("minBy")
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataRow<T>? = Aggregators.min<C>(skipNaN).aggregateByOrNull(this, expression)
+): DataRow<T>? = Aggregators.min.invoke(skipNaN).cast<C>().aggregateByOrNull(this, expression)
 
 public fun <T> DataFrame<T>.minByOrNull(column: String, skipNaN: Boolean = skipNaNDefault): DataRow<T>? =
     minByOrNull(column.toColumnOf<Comparable<Any>?>(), skipNaN)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): DataRow<T>? = Aggregators.min<C>(skipNaN).aggregateByOrNull(this, column)
+): DataRow<T>? = Aggregators.min.invoke(skipNaN).cast<C>().aggregateByOrNull(this, column)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T>? = minByOrNull(column.toColumnAccessor(), skipNaN)
@@ -236,11 +237,11 @@ public fun <T, C : Comparable<*>?> Grouped<T>.minFor(
 
 @Refine
 @Interpretable("GroupByMin2")
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
+public fun <T, C : Comparable<*>?> Grouped<T>.min(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C?>,
-): DataFrame<T> = Aggregators.min<C>(skipNaN).aggregateAll(this, name, columns)
+): DataFrame<T> = Aggregators.min.invoke(skipNaN).cast<C>().aggregateAll(this, name, columns)
 
 public fun <T> Grouped<T>.min(
     vararg columns: String,
@@ -250,7 +251,7 @@ public fun <T> Grouped<T>.min(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
+public fun <T, C : Comparable<*>?> Grouped<T>.min(
     vararg columns: ColumnReference<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -258,7 +259,7 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
+public fun <T, C : Comparable<*>?> Grouped<T>.min(
     vararg columns: KProperty<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -266,21 +267,21 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
 
 @Refine
 @Interpretable("GroupByMinOf")
-public inline fun <T, reified C : Comparable<C & Any>?> Grouped<T>.minOf(
+public inline fun <T, reified C : Comparable<*>?> Grouped<T>.minOf(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataFrame<T> = Aggregators.min<C>(skipNaN).aggregateOf(this, name, expression)
+): DataFrame<T> = Aggregators.min.invoke(skipNaN).cast<C>().aggregateOf(this, name, expression)
 
 @Interpretable("GroupByReduceExpression")
-public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.minBy(
+public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.minBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<G, R>,
 ): ReducedGroupBy<T, G> = reduce { minByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.minBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.minBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = reduce { minByOrNull(column, skipNaN) }
@@ -290,7 +291,7 @@ public fun <T, G> GroupBy<T, G>.minBy(column: String, skipNaN: Boolean = skipNaN
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.minBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.minBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = minBy(column.toColumnAccessor(), skipNaN)
@@ -330,7 +331,7 @@ public fun <T, R : Comparable<*>?> Pivot<T>.minFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = minFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(
+public fun <T, R : Comparable<*>?> Pivot<T>.min(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, R>,
 ): DataRow<T> = delegate { min(skipNaN, columns) }
@@ -340,31 +341,31 @@ public fun <T> Pivot<T>.min(vararg columns: String, skipNaN: Boolean = skipNaNDe
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(
+public fun <T, R : Comparable<*>?> Pivot<T>.min(
     vararg columns: ColumnReference<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = min(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(
+public fun <T, R : Comparable<*>?> Pivot<T>.min(
     vararg columns: KProperty<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = min(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.minOf(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.minOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): DataRow<T> = delegate { minOf(skipNaN, rowExpression) }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.minBy(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.minBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivot<T> = reduce { minByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.minBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = reduce { minByOrNull(column, skipNaN) }
@@ -374,7 +375,7 @@ public fun <T> Pivot<T>.minBy(column: String, skipNaN: Boolean = skipNaNDefault)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.minBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = minBy(column.toColumnAccessor(), skipNaN)
@@ -414,39 +415,39 @@ public fun <T, R : Comparable<*>?> PivotGroupBy<T>.minFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = minFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, R>,
-): DataFrame<T> = Aggregators.min<R>(skipNaN).aggregateAll(this, columns)
+): DataFrame<T> = Aggregators.min.invoke(skipNaN).cast<R>().aggregateAll(this, columns)
 
 public fun <T> PivotGroupBy<T>.min(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T> =
     min(skipNaN) { columns.toComparableColumns() }
 
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(
     vararg columns: ColumnReference<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = min(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(
     vararg columns: KProperty<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = min(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.minOf(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.minOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): DataFrame<T> = aggregate { minOf(skipNaN, rowExpression) }
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.minBy(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.minBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivotGroupBy<T> = reduce { minByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.minBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = reduce { minByOrNull(column, skipNaN) }
@@ -456,7 +457,7 @@ public fun <T> PivotGroupBy<T>.minBy(column: String, skipNaN: Boolean = skipNaND
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.minBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = minBy(column.toColumnAccessor(), skipNaN)
@@ -473,26 +474,26 @@ public fun <T : Comparable<T>> DataColumn<T?>.min(): T = min(skipNaN = skipNaNDe
 public fun <T : Comparable<T>> DataColumn<T?>.minOrNull(): T? = minOrNull(skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minBy(noinline selector: (T) -> R): T & Any =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minBy(noinline selector: (T) -> R): T =
     minBy(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minByOrNull(noinline selector: (T) -> R): T? =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minByOrNull(noinline selector: (T) -> R): T? =
     minByOrNull(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minOf(crossinline selector: (T) -> R): R & Any =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minOf(crossinline selector: (T) -> R): R =
     minOf(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minOfOrNull(crossinline selector: (T) -> R): R? =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minOfOrNull(crossinline selector: (T) -> R): R? =
     minOfOrNull(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public inline fun <reified T : Comparable<T>> AnyRow.rowMinOfOrNull(): T? = rowMinOfOrNull<T>(skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <reified T : Comparable<T & Any>?> AnyRow.rowMinOf(): T & Any = rowMinOf(skipNaN = skipNaNDefault)
+public inline fun <reified T : Comparable<T>> AnyRow.rowMinOf(): T = rowMinOf(skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public fun <T> DataFrame<T>.min(): DataRow<T> = min(skipNaN = skipNaNDefault)
@@ -516,7 +517,7 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.minFor(vararg columns: KProperty
     minFor(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(columns: ColumnsSelector<T, C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.min(columns: ColumnsSelector<T, C>): C =
     min(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -525,16 +526,16 @@ public fun <T> DataFrame<T>.min(vararg columns: String): Comparable<Any> =
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(vararg columns: ColumnReference<C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.min(vararg columns: ColumnReference<C>): C =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(vararg columns: KProperty<C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.min(vararg columns: KProperty<C>): C =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(columns: ColumnsSelector<T, C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(columns: ColumnsSelector<T, C>): C? =
     minOrNull(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -543,26 +544,25 @@ public fun <T> DataFrame<T>.minOrNull(vararg columns: String): Comparable<Any>?
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(vararg columns: ColumnReference<C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(vararg columns: ColumnReference<C>): C? =
     minOrNull(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(vararg columns: KProperty<C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(vararg columns: KProperty<C>): C? =
     minOrNull(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minOf(
-    crossinline expression: RowExpression<T, C>,
-): C & Any = minOf(skipNaN = skipNaNDefault, expression = expression)
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minOf(crossinline expression: RowExpression<T, C>): C =
+    minOf(skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minOfOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minOfOrNull(
     crossinline expression: RowExpression<T, C>,
 ): C? = minOfOrNull(skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T> = minBy(skipNaN = skipNaNDefault, expression = expression)
 
@@ -571,16 +571,16 @@ public fun <T> DataFrame<T>.minBy(column: String): DataRow<T> = minBy(column, sk
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(column: ColumnReference<C>): DataRow<T> =
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(column: ColumnReference<C>): DataRow<T> =
     minBy(column, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(column: KProperty<C>): DataRow<T> =
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(column: KProperty<C>): DataRow<T> =
     minBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T>? = minByOrNull(skipNaN = skipNaNDefault, expression = expression)
 
@@ -589,13 +589,12 @@ public fun <T> DataFrame<T>.minByOrNull(column: String): DataRow<T>? = minByOrNu
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(
-    column: ColumnReference<C>,
-): DataRow<T>? = minByOrNull(column, skipNaN = skipNaNDefault)
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(column: ColumnReference<C>): DataRow<T>? =
+    minByOrNull(column, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(column: KProperty<C>): DataRow<T>? =
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(column: KProperty<C>): DataRow<T>? =
     minByOrNull(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -620,7 +619,7 @@ public fun <T, C : Comparable<*>?> Grouped<T>.minFor(vararg columns: KProperty<C
     minFor(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
+public fun <T, C : Comparable<*>?> Grouped<T>.min(
     name: String? = null,
     columns: ColumnsSelector<T, C?>,
 ): DataFrame<T> = min(name, skipNaN = skipNaNDefault, columns = columns)
@@ -631,32 +630,30 @@ public fun <T> Grouped<T>.min(vararg columns: String, name: String? = null): Dat
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
+public fun <T, C : Comparable<*>?> Grouped<T>.min(
     vararg columns: ColumnReference<C>,
     name: String? = null,
 ): DataFrame<T> = min(columns = columns, name = name, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
-    vararg columns: KProperty<C>,
-    name: String? = null,
-): DataFrame<T> = min(columns = columns, name = name, skipNaN = skipNaNDefault)
+public fun <T, C : Comparable<*>?> Grouped<T>.min(vararg columns: KProperty<C>, name: String? = null): DataFrame<T> =
+    min(columns = columns, name = name, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> Grouped<T>.minOf(
+public inline fun <T, reified C : Comparable<*>?> Grouped<T>.minOf(
     name: String? = null,
     crossinline expression: RowExpression<T, C>,
 ): DataFrame<T> = minOf(name, skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.minBy(
+public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.minBy(
     crossinline rowExpression: RowExpression<G, R>,
 ): ReducedGroupBy<T, G> = minBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.minBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.minBy(
     column: ColumnReference<C>,
 ): ReducedGroupBy<T, G> = minBy(column, skipNaN = skipNaNDefault)
 
@@ -665,9 +662,8 @@ public fun <T, G> GroupBy<T, G>.minBy(column: String): ReducedGroupBy<T, G> = mi
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.minBy(
-    column: KProperty<C>,
-): ReducedGroupBy<T, G> = minBy(column, skipNaN = skipNaNDefault)
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.minBy(column: KProperty<C>): ReducedGroupBy<T, G> =
+    minBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public fun <T> Pivot<T>.min(separate: Boolean = false): DataRow<T> = min(separate, skipNaN = skipNaNDefault)
@@ -697,32 +693,32 @@ public fun <T, R : Comparable<*>?> Pivot<T>.minFor(
 ): DataRow<T> = minFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(columns: ColumnsSelector<T, R>): DataRow<T> =
+public fun <T, R : Comparable<*>?> Pivot<T>.min(columns: ColumnsSelector<T, R>): DataRow<T> =
     min(skipNaN = skipNaNDefault, columns = columns)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(vararg columns: ColumnReference<R>): DataRow<T> =
+public fun <T, R : Comparable<*>?> Pivot<T>.min(vararg columns: ColumnReference<R>): DataRow<T> =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(vararg columns: KProperty<R>): DataRow<T> =
+public fun <T, R : Comparable<*>?> Pivot<T>.min(vararg columns: KProperty<R>): DataRow<T> =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.minOf(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.minOf(
     crossinline rowExpression: RowExpression<T, R>,
 ): DataRow<T> = minOf(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.minBy(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.minBy(
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivot<T> = minBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.minBy(column: ColumnReference<C>): ReducedPivot<T> =
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.minBy(column: ColumnReference<C>): ReducedPivot<T> =
     minBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -730,7 +726,7 @@ public fun <T> Pivot<T>.minBy(column: String): ReducedPivot<T> = minBy(column, s
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.minBy(column: KProperty<C>): ReducedPivot<T> =
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.minBy(column: KProperty<C>): ReducedPivot<T> =
     minBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -761,7 +757,7 @@ public fun <T, R : Comparable<*>?> PivotGroupBy<T>.minFor(
 ): DataFrame<T> = minFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(columns: ColumnsSelector<T, R>): DataFrame<T> =
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(columns: ColumnsSelector<T, R>): DataFrame<T> =
     min(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -769,27 +765,27 @@ public fun <T> PivotGroupBy<T>.min(vararg columns: String): DataFrame<T> =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(vararg columns: ColumnReference<R>): DataFrame<T> =
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(vararg columns: ColumnReference<R>): DataFrame<T> =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(vararg columns: KProperty<R>): DataFrame<T> =
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(vararg columns: KProperty<R>): DataFrame<T> =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.minOf(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.minOf(
     crossinline rowExpression: RowExpression<T, R>,
 ): DataFrame<T> = minOf(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.minBy(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.minBy(
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivotGroupBy<T> = minBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.minBy(
     column: ColumnReference<C>,
 ): ReducedPivotGroupBy<T> = minBy(column, skipNaN = skipNaNDefault)
 
@@ -798,8 +794,7 @@ public fun <T> PivotGroupBy<T>.minBy(column: String): ReducedPivotGroupBy<T> = m
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.minBy(
-    column: KProperty<C>,
-): ReducedPivotGroupBy<T> = minBy(column, skipNaN = skipNaNDefault)
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.minBy(column: KProperty<C>): ReducedPivotGroupBy<T> =
+    minBy(column, skipNaN = skipNaNDefault)
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/percentile.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/percentile.kt
index be666a8448..3809746da6 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/percentile.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/percentile.kt
@@ -15,6 +15,8 @@ import org.jetbrains.kotlinx.dataframe.annotations.Refine
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 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.aggregators.cast2
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.intraComparableColumns
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateByOrNull
@@ -48,53 +50,53 @@ import kotlin.reflect.KProperty
 
 // region DataColumn
 
-public fun <T : Comparable<T & Any>?> DataColumn<T>.percentile(percentile: Double): T & Any =
+public fun <T : Comparable<*>?> DataColumn<T>.percentile(percentile: Double): T =
     percentileOrNull(percentile).suggestIfNull("percentile")
 
-public fun <T : Comparable<T & Any>?> DataColumn<T>.percentileOrNull(percentile: Double): T? =
-    Aggregators.percentileComparables<T>(percentile).aggregateSingleColumn(this)
+public fun <T : Comparable<*>?> DataColumn<T>.percentileOrNull(percentile: Double): T? =
+    Aggregators.percentile(percentile, skipNaNDefault).cast<T>().aggregateSingleColumn(this)
 
 public fun <T> DataColumn<T>.percentile(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where T : Comparable<T & Any>?, T : Number? =
+    where T : Comparable<*>?, T : Number? =
     percentileOrNull(percentile = percentile, skipNaN = skipNaN).suggestIfNull("percentile")
 
 public fun <T> DataColumn<T>.percentileOrNull(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where T : Comparable<T & Any>?, T : Number? =
-    Aggregators.percentileNumbers<T>(percentile, skipNaN).aggregateSingleColumn(this)
+    where T : Comparable<*>?, T : Number? =
+    Aggregators.percentile(percentile, skipNaN).cast2<T & Any, Double?>().aggregateSingleColumn(this)
 
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.percentileBy(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.percentileBy(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T & Any = percentileByOrNull(percentile, skipNaN, selector).suggestIfNull("percentileBy")
+): T = percentileByOrNull(percentile, skipNaN, selector).suggestIfNull("percentileBy")
 
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.percentileByOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.percentileByOrNull(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T? = Aggregators.percentileCommon<R>(percentile, skipNaN).aggregateByOrNull(this, selector)
+): T? = Aggregators.percentile(percentile, skipNaN).cast<R>().aggregateByOrNull(this, selector)
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.percentileOf(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.percentileOf(
     percentile: Double,
     crossinline expression: (T) -> R,
-): R & Any = percentileOfOrNull(percentile, expression).suggestIfNull("percentileOf")
+): R = percentileOfOrNull(percentile, expression).suggestIfNull("percentileOf")
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.percentileOfOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.percentileOfOrNull(
     percentile: Double,
     crossinline expression: (T) -> R,
-): R? = Aggregators.percentileComparables<R>(percentile).aggregateOf(this, expression)
+): R? = Aggregators.percentile(percentile, skipNaNDefault).cast<R>().aggregateOf(this, expression)
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataColumn<T>.percentileOf(
@@ -102,7 +104,7 @@ public inline fun <T, reified R> DataColumn<T>.percentileOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: (T) -> R,
 ): Double
-    where R : Comparable<R & Any>?, R : Number? =
+    where R : Comparable<*>?, R : Number? =
     percentileOfOrNull(percentile, skipNaN, expression).suggestIfNull("percentileOf")
 
 @OverloadResolutionByLambdaReturnType
@@ -111,8 +113,8 @@ public inline fun <T, reified R> DataColumn<T>.percentileOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: (T) -> R,
 ): Double?
-    where R : Comparable<R & Any>?, R : Number? =
-    Aggregators.percentileNumbers<R>(percentile, skipNaN).aggregateOf(this, expression)
+    where R : Comparable<*>?, R : Number? =
+    Aggregators.percentile(percentile, skipNaN).cast2<R & Any, Double?>().aggregateOf(this, expression)
 
 // endregion
 
@@ -184,18 +186,16 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.percentileFor(
 
 // TODO, requires explicit type C due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentile(
-    percentile: Double,
-    columns: ColumnsSelector<T, C>,
-): C & Any = percentileOrNull(percentile, columns).suggestIfNull("percentile")
+public fun <T, C : Comparable<*>?> DataFrame<T>.percentile(percentile: Double, columns: ColumnsSelector<T, C>): C =
+    percentileOrNull(percentile, columns).suggestIfNull("percentile")
 
 // TODO, requires explicit type C due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
 @Suppress("UNCHECKED_CAST")
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentileOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.percentileOrNull(
     percentile: Double,
     columns: ColumnsSelector<T, C>,
-): C? = Aggregators.percentileComparables<C>(percentile).aggregateAll(this, columns)
+): C? = Aggregators.percentile(percentile, skipNaNDefault).cast<C>().aggregateAll(this, columns)
 
 @OverloadResolutionByLambdaReturnType
 public fun <T, C> DataFrame<T>.percentile(
@@ -203,7 +203,7 @@ public fun <T, C> DataFrame<T>.percentile(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
 ): Double
-    where C : Number?, C : Comparable<C & Any>? =
+    where C : Number?, C : Comparable<*>? =
     percentileOrNull(percentile, skipNaN, columns).suggestIfNull("percentile")
 
 @OverloadResolutionByLambdaReturnType
@@ -213,8 +213,8 @@ public fun <T, C> DataFrame<T>.percentileOrNull(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
 ): Double?
-    where C : Comparable<C & Any>?, C : Number? =
-    Aggregators.percentileNumbers<C>(percentile, skipNaN).aggregateAll(this, columns)
+    where C : Comparable<*>?, C : Number? =
+    Aggregators.percentile(percentile, skipNaN).cast2<C & Any, Double?>().aggregateAll(this, columns)
 
 public fun <T> DataFrame<T>.percentile(
     percentile: Double,
@@ -231,14 +231,12 @@ public fun <T> DataFrame<T>.percentileOrNull(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentile(
-    percentile: Double,
-    vararg columns: ColumnReference<C>,
-): C & Any = percentileOrNull(percentile, *columns).suggestIfNull("percentile")
+public fun <T, C : Comparable<*>?> DataFrame<T>.percentile(percentile: Double, vararg columns: ColumnReference<C>): C =
+    percentileOrNull(percentile, *columns).suggestIfNull("percentile")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentileOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.percentileOrNull(
     percentile: Double,
     vararg columns: ColumnReference<C>,
 ): C? = percentileOrNull<T, C>(percentile) { columns.toColumnSet() }
@@ -250,7 +248,7 @@ public fun <T, C> DataFrame<T>.percentile(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where C : Comparable<C & Any>?, C : Number? =
+    where C : Comparable<*>?, C : Number? =
     percentileOrNull(percentile, *columns, skipNaN = skipNaN).suggestIfNull("percentile")
 
 @Deprecated(DEPRECATED_ACCESS_API)
@@ -260,19 +258,16 @@ public fun <T, C> DataFrame<T>.percentileOrNull(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where C : Comparable<C & Any>?, C : Number? =
-    percentileOrNull(percentile, skipNaN) { columns.toColumnSet() }
+    where C : Comparable<*>?, C : Number? = percentileOrNull(percentile, skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentile(
-    percentile: Double,
-    vararg columns: KProperty<C>,
-): C & Any = percentileOrNull(percentile, *columns).suggestIfNull("percentile")
+public fun <T, C : Comparable<*>?> DataFrame<T>.percentile(percentile: Double, vararg columns: KProperty<C>): C =
+    percentileOrNull(percentile, *columns).suggestIfNull("percentile")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentileOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.percentileOrNull(
     percentile: Double,
     vararg columns: KProperty<C>,
 ): C? = percentileOrNull<T, C>(percentile) { columns.toColumnSet() }
@@ -284,7 +279,7 @@ public fun <T, C> DataFrame<T>.percentile(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where C : Comparable<C & Any>?, C : Number? =
+    where C : Comparable<*>?, C : Number? =
     percentileOrNull(percentile, *columns, skipNaN = skipNaN).suggestIfNull("percentile")
 
 @Deprecated(DEPRECATED_ACCESS_API)
@@ -294,22 +289,21 @@ public fun <T, C> DataFrame<T>.percentileOrNull(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where C : Comparable<C & Any>?, C : Number? =
-    percentileOrNull(percentile, skipNaN) { columns.toColumnSet() }
+    where C : Comparable<*>?, C : Number? = percentileOrNull(percentile, skipNaN) { columns.toColumnSet() }
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataFrame<T>.percentileOf(
+public inline fun <T, reified R : Comparable<*>?> DataFrame<T>.percentileOf(
     percentile: Double,
     crossinline expression: RowExpression<T, R>,
-): R & Any = percentileOfOrNull(percentile, expression).suggestIfNull("percentileOf")
+): R = percentileOfOrNull(percentile, expression).suggestIfNull("percentileOf")
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataFrame<T>.percentileOfOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataFrame<T>.percentileOfOrNull(
     percentile: Double,
     crossinline expression: RowExpression<T, R>,
-): R? = Aggregators.percentileComparables<R>(percentile).aggregateOf(this, expression)
+): R? = Aggregators.percentile(percentile, skipNaNDefault).cast<R>().aggregateOf(this, expression)
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataFrame<T>.percentileOf(
@@ -317,7 +311,7 @@ public inline fun <T, reified R> DataFrame<T>.percentileOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): Double
-    where R : Comparable<R & Any>?, R : Number? =
+    where R : Comparable<*>?, R : Number? =
     percentileOfOrNull(percentile, skipNaN, expression).suggestIfNull("percentileOf")
 
 @OverloadResolutionByLambdaReturnType
@@ -326,10 +320,10 @@ public inline fun <T, reified R> DataFrame<T>.percentileOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): Double?
-    where R : Comparable<R & Any>?, R : Number? =
-    Aggregators.percentileNumbers<R>(percentile, skipNaN).aggregateOf(this, expression)
+    where R : Comparable<*>?, R : Number? =
+    Aggregators.percentile(percentile, skipNaN).cast2<R & Any, Double?>().aggregateOf(this, expression)
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileBy(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
@@ -343,7 +337,7 @@ public fun <T> DataFrame<T>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileBy(
     percentile: Double,
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -351,17 +345,17 @@ public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileB
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileBy(
     percentile: Double,
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = percentileByOrNull(percentile, column, skipNaN).suggestIfNull("percentileBy")
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileByOrNull(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataRow<T>? = Aggregators.percentileCommon<C>(percentile, skipNaN).aggregateByOrNull(this, expression)
+): DataRow<T>? = Aggregators.percentile(percentile, skipNaN).cast<C>().aggregateByOrNull(this, expression)
 
 public fun <T> DataFrame<T>.percentileByOrNull(
     percentile: Double,
@@ -371,15 +365,15 @@ public fun <T> DataFrame<T>.percentileByOrNull(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileByOrNull(
     percentile: Double,
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): DataRow<T>? = Aggregators.percentileCommon<C>(percentile, skipNaN).aggregateByOrNull(this, column)
+): DataRow<T>? = Aggregators.percentile(percentile, skipNaN).cast<C>().aggregateByOrNull(this, column)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileByOrNull(
     percentile: Double,
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -422,12 +416,12 @@ public fun <T, C : Comparable<*>?> Grouped<T>.percentileFor(
 
 @Refine
 @Interpretable("GroupByPercentile2")
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(
+public fun <T, C : Comparable<*>?> Grouped<T>.percentile(
     percentile: Double,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): DataFrame<T> = Aggregators.percentileCommon<C>(percentile, skipNaN).aggregateAll(this, name, columns)
+): DataFrame<T> = Aggregators.percentile(percentile, skipNaN).cast<C>().aggregateAll(this, name, columns)
 
 public fun <T> Grouped<T>.percentile(
     percentile: Double,
@@ -438,7 +432,7 @@ public fun <T> Grouped<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(
+public fun <T, C : Comparable<*>?> Grouped<T>.percentile(
     percentile: Double,
     vararg columns: ColumnReference<C>,
     name: String? = null,
@@ -447,7 +441,7 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(
+public fun <T, C : Comparable<*>?> Grouped<T>.percentile(
     percentile: Double,
     vararg columns: KProperty<C>,
     name: String? = null,
@@ -456,15 +450,15 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(
 
 @Refine
 @Interpretable("GroupByPercentileOf")
-public inline fun <T, reified R : Comparable<R & Any>?> Grouped<T>.percentileOf(
+public inline fun <T, reified R : Comparable<*>?> Grouped<T>.percentileOf(
     percentile: Double,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
-): DataFrame<T> = Aggregators.percentileCommon<R>(percentile, skipNaN).aggregateOf(this, name, expression)
+): DataFrame<T> = Aggregators.percentile(percentile, skipNaN).cast<R>().aggregateOf(this, name, expression)
 
 @Interpretable("GroupByReduceExpression") // TODO?
-public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.percentileBy(
+public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.percentileBy(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<G, R>,
@@ -472,7 +466,7 @@ public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.percent
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.percentileBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.percentileBy(
     percentile: Double,
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -486,7 +480,7 @@ public fun <T, G> GroupBy<T, G>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.percentileBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.percentileBy(
     percentile: Double,
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -534,7 +528,7 @@ public fun <T, C : Comparable<*>?> Pivot<T>.percentileFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = percentileFor(percentile, separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.percentile(
+public fun <T, C : Comparable<*>?> Pivot<T>.percentile(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
@@ -548,7 +542,7 @@ public fun <T> Pivot<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.percentile(
+public fun <T, C : Comparable<*>?> Pivot<T>.percentile(
     percentile: Double,
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -556,19 +550,19 @@ public fun <T, C : Comparable<C & Any>?> Pivot<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.percentile(
+public fun <T, C : Comparable<*>?> Pivot<T>.percentile(
     percentile: Double,
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = percentile(percentile, skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.percentileOf(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.percentileOf(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): DataRow<T> = delegate { percentileOf(percentile, skipNaN, expression) }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.percentileBy(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.percentileBy(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
@@ -576,7 +570,7 @@ public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.percentileBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.percentileBy(
     percentile: Double,
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -590,7 +584,7 @@ public fun <T> Pivot<T>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.percentileBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.percentileBy(
     percentile: Double,
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -637,11 +631,11 @@ public fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentileFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = percentileFor(percentile, separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.percentile(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentile(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): DataFrame<T> = Aggregators.percentileCommon<C>(percentile, skipNaN).aggregateAll(this, columns)
+): DataFrame<T> = Aggregators.percentile(percentile, skipNaN).cast<C>().aggregateAll(this, columns)
 
 public fun <T> PivotGroupBy<T>.percentile(
     percentile: Double,
@@ -651,7 +645,7 @@ public fun <T> PivotGroupBy<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.percentile(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentile(
     percentile: Double,
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -659,19 +653,19 @@ public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.percentile(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentile(
     percentile: Double,
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = percentile(percentile, skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.percentileOf(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.percentileOf(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
-): DataFrame<T> = Aggregators.percentileCommon<R>(percentile, skipNaN).aggregateOf(this, expression)
+): DataFrame<T> = Aggregators.percentile(percentile, skipNaN).cast<R>().aggregateOf(this, expression)
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.percentileBy(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.percentileBy(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
@@ -679,7 +673,7 @@ public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.percenti
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.percentileBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.percentileBy(
     percentile: Double,
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -693,7 +687,7 @@ public fun <T> PivotGroupBy<T>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.percentileBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.percentileBy(
     percentile: Double,
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,

From 378ae5bc6585c91e40d08607c24debe349c39f4e Mon Sep 17 00:00:00 2001
From: "andrei.kislitsyn" <kisandy@yandex.ru>
Date: Tue, 25 Nov 2025 18:17:57 +0400
Subject: [PATCH 04/16] increase Gradle JVM heap size to 32G

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle.properties b/gradle.properties
index 532fc3a057..464306775d 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,7 +2,7 @@ projectName=dataframe
 version=1.0.0
 jupyterApiTCRepo=
 kotlin.jupyter.add.scanner=false
-org.gradle.jvmargs=-Xmx16G -Duser.language=en -Duser.country=US -Dfile.encoding=UTF-8
+org.gradle.jvmargs=-Xmx32G -Duser.language=en -Duser.country=US -Dfile.encoding=UTF-8
 
 # build.number.detection=false
 # build.number=0.8.0

From 057598817a9da26f372e156cd6c22882ffe71a70 Mon Sep 17 00:00:00 2001
From: "andrei.kislitsyn" <kisandy@yandex.ru>
Date: Tue, 25 Nov 2025 18:44:31 +0400
Subject: [PATCH 05/16] Revert "increase Gradle JVM heap size to 32G"

This reverts commit 378ae5bc6585c91e40d08607c24debe349c39f4e.
---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle.properties b/gradle.properties
index 464306775d..532fc3a057 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,7 +2,7 @@ projectName=dataframe
 version=1.0.0
 jupyterApiTCRepo=
 kotlin.jupyter.add.scanner=false
-org.gradle.jvmargs=-Xmx32G -Duser.language=en -Duser.country=US -Dfile.encoding=UTF-8
+org.gradle.jvmargs=-Xmx16G -Duser.language=en -Duser.country=US -Dfile.encoding=UTF-8
 
 # build.number.detection=false
 # build.number=0.8.0

From 49d1d983960f50937d35883ae69d55d241f44ae0 Mon Sep 17 00:00:00 2001
From: "andrei.kislitsyn" <kisandy@yandex.ru>
Date: Tue, 25 Nov 2025 18:44:57 +0400
Subject: [PATCH 06/16] temporary ignore notebooks tests

---
 .../jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt b/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
index d935473f3f..7cad1033cf 100644
--- a/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
+++ b/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
@@ -9,6 +9,7 @@ import org.jetbrains.kotlinx.jupyter.repl.result.EvalResultEx
 import org.junit.Assume
 import org.junit.AssumptionViolatedException
 import org.junit.Before
+import org.junit.Ignore
 import org.junit.Test
 import java.io.File
 import java.util.Locale
@@ -18,6 +19,7 @@ import java.util.Locale
  * debug mode is on:
  * `kotlin.dataframe.debug=true`
  */
+@Ignore
 class SampleNotebooksTests : DataFrameJupyterTest() {
 
     /**

From b2c652819c1b275ba8f645574bbfae68abe87dbd Mon Sep 17 00:00:00 2001
From: "andrei.kislitsyn" <kisandy@yandex.ru>
Date: Wed, 26 Nov 2025 12:53:23 +0400
Subject: [PATCH 07/16] add kandy geo to dataframe-jupyter tests

---
 dataframe-jupyter/build.gradle.kts               |  6 +++++-
 .../dataframe/jupyter/SampleNotebooksTests.kt    |  1 -
 gradle/libs.versions.toml                        | 16 ++++------------
 3 files changed, 9 insertions(+), 14 deletions(-)

diff --git a/dataframe-jupyter/build.gradle.kts b/dataframe-jupyter/build.gradle.kts
index 00723fc9c1..4c41463267 100644
--- a/dataframe-jupyter/build.gradle.kts
+++ b/dataframe-jupyter/build.gradle.kts
@@ -36,7 +36,11 @@ dependencies {
 
     testImplementation(projects.dataframeJupyter)
     testImplementation(projects.dataframeGeoJupyter)
-    testImplementation(libs.kandy.notebook) {
+
+    testImplementation(libs.kandy) {
+        exclude("org.jetbrains.kotlinx", "dataframe")
+    }
+    testImplementation(libs.kandy.geo) {
         exclude("org.jetbrains.kotlinx", "dataframe")
     }
     testImplementation(libs.kandy.stats) {
diff --git a/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt b/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
index 7cad1033cf..dfc87e7a5e 100644
--- a/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
+++ b/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
@@ -19,7 +19,6 @@ import java.util.Locale
  * debug mode is on:
  * `kotlin.dataframe.debug=true`
  */
-@Ignore
 class SampleNotebooksTests : DataFrameJupyterTest() {
 
     /**
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 152eca7023..cf2f637c51 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -62,12 +62,8 @@ geotools = "33.2"
 jai-core = "1.1.3"
 jts = "1.20.0"
 
-# Normal examples Kandy versions
-kandy = "0.8.2-dev-90"
-
-# Example notebooks Kandy versions
-kandy-notebook = "0.8.1n"
-kandy-stats-notebook = "0.5.0n"
+kandy = "0.8.3-dev-91"
+kandy-stats= "0.5.0n"
 
 exposed = "1.0.0-beta-2"
 hibernate = "6.5.2.Final"
@@ -106,14 +102,10 @@ mysql = { group = "com.mysql", name = "mysql-connector-j", version.ref = "mysql"
 postgresql = { group = "org.postgresql", name = "postgresql", version.ref = "postgresql" }
 sqlite = { group = "org.xerial", name = "sqlite-jdbc", version.ref = "sqlite" }
 
-# Example notebooks Kandy versions
-kandy-notebook = { group = "org.jetbrains.kotlinx", name = "kandy-lets-plot", version.ref = "kandy-notebook" }
-# -- Requires repo: https://packages.jetbrains.team/maven/p/kds/kotlin-ds-maven
-kandy-stats = { group = "org.jetbrains.kotlinx", name = "kotlin-statistics-jvm", version.ref = "kandy-stats-notebook" }
-
-# Normal examples Kandy versions
 kandy = { group = "org.jetbrains.kotlinx", name = "kandy-lets-plot", version.ref = "kandy" }
+kandy-geo = { group = "org.jetbrains.kotlinx", name = "kandy-geo", version.ref = "kandy" }
 kandy-samples-utils = { group = "org.jetbrains.kotlinx", name = "kandy-samples-utils", version.ref = "kandy" }
+kandy-stats = { group = "org.jetbrains.kotlinx", name = "kotlin-statistics-jvm", version.ref = "kandy-stats" }
 
 poi-ooxml = { group = "org.apache.poi", name = "poi-ooxml", version.ref = "poi" }
 kotlin-datetimeJvm = { group = "org.jetbrains.kotlinx", name = "kotlinx-datetime-jvm", version.ref = "kotlinDatetime" }

From 2c6324cb65a52f15be8dc8994cecf3012772f048 Mon Sep 17 00:00:00 2001
From: "andrei.kislitsyn" <kisandy@yandex.ru>
Date: Wed, 26 Nov 2025 12:54:31 +0400
Subject: [PATCH 08/16] ktlint format

---
 .../jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt  | 1 -
 1 file changed, 1 deletion(-)

diff --git a/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt b/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
index dfc87e7a5e..d935473f3f 100644
--- a/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
+++ b/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
@@ -9,7 +9,6 @@ import org.jetbrains.kotlinx.jupyter.repl.result.EvalResultEx
 import org.junit.Assume
 import org.junit.AssumptionViolatedException
 import org.junit.Before
-import org.junit.Ignore
 import org.junit.Test
 import java.io.File
 import java.util.Locale

From 07fcff99109f850c40f9582c5e5205c925d49ad0 Mon Sep 17 00:00:00 2001
From: "andrei.kislitsyn" <kisandy@yandex.ru>
Date: Wed, 26 Nov 2025 13:23:17 +0400
Subject: [PATCH 09/16] ignore netflix notebook

---
 .../jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt b/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
index d935473f3f..e4ab2de87d 100644
--- a/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
+++ b/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
@@ -9,6 +9,7 @@ import org.jetbrains.kotlinx.jupyter.repl.result.EvalResultEx
 import org.junit.Assume
 import org.junit.AssumptionViolatedException
 import org.junit.Before
+import org.junit.Ignore
 import org.junit.Test
 import java.io.File
 import java.util.Locale
@@ -62,6 +63,7 @@ class SampleNotebooksTests : DataFrameJupyterTest() {
             ),
         )
 
+    @Ignore
     @Test
     fun netflix() {
         val currentLocale = Locale.getDefault()

From b84920dbb59565e8f00d0b999848133942817b9a Mon Sep 17 00:00:00 2001
From: "andrei.kislitsyn" <kisandy@yandex.ru>
Date: Wed, 26 Nov 2025 16:29:52 +0400
Subject: [PATCH 10/16] increase tests heap size

---
 dataframe-jupyter/build.gradle.kts                              | 2 +-
 .../jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt | 1 -
 gradle/libs.versions.toml                                       | 2 +-
 3 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/dataframe-jupyter/build.gradle.kts b/dataframe-jupyter/build.gradle.kts
index 4c41463267..517442e38d 100644
--- a/dataframe-jupyter/build.gradle.kts
+++ b/dataframe-jupyter/build.gradle.kts
@@ -65,7 +65,7 @@ tasks.processJupyterApiResources {
 }
 
 tasks.test {
-    maxHeapSize = "2048m"
+    maxHeapSize = "8192m"
 }
 
 kotlinPublications {
diff --git a/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt b/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
index e4ab2de87d..dfc87e7a5e 100644
--- a/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
+++ b/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
@@ -63,7 +63,6 @@ class SampleNotebooksTests : DataFrameJupyterTest() {
             ),
         )
 
-    @Ignore
     @Test
     fun netflix() {
         val currentLocale = Locale.getDefault()
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index cf2f637c51..72d4b3f743 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -63,7 +63,7 @@ jai-core = "1.1.3"
 jts = "1.20.0"
 
 kandy = "0.8.3-dev-91"
-kandy-stats= "0.5.0n"
+kandy-stats= "0.5.1-dev-1"
 
 exposed = "1.0.0-beta-2"
 hibernate = "6.5.2.Final"

From 6376365599654a082a5d272327703f6de78a63ae Mon Sep 17 00:00:00 2001
From: "andrei.kislitsyn" <kisandy@yandex.ru>
Date: Wed, 26 Nov 2025 16:36:41 +0400
Subject: [PATCH 11/16] ktlint format

---
 .../jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt  | 1 -
 1 file changed, 1 deletion(-)

diff --git a/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt b/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
index dfc87e7a5e..d935473f3f 100644
--- a/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
+++ b/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
@@ -9,7 +9,6 @@ import org.jetbrains.kotlinx.jupyter.repl.result.EvalResultEx
 import org.junit.Assume
 import org.junit.AssumptionViolatedException
 import org.junit.Before
-import org.junit.Ignore
 import org.junit.Test
 import java.io.File
 import java.util.Locale

From 495b54c002feceb7f32cac5139c8f247f5fbfe1b Mon Sep 17 00:00:00 2001
From: "andrei.kislitsyn" <kisandy@yandex.ru>
Date: Tue, 2 Dec 2025 18:33:44 +0400
Subject: [PATCH 12/16] ignore notebook tests

---
 .../jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt b/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
index d935473f3f..7cad1033cf 100644
--- a/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
+++ b/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
@@ -9,6 +9,7 @@ import org.jetbrains.kotlinx.jupyter.repl.result.EvalResultEx
 import org.junit.Assume
 import org.junit.AssumptionViolatedException
 import org.junit.Before
+import org.junit.Ignore
 import org.junit.Test
 import java.io.File
 import java.util.Locale
@@ -18,6 +19,7 @@ import java.util.Locale
  * debug mode is on:
  * `kotlin.dataframe.debug=true`
  */
+@Ignore
 class SampleNotebooksTests : DataFrameJupyterTest() {
 
     /**

From 3fe1eeb45b4a2be10e128eb9f6d927c12607c72e Mon Sep 17 00:00:00 2001
From: "andrei.kislitsyn" <kisandy@yandex.ru>
Date: Wed, 3 Dec 2025 13:11:55 +0400
Subject: [PATCH 13/16] unignore notebook tests

---
 .../jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt  | 1 -
 1 file changed, 1 deletion(-)

diff --git a/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt b/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
index 7cad1033cf..dfc87e7a5e 100644
--- a/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
+++ b/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
@@ -19,7 +19,6 @@ import java.util.Locale
  * debug mode is on:
  * `kotlin.dataframe.debug=true`
  */
-@Ignore
 class SampleNotebooksTests : DataFrameJupyterTest() {
 
     /**

From 1517c57a123d50ad58ac0ea32f5d31365bc1dd18 Mon Sep 17 00:00:00 2001
From: "andrei.kislitsyn" <kisandy@yandex.ru>
Date: Wed, 3 Dec 2025 13:13:36 +0400
Subject: [PATCH 14/16] remove unused import

---
 .../jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt  | 1 -
 1 file changed, 1 deletion(-)

diff --git a/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt b/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
index dfc87e7a5e..d935473f3f 100644
--- a/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
+++ b/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
@@ -9,7 +9,6 @@ import org.jetbrains.kotlinx.jupyter.repl.result.EvalResultEx
 import org.junit.Assume
 import org.junit.AssumptionViolatedException
 import org.junit.Before
-import org.junit.Ignore
 import org.junit.Test
 import java.io.File
 import java.util.Locale

From 63736072db1dc6b9635a0a933183d8807fcb5c61 Mon Sep 17 00:00:00 2001
From: "andrei.kislitsyn" <kisandy@yandex.ru>
Date: Wed, 3 Dec 2025 13:45:22 +0400
Subject: [PATCH 15/16] ignore notebook tests

---
 .../jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt b/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
index d935473f3f..7cad1033cf 100644
--- a/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
+++ b/dataframe-jupyter/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
@@ -9,6 +9,7 @@ import org.jetbrains.kotlinx.jupyter.repl.result.EvalResultEx
 import org.junit.Assume
 import org.junit.AssumptionViolatedException
 import org.junit.Before
+import org.junit.Ignore
 import org.junit.Test
 import java.io.File
 import java.util.Locale
@@ -18,6 +19,7 @@ import java.util.Locale
  * debug mode is on:
  * `kotlin.dataframe.debug=true`
  */
+@Ignore
 class SampleNotebooksTests : DataFrameJupyterTest() {
 
     /**

From 681c34aa95ed8c888e052d60427c330d83c7732e Mon Sep 17 00:00:00 2001
From: "andrei.kislitsyn" <kisandy@yandex.ru>
Date: Wed, 3 Dec 2025 20:42:25 +0400
Subject: [PATCH 16/16] update version to 1.0.0-Beta4n

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle.properties b/gradle.properties
index 532fc3a057..5612ca868c 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,5 +1,5 @@
 projectName=dataframe
-version=1.0.0
+version=1.0.0-Beta4n
 jupyterApiTCRepo=
 kotlin.jupyter.add.scanner=false
 org.gradle.jvmargs=-Xmx16G -Duser.language=en -Duser.country=US -Dfile.encoding=UTF-8