Are there any coroutines-friendly error handling functions? For example, some

runCatching

that doesn't catch

CancellationException

? Would be nice to have some standardized solution (and IDE warnings on catching the

CancellationException

in coroutines)

It's because kotlin.Result might change in the future, so the ABI of the inline class is not exposed to allow changes without breaking people with binary compatibility for JVM users that use libraries compiled before the changes.

I assumed so

Why do you want to use

kotlin.Result

specifically?

I wanted to write version of

runCatching

that won't catch

CancellationException

. Ideally, it would be a simple update to codebase, ideally returning same type

You can add compiler flag to allow use Result as return type

That's probably very unsafe for libraries 😄

Yeah, for libraries it's not good, it would require consumer to use this flag too

And would more importantly break after they decide to change the ABI of

kotlin.Result

, even with the flag activated (unless they add a mechanism to prevent compilation of such things, which is still breaking things and delaying update until library updates)

Am I on the right track here, does this makes sense?

public inline fun <R> coRunCatching(block: () -> R): Result<R> {
    return try {
        Result.success(block())
    } catch (e: CancellationException){
        throw e
    } catch (e: Throwable) {
        Result.failure(e)
    }
}

LGTM. You're using your own

Result

, right?

Haven't coded it yet, but yes.

You mean you haven't copy pasted it yet? 😉 (that said, might be a little easier to roll your own simplified version actually)

What is your use case for own result?

Use case is that I'd use it instead of

kotlin.Result

, so that updating current code to

coRunCatching

is just changing name of fun called.

You can also name it

cancellableRunCatching

, which IMHO is more accurate and makes it more obvious why it's used in place of stdlib's

runCatching

without having to look at the source of the function (which is impractical if not viewed from an IDE with checked out revision, like on VCS UIs or in-IDE diffs).