implementation of Predicate is not general enough

[marvinthepa]

Hey, I can't get this to compile

#[automock]
trait MyTrait {
    fn foo<'a>(&self, value: Option<&'a str>);
}

(see #61 for an explanation why the lifetime specification 'a is necessary).

And use it:

let m = MockMyTrait::new();
m.expect_foo().with(eq(None));

490 |         m.expect_foo().with(eq(None));
    |                        ^^^^ implementation of `Predicate` is not general enough
    |
    = note: `predicates::ord::EqPredicate<Option<&'2 str>>` must implement `Predicate<Option<&'1 str>>`, for any lifetime `'1`...
    = note: ...but it actually implements `Predicate<Option<&'2 str>>`, for some specific lifetime `'2`

Any hints on how I can convince the compiler to do what I want? Using a 'static lifetime works, but I would like to avoid that.

My workaround to achieve the same in the test:

        m.expect_foo().return_once(move |a| {
            assert_eq!(None, a);
        });

[asomers]

The problem is that you need a Predicate that matches the same lifetime as the function's argument, but that's hard. An easy workaround is to use withf instead of with. Though it looks like shorthand for with(predicates::Func), it actually has more relaxed lifetime requirements.

m.expect_foo().withf(|value| value == None);

which can probably be more efficiently written as

m.expect_foo().withf(Option::is_none);