      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
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126

    /// Check if an expression matches a refutable pattern.
    ///
    /// Syntax: `matches!(` *expression* `,` *pattern* `)`
    ///
    /// Return a boolean, true if the expression matches the pattern, false otherwise.
    ///
    /// # Examples
    ///
    /// ```
    /// #[macro_use]
    /// extern crate matches;
    ///
    /// pub enum Foo<T> {
    ///     A,
    ///     B(T),
    /// }
    ///
    /// impl<T> Foo<T> {
    ///     pub fn is_a(&self) -> bool {
    ///         matches!(*self, Foo::A)
    ///     }
    ///
    ///     pub fn is_b(&self) -> bool {
    ///         matches!(*self, Foo::B(_))
    ///     }
    /// }
    ///
    /// # fn main() { }
    /// ```
    #[macro_export]
    macro_rules! matches {
        ($expression:expr, $($pattern:tt)+) => {
            match $expression {
                $($pattern)+ => true,
                _ => false
            }
        }
    }

    /// Assert that an expression matches a refutable pattern.
    ///
    /// Syntax: `assert_matches!(` *expression* `,` *pattern* `)`
    ///
    /// Panic with a message that shows the expression if it does not match the
    /// pattern.
    ///
    /// # Examples
    ///
    /// ```
    /// #[macro_use]
    /// extern crate matches;
    ///
    /// fn main() {
    ///     let data = [1, 2, 3];
    ///     assert_matches!(data.get(1), Some(_));
    /// }
    /// ```
    #[macro_export]
    macro_rules! assert_matches {
        ($expression:expr, $($pattern:tt)+) => {
            match $expression {
                $($pattern)+ => (),
                ref e => panic!("assertion failed: `{:?}` does not match `{}`", e, stringify!($($pattern)+)),
            }
        }
    }

    /// Assert that an expression matches a refutable pattern using debug assertions.
    ///
    /// Syntax: `debug_assert_matches!(` *expression* `,` *pattern* `)`
    ///
    /// If debug assertions are enabled, panic with a message that shows the
    /// expression if it does not match the pattern.
    ///
    /// When debug assertions are not enabled, this macro does nothing.
    ///
    /// # Examples
    ///
    /// ```
    /// #[macro_use]
    /// extern crate matches;
    ///
    /// fn main() {
    ///     let data = [1, 2, 3];
    ///     debug_assert_matches!(data.get(1), Some(_));
    /// }
    /// ```
    #[macro_export]
    macro_rules! debug_assert_matches {
        ($expression:expr, $($pattern:tt)+) => {
            if cfg!(debug_assertions) {
                match $expression {
                    $($pattern)+ => (),
                    ref e => panic!("assertion failed: `{:?}` does not match `{}`", e, stringify!($($pattern)+)),
                }
            }
        }
    }

    #[test]
    fn matches_works() {
        let foo = Some("-12");
        assert!(matches!(foo, Some(bar) if
            matches!(bar.as_bytes()[0], b'+' | b'-') &&
            matches!(bar.as_bytes()[1], b'0'...b'9')
        ));
    }

    #[test]
    fn assert_matches_works() {
        let foo = Some("-12");
        assert_matches!(foo, Some(bar) if
            matches!(bar.as_bytes()[0], b'+' | b'-') &&
            matches!(bar.as_bytes()[1], b'0'...b'9')
        );
    }

    #[test]
    #[should_panic(expected = "assertion failed: `Some(\"-AB\")` does not match ")]
    fn assert_matches_panics() {
        let foo = Some("-AB");
        assert_matches!(foo, Some(bar) if
            matches!(bar.as_bytes()[0], b'+' | b'-') &&
            matches!(bar.as_bytes()[1], b'0'...b'9')
        );
    }