src/matchers/matches_pattern.rs

// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// There are no visible documentation elements in this module; the declarative
// macro is documented in the matchers module.
#![doc(hidden)]

/// Matches a value according to a pattern of matchers.
///
/// This takes as an argument a specification similar to a struct or enum
/// initialiser, where each value is a [`Matcher`][crate::matcher::Matcher]
/// which is applied to the corresponding field.
///
/// This can be used to match arbitrary combinations of fields on structures
/// using arbitrary matchers:
///
/// ```
/// # use googletest::prelude::*;
/// #[derive(Debug)]
/// struct MyStruct {
///     a_field: String,
///     another_field: String,
/// }
///
/// let my_struct = MyStruct {
///     a_field: "Something to believe in".into(),
///     another_field: "Something else".into()
/// };
/// verify_that!(my_struct, matches_pattern!(MyStruct {
///     a_field: starts_with("Something"),
///     another_field: ends_with("else"),
/// }))
/// #     .unwrap();
/// ```
///
/// It is not required to include all named fields in the specification. Omitted
/// fields have no effect on the output of the matcher.
///
/// ```
/// # use googletest::prelude::*;
/// # #[derive(Debug)]
/// # struct MyStruct {
/// #     a_field: String,
/// #     another_field: String,
/// # }
/// #
/// # let my_struct = MyStruct {
/// #     a_field: "Something to believe in".into(),
/// #     another_field: "Something else".into()
/// # };
/// verify_that!(my_struct, matches_pattern!(MyStruct {
///     a_field: starts_with("Something"),
///     // another_field is missing, so it may be anything.
/// }))
/// #     .unwrap();
/// ```
///
/// One can use it recursively to match nested structures:
///
/// ```
/// # use googletest::prelude::*;
/// #[derive(Debug)]
/// struct MyStruct {
///     a_nested_struct: MyInnerStruct,
/// }
///
/// #[derive(Debug)]
/// struct MyInnerStruct {
///     a_field: String,
/// }
///
/// let my_struct = MyStruct {
///     a_nested_struct: MyInnerStruct { a_field: "Something to believe in".into() },
/// };
/// verify_that!(my_struct, matches_pattern!(MyStruct {
///      a_nested_struct: matches_pattern!(MyInnerStruct {
///         a_field: starts_with("Something"),
///     }),
/// }))
/// #     .unwrap();
/// ```
///
/// One can use the alias [`pat`][crate::matchers::pat] to make this less
/// verbose:
///
/// ```
/// # use googletest::prelude::*;
/// # #[derive(Debug)]
/// # struct MyStruct {
/// #     a_nested_struct: MyInnerStruct,
/// # }
/// #
/// # #[derive(Debug)]
/// # struct MyInnerStruct {
/// #     a_field: String,
/// # }
/// #
/// # let my_struct = MyStruct {
/// #     a_nested_struct: MyInnerStruct { a_field: "Something to believe in".into() },
/// # };
/// verify_that!(my_struct, matches_pattern!(MyStruct {
///     a_nested_struct: pat!(MyInnerStruct {
///         a_field: starts_with("Something"),
///     }),
/// }))
/// #     .unwrap();
/// ```
///
/// In addition to fields, one can match on the outputs of methods
/// ("properties"):
///
/// ```
/// # use googletest::prelude::*;
/// #[derive(Debug)]
/// struct MyStruct {
///     a_field: String,
/// }
///
/// impl MyStruct {
///     fn get_a_field(&self) -> String { self.a_field.clone() }
/// }
///
/// let my_struct = MyStruct { a_field: "Something to believe in".into() };
/// verify_that!(my_struct, matches_pattern!(MyStruct {
///     get_a_field(): starts_with("Something"),
/// }))
/// #     .unwrap();
/// ```
///
/// If an inner matcher is `eq(...)`, it can be omitted:
///
/// ```
/// # use googletest::prelude::*;
/// #[derive(Debug)]
/// struct MyStruct {
///     a_field: String,
///     another_field: String,
/// }
///
/// let my_struct = MyStruct {
///     a_field: "this".into(),
///     another_field: "that".into()
/// };
/// verify_that!(my_struct, matches_pattern!(MyStruct {
///     a_field: "this",
///     another_field: "that",
/// }))
/// #     .unwrap();
/// ```
///
/// **Important**: The method should be pure function with a deterministic
/// output and no side effects. In particular, in the event of an assertion
/// failure, it will be invoked a second time, with the assertion failure output
/// reflecting the *second* invocation.
///
/// These may also include extra litteral parameters you pass in:
///
/// ```
/// # use googletest::prelude::*;
/// # #[derive(Debug)]
/// # struct MyStruct {
/// #     a_field: String,
/// # }
/// #
/// impl MyStruct {
///     fn append_to_a_field(&self, suffix: &str) -> String { self.a_field.clone() + suffix }
/// }
///
/// # let my_struct = MyStruct { a_field: "Something to believe in".into() };
/// verify_that!(my_struct, matches_pattern!(&MyStruct {
///     append_to_a_field("a suffix"): ref ends_with("a suffix"),
/// }))
/// #     .unwrap();
/// ```
///
/// You can precede both field and property matchers with a `ref` to match the
/// result by reference:
///
/// ```
/// # use googletest::prelude::*;
/// # #[derive(Debug)]
/// # struct MyStruct {
/// #     a_field: String,
/// # }
/// #
/// impl MyStruct {
///     fn get_a_field_ref(&self) -> String { self.a_field.clone() }
/// }
///
/// # let my_struct = MyStruct { a_field: "Something to believe in".into() };
/// verify_that!(my_struct, matches_pattern!(&MyStruct {
///     get_a_field_ref(): ref starts_with("Something"),
/// }))
/// #    .unwrap();
/// ```
///
/// Note that if the `actual` is of type `&ActualT` and the pattern type is
/// `ActualT`, this is automatically performed. This behavior is similar to the
/// reference binding mode in pattern matching.
///
/// ```
/// # use googletest::prelude::*;
/// # #[derive(Debug)]
/// # struct MyStruct {
/// #     a_field: String,
/// # }
/// #
/// impl MyStruct {
///     fn get_a_field_ref(&self) -> String { self.a_field.clone() }
/// }
///
/// # let my_struct = MyStruct { a_field: "Something to believe in".into() };
/// verify_that!(my_struct, matches_pattern!(MyStruct {
///     get_a_field_ref(): starts_with("Something"),
/// }))
/// #    .unwrap();
/// ```
///
/// One can also match tuple structs with up to 10 fields. In this case, all
/// fields must have matchers:
///
/// ```
/// # use googletest::prelude::*;
/// #[derive(Debug)]
/// struct MyTupleStruct(String, String);
///
/// let my_struct = MyTupleStruct("Something".into(), "Some other thing".into());
/// verify_that!(
///     my_struct,
///     matches_pattern!(&MyTupleStruct(ref eq("Something"), ref eq("Some other thing")))
/// )
/// #    .unwrap();
/// ```
///
/// One can also match enum values:
///
/// ```
/// # use googletest::prelude::*;
/// #[derive(Debug)]
/// enum MyEnum {
///     A(u32),
///     B,
/// }
///
/// # fn should_pass() -> Result<()> {
/// verify_that!(MyEnum::A(123), matches_pattern!(&MyEnum::A(eq(123))))?; // Passes
/// #     Ok(())
/// # }
/// # fn should_fail() -> Result<()> {
/// verify_that!(MyEnum::B, matches_pattern!(&MyEnum::A(eq(123))))?; // Fails - wrong enum variant
/// #     Ok(())
/// # }
/// # should_pass().unwrap();
/// # should_fail().unwrap_err();
/// ```
///
/// This macro does not support plain (non-struct) tuples. But it should not be
/// necessary as tuple of matchers are matchers of tuple. In other words, if
/// `MatcherU: Matcher<U>` and `MatcherT: Matcher<T>`, then `(MatcherU,
/// MatcherT): Matcher<(U, T)>`.
///
/// Trailing commas are allowed (but not required) in both ordinary and tuple
/// structs.
///
/// Note that the default format (rustfmt) can format macros if the macro
/// argument is parseable Rust code. This is mostly true for this macro with two
/// exceptions:
///  * property matching
///  * `ref` keyword with named fields
///
/// An option for formatting large is to avoid these exceptions (by removing the
/// parenthesis of properties and the `ref` keywords), run `rustfmt` and add
/// them back.
#[macro_export]
#[doc(hidden)]
macro_rules! __matches_pattern {
    ($($t:tt)*) => { $crate::matches_pattern_internal!($($t)*) }
}

// Internal-only macro created so that the macro definition does not appear in
// generated documentation.
#[doc(hidden)]
#[macro_export]
macro_rules! matches_pattern_internal {
    (
        @name [$($struct_name:tt)*],
        { $field_name:ident : ref $matcher:expr $(,)? }
    ) => {
        $crate::matchers::__internal_unstable_do_not_depend_on_these::is(
            stringify!($($struct_name)*),
            all!(field!($($struct_name)*.$field_name, ref $matcher))
        )
    };

    (
        @name [$($struct_name:tt)*],
        { $field_name:ident : $matcher:expr $(,)? }
    ) => {
        $crate::matchers::__internal_unstable_do_not_depend_on_these::is(
            stringify!($($struct_name)*),
            all!(field!($($struct_name)*.$field_name, $matcher))
        )
    };

    (
        @name [$($struct_name:tt)*],
        { $property_name:ident($($argument:expr),* $(,)?) : ref $matcher:expr $(,)? }
    ) => {
        $crate::matchers::__internal_unstable_do_not_depend_on_these::is(
            stringify!($($struct_name)*),
            all!(property!($($struct_name)*.$property_name($($argument),*), ref $matcher))
        )
    };

    (
        @name [$($struct_name:tt)*],
        { $property_name:ident($($argument:expr),* $(,)?) : $matcher:expr $(,)? }
    ) => {
        $crate::matchers::__internal_unstable_do_not_depend_on_these::is(
            stringify!($($struct_name)*),
            all!(property!($($struct_name)*.$property_name($($argument),*), $matcher))
        )
    };

    (
        @name [$($struct_name:tt)*],
        { $field_name:ident : ref $matcher:expr, $($rest:tt)* }
    ) => {
        $crate::matches_pattern_internal!(
            @fields (field!($($struct_name)*.$field_name, ref $matcher)),
            [$($struct_name)*],
            { $($rest)* }
        )
    };

    (
        @name [$($struct_name:tt)*],
        { $field_name:ident : $matcher:expr, $($rest:tt)* }
    ) => {
        $crate::matches_pattern_internal!(
            @fields (field!($($struct_name)*.$field_name, $matcher)),
            [$($struct_name)*],
            { $($rest)* }
        )
    };

    (
        @name [$($struct_name:tt)*],
        { $property_name:ident($($argument:expr),* $(,)?) : ref $matcher:expr, $($rest:tt)* }
    ) => {
        $crate::matches_pattern_internal!(
            @fields (property!($($struct_name)*.$property_name($($argument),*), ref $matcher)),
            [$($struct_name)*],
            { $($rest)* }
        )
    };

    (
        @name [$($struct_name:tt)*],
        { $property_name:ident($($argument:expr),* $(,)?) : $matcher:expr, $($rest:tt)* }
    ) => {
        $crate::matches_pattern_internal!(
            @fields (property!($($struct_name)*.$property_name($($argument),*), $matcher)),
            [$($struct_name)*],
            { $($rest)* }
        )
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        { $field_name:ident : ref $matcher:expr $(,)? }
    ) => {
        $crate::matchers::__internal_unstable_do_not_depend_on_these::is(
            stringify!($($struct_name)*),
            all!(
                $($processed)*,
                field!($($struct_name)*.$field_name, ref $matcher)
            ))
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        { $field_name:ident : $matcher:expr $(,)? }
    ) => {
        $crate::matchers::__internal_unstable_do_not_depend_on_these::is(
            stringify!($($struct_name)*),
            all!(
                $($processed)*,
                field!($($struct_name)*.$field_name, $matcher)
            ))
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        { $property_name:ident($($argument:expr),* $(,)?) : ref $matcher:expr $(,)? }
    ) => {
        $crate::matchers::__internal_unstable_do_not_depend_on_these::is(
            stringify!($($struct_name)*),
            all!(
                $($processed)*,
                property!($($struct_name)*.$property_name($($argument),*), ref $matcher)
            ))
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        { $property_name:ident($($argument:expr),* $(,)?) : $matcher:expr $(,)? }
    ) => {
        $crate::matchers::__internal_unstable_do_not_depend_on_these::is(
            stringify!($($struct_name)*),
            all!(
                $($processed)*,
                property!($($struct_name)*.$property_name($($argument),*), $matcher)
            ))
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        { $field_name:ident : ref $matcher:expr, $($rest:tt)* }
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                $($processed)*,
                field!($($struct_name)*.$field_name, ref $matcher)
            ),
            [$($struct_name)*],
            { $($rest)* }
        )
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        { $field_name:ident : $matcher:expr, $($rest:tt)* }
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                $($processed)*,
                field!($($struct_name)*.$field_name, $matcher)
            ),
            [$($struct_name)*],
            { $($rest)* }
        )
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        { $property_name:ident($($argument:expr),* $(,)?) : ref $matcher:expr, $($rest:tt)* }
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                $($processed)*,
                property!(ref $($struct_name)*.$property_name($($argument),*), $matcher)
            ),
            [$($struct_name)*],
            { $($rest)* }
        )
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        { $property_name:ident($($argument:expr),* $(,)?) : $matcher:expr, $($rest:tt)* }
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                $($processed)*,
                property!($($struct_name)*.$property_name($($argument),*), $matcher)
            ),
            [$($struct_name)*],
            { $($rest)* }
        )
    };

    (
        @name [$($struct_name:tt)*],
    ) => {
        $crate::matchers::__internal_unstable_do_not_depend_on_these::pattern_only(
            |v| matches!(v, $($struct_name)*),
            concat!("is ", stringify!($($struct_name)*)),
            concat!("is not ", stringify!($($struct_name)*)))
    };

    (
        @name [$($struct_name:tt)*],
        (ref $matcher:expr $(,)?)
    ) => {
        $crate::matchers::__internal_unstable_do_not_depend_on_these::is(
            stringify!($($struct_name)*),
            all!(field!($($struct_name)*.0, ref $matcher))
        )
    };

    (
        @name [$($struct_name:tt)*],
        ($matcher:expr $(,)?)
    ) => {
        $crate::matchers::__internal_unstable_do_not_depend_on_these::is(
            stringify!($($struct_name)*),
            all!(field!($($struct_name)*.0, $matcher))
        )
    };

    (
        @name [$($struct_name:tt)*],
        (ref $matcher:expr, $($rest:tt)*)
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                field!($($struct_name)*.0, ref $matcher)
            ),
            [$($struct_name)*],
            1,
            ($($rest)*)
        )
    };

    (
        @name [$($struct_name:tt)*],
        ($matcher:expr, $($rest:tt)*)
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                field!($($struct_name)*.0, $matcher)
            ),
            [$($struct_name)*],
            1,
            ($($rest)*)
        )
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        $field:tt,
        (ref $matcher:expr $(,)?)
    ) => {
        $crate::matchers::__internal_unstable_do_not_depend_on_these::is(
            stringify!($($struct_name)*),
            all!(
                $($processed)*,
                field!($($struct_name)*.$field, ref $matcher)
            ))
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        $field:tt,
        ($matcher:expr $(,)?)
    ) => {
        $crate::matchers::__internal_unstable_do_not_depend_on_these::is(
            stringify!($($struct_name)*),
            all!(
                $($processed)*,
                field!($($struct_name)*.$field, $matcher)
            ))
    };

    // We need to repeat this once for every supported field position, unfortunately. There appears
    // to be no way in declarative macros to compute $field + 1 and have the result evaluated to a
    // token which can be used as a tuple index.
    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        1,
        (ref $matcher:expr, $($rest:tt)*)
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                $($processed)*,
                field!($($struct_name)*.1, ref $matcher)
            ),
            [$($struct_name)*],
            2,
            ($($rest)*)
        )
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        1,
        ($matcher:expr, $($rest:tt)*)
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                $($processed)*,
                field!($($struct_name)*.1, $matcher)
            ),
            [$($struct_name)*],
            2,
            ($($rest)*)
        )
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        2,
        (ref $matcher:expr, $($rest:tt)*)
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                $($processed)*,
                field!($($struct_name)*.2, ref $matcher)
            ),
            [$($struct_name)*],
            3,
            ($($rest)*)
        )
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        2,
        ($matcher:expr, $($rest:tt)*)
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                $($processed)*,
                field!($($struct_name)*.2, $matcher)
            ),
            [$($struct_name)*],
            3,
            ($($rest)*)
        )
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        3,
        (ref $matcher:expr, $($rest:tt)*)
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                $($processed)*,
                field!($($struct_name)*.3, ref $matcher)
            ),
            [$($struct_name)*],
            4,
            ($($rest)*)
        )
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        3,
        ($matcher:expr, $($rest:tt)*)
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                $($processed)*,
                field!($($struct_name)*.3, $matcher)
            ),
            [$($struct_name)*],
            4,
            ($($rest)*)
        )
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        4,
        (ref $matcher:expr, $($rest:tt)*)
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                $($processed)*,
                field!($($struct_name)*.4, ref $matcher)
            ),
            [$($struct_name)*],
            5,
            ($($rest)*)
        )
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        4,
        ($matcher:expr, $($rest:tt)*)
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                $($processed)*,
                field!($($struct_name)*.4, $matcher)
            ),
            [$($struct_name)*],
            5,
            ($($rest)*)
        )
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        5,
        (ref $matcher:expr, $($rest:tt)*)
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                $($processed)*,
                field!($($struct_name)*.5, ref $matcher)
            ),
            [$($struct_name)*],
            6,
            ($($rest)*)
        )
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        5,
        ($matcher:expr, $($rest:tt)*)
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                $($processed)*,
                field!($($struct_name)*.5, $matcher)
            ),
            [$($struct_name)*],
            6,
            ($($rest)*)
        )
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        6,
        (ref $matcher:expr, $($rest:tt)*)
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                $($processed)*,
                field!($($struct_name)*.6, ref $matcher)
            ),
            [$($struct_name)*],
            7,
            ($($rest)*)
        )
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        6,
        ($matcher:expr, $($rest:tt)*)
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                $($processed)*,
                field!($($struct_name)*.6, $matcher)
            ),
            [$($struct_name)*],
            7,
            ($($rest)*)
        )
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        7,
        (ref $matcher:expr, $($rest:tt)*)
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                $($processed)*,
                field!($($struct_name)*.7, ref $matcher)
            ),
            [$($struct_name)*],
            8,
            ($($rest)*)
        )
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        7,
        ($matcher:expr, $($rest:tt)*)
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                $($processed)*,
                field!($($struct_name)*.7, $matcher)
            ),
            [$($struct_name)*],
            8,
            ($($rest)*)
        )
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        8,
        (ref $matcher:expr, $($rest:tt)*)
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                $($processed)*,
                field!($($struct_name)*.8, ref $matcher)
            ),
            [$($struct_name)*],
            9,
            ($($rest)*)
        )
    };

    (
        @fields ($($processed:tt)*),
        [$($struct_name:tt)*],
        8,
        ($matcher:expr, $($rest:tt)*)
    ) => {
        $crate::matches_pattern_internal!(
            @fields (
                $($processed)*,
                field!($($struct_name)*.8, $matcher)
            ),
            [$($struct_name)*],
            9,
            ($($rest)*)
        )
    };

    (@name [$($struct_name:tt)*], $first:tt $($rest:tt)*) => {
        $crate::matches_pattern_internal!(@name [$($struct_name)* $first], $($rest)*)
    };

    ($first:tt $($rest:tt)*) => {{
        #[allow(unused)]
        use $crate::matchers::{all, field, property};
        $crate::matches_pattern_internal!(@name [$first], $($rest)*)
    }};
}

/// An alias for [`matches_pattern`][crate::matchers::matches_pattern!].
#[macro_export]
#[doc(hidden)]
macro_rules! __pat {
    ($($t:tt)*) => { $crate::matches_pattern_internal!($($t)*) }
}

#[doc(hidden)]
pub mod internal {
    use crate::matcher::{Matcher, MatcherBase};
    use std::fmt::Debug;

    // Specialized implementation of the `predicate` matcher to support ref binding
    // mode for `matches_pattern`.
    pub fn pattern_only<T>(
        matcher_function: fn(&T) -> bool,
        match_description: &'static str,
        no_match_description: &'static str,
    ) -> PatternOnlyMatcher<T> {
        PatternOnlyMatcher { matcher_function, match_description, no_match_description }
    }

    #[derive(MatcherBase)]
    #[doc(hidden)]
    pub struct PatternOnlyMatcher<T> {
        matcher_function: fn(&T) -> bool,
        match_description: &'static str,
        no_match_description: &'static str,
    }

    impl<'a, T: Debug> Matcher<&'a T> for PatternOnlyMatcher<T> {
        fn matches(&self, actual: &'a T) -> crate::matcher::MatcherResult {
            (self.matcher_function)(actual).into()
        }

        fn describe(
            &self,
            matcher_result: crate::matcher::MatcherResult,
        ) -> crate::description::Description {
            match matcher_result {
                crate::matcher::MatcherResult::Match => self.match_description.into(),
                crate::matcher::MatcherResult::NoMatch => self.no_match_description.into(),
            }
        }
    }

    impl<T: Debug + Copy> Matcher<T> for PatternOnlyMatcher<T> {
        fn matches(&self, actual: T) -> crate::matcher::MatcherResult {
            (self.matcher_function)(&actual).into()
        }

        fn describe(
            &self,
            matcher_result: crate::matcher::MatcherResult,
        ) -> crate::description::Description {
            match matcher_result {
                crate::matcher::MatcherResult::Match => self.match_description.into(),
                crate::matcher::MatcherResult::NoMatch => self.no_match_description.into(),
            }
        }
    }
}