discrimenum 0.1.0

Derive `Hash` and `PartialEq` on enums where only the discriminant matters.
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

#[cfg(test)]
mod tests {
    use discrimenum::{Hash, PartialEq};

    #[test]
    fn should_hash() {
        use std::collections::hash_map::RandomState;
        use std::hash::{BuildHasher, Hasher};

        #[derive(Hash)]
        enum HashTest {
            A(usize),
            B(usize),
        }

        let a1 = HashTest::A(123);
        let a2 = HashTest::A(321);
        let b = HashTest::B(123);

        let hasher_builder = RandomState::new();
        let mut a1_hasher = hasher_builder.build_hasher();
        let mut a2_hasher = hasher_builder.build_hasher();
        let mut b_hasher = hasher_builder.build_hasher();

        {
            use std::hash::Hash;

            a1.hash(&mut a1_hasher);
            a2.hash(&mut a2_hasher);
            b.hash(&mut b_hasher);
        }

        assert_eq!(a1_hasher.finish(), a2_hasher.finish());
        assert_ne!(a1_hasher.finish(), b_hasher.finish());
    }

    #[test]
    fn should_hash_generic() {
        use std::collections::hash_map::RandomState;
        use std::hash::{BuildHasher, Hasher};

        #[derive(Hash)]
        enum HashTest<T> {
            A(T),
            B(T),
        }

        let a1 = HashTest::A(123);
        let a2 = HashTest::A(321);
        let b = HashTest::B(123);

        let hasher_builder = RandomState::new();
        let mut a1_hasher = hasher_builder.build_hasher();
        let mut a2_hasher = hasher_builder.build_hasher();
        let mut b_hasher = hasher_builder.build_hasher();

        {
            use std::hash::Hash;

            a1.hash(&mut a1_hasher);
            a2.hash(&mut a2_hasher);
            b.hash(&mut b_hasher);
        }

        assert_eq!(a1_hasher.finish(), a2_hasher.finish());
        assert_ne!(a1_hasher.finish(), b_hasher.finish());
    }

    #[test]
    fn should_partial_eq() {
        #[derive(Debug, PartialEq)]
        enum PartialEqTest {
            A(usize),
            B(usize),
        }

        let a1 = PartialEqTest::A(123);
        let a2 = PartialEqTest::A(321);
        let b = PartialEqTest::B(123);

        assert_eq!(a1, a2);
        assert_ne!(a1, b);
    }

    #[test]
    fn should_partial_eq_generic() {
        #[derive(Debug, PartialEq)]
        enum PartialEqTest<T: std::fmt::Debug> {
            A(T),
            B(T),
        }

        let a1 = PartialEqTest::A(123);
        let a2 = PartialEqTest::A(321);
        let b = PartialEqTest::B(123);

        assert_eq!(a1, a2);
        assert_ne!(a1, b);
    }
}