A modern programming language that makes developers happier.

kotlinlang

Is there a way to terminate a flow from within an intermediate operator lambda?  For example, a flow emits 5 random numbers between 1-10.  Inside `map` , if the number is over 5, you terminate the flow.

i.e. just cancel whatever job is in the coroutine context

I tried cancel, but it looks like that operator isn't available on the receiver within an intermediate flow operator.

Would there be a way to cancel the flow without canceling the context's job?

you can't do `coroutineContext.cancel()`?

Yup, that worked.  Thanks <@UCJ90MC59>.  However, something a bit weird happens.   For example:
```val pf = flowOf(1,2,3).map { if (it == 3) coroutineContext.cancel() else it }
runBlocking {
    val l = pf.toList()
    println(l)
}```
prints:
```[1, 2, kotlin.Unit]```
It's that last item `kotlin.Unit` that's surprising.

nothing returns `void` in kotlin, it always returns `Unit`, so you're returning `Unit` from `cancel()` there

in this case yes, perhaps throwing the `CancellationException` would be better

So throwing `CancellationException`  works, but `catch` must also be used to be able to get the items emitted _before_ the exception is thrown.  Otherwise partial collection doesn't occur.

There's actually a PR open to introduce an operator that is for exactly this use case I think: <https://github.com/Kotlin/kotlinx.coroutines/pull/2066|https://github.com/Kotlin/kotlinx.coroutines/pull/2066>

Nice!  Thanks <@U0KMMQA20>! Maybe it'll be available soon.

Throwing a `CancellationException` is not the right way as it's ambiguous with other cancellation causes. You can take a look at how the `take` intermediate operator is done, and that can help to do what you want. Or you can copy `transformWhile` that Zach linked, or wait for it to be merged (which might take a while).