add flowFromNonSuspend (hoc081098#196)

Author: hoc081098

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 Petrus Nguyễn Thái Học
+Copyright (c) 2021-2023 Petrus Nguyễn Thái Học
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1335,7 +1335,7 @@ snapshot](https://hoc081098.github.io/FlowExt/docs/latest).
 ```License
 MIT License
 
-Copyright (c) 2021-2022 Petrus Nguyễn Thái Học
+Copyright (c) 2021-2023 Petrus Nguyễn Thái Học
 ```
 
 [badge-android]: http://img.shields.io/badge/android-6EDB8D.svg?style=flat

api/FlowExt.api

@@ -134,6 +134,10 @@ public final class com/hoc081098/flowext/FlatMapFirstKt {
 public abstract interface annotation class com/hoc081098/flowext/FlowExtPreview : java/lang/annotation/Annotation {
 }
 
+public final class com/hoc081098/flowext/FlowFromNonSuspendKt {
+	public static final fun flowFromNonSuspend (Lkotlin/jvm/functions/Function0;)Lkotlinx/coroutines/flow/Flow;
+}
+
 public final class com/hoc081098/flowext/FlowFromSuspendKt {
 	public static final fun flowFromSuspend (Lkotlin/jvm/functions/Function1;)Lkotlinx/coroutines/flow/Flow;
 }

src/commonMain/kotlin/com/hoc081098/flowext/concat.kt

@@ -169,6 +169,22 @@ public fun <T> Flow<T>.concatWith(others: Sequence<Flow<T>>): Flow<T> {
   }
 }
 
+/**
+ * This function is an alias to [concatWith] operator.
+ *
+ * Returns a [Flow] that emits the items emitted from this [Flow], then the next, one after the other, without interleaving them.
+ *
+ * Example:
+ * ``` kotlin
+ * val flow1 = flowOf(1, 2, 3)
+ * val flow2 = flowOf(4, 5, 6)
+ * val result = flow1 + flow2 // produces the following emissions 1, 2, 3, 4, 5, 6
+ * ```
+ *
+ * @see concatWith
+ */
+public operator fun <T> Flow<T>.plus(other: Flow<T>): Flow<T> = concat(this, other)
+
 //
 // startWith
 //
@@ -267,19 +283,3 @@ public fun <T> Flow<T>.startWith(others: Sequence<T>): Flow<T> = concat(others.a
  * Returns a [Flow] that emits the items in a specified [Flow] before it begins to emit items emitted by the current [Flow].
  */
 public fun <T> Flow<T>.startWith(other: Flow<T>): Flow<T> = concat(other, this)
-
-/**
- * This function is an alias to [concatWith] operator.
- *
- * Returns a [Flow] that emits the items emitted from this [Flow], then the next, one after the other, without interleaving them.
- *
- * @see concatWith
- *
- * Example:
- * ``` kotlin
- *  val flow1 = flowOf(1, 2, 3)
- *  val flow2 = flowOf(4, 5, 6)
- *  val result = flow1 + flow2 // produces the following emissions 1, 2, 3, 4, 5, 6
- * ```
- */
-public operator fun <T, R : T> Flow<T>.plus(other: Flow<R>): Flow<T> = concat(this, other)

src/commonMain/kotlin/com/hoc081098/flowext/flowFromNonSuspend.kt

@@ -0,0 +1,40 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2021-2023 Petrus Nguyễn Thái Học
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.hoc081098.flowext
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+
+/**
+ * Creates a _cold_ flow that produces a single value from the given [function].
+ *
+ * Example of usage:
+ *
+ * ```
+ * fun call(): R = ...
+ * fun callAsFlow(): Flow<R> = flowFromNonSuspend(::call)
+ * ```
+ */
+public fun <T> flowFromNonSuspend(function: () -> T): Flow<T> = flow { return@flow emit(function()) }

src/commonMain/kotlin/com/hoc081098/flowext/flowFromSuspend.kt

@@ -37,4 +37,5 @@ import kotlinx.coroutines.flow.flow
  * fun remoteCallFlow(): Flow<R> = flowFromSuspend(::remoteCall)
  * ```
  */
-public fun <T> flowFromSuspend(function: suspend () -> T): Flow<T> = flow { emit(function()) }
+public fun <T> flowFromSuspend(function: suspend () -> T): Flow<T> =
+  flow { return@flow emit(function()) }

src/commonTest/kotlin/com/hoc081098/flowext/FlowFromNonSuspendTest.kt

@@ -0,0 +1,57 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2021-2023 Petrus Nguyễn Thái Học
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.hoc081098.flowext
+
+import com.hoc081098.flowext.utils.BaseTest
+import com.hoc081098.flowext.utils.TestException
+import com.hoc081098.flowext.utils.test
+import kotlin.test.Test
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+
+@ExperimentalCoroutinesApi
+class FlowFromNonSuspendTest : BaseTest() {
+  @Test
+  fun flowFromNonSuspendEmitsValues() = runTest {
+    var count = 0L
+    val flow = flowFromNonSuspend {
+      count
+    }
+
+    flow.test(listOf(Event.Value(0L), Event.Complete))
+
+    ++count
+    flow.test(listOf(Event.Value(1L), Event.Complete))
+
+    ++count
+    flow.test(listOf(Event.Value(2L), Event.Complete))
+  }
+
+  @Test
+  fun deferFactoryThrows() = runTest {
+    val testException = TestException()
+
+    flowFromNonSuspend<Int> { throw testException }.test(listOf(Event.Error(testException)))
+  }
+}