I want to downlaod list of assets in parallel, is this correct?

private suspend fun prefetchStories(stories: List<Story>) {
    coroutineScope {
        val fetches = mutableListOf<Deferred<Unit>>()
        for (story in stories) {
            fetches += async {
                prefetchStory(story)
            }
        }
        fetches.awaitAll()
    }
}

Unsure about the

coroutineScope

. Most example don't use it but I presume that means they're using GlobalScope, right?

coroutineScope

is the recommended way to go when you're inside a

suspend

function and want to parallelize some work, and wait for everything before returning. Since you don't need results, there is no point in using

async

, you can simply use

launch

instead. Also,

coroutineScope

will automatically wait for child coroutines to finish so you don't need to explicitly wait for them:

private suspend fun prefetchStories(stories: List<Story>) {
    coroutineScope {
        stories.forEach { story ->
            launch {
                prefetchStory(story)
            }
        }
    }
}

No need for `fetches`and

awaitAll

. Neither for async.

private suspend fun prefetchStories(stories: List<Story>) {
    coroutineScope {
        for (story in stories) {
            launch {
                prefetchStory(story)
            }
        }
    }
}

`coroutineScope`will wait for all children.

@uli pretty close 😄

🤣

I'm not sure this qualifies as being first, given how close in time we posted our answers - but I find it pretty funny how similar they are 😆

the scope reference was what I was after in a plain suspend fun, thanks!