Hi there is this the correct implementation of coroutineScope? Will this call the

someSuspendHttpRequestWithKtor

in parallel from the

map

call?

suspend fun someCRUDMethod(models: List<MyModel>) {
    val myModels = coroutineScope {
        async {
            models.map { myAPI.someSuspendHttpRequestWithKtor(it.id) }
        }
    }
    val myListOfModels = myModels.await()
    ....
}

Why not just this?:

suspend fun someCRUDMethod(models: List<MyModel>) {
    val myListOfModels = models.map { myAPI.someSuspendHttpRequestWithKtor(it.id) }
    ....
}

No I want to wait for all of them to complete

In sequence, not parallel?

Parallel, so the second one is the optimal solution?

Yup, your solution executes them in sequence, once for each item. My second example launches all of them in parallel and then awaits them all.

Alright thanks

Note, though, that

awaitAll()

, in this example, does not really wait at all… it already has all the results, because

coroutineScope [ ... ]

only resumes/returns when all its children (calls to

async

) have finished. Still, the effect is the same in your example.

I just want the requests to be run in parallel instead of sequentially and then wait for all of them to finish before doing other things

And awaits each of them in parallel. But since all children already have finished ( because

coroutineScope

has resumed and that can only happen if all its (async) children have finished), it doesn’t really wait in this case

I see. Thanks for the explanation 🙂