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

# coroutines

[hooliooo]

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()
    ....
}

[streetsofboston]

Why not just this?:

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

[streetsofboston]

You want to call all someSuspendHttpRequestWithKtor in parallel, one async for each item in models?

[streetsofboston]

If so, try:

// someSuspendHttpRequestWithKtor executed in parallel
suspend fun someCRUDMethod(models: List<MyModel>) {
    val myDeferredModels = coroutineScope {
        models.map { async { myAPI.someSuspendHttpRequestWithKtor(it.id) } }
    }
    val myListOfModels = myDeferredModels.awaitAll()
    ....
}

[hooliooo]

No I want to wait for all of them to complete

[streetsofboston]

In sequence, not parallel?

[hooliooo]

Parallel, so the second one is the optimal solution?

[streetsofboston]

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.

[hooliooo]

Alright thanks

[streetsofboston]

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.

[hooliooo]

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

[hooliooo]

So essentially awaitAll() just unboxes them from their Deferred wrapper?

[streetsofboston]

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

[streetsofboston]

But in other cases, if the async children have not yet finished, the awaitAll() will await until all of them have finished.

[hooliooo]

I see. Thanks for the explanation 🙂