anyOf equivalent of Kotlin Deferred

Question

Coroutine async returns Deferred<T> and there are example of lazy execution and usages of await.

However how can we wait for any one of the Deffered instances to complete?

In a nutshell

  // whats the equivalent of CompletableFuture.anyOf(...)?
  // is this how we do it? if so how costly is this?
  select<Unit> {
     deffered1.onAwait {}
     deffered2.onAwait {}
  }

Answer 1

For variety, mentioning .merge(): Flow<T> alternative to select(), which I used to address a similar problem (get the first in a collection of deferreds to complete with a non-null value), i.e.

val firstCompletedResult = deferreds.map { it::await.asFlow() }.merge().first()

or if you like,

suspend fun <T> Iterable<Deferred<T>>.awaitAny(): T = map { it::await.asFlow() }.merge().first()

Answer 2

Use select expression like this

        val deferred1: Deferred<String?> = GlobalScope.async { getValue1() }
        val deferred2: Deferred<String?> = GlobalScope.async { getValue2() }
        val deferred3: Deferred<String?> = GlobalScope.async { getValue3() }

        val deferredList = listOf(deferred1, deferred2, deferred3)
        val firstCompletedResult = select<String?> {
            deferredList.forEach {
                it.onAwait {}
            }
        }
        
        Log.d(TAG, "firstCompleted: $firstCompletedResult")

Answer 3

Probably not the safest way to do things, but something like this should work:

inline suspend fun <T> Iterable<Deferred<T>>.awaitAny(): T {
    var completed: T? = null
    forEachIndexed { index, deferred ->
        deferred.invokeOnCompletion {
            completed = deferred.getCompleted()
            forEachIndexed { index2, deferred2 ->
                if (index != index2) {
                    deferred2.cancel(it)
                }
            }
        }
    }
    forEach {
        try {
            it.await()
        } catch (ignored: JobCancellationException) {
            // ignore
        }
    }
    return completed!!
}

Proof: The following prints 1000

launch(CommonPool) {
        // 10 - 1 second(s)
        val deferredInts = List(10, {
            val delayMs = (10 - it) * 1000
            async(CommonPool) {
                delay(delayMs)
                delayMs
            }
        })
        val first = deferredInts.awaitAny()
        println(first)
    }