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 511376b9de..e57d6fa9c9 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
@@ -81,24 +81,24 @@ public fun <T> DataFrame<T>.max(skipNaN: Boolean = skipNaNDefault): DataRow<T> =
 
 @Refine
 @Interpretable("Max1")
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxFor(
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxFor(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsForAggregateSelector<T, C>,
-): DataRow<T> = Aggregators.max<C>(skipNaN).aggregateFor(this, columns)
+): DataRow<T> = Aggregators.max.invoke(skipNaN).aggregateFor(this, columns)
 
 public fun <T> DataFrame<T>.maxFor(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataRow<T> =
     maxFor(skipNaN) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxFor(
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxFor(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = maxFor(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxFor(
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxFor(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = maxFor(skipNaN) { columns.toColumnSet() }
@@ -212,24 +212,24 @@ public fun <T> Grouped<T>.max(skipNaN: Boolean = skipNaNDefault): DataFrame<T> =
 
 @Refine
 @Interpretable("GroupByMax0")
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.maxFor(
+public fun <T, C : Comparable<*>?> Grouped<T>.maxFor(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsForAggregateSelector<T, C>,
-): DataFrame<T> = Aggregators.max<C>(skipNaN).aggregateFor(this, columns)
+): DataFrame<T> = Aggregators.max.invoke(skipNaN).aggregateFor(this, columns)
 
 public fun <T> Grouped<T>.maxFor(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T> =
     maxFor(skipNaN) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.maxFor(
+public fun <T, C : Comparable<*>?> Grouped<T>.maxFor(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = maxFor(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.maxFor(
+public fun <T, C : Comparable<*>?> Grouped<T>.maxFor(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = maxFor(skipNaN) { columns.toColumnSet() }
@@ -302,7 +302,7 @@ public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.maxBy(
 public fun <T> Pivot<T>.max(separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataRow<T> =
     delegate { max(separate, skipNaN) }
 
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.maxFor(
+public fun <T, R : Comparable<*>?> Pivot<T>.maxFor(
     separate: Boolean = false,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsForAggregateSelector<T, R>,
@@ -316,7 +316,7 @@ public fun <T> Pivot<T>.maxFor(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.maxFor(
+public fun <T, R : Comparable<*>?> Pivot<T>.maxFor(
     vararg columns: ColumnReference<R>,
     separate: Boolean = false,
     skipNaN: Boolean = skipNaNDefault,
@@ -324,7 +324,7 @@ public fun <T, R : Comparable<R & Any>?> Pivot<T>.maxFor(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.maxFor(
+public fun <T, R : Comparable<*>?> Pivot<T>.maxFor(
     vararg columns: KProperty<R>,
     separate: Boolean = false,
     skipNaN: Boolean = skipNaNDefault,
@@ -388,11 +388,11 @@ public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.maxBy(
 public fun <T> PivotGroupBy<T>.max(separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T> =
     maxFor(separate, skipNaN, intraComparableColumns())
 
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.maxFor(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.maxFor(
     separate: Boolean = false,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsForAggregateSelector<T, R>,
-): DataFrame<T> = Aggregators.max<R>(skipNaN).aggregateFor(this, separate, columns)
+): DataFrame<T> = Aggregators.max.invoke(skipNaN).aggregateFor(this, separate, columns)
 
 public fun <T> PivotGroupBy<T>.maxFor(
     vararg columns: String,
@@ -402,7 +402,7 @@ public fun <T> PivotGroupBy<T>.maxFor(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.maxFor(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.maxFor(
     vararg columns: ColumnReference<R>,
     separate: Boolean = false,
     skipNaN: Boolean = skipNaNDefault,
@@ -410,7 +410,7 @@ public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.maxFor(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.maxFor(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.maxFor(
     vararg columns: KProperty<R>,
     separate: Boolean = false,
     skipNaN: Boolean = skipNaNDefault,
@@ -500,7 +500,7 @@ public inline fun <reified T : Comparable<T & Any>?> AnyRow.rowMaxOf(): T & Any
 public fun <T> DataFrame<T>.max(): DataRow<T> = max(skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxFor(columns: ColumnsForAggregateSelector<T, C>): DataRow<T> =
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxFor(columns: ColumnsForAggregateSelector<T, C>): DataRow<T> =
     maxFor(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -509,12 +509,12 @@ public fun <T> DataFrame<T>.maxFor(vararg columns: String): DataRow<T> =
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxFor(vararg columns: ColumnReference<C>): DataRow<T> =
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxFor(vararg columns: ColumnReference<C>): DataRow<T> =
     maxFor(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxFor(vararg columns: KProperty<C>): DataRow<T> =
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxFor(vararg columns: KProperty<C>): DataRow<T> =
     maxFor(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -608,7 +608,7 @@ public fun <T> Grouped<T>.max(): DataFrame<T> = max(skipNaN = skipNaNDefault)
 @Refine
 @Interpretable("GroupByMax0")
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.maxFor(columns: ColumnsForAggregateSelector<T, C>): DataFrame<T> =
+public fun <T, C : Comparable<*>?> Grouped<T>.maxFor(columns: ColumnsForAggregateSelector<T, C>): DataFrame<T> =
     maxFor(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -617,12 +617,12 @@ public fun <T> Grouped<T>.maxFor(vararg columns: String): DataFrame<T> =
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.maxFor(vararg columns: ColumnReference<C>): DataFrame<T> =
+public fun <T, C : Comparable<*>?> Grouped<T>.maxFor(vararg columns: ColumnReference<C>): DataFrame<T> =
     maxFor(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.maxFor(vararg columns: KProperty<C>): DataFrame<T> =
+public fun <T, C : Comparable<*>?> Grouped<T>.maxFor(vararg columns: KProperty<C>): DataFrame<T> =
     maxFor(columns = columns, skipNaN = skipNaNDefault)
 
 @Refine
@@ -684,7 +684,7 @@ public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.maxBy(
 public fun <T> Pivot<T>.max(separate: Boolean = false): DataRow<T> = max(separate, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.maxFor(
+public fun <T, R : Comparable<*>?> Pivot<T>.maxFor(
     separate: Boolean = false,
     columns: ColumnsForAggregateSelector<T, R>,
 ): DataRow<T> = maxFor(separate, skipNaN = skipNaNDefault, columns = columns)
@@ -695,14 +695,14 @@ public fun <T> Pivot<T>.maxFor(vararg columns: String, separate: Boolean = false
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.maxFor(
+public fun <T, R : Comparable<*>?> Pivot<T>.maxFor(
     vararg columns: ColumnReference<R>,
     separate: Boolean = false,
 ): DataRow<T> = maxFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.maxFor(
+public fun <T, R : Comparable<*>?> Pivot<T>.maxFor(
     vararg columns: KProperty<R>,
     separate: Boolean = false,
 ): DataRow<T> = maxFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
@@ -748,7 +748,7 @@ public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.maxBy(column: K
 public fun <T> PivotGroupBy<T>.max(separate: Boolean = false): DataFrame<T> = max(separate, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.maxFor(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.maxFor(
     separate: Boolean = false,
     columns: ColumnsForAggregateSelector<T, R>,
 ): DataFrame<T> = maxFor(separate, skipNaN = skipNaNDefault, columns = columns)
@@ -759,14 +759,14 @@ public fun <T> PivotGroupBy<T>.maxFor(vararg columns: String, separate: Boolean
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.maxFor(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.maxFor(
     vararg columns: ColumnReference<R>,
     separate: Boolean = false,
 ): DataFrame<T> = maxFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.maxFor(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.maxFor(
     vararg columns: KProperty<R>,
     separate: Boolean = false,
 ): DataFrame<T> = maxFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
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 0bf290dc49..6a1b29daff 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
@@ -138,24 +138,24 @@ public fun <T> DataFrame<T>.median(skipNaN: Boolean = skipNaNDefault): DataRow<T
 
 @Refine
 @Interpretable("Median1")
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.medianFor(
+public fun <T, C : Comparable<*>?> DataFrame<T>.medianFor(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsForAggregateSelector<T, C>,
-): DataRow<T> = Aggregators.medianCommon<C>(skipNaN).aggregateFor(this, columns)
+): DataRow<T> = Aggregators.median.invoke(skipNaN).aggregateFor(this, columns)
 
 public fun <T> DataFrame<T>.medianFor(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataRow<T> =
     medianFor(skipNaN) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.medianFor(
+public fun <T, C : Comparable<*>?> DataFrame<T>.medianFor(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = medianFor(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.medianFor(
+public fun <T, C : Comparable<*>?> DataFrame<T>.medianFor(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = medianFor(skipNaN) { columns.toColumnSet() }
@@ -329,23 +329,23 @@ public fun <T> Grouped<T>.median(skipNaN: Boolean = skipNaNDefault): DataFrame<T
 
 @Refine
 @Interpretable("GroupByMedian0")
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.medianFor(
+public fun <T, C : Comparable<*>?> Grouped<T>.medianFor(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsForAggregateSelector<T, C>,
-): DataFrame<T> = Aggregators.medianCommon<C>(skipNaN).aggregateFor(this, columns)
+): DataFrame<T> = Aggregators.median.invoke(skipNaN).aggregateFor(this, columns)
 
 public fun <T> Grouped<T>.medianFor(vararg columns: String): DataFrame<T> = medianFor { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.medianFor(
+public fun <T, C : Comparable<*>?> Grouped<T>.medianFor(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = medianFor(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.medianFor(
+public fun <T, C : Comparable<*>?> Grouped<T>.medianFor(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = medianFor(skipNaN) { columns.toColumnSet() }
@@ -418,7 +418,7 @@ public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.medianB
 public fun <T> Pivot<T>.median(separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataRow<T> =
     medianFor(separate, skipNaN, intraComparableColumns())
 
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.medianFor(
+public fun <T, C : Comparable<*>?> Pivot<T>.medianFor(
     separate: Boolean = false,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsForAggregateSelector<T, C>,
@@ -432,7 +432,7 @@ public fun <T> Pivot<T>.medianFor(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.medianFor(
+public fun <T, C : Comparable<*>?> Pivot<T>.medianFor(
     vararg columns: ColumnReference<C>,
     separate: Boolean = false,
     skipNaN: Boolean = skipNaNDefault,
@@ -440,7 +440,7 @@ public fun <T, C : Comparable<C & Any>?> Pivot<T>.medianFor(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.medianFor(
+public fun <T, C : Comparable<*>?> Pivot<T>.medianFor(
     vararg columns: KProperty<C>,
     separate: Boolean = false,
     skipNaN: Boolean = skipNaNDefault,
@@ -501,11 +501,11 @@ public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.medianBy(
 public fun <T> PivotGroupBy<T>.median(separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T> =
     medianFor(separate, skipNaN, intraComparableColumns())
 
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.medianFor(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.medianFor(
     separate: Boolean = false,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsForAggregateSelector<T, C>,
-): DataFrame<T> = Aggregators.medianCommon<C>(skipNaN).aggregateFor(this, separate, columns)
+): DataFrame<T> = Aggregators.median.invoke(skipNaN).aggregateFor(this, separate, columns)
 
 public fun <T> PivotGroupBy<T>.medianFor(
     vararg columns: String,
@@ -515,7 +515,7 @@ public fun <T> PivotGroupBy<T>.medianFor(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.medianFor(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.medianFor(
     vararg columns: ColumnReference<C>,
     separate: Boolean = false,
     skipNaN: Boolean = skipNaNDefault,
@@ -523,7 +523,7 @@ public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.medianFor(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.medianFor(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.medianFor(
     vararg columns: KProperty<C>,
     separate: Boolean = false,
     skipNaN: Boolean = skipNaNDefault,
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 96a22b9f05..a95167945e 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
@@ -81,24 +81,24 @@ public fun <T> DataFrame<T>.min(skipNaN: Boolean = skipNaNDefault): DataRow<T> =
 
 @Refine
 @Interpretable("Min1")
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minFor(
+public fun <T, C : Comparable<*>?> DataFrame<T>.minFor(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsForAggregateSelector<T, C>,
-): DataRow<T> = Aggregators.min<C>(skipNaN).aggregateFor(this, columns)
+): DataRow<T> = Aggregators.min.invoke(skipNaN).aggregateFor(this, columns)
 
 public fun <T> DataFrame<T>.minFor(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataRow<T> =
     minFor(skipNaN) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minFor(
+public fun <T, C : Comparable<*>?> DataFrame<T>.minFor(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = minFor(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minFor(
+public fun <T, C : Comparable<*>?> DataFrame<T>.minFor(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = minFor(skipNaN) { columns.toColumnSet() }
@@ -212,24 +212,24 @@ public fun <T> Grouped<T>.min(skipNaN: Boolean = skipNaNDefault): DataFrame<T> =
 
 @Refine
 @Interpretable("GroupByMin0")
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.minFor(
+public fun <T, C : Comparable<*>?> Grouped<T>.minFor(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsForAggregateSelector<T, C>,
-): DataFrame<T> = Aggregators.min<C>(skipNaN).aggregateFor(this, columns)
+): DataFrame<T> = Aggregators.min.invoke(skipNaN).aggregateFor(this, columns)
 
 public fun <T> Grouped<T>.minFor(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T> =
     minFor(skipNaN) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.minFor(
+public fun <T, C : Comparable<*>?> Grouped<T>.minFor(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = minFor(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.minFor(
+public fun <T, C : Comparable<*>?> Grouped<T>.minFor(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = minFor(skipNaN) { columns.toColumnSet() }
@@ -302,7 +302,7 @@ public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.minBy(
 public fun <T> Pivot<T>.min(separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataRow<T> =
     delegate { min(separate, skipNaN) }
 
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.minFor(
+public fun <T, R : Comparable<*>?> Pivot<T>.minFor(
     separate: Boolean = false,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsForAggregateSelector<T, R>,
@@ -316,7 +316,7 @@ public fun <T> Pivot<T>.minFor(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.minFor(
+public fun <T, R : Comparable<*>?> Pivot<T>.minFor(
     vararg columns: ColumnReference<R>,
     separate: Boolean = false,
     skipNaN: Boolean = skipNaNDefault,
@@ -324,7 +324,7 @@ public fun <T, R : Comparable<R & Any>?> Pivot<T>.minFor(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.minFor(
+public fun <T, R : Comparable<*>?> Pivot<T>.minFor(
     vararg columns: KProperty<R>,
     separate: Boolean = false,
     skipNaN: Boolean = skipNaNDefault,
@@ -388,11 +388,11 @@ public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.minBy(
 public fun <T> PivotGroupBy<T>.min(separate: Boolean = false, skipNaN: Boolean = skipNaNDefault): DataFrame<T> =
     minFor(separate, skipNaN, intraComparableColumns())
 
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.minFor(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.minFor(
     separate: Boolean = false,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsForAggregateSelector<T, R>,
-): DataFrame<T> = Aggregators.min<R>(skipNaN).aggregateFor(this, separate, columns)
+): DataFrame<T> = Aggregators.min.invoke(skipNaN).aggregateFor(this, separate, columns)
 
 public fun <T> PivotGroupBy<T>.minFor(
     vararg columns: String,
@@ -402,7 +402,7 @@ public fun <T> PivotGroupBy<T>.minFor(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.minFor(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.minFor(
     vararg columns: ColumnReference<R>,
     separate: Boolean = false,
     skipNaN: Boolean = skipNaNDefault,
@@ -410,7 +410,7 @@ public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.minFor(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.minFor(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.minFor(
     vararg columns: KProperty<R>,
     separate: Boolean = false,
     skipNaN: Boolean = skipNaNDefault,
@@ -500,7 +500,7 @@ public inline fun <reified T : Comparable<T & Any>?> AnyRow.rowMinOf(): T & Any
 public fun <T> DataFrame<T>.min(): DataRow<T> = min(skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minFor(columns: ColumnsForAggregateSelector<T, C>): DataRow<T> =
+public fun <T, C : Comparable<*>?> DataFrame<T>.minFor(columns: ColumnsForAggregateSelector<T, C>): DataRow<T> =
     minFor(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -509,12 +509,12 @@ public fun <T> DataFrame<T>.minFor(vararg columns: String): DataRow<T> =
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minFor(vararg columns: ColumnReference<C>): DataRow<T> =
+public fun <T, C : Comparable<*>?> DataFrame<T>.minFor(vararg columns: ColumnReference<C>): DataRow<T> =
     minFor(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minFor(vararg columns: KProperty<C>): DataRow<T> =
+public fun <T, C : Comparable<*>?> DataFrame<T>.minFor(vararg columns: KProperty<C>): DataRow<T> =
     minFor(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -608,7 +608,7 @@ public fun <T> Grouped<T>.min(): DataFrame<T> = min(skipNaN = skipNaNDefault)
 @Refine
 @Interpretable("GroupByMin0")
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.minFor(columns: ColumnsForAggregateSelector<T, C>): DataFrame<T> =
+public fun <T, C : Comparable<*>?> Grouped<T>.minFor(columns: ColumnsForAggregateSelector<T, C>): DataFrame<T> =
     minFor(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -617,12 +617,12 @@ public fun <T> Grouped<T>.minFor(vararg columns: String): DataFrame<T> =
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.minFor(vararg columns: ColumnReference<C>): DataFrame<T> =
+public fun <T, C : Comparable<*>?> Grouped<T>.minFor(vararg columns: ColumnReference<C>): DataFrame<T> =
     minFor(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.minFor(vararg columns: KProperty<C>): DataFrame<T> =
+public fun <T, C : Comparable<*>?> Grouped<T>.minFor(vararg columns: KProperty<C>): DataFrame<T> =
     minFor(columns = columns, skipNaN = skipNaNDefault)
 
 @Refine
@@ -684,7 +684,7 @@ public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.minBy(
 public fun <T> Pivot<T>.min(separate: Boolean = false): DataRow<T> = min(separate, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.minFor(
+public fun <T, R : Comparable<*>?> Pivot<T>.minFor(
     separate: Boolean = false,
     columns: ColumnsForAggregateSelector<T, R>,
 ): DataRow<T> = minFor(separate, skipNaN = skipNaNDefault, columns = columns)
@@ -695,14 +695,14 @@ public fun <T> Pivot<T>.minFor(vararg columns: String, separate: Boolean = false
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.minFor(
+public fun <T, R : Comparable<*>?> Pivot<T>.minFor(
     vararg columns: ColumnReference<R>,
     separate: Boolean = false,
 ): DataRow<T> = minFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.minFor(
+public fun <T, R : Comparable<*>?> Pivot<T>.minFor(
     vararg columns: KProperty<R>,
     separate: Boolean = false,
 ): DataRow<T> = minFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
@@ -748,7 +748,7 @@ public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.minBy(column: K
 public fun <T> PivotGroupBy<T>.min(separate: Boolean = false): DataFrame<T> = min(separate, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.minFor(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.minFor(
     separate: Boolean = false,
     columns: ColumnsForAggregateSelector<T, R>,
 ): DataFrame<T> = minFor(separate, skipNaN = skipNaNDefault, columns = columns)
@@ -759,14 +759,14 @@ public fun <T> PivotGroupBy<T>.minFor(vararg columns: String, separate: Boolean
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.minFor(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.minFor(
     vararg columns: ColumnReference<R>,
     separate: Boolean = false,
 ): DataFrame<T> = minFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.minFor(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.minFor(
     vararg columns: KProperty<R>,
     separate: Boolean = false,
 ): DataFrame<T> = minFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
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 0371994f4d..b57bf16a3d 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
@@ -152,11 +152,11 @@ public fun <T> DataFrame<T>.percentile(percentile: Double, skipNaN: Boolean = sk
 
 @Refine
 @Interpretable("Percentile1")
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentileFor(
+public fun <T, C : Comparable<*>?> DataFrame<T>.percentileFor(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsForAggregateSelector<T, C>,
-): DataRow<T> = Aggregators.percentileCommon<C>(percentile, skipNaN).aggregateFor(this, columns)
+): DataRow<T> = Aggregators.percentile.invoke(percentile, skipNaN).aggregateFor(this, columns)
 
 public fun <T> DataFrame<T>.percentileFor(
     percentile: Double,
@@ -166,7 +166,7 @@ public fun <T> DataFrame<T>.percentileFor(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentileFor(
+public fun <T, C : Comparable<*>?> DataFrame<T>.percentileFor(
     percentile: Double,
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -174,7 +174,7 @@ public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentileFor(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentileFor(
+public fun <T, C : Comparable<*>?> DataFrame<T>.percentileFor(
     percentile: Double,
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -393,18 +393,18 @@ public fun <T> Grouped<T>.percentile(percentile: Double, skipNaN: Boolean = skip
 
 @Refine
 @Interpretable("GroupByPercentile0")
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentileFor(
+public fun <T, C : Comparable<*>?> Grouped<T>.percentileFor(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsForAggregateSelector<T, C>,
-): DataFrame<T> = Aggregators.percentileCommon<C>(percentile, skipNaN).aggregateFor(this, columns)
+): DataFrame<T> = Aggregators.percentile.invoke(percentile, skipNaN).aggregateFor(this, columns)
 
 public fun <T> Grouped<T>.percentileFor(percentile: Double, vararg columns: String): DataFrame<T> =
     percentileFor(percentile) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentileFor(
+public fun <T, C : Comparable<*>?> Grouped<T>.percentileFor(
     percentile: Double,
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -412,7 +412,7 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentileFor(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentileFor(
+public fun <T, C : Comparable<*>?> Grouped<T>.percentileFor(
     percentile: Double,
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -500,7 +500,7 @@ public fun <T> Pivot<T>.percentile(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = percentileFor(percentile, separate, skipNaN, intraComparableColumns())
 
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.percentileFor(
+public fun <T, C : Comparable<*>?> Pivot<T>.percentileFor(
     percentile: Double,
     separate: Boolean = false,
     skipNaN: Boolean = skipNaNDefault,
@@ -516,7 +516,7 @@ public fun <T> Pivot<T>.percentileFor(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.percentileFor(
+public fun <T, C : Comparable<*>?> Pivot<T>.percentileFor(
     percentile: Double,
     vararg columns: ColumnReference<C>,
     separate: Boolean = false,
@@ -525,7 +525,7 @@ public fun <T, C : Comparable<C & Any>?> Pivot<T>.percentileFor(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.percentileFor(
+public fun <T, C : Comparable<*>?> Pivot<T>.percentileFor(
     percentile: Double,
     vararg columns: KProperty<C>,
     separate: Boolean = false,
@@ -603,12 +603,12 @@ public fun <T> PivotGroupBy<T>.percentile(
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = percentileFor(percentile, separate, skipNaN, intraComparableColumns())
 
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.percentileFor(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentileFor(
     percentile: Double,
     separate: Boolean = false,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsForAggregateSelector<T, C>,
-): DataFrame<T> = Aggregators.percentileCommon<C>(percentile, skipNaN).aggregateFor(this, separate, columns)
+): DataFrame<T> = Aggregators.percentile.invoke(percentile, skipNaN).aggregateFor(this, separate, columns)
 
 public fun <T> PivotGroupBy<T>.percentileFor(
     percentile: Double,
@@ -619,7 +619,7 @@ public fun <T> PivotGroupBy<T>.percentileFor(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.percentileFor(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentileFor(
     percentile: Double,
     vararg columns: ColumnReference<C>,
     separate: Boolean = false,
@@ -628,7 +628,7 @@ public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.percentileFor(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.percentileFor(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentileFor(
     percentile: Double,
     vararg columns: KProperty<C>,
     separate: Boolean = false,
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Analyze.kt b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Analyze.kt
index 8726e7d362..19457121da 100644
--- a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Analyze.kt
+++ b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Analyze.kt
@@ -181,7 +181,7 @@ class Analyze : TestBase() {
         // SampleStart
         df.min() // min of values per every comparable column
         df.min { age and weight } // min of all values in `age` and `weight`
-        df.minFor(skipNaN = true) { age and weight } // min of values per `age` and `weight` separately
+        df.minFor(skipNaN = true) { age and name.firstName } // min of values per `age` and `firstName` separately
         df.minOf { (weight ?: 0) / age } // min of expression evaluated for every row
         df.minBy { age } // DataRow with minimal `age`
         // SampleEnd
@@ -205,7 +205,7 @@ class Analyze : TestBase() {
         // SampleStart
         df.median() // median of values per every comparable column
         df.median { age and weight } // median of all values in `age` and `weight`
-        df.medianFor(skipNaN = true) { age and weight } // median of values per `age` and `weight` separately
+        df.medianFor(skipNaN = true) { age and name.firstName } // median of values per `age` and `firstName` separately
         df.medianOf { (weight ?: 0) / age } // median of expression evaluated for every row
         df.medianBy { age } // DataRow where the median age lies (lower-median for an even number of values)
         // SampleEnd
@@ -229,7 +229,7 @@ class Analyze : TestBase() {
         // SampleStart
         df.percentile(25.0) // 25th percentile of values per every comparable column
         df.percentile(75.0) { age and weight } // 75th percentile of all values in `age` and `weight`
-        df.percentileFor(50.0, skipNaN = true) { age and weight } // 50th percentile of values per `age` and `weight` separately
+        df.percentileFor(50.0, skipNaN = true) { age and name.firstName } // 50th percentile of values per `age` and `firstName` separately
         df.percentileOf(75.0) { (weight ?: 0) / age } // 75th percentile of expression evaluated for every row
         df.percentileBy(25.0) { age } // DataRow where the 25th percentile of `age` lies (index rounded using R3)
         // SampleEnd
@@ -438,7 +438,7 @@ class Analyze : TestBase() {
     fun columnsFor_properties() {
         // SampleStart
         df.minFor { colsOf<Int>() }
-        df.maxFor { name.firstName and name.lastName }
+        df.maxFor { name.firstName and age }
         df.sumFor { age and weight }
         df.meanFor { cols(1, 3).asNumbers() }
         df.medianFor { name.allCols().asComparable() }
@@ -457,7 +457,7 @@ class Analyze : TestBase() {
 
         df.minFor { colsOf<Int>() }
 
-        df.maxFor { firstName and lastName }
+        df.maxFor { firstName and age }
         // or
         df.maxFor(firstName, lastName)
 
@@ -475,7 +475,7 @@ class Analyze : TestBase() {
     fun columnsFor_strings() {
         // SampleStart
         df.minFor { colsOf<Int>() }
-        df.maxFor { "name"["firstName"].asComparable() and "name"["lastName"].asComparable() }
+        df.maxFor { "name"["firstName"].asComparable() and "age"<Int>() }
 
         df.sumFor("age", "weight")
         // or
diff --git a/docs/StardustDocs/resources/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Analyze.columnsFor.html b/docs/StardustDocs/resources/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Analyze.columnsFor.html
index 7b0fe0f8a7..a8fa769c9f 100644
--- a/docs/StardustDocs/resources/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Analyze.columnsFor.html
+++ b/docs/StardustDocs/resources/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Analyze.columnsFor.html
@@ -194,7 +194,7 @@
                                 </details>
                                 <br>
                                 <details>
-                                <summary>df.maxFor { name.firstName and name.lastName }</summary>
+                                <summary>df.maxFor { name.firstName and age }</summary>
                                                                 <details>
                                 <summary>Input DataFrame: rowsCount = 7, columnsCount = 5</summary>
                                  <table class="dataframe" id="df_2"></table>
@@ -668,7 +668,7 @@
 
 /*<!--*/
 call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"firstName: String\">firstName</span>", children: [], rightAlign: false, values: ["Charlie"] }, 
-{ name: "<span title=\"lastName: String\">lastName</span>", children: [], rightAlign: false, values: ["Wolf"] }, 
+{ name: "<span title=\"age: Int\">age</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"numbers\">45</span></span>"] }, 
 ], id: 3, rootId: 3, totalRows: 1 } ) });
 /*-->*/
 
diff --git a/docs/StardustDocs/topics/median.md b/docs/StardustDocs/topics/median.md
index ab1fcd05fb..3a20c256fa 100644
--- a/docs/StardustDocs/topics/median.md
+++ b/docs/StardustDocs/topics/median.md
@@ -30,7 +30,7 @@ When it's set to `true`, `NaN` values are ignored.
 ```kotlin
 df.median() // median of values per every comparable column
 df.median { age and weight } // median of all values in `age` and `weight`
-df.medianFor(skipNaN = true) { age and weight } // median of values per `age` and `weight` separately
+df.medianFor(skipNaN = true) { age and name.firstName } // median of values per `age` and `firstName` separately
 df.medianOf { (weight ?: 0) / age } // median of expression evaluated for every row
 df.medianBy { age } // DataRow where the median age lies (lower-median for an even number of values)
 ```
diff --git a/docs/StardustDocs/topics/minmax.md b/docs/StardustDocs/topics/minmax.md
index 4c096e6c07..82508830a4 100644
--- a/docs/StardustDocs/topics/minmax.md
+++ b/docs/StardustDocs/topics/minmax.md
@@ -21,7 +21,7 @@ When it's set to `true`, `NaN` values are ignored.
 ```kotlin
 df.min() // min of values per every comparable column
 df.min { age and weight } // min of all values in `age` and `weight`
-df.minFor(skipNaN = true) { age and weight } // min of values per `age` and `weight` separately
+df.minFor(skipNaN = true) { age and name.firstName } // min of values per `age` and `firstName` separately
 df.minOf { (weight ?: 0) / age } // min of expression evaluated for every row
 df.minBy { age } // DataRow with minimal `age`
 ```
diff --git a/docs/StardustDocs/topics/percentile.md b/docs/StardustDocs/topics/percentile.md
index 5fe3905fd8..51c2cc8598 100644
--- a/docs/StardustDocs/topics/percentile.md
+++ b/docs/StardustDocs/topics/percentile.md
@@ -52,7 +52,7 @@ In the future we might add an option to change the quantile estimation method.
 ```kotlin
 df.percentile(25.0) // 25th percentile of values per every comparable column
 df.percentile(75.0) { age and weight } // 75th percentile of all values in `age` and `weight`
-df.percentileFor(50.0, skipNaN = true) { age and weight } // 50th percentile of values per `age` and `weight` separately
+df.percentileFor(50.0, skipNaN = true) { age and name.firstName } // 50th percentile of values per `age` and `firstName` separately
 df.percentileOf(75.0) { (weight ?: 0) / age } // 75th percentile of expression evaluated for every row
 df.percentileBy(25.0) { age } // DataRow where the 25th percentile of `age` lies (index rounded using R3)
 ```