Why will a move closure not capture a value with a generic type?

Question

I'm trying to create a ScopeRunner type that can store method calls to a method of types implementing the Scope trait like this:

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());
}

I would expect that since ScopeRunner::new creates a move closure this would cause scope to be moved into the closure. But instead the borrow checker gives me this error:

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())}
   |

When I replace ScopeRunner::new with a non generic version that just takes a ScopeImpl this code does work.

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

I don't understand why this is different. To me it seems the lifetime of the generic Scope would be the same as the concrete version.

After reading Peter Halls excellent answer and researching a bit more I realized my question might be a duplicate of this one https://stackoverflow.com/questions/40053550/the-compiler-suggests-i-add-a-static-lifetime-because-the-parameter-type-may-no — Mendelt, May 28 '19 at 06:07

Peter Hall · Accepted Answer · 2019-05-27T20:15:14.437

The problem is that S could be any type with a Scope impl, which includes all kinds of not-yet-existing types that carry references to other types. For example you could have an implementation like this:

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

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

Rust is cautious and wants to make sure that this will work for any qualifying S, including if it contains references.

The easiest fix is to do as the error note suggests and just disallow S from having any non-static references:

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

Bounding S with 'static effectively means that S can contain either references to values with a 'static lifetime or no references at all.

If you want to be a bit more flexible, you can broaden that to references that outlive the ScopeRunner itself:

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)()
    }
}

Thank you. It seems bounding S with 'static like the compiler suggests means something different here than I was expecting. This is going to be part of the public interface of my cmdr crate and I was hoping to avoid forcing users to specify lifetimes, as Scope will be implemented by them but I don't think I can avoid it here. — Mendelt, May 28 '19 at 05:32
@Mendelt Users of your API still shouldn't need to write explicit lifetimes most of the time. — Peter Hall, May 28 '19 at 10:27

Why will a move closure not capture a value with a generic type?

1 Answers1