add `any` operator

[helmbold]

To make Kotlin Flow more suitable for a wide range of tasks, I suggest to add an any function like in Reactor.

Description

Emit a single boolean true if any of the values of this Flux sequence match the predicate.

Signature

fun <T> Flow<T>.any(predicate: (T) -> Boolean)): Flow<Boolean>

[elizarov]

You can use first { ... } terminal operator with Kotln Flow. I am not sure why would you need any. Can you give an example?

[helmbold]

Agreed. Since Flow doesn't have the concept of Mono and would terminate after emitting the first (and only) element adding any wouldn't make a big difference.

I just want to suggest the development of some more operators, since I was missing some operators I know from Reactor recently. So my approach is to go the the list of Flux operators, check if they already exist in Flow or were already filed as an issue, and then create a new issue. But maybe I generate too much duplicates (due slightly different naming) or operators that could easily replaced with existing Flow functions. @elizarov: I don't want to bother you, so if you don't think my approach is helpful, let me know.

[JakeWharton]

Since Flow doesn't have the concept of Mono

A Mono in coroutines is just a suspend fun, an asynchronous function invocation that can only produce a value or exception.

[elizarov]

This approach is not helpful. We don't have a goal of having all the Reactor operators. Our goals are completely opposite. We want to have a small core set of operators that people can easily learn and use to write their code. So, we are adding operators only when there are strong supporting use-cases to have them.

[helmbold]

Ok, thanks for clarification.

[jfsanchez91]

You can implement your own extension functions:

import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.count
import kotlinx.coroutines.flow.firstOrNull

suspend fun <T> Flow<T>.all(predicate: suspend (T) -> Boolean): Boolean {
    return this.count { !predicate(it) } == 0
}

suspend fun <T> Flow<T>.any(predicate: suspend (T) -> Boolean): Boolean {
    return this.firstOrNull { predicate(it) } != null
}

Testing

@Test
fun `Flow.all checks all elements match the predicate`() = runTest {
    val items = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 0).asFlow()
    Assertions.assertTrue(items.all { it <= 10 })
    Assertions.assertFalse(items.all { it >= 4 })
}

@Test
fun `Flow.any checks that at least one element matches the predicate`() = runTest {
    val items = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 0).asFlow()
    Assertions.assertTrue(items.any { it <= 0 }) // '0' matches
    Assertions.assertTrue(items.any { it >= 4 }) // '4, 5, 6, 7, 8, 9' match
    Assertions.assertFalse(items.any { it < 0 }) // No matches
}

[jdreddaway]

jfsanchez91 it would be better performance to use this.firstOrNull() and check for null instead of try/catching.