Is there a cleaner way of collecting two Flows? ``...

# stdlib

[Marcin Wisniowski]

Is there a cleaner way of collecting two Flows?

combine(flowA, flowB) { a, b -> a to b }.collect { (a, b) -> println("$a, $b") }

I'm looking to remove the "useless" transform step that the combine function requires.

[phldavies]

Why not combine to Unit and .collect()?

combine(flowA, flowB) { a, b -> println("$a, $b") }.collect()

[phldavies]

(there's probably a reason... genuinely intrigued if there is)

[Klitos Kyriacou]

Could combineTransform be what you're looking for?

[ephemient]

combineTransform is basically the same as combine with a lambda for this use case, although you can emit nothing which I guess is slightly less work

[Marcin Wisniowski]

Hmm, I'm not seeing how to apply combineTransform here in a way that would make it shorter.

[ephemient]

combineTransform(flowA, flowB) { a, b -> println("$a, $b") }.collect()

same as Phil's suggestion, but it skips the discarded emissions

[Marcin Wisniowski]

Phil's suggestion works fine, but combineTransform makes me manually specify types so it becomes combineTransform<TypeA, TypeB, Unit>(flowA, flowB) { a, b -> println("$a, $b") }.collect()

[Marcin Wisniowski]

Which becomes longer than the original. With combine the type parameters are inferred correctly.

[ephemient]

you should be able to write

.combineTransform<_, _, Nothing> { a, b ->

it is longer, but it more clearly marks that the transform doesn't actually produce any output

[Marcin Wisniowski]

It just all feels like a hack to me because it's "misusing" the transform lambda as the terminal operation instead of transforming data.