Rust already has most of what I want from error handling: explicit control flow, errors as values, and concise propagation with ?. The friction comes when deciding what to put in the error half of Result. We often end up choosing between precise types that require boilerplate and convenient types that hide which errors can occur. But precision and convenience do not have to be competing goals. Error types should compose as easily as the functions that return them.
I’m not sure non-exhsustive makes sense — you want the caller to handle everything you may return to them, and the new errors won’t be handled. Maybe a default branch in the handler could do, though
Had to just think about why
#[non_exhaustive]exists, so perhaps this helps you as well:Imagine you’re developing a really important core library, something like TCP. And then other libraries depend on your library.
Now, if you change your implementation, you may need to introduce a new error case, even though the rest of the API still works the same.
You have two choices to deal with that:
#[non_exhaustive]before going 1.0 and therefore forced all depending libraries to implement a default match case. You can sneak in the new error case in version 1.1 without all those depending libraries needing to manually upgrade. The ecosystem does not split in half between 1.0 vs. 2.0.Obviously, if it’s a really egregious new error case that needs specific handling, then you might still want to release version 2.0, but by adding the
#[non_exhaustive], you can decide later on and if you are such a central library, there’s definitely going to be situations where you want to make use of it.I have been thinking of semver incorrectly, you’re right: https://doc.rust-lang.org/cargo/reference/semver.html#enum-variant-new
This is exactly what it’s for.
#[non_exhaustive]forces you to add a default branch when matching on the error. It’s already used a lot, so without a way to do that, it becomes less useful in library code.