I have a suspend function which calls other 3 suspending functions. How can I have

doSomething

call the 3 suspending functions serially? (i.e. waiting for each one to complete before calling the other?)

suspend fun doSomething() {
    suspendingFun1()
    suspendingFun2()
    suspendingFun3()
  }

🧵

@julioromano: Your first example should work. 🤔

I agree with @Richard Gomez. Your original example already calls all three of them sequentially. That is the beauty of suspend functions. They are asynchronous, but you can call them like they are regular functions, imperatively/sequentially.

True, I’ll have to double check what those functions do internally as I had the impression that running them like so yielded parallel network calls. Thanks for your input!

It is easier to visualize that they are called sequentially when using an example where they return a value and take input

suspend fun doSomething(): Int {
    val res1 = suspendingFun1()
    val res2 = suspendingFun2(res1)
    return suspendingFun3(res2)
  }

If you need to lunch them sequentially then wait for all three of them to finish you’ve to modify your code as follows

suspend fun doSomethingInSerially() = coroutineScope {
        val job1 = launch { suspendingFun1() }
        val job2 = launch { suspendingFun2() }
        val job3 = launch { suspendingFun3() }
        joinAll(job1, job2, job3)
    }

@Kareem Waleed Wouldn't the use of

coroutineScope

implicitly wait for all of them to finish?

suspend fun doSomethingInSerially() = coroutineScope {
        launch { suspendingFun1() }
        launch { suspendingFun2() }
        launch { suspendingFun3() }
}

https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/coroutine-scope.html "This function returns as soon as the given block and all its children coroutines are completed"

@Richard Gomez Yes, actually the use of

join()

in my example is redundant. sorry 😄

the IDE is right. That is sequential:

suspend fun doSomethingInSerially() {
    coroutineScope {
      async { suspendingFun1() }.await()
      async { suspendingFun2() }.await()
      async { suspendingFun3() }.await()
    }
  }