Automated commit of generated code

Author: github-actions[bot]

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/mean.kt

@@ -14,12 +14,10 @@ import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.columns.toColumnsSetOf
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators
-import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast2
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateFor
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOf
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOfRow
-import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.of
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.primitiveNumberColumns
 import org.jetbrains.kotlinx.dataframe.impl.columns.toNumberColumns
 import org.jetbrains.kotlinx.dataframe.impl.primitiveNumberTypes
@@ -38,16 +36,12 @@ import kotlin.reflect.typeOf
 
 // region DataColumn
 
-public fun <T : Number> DataColumn<T?>.mean(skipNA: Boolean = skipNA_default): Double =
-    Aggregators.mean(skipNA).aggregate(this)
+public fun DataColumn<Number?>.mean(skipNA: Boolean = skipNA_default): Double = Aggregators.mean(skipNA).aggregate(this)
 
 public inline fun <T, reified R : Number> DataColumn<T>.meanOf(
     skipNA: Boolean = skipNA_default,
-    noinline expression: (T) -> R?,
-): Double =
-    Aggregators.mean(skipNA)
-        .cast2<R?, Double>()
-        .aggregateOf(this, expression)
+    crossinline expression: (T) -> R?,
+): Double = Aggregators.mean(skipNA).aggregateOf(this, expression)
 
 // endregion
 
@@ -113,8 +107,8 @@ public fun <T, C : Number> DataFrame<T>.mean(vararg columns: KProperty<C?>, skip
 
 public inline fun <T, reified D : Number> DataFrame<T>.meanOf(
     skipNA: Boolean = skipNA_default,
-    noinline expression: RowExpression<T, D?>,
-): Double = Aggregators.mean(skipNA).of(this, expression)
+    crossinline expression: RowExpression<T, D?>,
+): Double = Aggregators.mean(skipNA).aggregateOf(this, expression)
 
 // endregion
 

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt

@@ -18,7 +18,6 @@ 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.aggregateFor
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOf
-import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.of
 import org.jetbrains.kotlinx.dataframe.impl.columns.toComparableColumns
 import org.jetbrains.kotlinx.dataframe.impl.suggestIfNull
 import org.jetbrains.kotlinx.dataframe.math.median
@@ -101,7 +100,7 @@ public fun <T, C : Comparable<C>> DataFrame<T>.medianOrNull(vararg columns: KPro
 
 public inline fun <T, reified R : Comparable<R>> DataFrame<T>.medianOf(
     crossinline expression: RowExpression<T, R?>,
-): R? = Aggregators.median.of(this, expression) as R?
+): R? = Aggregators.median.aggregateOf(this, expression) as R?
 
 // endregion
 

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/percentile.kt

@@ -16,7 +16,6 @@ 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.aggregateFor
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOf
-import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.of
 import org.jetbrains.kotlinx.dataframe.impl.columns.toComparableColumns
 import org.jetbrains.kotlinx.dataframe.impl.suggestIfNull
 import org.jetbrains.kotlinx.dataframe.math.percentile
@@ -121,7 +120,7 @@ public fun <T, C : Comparable<C>> DataFrame<T>.percentileOrNull(percentile: Doub
 public inline fun <T, reified R : Comparable<R>> DataFrame<T>.percentileOf(
     percentile: Double,
     crossinline expression: RowExpression<T, R?>,
-): R? = Aggregators.percentile(percentile).of(this, expression) as R?
+): R? = Aggregators.percentile(percentile).aggregateOf(this, expression) as R?
 
 // endregion
 

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/std.kt

@@ -18,7 +18,6 @@ import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast2
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateFor
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOf
-import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.of
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.numberColumns
 import org.jetbrains.kotlinx.dataframe.math.std
 import kotlin.reflect.KProperty
@@ -99,7 +98,7 @@ public inline fun <T, reified R : Number> DataFrame<T>.stdOf(
     skipNA: Boolean = skipNA_default,
     ddof: Int = ddof_default,
     crossinline expression: RowExpression<T, R?>,
-): Double = Aggregators.std(skipNA, ddof).of(this, expression) ?: .0
+): Double = Aggregators.std(skipNA, ddof).aggregateOf(this, expression) ?: .0
 
 // endregion
 

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sum.kt

@@ -20,7 +20,6 @@ import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateFor
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateOf
-import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.of
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.numberColumns
 import org.jetbrains.kotlinx.dataframe.impl.columns.toNumberColumns
 import org.jetbrains.kotlinx.dataframe.impl.zero
@@ -38,8 +37,8 @@ public fun <T : Number> DataColumn<T>.sum(): T = values.sum(type())
 @JvmName("sumTNullable")
 public fun <T : Number> DataColumn<T?>.sum(): T = values.sum(type())
 
-public inline fun <T, reified R : Number> DataColumn<T>.sumOf(crossinline expression: (T) -> R): R? =
-    (Aggregators.sum as Aggregator<*, *>).cast<R>().of(this, expression)
+public inline fun <T, reified R : Number> DataColumn<T>.sumOf(noinline expression: (T) -> R): R? =
+    (Aggregators.sum as Aggregator<*, *>).cast<R>().aggregateOf(this, expression)
 
 // endregion
 

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/UnifyingNumbers.kt

@@ -25,6 +25,9 @@ import org.jetbrains.kotlinx.dataframe.impl.UnifiedNumberTypeOptions
  *      |    /   |
  *      |   /    |
  *    UByte     Byte
+ *        \     /
+ *        \    /
+ *       Nothing?
  * ```
  * For each number type in the graph, it holds that a number of that type can be expressed lossless by
  * a number of a more complex type (any of its parents).
@@ -36,6 +39,8 @@ import org.jetbrains.kotlinx.dataframe.impl.UnifiedNumberTypeOptions
  * potentially losing a little precision, but a warning will be given.
  *
  * See [UnifiedNumberTypeOptions] for these settings.
+ *
+ * At the bottom of the graph is [Nothing]. This can be interpreted as `null`.
  */
 internal interface UnifyingNumbers {
 
@@ -55,6 +60,9 @@ internal interface UnifyingNumbers {
      *      |    /   |
      *      |   /    |
      *    UByte     Byte
+     *        \     /
+     *        \    /
+     *       Nothing?
      * ```
      */
     interface Graph

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/NumberTypeUtils.kt

@@ -49,6 +49,9 @@ private val unifiedNumberTypeGraphs = mutableMapOf<UnifiedNumberTypeOptions, Dir
  *      |    /   |
  *      |   /    |
  *    UByte     Byte
+ *        \     /
+ *        \    /
+ *       Nothing?
  * ```
  *
  * For any two numbers, we can find the nearest common ancestor in this graph
@@ -97,6 +100,9 @@ internal fun getUnifiedNumberTypeGraph(
 
             addEdge(typeOf<Short>(), typeOf<UByte>())
             addEdge(typeOf<Short>(), typeOf<Byte>())
+
+            addEdge(typeOf<UByte>(), nothingType)
+            addEdge(typeOf<Byte>(), nothingType)
         }
     }
 
@@ -118,6 +124,9 @@ internal fun getUnifiedNumberTypeGraph(
  *      |    /   |
  *      |   /    |
  *    UByte     Byte
+ *        \     /
+ *        \    /
+ *       Nothing?
  * ```
  *
  * For any two numbers, we can find the nearest common ancestor in this graph
@@ -162,7 +171,11 @@ internal fun getUnifiedNumberType(
             ?: error("Can not find common number type for $first and $second")
     }
 
-    return if (first.isMarkedNullable || second.isMarkedNullable) result.withNullability(true) else result
+    return if (first.isMarkedNullable || second.isMarkedNullable) {
+        result.withNullability(true)
+    } else {
+        result
+    }
 }
 
 /** Determines the nearest common numeric type, in terms of complexity, between two given classes/types.
@@ -245,7 +258,7 @@ internal fun Iterable<Number?>.convertToUnifiedNumberType(
     options: UnifiedNumberTypeOptions = UnifiedNumberTypeOptions.DEFAULT,
     commonNumberType: KType? = null,
 ): Iterable<Number?> {
-    val commonNumberType = commonNumberType ?: this.filterNotNull().types().unifiedNumberType(options)
+    val commonNumberType = commonNumberType ?: this.types().unifiedNumberType(options)
     val converter = createConverter(typeOf<Number>(), commonNumberType)!! as (Number) -> Number?
     return map {
         if (it == null) return@map null
@@ -286,7 +299,7 @@ internal fun Sequence<Number?>.convertToUnifiedNumberType(
     options: UnifiedNumberTypeOptions = UnifiedNumberTypeOptions.DEFAULT,
     commonNumberType: KType? = null,
 ): Sequence<Number?> {
-    val commonNumberType = commonNumberType ?: this.filterNotNull().asIterable().types().unifiedNumberType(options)
+    val commonNumberType = commonNumberType ?: this.asIterable().types().unifiedNumberType(options)
     val converter = createConverter(typeOf<Number>(), commonNumberType)!! as (Number) -> Number?
     return map {
         if (it == null) return@map null

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/TypeUtils.kt

@@ -667,19 +667,26 @@ internal fun Any.isBigNumber(): Boolean = this is BigInteger || this is BigDecim
  *
  * The [KClass] is determined by retrieving the runtime class of each element.
  *
+ * [Nothing::class][Nothing] is used for elements that are `null`.
+ *
  * @return A set of [KClass] objects representing the runtime types of elements in the iterable.
  */
-internal fun Iterable<Any>.classes(): Set<KClass<*>> = mapTo(mutableSetOf()) { it::class }
+internal fun Iterable<Any?>.classes(): Set<KClass<*>> =
+    mapTo(mutableSetOf()) {
+        if (it == null) Nothing::class else it::class
+    }
 
 /**
  * Returns a set of [KType] objects representing the star-projected types of the runtime classes
  * of all unique elements in the iterable.
  *
- * The method internally relies on the [classes] function to collect the runtime classes of the
- * elements in the iterable and then maps each class to its star-projected type.
- *
  * This can be a heavy operation!
  *
+ * [typeOf<Nothing?>()][nullableNothingType] is used for elements that are `null`.
+ *
  * @return A set of [KType] objects corresponding to the star-projected runtime types of elements in the iterable.
  */
-internal fun Iterable<Any>.types(): Set<KType> = classes().mapTo(mutableSetOf()) { it.createStarProjectedType(false) }
+internal fun Iterable<Any?>.types(): Set<KType> =
+    mapTo(mutableSetOf()) {
+        if (it == null) nullableNothingType else it::class.createStarProjectedType(false)
+    }

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregator.kt

@@ -13,8 +13,7 @@ import kotlin.reflect.full.withNullability
  * The [AggregatorBase] class is a base implementation of this interface.
  *
  * @param Value The type of the values to be aggregated.
- *   This can be nullable for [Iterables][Iterable] or not, depending on the use case.
- *   For columns, [Value] will always be considered nullable; nulls are filtered out from columns anyway.
+ *   The input can always have nulls, they are filtered out.
  * @param Return The type of the resulting value. Can optionally be nullable.
  */
 @PublishedApi
@@ -26,17 +25,19 @@ internal interface Aggregator<in Value, out Return> {
     /**
      * Base function of [Aggregator].
      *
-     * Aggregates the given values, taking [type] into account, and computes a single resulting value.
+     * Aggregates the given values, taking [type] into account,
+     * filtering nulls (only if [type.isMarkedNullable][KType.isMarkedNullable]),
+     * and computes a single resulting value.
      *
      * When using [AggregatorBase], this can be supplied by the [AggregatorBase.aggregator] argument.
      *
      * When the exact [type] is unknown, use [aggregateCalculatingType].
      */
-    fun aggregate(values: Iterable<Value>, type: KType): Return
+    fun aggregate(values: Iterable<Value?>, type: KType): Return
 
     /**
      * Aggregates the data in the given column and computes a single resulting value.
-     * Nulls are filtered out by default, then [aggregate] (with [Iterable] and [KType]) is called.
+     * Calls [aggregate] (with [Iterable] and [KType]).
      *
      * See [AggregatorBase.aggregate].
      */
@@ -55,9 +56,9 @@ internal interface Aggregator<in Value, out Return> {
      * @param valueTypes The types of the values.
      *   If provided, this can be used to avoid calculating the types of [values] at runtime with reflection.
      *   It should contain all types of [values].
-     *   If `null`, the types of [values] will be calculated at runtime (heavy!).
+     *   If `null` or empty, the types of [values] will be calculated at runtime (heavy!).
      */
-    fun aggregateCalculatingType(values: Iterable<Value>, valueTypes: Set<KType>? = null): Return
+    fun aggregateCalculatingType(values: Iterable<Value?>, valueTypes: Set<KType>? = null): Return
 
     /**
      * Function that can give the return type of [aggregate] as [KType], given the type of the input.
@@ -92,8 +93,11 @@ internal fun <Value, Return> Aggregator<*, *>.cast2(): Aggregator<Value, Return>
 /** Type alias for [Aggregator.calculateReturnTypeOrNull] */
 internal typealias CalculateReturnTypeOrNull = (type: KType, emptyInput: Boolean) -> KType?
 
-/** Type alias for [Aggregator.aggregate]. */
-internal typealias Aggregate<Value, Return> = Iterable<Value>.(type: KType) -> Return
+/**
+ * Type alias for the argument for [Aggregator.aggregate].
+ * Nulls have already been filtered out when this argument is called.
+ */
+internal typealias Aggregate<Value, Return> = Iterable<Value & Any>.(type: KType) -> Return
 
 /** Common case for [CalculateReturnTypeOrNull], preserves return type, but makes it nullable for empty inputs. */
 internal val preserveReturnTypeNullIfEmpty: CalculateReturnTypeOrNull = { type, emptyInput ->

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorBase.kt

@@ -4,6 +4,7 @@ import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.api.asIterable
 import org.jetbrains.kotlinx.dataframe.api.asSequence
 import org.jetbrains.kotlinx.dataframe.impl.commonType
+import org.jetbrains.kotlinx.dataframe.impl.nothingType
 import kotlin.reflect.KType
 import kotlin.reflect.full.withNullability
 
@@ -14,7 +15,7 @@ import kotlin.reflect.full.withNullability
  * or multiple [DataColumns][DataColumn].
  *
  * @param name The name of this aggregator.
- * @param aggregator Functional argument for the [aggregate] function.
+ * @param aggregator Functional argument for the [aggregate] function. Nulls are filtered out before this is called.
  */
 internal abstract class AggregatorBase<in Value, out Return>(
     override val name: String,
@@ -25,13 +26,26 @@ internal abstract class AggregatorBase<in Value, out Return>(
     /**
      * Base function of [Aggregator].
      *
-     * Aggregates the given values, taking [type] into account, and computes a single resulting value.
+     * Aggregates the given values, taking [type] into account,
+     * filtering nulls (only if [type.isMarkedNullable][KType.isMarkedNullable]),
+     * and computes a single resulting value.
      *
-     * Uses [aggregator] to compute the result.
+     * When using [AggregatorBase], this can be supplied by the [AggregatorBase.aggregator] argument.
      *
      * When the exact [type] is unknown, use [aggregateCalculatingType].
      */
-    override fun aggregate(values: Iterable<Value>, type: KType): Return = aggregator(values, type)
+    @Suppress("UNCHECKED_CAST")
+    override fun aggregate(values: Iterable<Value?>, type: KType): Return =
+        aggregator(
+            // values =
+            if (type.isMarkedNullable) {
+                values.asSequence().filterNotNull().asIterable()
+            } else {
+                values as Iterable<Value & Any>
+            },
+            // type =
+            type.withNullability(false),
+        )
 
     /**
      * Function that can give the return type of [aggregate] as [KType], given the type of the input.
@@ -44,7 +58,7 @@ internal abstract class AggregatorBase<in Value, out Return>(
      * @return The return type of [aggregate] as [KType].
      */
     override fun calculateReturnTypeOrNull(type: KType, emptyInput: Boolean): KType? =
-        getReturnTypeOrNull(type, emptyInput)
+        getReturnTypeOrNull(type.withNullability(false), emptyInput)
 
     /**
      * Aggregates the data in the given column and computes a single resulting value.
@@ -54,13 +68,8 @@ internal abstract class AggregatorBase<in Value, out Return>(
     @Suppress("UNCHECKED_CAST")
     override fun aggregate(column: DataColumn<Value?>): Return =
         aggregate(
-            values =
-                if (column.hasNulls()) {
-                    column.asSequence().filterNotNull().asIterable()
-                } else {
-                    column.asIterable() as Iterable<Value>
-                },
-            type = column.type().withNullability(false),
+            values = column.asIterable(),
+            type = column.type(),
         )
 
     /** Special case of [aggregate][org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregator.aggregate] with [Iterable] that calculates the common type of the values at runtime.
@@ -70,9 +79,9 @@ internal abstract class AggregatorBase<in Value, out Return>(
      * @param valueTypes The types of the values.
      *   If provided, this can be used to avoid calculating the types of [values][org.jetbrains.kotlinx.dataframe.values] at runtime with reflection.
      *   It should contain all types of [values][org.jetbrains.kotlinx.dataframe.values].
-     * If `null`, the types of [values][org.jetbrains.kotlinx.dataframe.values] will be calculated at runtime (heavy!). */
-    override fun aggregateCalculatingType(values: Iterable<Value>, valueTypes: Set<KType>?): Return {
-        val commonType = if (valueTypes != null) {
+     * If `null` or empty, the types of [values][org.jetbrains.kotlinx.dataframe.values] will be calculated at runtime (heavy!). */
+    override fun aggregateCalculatingType(values: Iterable<Value?>, valueTypes: Set<KType>?): Return {
+        val commonType = if (valueTypes != null && valueTypes.isNotEmpty()) {
             valueTypes.commonType(false)
         } else {
             var hasNulls = false
@@ -84,7 +93,11 @@ internal abstract class AggregatorBase<in Value, out Return>(
                     it.javaClass.kotlin
                 }
             }
-            classes.commonType(hasNulls)
+            if (classes.isEmpty()) {
+                nothingType(hasNulls)
+            } else {
+                classes.commonType(hasNulls)
+            }
         }
         return aggregate(values, commonType)
     }