remove unneeded crossinlines

Author: AndreiKingsley

core/api/core.api

@@ -5427,7 +5427,6 @@ public final class org/jetbrains/kotlinx/dataframe/impl/UtilsKt {
 	public static final fun headPlusArray (J[J)[J
 	public static final fun headPlusArray (S[S)[S
 	public static final fun headPlusArray (Z[Z)[Z
-	public static final fun indexOfMax (Lkotlin/sequences/Sequence;)I
 	public static final fun toCamelCaseByDelimiters (Ljava/lang/String;Lkotlin/text/Regex;Ljava/lang/String;)Ljava/lang/String;
 	public static synthetic fun toCamelCaseByDelimiters$default (Ljava/lang/String;Lkotlin/text/Regex;Ljava/lang/String;ILjava/lang/Object;)Ljava/lang/String;
 	public static final fun zero (Lkotlin/reflect/KClass;)Ljava/lang/Number;

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

@@ -205,7 +205,7 @@ public fun <T> DataRow<T>.relative(relativeIndices: IntRange): DataFrame<T> =
         (relativeIndices.first + index).coerceIn(df().indices)..(relativeIndices.last + index).coerceIn(df().indices),
     )
 
-public inline fun <T> DataRow<T>.movingAverage(k: Int, crossinline 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/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/drop.kt

@@ -67,7 +67,7 @@ public inline fun <T> DataFrame<T>.drop(predicate: RowFilter<T>): DataFrame<T> =
 /**
  * Returns a DataFrame containing all rows except first rows that satisfy the given [predicate].
  */
-public inline fun <T> DataFrame<T>.dropWhile(crossinline predicate: RowFilter<T>): DataFrame<T> =
+public inline fun <T> DataFrame<T>.dropWhile(predicate: RowFilter<T>): DataFrame<T> =
     firstOrNull { !predicate(it, it) }?.let { drop(it.index()) } ?: this
 
 // endregion

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/duplicate.kt

@@ -11,7 +11,7 @@ public fun <T> DataFrame<T>.duplicate(n: Int): FrameColumn<T> = List(n) { this }
 
 public fun <T> DataFrame<T>.duplicateRows(n: Int): DataFrame<T> = duplicateRowsImpl(n)
 
-public inline fun <T> DataFrame<T>.duplicateRows(n: Int, crossinline filter: RowFilter<T>): DataFrame<T> =
+public inline fun <T> DataFrame<T>.duplicateRows(n: Int, filter: RowFilter<T>): DataFrame<T> =
     duplicateRowsImpl(n, rows().filter { filter(it, it) }.map { it.index() })
 
 public fun <T> DataRow<T>.duplicate(n: Int): DataFrame<T> = duplicateImpl(n)

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt

@@ -7,17 +7,102 @@ import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.annotations.AccessApiOverload
 import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
 import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
 import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.documentation.DocumentationUrls
+import org.jetbrains.kotlinx.dataframe.documentation.DslGrammarLink
+import org.jetbrains.kotlinx.dataframe.documentation.ExcludeFromSources
+import org.jetbrains.kotlinx.dataframe.documentation.Indent
+import org.jetbrains.kotlinx.dataframe.documentation.LineBreak
+import org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns
 import org.jetbrains.kotlinx.dataframe.impl.columnName
 import kotlin.experimental.ExperimentalTypeInference
 import kotlin.reflect.KProperty
 
 // region DataFrame
 
+/**
+ * Groups the specified [columns\] within the [DataFrame].
+ *
+ * This function does not immediately group the columns but instead select columns to group and
+ * returns a [GroupClause],
+ * which serves as an intermediate step.
+ * The [GroupClause] allows specifying the final
+ * destination of the selected columns using methods such
+ * as [into][GroupClause.into] and,
+ * that return a new [DataFrame] with grouped columns.
+ * Check out [Grammar].
+ *
+ * @include [SelectingColumns.ColumnGroupsAndNestedColumnsMention]
+ *
+ * See [Selecting Columns][GroupSelectingOptions].
+ *
+ * For more information: {@include [DocumentationUrls.Group]}
+ *
+ * Reverse operation: [ungroup].
+ *
+ * It is a special case of [move] operation.
+ *
+ * Don't confuse this with [groupBy],
+ * which groups the dataframe by the values in the selected columns!
+ */
+internal interface GroupDocs {
+
+    /**
+     * {@comment Version of [SelectingColumns] with correctly filled in examples}
+     * @include [SelectingColumns] {@include [SetGroupOperationArg]}
+     */
+    interface GroupSelectingOptions
+
+    /**
+     * ## Group Operation Grammar
+     * {@include [LineBreak]}
+     * {@include [DslGrammarLink]}
+     * {@include [LineBreak]}
+     *
+     * [**`into`**][GroupClause.into]**`(`**`groupName: `[`String`][String]**`)`**
+     *
+     * {@include [Indent]}
+     * __`.`__[**`into`**][GroupClause.into]**`  {  `**`groupNameExpression: `[`ColumnsSelector`][ColumnsSelector]**`  }  `**
+     */
+    interface Grammar
+}
+
+/** {@set [SelectingColumns.OPERATION] [group][group]} */
+@ExcludeFromSources
+private interface SetGroupOperationArg
+
+/**
+ * {@include [GroupDocs]}
+ * ### This Group Overload
+ */
+@ExcludeFromSources
+private interface CommonGroupDocs
+
+/**
+ * @include [CommonGroupDocs]
+ * @include [SelectingColumns.Dsl] {@include [SetGroupOperationArg]}
+ * ### Examples:
+ * ```kotlin
+ * df.group { columnA and columnB }.into("valueCols")
+ * df.group { colsOf<String>() }.into { it.name.split(".").first() }
+ * ```
+ * @param [columns\] The [Columns Selector][ColumnsSelector] used to select the columns of this [DataFrame] to group.
+ */
 @Interpretable("Group0")
 public fun <T, C> DataFrame<T>.group(columns: ColumnsSelector<T, C>): GroupClause<T, C> = GroupClause(this, columns)
 
+/**
+ * @include [CommonGroupDocs]
+ * @include [SelectingColumns.ColumnNames] {@include [SetGroupOperationArg]}
+ * ### Example:
+ * ```kotlin
+ * df.group("second").into("valueCols")
+ * df.group("prop.A", "prop.B", "cnt.A", "cnt.B").into { it.name.split(".").first() }
+ * ```
+ * @param [columns\] The [Column Names][String] used to select the columns of this [DataFrame] to group.
+ */
 public fun <T> DataFrame<T>.group(vararg columns: String): GroupClause<T, Any?> = group { columns.toColumnSet() }
 
 @AccessApiOverload
@@ -31,23 +116,110 @@ public fun <T> DataFrame<T>.group(vararg columns: KProperty<*>): GroupClause<T,
 
 // region GroupClause
 
+/**
+ * An intermediate class used in the [group] operation.
+ *
+ * This class itself does nothing—it is just a transitional step before specifying
+ * how to group the selected columns.
+ * It must be followed by one of the positioning methods
+ * to produce a new [DataFrame] with the updated column structure.
+ *
+ * Use the following methods to finalize the move:
+ * - [into(groupName)][GroupClause.into] – groups selected columns into a one column group.
+ * - [into { groupNameExpression }][GroupClause.into] – groups each column into a group
+ * by specifying path or name.
+ *
+ * See [Grammar][GroupDocs.Grammar] for more details.
+ */
 public class GroupClause<T, C>(internal val df: DataFrame<T>, internal val columns: ColumnsSelector<T, C>) {
     override fun toString(): String = "GroupClause(df=$df, columns=$columns)"
 }
 
 // region into
 
+/**
+ * Groups columns, previously selected with [group], into new or existing column groups
+ * within the [DataFrame], using an [ColumnsSelectionDsl] expression to specify the target group name for each column.
+ * The expression is applied to each selected column and determines the name of the column group
+ * it will be placed into.
+ *
+ * If a column group with the specified name does not exist, it will be created.
+ *
+ * See [Selecting Columns][SelectingColumns].
+ *
+ * For more information: {@include [DocumentationUrls.Group]}
+ *
+ * @include [SelectingColumns.ColumnNames]
+ *
+ * ### Example:
+ * ```kotlin
+ * df.group { all() }.into { it.type().toString() }
+ * ```
+ *
+ * @param column A [ColumnsSelector] expression that takes a column and returns the name of the [ColumnGroup]
+ * where that column should be grouped.
+ * All selected columns will be moved under the groups defined by this expression.
+ */
 @JvmName("intoString")
 @OverloadResolutionByLambdaReturnType
 @OptIn(ExperimentalTypeInference::class)
 public fun <T, C> GroupClause<T, C>.into(column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> String): DataFrame<T> =
     df.move(columns).under { column(it).toColumnAccessor() }
 
+/**
+ * Groups columns, previously selected with [group], into a new or existing column group
+ * within the [DataFrame] by specifying its path via [ColumnsSelectionDsl] expression.
+ *
+ * If the specified path refers to a non-existent column group, it will be created automatically,
+ * including any missing intermediate segments.
+ *
+ * See [Selecting Columns][SelectingColumns].
+ *
+ * For more information: {@include [DocumentationUrls.Group]}
+ *
+ * @include [SelectingColumns.ColumnNames]
+ *
+ * ### Examples:
+ * ```kotlin
+ * // Group selected columns into an existing column group:
+ * df.group("age", "weight").into { info }
+ * // Group selected columns into a nested column group using a path that may
+ * // contain both existing and new segments:
+ * df.group { employee.age and employee.weight }.into { pathOf("info", "personal") }
+ * // Group selected columns under their ancestor group located two levels up in the path hierarchy
+ * df.group { colsAtAnyDepth().colsOf<String>() }.into { it.path.dropLast(2) }
+ * ```
+ *
+ * @param column A [ColumnsSelector] expression that takes a column and returns the full path to the [ColumnGroup]
+ * where that column should be grouped.
+ * All selected columns will be moved under the groups defined by this expression.
+ */
 @JvmName("intoColumn")
 public fun <T, C> GroupClause<T, C>.into(
     column: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> AnyColumnReference,
 ): DataFrame<T> = df.move(columns).under(column)
 
+/**
+ * Groups columns, previously selected with [group], into a new or existing column group
+ * within the [DataFrame], by specifying its name.
+ *
+ * If a column group with the specified name does not exist, it will be created.
+ *
+ * See [Selecting Columns][SelectingColumns].
+ *
+ * For more information: {@include [DocumentationUrls.Group]}
+ *
+ * @include [SelectingColumns.ColumnNames]
+ *
+ * ### Examples:
+ * ```kotlin
+ * df.group("age", "weight").into("info")
+ * df.group { age and weight }.into("info")
+ * ```
+ *
+ * @param [column] A [ColumnsSelector] that defines the path to a [ColumnGroup]
+ * in the [DataFrame], where the selected columns will be moved.
+ */
 @Refine
 @Interpretable("Into0")
 public fun <T, C> GroupClause<T, C>.into(column: String): DataFrame<T> = into(columnGroup().named(column))

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/take.kt

@@ -60,7 +60,7 @@ public fun <T> DataFrame<T>.takeLast(n: Int = 1): DataFrame<T> {
 /**
  * Returns a DataFrame containing first rows that satisfy the given [predicate].
  */
-public inline fun <T> DataFrame<T>.takeWhile(crossinline predicate: RowFilter<T>): DataFrame<T> =
+public inline fun <T> DataFrame<T>.takeWhile(predicate: RowFilter<T>): DataFrame<T> =
     firstOrNull { !predicate(it, it) }?.let { take(it.index()) } ?: this
 
 // endregion

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt

@@ -6,19 +6,65 @@ import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.annotations.AccessApiOverload
 import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
 import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.documentation.DocumentationUrls
+import org.jetbrains.kotlinx.dataframe.documentation.ExcludeFromSources
+import org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.removeAt
 import kotlin.reflect.KProperty
 
 // region DataFrame
 
+/**
+ * Ungroups the specified [column groups][columns\] within the [DataFrame], i.e.,
+ * replaces each [ColumnGroup] with its nested columns.
+ *
+ * See [Selecting Columns][UngroupSelectingOptions].
+ *
+ * For more information: {@include [DocumentationUrls.Ungroup]}
+ */
+internal interface UngroupDocs {
+    /**
+     * {@comment Version of [SelectingColumns] with correctly filled in examples}
+     * @include [SelectingColumns] {@include [SetUngroupOperationArg]}
+     */
+    interface UngroupSelectingOptions
+}
+
+/** {@set [SelectingColumns.OPERATION] [ungroup][ungroup]} */
+@ExcludeFromSources
+private interface SetUngroupOperationArg
+
+/**
+ * {@include [UngroupDocs]}
+ * ### This Ungroup Overload
+ */
+@ExcludeFromSources
+private interface CommonUngroupDocs
+
+/**
+ * @include [CommonUngroupDocs]
+ * @include [SelectingColumns.Dsl] {@include [SetUngroupOperationArg]}
+ * ### Examples:
+ * ```kotlin
+ * df.ungroup { groupA and groupB }
+ * df.ungroup { all() }
+ * ```
+ * @param [columns\] The [Columns Selector][ColumnsSelector] used to select the column groups of this [DataFrame] to ungroup.
+ */
 @Refine
 @Interpretable("Ungroup0")
 public fun <T, C> DataFrame<T>.ungroup(columns: ColumnsSelector<T, C>): DataFrame<T> =
     move { columns.toColumnSet().colsInGroups() }
         .into { it.path.removeAt(it.path.size - 2).toPath() }
 
+/**
+ * @include [CommonUngroupDocs]
+ * @include [SelectingColumns.ColumnNames.WithExample] {@include [SetUngroupOperationArg]}
+ * @param [columns\] The [Column Names][String] used to select the columns of this [DataFrame] to ungroup.
+ */
 public fun <T> DataFrame<T>.ungroup(vararg columns: String): DataFrame<T> = ungroup { columns.toColumnSet() }
 
 @AccessApiOverload

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt

@@ -92,4 +92,10 @@ internal interface DocumentationUrls {
 
     /** [See `move` on the documentation website.]({@include [Url]}/move.html) */
     interface Move
+
+    /** [See `group` on the documentation website.]({@include [Url]}/group.html) */
+    interface Group
+
+    /** [See `group` on the documentation website.]({@include [Url]}/ungroup.html) */
+    interface Ungroup
 }

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/describe.kt

@@ -118,10 +118,10 @@ private fun DataColumn<Any?>.convertToComparableOrNull(): DataColumn<Comparable<
 
         // Found incomparable number types, convert all to Double first
         isNumber() -> with(cast<Number?>()) {
-            if (any { it?.isPrimitiveNumber() == false }) {
-                return@convertToComparableOrNull null
+            map {
+                if (it?.isPrimitiveNumber() == false) return@convertToComparableOrNull null
+                it?.toDouble() as Comparable<Any>?
             }
-            map { it?.toDouble() as Comparable<Any>? }
         }
 
         else -> null

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/joinWith.kt

@@ -25,7 +25,7 @@ internal class JoinedDataRowImpl<A, B>(
     override val right: DataRow<B> = DataRowImpl(index1, rightOwner)
 }
 
-internal inline fun <A, B> DataFrame<A>.joinWithImpl(
+internal fun <A, B> DataFrame<A>.joinWithImpl(
     right: DataFrame<B>,
     type: JoinType = JoinType.Inner,
     addNewColumns: Boolean,