Automated commit of generated code

Author: github-actions[bot]

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

@@ -113,7 +113,7 @@ internal interface DiffOrNullDocs
  */
 @OptIn(ExperimentalTypeInference::class)
 @OverloadResolutionByLambdaReturnType
-public fun <T> DataRow<T>.diff(firstRowResult: Double, expression: RowExpression<T, Double>): Double =
+public inline fun <T> DataRow<T>.diff(firstRowResult: Double, expression: RowExpression<T, Double>): Double =
     prev()?.let { p -> expression(this, this) - expression(p, p) }
         ?: firstRowResult
 
@@ -125,7 +125,7 @@ public fun <T> DataRow<T>.diff(firstRowResult: Double, expression: RowExpression
 @OptIn(ExperimentalTypeInference::class)
 @OverloadResolutionByLambdaReturnType
 // required to resolve `diff(0) { intValue }`
-public fun <T> DataRow<T>.diff(firstRowResult: Int, expression: RowExpression<T, Int>): Int =
+public inline fun <T> DataRow<T>.diff(firstRowResult: Int, expression: RowExpression<T, Int>): Int =
     prev()?.let { p -> expression(this, this) - expression(p, p) }
         ?: firstRowResult
 
@@ -134,7 +134,7 @@ public fun <T> DataRow<T>.diff(firstRowResult: Int, expression: RowExpression<T,
  *
  * @return [firstRowValue] for the first row; difference between expression computed for current and previous row for the following rows
  */
-public fun <T> DataRow<T>.diff(firstRowResult: Long, expression: RowExpression<T, Long>): Long =
+public inline fun <T> DataRow<T>.diff(firstRowResult: Long, expression: RowExpression<T, Long>): Long =
     prev()?.let { p -> expression(this, this) - expression(p, p) }
         ?: firstRowResult
 
@@ -143,7 +143,7 @@ public fun <T> DataRow<T>.diff(firstRowResult: Long, expression: RowExpression<T
  *
  * @return [firstRowValue] for the first row; difference between expression computed for current and previous row for the following rows
  */
-public fun <T> DataRow<T>.diff(firstRowResult: Float, expression: RowExpression<T, Float>): Float =
+public inline fun <T> DataRow<T>.diff(firstRowResult: Float, expression: RowExpression<T, Float>): Float =
     prev()?.let { p -> expression(this, this) - expression(p, p) }
         ?: firstRowResult
 
@@ -154,31 +154,31 @@ public fun <T> DataRow<T>.diff(firstRowResult: Float, expression: RowExpression<
  */
 @OptIn(ExperimentalTypeInference::class)
 @OverloadResolutionByLambdaReturnType
-public fun <T> DataRow<T>.diffOrNull(expression: RowExpression<T, Double>): Double? =
+public inline fun <T> DataRow<T>.diffOrNull(expression: RowExpression<T, Double>): Double? =
     prev()?.let { p -> expression(this, this) - expression(p, p) }
 
 /**
  * Calculates the difference between the results of a row expression computed on the current and previous DataRow.
  *
  * @return null for the first row; difference between expression computed for current and previous row for the following rows
  */
-public fun <T> DataRow<T>.diffOrNull(expression: RowExpression<T, Int>): Int? =
+public inline fun <T> DataRow<T>.diffOrNull(expression: RowExpression<T, Int>): Int? =
     prev()?.let { p -> expression(this, this) - expression(p, p) }
 
 /**
  * Calculates the difference between the results of a row expression computed on the current and previous DataRow.
  *
  * @return null for the first row; difference between expression computed for current and previous row for the following rows
  */
-public fun <T> DataRow<T>.diffOrNull(expression: RowExpression<T, Long>): Long? =
+public inline fun <T> DataRow<T>.diffOrNull(expression: RowExpression<T, Long>): Long? =
     prev()?.let { p -> expression(this, this) - expression(p, p) }
 
 /**
  * Calculates the difference between the results of a row expression computed on the current and previous DataRow.
  *
  * @return null for the first row; difference between expression computed for current and previous row for the following rows
  */
-public fun <T> DataRow<T>.diffOrNull(expression: RowExpression<T, Float>): Float? =
+public inline fun <T> DataRow<T>.diffOrNull(expression: RowExpression<T, Float>): Float? =
     prev()?.let { p -> expression(this, this) - expression(p, p) }
 
 public fun AnyRow.columnsCount(): Int = df().ncol
@@ -221,7 +221,7 @@ public fun <T> DataRow<T>.relative(relativeIndices: IntRange): DataFrame<T> =
         (relativeIndices.first + index).coerceIn(df().indices)..(relativeIndices.last + index).coerceIn(df().indices),
     )
 
-public fun <T> DataRow<T>.movingAverage(k: Int, expression: RowExpression<T, Number>): Double {
+public inline fun <T> DataRow<T>.movingAverage(k: Int, expression: RowExpression<T, Number>): Double {
     var count = 0
     return backwardIterable().take(k).sumOf {
         count++

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

@@ -166,7 +166,8 @@ public class AddDsl<T>(
     ColumnSelectionDsl<T> {
 
     // TODO: support adding column into path
-    internal val columns = mutableListOf<AnyCol>()
+    @PublishedApi
+    internal val columns: MutableList<AnyCol> = mutableListOf<AnyCol>()
 
     public fun add(column: AnyColumnReference): Boolean = columns.add(column.resolveSingle(df)!!.data)
 

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

@@ -46,7 +46,7 @@ public fun AnyRow.allNA(): Boolean = owner.columns().all { it[index()].isNA }
 // region DataFrame
 
 /** Returns `true` if all [rows] match the given [predicate] or [rows] is empty. */
-public fun <T> DataFrame<T>.all(predicate: RowFilter<T>): Boolean = rows().all { predicate(it, it) }
+public inline fun <T> DataFrame<T>.all(predicate: RowFilter<T>): Boolean = rows().all { predicate(it, it) }
 
 // endregion
 
@@ -8093,6 +8093,7 @@ public interface AllColumnsSelectionDsl<out _UNUSED> {
  * else it simply returns a [(transformable) ColumnSet][TransformableColumnSet] from [this]
  * (like when [this] is a [ColumnSet]).
  */
+@PublishedApi
 internal fun ColumnsResolver<*>.allColumnsInternal(removePaths: Boolean = false): TransformableColumnSet<*> =
     transform { cols ->
         if (this is SingleColumn<*> && cols.singleOrNull()?.isColumnGroup() == true) {
@@ -8114,7 +8115,8 @@ internal fun ColumnsResolver<*>.allColumnsInternal(removePaths: Boolean = false)
  * @param colByPredicate a function that takes a ColumnWithPath and returns true if the column matches the predicate, false otherwise
  * @return a new ColumnSet containing all columns after the first column that matches the given predicate
  */
-internal fun ColumnsResolver<*>.allAfterInternal(colByPredicate: ColumnFilter<*>): ColumnSet<*> {
+@PublishedApi
+internal inline fun ColumnsResolver<*>.allAfterInternal(crossinline colByPredicate: ColumnFilter<*>): ColumnSet<*> {
     var take = false
     return colsInternal {
         if (take) {
@@ -8132,7 +8134,8 @@ internal fun ColumnsResolver<*>.allAfterInternal(colByPredicate: ColumnFilter<*>
  * @param colByPredicate the predicate used to determine if a column should be included in the resulting set
  * @return a column set containing all columns that satisfy the predicate
  */
-internal fun ColumnsResolver<*>.allFromInternal(colByPredicate: ColumnFilter<*>): ColumnSet<*> {
+@PublishedApi
+internal inline fun ColumnsResolver<*>.allFromInternal(crossinline colByPredicate: ColumnFilter<*>): ColumnSet<*> {
     var take = false
     return colsInternal {
         if (take) {
@@ -8150,7 +8153,8 @@ internal fun ColumnsResolver<*>.allFromInternal(colByPredicate: ColumnFilter<*>)
  * @param colByPredicate the predicate function used to determine if a column should be included in the returned ColumnSet
  * @return a new ColumnSet containing all columns that come before the first column that satisfies the given predicate
  */
-internal fun ColumnsResolver<*>.allBeforeInternal(colByPredicate: ColumnFilter<*>): ColumnSet<*> {
+@PublishedApi
+internal inline fun ColumnsResolver<*>.allBeforeInternal(crossinline colByPredicate: ColumnFilter<*>): ColumnSet<*> {
     var take = true
     return colsInternal {
         if (!take) {
@@ -8168,7 +8172,8 @@ internal fun ColumnsResolver<*>.allBeforeInternal(colByPredicate: ColumnFilter<*
  * @param colByPredicate a predicate function that takes a ColumnWithPath and returns true if the column satisfies the desired condition.
  * @return a ColumnSet containing all columns up to the first column that satisfies the given predicate.
  */
-internal fun ColumnsResolver<*>.allUpToInternal(colByPredicate: ColumnFilter<*>): ColumnSet<*> {
+@PublishedApi
+internal inline fun ColumnsResolver<*>.allUpToInternal(crossinline colByPredicate: ColumnFilter<*>): ColumnSet<*> {
     var take = true
     return colsInternal {
         if (!take) {

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

@@ -14,6 +14,6 @@ public fun <T> DataColumn<T>.any(predicate: Predicate<T>): Boolean = values.any(
 
 // region DataFrame
 
-public fun <T> DataFrame<T>.any(predicate: RowFilter<T>): Boolean = rows().any { predicate(it, it) }
+public inline fun <T> DataFrame<T>.any(predicate: RowFilter<T>): Boolean = rows().any { predicate(it, it) }
 
 // endregion

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

@@ -6,10 +6,10 @@ import org.jetbrains.kotlinx.dataframe.RowExpression
 
 // region DataFrame
 
-public fun <T, V> DataFrame<T>.associateBy(transform: RowExpression<T, V>): Map<V, DataRow<T>> =
+public inline fun <T, V> DataFrame<T>.associateBy(transform: RowExpression<T, V>): Map<V, DataRow<T>> =
     rows().associateBy { transform(it, it) }
 
-public fun <T, K, V> DataFrame<T>.associate(transform: RowExpression<T, Pair<K, V>>): Map<K, V> =
+public inline fun <T, K, V> DataFrame<T>.associate(transform: RowExpression<T, Pair<K, V>>): Map<K, V> =
     rows().associate { transform(it, it) }
 
 // endregion

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

@@ -365,8 +365,8 @@ public interface ColGroupsColumnsSelectionDsl {
  * @return A [TransformableColumnSet] containing the column groups that satisfy the filter.
  */
 @Suppress("UNCHECKED_CAST")
-internal fun ColumnsResolver<*>.columnGroupsInternal(
-    filter: (ColumnGroup<*>) -> Boolean,
+internal inline fun ColumnsResolver<*>.columnGroupsInternal(
+    crossinline filter: (ColumnGroup<*>) -> Boolean,
 ): TransformableColumnSet<AnyRow> = colsInternal { it.isColumnGroup() && filter(it) } as TransformableColumnSet<AnyRow>
 
 // endregion

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

@@ -4920,7 +4920,8 @@ internal fun SingleColumn<DataRow<*>>.colsInternal(refs: Iterable<ColumnReferenc
  * Else, it returns a new [ColumnSet] containing all columns in this [ColumnsResolver] that
  * match the given [predicate].
  */
-internal fun ColumnsResolver<*>.colsInternal(predicate: ColumnFilter<*>): TransformableColumnSet<*> =
+@PublishedApi
+internal inline fun ColumnsResolver<*>.colsInternal(crossinline predicate: ColumnFilter<*>): TransformableColumnSet<*> =
     allColumnsInternal().transform { it.filter(predicate) }
 
 internal fun ColumnsResolver<*>.colsInternal(indices: IntArray): TransformableColumnSet<*> =

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

@@ -627,7 +627,10 @@ public inline fun <reified C> SingleColumn<DataRow<*>>.colsOf(
  * match the given [filter] and are the given [type].
  */
 @Suppress("UNCHECKED_CAST")
-internal fun <C> ColumnsResolver<*>.colsOfInternal(type: KType, filter: ColumnFilter<C>): TransformableColumnSet<C> =
+internal inline fun <C> ColumnsResolver<*>.colsOfInternal(
+    type: KType,
+    crossinline filter: ColumnFilter<C>,
+): TransformableColumnSet<C> =
     colsInternal {
         it.isSubtypeOf(type) && filter(it.cast())
     } as TransformableColumnSet<C>

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

@@ -402,9 +402,9 @@ public interface ColsOfKindColumnsSelectionDsl {
  * @param filter The filter function to apply on each column. Must accept a ColumnWithPath object and return a Boolean.
  * @return A [TransformableColumnSet] containing the columns of given kinds that satisfy the filter.
  */
-internal fun ColumnsResolver<*>.columnsOfKindInternal(
+internal inline fun ColumnsResolver<*>.columnsOfKindInternal(
     kinds: Set<ColumnKind>,
-    filter: ColumnFilter<*>,
+    crossinline filter: ColumnFilter<*>,
 ): TransformableColumnSet<*> = colsInternal { it.kind() in kinds && filter(it) }
 
 // endregion

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

@@ -25,15 +25,15 @@ public fun <T> DataColumn<T>.count(predicate: Predicate<T>? = null): Int =
 
 public fun AnyRow.count(): Int = columnsCount()
 
-public fun AnyRow.count(predicate: Predicate<Any?>): Int = values().count(predicate)
+public inline fun AnyRow.count(predicate: Predicate<Any?>): Int = values().count(predicate)
 
 // endregion
 
 // region DataFrame
 
 public fun <T> DataFrame<T>.count(): Int = rowsCount()
 
-public fun <T> DataFrame<T>.count(predicate: RowFilter<T>): Int = rows().count { predicate(it, it) }
+public inline fun <T> DataFrame<T>.count(predicate: RowFilter<T>): Int = rows().count { predicate(it, it) }
 
 // endregion
 
@@ -46,23 +46,29 @@ public fun <T> Grouped<T>.count(resultName: String = "count"): DataFrame<T> =
 
 @Refine
 @Interpretable("GroupByCount0")
-public fun <T> Grouped<T>.count(resultName: String = "count", predicate: RowFilter<T>): DataFrame<T> =
-    aggregateValue(resultName) { count(predicate) default 0 }
+public inline fun <T> Grouped<T>.count(
+    resultName: String = "count",
+    crossinline predicate: RowFilter<T>,
+): DataFrame<T> = aggregateValue(resultName) { count(predicate) default 0 }
 
 // endregion
 
 // region Pivot
 
 public fun <T> Pivot<T>.count(): DataRow<T> = delegate { count() }
 
-public fun <T> Pivot<T>.count(predicate: RowFilter<T>): DataRow<T> = delegate { count(predicate) }
+public inline fun <T> Pivot<T>.count(crossinline predicate: RowFilter<T>): DataRow<T> = delegate { count(predicate) }
 
 // endregion
 
 // region PivotGroupBy
 
 public fun <T> PivotGroupBy<T>.count(): DataFrame<T> = aggregate { count() default 0 }
 
-public fun <T> PivotGroupBy<T>.count(predicate: RowFilter<T>): DataFrame<T> = aggregate { count(predicate) default 0 }
+public inline fun <T> PivotGroupBy<T>.count(crossinline predicate: RowFilter<T>): DataFrame<T> =
+    aggregate {
+        count(predicate) default
+            0
+    }
 
 // endregion