Error handling with effect scope and exceptions.

[KristianNedrevold]

Hey. I'm not sure if this should be posted under discussions or issues, but as context receivers are still experimental I figured this might be the right place.

A lot of my functions that interact with APIs I don't own look like

fun doSomething(): Either<MyError, T> = Either.catch { ... }.mapLeft { MyError }

When using EffectScope we can handle exceptions in the function call and map it to some domain error

context(EffectScope<MyError>) suspend fun doSomething(): T = try { ... } catch { shift(MyError) }

If we want to handle it at the call site we can do something like this

context(EffectScope<MyError>) suspend fun doSomething(): T = ...
effect { doSomething() }.fold(
    error = { ... } ...

Handling the exceptions at the call site is what I think is the most idiomatic solution, but it also requires exceptions to be exceptional. This is often not the case when dealing with external APIs. It would be nice if we could have a idiomatic way to catch and map exceptions to some sort of domain error type.

Maybe something like:

suspend inline fun <T, R>EffectScope<T>.guard(f: () -> R, e: (Throwable) ->  T): R = try {
    f()
} catch (t: Throwable) {
    shift(e(t.nonFatalOrThrow()))
}

[nomisRev]

Hey @KristianNedrevold,

Thanks for opening this ticket! Such an API is indeed still missing. Since currently the pattern is Either.catch { ... }.mapLeft { MyError }.

In the 2.x.x API we have following signature, which we can back port to EffectScope.

suspend fun <E, A> Raise<E>.catch(
  block: suspend Raise<E>.() -> A,
  catch: suspend Raise<E>.(Throwable) -> A
): A

It's a bit more higher-level since it abstracts handleErrorWith instead of mapLeft: Either.catch { ... }.handleErrorWith { MyError.left() } rather.

[kyay10]

I ran into this again recently.
What I'd like to have is a withException or withCatch similar to withError.

inline fun <reified T: Throwable, Error, R> Raise<Error>.withCatch(transform: (T) -> Error, block: () -> R) = catch(block) { t: T -> raise(transform(t)) }

This can help simplify the pattern at hand here