Python

Yeah, at $DAYJOB, we switched (regrettably) from Scala to Kotlin and wanted to continue using the errors-as-value style, which I was the biggest proponent of. However, there not being a way to make the Kotlin compiler shout at you, if you implicitly ignore a return value, really made me question that choice.

It means that if you refactor a function to now be able to fail, then you have to go to all usages and make sure you continue the bubbling.

With exceptions, you should also do that, to potentially introduce try-catches, but if you don't, then it will at least crash very visibly.

If the compiler does shout at you, like in Scala and Rust, then I think, that's a better pattern.

Do they then they extensively use algebraic data types like rusts Option?

no, there's no better error handling than writing if err != nil { return err } after every line of code, this is clearly the superior way

/s

I disagree. I've had to debug messes where errors are only really caught at the top level, and often there's something that programmer could've done to properly handle it but didn't because it wasn't clear that the function they called could produce an error.

And that's where Go and Rust do a fantastic job imo. Since you're forced to acknowledge errors, you give the programmer the opportunity to handle them and take corrective action. I like the Rust syntax a bit more because it's easy to return errors without messing with logic flow, so you can handle all errors at the calling function easily if that's better for logic flow.

The best solution for Python, imo, is a mix. Here are some things I'd love to see that are related here:

• optional chaining - x = y?.z ?? DEFAULT instead of x = y.z if y else DEFAULT (esp for nontrivial nesting)
• monads - return can be an error or value, and you need to determine which before unpacking it; could work with optional chaining as well (would return from the function with the error, otherwise continue with the data), or require destructuring (e.g. with match blocks); similar to try/except, but there's no assumption of success

Some libraries used to do it this way, such as Marshmallow (used a monad pattern).

Sometimes its cleaner and more robust this way, and sometimes it's better to throw errors. There should be simple syntax to pick between them (e.g. like Rust's .unwrap()).

@SittingWave @mac

That article isn't really advocating handling _all_ errors as values AFAICS - it just doesn't distinguish between _exceptional_ and _normal but unsuccessful_ paths.

For a wrapper around an HTTP transport, returning HTTP responses instead of raising an exception for stuff like "403 Forbidden" is probably reasonable. Their own example code is full of exceptions, though.

raise and raise ... from ?

I disagree, I hate that keyword. Exceptions should be... exceptional, and regular errors should be data. I only want to see exception blocks at top levels for logging and whatnot, everything else should be destructured monads in a match block or similar.

Forgetting a function can throw exceptions is an honest mistake, ignoring errors when you've destructured a return value to get the data is a choice. The former is hard to catch, the latter is plainly obvious in a code review.