hey Is there any way when using ```awaitAll ``` with differe

Question

hey Is there any way when using ```awaitAll ``` with different variables of different types for it to not be casted as Any

Joffrey · Answer

Union types are not a thing in Kotlin yet I guess that s what you re looking for

xii · Answer

perhaps that s it

xii · Answer

basically i make 3 api calls and put them in a list

xii · Answer

and wanted to await and do something like val call1 call2 = awaitAll call1Request call2Request

xii · Answer

rather than just doing ```val call1 = call1Request await ```

ephemient · Answer

without heterogeneous lists and some fancy type operators you can only specialize on specific sizes for example ```suspend fun lt A B gt Pair lt Deferred lt A gt Deferred lt B gt gt awaitAll Pair lt A B gt = Pair first await second await suspend fun lt A B C gt Triple lt Deferred lt A gt Deferred lt B gt Deferred lt C gt gt awaitAll Triple lt A B C gt = Triple first await second await third await ```

xii · Answer

does three awaits like that do exactly the same that an await all would traditionally do on a list

xii · Answer

three is good enough for me smiley

ephemient · Answer

yes it does

Joffrey · Answer

< ephemient> not really `awaitAll` on a list of deferred fails on the earliest failure regardless of order in the list Using multiple await forces you to wait for all preceding tasks to finish before failing on the await that fails

xii · Answer

that s unfortunate

ephemient · Answer

oh that s true in most cases you ll end up with similar behavior if the deferred comes from async in the same coroutine scope but not necessarily

ephemient · Answer

perhaps you could get away with ```suspend fun lt A B C gt Triple lt Deferred lt A gt Deferred lt B gt Deferred lt C gt gt awaitAll Triple lt A B C gt = try Triple first await second await third await catch e Throwable first cancel second cancel third cancel throw e ```

ephemient · Answer

or just cast away ```suspend fun lt A B C gt Triple lt Deferred lt A gt Deferred lt B gt Deferred lt C gt gt awaitAll Triple lt A B C gt = listOf first second third awaitAll let first second third gt Triple first as A second as B third as C ```

Joffrey · Answer

Mmh I don t think the `catch`+ `cancel` approach solves the problem because the time that you spend waiting before the failure is the problem not the time after

Joffrey · Answer

But you re right that if those deferred come from the same scope with a regular non supervisor job one failure should cancel the others anyway automatically

ephemient · Answer

yeah the catch+cancel doesn t propagate in the same order you d need to drop down to a lower level with `invokeOnCompletion` to preserve it

ephemient · Answer

but how much that matters depends on the use

gildor · Answer

gt Using multiple await forces you to wait for all preceding tasks to finish before failing on the await that fails No if you use own scope This why I prefer and use this version ```suspend fun lt A B C gt awaitTriple a suspend gt A b suspend gt B c suspend gt C Triple lt A B C gt return coroutineScope val aDeferred = async a val bDeferred = async b val cDeferred = async c Triple aDeferred await bDeferred await cDeferred await ```

gildor · Answer

This is what you usually want anyway no need to create own scope and less chance to do mistake