Macro enum_unitary::enum_unitary

macro_rules! enum_unitary {
    (
    $(#[$attrs:meta])*
    enum $enum:ident { }
  ) => { ... };
    (
    $(#[$attrs:meta])*
    pub enum $enum:ident { }
  ) => { ... };
    (
    $(#[$attrs:meta])*
    enum $enum:ident { $singleton:ident$(,)* }
  ) => { ... };
    (
    $(#[$attrs:meta])*
    pub enum $enum:ident { $singleton:ident$(,)* }
  ) => { ... };
    (
    $(#[$attrs:meta])*
    enum $enum:ident { $first:ident$(, $variant:ident$(,)*)+ }
  ) => { ... };
    (
    $(#[$attrs:meta])*
    enum $enum:ident {$($variant:ident),+} {$more:ident$(, $tail:ident)+}
  ) => { ... };
    (
    $(#[$attrs:meta])*
    enum $enum:ident {$min:ident$(, $variant:ident)*} {$max:ident}
  ) => { ... };
    (
    $(#[$attrs:meta])*
    pub enum $enum:ident { $first:ident$(, $variant:ident$(,)*)+ }
  ) => { ... };
    (
    $(#[$attrs:meta])*
    pub enum $enum:ident
      {$($variant:ident),+} {$more:ident$(, $tail:ident)+}
  ) => { ... };
    (
    $(#[$attrs:meta])*
    pub enum $enum:ident
      {$min:ident$(, $variant:ident)*} {$max:ident}
  ) => { ... };
}

Derive and implement extra traits for "unitary" enums (i.e. enums where variants do not have payloads):

• derive IntoEnumIterator: implements an iterator type named FooEnumIterator for an enum named Foo and provides a trait method into_enum_iter()
• implements num_traits traits Bounded, ToPrimitive, FromPrimitive
• provides a trait method count_variants() and a const method count() returning the number of variants
• provides next_variant() and prev_variant() methods
• provides an iter_variants() method which returns the enum iterator as a boxed trait object for generic traversals

Note that Clone is also automatically derived so there will be an error if it is given in a derive attribute.

Currently explicit discriminators are not allowed: enum variants will be numbered consecutively starting from 0.

Examples

extern crate enum_iterator;
extern crate enum_unitary;

fn main () {
  use enum_unitary::{enum_unitary, EnumUnitary, Bounded, FromPrimitive,
    ToPrimitive};
  enum_unitary! {
    #[derive(Debug, PartialEq)]
    pub enum E {
      A, B, C
    }
  }
  assert_eq!(E::count(), 3);
  assert_eq!(Into::<usize>::into (E::A), 0);
  assert_eq!(Into::<usize>::into (E::B), 1);
  assert_eq!(Into::<usize>::into (E::C), 2);
  assert_eq!(E::min_value(), E::A);
  assert_eq!(E::max_value(), E::C);
  let mut i = E::iter_variants();
  assert_eq!(i.next(), Some (E::A));
  assert_eq!(i.next(), Some (E::B));
  assert_eq!(i.next(), Some (E::C));
  assert_eq!(i.next(), None);
  assert_eq!(E::A.next_variant(), Some (E::B));
  assert_eq!(E::A.prev_variant(), None);
  assert_eq!(E::B.next_variant(), Some (E::C));
  assert_eq!(E::B.prev_variant(), Some (E::A));
  assert_eq!(E::C.next_variant(), None);
  assert_eq!(E::C.prev_variant(), Some (E::B));
}