Derive Macro arg_enum_proc_macro::ArgEnum

#[derive(ArgEnum)]

Implement std::fmt::Display, std::str::FromStr and variants().

The invocation:

use arg_enum_proc_macro::ArgEnum;

#[derive(ArgEnum)]
enum Foo {
    A,
    B
}

produces:

enum Foo {
    A,
    B
}
impl ::std::str::FromStr for Foo {
    type Err = String;

    fn from_str(s: &str) -> ::std::result::Result<Self,Self::Err> {
        match s {
            "A" | _ if s.eq_ignore_ascii_case("A") => Ok(Foo::A),
            "B" | _ if s.eq_ignore_ascii_case("B") => Ok(Foo::B),
            _ => Err({
                let v = vec![ "A", "B" ];
                format!("valid values: {}", v.join(" ,"))
            }),
        }
    }
}
impl ::std::fmt::Display for Foo {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Foo::A => write!(f, "A"),
            Foo::B => write!(f, "B"),
        }
    }
}

impl Foo {
    #[allow(dead_code)]
    pub fn variants() -> [&'static str; 2] {
        [ "A", "B" ]
    }
}