Rust 如何使用`&；返回未来的组合器；自我`

我使用futures v0.1编写了这段代码：

impl ArcService for (Box<MiddleWare<Request>>, Box<ArcService>) {
    fn call(&self, req: Request, res: Response) -> Box<Future<Item = Response, Error = Error>> {
        box self.0.call(req).and_then(move |req| self.1.call(req, res))
    }
}

pub trait ArcService: Send + Sync {
    fn call(&self, req: Request, res: Response) -> Box<Future<Item = Response, Error = Error>>;
}

pub trait MiddleWare<T>: Sync + Send {
    fn call<'a>(&'a self, param: T) -> Box<Future<Item = T, Error = Error> + 'a>;
}

type MiddleWareFuture<'a, I> = Box<Future<Item = I, Error = Error> + 'a>;

impl MiddleWare<Request> for Vec<Box<MiddleWare<Request>>> {
    fn call(&self, request: Request) -> MiddleWareFuture<Request> {
        self.iter()
            .fold(box Ok(request).into_future(), |request, middleware| {
                box request.and_then(move |req| middleware.call(req))
            })
    }
}

pub struct ArcRouter {
    routes: HashMap<Method, Box<ArcService>>,
}

// Service implementation
impl hyper::Server::Service for ArcRouter {
    type Response = Response;
    type Request = Request;
    type Error = hyper::Error;
    type Future = Box<Future<Item = Self::Response, Error = Self::Error>>;

    fn call(&self, req: Request) -> Box<Future<Item = Self::Response, Error = Self::Error>> {
        if let Some(routeMatch) = self.matchRoute(req.path(), req.method()) {
            let mut request: ArcRequest = req.into();
            request.paramsMap.insert(routeMatch.params);
            let response = routeMatch.handler //handler is ArcService
                    .call(request, ArcResponse::new())
                    .map(|res| res.into());
            return box response;
        }

        // TODO: this should be handled by a user defined 404 handler
        return box Ok(Response::new().with_status(StatusCode::NotFound)).into_future();
    }
}

它给出了生存期错误：

错误[E0495]：由于需求冲突，无法推断适当的生存期
-->src/main.rs:16:28
|
16 |让f=未来：：ok（self）.map（| ex | ex.age+1）；
|                            ^^^^
|
注意：首先，生命周期不能超过15:5在方法体上定义的匿名生命周期#1。。。
-->src/main.rs:15:5
|
15 |/fn使|成为|未来（&self）->框{
16 | |让f=future:：ok（self）.map（| ex | ex.age+1）；
17 | |盒：：新（f）
18 | |     }
| |_____^
注意：…因此表达式是可赋值的（预期和示例、发现和示例）
-->src/main.rs:16:28
|
16 |让f=未来：：ok（self）.map（| ex | ex.age+1）；
|                            ^^^^
=注意：但是，生存期必须对静态生存期有效。。。
注意：…因此表达式是可赋值的（应为std:：boxed:：Box
如何使用
&self

您返回一个未来，该未来指的是
self
，如下所示：

use futures::future::{self, FutureResult}; // 0.1.28

struct Example {
    age: i32,
}

impl Example {
    fn make_a_future(&self) -> FutureResult<&Example, ()> {
        future::ok(self)
    }
}


你真正的问题是“我怎样才能对编译器撒谎并试图在我的程序中引入内存不安全？”

box隐式
'static
-我看到您使用了语法
Box@Shepmaster我最终需要一个静态的
盒子。那么，我不清楚你的最终目标是什么。大概你在尝试更难的主题（如多线程/异步IO。如果您包含对任何对象的引用，则无法满足
的静态
界限。这与未来无关。请检查编辑。有许多方法可以解决生存期问题，但这与
未来
和组合符没有真正的关系。简而言之：删除引用。移动值，克隆值，克隆
Rc
/
Arc
指向它们的指针，…-或者通过一切跟踪所涉及的生命周期（
box谢谢您的示例，我用一个正确反映我的问题的示例更新了我的问题。
use futures::future::{self, FutureResult}; // 0.1.28

struct Example {
    age: i32,
}

impl Example {
    fn make_a_future(&self) -> FutureResult<&Example, ()> {
        future::ok(self)
    }
}

use futures::{future, Future}; // 0.1.28

struct Example {
    age: i32,
}

impl Example {
    fn make_a_future<'a>(&'a self) -> impl Future<Item = i32, Error = ()> + 'a {
        future::ok(self).map(|ex| ex.age + 1)
    }
}