匿名函数 - 由于需求冲突，无法推断出合适的生命周期

Question

I am trying to use the strategy pattern to have different methods for generating actions from a list of input.

use rand::{prelude::SliceRandom, Rng};

#[derive(Debug, Clone)]
struct Inner {
    num: usize,
}

#[derive(Debug)]
enum Outer {
    ActionA(Inner),
    ActionB(Inner),
}

fn main() {
    // A method to generate an Outer from a list of Inners
    type Strategy = Box<dyn Fn(&Vec<&Inner>) -> Box<dyn FnMut() -> Outer>>;

    let random_strategy: Strategy = Box::new(|inners| {
        let mut rng = rand::thread_rng();
        Box::new(move || {
            let inner = inners.choose(&mut rng).unwrap();
            if rng.gen_bool(1.0 / 2.0) {
                Outer::ActionA(inner.to_owned().clone())
            } else {
                Outer::ActionB(inner.to_owned().clone())
            }
        })
    });

    let inners = vec![&Inner { num: 3 }, &Inner { num: 4 }];
    let get_choice = random_strategy(&inners);

    for _ in 0..4 {
        let choice = get_choice();
        println!("{:?}", choice);
        // do something...
    }
}

Each strategy is a closure because it may contain some state (not shown here in order to keep the example simple).

I get the compiler error

cannot infer an appropriate lifetime due to conflicting requirements
expected `(&&Vec<&Inner>, &mut ThreadRng)`
   found `(&&Vec<&Inner>, &mut ThreadRng)`
but, the lifetime must be valid for the static lifetime...
expected `Box<(dyn FnMut() -> Outer + 'static)>`
   found `Box<dyn FnMut() -> Outer>`

I'm confused as to why the output Outer must have a static lifetime. I am creating Outer once, using a wholly-owned Inner (after cloning), returning it from the anonymous function, and never using it again in that anonymous function. I would expect that the caller ( let choice = get_choice() ) would have ownership over Outer .

This question has the same error but differs because, in my example, Outer needs to own Inner .

I can change the strategy definition to

type Strategy<'a> = Box<dyn Fn(&'a Vec<&'a Inner>) -> Box<dyn FnMut() -> Outer>>;

but then I get the error

`inners` does not live long enough
borrowed value does not live long enoughrustcE0597
main.rs(38, 1): `inners` dropped here while still borrowed
main.rs(18, 26): type annotation requires that `inners` is borrowed for `'static`

(Line 38 is the end of the main function)

I'm unsure how to fix this without cloning the entirety of inners each time I want to use a strategy.

Answer 1

The problem is that

        move || {
            let inner = inners.choose(&mut rng).unwrap();
            if rng.gen_bool(1.0 / 2.0) {
                Outer::ActionA(inner.to_owned().clone())
            } else {
                Outer::ActionB(inner.to_owned().clone())
            }
        }

captures inners , which is the &Vec<&Inner> you passed in to the outer closure. inners is not bounded by 'static , so the closure as a whole cannot be coerced to dyn FnMut() -> Outer , which is implicitly dyn (FnMut() -> Outer) + 'static .

To fix this, you can allow the Strategy to return a function that isn't 'static , by redefining the type like so:

type Strategy = Box<
    dyn for<'a>
        Fn(&'a Vec<&'a Inner>) -> Box<dyn (FnMut() -> Outer) + 'a>
>;

Note the for<'a> . This is the trait-bound syntax equivalent to declaring a function like

fn example_strategy<'a>(&'a Vec<&'a Inner>) -> Box<dyn (FnMut() -> Outer) + 'a> {...}

where the function output has a lifetime depending on the input.

With this change, and adding a missing mut qualifier (calling a FnMut requires mutable access to the function), your program will compile.

Maybe you want the FnMut() -> Outer to stay 'static ; in that case, you'd need to define Strategy so that it owns the Inner s, with corresponding changes to how you call it. But you probably don't want this since you mentioned not cloning the Inner s; I'm mentioning it for comparison.

type Strategy = Box<dyn Fn(Vec<Inner>) -> Box<dyn FnMut() -> Outer>>;