Why Use Structured Errors in Rust Applications?(home.expurple.me)

    use std::backtrace::Backtrace;
    use std::error::Error;
    use std::fmt::{Debug, Display};
    use std::num::ParseIntError;
    
    #[derive(Debug)]
    struct WithBacktrace<E> {
        source: E,
        backtrace: Backtrace,
    }
    
    impl<E> Display for WithBacktrace<E>
    where
        E: Display,
    {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            self.source.fmt(f)
        }
    }
    
    impl<E> Error for WithBacktrace<E>
    where
        E: Error + 'static,
    {
        fn source(&self) -> Option<&(dyn Error + 'static)> {
            Some(&self.source)
        }
    }
    
    impl<E> From<E> for WithBacktrace<E> {
        fn from(source: E) -> Self {
            Self {
                source,
                backtrace: Backtrace::capture(),
            }
        }
    }

    fn add_a_backtrace_to_another_error() -> Result<(), WithBacktrace<ParseIntError>> {
        let num = "not_a_number".parse::<i64>()?;
        Ok(())
    }

    #[derive(Debug, thiserror::Error)]
    #[error("encountered a `None` value")]
    struct NoneError;
    
    fn backtrace_on_none() -> Result<(), WithBacktrace<NoneError>> {
        None.ok_or(NoneError)?
    }