<!DOCTYPE HTML>
<html lang="en" class="sidebar-visible no-js light">
    <head>
        <!-- Book generated using mdBook -->
        <meta charset="UTF-8">
        <title>The source() of Errors - chainerror</title>


        <!-- Custom HTML head -->
        
        <meta name="description" content="A tutorial for the chainerror rust crate.">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <meta name="theme-color" content="#ffffff" />

        <link rel="icon" href="favicon.svg">
        <link rel="shortcut icon" href="favicon.png">
        <link rel="stylesheet" href="css/variables.css">
        <link rel="stylesheet" href="css/general.css">
        <link rel="stylesheet" href="css/chrome.css">
        <link rel="stylesheet" href="css/print.css" media="print">

        <!-- Fonts -->
        <link rel="stylesheet" href="FontAwesome/css/font-awesome.css">
        <link rel="stylesheet" href="fonts/fonts.css">

        <!-- Highlight.js Stylesheets -->
        <link rel="stylesheet" href="highlight.css">
        <link rel="stylesheet" href="tomorrow-night.css">
        <link rel="stylesheet" href="ayu-highlight.css">

        <!-- Custom theme stylesheets -->

    </head>
    <body>
    <div id="body-container">
        <!-- Provide site root to javascript -->
        <script>
            var path_to_root = "";
            var default_theme = window.matchMedia("(prefers-color-scheme: dark)").matches ? "navy" : "light";
        </script>

        <!-- Work around some values being stored in localStorage wrapped in quotes -->
        <script>
            try {
                var theme = localStorage.getItem('mdbook-theme');
                var sidebar = localStorage.getItem('mdbook-sidebar');

                if (theme.startsWith('"') && theme.endsWith('"')) {
                    localStorage.setItem('mdbook-theme', theme.slice(1, theme.length - 1));
                }

                if (sidebar.startsWith('"') && sidebar.endsWith('"')) {
                    localStorage.setItem('mdbook-sidebar', sidebar.slice(1, sidebar.length - 1));
                }
            } catch (e) { }
        </script>

        <!-- Set the theme before any content is loaded, prevents flash -->
        <script>
            var theme;
            try { theme = localStorage.getItem('mdbook-theme'); } catch(e) { }
            if (theme === null || theme === undefined) { theme = default_theme; }
            var html = document.querySelector('html');
            html.classList.remove('no-js')
            html.classList.remove('light')
            html.classList.add(theme);
            html.classList.add('js');
        </script>

        <!-- Hide / unhide sidebar before it is displayed -->
        <script>
            var html = document.querySelector('html');
            var sidebar = null;
            if (document.body.clientWidth >= 1080) {
                try { sidebar = localStorage.getItem('mdbook-sidebar'); } catch(e) { }
                sidebar = sidebar || 'visible';
            } else {
                sidebar = 'hidden';
            }
            html.classList.remove('sidebar-visible');
            html.classList.add("sidebar-" + sidebar);
        </script>

        <nav id="sidebar" class="sidebar" aria-label="Table of contents">
            <div class="sidebar-scrollbox">
                <ol class="chapter"><li class="chapter-item expanded affix "><a href="index.html">chainerror</a></li><li class="chapter-item expanded "><a href="tutorial1.html"><strong aria-hidden="true">1.</strong> Simple String Errors</a></li><li class="chapter-item expanded "><a href="tutorial2.html"><strong aria-hidden="true">2.</strong> Simple Chained String Errors</a></li><li class="chapter-item expanded "><a href="tutorial3.html"><strong aria-hidden="true">3.</strong> Mapping Errors</a></li><li class="chapter-item expanded "><a href="tutorial4.html"><strong aria-hidden="true">4.</strong> More Information</a></li><li class="chapter-item expanded "><a href="tutorial5.html" class="active"><strong aria-hidden="true">5.</strong> The source() of Errors</a></li><li class="chapter-item expanded "><a href="tutorial6.html"><strong aria-hidden="true">6.</strong> Downcast the Errors</a></li><li class="chapter-item expanded "><a href="tutorial7.html"><strong aria-hidden="true">7.</strong> The root cause of all Errors</a></li><li class="chapter-item expanded "><a href="tutorial8.html"><strong aria-hidden="true">8.</strong> Finding an Error cause</a></li><li class="chapter-item expanded "><a href="tutorial9.html"><strong aria-hidden="true">9.</strong> Selective Error Handling</a></li><li class="chapter-item expanded "><a href="tutorial10.html"><strong aria-hidden="true">10.</strong> ErrorKind to the rescue</a></li><li class="chapter-item expanded "><a href="tutorial11.html"><strong aria-hidden="true">11.</strong> Debug for the ErrorKind</a></li><li class="chapter-item expanded "><a href="tutorial12.html"><strong aria-hidden="true">12.</strong> Deref for the ErrorKind</a></li><li class="chapter-item expanded "><a href="tutorial13.html"><strong aria-hidden="true">13.</strong> Writing a library</a></li><li class="chapter-item expanded "><a href="tutorial14.html"><strong aria-hidden="true">14.</strong> Going back to std</a></li><li class="chapter-item expanded affix "><a href="end.html">The End</a></li></ol>
            </div>
            <div id="sidebar-resize-handle" class="sidebar-resize-handle"></div>
        </nav>

        <!-- Track and set sidebar scroll position -->
        <script>
            var sidebarScrollbox = document.querySelector('#sidebar .sidebar-scrollbox');
            sidebarScrollbox.addEventListener('click', function(e) {
                if (e.target.tagName === 'A') {
                    sessionStorage.setItem('sidebar-scroll', sidebarScrollbox.scrollTop);
                }
            }, { passive: true });
            var sidebarScrollTop = sessionStorage.getItem('sidebar-scroll');
            sessionStorage.removeItem('sidebar-scroll');
            if (sidebarScrollTop) {
                // preserve sidebar scroll position when navigating via links within sidebar
                sidebarScrollbox.scrollTop = sidebarScrollTop;
            } else {
                // scroll sidebar to current active section when navigating via "next/previous chapter" buttons
                var activeSection = document.querySelector('#sidebar .active');
                if (activeSection) {
                    activeSection.scrollIntoView({ block: 'center' });
                }
            }
        </script>

        <div id="page-wrapper" class="page-wrapper">

            <div class="page">
                                <div id="menu-bar-hover-placeholder"></div>
                <div id="menu-bar" class="menu-bar sticky">
                    <div class="left-buttons">
                        <button id="sidebar-toggle" class="icon-button" type="button" title="Toggle Table of Contents" aria-label="Toggle Table of Contents" aria-controls="sidebar">
                            <i class="fa fa-bars"></i>
                        </button>
                        <button id="theme-toggle" class="icon-button" type="button" title="Change theme" aria-label="Change theme" aria-haspopup="true" aria-expanded="false" aria-controls="theme-list">
                            <i class="fa fa-paint-brush"></i>
                        </button>
                        <ul id="theme-list" class="theme-popup" aria-label="Themes" role="menu">
                            <li role="none"><button role="menuitem" class="theme" id="light">Light</button></li>
                            <li role="none"><button role="menuitem" class="theme" id="rust">Rust</button></li>
                            <li role="none"><button role="menuitem" class="theme" id="coal">Coal</button></li>
                            <li role="none"><button role="menuitem" class="theme" id="navy">Navy</button></li>
                            <li role="none"><button role="menuitem" class="theme" id="ayu">Ayu</button></li>
                        </ul>
                        <button id="search-toggle" class="icon-button" type="button" title="Search. (Shortkey: s)" aria-label="Toggle Searchbar" aria-expanded="false" aria-keyshortcuts="S" aria-controls="searchbar">
                            <i class="fa fa-search"></i>
                        </button>
                    </div>

                    <h1 class="menu-title">chainerror</h1>

                    <div class="right-buttons">
                        <a href="print.html" title="Print this book" aria-label="Print this book">
                            <i id="print-button" class="fa fa-print"></i>
                        </a>

                    </div>
                </div>

                <div id="search-wrapper" class="hidden">
                    <form id="searchbar-outer" class="searchbar-outer">
                        <input type="search" id="searchbar" name="searchbar" placeholder="Search this book ..." aria-controls="searchresults-outer" aria-describedby="searchresults-header">
                    </form>
                    <div id="searchresults-outer" class="searchresults-outer hidden">
                        <div id="searchresults-header" class="searchresults-header"></div>
                        <ul id="searchresults">
                        </ul>
                    </div>
                </div>

                <!-- Apply ARIA attributes after the sidebar and the sidebar toggle button are added to the DOM -->
                <script>
                    document.getElementById('sidebar-toggle').setAttribute('aria-expanded', sidebar === 'visible');
                    document.getElementById('sidebar').setAttribute('aria-hidden', sidebar !== 'visible');
                    Array.from(document.querySelectorAll('#sidebar a')).forEach(function(link) {
                        link.setAttribute('tabIndex', sidebar === 'visible' ? 0 : -1);
                    });
                </script>

                <div id="content" class="content">
                    <main>
                        <h1 id="the-source-of-errors"><a class="header" href="#the-source-of-errors">The source() of Errors</a></h1>
<p>Sometimes you want to inspect the <code>source()</code> of an <code>Error</code>.
<code>chainerror</code> implements <code>std::error::Error::source()</code>, so you can get the cause of an error.</p>
<pre><pre class="playground"><code class="language-rust">use chainerror::Context as _;

use std::error::Error;
use std::io;

fn do_some_io() -&gt; Result&lt;(), Box&lt;dyn Error + Send + Sync&gt;&gt; {
    Err(io::Error::from(io::ErrorKind::NotFound))?;
    Ok(())
}

fn func2() -&gt; Result&lt;(), Box&lt;dyn Error + Send + Sync&gt;&gt; {
    let filename = &quot;foo.txt&quot;;
    do_some_io().context(format!(&quot;Error reading '{}'&quot;, filename))?;
    Ok(())
}

fn func1() -&gt; Result&lt;(), Box&lt;dyn Error + Send + Sync&gt;&gt; {
    if let Err(e) = func2() {
        if let Some(s) = e.source() {
            eprintln!(&quot;func2 failed because of '{}'&quot;, s);
            Err(e).context(&quot;func1 error&quot;)?;
        }
    }
    Ok(())
}

fn main() -&gt; Result&lt;(), Box&lt;dyn Error + Send + Sync&gt;&gt; {
    if let Err(e) = func1() {
        eprintln!(&quot;{}&quot;, e);
        std::process::exit(1);
    }
    Ok(())
}
<span class="boring">#[allow(dead_code)]
</span><span class="boring">mod chainerror {
</span><span class="boring">#![doc = include_str!(&quot;../README.md&quot;)]
</span><span class="boring">#![deny(clippy::all)]
</span><span class="boring">#![allow(clippy::needless_doctest_main)]
</span><span class="boring">#![deny(missing_docs)]
</span><span class="boring">
</span><span class="boring">use std::any::TypeId;
</span><span class="boring">use std::error::Error as StdError;
</span><span class="boring">use std::fmt::{Debug, Display, Formatter};
</span><span class="boring">use std::panic::Location;
</span><span class="boring">
</span><span class="boring">/// chains an inner error kind `T` with a causing error
</span><span class="boring">pub struct Error&lt;T&gt; {
</span><span class="boring">    occurrence: Option&lt;String&gt;,
</span><span class="boring">    kind: T,
</span><span class="boring">    error_cause: Option&lt;Box&lt;dyn StdError + 'static + Send + Sync&gt;&gt;,
</span><span class="boring">}
</span><span class="boring">
</span><span class="boring">/// convenience type alias
</span><span class="boring">pub type Result&lt;O, E&gt; = std::result::Result&lt;O, Error&lt;E&gt;&gt;;
</span><span class="boring">
</span><span class="boring">impl&lt;T: 'static + Display + Debug&gt; Error&lt;T&gt; {
</span><span class="boring">    /// Use the `context()` or `map_context()` Result methods instead of calling this directly
</span><span class="boring">    #[inline]
</span><span class="boring">    pub fn new(
</span><span class="boring">        kind: T,
</span><span class="boring">        error_cause: Option&lt;Box&lt;dyn StdError + 'static + Send + Sync&gt;&gt;,
</span><span class="boring">        occurrence: Option&lt;String&gt;,
</span><span class="boring">    ) -&gt; Self {
</span><span class="boring">        Self {
</span><span class="boring">            occurrence,
</span><span class="boring">            kind,
</span><span class="boring">            error_cause,
</span><span class="boring">        }
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    /// return the root cause of the error chain, if any exists
</span><span class="boring">    pub fn root_cause(&amp;self) -&gt; Option&lt;&amp;(dyn StdError + 'static)&gt; {
</span><span class="boring">        self.iter().last()
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    /// Find the first error cause of type U, if any exists
</span><span class="boring">    ///
</span><span class="boring">    /// # Examples
</span><span class="boring">    ///
</span><span class="boring">    /// ```rust
</span><span class="boring">    /// use chainerror::Context as _;
</span><span class="boring">    /// use chainerror::ErrorDown as _;
</span><span class="boring">    /// use std::error::Error;
</span><span class="boring">    /// use std::io;
</span><span class="boring">    ///
</span><span class="boring">    /// fn do_some_io() -&gt; Result&lt;(), Box&lt;dyn Error + Send + Sync&gt;&gt; {
</span><span class="boring">    ///     Err(io::Error::from(io::ErrorKind::NotFound))?;
</span><span class="boring">    ///     Ok(())
</span><span class="boring">    /// }
</span><span class="boring">    ///
</span><span class="boring">    /// chainerror::str_context!(Func2Error);
</span><span class="boring">    ///
</span><span class="boring">    /// fn func2() -&gt; Result&lt;(), Box&lt;dyn Error + Send + Sync&gt;&gt; {
</span><span class="boring">    ///     let filename = &quot;foo.txt&quot;;
</span><span class="boring">    ///     do_some_io().context(Func2Error(format!(&quot;Error reading '{}'&quot;, filename)))?;
</span><span class="boring">    ///     Ok(())
</span><span class="boring">    /// }
</span><span class="boring">    ///
</span><span class="boring">    /// chainerror::str_context!(Func1Error);
</span><span class="boring">    ///
</span><span class="boring">    /// fn func1() -&gt; Result&lt;(), Box&lt;dyn Error + Send + Sync&gt;&gt; {
</span><span class="boring">    ///     func2().context(Func1Error::new(&quot;func1 error&quot;))?;
</span><span class="boring">    ///     Ok(())
</span><span class="boring">    /// }
</span><span class="boring">    ///
</span><span class="boring">    /// if let Err(e) = func1() {
</span><span class="boring">    ///     if let Some(f1err) = e.downcast_chain_ref::&lt;Func1Error&gt;() {
</span><span class="boring">    ///         assert!(f1err.find_cause::&lt;io::Error&gt;().is_some());
</span><span class="boring">    ///
</span><span class="boring">    ///         assert!(f1err.find_chain_cause::&lt;Func2Error&gt;().is_some());
</span><span class="boring">    ///     }
</span><span class="boring">    /// #        else {
</span><span class="boring">    /// #            panic!();
</span><span class="boring">    /// #        }
</span><span class="boring">    /// }
</span><span class="boring">    /// #    else {
</span><span class="boring">    /// #         unreachable!();
</span><span class="boring">    /// #    }
</span><span class="boring">    /// ```
</span><span class="boring">    #[inline]
</span><span class="boring">    pub fn find_cause&lt;U: StdError + 'static&gt;(&amp;self) -&gt; Option&lt;&amp;U&gt; {
</span><span class="boring">        self.iter()
</span><span class="boring">            .filter_map(&lt;dyn StdError&gt;::downcast_ref::&lt;U&gt;)
</span><span class="boring">            .next()
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    /// Find the first error cause of type [`Error&lt;U&gt;`](Error), if any exists
</span><span class="boring">    ///
</span><span class="boring">    /// Same as `find_cause`, but hides the [`Error&lt;U&gt;`](Error) implementation internals
</span><span class="boring">    ///
</span><span class="boring">    /// # Examples
</span><span class="boring">    ///
</span><span class="boring">    /// ```rust
</span><span class="boring">    /// # chainerror::str_context!(FooError);
</span><span class="boring">    /// # let err = chainerror::Error::new(String::new(), None, None);
</span><span class="boring">    /// // Instead of writing
</span><span class="boring">    /// err.find_cause::&lt;chainerror::Error&lt;FooError&gt;&gt;();
</span><span class="boring">    ///
</span><span class="boring">    /// // leave out the chainerror::Error&lt;FooError&gt; implementation detail
</span><span class="boring">    /// err.find_chain_cause::&lt;FooError&gt;();
</span><span class="boring">    /// ```
</span><span class="boring">    #[inline]
</span><span class="boring">    pub fn find_chain_cause&lt;U: StdError + 'static&gt;(&amp;self) -&gt; Option&lt;&amp;Error&lt;U&gt;&gt; {
</span><span class="boring">        self.iter()
</span><span class="boring">            .filter_map(&lt;dyn StdError&gt;::downcast_ref::&lt;Error&lt;U&gt;&gt;)
</span><span class="boring">            .next()
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    /// Find the first error cause of type [`Error&lt;U&gt;`](Error) or `U`, if any exists and return `U`
</span><span class="boring">    ///
</span><span class="boring">    /// Same as `find_cause` and `find_chain_cause`, but hides the [`Error&lt;U&gt;`](Error) implementation internals
</span><span class="boring">    ///
</span><span class="boring">    /// # Examples
</span><span class="boring">    ///
</span><span class="boring">    /// ```rust
</span><span class="boring">    /// # chainerror::str_context!(FooErrorKind);
</span><span class="boring">    /// # let err = chainerror::Error::new(String::new(), None, None);
</span><span class="boring">    /// // Instead of writing
</span><span class="boring">    /// err.find_cause::&lt;chainerror::Error&lt;FooErrorKind&gt;&gt;();
</span><span class="boring">    /// // and/or
</span><span class="boring">    /// err.find_chain_cause::&lt;FooErrorKind&gt;();
</span><span class="boring">    /// // and/or
</span><span class="boring">    /// err.find_cause::&lt;FooErrorKind&gt;();
</span><span class="boring">    ///
</span><span class="boring">    /// // leave out the chainerror::Error&lt;FooErrorKind&gt; implementation detail
</span><span class="boring">    /// err.find_kind_or_cause::&lt;FooErrorKind&gt;();
</span><span class="boring">    /// ```
</span><span class="boring">    #[inline]
</span><span class="boring">    pub fn find_kind_or_cause&lt;U: StdError + 'static&gt;(&amp;self) -&gt; Option&lt;&amp;U&gt; {
</span><span class="boring">        self.iter()
</span><span class="boring">            .filter_map(|e| {
</span><span class="boring">                e.downcast_ref::&lt;Error&lt;U&gt;&gt;()
</span><span class="boring">                    .map(|e| e.kind())
</span><span class="boring">                    .or_else(|| e.downcast_ref::&lt;U&gt;())
</span><span class="boring">            })
</span><span class="boring">            .next()
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    /// Return a reference to T of [`Error&lt;T&gt;`](Error)
</span><span class="boring">    ///
</span><span class="boring">    /// # Examples
</span><span class="boring">    ///
</span><span class="boring">    /// ```rust
</span><span class="boring">    /// use chainerror::Context as _;
</span><span class="boring">    /// use std::error::Error;
</span><span class="boring">    /// use std::io;
</span><span class="boring">    ///
</span><span class="boring">    /// fn do_some_io() -&gt; Result&lt;(), Box&lt;dyn Error + Send + Sync&gt;&gt; {
</span><span class="boring">    ///     Err(io::Error::from(io::ErrorKind::NotFound))?;
</span><span class="boring">    ///     Ok(())
</span><span class="boring">    /// }
</span><span class="boring">    ///
</span><span class="boring">    /// chainerror::str_context!(Func2Error);
</span><span class="boring">    ///
</span><span class="boring">    /// fn func2() -&gt; Result&lt;(), Box&lt;dyn Error + Send + Sync&gt;&gt; {
</span><span class="boring">    ///     let filename = &quot;foo.txt&quot;;
</span><span class="boring">    ///     do_some_io().context(Func2Error(format!(&quot;Error reading '{}'&quot;, filename)))?;
</span><span class="boring">    ///     Ok(())
</span><span class="boring">    /// }
</span><span class="boring">    ///
</span><span class="boring">    /// #[derive(Debug)]
</span><span class="boring">    /// enum Func1ErrorKind {
</span><span class="boring">    ///     Func2,
</span><span class="boring">    ///     IO(String),
</span><span class="boring">    /// }
</span><span class="boring">    ///
</span><span class="boring">    /// /// impl ::std::fmt::Display for Func1ErrorKind {…}
</span><span class="boring">    /// # impl ::std::fmt::Display for Func1ErrorKind {
</span><span class="boring">    /// #     fn fmt(&amp;self, f: &amp;mut ::std::fmt::Formatter) -&gt; ::std::fmt::Result {
</span><span class="boring">    /// #         match self {
</span><span class="boring">    /// #             Func1ErrorKind::Func2 =&gt; write!(f, &quot;func1 error calling func2&quot;),
</span><span class="boring">    /// #             Func1ErrorKind::IO(filename) =&gt; write!(f, &quot;Error reading '{}'&quot;, filename),
</span><span class="boring">    /// #         }
</span><span class="boring">    /// #     }
</span><span class="boring">    /// # }
</span><span class="boring">    ///
</span><span class="boring">    /// fn func1() -&gt; chainerror::Result&lt;(), Func1ErrorKind&gt; {
</span><span class="boring">    ///     func2().context(Func1ErrorKind::Func2)?;
</span><span class="boring">    ///     do_some_io().context(Func1ErrorKind::IO(&quot;bar.txt&quot;.into()))?;
</span><span class="boring">    ///     Ok(())
</span><span class="boring">    /// }
</span><span class="boring">    ///
</span><span class="boring">    /// if let Err(e) = func1() {
</span><span class="boring">    ///     match e.kind() {
</span><span class="boring">    ///         Func1ErrorKind::Func2 =&gt; {}
</span><span class="boring">    ///         Func1ErrorKind::IO(filename) =&gt; panic!(),
</span><span class="boring">    ///     }
</span><span class="boring">    /// }
</span><span class="boring">    /// #    else {
</span><span class="boring">    /// #         unreachable!();
</span><span class="boring">    /// #    }
</span><span class="boring">    /// ```
</span><span class="boring">    #[inline]
</span><span class="boring">    pub fn kind(&amp;self) -&gt; &amp;T {
</span><span class="boring">        &amp;self.kind
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    /// Returns an Iterator over all error causes/sources
</span><span class="boring">    ///
</span><span class="boring">    /// # Example
</span><span class="boring">    #[inline]
</span><span class="boring">    pub fn iter(&amp;self) -&gt; impl Iterator&lt;Item = &amp;(dyn StdError + 'static)&gt; {
</span><span class="boring">        ErrorIter {
</span><span class="boring">            current: Some(self),
</span><span class="boring">        }
</span><span class="boring">    }
</span><span class="boring">}
</span><span class="boring">
</span><span class="boring">/// Convenience methods for `Result&lt;&gt;` to turn the error into a decorated [`Error`](Error)
</span><span class="boring">pub trait Context&lt;O, E: Into&lt;Box&lt;dyn StdError + 'static + Send + Sync&gt;&gt;&gt; {
</span><span class="boring">    /// Decorate the error with a `kind` of type `T` and the source `Location`
</span><span class="boring">    fn context&lt;T: 'static + Display + Debug&gt;(self, kind: T) -&gt; std::result::Result&lt;O, Error&lt;T&gt;&gt;;
</span><span class="boring">
</span><span class="boring">    /// Decorate the error just with the source `Location`
</span><span class="boring">    fn annotate(self) -&gt; std::result::Result&lt;O, Error&lt;AnnotatedError&gt;&gt;;
</span><span class="boring">
</span><span class="boring">    /// Decorate the `error` with a `kind` of type `T` produced with a `FnOnce(&amp;error)` and the source `Location`
</span><span class="boring">    fn map_context&lt;T: 'static + Display + Debug, F: FnOnce(&amp;E) -&gt; T&gt;(
</span><span class="boring">        self,
</span><span class="boring">        op: F,
</span><span class="boring">    ) -&gt; std::result::Result&lt;O, Error&lt;T&gt;&gt;;
</span><span class="boring">}
</span><span class="boring">
</span><span class="boring">/// Convenience type to just decorate the error with the source `Location`
</span><span class="boring">pub struct AnnotatedError(());
</span><span class="boring">
</span><span class="boring">impl Display for AnnotatedError {
</span><span class="boring">    fn fmt(&amp;self, f: &amp;mut Formatter&lt;'_&gt;) -&gt; std::fmt::Result {
</span><span class="boring">        write!(f, &quot;(passed error)&quot;)
</span><span class="boring">    }
</span><span class="boring">}
</span><span class="boring">
</span><span class="boring">impl Debug for AnnotatedError {
</span><span class="boring">    fn fmt(&amp;self, f: &amp;mut Formatter&lt;'_&gt;) -&gt; std::fmt::Result {
</span><span class="boring">        write!(f, &quot;(passed error)&quot;)
</span><span class="boring">    }
</span><span class="boring">}
</span><span class="boring">
</span><span class="boring">impl&lt;O, E: Into&lt;Box&lt;dyn StdError + 'static + Send + Sync&gt;&gt;&gt; Context&lt;O, E&gt;
</span><span class="boring">    for std::result::Result&lt;O, E&gt;
</span><span class="boring">{
</span><span class="boring">    #[track_caller]
</span><span class="boring">    #[inline]
</span><span class="boring">    fn context&lt;T: 'static + Display + Debug&gt;(self, kind: T) -&gt; std::result::Result&lt;O, Error&lt;T&gt;&gt; {
</span><span class="boring">        match self {
</span><span class="boring">            Ok(t) =&gt; Ok(t),
</span><span class="boring">            Err(error_cause) =&gt; Err(Error::new(
</span><span class="boring">                kind,
</span><span class="boring">                Some(error_cause.into()),
</span><span class="boring">                Some(Location::caller().to_string()),
</span><span class="boring">            )),
</span><span class="boring">        }
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    #[track_caller]
</span><span class="boring">    #[inline]
</span><span class="boring">    fn annotate(self) -&gt; std::result::Result&lt;O, Error&lt;AnnotatedError&gt;&gt; {
</span><span class="boring">        match self {
</span><span class="boring">            Ok(t) =&gt; Ok(t),
</span><span class="boring">            Err(error_cause) =&gt; Err(Error::new(
</span><span class="boring">                AnnotatedError(()),
</span><span class="boring">                Some(error_cause.into()),
</span><span class="boring">                Some(Location::caller().to_string()),
</span><span class="boring">            )),
</span><span class="boring">        }
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    #[track_caller]
</span><span class="boring">    #[inline]
</span><span class="boring">    fn map_context&lt;T: 'static + Display + Debug, F: FnOnce(&amp;E) -&gt; T&gt;(
</span><span class="boring">        self,
</span><span class="boring">        op: F,
</span><span class="boring">    ) -&gt; std::result::Result&lt;O, Error&lt;T&gt;&gt; {
</span><span class="boring">        match self {
</span><span class="boring">            Ok(t) =&gt; Ok(t),
</span><span class="boring">            Err(error_cause) =&gt; {
</span><span class="boring">                let kind = op(&amp;error_cause);
</span><span class="boring">                Err(Error::new(
</span><span class="boring">                    kind,
</span><span class="boring">                    Some(error_cause.into()),
</span><span class="boring">                    Some(Location::caller().to_string()),
</span><span class="boring">                ))
</span><span class="boring">            }
</span><span class="boring">        }
</span><span class="boring">    }
</span><span class="boring">}
</span><span class="boring">
</span><span class="boring">/// An iterator over all error causes/sources
</span><span class="boring">pub struct ErrorIter&lt;'a&gt; {
</span><span class="boring">    current: Option&lt;&amp;'a (dyn StdError + 'static)&gt;,
</span><span class="boring">}
</span><span class="boring">
</span><span class="boring">impl&lt;'a&gt; Iterator for ErrorIter&lt;'a&gt; {
</span><span class="boring">    type Item = &amp;'a (dyn StdError + 'static);
</span><span class="boring">
</span><span class="boring">    #[inline]
</span><span class="boring">    fn next(&amp;mut self) -&gt; Option&lt;Self::Item&gt; {
</span><span class="boring">        let current = self.current;
</span><span class="boring">        self.current = self.current.and_then(StdError::source);
</span><span class="boring">        current
</span><span class="boring">    }
</span><span class="boring">}
</span><span class="boring">
</span><span class="boring">impl&lt;T: 'static + Display + Debug&gt; std::ops::Deref for Error&lt;T&gt; {
</span><span class="boring">    type Target = T;
</span><span class="boring">
</span><span class="boring">    #[inline]
</span><span class="boring">    fn deref(&amp;self) -&gt; &amp;Self::Target {
</span><span class="boring">        &amp;self.kind
</span><span class="boring">    }
</span><span class="boring">}
</span><span class="boring">
</span><span class="boring">/// Convenience trait to hide the [`Error&lt;T&gt;`](Error) implementation internals
</span><span class="boring">pub trait ErrorDown {
</span><span class="boring">    /// Test if of type `Error&lt;T&gt;`
</span><span class="boring">    fn is_chain&lt;T: 'static + Display + Debug&gt;(&amp;self) -&gt; bool;
</span><span class="boring">    /// Downcast to a reference of `Error&lt;T&gt;`
</span><span class="boring">    fn downcast_chain_ref&lt;T: 'static + Display + Debug&gt;(&amp;self) -&gt; Option&lt;&amp;Error&lt;T&gt;&gt;;
</span><span class="boring">    /// Downcast to a mutable reference of `Error&lt;T&gt;`
</span><span class="boring">    fn downcast_chain_mut&lt;T: 'static + Display + Debug&gt;(&amp;mut self) -&gt; Option&lt;&amp;mut Error&lt;T&gt;&gt;;
</span><span class="boring">    /// Downcast to T of `Error&lt;T&gt;`
</span><span class="boring">    fn downcast_inner_ref&lt;T: 'static + StdError&gt;(&amp;self) -&gt; Option&lt;&amp;T&gt;;
</span><span class="boring">    /// Downcast to T mutable reference of `Error&lt;T&gt;`
</span><span class="boring">    fn downcast_inner_mut&lt;T: 'static + StdError&gt;(&amp;mut self) -&gt; Option&lt;&amp;mut T&gt;;
</span><span class="boring">}
</span><span class="boring">
</span><span class="boring">impl&lt;U: 'static + Display + Debug&gt; ErrorDown for Error&lt;U&gt; {
</span><span class="boring">    #[inline]
</span><span class="boring">    fn is_chain&lt;T: 'static + Display + Debug&gt;(&amp;self) -&gt; bool {
</span><span class="boring">        TypeId::of::&lt;T&gt;() == TypeId::of::&lt;U&gt;()
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    #[inline]
</span><span class="boring">    fn downcast_chain_ref&lt;T: 'static + Display + Debug&gt;(&amp;self) -&gt; Option&lt;&amp;Error&lt;T&gt;&gt; {
</span><span class="boring">        if self.is_chain::&lt;T&gt;() {
</span><span class="boring">            #[allow(clippy::cast_ptr_alignment)]
</span><span class="boring">            unsafe {
</span><span class="boring">                #[allow(trivial_casts)]
</span><span class="boring">                Some(*(self as *const dyn StdError as *const &amp;Error&lt;T&gt;))
</span><span class="boring">            }
</span><span class="boring">        } else {
</span><span class="boring">            None
</span><span class="boring">        }
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    #[inline]
</span><span class="boring">    fn downcast_chain_mut&lt;T: 'static + Display + Debug&gt;(&amp;mut self) -&gt; Option&lt;&amp;mut Error&lt;T&gt;&gt; {
</span><span class="boring">        if self.is_chain::&lt;T&gt;() {
</span><span class="boring">            #[allow(clippy::cast_ptr_alignment)]
</span><span class="boring">            unsafe {
</span><span class="boring">                #[allow(trivial_casts)]
</span><span class="boring">                Some(&amp;mut *(self as *mut dyn StdError as *mut &amp;mut Error&lt;T&gt;))
</span><span class="boring">            }
</span><span class="boring">        } else {
</span><span class="boring">            None
</span><span class="boring">        }
</span><span class="boring">    }
</span><span class="boring">    #[inline]
</span><span class="boring">    fn downcast_inner_ref&lt;T: 'static + StdError&gt;(&amp;self) -&gt; Option&lt;&amp;T&gt; {
</span><span class="boring">        if self.is_chain::&lt;T&gt;() {
</span><span class="boring">            #[allow(clippy::cast_ptr_alignment)]
</span><span class="boring">            unsafe {
</span><span class="boring">                #[allow(trivial_casts)]
</span><span class="boring">                Some(&amp;(*(self as *const dyn StdError as *const &amp;Error&lt;T&gt;)).kind)
</span><span class="boring">            }
</span><span class="boring">        } else {
</span><span class="boring">            None
</span><span class="boring">        }
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    #[inline]
</span><span class="boring">    fn downcast_inner_mut&lt;T: 'static + StdError&gt;(&amp;mut self) -&gt; Option&lt;&amp;mut T&gt; {
</span><span class="boring">        if self.is_chain::&lt;T&gt;() {
</span><span class="boring">            #[allow(clippy::cast_ptr_alignment)]
</span><span class="boring">            unsafe {
</span><span class="boring">                #[allow(trivial_casts)]
</span><span class="boring">                Some(&amp;mut (*(self as *mut dyn StdError as *mut &amp;mut Error&lt;T&gt;)).kind)
</span><span class="boring">            }
</span><span class="boring">        } else {
</span><span class="boring">            None
</span><span class="boring">        }
</span><span class="boring">    }
</span><span class="boring">}
</span><span class="boring">
</span><span class="boring">impl ErrorDown for dyn StdError + 'static {
</span><span class="boring">    #[inline]
</span><span class="boring">    fn is_chain&lt;T: 'static + Display + Debug&gt;(&amp;self) -&gt; bool {
</span><span class="boring">        self.is::&lt;Error&lt;T&gt;&gt;()
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    #[inline]
</span><span class="boring">    fn downcast_chain_ref&lt;T: 'static + Display + Debug&gt;(&amp;self) -&gt; Option&lt;&amp;Error&lt;T&gt;&gt; {
</span><span class="boring">        self.downcast_ref::&lt;Error&lt;T&gt;&gt;()
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    #[inline]
</span><span class="boring">    fn downcast_chain_mut&lt;T: 'static + Display + Debug&gt;(&amp;mut self) -&gt; Option&lt;&amp;mut Error&lt;T&gt;&gt; {
</span><span class="boring">        self.downcast_mut::&lt;Error&lt;T&gt;&gt;()
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    #[inline]
</span><span class="boring">    fn downcast_inner_ref&lt;T: 'static + StdError&gt;(&amp;self) -&gt; Option&lt;&amp;T&gt; {
</span><span class="boring">        self.downcast_ref::&lt;T&gt;()
</span><span class="boring">            .or_else(|| self.downcast_ref::&lt;Error&lt;T&gt;&gt;().map(|e| e.kind()))
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    #[inline]
</span><span class="boring">    fn downcast_inner_mut&lt;T: 'static + StdError&gt;(&amp;mut self) -&gt; Option&lt;&amp;mut T&gt; {
</span><span class="boring">        if self.is::&lt;T&gt;() {
</span><span class="boring">            return self.downcast_mut::&lt;T&gt;();
</span><span class="boring">        }
</span><span class="boring">
</span><span class="boring">        self.downcast_mut::&lt;Error&lt;T&gt;&gt;()
</span><span class="boring">            .and_then(|e| e.downcast_inner_mut::&lt;T&gt;())
</span><span class="boring">    }
</span><span class="boring">}
</span><span class="boring">
</span><span class="boring">impl ErrorDown for dyn StdError + 'static + Send {
</span><span class="boring">    #[inline]
</span><span class="boring">    fn is_chain&lt;T: 'static + Display + Debug&gt;(&amp;self) -&gt; bool {
</span><span class="boring">        self.is::&lt;Error&lt;T&gt;&gt;()
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    #[inline]
</span><span class="boring">    fn downcast_chain_ref&lt;T: 'static + Display + Debug&gt;(&amp;self) -&gt; Option&lt;&amp;Error&lt;T&gt;&gt; {
</span><span class="boring">        self.downcast_ref::&lt;Error&lt;T&gt;&gt;()
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    #[inline]
</span><span class="boring">    fn downcast_chain_mut&lt;T: 'static + Display + Debug&gt;(&amp;mut self) -&gt; Option&lt;&amp;mut Error&lt;T&gt;&gt; {
</span><span class="boring">        self.downcast_mut::&lt;Error&lt;T&gt;&gt;()
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    #[inline]
</span><span class="boring">    fn downcast_inner_ref&lt;T: 'static + StdError&gt;(&amp;self) -&gt; Option&lt;&amp;T&gt; {
</span><span class="boring">        self.downcast_ref::&lt;T&gt;()
</span><span class="boring">            .or_else(|| self.downcast_ref::&lt;Error&lt;T&gt;&gt;().map(|e| e.kind()))
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    #[inline]
</span><span class="boring">    fn downcast_inner_mut&lt;T: 'static + StdError&gt;(&amp;mut self) -&gt; Option&lt;&amp;mut T&gt; {
</span><span class="boring">        if self.is::&lt;T&gt;() {
</span><span class="boring">            return self.downcast_mut::&lt;T&gt;();
</span><span class="boring">        }
</span><span class="boring">
</span><span class="boring">        self.downcast_mut::&lt;Error&lt;T&gt;&gt;()
</span><span class="boring">            .and_then(|e| e.downcast_inner_mut::&lt;T&gt;())
</span><span class="boring">    }
</span><span class="boring">}
</span><span class="boring">
</span><span class="boring">impl ErrorDown for dyn StdError + 'static + Send + Sync {
</span><span class="boring">    #[inline]
</span><span class="boring">    fn is_chain&lt;T: 'static + Display + Debug&gt;(&amp;self) -&gt; bool {
</span><span class="boring">        self.is::&lt;Error&lt;T&gt;&gt;()
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    #[inline]
</span><span class="boring">    fn downcast_chain_ref&lt;T: 'static + Display + Debug&gt;(&amp;self) -&gt; Option&lt;&amp;Error&lt;T&gt;&gt; {
</span><span class="boring">        self.downcast_ref::&lt;Error&lt;T&gt;&gt;()
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    #[inline]
</span><span class="boring">    fn downcast_chain_mut&lt;T: 'static + Display + Debug&gt;(&amp;mut self) -&gt; Option&lt;&amp;mut Error&lt;T&gt;&gt; {
</span><span class="boring">        self.downcast_mut::&lt;Error&lt;T&gt;&gt;()
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    #[inline]
</span><span class="boring">    fn downcast_inner_ref&lt;T: 'static + StdError&gt;(&amp;self) -&gt; Option&lt;&amp;T&gt; {
</span><span class="boring">        self.downcast_ref::&lt;T&gt;()
</span><span class="boring">            .or_else(|| self.downcast_ref::&lt;Error&lt;T&gt;&gt;().map(|e| e.kind()))
</span><span class="boring">    }
</span><span class="boring">
</span><span class="boring">    #[inline]
</span><span class="boring">    fn downcast_inner_mut&lt;T: 'static + StdError&gt;(&amp;mut self) -&gt; Option&lt;&amp;mut T&gt; {
</span><span class="boring">        if self.is::&lt;T&gt;() {
</span><span class="boring">            return self.downcast_mut::&lt;T&gt;();
</span><span class="boring">        }
</span><span class="boring">
</span><span class="boring">        self.downcast_mut::&lt;Error&lt;T&gt;&gt;()
</span><span class="boring">            .and_then(|e| e.downcast_inner_mut::&lt;T&gt;())
</span><span class="boring">    }
</span><span class="boring">}
</span><span class="boring">
</span><span class="boring">impl&lt;T: 'static + Display + Debug&gt; StdError for Error&lt;T&gt; {
</span><span class="boring">    #[inline]
</span><span class="boring">    fn source(&amp;self) -&gt; Option&lt;&amp;(dyn StdError + 'static)&gt; {
</span><span class="boring">        self.error_cause
</span><span class="boring">            .as_ref()
</span><span class="boring">            .map(|e| e.as_ref() as &amp;(dyn StdError + 'static))
</span><span class="boring">    }
</span><span class="boring">}
</span><span class="boring">
</span><span class="boring">impl&lt;T: 'static + Display + Debug&gt; StdError for &amp;mut Error&lt;T&gt; {
</span><span class="boring">    #[inline]
</span><span class="boring">    fn source(&amp;self) -&gt; Option&lt;&amp;(dyn StdError + 'static)&gt; {
</span><span class="boring">        self.error_cause
</span><span class="boring">            .as_ref()
</span><span class="boring">            .map(|e| e.as_ref() as &amp;(dyn StdError + 'static))
</span><span class="boring">    }
</span><span class="boring">}
</span><span class="boring">
</span><span class="boring">impl&lt;T: 'static + Display + Debug&gt; Display for Error&lt;T&gt; {
</span><span class="boring">    #[inline]
</span><span class="boring">    fn fmt(&amp;self, f: &amp;mut Formatter&lt;'_&gt;) -&gt; std::fmt::Result {
</span><span class="boring">        write!(f, &quot;{}&quot;, self.kind)?;
</span><span class="boring">
</span><span class="boring">        if f.alternate() {
</span><span class="boring">            if let Some(e) = self.source() {
</span><span class="boring">                write!(f, &quot;\nCaused by:\n  {:#}&quot;, &amp;e)?;
</span><span class="boring">            }
</span><span class="boring">        }
</span><span class="boring">
</span><span class="boring">        Ok(())
</span><span class="boring">    }
</span><span class="boring">}
</span><span class="boring">
</span><span class="boring">impl&lt;T: 'static + Display + Debug&gt; Debug for Error&lt;T&gt; {
</span><span class="boring">    #[inline]
</span><span class="boring">    fn fmt(&amp;self, f: &amp;mut Formatter&lt;'_&gt;) -&gt; std::fmt::Result {
</span><span class="boring">        if f.alternate() {
</span><span class="boring">            let mut f = f.debug_struct(&amp;format!(&quot;Error&lt;{}&gt;&quot;, std::any::type_name::&lt;T&gt;()));
</span><span class="boring">
</span><span class="boring">            let f = f
</span><span class="boring">                .field(&quot;occurrence&quot;, &amp;self.occurrence)
</span><span class="boring">                .field(&quot;kind&quot;, &amp;self.kind)
</span><span class="boring">                .field(&quot;source&quot;, &amp;self.source());
</span><span class="boring">
</span><span class="boring">            f.finish()
</span><span class="boring">        } else {
</span><span class="boring">            if let Some(ref o) = self.occurrence {
</span><span class="boring">                write!(f, &quot;{}: &quot;, o)?;
</span><span class="boring">            }
</span><span class="boring">
</span><span class="boring">            if TypeId::of::&lt;String&gt;() == TypeId::of::&lt;T&gt;()
</span><span class="boring">                || TypeId::of::&lt;&amp;str&gt;() == TypeId::of::&lt;T&gt;()
</span><span class="boring">            {
</span><span class="boring">                Display::fmt(&amp;self.kind, f)?;
</span><span class="boring">            } else {
</span><span class="boring">                Debug::fmt(&amp;self.kind, f)?;
</span><span class="boring">            }
</span><span class="boring">
</span><span class="boring">            if let Some(e) = self.source() {
</span><span class="boring">                write!(f, &quot;\nCaused by:\n{:?}&quot;, &amp;e)?;
</span><span class="boring">            }
</span><span class="boring">            Ok(())
</span><span class="boring">        }
</span><span class="boring">    }
</span><span class="boring">}
</span><span class="boring">
</span><span class="boring">impl&lt;T&gt; From&lt;T&gt; for Error&lt;T&gt;
</span><span class="boring">where
</span><span class="boring">    T: 'static + Display + Debug,
</span><span class="boring">{
</span><span class="boring">    #[track_caller]
</span><span class="boring">    #[inline]
</span><span class="boring">    fn from(e: T) -&gt; Error&lt;T&gt; {
</span><span class="boring">        Error::new(e, None, Some(Location::caller().to_string()))
</span><span class="boring">    }
</span><span class="boring">}
</span><span class="boring">/// Convenience macro to create a &quot;new type&quot; T(String) and implement Display + Debug for T
</span><span class="boring">///
</span><span class="boring">/// # Examples
</span><span class="boring">///
</span><span class="boring">/// ```rust
</span><span class="boring">/// # use chainerror::Context as _;
</span><span class="boring">/// # use chainerror::ErrorDown as _;
</span><span class="boring">/// # use std::error::Error;
</span><span class="boring">/// # use std::io;
</span><span class="boring">/// # use std::result::Result;
</span><span class="boring">/// # fn do_some_io() -&gt; Result&lt;(), Box&lt;dyn Error + Send + Sync&gt;&gt; {
</span><span class="boring">/// #     Err(io::Error::from(io::ErrorKind::NotFound))?;
</span><span class="boring">/// #     Ok(())
</span><span class="boring">/// # }
</span><span class="boring">/// chainerror::str_context!(Func2Error);
</span><span class="boring">///
</span><span class="boring">/// fn func2() -&gt; chainerror::Result&lt;(), Func2Error&gt; {
</span><span class="boring">///     let filename = &quot;foo.txt&quot;;
</span><span class="boring">///     do_some_io().context(Func2Error(format!(&quot;Error reading '{}'&quot;, filename)))?;
</span><span class="boring">///     Ok(())
</span><span class="boring">/// }
</span><span class="boring">///
</span><span class="boring">/// chainerror::str_context!(Func1Error);
</span><span class="boring">///
</span><span class="boring">/// fn func1() -&gt; Result&lt;(), Box&lt;dyn Error&gt;&gt; {
</span><span class="boring">///     func2().context(Func1Error::new(&quot;func1 error&quot;))?;
</span><span class="boring">///     Ok(())
</span><span class="boring">/// }
</span><span class="boring">/// #     if let Err(e) = func1() {
</span><span class="boring">/// #         if let Some(f1err) = e.downcast_chain_ref::&lt;Func1Error&gt;() {
</span><span class="boring">/// #             assert!(f1err.find_cause::&lt;chainerror::Error&lt;Func2Error&gt;&gt;().is_some());
</span><span class="boring">/// #             assert!(f1err.find_chain_cause::&lt;Func2Error&gt;().is_some());
</span><span class="boring">/// #         } else {
</span><span class="boring">/// #             panic!();
</span><span class="boring">/// #         }
</span><span class="boring">/// #     } else {
</span><span class="boring">/// #         unreachable!();
</span><span class="boring">/// #     }
</span><span class="boring">/// ```
</span><span class="boring">#[macro_export]
</span><span class="boring">macro_rules! str_context {
</span><span class="boring">    ($e:ident) =&gt; {
</span><span class="boring">        #[derive(Clone)]
</span><span class="boring">        pub struct $e(pub String);
</span><span class="boring">        impl $e {
</span><span class="boring">            pub fn new&lt;S: Into&lt;String&gt;&gt;(s: S) -&gt; Self {
</span><span class="boring">                $e(s.into())
</span><span class="boring">            }
</span><span class="boring">        }
</span><span class="boring">        impl ::std::fmt::Display for $e {
</span><span class="boring">            fn fmt(&amp;self, f: &amp;mut ::std::fmt::Formatter) -&gt; ::std::fmt::Result {
</span><span class="boring">                write!(f, &quot;{}&quot;, self.0)
</span><span class="boring">            }
</span><span class="boring">        }
</span><span class="boring">        impl ::std::fmt::Debug for $e {
</span><span class="boring">            fn fmt(&amp;self, f: &amp;mut ::std::fmt::Formatter) -&gt; ::std::fmt::Result {
</span><span class="boring">                write!(f, &quot;{}({})&quot;, stringify!($e), self.0)
</span><span class="boring">            }
</span><span class="boring">        }
</span><span class="boring">        impl ::std::error::Error for $e {}
</span><span class="boring">    };
</span><span class="boring">}
</span><span class="boring">
</span><span class="boring">/// Derive an Error for an ErrorKind, which wraps a [`Error`](Error) and implements a `kind()` method
</span><span class="boring">///
</span><span class="boring">/// It basically hides [`Error`](Error) to the outside and only exposes the [`kind()`](Error::kind)
</span><span class="boring">/// method.
</span><span class="boring">///
</span><span class="boring">/// Error::kind() returns the ErrorKind
</span><span class="boring">/// Error::source() returns the parent error
</span><span class="boring">///
</span><span class="boring">/// # Examples
</span><span class="boring">///
</span><span class="boring">/// ```rust
</span><span class="boring">/// use chainerror::Context as _;
</span><span class="boring">/// use std::io;
</span><span class="boring">///
</span><span class="boring">/// fn do_some_io(_f: &amp;str) -&gt; std::result::Result&lt;(), io::Error&gt; {
</span><span class="boring">///     return Err(io::Error::from(io::ErrorKind::NotFound));
</span><span class="boring">/// }
</span><span class="boring">///
</span><span class="boring">/// #[derive(Debug, Clone)]
</span><span class="boring">/// pub enum ErrorKind {
</span><span class="boring">///     IO(String),
</span><span class="boring">///     FatalError(String),
</span><span class="boring">///     Unknown,
</span><span class="boring">/// }
</span><span class="boring">///
</span><span class="boring">/// chainerror::err_kind!(Error, ErrorKind);
</span><span class="boring">///
</span><span class="boring">/// impl std::fmt::Display for ErrorKind {
</span><span class="boring">///     fn fmt(&amp;self, f: &amp;mut ::std::fmt::Formatter) -&gt; std::fmt::Result {
</span><span class="boring">///         match self {
</span><span class="boring">///             ErrorKind::FatalError(e) =&gt; write!(f, &quot;fatal error {}&quot;, e),
</span><span class="boring">///             ErrorKind::Unknown =&gt; write!(f, &quot;unknown error&quot;),
</span><span class="boring">///             ErrorKind::IO(filename) =&gt; write!(f, &quot;Error reading '{}'&quot;, filename),
</span><span class="boring">///         }
</span><span class="boring">///     }
</span><span class="boring">/// }
</span><span class="boring">///
</span><span class="boring">/// impl ErrorKind {
</span><span class="boring">///     fn from_io_error(e: &amp;io::Error, f: String) -&gt; Self {
</span><span class="boring">///         match e.kind() {
</span><span class="boring">///             io::ErrorKind::BrokenPipe =&gt; panic!(&quot;Should not happen&quot;),
</span><span class="boring">///             io::ErrorKind::ConnectionReset =&gt; {
</span><span class="boring">///                 ErrorKind::FatalError(format!(&quot;While reading `{}`: {}&quot;, f, e))
</span><span class="boring">///             }
</span><span class="boring">///             _ =&gt; ErrorKind::IO(f),
</span><span class="boring">///         }
</span><span class="boring">///     }
</span><span class="boring">/// }
</span><span class="boring">///
</span><span class="boring">/// impl From&lt;&amp;io::Error&gt; for ErrorKind {
</span><span class="boring">///     fn from(e: &amp;io::Error) -&gt; Self {
</span><span class="boring">///         ErrorKind::IO(format!(&quot;{}&quot;, e))
</span><span class="boring">///     }
</span><span class="boring">/// }
</span><span class="boring">///
</span><span class="boring">/// pub fn func1() -&gt; std::result::Result&lt;(), Error&gt; {
</span><span class="boring">///     let filename = &quot;bar.txt&quot;;
</span><span class="boring">///
</span><span class="boring">///     do_some_io(filename).map_context(|e| ErrorKind::from_io_error(e, filename.into()))?;
</span><span class="boring">///     do_some_io(filename).map_context(|e| ErrorKind::IO(filename.into()))?;
</span><span class="boring">///     do_some_io(filename).map_context(|e| ErrorKind::from(e))?;
</span><span class="boring">///     Ok(())
</span><span class="boring">/// }
</span><span class="boring">/// ```
</span><span class="boring">#[macro_export]
</span><span class="boring">macro_rules! err_kind {
</span><span class="boring">    ($e:ident, $k:ident) =&gt; {
</span><span class="boring">        pub struct $e($crate::Error&lt;$k&gt;);
</span><span class="boring">
</span><span class="boring">        impl $e {
</span><span class="boring">            pub fn kind(&amp;self) -&gt; &amp;$k {
</span><span class="boring">                self.0.kind()
</span><span class="boring">            }
</span><span class="boring">        }
</span><span class="boring">
</span><span class="boring">        impl From&lt;$k&gt; for $e {
</span><span class="boring">            fn from(e: $k) -&gt; Self {
</span><span class="boring">                $e($crate::Error::new(e, None, None))
</span><span class="boring">            }
</span><span class="boring">        }
</span><span class="boring">
</span><span class="boring">        impl From&lt;$crate::Error&lt;$k&gt;&gt; for $e {
</span><span class="boring">            fn from(e: $crate::Error&lt;$k&gt;) -&gt; Self {
</span><span class="boring">                $e(e)
</span><span class="boring">            }
</span><span class="boring">        }
</span><span class="boring">
</span><span class="boring">        impl From&lt;&amp;$e&gt; for $k
</span><span class="boring">        where
</span><span class="boring">            $k: Clone,
</span><span class="boring">        {
</span><span class="boring">            fn from(e: &amp;$e) -&gt; Self {
</span><span class="boring">                e.kind().clone()
</span><span class="boring">            }
</span><span class="boring">        }
</span><span class="boring">
</span><span class="boring">        impl std::error::Error for $e {
</span><span class="boring">            fn source(&amp;self) -&gt; Option&lt;&amp;(dyn std::error::Error + 'static)&gt; {
</span><span class="boring">                self.0.source()
</span><span class="boring">            }
</span><span class="boring">        }
</span><span class="boring">
</span><span class="boring">        impl std::fmt::Display for $e {
</span><span class="boring">            fn fmt(&amp;self, f: &amp;mut std::fmt::Formatter) -&gt; std::fmt::Result {
</span><span class="boring">                std::fmt::Display::fmt(&amp;self.0, f)
</span><span class="boring">            }
</span><span class="boring">        }
</span><span class="boring">
</span><span class="boring">        impl std::fmt::Debug for $e {
</span><span class="boring">            fn fmt(&amp;self, f: &amp;mut std::fmt::Formatter) -&gt; std::fmt::Result {
</span><span class="boring">                std::fmt::Debug::fmt(&amp;self.0, f)
</span><span class="boring">            }
</span><span class="boring">        }
</span><span class="boring">    };
</span><span class="boring">}
</span><span class="boring">}</span></code></pre></pre>
<p>Note, that because we changed the output of the error in <code>main()</code> from 
<code>Debug</code> to <code>Display</code>, we don't see the error backtrace with filename and line number.</p>
<p>To use the <code>Display</code> backtrace, you have to use the alternative display format output <code>{:#}</code>.</p>

                    </main>

                    <nav class="nav-wrapper" aria-label="Page navigation">
                        <!-- Mobile navigation buttons -->
                            <a rel="prev" href="tutorial4.html" class="mobile-nav-chapters previous" title="Previous chapter" aria-label="Previous chapter" aria-keyshortcuts="Left">
                                <i class="fa fa-angle-left"></i>
                            </a>

                            <a rel="next" href="tutorial6.html" class="mobile-nav-chapters next" title="Next chapter" aria-label="Next chapter" aria-keyshortcuts="Right">
                                <i class="fa fa-angle-right"></i>
                            </a>

                        <div style="clear: both"></div>
                    </nav>
                </div>
            </div>

            <nav class="nav-wide-wrapper" aria-label="Page navigation">
                    <a rel="prev" href="tutorial4.html" class="nav-chapters previous" title="Previous chapter" aria-label="Previous chapter" aria-keyshortcuts="Left">
                        <i class="fa fa-angle-left"></i>
                    </a>

                    <a rel="next" href="tutorial6.html" class="nav-chapters next" title="Next chapter" aria-label="Next chapter" aria-keyshortcuts="Right">
                        <i class="fa fa-angle-right"></i>
                    </a>
            </nav>

        </div>




        <script>
            window.playground_copyable = true;
        </script>


        <script src="elasticlunr.min.js"></script>
        <script src="mark.min.js"></script>
        <script src="searcher.js"></script>

        <script src="clipboard.min.js"></script>
        <script src="highlight.js"></script>
        <script src="book.js"></script>

        <!-- Custom JS scripts -->


    </div>
    </body>
</html>