gotham-rs/gotham

Now I have another problem, don't know what's going on:

#[derive(StateData)]
pub struct State<R, C, V>
where
    R: Sync + Send + 'static,
    C: Sync + Send + 'static,
    V: Sync + Send + 'static,
{
    inner: std::sync::Arc<CommandHandler<R, C, V>>,
}

impl<R, C, V> Clone for State<R, C, V>
where
    R: Finder<HfBox> + Sync + Send + 'static,
    C: Calculator + Sync + Send + 'static,
    V: Validator + Sync + Send + 'static,
{
    fn clone(&self) -> Self {
        State {
            inner: self.inner.clone(),
        }
    }
}

impl<R, C, V> State<R, C, V>
where
    R: Finder<HfBox> + Sync + Send + 'static,
    C: Calculator + Sync + Send + 'static,
    V: Validator + Sync + Send + 'static,
{
    pub fn new(inner: std::sync::Arc<CommandHandler<R, C, V>>) -> Self {
        State { inner }
    }

    async fn handle(
        &self,
        input: <CommandHandler<R, C, V> as Handler>::Input,
    ) -> Result<
        <CommandHandler<R, C, V> as Handler>::Output,
        <CommandHandler<R, C, V> as Handler>::Error,
    > {
        self.inner.handle(input).await
    }
}

pub fn handle<R, C, V>(mut state: GothamState) -> Box<HandlerFuture>
where
    R: Finder<HfBox> + Sync + Send + 'static,
    C: Calculator + Sync + Send + 'static,
    V: Validator + Sync + Send + 'static,
{
    let input: Result<InputPlan, InputValidationError> = Input::take_from(&mut state).try_into();
    if let Err(err) = input {
        return future::err((state, err.into_handler_error())).boxed();
    }

    let input_plan = input.unwrap();
    let command = Command {
        interval: (&input_plan).into(),
        plan: input_plan.into(),
    };

    State::<R, C, V>::borrow_from(&state)
        .handle(command)
        .boxed()
        .compat()
        .then(move |result| match result {
            Err(err) => future::err((state, err.into_handler_error())),
            Ok(hfbox) => {
                let json = serde_json::to_string(&hfbox).unwrap();

                let response = create_response(
                    &state,
                    StatusCode::OK,
                    mime::APPLICATION_JSON,
                    Body::from(json),
                );

                future::ok((state, response))
            }
        })
        .boxed()
}

This thing fails here:

error[E0597]: `state` does not live long enough
   --> my-service-api/src/controller/content/get.rs:97:35
    |
97  |     State::<R, C, V>::borrow_from(&state)
    |     ------------------------------^^^^^^-
    |     |                             |
    |     |                             borrowed value does not live long enough
    |     argument requires that `state` is borrowed for `'static`
...
117 | }
    | - `state` dropped here while still borrowed

error[E0505]: cannot move out of `state` because it is borrowed
   --> my-service-api/src/controller/content/get.rs:101:15
    |
97  |     State::<R, C, V>::borrow_from(&state)
    |     -------------------------------------
    |     |                             |
    |     |                             borrow of `state` occurs here
    |     argument requires that `state` is borrowed for `'static`
...
101 |         .then(move |result| match result {
    |               ^^^^^^^^^^^^^ move out of `state` occurs here
102 |             Err(err) => future::err((state, err.into_handler_error())),
    |                                      ----- move occurs due to use in closure