Kotlin Arrow EffectScope.shift() implementation throws exception?

Question

When looking at arrows documentation about functional error handling one of the reason listed to avoid throwing exceptions is performance cost (referencing The hidden performance costs of instantiating Throwables )

So it is suggested to model errors/failures as an Effect .
When building an Effect to interrupt a computation the shift() method should be used (and under the hood it is also what is used to "unwrap" the effects through the bind() method).

Looking at the shift() method implementation seems that its magic is done...throwing an exception, meaning that not only exceptions are created when we want to signal an error, but also to "unwrap" any missing Option , Left instance of an Either and all the other effect types exposed by the library.

What I'm not getting is if there's some optimization done to avoid the issues with "the hidden performance costs of instantiating Throwables", or in the end they are not a real problem?

Answer 1

What I'm not getting is if there's some optimisation done to avoid the issues with "the hidden performance costs of instantiating Throwables", or in the end they are not a real problem?

The argumentation that this is the biggest reason for using typed errors on the JVM is probably an overstatement, there are better reason for using typed errors. Exceptions are not typed, so they are not tracked by the compiler. This is what we want to avoid if you care about type-safety, or purity. This will be better reflected in the documentation or 2.xx

Avoiding the performance penalty can be a benefit in hot-loops, but in general application programming it can probably be neglected.

However to answer your question on how this is dealt with in Kotlin, and Arrow:

In Kotlin cancellation of Coroutines works through CancellationException , so it's required to use this mechanism to correctly work in the Kotlin language. You can find more details in the Arrow 2.xx Raise design document .

It's possible to remove the performance penalty of exceptions. Which is also what Arrow is doing. (Except a small regression in a single version, this was be fixed in the next release).

An example of this can also be found in the official KotlinX Coroutines which applies the same technique for disabled stack traces for JobCancellationException .