irmatch 0.2.0

Macro to match against a guaranteed enum variant
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

#[macro_export]
macro_rules! irmatch {
    ($v: expr; $( $p: pat => $r: expr ),+) => {{
        match $v {
            $($p => $r,)+

            _ => {
                unreachable!("Failed to match {} at {}:{}",
                               stringify!($($p)+), file!(), line!())
            }
        }

    }}
}

#[cfg(test)]
mod tests {
    enum T {
        A(i32),
        B(i32, i32),
        C(i32, bool),
        D,
        E {
            f1: i32,
            f2: bool
        }
    }

    #[test]
    fn test_single_tuple() {
        let t = T::A(5);
        let v = irmatch!(t; T::A(i) => i);
        assert_eq!(5, v);
    }

    #[test]
    fn test_double_tuple() {
        let t = T::B(5, -7);
        let v = irmatch!(t; T::B(i1, i2) => (i1, i2));
        assert_eq!((5, -7), v);
    }

    #[test]
    fn test_struct() {
        let t = T::E {
            f1: 10,
            f2: false
        };
        let v = irmatch!(t; T::E{f1: i, f2: b} => (i, b));
        assert_eq!((10, false), v);
    }

    #[test]
    fn test_empty() {
        let t = T::D;
        let v = irmatch!(t; T::D => ());
        assert_eq!((), v);
    }

    #[test]
    #[should_panic]
    fn test_invariant_error() {
        let t = T::B(5, 10);
        let v = irmatch!(t; T::D => ());

        let t = T::A(5);
        let v = irmatch!(t; T::E{..} => ());
    }

    #[test]
    fn multi_pattern() {
        let t = T::B(5, 10);
        let v = irmatch!(t; T::B(..) => (), T::A(..) => ());

        assert_eq!((), v);
    }

    #[test]
    #[should_panic]
    fn multi_pattern_fail() {
        let t = T::B(5, 10);
        let v = irmatch!(t; T::D => (), T::A(..) => ());

        assert_eq!((), v);
    }
}