hey it seems flow does not have zip operator which would take more than one argument ```.zip(Iterabl...

# flow

[Maciej]

hey it seems flow does not have zip operator which would take more than one argument

.zip(Iterable<Flow>)

are there plans to add it?

[CLOVIS]

What would it take as the transform lambda? suspend (List<Any>) -> R ?

[Maciej]

I would use same concept as for combine

[Maciej]

public inline fun <reified T, R> combine(
    vararg flows: Flow<T>,
    crossinline transform: suspend (Array<T>) -> R)

[CLOVIS]

If you're happy with combine (they all must have a common super type), then you can just use it

[ephemient]

zip and combine do different things, you can't trivially switch between them

[Maciej]

@CLOVIS ☝️

[Maciej]

zip waits for all flows to complete and then emit result, combine emits multiple results

[ephemient]

this is not very efficient but should work:

fun <T> Flow<T>.zip(others: Iterable<Flow<T>>): Flow<List<T>> =
    others.fold(map { listOf(it) }) { acc, flow -> acc.zip(flow, List<T>::plus) }

[Maciej]

thx, but it's still not the same as rxjava counterpart where all zip tasks are executed at the same time

[ephemient]

what do you mean, they are executed in parallel

[ephemient]

https://pl.kotl.in/KrsnCWlbS

[Maciej]

sorry, you right I've understood that it will work in pairs
flow0 + flow1 = result1
result1 + flow2 = result2
and so on, but I was mistaken, again thx for help

[ephemient]

the fold sets up all the zip operations before anything is collected. once collecting starts, it'll pull from all of them. the big inefficiency is that constructing lists by + is O(N^2)

[ephemient]

you can avoid that with a more complex implementation like

fun <T> Iterable<Flow<T>>.zip(): Flow<List<T>> = flow {
    coroutineScope {
        val job = Job(coroutineContext.job)
        val channels = map { it.buffer(Channel.RENDEZVOUS).produceIn(this + job) }
        try {
            while (true) emit(channels.map { it.receiveCatching().onClosed { return@coroutineScope }.getOrThrow() })
        } finally {
            job.cancel()
        }
    }
}

but I have a hard time coming up with scenarios where you'd use zip on a wide enough collection of flows for it to really matter

[Maciej]

you right, I hope someday this could be added on language level

[ephemient]

I am not sure what you mean by that. Flows are not a language feature, they are a library construct