Hacker News Reader

Comment by Expurple | Hacker News Reader

> isn't 'the error' just a case of valid data that shouldn't be thrown as exception at all?

That's the thing! Errors are just a case of return data! To me, it just makes more sense to model them like that rather than like checked exceptions. Checked exceptions are simply unnecessary if the language has sum types, Result and some syntax like Rust's `?` for propagating errors easily like exceptions. Checked exceptions are a weird, special and sometimes poorly supported [1] way to "augment the return type". It's easier to just have a single, all-encompassing, composable return type.

[1] https://home.expurple.me/posts/rust-solves-the-issues-with-e...

View on HN

>Errors are just a case of return data!

Are they? Why mix valid data with errors?

They aren't necessarily mixed together in an unmaintainable way. In a Rust-like functional paradigm, fallible functions typically return Result<T, E> and you can extract the T out of it and proceed to work on just the valid T when you've already handled the errors. Just like you would do in a language with exceptions.

And the function has to do pattern matching and handle both cases. What for?

It's equivalent to having to "catch or specify" [1]. IMO, it's a lesser evil than unchecked exceptions [2]. Explicit and mandatory handling is desirable for most errors. The caller has the responsibility to decide whether it needs to handle the error. If it simply wants to propagate it, there's the `?` operator. If it doesn't care about defining a wrapper type and/or preserving the error details, there's `Box<dyn Error>` (equivalent to `throws Exception`). Explicit and reliable error handling usually doesn't come at the cost of writing full `match` statements everywhere.

[1] https://docs.oracle.com/javase/tutorial/essential/exceptions...

[2] https://home.expurple.me/posts/rust-solves-the-issues-with-e...

I don't see why it is a 'lesser evil'.

"Explicit and mandatory handling is desirable for most errors." -- that depends on the domain. Quite often all the caller needs is to cancel whatever it is doing and propagate the error. In this case why do we need a detour into the f() function in your example?

From the part of your essay that you linked to:

"Potentially leaving your data in an inconsistent, half-way modified state." -- this is just not the case with RAII.

"No one wraps every line in a try-catch." -- no one needs to.

> Quite often all the caller needs is to cancel whatever it is doing and propagate the error.

Yes, this is the most common case. That's why Rust has `?` to support it as well as exceptions do. My take is that:

- The caller should make this decision explicitly. This avoids propagating (or catching) the error accidentally and makes the code easier to understand and review (see the example with `f(g(x))` vs `f(g(x)?)?`).

- Exceptions make the other error handling patterns too unergonomic, and they're not uncommon enough to justify this cost. My post does a bad job at providing more examples to demonstate that they aren't uncommon. But e.g. `.map_err(Wrapper)?` is way more convenient than catching and throwing a wrapper, which isn't so uncommon in Java.

> "Potentially leaving your data in an inconsistent, half-way modified state." -- this is just not the case with RAII.

RAII solves this only when you have locally-owned data or some locally-owned "scope guard" [1] that acts as a "defer", like std::sync::MutexGuard.

This doesn't help when you hold a non-owned &mut to some private data structure, you're in the middle of modifying it and currently it doesn't hold its own invariants because you haven't finished restoring those yet. Now I understand that the post lacks a concrete example to demonstate this. I'm sorry. If you're interested in this topic, you can learn more by googling about exception safery (aka panic safety) in Rust and C++. Both are languages with RAII that doesn't solve the issue completely.

[1] https://docs.rs/scopeguard/latest/scopeguard/

>The caller should make this decision explicitly.

Isn't it too low-level? Why not define instead cleanup/recovery through RAII and occasional try/catch for maintaining tricky invariants, and have no need to manually propagate errors?

>`.map_err(Wrapper)?` is way more convenient than catching and throwing a wrapper

If you only wrap exceptions on the API boundary it might be more ergonomic than having to manually propagate errors inside the API implementation and map them anyway.

>you're in the middle of modifying it and currently it doesn't hold its own invariants because you haven't finished restoring those yet

Sometimes it's better to call throwing functions and get needed data before modifying the private data, sometimes it's time to use try/catch. Is it happening often?

>Exceptions make the other error handling patterns too unergonomic

But so does packing valid data and errors together. Imagine you need to call f(h1()) and f(h2()) where h1() and h2() return the same data type for valid data but different types of errors. What do you do?

>the post lacks a concrete example

Yes, having a specific example seems to me to be the best way to discuss design tradeoffs, but you did the second best thing -- you started with declaring your assumptions (exceptions are disguised return values and optimizing ergonomics of passing errors through f(g(x)) is important) with both of which I happen to disagree)

> Sometimes it's better to call throwing functions and get needed data before modifying the private data

Haha! Here we go back to the topic of unchecked exceptions and "the lesser evil". With unchecked exceptions, every function is throwing! Even if it shouldn't throw today according to the docs:

1. The docs could be simply wrong.

2. It isn't a semver breaking change to start throwing in a future version. The compiler won't warn you when this happens. You won't manually audit all your dependencies when updating them [1].

We come back to the need to properly reflect errors in the type system. Without returning them by value, the only popular alternative is checked exceptions. But, as I mentioned in the updated version of the post [2], checked exceptions in Java are unfriendly to generic code. This is important and will come up right now:

> Imagine you need to call f(h1()) and f(h2()) where h1() and h2() return the same data type for valid data but different types of errors. What do you do?

This depends on the context. A general answer: `f` can be generic over the error type.

    fn f<E>(result: Result<_, E>)

If it needs to do something more specific with E, like logging it, it can also have a more specific bound on E:

    use std::fmt::Display;
    fn f<E: Display>(result: Result<_, E>)

If it has to be a concrete function, it can use runtime polymorphism instead:

    use std::fmt::Display;
    fn f(result: Result<_, Box<dyn Display>>)
    
    // in this case, the caller has to explicitly box the error
    f(h1().map_err(Box::new))

---

[1] Unless you operate on a really serious level where you should strive to use a more reliable language anyway.

[2] https://home.expurple.me/posts/rust-solves-the-issues-with-e...

>every function is throwing

It was a poor choice of words. You can replace 'throwing functions' with 'throwing code'. There is plenty of code that is guaranteed not to throw -- starting from operations on basic types and ending with noexcept functions if we are talking about C++.

>The compiler won't warn you when this happens.

It will if you write an asserting in the code that relies on a function not throwing:

  static_assert(noexcept(f()));

>`f` can be generic over the error type

Isn't it too much clutter? What if a function has three arguments? You'd need three generic parameters for their errors.

> Isn't it too much clutter?

I have never seen, other than like, methods on Result itself, Rust code that accepts a Result type as an argument. You are absolutely right that would lead to a crazy amount of clutter.

> Imagine you need to call f(h1()) and f(h2()) where h1() and h2() return the same data type for valid data but different types of errors. What do you do?

It sort of depends on the specific different error types. Most of the code I've been writing is application level code, so I'd just be returning the errors upstream. The anyhow library makes it easy to return a "trait object" which is sort of like a virtual base class in C++, at least for these purposes. With that I could just do

    f(h1()?);
    f(h2()?);

The ? operator lets you return the error half of the Result to the parent. If I had to do the conversions myself, if I implemented some traits, I could do this too. That said, I would probably use a temporary for clarify:

    let x = h1()?;
    f(x);

    let x = h2()?;
    f(x);

For some cases, I may not want to implement the traits, but maybe there's some sort of common error that I'd want to return to the caller. In that case, I may

    let x = h1().map_err(|e| /* do whatever conversion here */ )?;
    f(x);

    let x = h2().map_err(|e| /* do whatever conversion here */ )?;
    f(x);

These three represent the vast majority of this kind of code I write and see in the wild.

Thanks for chiming in.

When I looked at anyhow, I remember thinking that it's just a way to emulate in Rust the kind of error propagation that C++ has with exceptions, but manually with ?.

What's your take on this?

I think that it's reasonable to look at two features designed to solve similar problems, and think they look similar. And yeah, anyhow feels closer to an exception. There's some differences though; you don't have to use anyhow, so in some senses, Rust's system here has more flexibility overall. Another is that anyhow gives you a more "semantic" backtrace by default. Here's what I mean: Consider this program:

    use anyhow::Result;
    use anyhow::bail;
    
    fn main() -> Result<()> {
        foo()?;
        
        Ok(())
    }
    
    fn foo() -> Result<()> {
        bar()?;
        
        Ok(())
    }
    
    fn bar() -> Result<()> {
        bail!("oh no");
    }

When you run this, you'll see

  Error: oh no

We don't get a stacktrace, we get our error.

Whenever you want to insert something into this backtrace, you can:

    use anyhow::bail;
    use anyhow::Context;
    use anyhow::Result;
    
    fn main() -> Result<()> {
        foo()?;
        
        Ok(())
    }
    
    fn foo() -> Result<()> {
        bar().context("couldn't bar")?;
        
        Ok(())
    }
    
    fn bar() -> Result<()> {
        bail!("oh no");
    }

Running this, you instead get

  Error: couldn't bar
  
  Caused by:
      oh no

And if we add some context to foo:

  Error: was trying to foo
  
  Caused by:
      0: couldn't bar
      1: oh no

I find this to be a lot nicer than a stacktrace. And if you want to get a stacktrace, you can do so by setting the standard environment variable.

Yep, semantic backtrace is very handy when you need the user to understand the error and fix input data.

> There is plenty of code that is guaranteed not to throw -- starting from operations on basic types

This is fair, although this places some mental load on the programmer because they need to be careful when dealing with generics / operator overloading or when extracting helper functions.

> noexcept functions if we are talking about C++

This is a good C++-specific guarantee. But it's probably outweighted by the C++-specific lack of guarantees. "Operations on basic types" can now invoke UB, if we are talking about C++.

> Isn't it too much clutter?

In cases with one generic parameter, like the ones I demonstrated, I think it looks ok. Normal generic code. Rust generics are only going to require less ceremony in the future, because the team keeps making progress on implied bounds, lifetime elision, 2024 lifetime capture rules.

> What if a function has three arguments? You'd need three generic parameters for their errors.

This really depends on the context and what the code actually does, and needs a concrete example to discuss. I don't remember seeing a real world example with three Result parameters, nevermind having generic but distinct errors in them.

>careful when dealing with generics / operator overloading

In C++, you can't overload operators for built-in types and template parameters are normally constrained:

  auto f(std::integral auto x) noexcept
  {
      return x+x;
  }

But yes, writing C++ templates that work with wide range of types takes some thinking and operator overloading adds to the mental load (or reduces it, when used sparingly and properly).

>"Operations on basic types" can now invoke UB

They always could. I don't want this conversation to become about Rust vs. C++, I'd gladly use Rust when where is appropriate task.

>needs a concrete example to discuss

Write a new post when you come up with a bunch of good examples)

Sure. Thanks for the conversation. If you're interested in the follow up, I have an RSS feed: https://home.expurple.me/posts/index.xml

Thanks! What do people use nowadays to follow rss? A telegram bot perhaps?

Honestly, no idea. I got into RSS about a year ago. I just use Thunderbird, which I already use for my mail

I'll see how this one works: https://t.me/FeedRiverBot

Reply on news.ycombinator.com