But it creates a new scope isn't it?

# coroutines

[dstarcev]

But it creates a new scope isn't it?

[Jonathan]

suspend inline fun <T, R> Iterable<T>.mapAsync(
    crossinline transform: suspend (T) -> R
) = coroutineScope {
  map { async { transform(it) } }.map { it.await() }
}

[Jonathan]

Yes, and that what you want.

[Jonathan]

You want mapAsync to suspend until all jobs are completed

[Jonathan]

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

[gildor]

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

[Jonathan]

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

[Jonathan]

With GlobalScope jobs are not cancelled in case of failure

[Jonathan]

Global scope just leaks the coroutines

[dstarcev]

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]

awaitAll does the trick for you and nothingg will leak

[gildor]

so it’s exactly the use case of awaitAll and documentation explicitly mentions how awaitAll is different from .map { it.await() }

[Jonathan]

Yes true. However, I tend to find coroutineScope more explicit

[gildor]

what can be more explicit than awaitAll?

[gildor]

this is exactly what must be used

[gildor]

and coroutineScope even not used in this case

[gildor]

and provides useless scope

[gildor]

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]

suspend inline fun <T, R> Iterable<T>.mapAsync1(
    crossinline transform: suspend (T) -> R
) = coroutineScope { map { async { transform(it) } }.awaitAll() }

suspend inline fun <T, R> Iterable<T>.mapAsync2(
    crossinline transform: suspend (T) -> R
) = map { GlobalScope.async { transform(it) } }.awaitAll()

[Jonathan]

Both solutions are fine

[Jonathan]

I prefer the first one, but it is opinionated style.

[Jonathan]

In both cases no coroutine is leaked

[gildor]

There is semantical difference between 2 solutions

[dstarcev]

btw, what difference will it make if I specify the receiver?

suspend inline fun <T, R> Iterable<T>.mapAsync2(
    crossinline transform: suspend CoroutineScope.(T) -> R
) = map { GlobalScope.async { transform(it) } }.awaitAll()

[gildor]

coroutineScope solution uses outer context

[gildor]

but GlobalScope uses DefaultDispatcher

[Jonathan]

true

[gildor]

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

[dstarcev]

in what way?

[gildor]

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

[gildor]

so you shouldn’t use it for blocking code

[gildor]

for blocking code you should use IO explicitly

[gildor]

coroutineScope uses dispatcher of outer scope

[gildor]

so you can wrap it to withContext(<http://Dispatchers.IO|Dispatchers.IO>)

[gildor]

This will not work for GlobalScope

[dstarcev]

May I add this in the place where I create the initial scope?

runBlocking(<http://Dispatchers.IO|Dispatchers.IO>) {
...
}

[dstarcev]

the intention in my case is to parallelize blocking operations

[gildor]

runBlocking IO doesn’t make any sense in this case

[gildor]

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

[dstarcev]

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

[gildor]

Use GlobalScope

[gildor]

+ dispatcher on your choice