Is there an example somewhere how to implement switchMap for Kotlin Flows?

Isn't it called

flatMap

?

ReactiveX offers different strategies on how to interleave resulting streams.

Note that FlatMap merges the emissions of these Observables, so that they may interleave.

These docs makes comparison with other operators. http://reactivex.io/documentation/operators/flatmap.html

@simon.vergauwen thanks for the link, the comparison looks very interesting. I am currently using the switchMap version. Would that mean I need to make my own implementation or is there something (similar) already available in Flow?

Reading the comment on

flatMapConcat

and seeing how it’s an alias to

flatMapMerge(concurrency = 1, bufferSize = 1)

I imagine this behaves as

switchMap

but the docs are not extensive enough to confirm that without trying it out unfortunately.

Transforms elements emitted by the original flow by applying transform, that returns another flow, and then concatenating and flattening these flows. This method is identical to flatMapMerge(concurrency = 1, bufferSize = 1)

source: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/

I found the following issue which shows that

switchMap

still needs to be added: https://github.com/Kotlin/kotlinx.coroutines/issues/1107 So I think

flatMapConcat

works a bit differently but I really don’t know without trying.

First, there'd need to be a way to stop `collect`ing. Is there 'break' like functionality for cancel collecting a Flow?

@streetsofboston Would throwing a

CancellationException

work?

That may work, but it looks 'hacky' to me... Usually, your code calls

collect

inside a `launch`ed coroutine. Then cancelling the

Job

returned by that

launch

looks more idiomatic to me. Still, I think we'd want a more simple way, more imperative/sequential way of breaking out of a

collect

loop. You can't break out of an Rx

subscribe

either, but since coroutines allow for a more imperitive/sequential way of programming, it would be great if Coroutines'

collect

would allow a 'break' or 'exit' out of the loop. Think about having two plain `Collection<T>`s and writing a

switchMap

for these two collections just using

for

loops...

@streetsofboston thanks for your detailed reply, I appreciate your explanation. qwwdfsad just made a pull request with an implementation for the switchMap operator, so I no longer need to implement it myself anymore: https://github.com/Kotlin/kotlinx.coroutines/pull/1132 Looks like they are cancelling the

Job

returned by

launch

, just like you explained earlier.