Fixed formatting (#367)

* Fixed formatting

* Fixed the review

* Fixed the review

Author: zaleslaw

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

@@ -7,15 +7,23 @@ import org.jetbrains.kotlinx.dataframe.impl.asList
 import kotlin.reflect.typeOf
 
 internal val ColumnReference<*>.name: String get() = name()
-public inline fun <reified T> ColumnReference<T>.withValues(vararg values: T): ValueColumn<T> = withValues(values.asIterable())
+
+public inline fun <reified T> ColumnReference<T>.withValues(vararg values: T): ValueColumn<T> =
+    withValues(values.asIterable())
+
 public inline fun <reified T> ColumnReference<T>.withValues(values: Iterable<T>): ValueColumn<T> =
     DataColumn.createValueColumn(name(), values.asList(), typeOf<T>())
 
 public infix fun <C : Comparable<C>> ColumnReference<C>.gt(value: C): ColumnReference<Boolean> = map { it > value }
+
 public infix fun <C : Comparable<C>> ColumnReference<C>.lt(value: C): ColumnReference<Boolean> = map { it < value }
+
 public infix fun <C> ColumnReference<C>.eq(value: C): ColumnReference<Boolean> = map { it == value }
+
 public infix fun <C> ColumnReference<C>.neq(value: C): ColumnReference<Boolean> = map { it != value }
 
 public fun ColumnReference<String?>.length(): ColumnReference<Int> = map { it?.length ?: 0 }
+
 public fun ColumnReference<String?>.lowercase(): ColumnReference<String?> = map { it?.lowercase() }
+
 public fun ColumnReference<String?>.uppercase(): ColumnReference<String?> = map { it?.uppercase() }

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

@@ -7,105 +7,164 @@ import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import java.math.BigDecimal
 
 public operator fun DataColumn<Int>.plus(value: Int): DataColumn<Int> = map { it + value }
+
 public operator fun DataColumn<Int>.minus(value: Int): DataColumn<Int> = map { it - value }
+
 public operator fun Int.plus(column: DataColumn<Int>): DataColumn<Int> = column.map { this + it }
+
 public operator fun Int.minus(column: DataColumn<Int>): DataColumn<Int> = column.map { this - it }
+
 public operator fun DataColumn<Int>.unaryMinus(): DataColumn<Int> = map { -it }
+
 public operator fun DataColumn<Int>.times(value: Int): DataColumn<Int> = map { it * value }
+
 public operator fun DataColumn<Int>.div(value: Int): DataColumn<Int> = map { it / value }
+
 public operator fun Int.div(column: DataColumn<Int>): DataColumn<Int> = column.map { this / it }
+
 public operator fun AnyCol.plus(str: String): DataColumn<String> = map { it.toString() + str }
 
 public operator fun ColumnReference<Int>.plus(value: Int): ColumnReference<Int> = map { it + value }
+
 public operator fun ColumnReference<Int>.minus(value: Int): ColumnReference<Int> = map { it - value }
+
 public operator fun Int.plus(column: ColumnReference<Int>): ColumnReference<Int> = column.map { this + it }
+
 public operator fun Int.minus(column: ColumnReference<Int>): ColumnReference<Int> = column.map { this - it }
+
 public operator fun ColumnReference<Int>.unaryMinus(): ColumnReference<Int> = map { -it }
+
 public operator fun ColumnReference<Int>.times(value: Int): ColumnReference<Int> = map { it * value }
+
 public operator fun ColumnReference<Int>.div(value: Int): ColumnReference<Int> = map { it / value }
+
 public operator fun Int.div(column: ColumnReference<Int>): ColumnReference<Int> = column.map { this / it }
+
 public operator fun ColumnReference<Any?>.plus(str: String): ColumnReference<String> = map { it.toString() + str }
 
 @JvmName("plusIntNullable")
 public operator fun DataColumn<Int?>.plus(value: Int): DataColumn<Int?> = map { it?.plus(value) }
+
 @JvmName("minusIntNullable")
 public operator fun DataColumn<Int?>.minus(value: Int): DataColumn<Int?> = map { it?.minus(value) }
+
 @JvmName("plusNullable")
 public operator fun Int.plus(column: DataColumn<Int?>): DataColumn<Int?> = column.map { it?.plus(this) }
+
 @JvmName("minusNullable")
 public operator fun Int.minus(column: DataColumn<Int?>): DataColumn<Int?> = column.map { it?.let { this - it } }
+
 @JvmName("unaryMinusIntNullable")
 public operator fun DataColumn<Int?>.unaryMinus(): DataColumn<Int?> = map { it?.unaryMinus() }
+
 @JvmName("timesIntNullable")
 public operator fun DataColumn<Int?>.times(value: Int): DataColumn<Int?> = map { it?.times(value) }
+
 @JvmName("divIntNullable")
 public operator fun DataColumn<Int?>.div(value: Int): DataColumn<Int?> = map { it?.div(value) }
+
 @JvmName("divNullable")
 public operator fun Int.div(column: DataColumn<Int?>): DataColumn<Int?> = column.map { it?.let { this / it } }
 
 @JvmName("plusInt")
 public operator fun DataColumn<Int>.plus(value: Double): DataColumn<Double> = map { it + value }
+
 @JvmName("minusInt")
 public operator fun DataColumn<Int>.minus(value: Double): DataColumn<Double> = map { it - value }
+
 @JvmName("doublePlus")
 public operator fun Double.plus(column: DataColumn<Int>): DataColumn<Double> = column.map { this + it }
+
 @JvmName("doubleMinus")
 public operator fun Double.minus(column: DataColumn<Int>): DataColumn<Double> = column.map { this - it }
+
 @JvmName("timesInt")
 public operator fun DataColumn<Int>.times(value: Double): DataColumn<Double> = map { it * value }
+
 @JvmName("divInt")
 public operator fun DataColumn<Int>.div(value: Double): DataColumn<Double> = map { it / value }
+
 @JvmName("doubleDiv")
 public operator fun Double.div(column: DataColumn<Int>): DataColumn<Double> = column.map { this / it }
 
 @JvmName("plusDouble")
 public operator fun DataColumn<Double>.plus(value: Int): DataColumn<Double> = map { it + value }
+
 @JvmName("minusDouble")
 public operator fun DataColumn<Double>.minus(value: Int): DataColumn<Double> = map { it - value }
+
 @JvmName("intPlus")
 public operator fun Int.plus(column: DataColumn<Double>): DataColumn<Double> = column.map { this + it }
+
 @JvmName("intMinus")
 public operator fun Int.minus(column: DataColumn<Double>): DataColumn<Double> = column.map { this - it }
+
 @JvmName("timesDouble")
 public operator fun DataColumn<Double>.times(value: Int): DataColumn<Double> = map { it * value }
+
 @JvmName("divDouble")
 public operator fun DataColumn<Double>.div(value: Int): DataColumn<Double> = map { it / value }
+
 @JvmName("intDiv")
 public operator fun Int.div(column: DataColumn<Double>): DataColumn<Double> = column.map { this / it }
 
 public operator fun DataColumn<Double>.plus(value: Double): DataColumn<Double> = map { it + value }
+
 public operator fun DataColumn<Double>.minus(value: Double): DataColumn<Double> = map { it - value }
+
 public operator fun Double.plus(column: DataColumn<Double>): DataColumn<Double> = column.map { this + it }
+
 public operator fun Double.minus(column: DataColumn<Double>): DataColumn<Double> = column.map { this - it }
+
 @JvmName("unaryMinusDouble")
 public operator fun DataColumn<Double>.unaryMinus(): DataColumn<Double> = map { -it }
+
 public operator fun DataColumn<Double>.times(value: Double): DataColumn<Double> = map { it * value }
+
 public operator fun DataColumn<Double>.div(value: Double): DataColumn<Double> = map { it / value }
+
 public operator fun Double.div(column: DataColumn<Double>): DataColumn<Double> = column.map { this / it }
 
 public operator fun DataColumn<Long>.plus(value: Long): DataColumn<Long> = map { it + value }
+
 public operator fun DataColumn<Long>.minus(value: Long): DataColumn<Long> = map { it - value }
+
 public operator fun Long.plus(column: DataColumn<Long>): DataColumn<Long> = column.map { this + it }
+
 public operator fun Long.minus(column: DataColumn<Long>): DataColumn<Long> = column.map { this - it }
+
 @JvmName("unaryMinusLong")
 public operator fun DataColumn<Long>.unaryMinus(): DataColumn<Long> = map { -it }
+
 public operator fun DataColumn<Long>.times(value: Long): DataColumn<Long> = map { it * value }
+
 public operator fun DataColumn<Long>.div(value: Long): DataColumn<Long> = map { it / value }
+
 public operator fun Long.div(column: DataColumn<Long>): DataColumn<Long> = column.map { this / it }
 
 public operator fun DataColumn<BigDecimal>.plus(value: BigDecimal): DataColumn<BigDecimal> = map { it + value }
+
 public operator fun DataColumn<BigDecimal>.minus(value: BigDecimal): DataColumn<BigDecimal> = map { it - value }
+
 public operator fun BigDecimal.plus(column: DataColumn<BigDecimal>): DataColumn<BigDecimal> = column.map { this + it }
+
 public operator fun BigDecimal.minus(column: DataColumn<BigDecimal>): DataColumn<BigDecimal> = column.map { this - it }
+
 @JvmName("unaryMinusBigDecimal")
 public operator fun DataColumn<BigDecimal>.unaryMinus(): DataColumn<BigDecimal> = map { -it }
+
 public operator fun DataColumn<BigDecimal>.times(value: BigDecimal): DataColumn<BigDecimal> = map { it * value }
+
 public operator fun DataColumn<BigDecimal>.div(value: BigDecimal): DataColumn<BigDecimal> = map { it / value }
+
 public operator fun BigDecimal.div(column: DataColumn<BigDecimal>): DataColumn<BigDecimal> = column.map { this / it }
 
 public infix fun <T> DataColumn<T>.eq(value: T): DataColumn<Boolean> = isMatching { it == value }
+
 public infix fun <T> DataColumn<T>.neq(value: T): DataColumn<Boolean> = isMatching { it != value }
+
 public infix fun <T : Comparable<T>> DataColumn<T>.gt(value: T): DataColumn<Boolean> = isMatching { it > value }
+
 public infix fun <T : Comparable<T>> DataColumn<T>.lt(value: T): DataColumn<Boolean> = isMatching { it < value }
 
 internal fun <T> DataColumn<T>.isMatching(predicate: Predicate<T>): DataColumn<Boolean> = map { predicate(it) }

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

@@ -11,14 +11,21 @@ import kotlin.reflect.full.isSubtypeOf
 import kotlin.reflect.typeOf
 
 public fun AnyCol.isColumnGroup(): Boolean = kind() == ColumnKind.Group
+
 public fun AnyCol.isFrameColumn(): Boolean = kind() == ColumnKind.Frame
+
 public fun AnyCol.isValueColumn(): Boolean = kind() == ColumnKind.Value
 
 public fun AnyCol.isSubtypeOf(type: KType): Boolean = this.type.isSubtypeOf(type) && (!this.type.isMarkedNullable || type.isMarkedNullable)
+
 public inline fun <reified T> AnyCol.isSubtypeOf(): Boolean = isSubtypeOf(typeOf<T>())
+
 public inline fun <reified T> AnyCol.isType(): Boolean = type() == typeOf<T>()
+
 public fun AnyCol.isNumber(): Boolean = isSubtypeOf<Number?>()
+
 public fun AnyCol.isList(): Boolean = typeClass == List::class
+
 public fun AnyCol.isComparable(): Boolean = isSubtypeOf<Comparable<*>?>()
 
 @PublishedApi

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

@@ -26,36 +26,57 @@ import kotlin.reflect.KProperty
 public fun <T, C> DataFrame<T>.getColumnsWithPaths(selector: ColumnsSelector<T, C>): List<ColumnWithPath<C>> =
     getColumnsWithPaths(UnresolvedColumnsPolicy.Fail, selector)
 
-public fun <T, C> DataFrame<T>.getColumnPath(selector: ColumnSelector<T, C>): ColumnPath = getColumnPaths(selector).single()
+public fun <T, C> DataFrame<T>.getColumnPath(selector: ColumnSelector<T, C>): ColumnPath =
+    getColumnPaths(selector).single()
+
 public fun <T, C> DataFrame<T>.getColumnPaths(selector: ColumnsSelector<T, C>): List<ColumnPath> =
     getColumnPaths(UnresolvedColumnsPolicy.Fail, selector)
 
-public fun <T, C> DataFrame<T>.getColumnWithPath(selector: ColumnSelector<T, C>): ColumnWithPath<C> = getColumnsWithPaths(selector).single()
+public fun <T, C> DataFrame<T>.getColumnWithPath(selector: ColumnSelector<T, C>): ColumnWithPath<C> =
+    getColumnsWithPaths(selector).single()
+
 public fun <T, C> DataFrame<T>.getColumns(selector: ColumnsSelector<T, C>): List<DataColumn<C>> = get(selector)
+
 public fun <T> DataFrame<T>.getColumns(vararg columns: String): List<AnyCol> = getColumns { columns.toColumnSet() }
 
 public fun <T> DataFrame<T>.getColumnIndex(col: AnyCol): Int = getColumnIndex(col.name())
-public fun <T> DataFrame<T>.getRows(range: IntRange): DataFrame<T> = if (range == indices()) this else columns().map { col -> col[range] }.toDataFrame().cast()
-public fun <T> DataFrame<T>.getRows(indices: Iterable<Int>): DataFrame<T> = columns().map { col -> col[indices] }.toDataFrame().cast()
+
+public fun <T> DataFrame<T>.getRows(range: IntRange): DataFrame<T> =
+    if (range == indices()) this else columns().map { col -> col[range] }.toDataFrame().cast()
+
+public fun <T> DataFrame<T>.getRows(indices: Iterable<Int>): DataFrame<T> =
+    columns().map { col -> col[indices] }.toDataFrame().cast()
+
 public fun <T> DataFrame<T>.getOrNull(index: Int): DataRow<T>? = if (index < 0 || index >= nrow) null else get(index)
 
-public fun <T> ColumnsContainer<T>.getFrameColumn(columnPath: ColumnPath): FrameColumn<*> = get(columnPath).asAnyFrameColumn()
-public fun <T> ColumnsContainer<T>.getFrameColumn(columnName: String): FrameColumn<*> = get(columnName).asAnyFrameColumn()
-public fun <T> ColumnsContainer<T>.getColumnGroup(columnPath: ColumnPath): ColumnGroup<*> = get(columnPath).asColumnGroup()
+public fun <T> ColumnsContainer<T>.getFrameColumn(columnPath: ColumnPath): FrameColumn<*> =
+    get(columnPath).asAnyFrameColumn()
+
+public fun <T> ColumnsContainer<T>.getFrameColumn(columnName: String): FrameColumn<*> =
+    get(columnName).asAnyFrameColumn()
+
+public fun <T> ColumnsContainer<T>.getColumnGroup(columnPath: ColumnPath): ColumnGroup<*> =
+    get(columnPath).asColumnGroup()
 
 // region getColumn
 
-public fun <T> ColumnsContainer<T>.getColumn(name: String): AnyCol = getColumnOrNull(name) ?: throw IllegalArgumentException("Column not found: '$name'")
+public fun <T> ColumnsContainer<T>.getColumn(name: String): AnyCol =
+    getColumnOrNull(name) ?: throw IllegalArgumentException("Column not found: '$name'")
 
-public fun <T, R> ColumnsContainer<T>.getColumn(column: ColumnReference<DataFrame<R>>): FrameColumn<R> = getColumnOrNull(column)?.asFrameColumn() ?: throw IllegalArgumentException("FrameColumn not found: '$column'")
+public fun <T, R> ColumnsContainer<T>.getColumn(column: ColumnReference<DataFrame<R>>): FrameColumn<R> =
+    getColumnOrNull(column)?.asFrameColumn() ?: throw IllegalArgumentException("FrameColumn not found: '$column'")
 
-public fun <T, R> ColumnsContainer<T>.getColumn(column: ColumnReference<DataRow<R>>): ColumnGroup<R> = getColumnOrNull(column)?.asColumnGroup() ?: throw IllegalArgumentException("ColumnGroup not found: '$column'")
+public fun <T, R> ColumnsContainer<T>.getColumn(column: ColumnReference<DataRow<R>>): ColumnGroup<R> =
+    getColumnOrNull(column)?.asColumnGroup() ?: throw IllegalArgumentException("ColumnGroup not found: '$column'")
 
-public fun <T, R> ColumnsContainer<T>.getColumn(column: ColumnReference<R>): DataColumn<R> = getColumnOrNull(column) ?: throw IllegalArgumentException("Column not found: '$column'")
+public fun <T, R> ColumnsContainer<T>.getColumn(column: ColumnReference<R>): DataColumn<R> =
+    getColumnOrNull(column) ?: throw IllegalArgumentException("Column not found: '$column'")
 
-public fun <T> ColumnsContainer<T>.getColumn(path: ColumnPath): AnyCol = getColumnOrNull(path) ?: throw IllegalArgumentException("Column not found: '$path'")
+public fun <T> ColumnsContainer<T>.getColumn(path: ColumnPath): AnyCol =
+    getColumnOrNull(path) ?: throw IllegalArgumentException("Column not found: '$path'")
 
-public fun <T> ColumnsContainer<T>.getColumn(index: Int): AnyCol = getColumnOrNull(index) ?: throw IllegalArgumentException("Column index is out of bounds: $index. Columns count = $ncol")
+public fun <T> ColumnsContainer<T>.getColumn(index: Int): AnyCol = getColumnOrNull(index)
+    ?: throw IllegalArgumentException("Column index is out of bounds: $index. Columns count = $ncol")
 
 public fun <T, C> ColumnsContainer<T>.getColumn(selector: ColumnSelector<T, C>): DataColumn<C> = get(selector)
 
@@ -67,35 +88,41 @@ public fun <T> ColumnsContainer<T>.getColumnGroup(index: Int): ColumnGroup<*> =
 
 public fun <T> ColumnsContainer<T>.getColumnGroup(name: String): ColumnGroup<*> = getColumn(name).asColumnGroup()
 
-public fun <T> ColumnsContainer<T>.getColumnGroup(column: KProperty<*>): ColumnGroup<*> = getColumnGroup(column.columnName)
+public fun <T> ColumnsContainer<T>.getColumnGroup(column: KProperty<*>): ColumnGroup<*> =
+    getColumnGroup(column.columnName)
 
-public fun <T, C> ColumnsContainer<T>.getColumnGroup(column: ColumnReference<DataRow<C>>): ColumnGroup<C> = getColumn(column)
+public fun <T, C> ColumnsContainer<T>.getColumnGroup(column: ColumnReference<DataRow<C>>): ColumnGroup<C> =
+    getColumn(column)
 
-public fun <T, C> ColumnsContainer<T>.getColumnGroup(column: ColumnSelector<T, DataRow<C>>): ColumnGroup<C> = get(column).asColumnGroup()
+public fun <T, C> ColumnsContainer<T>.getColumnGroup(column: ColumnSelector<T, DataRow<C>>): ColumnGroup<C> =
+    get(column).asColumnGroup()
 
 // endregion
 
 // region getColumnGroupOrNull
 
-public fun <T> ColumnsContainer<T>.getColumnGroupOrNull(name: String): ColumnGroup<*>? = getColumnOrNull(name)?.asColumnGroup()
+public fun <T> ColumnsContainer<T>.getColumnGroupOrNull(name: String): ColumnGroup<*>? =
+    getColumnOrNull(name)?.asColumnGroup()
 
-public fun <T> ColumnsContainer<T>.getColumnGroupOrNull(column: KProperty<*>): ColumnGroup<*>? = getColumnGroupOrNull(column.columnName)
+public fun <T> ColumnsContainer<T>.getColumnGroupOrNull(column: KProperty<*>): ColumnGroup<*>? =
+    getColumnGroupOrNull(column.columnName)
 
 // endregion
 
 // region containsColumn
 
 public fun <C> ColumnsContainer<*>.containsColumn(column: ColumnReference<C>): Boolean = getColumnOrNull(column) != null
+
 public fun ColumnsContainer<*>.containsColumn(column: KProperty<*>): Boolean = containsColumn(column.columnName)
 
 public operator fun ColumnsContainer<*>.contains(column: AnyColumnReference): Boolean = containsColumn(column)
+
 public operator fun ColumnsContainer<*>.contains(column: KProperty<*>): Boolean = containsColumn(column)
 
 // region rows
 
 public fun <T> DataFrame<T>.rows(): Iterable<DataRow<T>> = object : Iterable<DataRow<T>> {
     override fun iterator() =
-
         object : Iterator<DataRow<T>> {
             var nextRow = 0
 
@@ -110,7 +137,6 @@ public fun <T> DataFrame<T>.rows(): Iterable<DataRow<T>> = object : Iterable<Dat
 
 public fun <T> DataFrame<T>.rowsReversed(): Iterable<DataRow<T>> = object : Iterable<DataRow<T>> {
     override fun iterator() =
-
         object : Iterator<DataRow<T>> {
             var nextRow = nrow - 1