Lifetimes in asynchronous closure

[Yandros]

So, FWIW, the following works:

#![allow(unused)]
#![warn(unused_must_use)]

use ::{
    futures::{
        future::{BoxFuture, FutureExt},
    },
    std::{
        collections::HashMap,
        future::Future,
    },
};

pub
struct ObjectCache<T> {
    pub store: HashMap<u32, T>,
}

impl<T> ObjectCache<T> {
    pub
    fn new ()
      -> ObjectCache<T>
    {
        ObjectCache {
            store: <_>::default(),
        }
    }

    pub
    async
    fn get<'up, F : 'up, R> (
        self: &'_ ObjectCache<T>,
        handle: u32,
        closure: F,
    ) -> Result<R, ()>
    where
        for<'r>
            F : FnOnce(&'r T, [&'r &'up (); 0])
                  -> BoxFuture<'r, Result<R, ()>>
        ,
    {
        match self.store.get(&handle) {
            | Some(obj) => closure(obj, []).await,
            | None => Err(())
        }
    }
}

async
fn perform_action (
    request: &'_ str,
    handle: u32,
) -> Result<u32, ()>
{
    AGENT_CACHE
        .get(
            handle,
            move |agent: &'_ Agent, []| {
                agent.process(request)
            }.boxed(),
        )
        .await
}

::lazy_static::lazy_static! {
    pub
    static ref AGENT_CACHE: ObjectCache<Agent> = {
        ObjectCache::<Agent>::new()
    };
}

pub
struct Agent;

impl Agent {
    pub
    async
    fn process (
        self: &'_ Agent,
        request: &'_ str,
    ) -> Result<u32, ()>
    {
        // info!("Processing {}", request);
        let () = async {}.await;
        // sleep(Duration::from_secs(1)).await;
        Ok(42)
    }
}

• Playground

It showcases the hack described over

Argument requires that ... is borrowed for `'static`

Start with #![deny(elided_lifetimes_in_paths)] at the root of your src/{lib,main}.rs file. From there, it should lint about the missing lifetime parameter in, for instance, render's signature, expecting something like: fn render (mut f: impl FnMut(&mut RenderPass<'_>)) Now to apply the rules of lifetime elision: Identify the lifetime parameters / placeholders / "holes": // v vv fn render (mut f: impl FnMut(&mut RenderPass<'_>)) i.e., // …

to be able to upper-bound the higher-order lifetime in for<'r> FnOnce(&'r T) -> BoxFuture<'r, …> (the problem @steffahn was talking about) by adding an extra phony parameter, [&'r &'up (); 0] (for some "free" generic lifetime parameter <'up>) so as to yield an implicit where 'up : 'r bound on the higher-order lifetime, thus allowing to capture stuff outside the closure. It then requires the call sites to provide that extra [] parameter.

• (Here is another attempt with no extra [] parameter, but using a wrapper instead, together with an unsafe-ish RefCast pattern)