//! Create a simple error enum that is a composite of other errors.
//! ```rust
//! # use composite_error::composite_error;
//! composite_error! {
//!     MyError {
//!         IoError: std::io::Error,
//!         Other: String,
//!     }
//! }
//!
//! let e = MyError::Other("This is an error".into());
//! println!("{}", e);
//! ```

#[macro_export]
macro_rules! composite_error {
    ($name:ident { $($variant:ident: $error:ty,)* }) => {
        enum $name {
            $($variant($error)),*
        }
        
        impl std::fmt::Display for $name {
            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::result::Result<(), std::fmt::Error> {
                let (variant, value) = match self {
                    $(Self::$variant(e) => (stringify!($variant), e.to_string())),*
                };

                std::write!(f, "{}: {}", variant, value)
            }
        }

        $(
        impl std::convert::From<$error> for $name {
            fn from(e: $error) -> Self {
                Self::$variant(e)
            }
        }
        )*
    };
    (#[derive($($derives:path),*)] $name:ident { $($variant:ident: $error:ty,)* }) => {
        #[derive($($derives),*)]
        enum $name {
            $($variant($error)),*
        }
        
        impl std::fmt::Display for $name {
            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::result::Result<(), std::fmt::Error> {
                let (variant, value) = match self {
                    $(Self::$variant(e) => (stringify!($variant), e.to_string())),*
                };

                std::write!(f, "{}: {}", variant, value)
            }
        }

        $(
        impl std::convert::From<$error> for $name {
            fn from(e: $error) -> Self {
                Self::$variant(e)
            }
        }
        )*
    };
}

#[cfg(test)]
mod tests {
    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }
}