But it creates a new scope isn t it

Question

Jonathan · Answer

``` suspend inline fun lt T R gt Iterable lt T gt mapAsync crossinline transform suspend T gt R = coroutineScope map async transform it map it await ```

Jonathan · Answer

Yes and that what you want

Jonathan · Answer

You want `mapAsync` to suspend until all jobs are completed

Jonathan · Answer

But you also want `mapAsync` to throw as soon as one job fail

gildor · Answer

You can use coroutineScope but why not just use GlobalScope in this case

Jonathan · Answer

And you also want to make sure all job started are canceled in this case

Jonathan · Answer

With GlobalScope jobs are not cancelled in case of failure

Jonathan · Answer

Global scope just leaks the coroutines

dstarcev · Answer

I am quite new to coroutines is it correct for a function to have it s own scope ignoring whatever it is on the caller site

gildor · Answer

awaitAll does the trick for you and nothingg will leak

gildor · Answer

so it s exactly the use case of awaitAll and documentation explicitly mentions how awaitAll is different from map it await

Jonathan · Answer

Yes true However I tend to find `coroutineScope` more explicit

gildor · Answer

what can be more explicit than awaitAll

gildor · Answer

this is exactly what must be used

gildor · Answer

and coroutineScope even not used in this case

gildor · Answer

and provides useless scope

gildor · Answer

gt is it correct for a function to have it s own scope ignoring whatever it is on the caller site No `coroutineScope` uses `coroutineContext` of outer scope

dstarcev · Answer

``` suspend inline fun lt T R gt Iterable lt T gt mapAsync1 crossinline transform suspend T gt R = coroutineScope map async transform it awaitAll suspend inline fun lt T R gt Iterable lt T gt mapAsync2 crossinline transform suspend T gt R = map GlobalScope async transform it awaitAll ```

Jonathan · Answer

Both solutions are fine

Jonathan · Answer

I prefer the first one but it is opinionated style

Jonathan · Answer

In both cases no coroutine is leaked

gildor · Answer

There is semantical difference between 2 solutions

dstarcev · Answer

btw what difference will it make if I specify the receiver ``` suspend inline fun lt T R gt Iterable lt T gt mapAsync2 crossinline transform suspend CoroutineScope T gt R = map GlobalScope async transform it awaitAll ```

gildor · Answer

coroutineScope solution uses outer context

gildor · Answer

but GlobalScope uses DefaultDispatcher

Jonathan · Answer

true

gildor · Answer

also I would pass dispatcher for this function so you could use this function for blocking IO

dstarcev · Answer

in what way

gildor · Answer

because solution with GlobalScope in your current version uses Default dispatcher by default

gildor · Answer

so you shouldn t use it for blocking code

gildor · Answer

for blocking code you should use IO explicitly

gildor · Answer

coroutineScope uses dispatcher of outer scope

gildor · Answer

so you can wrap it to `withContext <http Dispatchers IO|Dispatchers IO> `

gildor · Answer

This will not work for GlobalScope

dstarcev · Answer

May I add this in the place where I create the initial scope ``` runBlocking <http Dispatchers IO|Dispatchers IO> ```

dstarcev · Answer

the intention in my case is to parallelize blocking operations

gildor · Answer

runBlocking IO doesn t make any sense in this case

gildor · Answer

if you usr runBlocking with coroutineScope you will have 1 main thread execute all your tasks

dstarcev · Answer

In case I write a blocking server and sometimes want to parallelize tasks what do I do

gildor · Answer

Use GlobalScope

gildor · Answer

+ dispatcher on your choice