Is there an example somewhere how to implement swi...

# coroutines

[Thomas]

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

[louiscad]

Isn't it called flatMap?

[simon.vergauwen]

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]

flatMapConcat or flatMapMerge look like good examples.

[Thomas]

@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?

[Thomas]

@louiscad flatMap doesn’t exist in Flow. Do you mean flatMapConcat or flatMapMerge instead? Which one would be the equivalent of switchMap in Rx?

[simon.vergauwen]

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/

[Thomas]

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.

[streetsofboston]

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

[Thomas]

@streetsofboston Would throwing a CancellationException work?

[streetsofboston]

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...

[Thomas]

@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.