Incorporate FromError into try!

Author: aturon

src/libstd/error.rs

@@ -46,6 +46,32 @@
 //! The main use of this trait is in the `try!` macro, which uses it to
 //! automatically convert a given error to the error specified in a function's
 //! return type.
+//!
+//! For example,
+//!
+//! ```
+//! use std::io::IoError;
+//! use std::os::MapError;
+//!
+//! impl FromError<IoError> for Box<Error> {
+//!     fn from_error(err: IoError) -> Box<Error> {
+//!         box err
+//!     }
+//! }
+//!
+//! impl FromError<MapError> for Box<Error> {
+//!     fn from_error(err: MapError) -> Box<Error> {
+//!         box err
+//!     }
+//! }
+//!
+//! #[allow(unused_variables)]
+//! fn open_and_map() -> Box<Error> {
+//!     let f = try!(io::File::open("foo.txt"));
+//!     let m = try!(os::MemoryMap::new(0, &[]));
+//!     // do something interesting here...
+//! }
+//! ```
 
 use any::{Any, AnyRefExt, AnyMutRefExt};
 use mem::{transmute, transmute_copy};
@@ -80,13 +106,6 @@ impl<E> FromError<E> for E {
     }
 }
 
-// FIXME (#https://github.com/rust-lang/rust/pull/17669/): Add this once multidispatch lands
-// impl<E: Error> FromError<E> for Box<Error> {
-//     fn from_err(err: E) -> Box<Error> {
-//         box err as Box<Error>
-//     }
-// }
-
 // Note: the definitions below are copied from core::any, and should be unified
 // as soon as possible.
 

src/libstd/lib.rs

@@ -258,6 +258,7 @@ mod std {
     pub use hash;
 
     pub use comm; // used for select!()
+    pub use error; // used for try!()
     pub use fmt; // used for any formatting strings
     pub use io; // used for println!()
     pub use local_data; // used for local_data_key!()

src/libstd/macros.rs

@@ -317,8 +317,13 @@ macro_rules! local_data_key(
 /// error if the value of the expression is `Err`. For more information, see
 /// `std::io`.
 #[macro_export]
-macro_rules! try(
-    ($e:expr) => (match $e { Ok(e) => e, Err(e) => return Err(e) })
+macro_rules! try (
+    ($expr:expr) => ({
+        match $expr {
+            Ok(val) => val,
+            Err(err) => return Err(::std::error::FromError::from_error(err))
+        }
+    })
 )
 
 /// Create a `std::vec::Vec` containing the arguments.