val result = withContext(<http://Dispatchers.IO|Dispatchers.IO>) { blockingCall() }

vs

val resultAsync = async(<http://Dispatchers.IO|Dispatchers.IO>) { blockingCall() }
doSomethingElse()
val result = resultAsync.await()

see: imagine, you have

fun myApiBlockingCall(): String {
  Thread.sleep(1000)
  return "Foo"
}

To convert it to non-blocking using withContext:

suspend fun myApiCall() = withContext(IO) {
   myApiBlockingCall()
}

And that’s all. You can call myApiCall in any suspend block with any dispatcher without blocking

I can’t do

myApiCall().await()

right - how do I wait for the result?

Let me try it

Whaaaaaa

This is some magic right here

Thank you guys

How do i ‘return’ foo from the suspend function

It complains i need another return statement outside the with context

fun main()

needs to return

Unit

, be it

suspend

or not

How do i assign value of myApiCall to a var

MyApiCall - i can add a return inside the with context - but intellij complains that i need one at the end too

But apparently the function itself needs a return outside too

I would also recommend to use runBlocking instead of suspend main. It may be handy sometimes, but runBlocking also provides CoroutineScope, so you can use launch or async directly and don't worry about running coroutines

I thought async await is discouraged

But to use suspend functions you need suspend lambda, so you need to somehow start coroutine, so use launch, async or runBlocking

I'm talking only about entry point usage, that to play with coroutines in

main

method is more handy to use

fun main() = runBlocking<Unit>{}

instead of

suspend fun main() {}

because runBlocking also provides coroutine scope

I see makes sense

Thank you!