Implement std::error::Error for ()?

[brson]

I ran into an API that returned Result<T, ()>, which seems reasonable, but couldn't convert the error to Box<Error> because

crater-web/main.rs:52:40: 52:52 error: the trait `std::error::Error` is not implemented for the type `()` [E0277]
crater-web/main.rs:52                 let e: Box<StdError> = Box::new(());

[dstu]

I also ran into this recently. Thinking about it a little, it seems you could go about this more than one way. Does () as your error type mean that an error can't happen (which makes sense to me) or that you don't care about the error type (not what I would like to see in code, but something I imagine many would be tempted to use)?

Deciding on the semantics of impl Error for () will inform the impl details. If () means "can't fail", then it's reasonable to invoke panic! or unreachable!. Any thoughts about where to take this?

[bluss]

If it's an error that can't happen, it should be a void type, not (). For example enum NoError { }.

[rphmeier]

Using a void type only makes sense in the context of associated error types. Otherwise, an infallible function should not be returning a Result.

I would say that an implementation of Error for () does not encourage explicitness in error handling.
At the same time, the lack of an implementation probably wouldn't stop people from using it anyway, and it only makes things harder for anyone trying to use their API.

[dtolnay]

The API guidelines now strongly discourage using () as an error type as part of a broader discussion on well-behaved error types.

Never use () as an error type, even where there is no useful additional information for the error to carry.

• () does not implement Error so it cannot be used with error handling libraries like error-chain.
• () does not implement Display so a user would need to write an error message of their own if they want to fail because of the error.
• () has an unhelpful Debug representation for users that decide to unwrap() the error.
• It would not be semantically meaningful for a downstream library to implement From<()> for their error type, so () as an error type cannot be used with the ? operator.

Instead, define a meaningful error type specific to your crate or to the individual function. Provide appropriate Error and Display impls. If there is no useful information for the error to carry, it can be implemented as a unit struct.