A generic way to wrap errors would be useful in the standard library

[glandium]

It would be useful in functions that can fail in different ways from the functions it calls itself, allowing something like:

fn func() -> Result<T, Error> {
  try!(may_return_error_type_A);
  try!(may_return_error_type_B);
}

[eddyb]

trait WrapError<T> {
    fn wrap_error(e: T) -> Self;
}
impl<T> WrapError<T> for T {
    fn wrap_error(e: T) -> T {e}
}
fn wrap_error<T, E: WrapError<T> = T>(e: T) -> E {
    WrapError::wrap_error(e)
}
macro_rules! try(
    ($e:expr) => (match $e { Ok(e) => e, Err(e) => return Err(wrap_error(e)) })
)

This would be backwards-compatible and allow the user to add custom wrappers - even have #[deriving(WrapError)] on enums.
Too bad it requires better coherence - see rust-lang/rfcs#48 - and something like #13702 for the default in wrap_error's definition (without which the change to try! is a backward-compat hazard).

[aturon]

cc rust-lang/rfcs#201

[ghost]

This is now implemented, closing.