next 0.2.0

Provides a trait to get the next sequential value
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

use core::f32;

use next::Next;

#[test]
fn next_enum() {
    mod next_module {
        pub use next::Next;
    }

    #[repr(u8)]
    #[derive(Next, PartialEq, Debug)]
    #[next(path = next_module::Next)]
    enum Foo {
        C { first: f32, second: u8 } = 2,
        A = 0,
        B(bool),
    }

    assert_eq!(Foo::MIN, Foo::A);
    assert_eq!(Foo::A.next(), Some(Foo::B(false)));
    assert_eq!(Foo::B(false).next(), Some(Foo::B(true)));
    assert_eq!(
        Foo::B(true).next(),
        Some(Foo::C {
            first: f32::NEG_INFINITY,
            second: 0
        }),
    );
    assert_eq!(
        Foo::C {
            first: f32::NEG_INFINITY,
            second: 0
        }
        .next(),
        Some(Foo::C {
            first: f32::NEG_INFINITY,
            second: 1,
        }),
    );
    assert_eq!(
        Foo::C {
            first: f32::NEG_INFINITY,
            second: u8::MAX,
        }
        .next(),
        Some(Foo::C {
            first: f32::MIN,
            second: 0,
        }),
    );
    assert_eq!(
        Foo::C {
            first: f32::INFINITY,
            second: u8::MAX,
        }
        .next(),
        None,
    );
}

#[test]
fn next_struct() {
    #[derive(Next, PartialEq, Debug)]
    struct Foo {
        a: (),
    }

    assert_eq!(Foo::MIN, Foo { a: () });
    assert_eq!(Foo { a: () }.next(), None);
}