zipDelayError.kt

import io.reactivex.Single
import io.reactivex.rxkotlin.Singles

fun <T1 : Any, T2 : Any> Singles.zipDelayError(
    s1: Single<T1>,
    s2: Single<T2>,
): Single<Pair<T1, T2>> {
    abstract class Value(val sortOrder: Int) {
        abstract val value: Any
    }

    data class V1(override val value: T1) : Value(1)
    data class V2(override val value: T2) : Value(2)

    return Single
        .mergeDelayError(
            s1.map { listOf(V1(it)) },
            s2.map { listOf(V2(it)) },
        )
        .scan { t1, t2 ->
            t1 + t2
        }
        .lastOrError()
        .map { wrappers ->
            check(wrappers.size == 2)

            val sorted = wrappers.sortedBy { it.sortOrder }

            val t1 = sorted[0] as? V1
            val t2 = sorted[1] as? V2

            checkNotNull(t1).value to checkNotNull(t2).value
        }
}

fun <T1 : Any, T2 : Any, T3 : Any> Singles.zipDelayError(
    s1: Single<T1>,
    s2: Single<T2>,
    s3: Single<T3>,
): Single<Triple<T1, T2, T3>> {
    abstract class Value(val sortOrder: Int) {
        abstract val value: Any
    }

    data class V1(override val value: T1) : Value(1)
    data class V2(override val value: T2) : Value(2)
    data class V3(override val value: T3) : Value(3)

    return Single
        .mergeDelayError(
            s1.map { listOf(V1(it)) },
            s2.map { listOf(V2(it)) },
            s3.map { listOf(V3(it)) },
        )
        .scan { t1, t2 ->
            t1 + t2
        }
        .lastOrError()
        .map { wrappers ->
            check(wrappers.size == 3)

            val sorted = wrappers.sortedBy { it.sortOrder }

            val t1 = sorted[0] as? V1
            val t2 = sorted[1] as? V2
            val t3 = sorted[2] as? V3

            Triple(checkNotNull(t1).value, checkNotNull(t2).value, checkNotNull(t3).value)
        }
}