variter 0.3.0

Declarative macro-derivable trait for iterating over field-less enum type variants
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

use std::collections::HashSet;

use variter::{derive_var_iter, VarIter};

derive_var_iter! {
    @impl_attr {
        #[doc(hidden)]
    }
    #[derive(Debug, PartialEq)]
    enum Foo {}

    #[derive(Debug, PartialEq, Eq, Hash, Copy, Clone)]
    enum Bar {
        X,
        Y,
        Z,
    }

    #[derive(Debug, PartialEq, Eq, Copy, Clone)]
    enum Baz {
        A = 1,
        B = 10,
        C,
    }

    /// Yep!
    enum Documented {
        /// Also this
        #[cold]
        Variant1,
    }
}

#[test]
fn foo_has_no_cases() {
    assert_eq!(Foo::ALL_VARIANTS, &[]);
}

#[test]
fn bar_has_three_cases() {
    assert_eq!(Bar::ALL_VARIANTS.len(), 3);
}

#[test]
fn bar_cases_are_unique() {
    let mut set = HashSet::with_capacity(Bar::ALL_VARIANTS.len());
    assert!(Bar::ALL_VARIANTS.iter().all(|&case| set.insert(case)));
}

#[test]
fn baz_has_three_cases() {
    assert_eq!(Baz::ALL_VARIANTS.len(), 3);
}

#[test]
fn baz_discriminants_work() {
    for &var in Baz::ALL_VARIANTS.iter() {
        match var {
            Baz::A => assert_eq!(var as isize, 1),
            Baz::B => assert_eq!(var as isize, 10),
            Baz::C => assert_eq!(var as isize, 11),
        }
    }
}

#[test]
fn macro_works_in_fn() {
    derive_var_iter! {
        enum Foo {}
        enum Bar { A, B, C }
    }
}

#[test]
fn crate_impls_work() { for _ in std::cmp::Ordering::ALL_VARIANTS {} }