Macro enum_unitary 

macro_rules! enum_unitary {
    (
    $(#[$attrs:meta])*
    enum $enum:ident { $($variant:ident),* }
  ) => { ... };
    (
    $(#[$attrs:meta])*
    pub enum $enum:ident { $($variant:ident),* }
  ) => { ... };
}

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

• implements num_traits traits Bounded, ToPrimitive, FromPrimitive
• implements primitive conversion types

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

use enum_unitary::{enum_unitary, EnumUnitary, FromPrimitive,
  ToPrimitive};

fn main () {
  enum_unitary! {
    #[derive(Debug, PartialEq)]
    pub enum E {
      A, B, C
    }
  }
  assert_eq!(enum_iterator::cardinality::<E>(), 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!(enum_iterator::first::<E>().unwrap(), E::A);
  assert_eq!(enum_iterator::last::<E>().unwrap(),  E::C);
  let mut i = enum_iterator::all::<E>();
  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!(enum_iterator::next (&E::A), Some (E::B));
  assert_eq!(enum_iterator::previous (&E::A), None);
  assert_eq!(enum_iterator::next (&E::B), Some (E::C));
  assert_eq!(enum_iterator::previous (&E::B), Some (E::A));
  assert_eq!(enum_iterator::next (&E::C), None);
  assert_eq!(enum_iterator::previous (&E::C), Some (E::B));
}