wrapped_enum

//! wrapped_enum! - Wrap multiple types into an Enum //! //! This is useful when returning multiple types. //! simply to just work on an enum of known types. //! //! Documentation is required when using public enums //! //! //! # #[macro_use] extern crate wrapped_enum; //! # use std::io; //! #[derive(Debug)] //! pub enum TestError { //! ErrorA, //! ErrorB(u8, u16), //! ErrorC(String), //! } //! //! wrapped_enum!{ //! #[derive(Debug)] //! /// Document your pub enums //! pub enum DocumentedEnum { //! /// Variants too //! Io(io::Error), //! /// Documentation is required for pub enums //! Test(TestError), //! /// Unknown error //! Unknown(()), //! } //! } //! //! wrapped_enum!{ //! #[derive(Debug, Eq, PartialEq)] //! /// You can't document private variants //! enum UndocumentedEnum { //! // However, there is nothing wrong with normal comments //! Byte(u8), // 00-FF //! DoubleByte(u16), // 0000-FFFF //! } //! } //! //! # fn main() { //! assert!(UndocumentedEnum::from(0u8) == UndocumentedEnum::Byte(0)); //! assert!(UndocumentedEnum::from(0u16) == UndocumentedEnum::DoubleByte(0)); //! # } //!

#[macro_export] macro_rules! wrapped_enum { ($(#[$attr:meta])* pub enum $enum_name:ident { $($(#[$variant_attr:meta])+ $enum_variant_name:ident($ty:ty)),+ $(,)* } ) => ( $(#[$attr])* pub enum $enum_name { $($(#[$variant_attr])+ $enum_variant_name($ty)),+ } $(impl From<$ty> for $enum_name { fn from (ty: $ty) -> Self { $enum_name::$enum_variant_name(ty) } })+ ); ($(#[$attr:meta])* enum $enum_name:ident { $($enum_variant_name:ident($ty:ty)),+ $(,)* } ) => ( $(#[$attr])* enum $enum_name { $($enum_variant_name($ty)),+ } $(impl From<$ty> for $enum_name { fn from (ty: $ty) -> Self { $enum_name::$enum_variant_name(ty) } })+ ); }

#[cfg(test)] mod test { #[derive(Debug)] #[allow(dead_code)] pub enum CommunicationError { HumanError(Human, ErrorAction), UnknownError, }

#[derive(Debug)]
#[allow(dead_code)]
pub enum ErrorAction {
    AttemptedToStealSecrets,
    StoleSecrets,
}

#[derive(Debug)]
#[allow(dead_code)]
pub enum Human {
    Alice, // Good
    Bob,   // Good
    Carol, // Good
    Dave,  // Good
    Eve,   // Bad
}

wrapped_enum!{
    #[derive(Debug)]
    /// Document your pub enums
    pub enum TestError {

// /// Variants too // Io(io::Error), /// Documentation is required for pub enums Test(CommunicationError), /// Unknown error Unknown(()), } }

wrapped_enum!{
    #[derive(Debug)]
    /// You can't document private variants
    enum UndocumentedEnum {
        // However, there is nothing wrong with normal comments
        Byte(u8),        // 00-FF
        DoubleByte(u16), // 0000-FFFF
    }
}

#[test]
fn eve_intercept_alice_and_bobs_communication() {
    let error: Result<(), CommunicationError> =
        Err(CommunicationError::HumanError(Human::Eve,
                                           ErrorAction::AttemptedToStealSecrets));

    let result: Result<(), TestError> = error.map_err(From::from);

    assert!(result.is_err());
}

}