A modern programming language that makes developers happier.

kotlinlang

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()
  }```
:thread:

Right now I came up with:
```  suspend fun doSomethingInSerially() {
    coroutineScope {
      async { suspendingFun1() }.await()
      async { suspendingFun2() }.await()
      async { suspendingFun3() }.await()
    }
  }```
But I don’t know if it’s correct. And the IDE suggest me all those `async {}.await()` calls are redundant and to replace them with `withContext(Dispatchers.Default) {}` instead :shrug:

<@U5N9H0BN1>: Your first example should work. :thinking_face:

```suspend fun doSomething() {
    val thing1 = suspendingFun1()
    val thing2 = suspendingFun2(thing1)
    suspendingFun3(thing2)
  }```

I agree with <@U029ZKPDPSQ>. 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)
    }```

this would do what you need if you don’t expect a result from your async functions

<@UURR16LSK> 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"

<@U029ZKPDPSQ> Yes, actually the use of `join()` in my example is redundant. sorry :smile:

the IDE is right. That is sequential:
```suspend fun doSomethingInSerially() {
    coroutineScope {
      async { suspendingFun1() }.await()
      async { suspendingFun2() }.await()
      async { suspendingFun3() }.await()
    }
  }```
