Hello again, why does ```fun businessLogic(...) =...

# coroutines

[Hugo Costa]

Hello again, why does

fun businessLogic(...) = runBlocking(Dispatchers.Default) {
    val businessValue = async { someFunction() }
    ...
}

work but

suspended fun businessLogic(...): ReturnValue {
    val businessValue = async { someFunction() }
    ...
}

doesn't? Doesn't the context from wherever this function is called carry over to allow for the async job to be launched?

[Sam]

To launch coroutines inside a suspending function you can use a coroutineScope block:

suspend fun businessLogic(…): ReturnValue {
  coroutineScope {
    val businessValue = async { someFunction() }
    …
  }
}

The runBlocking function implicitly creates a coroutine scope for its body code block, for convenience, which is why you don't need to do the same thing there.

[Hugo Costa]

Thanks 🙂 feels like something that should happen by default. I guess the idea here would be that whatever code that runs within a suspending function should, ideally, yield when not in use?

[Sam]

I think it's good for it to be explicit. The coroutineScope function will wait for all its coroutines to finish, which is important. If you could just call launch/async without it, it would be unclear if the containing function was going to wait for the new task or not.

[Hugo Costa]

Clear. Feels like making all my functions be

suspend fun businessLogic(…) = coroutineScope {
    val businessValue = async { someFunction() }
    …
}

Make sense if that's the case 😅

[Hugo Costa]

I'll likely add it wherever I might need to do these async jobs. Thanks!