Hello, I'm wondering if it's OK to do this kind of code. If I understood correctly, Coroutines use exceptions internaly to "communicate" between child and parent about their state (and propagate cancellation via

CancellationException

). Wouldn't using a big

catch (exception: Exception)

around a suspending function

api.getFooResponse()

defeat this purpose and prevent any coroutine calling

getFoo()

to be cancelled correctly ? Wouldn't the

CancellationException

be "swallowed" ? Should we re-throw it ?

suspend fun getFoo(): Foo? = try {
        val fooResponse = api.getFooResponse()
        Foo(bar = fooResponse.bar)
    } catch (exception: Exception) {
        exception.printStackTrace()
        null
    }

Really the important thing is that when you receive a

CancellationException

you should stop what you’re doing. You don’t necessarily need to rethrow the exception. The coroutine will still remember that it has been cancelled, and will prevent you from suspending again. But rethrowing it is a good way to make sure that everything exits quickly and doesn’t start trying to do more work.

if you don't rethrow, the next coroutine operation will throw a new exception, so there's not a lot you can do in that state

I guess the worst thing would be if

getFoo

turns out to be in a loop, e.g.

while (foo == null) foo = getFoo()

😬 in that case definitely rethrow the exception 😄

I can't find any extension or utility method for coroutines (there is

Flow.catch {}

tho), so I guess I would have to write my own ? 1

fun Throwable.rethrowCancellationOrNull(): Nothing? = if (this is CancellationException) {
    throw this
} else {
    null
}

Example :

suspend fun getFoo(): Foo? = try {
        val fooResponse = api.getFooResponse()
        Foo(bar = fooResponse.bar)
    } catch (exception: Exception) {
        exception.printStackTrace()
        exception.rethrowCancellationOrNull()
    }

2

suspend fun <T, R> T.runCatchingSuspendOrNull(block: suspend T.() -> R): R? {
    return try {
        block()
    } catch (e: Throwable) {
        e.printStackTrace()
        if (e is CancellationException) {
            throw e
        }
        null
    }
}

Example :

suspend fun getFoo(): Foo? = runCatchingSuspendOrNull {
    val fooResponse = api.getFooResponse()
    Foo(bar = fooResponse.bar)
}

What do you think ?

In an ideal world, you wouldn’t need to catch something as broad as

Exception

or

Throwable

at all. But if you really have to do that, both of those options seem like good chocies

Thanks, I'll check that ! Yes the better approach would be to catch only the type of Exception that

getFooResponse()

could throw... but I have no idea what exception could be thrown, and maybe tomorrow a library update would silently add a new thrown exception type, and neither I nor the compiler would know about it. I really hate Exceptions in Kotlin, I really wish everything would be sealed classes instead. ^^

#arrow Either type is quite useful for domain error representation.