Inline functions and allow suspending transform lambdas

Author: cvb941

.idea/compiler.xml

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.3.3-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.1-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

.idea/misc.xml

@@ -6,8 +6,8 @@ import kotlinx.coroutines.coroutineScope
 /**
  *  Performs map transformation on the iterable using coroutines.
  */
-suspend fun <T, R> Iterable<T>.mapParallel(
-    transform: (T) -> R
+suspend inline fun <T, R> Iterable<T>.mapParallel(
+    crossinline transform: suspend (T) -> R
 ): List<R> = coroutineScope {
     map { async { transform(it) } }.map { it.await() }
 }
@@ -16,72 +16,72 @@ suspend fun <T, R> Iterable<T>.mapParallel(
 /**
  *  Performs map transformation on the array using coroutines.
  */
-suspend fun <T, R> Array<out T>.mapParallel(
-    transform: (T) -> R
+suspend inline fun <T, R> Array<out T>.mapParallel(
+    crossinline transform: suspend (T) -> R
 ): List<R> = coroutineScope {
     map { async { transform(it) } }.map { it.await() }
 }
 
 /**
  *  Performs map transformation on the array using coroutines.
  */
-suspend fun <R> ByteArray.mapParallel(
-    transform: (Byte) -> R
+suspend inline fun <R> ByteArray.mapParallel(
+    crossinline transform: suspend (Byte) -> R
 ): List<R> = coroutineScope {
     map { async { transform(it) } }.map { it.await() }
 }
 
 /**
  *  Performs map transformation on the array using coroutines.
  */
-suspend fun <R> ShortArray.mapParallel(
-    transform: (Short) -> R
+suspend inline fun <R> ShortArray.mapParallel(
+    crossinline transform: suspend (Short) -> R
 ): List<R> = coroutineScope {
     map { async { transform(it) } }.map { it.await() }
 }
 
 /**
  *  Performs map transformation on the array using coroutines.
  */
-suspend fun <R> IntArray.mapParallel(
-    transform: (Int) -> R
+suspend inline fun <R> IntArray.mapParallel(
+    crossinline transform: suspend (Int) -> R
 ): List<R> = coroutineScope {
     map { async { transform(it) } }.map { it.await() }
 }
 
 /**
  *  Performs map transformation on the array using coroutines.
  */
-suspend fun <R> LongArray.mapParallel(
-    transform: (Long) -> R
+suspend inline fun <R> LongArray.mapParallel(
+    crossinline transform: suspend (Long) -> R
 ): List<R> = coroutineScope {
     map { async { transform(it) } }.map { it.await() }
 }
 
 /**
  *  Performs map transformation on the array using coroutines.
  */
-suspend fun <R> FloatArray.mapParallel(
-    transform: (Float) -> R
+suspend inline fun <R> FloatArray.mapParallel(
+    crossinline transform: suspend (Float) -> R
 ): List<R> = coroutineScope {
     map { async { transform(it) } }.map { it.await() }
 }
 
 /**
  *  Performs map transformation on the array using coroutines.
  */
-suspend fun <R> DoubleArray.mapParallel(
-    transform: (Double) -> R
+suspend inline fun <R> DoubleArray.mapParallel(
+    crossinline transform: suspend (Double) -> R
 ): List<R> = coroutineScope {
     map { async { transform(it) } }.map { it.await() }
 }
 
 /**
  *  Performs map transformation on the array using coroutines.
  */
-suspend fun <R> BooleanArray.mapParallel(
-    transform: (Boolean) -> R
+suspend inline fun <R> BooleanArray.mapParallel(
+    crossinline transform: suspend (Boolean) -> R
 ): List<R> = coroutineScope {
     map { async { transform(it) } }.map { it.await() }
 }
-//endregion
+//endregion

gradle/wrapper/gradle-wrapper.properties

@@ -10,13 +10,13 @@ import kotlin.math.ceil
  *
  *  @param chunkSize Size of each sub-collection that will be reduced in each coroutine.
  */
-suspend fun <T, R> Iterable<T>.mapParallelChunked(
+suspend inline fun <T, R> Iterable<T>.mapParallelChunked(
     chunkSize: Int,
-    transform: (T) -> R
+    crossinline transform: suspend (T) -> R
 ): List<R> = coroutineScope {
     chunked(chunkSize).map { subChunk ->
         async {
-            subChunk.map(transform)
+            subChunk.map { transform(it) }
         }
     }.flatMap {
         it.await()
@@ -33,9 +33,9 @@ suspend fun <T, R> Iterable<T>.mapParallelChunked(
  *  @param chunksCount How many chunks should the collection be split into. Defaults to the number of available processors.
  *
  */
-suspend fun <T, E> Collection<T>.mapParallelChunked(
+suspend inline fun <T, E> Collection<T>.mapParallelChunked(
     chunksCount: Int = Runtime.getRuntime().availableProcessors(),
-    transform: (T) -> E
+    crossinline transform: suspend (T) -> E
 ): List<E> {
     assert(chunksCount > 0) { "Parameter chunksCount must be greater than 0" }
     if (isEmpty()) return emptyList()

transformations/src/main/kotlin/com/lukaskusik/coroutines/transformations/map/ParallelMap.kt

@@ -6,8 +6,8 @@ import kotlinx.coroutines.coroutineScope
 /**
  *  Performs map transformation on the iterable using coroutines.
  */
-suspend fun <T, R> Iterable<T>.mapIndexedParallel(
-    transform: (index: Int, T) -> R
+suspend inline fun <T, R> Iterable<T>.mapIndexedParallel(
+    crossinline transform: suspend (index: Int, T) -> R
 ): List<R> = coroutineScope {
     mapIndexed { i, elem -> async { transform(i, elem) } }.map { it.await() }
 }
@@ -16,72 +16,72 @@ suspend fun <T, R> Iterable<T>.mapIndexedParallel(
 /**
  *  Performs map transformation on the array using coroutines.
  */
-suspend fun <T, R> Array<out T>.mapIndexedParallel(
-    transform: (index: Int, T) -> R
+suspend inline fun <T, R> Array<out T>.mapIndexedParallel(
+    crossinline transform: suspend (index: Int, T) -> R
 ): List<R> = coroutineScope {
     mapIndexed { i, elem -> async { transform(i, elem) } }.map { it.await() }
 }
 
 /**
  *  Performs map transformation on the array using coroutines.
  */
-suspend fun <R> ByteArray.mapIndexedParallel(
-    transform: (index: Int, Byte) -> R
+suspend inline fun <R> ByteArray.mapIndexedParallel(
+    crossinline transform: suspend (index: Int, Byte) -> R
 ): List<R> = coroutineScope {
     mapIndexed { i, elem -> async { transform(i, elem) } }.map { it.await() }
 }
 
 /**
  *  Performs map transformation on the array using coroutines.
  */
-suspend fun <R> ShortArray.mapIndexedParallel(
-    transform: (index: Int, Short) -> R
+suspend inline fun <R> ShortArray.mapIndexedParallel(
+    crossinline transform: suspend (index: Int, Short) -> R
 ): List<R> = coroutineScope {
     mapIndexed { i, elem -> async { transform(i, elem) } }.map { it.await() }
 }
 
 /**
  *  Performs map transformation on the array using coroutines.
  */
-suspend fun <R> IntArray.mapIndexedParallel(
-    transform: (index: Int, Int) -> R
+suspend inline fun <R> IntArray.mapIndexedParallel(
+    crossinline transform: suspend (index: Int, Int) -> R
 ): List<R> = coroutineScope {
     mapIndexed { i, elem -> async { transform(i, elem) } }.map { it.await() }
 }
 
 /**
  *  Performs map transformation on the array using coroutines.
  */
-suspend fun <R> LongArray.mapIndexedParallel(
-    transform: (index: Int, Long) -> R
+suspend inline fun <R> LongArray.mapIndexedParallel(
+    crossinline transform: suspend (index: Int, Long) -> R
 ): List<R> = coroutineScope {
     mapIndexed { i, elem -> async { transform(i, elem) } }.map { it.await() }
 }
 
 /**
  *  Performs map transformation on the array using coroutines.
  */
-suspend fun <R> FloatArray.mapIndexedParallel(
-    transform: (index: Int, Float) -> R
+suspend inline fun <R> FloatArray.mapIndexedParallel(
+    crossinline transform: suspend (index: Int, Float) -> R
 ): List<R> = coroutineScope {
     mapIndexed { i, elem -> async { transform(i, elem) } }.map { it.await() }
 }
 
 /**
  *  Performs map transformation on the array using coroutines.
  */
-suspend fun <R> DoubleArray.mapIndexedParallel(
-    transform: (index: Int, Double) -> R
+suspend inline fun <R> DoubleArray.mapIndexedParallel(
+    crossinline transform: suspend (index: Int, Double) -> R
 ): List<R> = coroutineScope {
     mapIndexed { i, elem -> async { transform(i, elem) } }.map { it.await() }
 }
 
 /**
  *  Performs map transformation on the array using coroutines.
  */
-suspend fun <R> BooleanArray.mapIndexedParallel(
-    transform: (index: Int, Boolean) -> R
+suspend inline fun <R> BooleanArray.mapIndexedParallel(
+    crossinline transform: suspend (index: Int, Boolean) -> R
 ): List<R> = coroutineScope {
     mapIndexed { i, elem -> async { transform(i, elem) } }.map { it.await() }
 }
-//endregion
+//endregion

transformations/src/main/kotlin/com/lukaskusik/coroutines/transformations/map/ParallelMapChunked.kt

@@ -9,9 +9,9 @@ import kotlinx.coroutines.coroutineScope
  *
  *  @param chunkSize Size of each sub-collection that will be reduced in each coroutine.
  */
-suspend fun <T, R> Iterable<T>.mapIndexedParallelChunked(
+suspend inline fun <T, R> Iterable<T>.mapIndexedParallelChunked(
     chunkSize: Int,
-    transform: (index: Int, T) -> R
+    crossinline transform: suspend (index: Int, T) -> R
 ): List<R> = coroutineScope {
     withIndex().chunked(chunkSize).map { subChunk ->
         async {
@@ -32,9 +32,9 @@ suspend fun <T, R> Iterable<T>.mapIndexedParallelChunked(
  *  @param chunksCount How many chunks should the collection be split into. Defaults to the number of available processors.
  *
  */
-suspend fun <T, E> Collection<T>.mapIndexedParallelChunked(
+suspend inline fun <T, E> Collection<T>.mapIndexedParallelChunked(
     chunksCount: Int = Runtime.getRuntime().availableProcessors(),
-    transform: (index: Int, T) -> E
+    crossinline transform: suspend (index: Int, T) -> E
 ): List<E> {
     assert(chunksCount > 0) { "Parameter chunksCount must be greater than 0" }
     if (isEmpty()) return emptyList()

transformations/src/main/kotlin/com/lukaskusik/coroutines/transformations/mapindexed/ParallelMapIndexed.kt

@@ -1,41 +1,41 @@
 package com.lukaskusik.coroutines.transformations.mapinplace
 
-fun <T> Array<T>.mapInPlace(transform: (T) -> T): Array<T> {
+inline fun <T> Array<T>.mapInPlace(transform: (T) -> T): Array<T> {
     for (i in this.indices) this[i] = transform(this[i])
     return this
 }
 
-fun ByteArray.mapInPlace(transform: (Byte) -> Byte): ByteArray {
+inline fun ByteArray.mapInPlace(transform: (Byte) -> Byte): ByteArray {
     for (i in this.indices) this[i] = transform(this[i])
     return this
 }
 
-fun ShortArray.mapInPlace(transform: (Short) -> Short): ShortArray {
+inline fun ShortArray.mapInPlace(transform: (Short) -> Short): ShortArray {
     for (i in this.indices) this[i] = transform(this[i])
     return this
 }
 
-fun IntArray.mapInPlace(transform: (Int) -> Int): IntArray {
+inline fun IntArray.mapInPlace(transform: (Int) -> Int): IntArray {
     for (i in this.indices) this[i] = transform(this[i])
     return this
 }
 
-fun LongArray.mapInPlace(transform: (Long) -> Long): LongArray {
+inline fun LongArray.mapInPlace(transform: (Long) -> Long): LongArray {
     for (i in this.indices) this[i] = transform(this[i])
     return this
 }
 
-fun FloatArray.mapInPlace(transform: (Float) -> Float): FloatArray {
+inline fun FloatArray.mapInPlace(transform: (Float) -> Float): FloatArray {
     for (i in this.indices) this[i] = transform(this[i])
     return this
 }
 
-fun DoubleArray.mapInPlace(transform: (Double) -> Double): DoubleArray {
+inline fun DoubleArray.mapInPlace(transform: (Double) -> Double): DoubleArray {
     for (i in this.indices) this[i] = transform(this[i])
     return this
 }
 
-fun BooleanArray.mapInPlace(transform: (Boolean) -> Boolean): BooleanArray {
+inline fun BooleanArray.mapInPlace(transform: (Boolean) -> Boolean): BooleanArray {
     for (i in this.indices) this[i] = transform(this[i])
     return this
 }

transformations/src/main/kotlin/com/lukaskusik/coroutines/transformations/mapindexed/ParallelMapIndexedChunked.kt

@@ -1,41 +1,41 @@
 package com.lukaskusik.coroutines.transformations.mapinplace
 
-fun <T> Array<T>.mapInPlaceIndexed(transform: (index: Int, T) -> T): Array<T> {
+inline fun <T> Array<T>.mapInPlaceIndexed(transform: (index: Int, T) -> T): Array<T> {
     for (i in this.indices) this[i] = transform(i, this[i])
     return this
 }
 
-fun ByteArray.mapInPlaceIndexed(transform: (index: Int, Byte) -> Byte): ByteArray {
+inline fun ByteArray.mapInPlaceIndexed(transform: (index: Int, Byte) -> Byte): ByteArray {
     for (i in this.indices) this[i] = transform(i, this[i])
     return this
 }
 
-fun ShortArray.mapInPlaceIndexed(transform: (index: Int, Short) -> Short): ShortArray {
+inline fun ShortArray.mapInPlaceIndexed(transform: (index: Int, Short) -> Short): ShortArray {
     for (i in this.indices) this[i] = transform(i, this[i])
     return this
 }
 
-fun IntArray.mapInPlaceIndexed(transform: (index: Int, Int) -> Int): IntArray {
+inline fun IntArray.mapInPlaceIndexed(transform: (index: Int, Int) -> Int): IntArray {
     for (i in this.indices) this[i] = transform(i, this[i])
     return this
 }
 
-fun LongArray.mapInPlaceIndexed(transform: (index: Int, Long) -> Long): LongArray {
+inline fun LongArray.mapInPlaceIndexed(transform: (index: Int, Long) -> Long): LongArray {
     for (i in this.indices) this[i] = transform(i, this[i])
     return this
 }
 
-fun FloatArray.mapInPlaceIndexed(transform: (index: Int, Float) -> Float): FloatArray {
+inline fun FloatArray.mapInPlaceIndexed(transform: (index: Int, Float) -> Float): FloatArray {
     for (i in this.indices) this[i] = transform(i, this[i])
     return this
 }
 
-fun DoubleArray.mapInPlaceIndexed(transform: (index: Int, Double) -> Double): DoubleArray {
+inline fun DoubleArray.mapInPlaceIndexed(transform: (index: Int, Double) -> Double): DoubleArray {
     for (i in this.indices) this[i] = transform(i, this[i])
     return this
 }
 
-fun BooleanArray.mapInPlaceIndexed(transform: (index: Int, Boolean) -> Boolean): BooleanArray {
+inline fun BooleanArray.mapInPlaceIndexed(transform: (index: Int, Boolean) -> Boolean): BooleanArray {
     for (i in this.indices) this[i] = transform(i, this[i])
     return this
 }