async closure with the closure taking references in the argument

main.rs

use futures::future::{BoxFuture, FutureExt};

#[tokio::main]
async fn main() {
    println!("Hello, world!");
    let db = AppDatabase(0);
    let r = db.execute_transaction(transaction).await;
    println!("{:?}", r);
}

fn transaction<'a>(
    db: &'a AppDatabase,
    session: &'a mut DatabaseSession,
) -> BoxFuture<'a, anyhow::Result<()>> {
    let val = 5;
    async move { db.insert_with_session(val, session).await }.boxed()
}

struct AppDatabase(i32);
struct DatabaseSession(i32);

impl AppDatabase {
    async fn execute_transaction<F>(&self, f: F) -> anyhow::Result<()>
    where
        F: for<'a> Fn(
            &'a AppDatabase,
            &'a mut DatabaseSession,
        ) -> BoxFuture<'a, anyhow::Result<()>>,
    {
        let mut session = DatabaseSession(0);
        let result = f(&self, &mut session).await;
        if result.is_err() {
            println!("rollback transaction here");
            result
        } else {
            println!("commit transaction here");
            Ok(())
        }
    }

    async fn insert_with_session(
        &self,
        val: i32,
        session: &mut DatabaseSession,
    ) -> anyhow::Result<()> {
        println!("some dummy insert operation here");
        session.0 = val;
        Ok(())
    }
}