为什么我可以将对非静态局部变量的引用传递给具有"静态边界"的函数？

Question

我在理解为什么可以编写这样的代码时遇到问题

extern crate futures;
extern crate hyper;
use hyper::server::{Http, Request, Response, Service};
struct Environment {}
struct HttpService<'a> {
    pub env: &'a Environment,
}
impl<'a> Service for HttpService<'a> {
    type Request = Request;
    type Response = Response;
    type Future = futures::future::FutureResult<Self::Response, Self::Error>;
    type Error = hyper::Error;
    fn call(&self, _req: Request) -> Self::Future {
        futures::future::ok(Response::new())
    }
}
fn foo() {
    let addr = "127.0.0.1:3000".parse().unwrap();
    let env = Environment {};
    // <<<<< why is the non-static &env accepted here?
    let server = Http::new().bind(&addr, move || Ok(HttpService { env: &env }));
    server.unwrap().run().unwrap();
}

bind()方法定义为

fn bind<S, Bd>(&self, addr: &SocketAddr, new_service: S) -> Result<Server<S, Bd>>
where
    S: NewService<Request = Request, Response = Response<Bd>, Error = Error> + 'static,
    Bd: Stream<Item = B, Error = Error>,

这意味着闭包必须具有'static生存期，通过&env会违反该生命周期。

为什么它在上面的代码中起作用，但在

fn bar() {
    use tokio_core::net::TcpListener;
    let addr = "127.0.0.1:3000".parse().unwrap();
    let env = Environment {};
    let mut core = tokio_core::reactor::Core::new().unwrap();
    let handle = core.handle();
    use futures::Stream;
    use futures::Future;
    let listener = TcpListener::bind(&addr, &handle)
        .unwrap()
        .incoming()
        .for_each(move |(socket, addr)| {
            let svc = HttpService { env: &env };
            let fut = Http::<hyper::Chunk>::new()
                .serve_connection(socket, svc)
                .map(|_| ())
                .map_err(|_| panic!("err"));
            handle.spawn(fut);
            Ok(())
        });
}

失败并出现与预期生存期相关的错误：

error[E0495]: cannot infer an appropriate lifetime for borrow expression due to conflicting requirements
  --> src/main.rs:50:42
   |
50 |             let svc = HttpService { env: &env };
   |                                          ^^^^
   |
note: first, the lifetime cannot outlive the lifetime  as defined on the body at 49:19...
  --> src/main.rs:49:19
   |
49 |           .for_each(move |(socket, addr)| {
   |  ___________________^
50 | |             let svc = HttpService { env: &env };
51 | |             let fut = Http::<hyper::Chunk>::new()
52 | |                 .serve_connection(socket, svc)
...  |
56 | |             Ok(())
57 | |         });
   | |_________^
note: ...so that closure can access `env`
  --> src/main.rs:50:42
   |
50 |             let svc = HttpService { env: &env };
   |                                          ^^^^
   = note: but, the lifetime must be valid for the static lifetime...
note: ...so that the type `HttpService<'_>` will meet its required lifetime bounds
  --> src/main.rs:53:18
   |
53 |                 .map(|_| ())
   |                  ^^^

更好的是，如何使用更强大的Http::serve_*()函数编写后一部分？

我正在使用

• 锈 1.22.1
• 超级 0.11.15
• 东京核心 0.1.12

Answer 1

通过使用 move 关键字，您已将Environment变量的所有权转移到闭包。这意味着闭包本身没有引用，因此不涉及生存期。闭包的返回值具有与闭包本身相关的生存期，但这是允许的。

请注意，这种情况使用 NewService 。

在 Tokio 示例中，您调用 Handle::spawn ，这需要'static生存期。未来是指不符合该要求Environment。

请注意，这种情况使用 Service 。