Renaming

Author: qwwdfsad

binary-compatibility-validator/reference-public-api/kotlinx-coroutines-core.txt

@@ -856,7 +856,8 @@ public final class kotlinx/coroutines/flow/FlowKt {
 	public static final fun retry (Lkotlinx/coroutines/flow/Flow;ILkotlin/jvm/functions/Function1;)Lkotlinx/coroutines/flow/Flow;
 	public static synthetic fun retry$default (Lkotlinx/coroutines/flow/Flow;ILkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lkotlinx/coroutines/flow/Flow;
 	public static final fun sample (Lkotlinx/coroutines/flow/Flow;J)Lkotlinx/coroutines/flow/Flow;
-	public static final fun scan (Lkotlinx/coroutines/flow/Flow;Lkotlin/jvm/functions/Function3;)Lkotlinx/coroutines/flow/Flow;
+	public static final fun scan (Lkotlinx/coroutines/flow/Flow;Ljava/lang/Object;Lkotlin/jvm/functions/Function3;)Lkotlinx/coroutines/flow/Flow;
+	public static final fun scanReduce (Lkotlinx/coroutines/flow/Flow;Lkotlin/jvm/functions/Function3;)Lkotlinx/coroutines/flow/Flow;
 	public static final fun single (Lkotlinx/coroutines/flow/Flow;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public static final fun singleOrNull (Lkotlinx/coroutines/flow/Flow;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public static final fun switchMap (Lkotlinx/coroutines/flow/Flow;Lkotlin/jvm/functions/Function2;)Lkotlinx/coroutines/flow/Flow;
@@ -885,6 +886,7 @@ public final class kotlinx/coroutines/flow/MigrationKt {
 	public static final fun observeOn (Lkotlinx/coroutines/flow/Flow;Lkotlin/coroutines/CoroutineContext;)Lkotlinx/coroutines/flow/Flow;
 	public static final fun onErrorResume (Lkotlinx/coroutines/flow/Flow;Lkotlinx/coroutines/flow/Flow;)Lkotlinx/coroutines/flow/Flow;
 	public static final fun publishOn (Lkotlinx/coroutines/flow/Flow;Lkotlin/coroutines/CoroutineContext;)Lkotlinx/coroutines/flow/Flow;
+	public static final fun scanFold (Lkotlinx/coroutines/flow/Flow;Ljava/lang/Object;Lkotlin/jvm/functions/Function3;)Lkotlinx/coroutines/flow/Flow;
 	public static final fun skip (Lkotlinx/coroutines/flow/Flow;I)Lkotlinx/coroutines/flow/Flow;
 	public static final fun subscribe (Lkotlinx/coroutines/flow/Flow;)V
 	public static final fun subscribe (Lkotlinx/coroutines/flow/Flow;Lkotlin/jvm/functions/Function1;)V

kotlinx-coroutines-core/common/src/flow/Migration.kt

@@ -239,4 +239,11 @@ public fun <T> Flow<T>.skip(count: Int): Flow<T> = error("Should not be called")
     message = "Flow analogue of 'forEach' is 'collect'",
     replaceWith = ReplaceWith("collect(block)")
 )
-public fun <T> Flow<T>.forEach(action: suspend (value: T) -> Unit): Unit = error("Should not be called")
+public fun <T> Flow<T>.forEach(action: suspend (value: T) -> Unit): Unit = error("Should not be called")
+
+@Deprecated(
+    level = DeprecationLevel.ERROR,
+    message = "Flow has less verbose 'scan' shortcut",
+    replaceWith = ReplaceWith("scan(initial, operation)")
+)
+public fun <T, R> Flow<T>.scanFold(initial: R, @BuilderInference operation: suspend (accumulator: R, value: T) -> R): Flow<R> = error("Should not be called")

kotlinx-coroutines-core/common/src/flow/operators/Transform.kt

@@ -100,10 +100,29 @@ public fun <T> Flow<T>.onEach(action: suspend (T) -> Unit): Flow<T> = flow {
     }
 }
 
+/**
+ * Folds the given flow with [operation], emitting every intermediate result, including [initial] value.
+ * Note that initial value should be immutable (or should not be mutated) as it is shared between different collectors.
+ * For example:
+ * ```
+ * flowOf(1, 2, 3).accumulate(emptyList<Int>()) { acc, value -> acc + value }.toList()
+ * ```
+ * will produce `[], [1], [1, 2], [1, 2, 3]]`.
+ */
+@FlowPreview
+public fun <T, R> Flow<T>.scan(initial: R, @BuilderInference operation: suspend (accumulator: R, value: T) -> R): Flow<R> = flow {
+    var accumulator: R = initial
+    emit(accumulator)
+    collect { value ->
+        accumulator = operation(accumulator, value)
+        emit(accumulator)
+    }
+}
+
 /**
  * Reduces the given flow with [operation], emitting every intermediate result, including initial value.
  * The first element is taken as initial value for operation accumulator.
- * This operator has a sibling with initial value -- [accumulate].
+ * This operator has a sibling with initial value -- [scan].
  *
  * For example:
  * ```
@@ -112,7 +131,7 @@ public fun <T> Flow<T>.onEach(action: suspend (T) -> Unit): Flow<T> = flow {
  * will produce `[1, 3, 6, 10]`
  */
 @FlowPreview
-public fun <T> Flow<T>.scan(operation: suspend (accumulator: T, value: T) -> T): Flow<T> = flow {
+public fun <T> Flow<T>.scanReduce(operation: suspend (accumulator: T, value: T) -> T): Flow<T> = flow {
     var accumulator: Any? = NullSurrogate
     collect { value ->
         accumulator = if (accumulator === NullSurrogate) {
@@ -123,22 +142,3 @@ public fun <T> Flow<T>.scan(operation: suspend (accumulator: T, value: T) -> T):
         emit(accumulator as T)
     }
 }
-
-/**
- * Reduces the given flow with [operation], emitting every intermediate result, including [initial] value.
- * Note that initial value should be immutable (or should not be mutated) as it is shared between different collectors.
- * For example:
- * ```
- * flowOf(1, 2, 3).accumulate(emptyList<Int>()) { acc, value -> acc + value }.toList()
- * ```
- * will produce `[], [1], [1, 2], [1, 2, 3]]`.
- */
-@FlowPreview
-public fun <T, R> Flow<T>.accumulate(initial: R, @BuilderInference operation: suspend (accumulator: R, value: T) -> R): Flow<R> = flow {
-    var accumulator: R = initial
-    emit(accumulator)
-    collect { value ->
-        accumulator = operation(accumulator, value)
-        emit(accumulator)
-    }
-}

kotlinx-coroutines-core/common/test/flow/operators/ScanTest.kt

@@ -12,27 +12,27 @@ class ScanTest : TestBase() {
     @Test
     fun testScan() = runTest {
         val flow = flowOf(1, 2, 3, 4, 5)
-        val result = flow.scan { acc, v -> acc + v }.toList()
+        val result = flow.scanReduce { acc, v -> acc + v }.toList()
         assertEquals(listOf(1, 3, 6, 10, 15), result)
     }
 
     @Test
     fun testScanWithInitial() = runTest {
         val flow = flowOf(1, 2, 3)
-        val result = flow.accumulate(emptyList<Int>()) { acc, value -> acc + value }.toList()
+        val result = flow.scan(emptyList<Int>()) { acc, value -> acc + value }.toList()
         assertEquals(listOf(emptyList(), listOf(1), listOf(1, 2), listOf(1, 2, 3)), result)
     }
 
     @Test
     fun testNulls() = runTest {
         val flow = flowOf(null, 2, null, null, null, 5)
-        val result = flow.scan { acc, v ->  if (v == null) acc else (if (acc == null) v else acc + v) }.toList()
+        val result = flow.scanReduce { acc, v ->  if (v == null) acc else (if (acc == null) v else acc + v) }.toList()
         assertEquals(listOf(null, 2, 2, 2, 2, 7), result)
     }
 
     @Test
     fun testEmptyFlow() = runTest {
-        val result = emptyFlow<Int>().scan { _, _ -> 1 }.toList()
+        val result = emptyFlow<Int>().scanReduce { _, _ -> 1 }.toList()
         assertTrue(result.isEmpty())
     }
 
@@ -49,7 +49,7 @@ class ScanTest : TestBase() {
                 emit(1)
                 emit(2)
             }
-        }.scan { _, value ->
+        }.scanReduce { _, value ->
             expect(value) // 2
             latch.receive()
             throw TestException()