What happens if a non-suspend function is called from a coroutine?

Question

One of the key concepts of coroutines in Kotlin is that a suspend function must be called from a coroutine or another suspend function.

However, a suspend function can call any kind of function, suspend or normal.
What is the consequence of that? (This is not a real scenario i have, just want to know for theoretical reasons)

I imagine that in that scenario the only point of creating a coroutine would be to change the context (thread) before calling it, so it doesn´t block the main thread. However, would all the other advantages of coroutines be lost? (cooperative cancellation, structured concurrency...)

Answer 1

If a suspending function calls another suspending function, then the coroutine is suspended, until the result is returned.

Calling a regular function from a suspending function will block the thread. Which thread? Well, that depends on the Dispatcher you're using. IO is able to spawn hundred of threads. But the Default dispatcher has same amount of threads as your CPUs count. Meaning that while this won't block other coroutines, it will reduce the amount of available resources.

Meaning: don't invoke non-suspending function that may block for a long period of time on this dispatcher, same as you don't block your UI thread.

And yes, suspending function may produce the same results, if you're do something like a busy loop without yield() or any other suspend invocation in it.