为什么移动闭包不捕获具有通用类型的值?

时间:2019-05-27 19:47:03

标签: generics rust closures borrow-checker

我正在尝试创建一个ScopeRunner类型,该类型可以存储对实现Scope特性的类型的方法的调用,如下所示:

trait Scope {
    fn run(&self) -> String;
}

struct ScopeImpl;

impl Scope for ScopeImpl {
    fn run(&self) -> String {
        "Some string".to_string()
    }
}


struct ScopeRunner {
    runner: Box<dyn Fn() -> String>,
}

impl ScopeRunner {
    fn new<S: Scope>(scope: S) -> Self {
        ScopeRunner {
            runner: Box::new(move || scope.run())
        }
    }

    pub fn run(self) -> String {
        (self.runner)()
    }

}


fn main() {
    let scope = ScopeImpl {};
    let scope_runner = ScopeRunner::new(scope);

    dbg!(scope_runner.run());
}

我希望由于ScopeRunner::new创建了一个移动闭包,这将导致合并范围被移动到闭包中。但是取而代之的是借阅检查器给了我这个错误:

error[E0310]: the parameter type `S` may not live long enough
  --> src/main.rs:21:30
   |
20 |     fn new<S: Scope>(scope: S) -> Self {
   |            -- help: consider adding an explicit lifetime bound `S: 'static`...
21 |         ScopeRunner {runner: Box::new(move || scope.run())}
   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
note: ...so that the type `[closure@src/main.rs:21:39: 21:58 scope:S]` will meet its required lifetime bounds
  --> src/main.rs:21:30
   |
21 |         ScopeRunner {runner: Box::new(move || scope.run())}
   | 

当我将ScopeRunner::new替换为仅使用ScopeImpl的非通用版本时,此代码即可正常工作。

fn new(scope: ScopeImpl) -> Self {
    ScopeRunner {
        runner: Box::new(move || scope.run())
    }
}

我不明白为什么会有所不同。在我看来,通用Scope的生存期与具体版本相同。

1 个答案:

答案 0 :(得分:3)

问题是S可以是带有Scope隐含符号的任何类型,其中包括各种尚不存在的类型,这些类型带有对其他类型的引用。例如,您可能具有这样的实现:

struct AnotherScope<'a> {
    reference: &'str,
}

impl Scope for ScopeImpl {
    fn run(&self) -> String {
        self.reference.to_string()
    }
}

Rust谨慎行事,并希望确保此方法适用于符合条件的{em {em}} S,包括它是否包含引用。

最简单的解决方法是按照错误注释中的建议进行操作,只是禁止S使用任何非静态引用:

fn new<S: Scope + 'static>(scope: S) -> Self {
    ScopeRunner {
        runner: Box::new(move || scope.run())
    }
}

S'static绑定意味着S可以包含对具有'static生存期的值的引用,也可以根本不包含任何引用。

如果您想更灵活一些,可以将其扩展为超出ScopeRunner本身的引用:

struct ScopeRunner<'s> {
    runner: Box<dyn Fn() -> String + 's>,
}

impl<'s> ScopeRunner<'s> {
    fn new<S: Scope + 's>(scope: S) -> Self {
        ScopeRunner { 
            runner: Box::new(move || scope.run())
        }
    }

    pub fn run(self) -> String {
        (self.runner)()
    }
}