clap::simple_enum!

macro_rules! simple_enum {
    ($e:ident => $($v:ident),+) => {
        enum $e {
            $($v),+
        }

        impl ::std::str::FromStr for $e {
            type Err = String;

            fn from_str(s: &str) -> Result<Self,Self::Err> {
                match s {
                    $(stringify!($v) => Ok($e::$v),)+
                    _                => Err({
                                            let v = vec![
                                                $(stringify!($v),)+
                                            ];
                                            format!("valid values:{}",
                                                v.iter().fold(String::new(), |a, i| {
                                                    a + &format!(" {}", i)[..]
                                                }))
                                        })
                }
            }
        }

        impl ::std::fmt::Display for $e {
            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
                match *self {
                    $($e::$v => write!(f, stringify!($v)),)+
                }
            }
        }

        impl $e {
            #[allow(dead_code)]
            pub fn variants() -> Vec<&'static str> {
                vec![
                    $(stringify!($v),)+
                ]
            }
        }
    };
}

Convenience macro generated a simple enum with variants to be used as a type when parsing arguments. This enum also provides a variants() function which can be used to retrieve a Vec<&'static str> of the variant names.

NOTE: This macro automaically implements std::str::FromStr and std::fmt::Display

Example

simple_enum!{Foo => Bar, Baz, Qux}
// Foo enum can now be used via Foo::Bar, or Foo::Baz, etc
// and implements std::str::FromStr to use with the value_t! macros
fn main() {
    let enum_vals = ["Bar", "Baz", "Qux"];
    let m = App::new("app")
                .arg(Arg::from_usage("<foo> 'the foo'")
                    .possible_values(&enum_vals))
                .get_matches();
    let f = value_t_or_exit!(m.value_of("foo"), Foo);

    // Use f like any other Foo variant...
}