This removes the FromError trait, since it can now be expressed using
the new convert::Into trait. All implementations of FromError<E> where
changed to From<E>, and `try!` was changed to use From::from instead.
Because this removes FromError, it is a breaking change, but fixing it
simply requires changing the words `FromError` to `From`, and
`from_error` to `from`.
[breaking-change]
use core::any::Any;
use core::cmp::Ordering;
use core::default::Default;
use core::any::Any;
use core::cmp::Ordering;
use core::default::Default;
-use core::error::{Error, FromError};
use core::fmt;
use core::hash::{self, Hash};
use core::mem;
use core::fmt;
use core::hash::{self, Hash};
use core::mem;
impl<I: ExactSizeIterator + ?Sized> ExactSizeIterator for Box<I> {}
#[stable(feature = "rust1", since = "1.0.0")]
impl<I: ExactSizeIterator + ?Sized> ExactSizeIterator for Box<I> {}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, E: Error + 'a> FromError<E> for Box<Error + 'a> {
- fn from_error(err: E) -> Box<Error + 'a> {
+impl<'a, E: Error + 'a> From<E> for Box<Error + 'a> {
+ fn from(err: E) -> Box<Error + 'a> {
+// From itself is always itself
+impl<T> From<T> for T {
+ fn from(t: T) -> T {
+ t
+ }
+}
+
// From implies Into
impl<T, U> Into<U> for T where U: From<T> {
fn into(self) -> U {
// From implies Into
impl<T, U> Into<U> for T where U: From<T> {
fn into(self) -> U {
//! particular implementation, but also reveal some of its implementation for
//! debugging via `cause` chains.
//!
//! particular implementation, but also reveal some of its implementation for
//! debugging via `cause` chains.
//!
-//! # The `FromError` trait
-//!
-//! `FromError` is a simple trait that expresses conversions between different
-//! error types. To provide maximum flexibility, it does not require either of
-//! the types to actually implement the `Error` trait, although this will be the
-//! common case.
-//!
-//! 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,
//!
//! ```
//! For example,
//!
//! ```
//! Map(MapError)
//! }
//!
//! Map(MapError)
//! }
//!
-//! impl FromError<IoError> for MyError {
-//! fn from_error(err: IoError) -> MyError {
+//! impl From<IoError> for MyError {
+//! fn from(err: IoError) -> MyError {
//! MyError::Io(err)
//! }
//! }
//!
//! MyError::Io(err)
//! }
//! }
//!
-//! impl FromError<MapError> for MyError {
-//! fn from_error(err: MapError) -> MyError {
+//! impl From<MapError> for MyError {
+//! fn from(err: MapError) -> MyError {
//! MyError::Map(err)
//! }
//! }
//! MyError::Map(err)
//! }
//! }
#[stable(feature = "rust1", since = "1.0.0")]
fn cause(&self) -> Option<&Error> { None }
}
#[stable(feature = "rust1", since = "1.0.0")]
fn cause(&self) -> Option<&Error> { None }
}
-
-/// A trait for types that can be converted from a given error type `E`.
-#[stable(feature = "rust1", since = "1.0.0")]
-pub trait FromError<E> {
- /// Perform the conversion.
- #[stable(feature = "rust1", since = "1.0.0")]
- fn from_error(err: E) -> Self;
-}
-
-// Any type is convertable from itself
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<E> FromError<E> for E {
- fn from_error(err: E) -> E {
- err
- }
-}
/// Short circuiting evaluation on Err
///
/// Short circuiting evaluation on Err
///
-/// `libstd` contains a more general `try!` macro that uses `FromError`.
+/// `libstd` contains a more general `try!` macro that uses `From<E>`.
#[macro_export]
macro_rules! try {
($e:expr) => ({
#[macro_export]
macro_rules! try {
($e:expr) => ({
fn description(&self) -> &str { "encoder error" }
}
fn description(&self) -> &str { "encoder error" }
}
-impl std::error::FromError<fmt::Error> for EncoderError {
- fn from_error(err: fmt::Error) -> EncoderError { EncoderError::FmtError(err) }
+impl From<fmt::Error> for EncoderError {
+ fn from(err: fmt::Error) -> EncoderError { EncoderError::FmtError(err) }
}
pub type EncodeResult = Result<(), EncoderError>;
}
pub type EncodeResult = Result<(), EncoderError>;
use convert::Into;
use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
use convert::Into;
use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
-use error::{Error, FromError};
use fmt;
use io;
use iter::Iterator;
use fmt;
use io;
use iter::Iterator;
}
#[stable(feature = "rust1", since = "1.0.0")]
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl FromError<NulError> for io::Error {
- fn from_error(_: NulError) -> io::Error {
+impl From<NulError> for io::Error {
+ fn from(_: NulError) -> io::Error {
io::Error::new(io::ErrorKind::InvalidInput,
"data provided contains a nul byte", None)
}
io::Error::new(io::ErrorKind::InvalidInput,
"data provided contains a nul byte", None)
}
#[stable(feature = "rust1", since = "1.0.0")]
#[allow(deprecated)]
#[stable(feature = "rust1", since = "1.0.0")]
#[allow(deprecated)]
-impl FromError<NulError> for old_io::IoError {
- fn from_error(_: NulError) -> old_io::IoError {
+impl From<NulError> for old_io::IoError {
+ fn from(_: NulError) -> old_io::IoError {
old_io::IoError {
kind: old_io::IoErrorKind::InvalidInput,
desc: "data provided contains a nul byte",
old_io::IoError {
kind: old_io::IoErrorKind::InvalidInput,
desc: "data provided contains a nul byte",
use io::prelude::*;
use cmp;
use io::prelude::*;
use cmp;
-use error::{self, FromError};
use fmt;
use io::{self, DEFAULT_BUF_SIZE, Error, ErrorKind};
use ptr;
use fmt;
use io::{self, DEFAULT_BUF_SIZE, Error, ErrorKind};
use ptr;
}
#[stable(feature = "rust1", since = "1.0.0")]
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<W> FromError<IntoInnerError<W>> for Error {
- fn from_error(iie: IntoInnerError<W>) -> Error { iie.1 }
+impl<W> From<IntoInnerError<W>> for Error {
+ fn from(iie: IntoInnerError<W>) -> Error { iie.1 }
}
#[stable(feature = "rust1", since = "1.0.0")]
}
#[stable(feature = "rust1", since = "1.0.0")]
($expr:expr) => (match $expr {
$crate::result::Result::Ok(val) => val,
$crate::result::Result::Err(err) => {
($expr:expr) => (match $expr {
$crate::result::Result::Ok(val) => val,
$crate::result::Result::Err(err) => {
- return $crate::result::Result::Err($crate::error::FromError::from_error(err))
+ return $crate::result::Result::Err($crate::convert::From::from(err))
use clone::Clone;
use convert::From;
use env;
use clone::Clone;
use convert::From;
use env;
-use error::{FromError, Error};
use ffi::{OsString, OsStr};
use fmt;
use iter::Iterator;
use ffi::{OsString, OsStr};
use fmt;
use iter::Iterator;
use prelude::v1::*;
use cell::UnsafeCell;
use prelude::v1::*;
use cell::UnsafeCell;
-use error::{Error, FromError};
pub fn get_mut(&mut self) -> &mut T { &mut self.guard }
}
pub fn get_mut(&mut self) -> &mut T { &mut self.guard }
}
-impl<T> FromError<PoisonError<T>> for TryLockError<T> {
- fn from_error(err: PoisonError<T>) -> TryLockError<T> {
+impl<T> From<PoisonError<T>> for TryLockError<T> {
+ fn from(err: PoisonError<T>) -> TryLockError<T> {
TryLockError::Poisoned(err)
}
}
TryLockError::Poisoned(err)
}
}