add safeCast operator

CHANGELOG.md

@@ -4,6 +4,10 @@
 
 ### Changed
 
+### Added
+
+- Add `Flow.safeCast` operator.
+
 - Update dependencies
   - `Gradle` to `8.3`.
 

README.md

@@ -122,9 +122,10 @@ dependencies {
 - Intermediate operators
   - [`bufferCount`](#buffercount)
   - [`combine`](#combine)
-  - [`cast`](#cast--castnotnull--castnullable)
-  - [`castNotNull`](#cast--castnotnull--castnullable)
-  - [`castNullable`](#cast--castnotnull--castnullable)
+  - [`cast`](#cast--castnotnull--castnullable--safeCast)
+  - [`castNotNull`](#cast--castnotnull--castnullable--safeCast)
+  - [`castNullable`](#cast--castnotnull--castnullable--safeCast)
+  - [`safeCast`](#cast--castnotnull--castnullable--safeCast)
   - [`concatWith`](#concatwith)
   - [`startWith`](#startwith)
   - [`flatMapFirst`](#flatmapfirst--exhaustmap)
@@ -432,7 +433,7 @@ timer: kotlin.Unit
 
 ----
 
-#### cast / castNotNull / castNullable
+#### cast / castNotNull / castNullable / safeCast
 
 - Similar
   to [RxJava cast](http://reactivex.io/RxJava/3.x/javadoc/io/reactivex/rxjava3/core/Flowable.html#cast-java.lang.Class-)
@@ -487,6 +488,31 @@ castNotNull: 3
 
 ----
 
+
+##### safeCast
+
+Adapt this `Flow<*>` to be a `Flow<R?>`.
+
+At the collection time, if this `Flow` has any value that is not an instance of R, null will be emitted.
+
+```kotlin
+flowOf<Any?>(1, 2, 3, "Kotlin", null)
+  .safeCast<Int?>()
+  .collect { v: Int? -> println("safeCast: $v") }
+```
+
+Output:
+
+```none
+safeCast: 1
+safeCast: 2
+safeCast: 3
+safeCast: null
+safeCast: null
+```
+
+----
+
 #### concatWith
 
 - Similar to [RxJS concatWith](https://rxjs.dev/api/operators/concatWith)

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

@@ -53,3 +53,9 @@ public inline fun <reified T : Any> Flow<T?>.castNotNull(): Flow<T> = map { it!!
  */
 @Suppress("NOTHING_TO_INLINE")
 public inline fun <T> Flow<T>.castNullable(): Flow<T?> = this
+
+/**
+ * Adapt this `Flow<*>` to be a `Flow<R?>`.
+ */
+@Suppress("NOTHING_TO_INLINE")
+public inline fun <reified R> Flow<*>.safeCast(): Flow<R?> = map { it as? R }

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

@@ -28,11 +28,13 @@ import com.hoc081098.flowext.utils.BaseTest
 import com.hoc081098.flowext.utils.assertFailsWith
 import com.hoc081098.flowext.utils.test
 import kotlin.test.Test
+import kotlin.test.assertContentEquals
 import kotlin.test.assertIs
 import kotlin.test.assertSame
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.toList
 
 @ExperimentalCoroutinesApi
 class CastTest : BaseTest() {
@@ -96,4 +98,48 @@ class CastTest : BaseTest() {
     val flow = flowOf(1, 2, 3)
     assertSame(flow.castNullable(), flow)
   }
+
+  @Test
+  fun testSafeCastSuccess() = runTest {
+    assertIs<Flow<Int?>>(
+      flowOf<Any?>(1, 2, 3, "hello").safeCast<Int?>(),
+    )
+
+    assertIs<Flow<Int?>>(
+      flowOf<Any?>(1, 2, 3, "kotlin", null)
+        .safeCast<Int?>(),
+    )
+      .test(
+        listOf(
+          Event.Value(1),
+          Event.Value(2),
+          Event.Value(3),
+          Event.Value(null),
+          Event.Value(null),
+          Event.Complete,
+        ),
+      )
+  }
+
+  @Test
+  fun testSafeCast() {
+    val stringFlow: Flow<String?> = flowOf("Hello", 42, "World", 123, "Kotlin").safeCast()
+    assertIs<Flow<String?>>(stringFlow)
+
+    kotlinx.coroutines.test.runTest {
+      assertContentEquals(
+        listOf("Hello", null, "World", null, "Kotlin"),
+        stringFlow.toList(),
+      )
+    }
+    val intFlow: Flow<Int?> = flowOf(1, 2, 3, null).safeCast()
+    assertIs<Flow<Int?>>(intFlow)
+
+    kotlinx.coroutines.test.runTest {
+      assertContentEquals(
+        listOf(1, 2, 3, null),
+        intFlow.toList(),
+      )
+    }
+  }
 }