[Flow] combineTransformLatest()

I’d like to propose introduce new combineTransformLatest operator , which behaves like combineTransform but cancels transformer if new value arrives.

Example: loading places to map; user is moving with map, which cancels the previous fetching, also the loaded data depend on filter or other Flows.

I've implement this

class Symbol(val symbol: String) {
	override fun toString(): String = symbol

	@Suppress("UNCHECKED_CAST", "NOTHING_TO_INLINE")
	inline fun <T> unbox(value: Any?): T = if (value === this) null as T else value as T
}

val NULL = Symbol("NULL")

inline fun <reified T, R> combineTransformLatest(
	vararg flows: Flow<T>,
	@BuilderInference crossinline transform: suspend FlowCollector<R>.(Array<T>) -> Unit
): Flow<R> {
	return channelFlow {
		coroutineScope {
			val size = flows.size
			val channels = flows.map { flow ->
				[e-mail]<Any> {
					flow.collect { value ->
						[e-mail](value ?: NULL)
					}
				}
			}
		var job: Job? = null
		val latestValues = arrayOfNulls<Any?>(size)
		val isClosed = Array(size) { false }

		while (!isClosed.all { it }) {
			select<Unit> {
				for (i in 0 until size) {
					if (isClosed[i]) continue
					@Suppress("DEPRECATION")
					channels[i].onReceiveOrNull { receivedValue ->
						if (receivedValue == null) {
							isClosed[i] = true
						} else {
							latestValues[i] = receivedValue
							if (latestValues.all { it !== null }) {
								job?.apply {
									cancel(CancellationException())
									join()
								}
								job = launch {
									val arguments = arrayOfNulls<T>(size)
									for (index in 0 until size) {
										arguments[index] = NULL.unbox(latestValues[index])
									}
									flow<R> {
										@Suppress("UNCHECKED_CAST")
										[e-mail](arguments as Array<T>)
									}.collect {
										[e-mail](it)
									}
								}
							}
						}
					}
				}
			}
		}
	}
}

Not totally sure if the channelFlow as wrapper is correct, probably possible to do it without it but only with access to intenals.

I’m ok to have just this signature - varargs and with transformer, which allows not to emit or emit multiple times in opposite combineLatest().

[PaulWoitaschek]

I managed to roll my own combineTransformLatest which is based on the existing operators 🎉

import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.FlowCollector
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.transformLatest

inline fun <reified T, R> combineTransformLatest(
  vararg flows: Flow<T>,
  @BuilderInference noinline transform: suspend FlowCollector<R>.(Array<T>) -> Unit
): Flow<R> {
  return combine(*flows) { it }
    .transformLatest(transform)
}

fun <T1, T2, R> combineTransformLatest(
  flow: Flow<T1>,
  flow2: Flow<T2>,
  @BuilderInference transform: suspend FlowCollector<R>.(T1, T2) -> Unit
): Flow<R> {
  return combineTransformLatest(flow, flow2) { args ->
    @Suppress("UNCHECKED_CAST")
    transform(
      args[0] as T1,
      args[1] as T2
    )
  }
}

[Shusek]

In fact, combineTransform should be called combineTransformConcat because any function that is suspended inside transform collector also suspend combines a bit like flatMapConcat operator.