when to use "suspend function" vs "function return...

# coroutines

[Sourabh Rawat]

when to use "suspend function" vs "function returning Deferred"?

[Dominaezzz]

Never return Deferred. (There are use cases for returning Deferred, but if you have to ask, you don't have that use case)

[Casey Brooks]

Deferred comes from the async { } builder, which is designed for spawning multiple parallel tasks and giving you a way to wait for them to finish and aggregate the results, A single function that would return a Deferred is essentially saying “run this function asynchronously and return a result`, which is exactly the same sentiment as a normal suspend function, but with an extra step.

So don’t return Deferred, and generally, don’t use coroutine builders inside a function. Just mark the function suspend and wrap it in the appropriate coroutine builder at the call-site.

[Sourabh Rawat]

generally, don’t use coroutine builders inside a function

what is the reason behind this?

[Casey Brooks]

Because it prevents you from combining those functions, and will probably lead you to doing Very Bad Things™️ with those functions.

This is what a code snippet might look like trying to combine functions that use builders internally:

fun CoroutineScope.asyncMethod1(): Deferred<Int> = async {
    delay(1.seconds)
    1
}
fun CoroutineScope.asyncMethod2(someValue: Int) = launch {
    delay(1.seconds)
}
fun main() = runBlocking {
    val value1 = asyncMethod1().await()
    asyncMethod2(value1).join()

    println("finished")
}

and here’s what it should look like:

suspend fun asyncMethod1(): Int {
    delay(1.seconds)
    return 1
}
suspend fun asyncMethod2(someValue: Int) {
    delay(1.seconds)
}
fun main() = runBlocking {
    val value1 = asyncMethod1()
    asyncMethod2(value1)

    println("finished")
}

[Casey Brooks]

But like Dominic said above, there are use-cases for using coroutine builders inside the body of a function or returning a Deferred, but if you have to ask, then you don’t have that use-case

[gildor]

It’s completely fine to use coroutine builders inside of a suspend function, if this function has own coroutine scope like”

suspend fun doSomething() = coroutineScope {
   // here you can call any coroutine builders to run multiple coroutines in parallel, scope will return only when all those coroutines are finished
}

But using top level coroutine builder (and pass scope as argument of a function), is usually a bad solution