0.8 changes (#10)

* use `#[track_caller]`
* removed feature `display-cause`
* remove ChainErrorFrom and IntoChainError, add From
* cleanup

.github/workflows/rust.yml

@@ -19,7 +19,7 @@ jobs:
     strategy:
       matrix:
         version:
-          - 1.46.0
+          - 1.54.0
           - stable
           - beta
           - nightly
@@ -70,16 +70,3 @@ jobs:
         with:
           command: clippy
           args: -- -D warnings
-
-  readme:
-    name: cargo readme
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: stable
-          profile: minimal
-          override: true
-      - run: cargo install cargo-readme
-      - run: cargo readme > README.md && git diff --exit-code

Cargo.toml

@@ -21,7 +21,3 @@ github = { repository = "haraldh/chainerror", workflow = "Rust" }
 maintenance = { status = "actively-developed" }
 is-it-maintained-issue-resolution = { repository = "haraldh/chainerror" }
 is-it-maintained-open-issues = { repository = "haraldh/chainerror" }
-
-[features]
-default = []
-display-cause = []

README.md

@@ -1,9 +1,6 @@
 [![Crate](https://img.shields.io/crates/v/chainerror.svg)](https://crates.io/crates/chainerror)
 [![Rust Documentation](https://img.shields.io/badge/api-rustdoc-blue.svg)](https://docs.rs/chainerror/)
-[![Coverage Status](https://coveralls.io/repos/github/haraldh/chainerror/badge.svg?branch=master)](https://coveralls.io/github/haraldh/chainerror?branch=master)
+[![Coverage Status](https://codecov.io/gh/haraldh/chainerror/branch/master/graph/badge.svg?token=HGLJFGA11B)](https://codecov.io/gh/haraldh/chainerror)
-[![Workflow Status](https://github.com/haraldh/chainerror/workflows/Rust/badge.svg)](https://github.com/haraldh/chainerror/actions?query=workflow%3A%22Rust%22)
-[![Average time to resolve an issue](https://isitmaintained.com/badge/resolution/haraldh/chainerror.svg)](https://isitmaintained.com/project/haraldh/chainerror "Average time to resolve an issue")
-[![Percentage of issues still open](https://isitmaintained.com/badge/open/haraldh/chainerror.svg)](https://isitmaintained.com/project/haraldh/chainerror "Percentage of issues still open")
 ![Maintenance](https://img.shields.io/badge/maintenance-activly--developed-brightgreen.svg)
 
 # chainerror
@@ -93,11 +90,6 @@ Along with the `ChainError<T>` struct, `chainerror` comes with some useful helpe
 
 Debug information is worth it!
 
-### Features
-
-`display-cause`
-: turn on printing a backtrace of the errors in `Display`
-
 ## Tutorial
 
 Read the [Tutorial](https://haraldh.github.io/chainerror/tutorial1.html)

examples/example.rs

@@ -51,6 +51,10 @@ fn func1() -> ChainResult<(), Func1Error> {
 
 fn main() {
     if let Err(e) = func1() {
+        eprintln!("\nDisplay Error {{}}:\n{}", e);
+
+        eprintln!("\nAlternative Display Error {{:#}}:\n{:#}", e);
+
         eprintln!("\nDebug Error {{:?}}:\n{:?}", e);
 
         eprintln!("\nAlternative Debug Error {{:#?}}:\n{:#?}\n", e);

examples/tutorial1.rs

@@ -1,3 +1,6 @@
+#![allow(clippy::single_match)]
+#![allow(clippy::redundant_pattern_matching)]
+
 use std::error::Error;
 use std::io;
 use std::result::Result;

examples/tutorial13.rs

@@ -1,3 +1,6 @@
+#![allow(clippy::single_match)]
+#![allow(clippy::redundant_pattern_matching)]
+
 pub mod mycrate {
     use chainerror::prelude::v1::*;
     use std::io;

examples/tutorial14.rs

@@ -1,3 +1,6 @@
+#![allow(clippy::single_match)]
+#![allow(clippy::redundant_pattern_matching)]
+
 pub mod mycrate {
     use std::error::Error as StdError;
 

examples/tutorial15.rs

@@ -1,3 +1,6 @@
+#![allow(clippy::single_match)]
+#![allow(clippy::redundant_pattern_matching)]
+
 pub mod mycrate {
     use chainerror::prelude::v1::*;
     use std::io;

examples/tutorial6.rs

@@ -1,3 +1,6 @@
+#![allow(clippy::single_match)]
+#![allow(clippy::redundant_pattern_matching)]
+
 use chainerror::prelude::v1::*;
 use std::error::Error;
 use std::io;

examples/tutorial7.rs

@@ -1,3 +1,6 @@
+#![allow(clippy::single_match)]
+#![allow(clippy::redundant_pattern_matching)]
+
 use chainerror::prelude::v1::*;
 use std::error::Error;
 use std::io;

src/lib.rs

@@ -1,113 +1,11 @@
-//! `chainerror` provides an error backtrace without doing a real backtrace, so even after you `strip` your
+#![doc = include_str!("../README.md")]
-//! binaries, you still have the error backtrace.
-//!
-//! Having nested function returning errors, the output doesn't tell where the error originates from.
-//!
-//! ```rust
-//! use std::path::PathBuf;
-//!
-//! type BoxedError = Box<dyn std::error::Error + Send + Sync>;
-//! fn read_config_file(path: PathBuf) -> Result<(), BoxedError> {
-//!     // do stuff, return other errors
-//!     let _buf = std::fs::read_to_string(&path)?;
-//!     // do stuff, return other errors
-//!     Ok(())
-//! }
-//!
-//! fn process_config_file() -> Result<(), BoxedError> {
-//!     // do stuff, return other errors
-//!     let _buf = read_config_file("foo.txt".into())?;
-//!     // do stuff, return other errors
-//!     Ok(())
-//! }
-//!
-//! fn main() {
-//!     if let Err(e) = process_config_file() {
-//!         eprintln!("Error:\n{:?}", e);
-//!     }
-//! }
-//! ```
-//!
-//! This gives the output:
-//! ```console
-//! Error:
-//! Os { code: 2, kind: NotFound, message: "No such file or directory" }
-//! ```
-//! and you have no idea where it comes from.
-//!
-//!
-//! With `chainerror`, you can supply a context and get a nice error backtrace:
-//!
-//! ```rust
-//! use chainerror::prelude::v1::*;
-//! use std::path::PathBuf;
-//!
-//! type BoxedError = Box<dyn std::error::Error + Send + Sync>;
-//! fn read_config_file(path: PathBuf) -> Result<(), BoxedError> {
-//!     // do stuff, return other errors
-//!     let _buf = std::fs::read_to_string(&path).context(format!("Reading file: {:?}", &path))?;
-//!     // do stuff, return other errors
-//!     Ok(())
-//! }
-//!
-//! fn process_config_file() -> Result<(), BoxedError> {
-//!     // do stuff, return other errors
-//!     let _buf = read_config_file("foo.txt".into()).context("read the config file")?;
-//!     // do stuff, return other errors
-//!     Ok(())
-//! }
-//!
-//! fn main() {
-//!     if let Err(e) = process_config_file() {
-//!         eprintln!("Error:\n{:?}", e);
-//! #       let s = format!("{:?}", e);
-//! #       let lines = s.lines().collect::<Vec<_>>();
-//! #       assert_eq!(lines.len(), 5);
-//! #       assert!(lines[0].starts_with("src/lib.rs:"));
-//! #       assert_eq!(lines[1], "Caused by:");
-//! #       assert!(lines[2].starts_with("src/lib.rs:"));
-//! #       assert_eq!(lines[3], "Caused by:");
-//! #       assert_eq!(lines[4], "Os { code: 2, kind: NotFound, message: \"No such file or directory\" }");
-//!     }
-//! #   else { panic!(); }
-//! }
-//! ```
-//!
-//! with the output:
-//! ```console
-//! Error:
-//! examples/simple.rs:14:51: read the config file
-//! Caused by:
-//! examples/simple.rs:7:47: Reading file: "foo.txt"
-//! Caused by:
-//! Os { code: 2, kind: NotFound, message: "No such file or directory" }
-//! ```
-//!
-//! `chainerror` uses `.source()` of `std::error::Error` along with `#[track_caller]` and `Location` to provide a nice debug error backtrace.
-//! It encapsulates all types, which have `Display + Debug` and can store the error cause internally.
-//!
-//! Along with the `ChainError<T>` struct, `chainerror` comes with some useful helper macros to save a lot of typing.
-//!
-//! `chainerror` has no dependencies!
-//!
-//! Debug information is worth it!
-//!
-//! ## Features
-//!
-//! `display-cause`
-//! : turn on printing a backtrace of the errors in `Display`
-//!
-//! # Tutorial
-//!
-//! Read the [Tutorial](https://haraldh.github.io/chainerror/tutorial1.html)
-
 #![deny(clippy::all)]
 #![allow(clippy::needless_doctest_main)]
 #![deny(missing_docs)]
 
 use std::any::TypeId;
-use std::error::Error;
+use std::error::Error as StdError;
-use std::fmt::{Debug, Display, Formatter, Result};
+use std::fmt::{Debug, Display, Formatter};
 use std::panic::Location;
 
 pub mod prelude {
@@ -115,28 +13,29 @@ pub mod prelude {
     pub mod v1 {
         //! convenience prelude
         pub use super::super::ChainErrorDown as _;
+        pub use super::super::Error as ChainError;
+        pub use super::super::Result as ChainResult;
         pub use super::super::ResultTrait as _;
-        pub use super::super::{ChainError, ChainResult};
         pub use crate::{derive_err_kind, derive_str_context};
     }
 }
 
 /// chains an inner error kind `T` with a causing error
-pub struct ChainError<T> {
+pub struct Error<T> {
     occurrence: Option<String>,
     kind: T,
-    error_cause: Option<Box<dyn Error + 'static + Send + Sync>>,
+    error_cause: Option<Box<dyn StdError + 'static + Send + Sync>>,
 }
 
 /// convenience type alias
-pub type ChainResult<O, E> = std::result::Result<O, ChainError<E>>;
+pub type Result<O, E> = std::result::Result<O, Error<E>>;
 
-impl<T: 'static + Display + Debug> ChainError<T> {
+impl<T: 'static + Display + Debug> Error<T> {
     /// Use the `context()` or `map_context()` Result methods instead of calling this directly
     #[inline]
     pub fn new(
         kind: T,
-        error_cause: Option<Box<dyn Error + 'static + Send + Sync>>,
+        error_cause: Option<Box<dyn StdError + 'static + Send + Sync>>,
         occurrence: Option<String>,
     ) -> Self {
         Self {
@@ -147,7 +46,7 @@ impl<T: 'static + Display + Debug> ChainError<T> {
     }
 
     /// return the root cause of the error chain, if any exists
-    pub fn root_cause(&self) -> Option<&(dyn Error + 'static)> {
+    pub fn root_cause(&self) -> Option<&(dyn StdError + 'static)> {
         self.iter().last()
     }
 
@@ -195,9 +94,9 @@ impl<T: 'static + Display + Debug> ChainError<T> {
     /// #    }
     /// ```
     #[inline]
-    pub fn find_cause<U: Error + 'static>(&self) -> Option<&U> {
+    pub fn find_cause<U: StdError + 'static>(&self) -> Option<&U> {
         self.iter()
-            .filter_map(<dyn Error>::downcast_ref::<U>)
+            .filter_map(<dyn StdError>::downcast_ref::<U>)
             .next()
     }
 
@@ -218,9 +117,9 @@ impl<T: 'static + Display + Debug> ChainError<T> {
     /// err.find_chain_cause::<FooError>();
     /// ```
     #[inline]
-    pub fn find_chain_cause<U: Error + 'static>(&self) -> Option<&ChainError<U>> {
+    pub fn find_chain_cause<U: StdError + 'static>(&self) -> Option<&Error<U>> {
         self.iter()
-            .filter_map(<dyn Error>::downcast_ref::<ChainError<U>>)
+            .filter_map(<dyn StdError>::downcast_ref::<Error<U>>)
             .next()
     }
 
@@ -245,10 +144,10 @@ impl<T: 'static + Display + Debug> ChainError<T> {
     /// err.find_kind_or_cause::<FooErrorKind>();
     /// ```
     #[inline]
-    pub fn find_kind_or_cause<U: Error + 'static>(&self) -> Option<&U> {
+    pub fn find_kind_or_cause<U: StdError + 'static>(&self) -> Option<&U> {
         self.iter()
             .filter_map(|e| {
-                e.downcast_ref::<ChainError<U>>()
+                e.downcast_ref::<Error<U>>()
                     .map(|e| e.kind())
                     .or_else(|| e.downcast_ref::<U>())
             })
@@ -318,7 +217,7 @@ impl<T: 'static + Display + Debug> ChainError<T> {
     ///
     /// # Example
     #[inline]
-    pub fn iter(&self) -> impl Iterator<Item = &(dyn Error + 'static)> {
+    pub fn iter(&self) -> impl Iterator<Item = &(dyn StdError + 'static)> {
         ErrorIter {
             current: Some(self),
         }
@@ -326,31 +225,26 @@ impl<T: 'static + Display + Debug> ChainError<T> {
 }
 
 /// Convenience methods for `Result<>` to turn the error into a decorated ChainError
-pub trait ResultTrait<O, E: Into<Box<dyn Error + 'static + Send + Sync>>> {
+pub trait ResultTrait<O, E: Into<Box<dyn StdError + 'static + Send + Sync>>> {
     /// Decorate the error with a `kind` of type `T` and the source `Location`
-    fn context<T: 'static + Display + Debug>(
+    fn context<T: 'static + Display + Debug>(self, kind: T) -> std::result::Result<O, Error<T>>;
-        self,
-        kind: T,
-    ) -> std::result::Result<O, ChainError<T>>;
 
     /// Decorate the `error` with a `kind` of type `T` produced with a `FnOnce(&error)` and the source `Location`
     fn map_context<T: 'static + Display + Debug, F: FnOnce(&E) -> T>(
         self,
         op: F,
-    ) -> std::result::Result<O, ChainError<T>>;
+    ) -> std::result::Result<O, Error<T>>;
 }
 
-impl<O, E: Into<Box<dyn Error + 'static + Send + Sync>>> ResultTrait<O, E>
+impl<O, E: Into<Box<dyn StdError + 'static + Send + Sync>>> ResultTrait<O, E>
     for std::result::Result<O, E>
 {
     #[track_caller]
-    fn context<T: 'static + Display + Debug>(
+    #[inline]
-        self,
+    fn context<T: 'static + Display + Debug>(self, kind: T) -> std::result::Result<O, Error<T>> {
-        kind: T,
-    ) -> std::result::Result<O, ChainError<T>> {
         match self {
             Ok(t) => Ok(t),
-            Err(error_cause) => Err(ChainError::new(
+            Err(error_cause) => Err(Error::new(
                 kind,
                 Some(error_cause.into()),
                 Some(Location::caller().to_string()),
@@ -359,15 +253,16 @@ impl<O, E: Into<Box<dyn Error + 'static + Send + Sync>>> ResultTrait<O, E>
     }
 
     #[track_caller]
+    #[inline]
     fn map_context<T: 'static + Display + Debug, F: FnOnce(&E) -> T>(
         self,
         op: F,
-    ) -> std::result::Result<O, ChainError<T>> {
+    ) -> std::result::Result<O, Error<T>> {
         match self {
             Ok(t) => Ok(t),
             Err(error_cause) => {
                 let kind = op(&error_cause);
-                Err(ChainError::new(
+                Err(Error::new(
                     kind,
                     Some(error_cause.into()),
                     Some(Location::caller().to_string()),
@@ -379,21 +274,21 @@ impl<O, E: Into<Box<dyn Error + 'static + Send + Sync>>> ResultTrait<O, E>
 
 /// An iterator over all error causes/sources
 pub struct ErrorIter<'a> {
-    current: Option<&'a (dyn Error + 'static)>,
+    current: Option<&'a (dyn StdError + 'static)>,
 }
 
 impl<'a> Iterator for ErrorIter<'a> {
-    type Item = &'a (dyn Error + 'static);
+    type Item = &'a (dyn StdError + 'static);
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
         let current = self.current;
-        self.current = self.current.and_then(Error::source);
+        self.current = self.current.and_then(StdError::source);
         current
     }
 }
 
-impl<T: 'static + Display + Debug> std::ops::Deref for ChainError<T> {
+impl<T: 'static + Display + Debug> std::ops::Deref for Error<T> {
     type Target = T;
 
     #[inline]
@@ -407,28 +302,28 @@ pub trait ChainErrorDown {
     /// Test if of type `ChainError<T>`
     fn is_chain<T: 'static + Display + Debug>(&self) -> bool;
     /// Downcast to a reference of `ChainError<T>`
-    fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&ChainError<T>>;
+    fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&Error<T>>;
     /// Downcast to a mutable reference of `ChainError<T>`
-    fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut ChainError<T>>;
+    fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut Error<T>>;
     /// Downcast to T of `ChainError<T>`
-    fn downcast_inner_ref<T: 'static + Error>(&self) -> Option<&T>;
+    fn downcast_inner_ref<T: 'static + StdError>(&self) -> Option<&T>;
     /// Downcast to T mutable reference of `ChainError<T>`
-    fn downcast_inner_mut<T: 'static + Error>(&mut self) -> Option<&mut T>;
+    fn downcast_inner_mut<T: 'static + StdError>(&mut self) -> Option<&mut T>;
 }
 
-impl<U: 'static + Display + Debug> ChainErrorDown for ChainError<U> {
+impl<U: 'static + Display + Debug> ChainErrorDown for Error<U> {
     #[inline]
     fn is_chain<T: 'static + Display + Debug>(&self) -> bool {
         TypeId::of::<T>() == TypeId::of::<U>()
     }
 
     #[inline]
-    fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&ChainError<T>> {
+    fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&Error<T>> {
         if self.is_chain::<T>() {
             #[allow(clippy::cast_ptr_alignment)]
             unsafe {
                 #[allow(trivial_casts)]
-                Some(*(self as *const dyn Error as *const &ChainError<T>))
+                Some(*(self as *const dyn StdError as *const &Error<T>))
             }
         } else {
             None
@@ -436,24 +331,24 @@ impl<U: 'static + Display + Debug> ChainErrorDown for ChainError<U> {
     }
 
     #[inline]
-    fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut ChainError<T>> {
+    fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut Error<T>> {
         if self.is_chain::<T>() {
             #[allow(clippy::cast_ptr_alignment)]
             unsafe {
                 #[allow(trivial_casts)]
-                Some(&mut *(self as *mut dyn Error as *mut &mut ChainError<T>))
+                Some(&mut *(self as *mut dyn StdError as *mut &mut Error<T>))
             }
         } else {
             None
         }
     }
     #[inline]
-    fn downcast_inner_ref<T: 'static + Error>(&self) -> Option<&T> {
+    fn downcast_inner_ref<T: 'static + StdError>(&self) -> Option<&T> {
         if self.is_chain::<T>() {
             #[allow(clippy::cast_ptr_alignment)]
             unsafe {
                 #[allow(trivial_casts)]
-                Some(&(*(self as *const dyn Error as *const &ChainError<T>)).kind)
+                Some(&(*(self as *const dyn StdError as *const &Error<T>)).kind)
             }
         } else {
             None
@@ -461,12 +356,12 @@ impl<U: 'static + Display + Debug> ChainErrorDown for ChainError<U> {
     }
 
     #[inline]
-    fn downcast_inner_mut<T: 'static + Error>(&mut self) -> Option<&mut T> {
+    fn downcast_inner_mut<T: 'static + StdError>(&mut self) -> Option<&mut T> {
         if self.is_chain::<T>() {
             #[allow(clippy::cast_ptr_alignment)]
             unsafe {
                 #[allow(trivial_casts)]
-                Some(&mut (*(self as *mut dyn Error as *mut &mut ChainError<T>)).kind)
+                Some(&mut (*(self as *mut dyn StdError as *mut &mut Error<T>)).kind)
             }
         } else {
             None
@@ -474,142 +369,141 @@ impl<U: 'static + Display + Debug> ChainErrorDown for ChainError<U> {
     }
 }
 
-impl ChainErrorDown for dyn Error + 'static {
+impl ChainErrorDown for dyn StdError + 'static {
     #[inline]
     fn is_chain<T: 'static + Display + Debug>(&self) -> bool {
-        self.is::<ChainError<T>>()
+        self.is::<Error<T>>()
     }
 
     #[inline]
-    fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&ChainError<T>> {
+    fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&Error<T>> {
-        self.downcast_ref::<ChainError<T>>()
+        self.downcast_ref::<Error<T>>()
     }
 
     #[inline]
-    fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut ChainError<T>> {
+    fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut Error<T>> {
-        self.downcast_mut::<ChainError<T>>()
+        self.downcast_mut::<Error<T>>()
     }
 
     #[inline]
-    fn downcast_inner_ref<T: 'static + Error>(&self) -> Option<&T> {
+    fn downcast_inner_ref<T: 'static + StdError>(&self) -> Option<&T> {
         self.downcast_ref::<T>()
-            .or_else(|| self.downcast_ref::<ChainError<T>>().map(|e| e.kind()))
+            .or_else(|| self.downcast_ref::<Error<T>>().map(|e| e.kind()))
     }
 
     #[inline]
-    fn downcast_inner_mut<T: 'static + Error>(&mut self) -> Option<&mut T> {
+    fn downcast_inner_mut<T: 'static + StdError>(&mut self) -> Option<&mut T> {
         if self.is::<T>() {
             return self.downcast_mut::<T>();
         }
 
-        self.downcast_mut::<ChainError<T>>()
+        self.downcast_mut::<Error<T>>()
             .and_then(|e| e.downcast_inner_mut::<T>())
     }
 }
 
-impl ChainErrorDown for dyn Error + 'static + Send {
+impl ChainErrorDown for dyn StdError + 'static + Send {
     #[inline]
     fn is_chain<T: 'static + Display + Debug>(&self) -> bool {
-        self.is::<ChainError<T>>()
+        self.is::<Error<T>>()
     }
 
     #[inline]
-    fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&ChainError<T>> {
+    fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&Error<T>> {
-        self.downcast_ref::<ChainError<T>>()
+        self.downcast_ref::<Error<T>>()
     }
 
     #[inline]
-    fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut ChainError<T>> {
+    fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut Error<T>> {
-        self.downcast_mut::<ChainError<T>>()
+        self.downcast_mut::<Error<T>>()
     }
 
     #[inline]
-    fn downcast_inner_ref<T: 'static + Error>(&self) -> Option<&T> {
+    fn downcast_inner_ref<T: 'static + StdError>(&self) -> Option<&T> {
         self.downcast_ref::<T>()
-            .or_else(|| self.downcast_ref::<ChainError<T>>().map(|e| e.kind()))
+            .or_else(|| self.downcast_ref::<Error<T>>().map(|e| e.kind()))
     }
 
     #[inline]
-    fn downcast_inner_mut<T: 'static + Error>(&mut self) -> Option<&mut T> {
+    fn downcast_inner_mut<T: 'static + StdError>(&mut self) -> Option<&mut T> {
         if self.is::<T>() {
             return self.downcast_mut::<T>();
         }
 
-        self.downcast_mut::<ChainError<T>>()
+        self.downcast_mut::<Error<T>>()
             .and_then(|e| e.downcast_inner_mut::<T>())
     }
 }
 
-impl ChainErrorDown for dyn Error + 'static + Send + Sync {
+impl ChainErrorDown for dyn StdError + 'static + Send + Sync {
     #[inline]
     fn is_chain<T: 'static + Display + Debug>(&self) -> bool {
-        self.is::<ChainError<T>>()
+        self.is::<Error<T>>()
     }
 
     #[inline]
-    fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&ChainError<T>> {
+    fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&Error<T>> {
-        self.downcast_ref::<ChainError<T>>()
+        self.downcast_ref::<Error<T>>()
     }
 
     #[inline]
-    fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut ChainError<T>> {
+    fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut Error<T>> {
-        self.downcast_mut::<ChainError<T>>()
+        self.downcast_mut::<Error<T>>()
     }
 
     #[inline]
-    fn downcast_inner_ref<T: 'static + Error>(&self) -> Option<&T> {
+    fn downcast_inner_ref<T: 'static + StdError>(&self) -> Option<&T> {
         self.downcast_ref::<T>()
-            .or_else(|| self.downcast_ref::<ChainError<T>>().map(|e| e.kind()))
+            .or_else(|| self.downcast_ref::<Error<T>>().map(|e| e.kind()))
     }
 
     #[inline]
-    fn downcast_inner_mut<T: 'static + Error>(&mut self) -> Option<&mut T> {
+    fn downcast_inner_mut<T: 'static + StdError>(&mut self) -> Option<&mut T> {
         if self.is::<T>() {
             return self.downcast_mut::<T>();
         }
 
-        self.downcast_mut::<ChainError<T>>()
+        self.downcast_mut::<Error<T>>()
             .and_then(|e| e.downcast_inner_mut::<T>())
     }
 }
 
-impl<T: 'static + Display + Debug> Error for ChainError<T> {
+impl<T: 'static + Display + Debug> StdError for Error<T> {
     #[inline]
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
         self.error_cause
             .as_ref()
-            .map(|e| e.as_ref() as &(dyn Error + 'static))
+            .map(|e| e.as_ref() as &(dyn StdError + 'static))
     }
 }
 
-impl<T: 'static + Display + Debug> Error for &mut ChainError<T> {
+impl<T: 'static + Display + Debug> StdError for &mut Error<T> {
     #[inline]
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
         self.error_cause
             .as_ref()
-            .map(|e| e.as_ref() as &(dyn Error + 'static))
+            .map(|e| e.as_ref() as &(dyn StdError + 'static))
     }
 }
 
-impl<T: 'static + Display + Debug> Display for ChainError<T> {
+impl<T: 'static + Display + Debug> Display for Error<T> {
     #[inline]
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.kind)?;
 
-        #[cfg(feature = "display-cause")]
+        if f.alternate() {
-        {
             if let Some(e) = self.source() {
-                writeln!(f, "\nCaused by:")?;
+                write!(f, "\nCaused by:\n  {:#}", &e)?;
-                Display::fmt(&e, f)?;
             }
         }
+
         Ok(())
     }
 }
 
-impl<T: 'static + Display + Debug> Debug for ChainError<T> {
+impl<T: 'static + Display + Debug> Debug for Error<T> {
     #[inline]
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         if f.alternate() {
             let mut f = f.debug_struct(&format!("ChainError<{}>", std::any::type_name::<T>()));
 
@@ -633,54 +527,29 @@ impl<T: 'static + Display + Debug> Debug for ChainError<T> {
             }
 
             if let Some(e) = self.source() {
-                writeln!(f, "\nCaused by:")?;
+                write!(f, "\nCaused by:\n{:?}", &e)?;
-                Debug::fmt(&e, f)?;
             }
             Ok(())
         }
     }
 }
 
-/// `ChainErrorFrom<T>` is similar to `From<T>`
+impl<T> From<T> for Error<T>
-pub trait ChainErrorFrom<T>: Sized {
-    /// similar to From<T>::from()
-    fn chain_error_from(from: T, line_filename: Option<String>) -> ChainError<Self>;
-}
-
-/// `IntoChainError<T>` is similar to `Into<T>`
-pub trait IntoChainError<T>: Sized {
-    /// similar to Into<T>::into()
-    fn into_chain_error(self, line_filename: Option<String>) -> ChainError<T>;
-}
-
-impl<T, U> IntoChainError<U> for T
 where
-    U: ChainErrorFrom<T>,
+    T: 'static + Display + Debug,
 {
+    #[track_caller]
     #[inline]
-    fn into_chain_error(self, line_filename: Option<String>) -> ChainError<U> {
+    fn from(e: T) -> Error<T> {
-        U::chain_error_from(self, line_filename)
+        Error::new(e, None, Some(Location::caller().to_string()))
     }
 }
-
-impl<T, U> ChainErrorFrom<T> for U
-where
-    T: Into<U>,
-    U: 'static + Display + Debug,
-{
-    #[inline]
-    fn chain_error_from(t: T, line_filename: Option<String>) -> ChainError<Self> {
-        let e: U = t.into();
-        ChainError::new(e, None, line_filename)
-    }
-}
-
 /// Convenience macro to create a "new type" T(String) and implement Display + Debug for T
 ///
 /// # Examples
 ///
 /// ```rust
-/// # use crate::chainerror::*;
+/// # use chainerror::prelude::v1::*;
 /// # use std::error::Error;
 /// # use std::io;
 /// # use std::result::Result;
@@ -799,7 +668,7 @@ macro_rules! derive_str_context {
 #[macro_export]
 macro_rules! derive_err_kind {
     ($e:ident, $k:ident) => {
-        pub struct $e($crate::ChainError<$k>);
+        pub struct $e($crate::Error<$k>);
 
         impl $e {
             pub fn kind(&self) -> &$k {
@@ -809,12 +678,12 @@ macro_rules! derive_err_kind {
 
         impl From<$k> for $e {
             fn from(e: $k) -> Self {
-                $e($crate::ChainError::new(e, None, None))
+                $e($crate::Error::new(e, None, None))
             }
         }
 
         impl From<ChainError<$k>> for $e {
-            fn from(e: $crate::ChainError<$k>) -> Self {
+            fn from(e: $crate::Error<$k>) -> Self {
                 $e(e)
             }
         }

tests/test_iter.rs

@@ -2,7 +2,6 @@ use chainerror::prelude::v1::*;
 use std::error::Error;
 use std::io;
 
-#[cfg(not(feature = "display-cause"))]
 #[test]
 fn test_iter() -> Result<(), Box<dyn Error + Send + Sync>> {
     use std::fmt::Write;
@@ -32,9 +31,8 @@ fn test_iter() -> Result<(), Box<dyn Error + Send + Sync>> {
     Ok(())
 }
 
-#[cfg(feature = "display-cause")]
 #[test]
-fn test_iter() -> Result<(), Box<dyn Error + Send + Sync>> {
+fn test_iter_alternate() -> Result<(), Box<dyn Error + Send + Sync>> {
     let err: Result<(), _> = Err(io::Error::from(io::ErrorKind::NotFound));
     let err = err.context("1");
     let err = err.context("2");
@@ -44,9 +42,9 @@ fn test_iter() -> Result<(), Box<dyn Error + Send + Sync>> {
     let err = err.context("6");
     let err = err.err().unwrap();
 
-    let res = err.to_string();
+    let res = format!("{:#}", err);
 
-    assert_eq!(res, "6\nCaused by:\n5\nCaused by:\n4\nCaused by:\n3\nCaused by:\n2\nCaused by:\n1\nCaused by:\nentity not found");
+    assert_eq!(res, format!("6\nCaused by:\n  5\nCaused by:\n  4\nCaused by:\n  3\nCaused by:\n  2\nCaused by:\n  1\nCaused by:\n  {:#}", io::Error::from(io::ErrorKind::NotFound)));
 
     let io_error: Option<&io::Error> = err
         .iter()