Beginner here… Is it a typical pattern to pass around the coroutine scope as a parameter to my suspen functions?

nope

that's a very big anti-pattern usually

a suspend function`s scope is the scope that called the suspend function

and if you need a new scope object specifically, use

coroutineScope { ... }

use

coroutineScope {  }

to access a nested scope under the coroutine scope that called the suspending function https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/coroutine-scope.html

then which

async

do I call? I suppose not the GlobalScope’s

you create an instance of

CoroutineScope

and store it somewhere. For example on Android I would create an instance of

CoroutineScope(Dispatchers.Default)

and store it in the

Application

subclass

oh, I see. I use Ktor, so I do have an application object that also serves as the coroutine scope

and inject it into classes that are scoped to the

Application

as well

that seems like a little too much boilerplate just to be able to run code asynchronously - is there a simpler way? how bad is it to do

GlobalScope.async

?

if code quality/correctness does not matter to you, then you can use

GlobalScope

it is honestly not that much boiler plate -- all you really need to do is say

coroutineScope { ... }

however if this is within the scope of an API call, an error thrown by

GlobalScope.async { }

will not be thrown from where you call it, unless you use

.await()

on the deferred that’s returned

an important thing to note is that I would expect that with ktor, there is almost no need to use

async

if you make an I/O call (or other blocking work), use

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

, if you suspend ktor will probably switch to handling other requests automatically, as that's what coroutines are meant to do

so does this makes sense?

private suspend fun searchAllEngines(input: String) = coroutineScope {
        searchEngines.map {
            async<Collection<Result>> {
                try {
                    it.search(input)
                } catch (exc: Exception) {
                    logger.error("${it::class.simpleName} failed: ${exc.message}")
                    emptyList()
                }
            }
        }
    }

sure, as long as

it.search

is also

suspend

and appropriately switches to the IO dispatcher

cool 👍 thanks!