Calling a suspend function from a function block in a suspend function doesn’t work

private suspend fun outerSuspend() {
    timer(period = 10) {
        innerSuspend() // Error: Suspend functions can be only called within coroutine body
    }
}

It works if I create a new CoroutineScope inside the function block

private suspend fun outerSuspend() {
    timer(period = 10) {
        CoroutineScope(<http://Dispatchers.IO|Dispatchers.IO>).launch {
            innerSuspend()
        }
    }
}

Is there a way to use the outer scope in the inner block?

in order to do that you need to have

timer

be

inline

or

suspend

itself

And if that is not possible (timer being inline/suspend), you can do this:

private suspend fun outerSuspend() = coroutineScope {
    timer(period = 10) {
        launch { innerSuspend() }
    }
}

Because creating a new

CoroutineScope

, like in your original example’s solution, breaks cancellation/structured-concurrency.

hmm, but that does not actually gate the code in the

timer

Yup. But I didn’t think that gating it was needed

Just curious what timer does. It looks that it easier to reimplement it with coroutines than try to use non-suspend version of it, also it would make it properly cancellable

True. A

while (isActive) { 
    innerSuspend()
    delay(periodInMillis)
}

is a straightforward solution.

yeah, if it repeat just use delay before or after innerSuspend, and remove while if you don’t need repeat and you just want wait

@octylFractal You used the term "gate". What does it mean?

basically that it will "escape" outside a normal sequential execution flow, i.e. if the

timer

function was intended to cancel / interrupt / measure the inner block, it would not do so properly because

launch

immediately returns in this case

I think I get it. Thanks @octylFractal!