我在我的真实的项目中使用下面的代码。（显然这是简化的，一个文件只用于操场。）
铁 rust 探险家Playground
正如您所看到的，我尝试使用sqlxTransaction从一个函数到一个闭包。
但我被困住了。
我甚至不知道这（如此常见的戈郎模式）是否是最好的wat在 rust 做。但至少它现在应该工作。

use std::{future::Future, pin::Pin, sync::Arc};

pub trait Trait: Send + Sync + Player + Shirt {}

impl<T: Player + Shirt> Trait for T {}

pub type Lambda<'a, ArgT, ResT> =
    dyn Fn(ArgT) -> Pin<Box<dyn Future<Output = Result<ResT, String>> + Send + 'a>> + Sync + 'a;

#[async_trait::async_trait]
pub trait Player: Send + Sync {
    async fn player_create<'a>(
        &'a self,
        _input: &PlayerInput,
        lambda: &Lambda<'_, PlayerCreateLambdaArgs<'a>, DomainPlayer>,
    ) -> Result<DomainPlayer, String>;
}

#[async_trait::async_trait]
pub trait Shirt: Send + Sync {
    async fn shirt_get_next_and_increase<'a>(
        &'a self,
        tx: &'a mut sqlx::PgConnection,
        model: String,
    ) -> Result<i64, String>;
}

pub struct Repo {
    pub pool: Arc<sqlx::PgPool>,
}

impl Repo {
    pub fn new(pool: Arc<sqlx::PgPool>) -> Self {
        Self { pool }
    }
}

#[async_trait::async_trait]
impl Player for Repo {
    async fn player_create<'a>(
        &'a self,
        _input: &PlayerInput,
        lambda: &Lambda<'_, PlayerCreateLambdaArgs<'a>, DomainPlayer>,
    ) -> Result<DomainPlayer, String> {
        let mut tx = self.pool.begin().await.unwrap();

        // use _input here

        let shirt_next_value = Box::new(|model: String| {
            self::Shirt::shirt_get_next_and_increase(self, &mut tx, model)
        });

        let domain_player = lambda(PlayerCreateLambdaArgs { shirt_next_value }).await?;

        let res =
            sqlx::query_as::<_, DomainPlayer>("INSERT INTO player (...) VALUES (...) RETURNING *")
                .bind(domain_player.id)
                .bind(domain_player.shirt_number)
                .fetch_one(&mut *tx)
                .await
                .unwrap();

        Ok(res)
    }
}

#[async_trait::async_trait]
impl Shirt for Repo {
    async fn shirt_get_next_and_increase<'a>(
        &'a self,
        _tx: &'a mut sqlx::PgConnection,
        _model: String,
    ) -> Result<i64, String> {
        // Here I'm awaiting an async call for DB operations using the same DB transacion of the caller (_tx)...

        // use _tx here...

        let res = 123;

        Ok(res)
    }
}

pub struct Needs {
    pub command_pg_repo: Arc<dyn Trait>,
}

#[derive(Default)]
pub struct PlayerInput {
    pub id: String,
}

#[derive(Debug, Default, Clone, sqlx::FromRow)]
pub struct DomainPlayer {
    pub id: String,
    pub shirt_number: i64,
}

pub struct PlayerCreateLambdaArgs<'a> {
    // other needed fields here
    pub shirt_next_value: Box<
        dyn FnMut(String) -> Pin<Box<dyn Future<Output = Result<i64, String>> + Send + 'a>>
            + Send
            + Sync
            + 'a,
    >,
}

pub struct Handler {
    needs: Arc<Needs>,
}

impl Handler {
    pub fn new(needs: Arc<Needs>) -> Self {
        Self { needs }
    }

    pub async fn handle(&self, input: &PlayerInput) -> Result<DomainPlayer, String> {
        let res = self
            .needs
            .command_pg_repo
            .player_create(&input, &|mut args| {
                let input = input;

                Box::pin(async move {
                    let shirt_number = (args.shirt_next_value)("player".to_string()).await?;

                    let o = DomainPlayer {
                        id: input.id.to_string(),
                        shirt_number,
                    };

                    Ok(o)
                })
            })
            .await?;

        Ok(res)
    }
}

#[tokio::main]
async fn main() -> Result<(), String> {
    let db_conn = sqlx::PgPool::connect("fake_url").await.unwrap();

    let pg_repo = Arc::new(Repo::new(Arc::new(db_conn)));

    let needs = Arc::new(Needs {
        command_pg_repo: pg_repo,
    });

    let handler = Handler::new(needs);

    let new_player_input = PlayerInput {
        id: "abc".to_string(),
    };

    let player = handler.handle(&new_player_input).await?;

    dbg!(player);

    Ok(())
}

错误：

error: captured variable cannot escape `FnMut` closure body
  --> src/main.rs:62:13
   |
57 |         let mut tx = self.pool.begin().await.unwrap();
   |             ------ variable defined here
...
61 |         let shirt_next_value = Box::new(|model: String| {
   |                                                       - inferred to be a `FnMut` closure
62 |             self::Shirt::shirt_get_next_and_increase(self, &mut tx, model)
   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^--^^^^^^^^
   |             |                                                   |
   |             |                                                   variable captured here
   |             returns a reference to a captured variable which escapes the closure body
   |
   = note: `FnMut` closures only have access to their captured variables while they are executing...
   = note: ...therefore, they cannot allow references to captured variables to escape

error[E0597]: `tx` does not live long enough
  --> src/main.rs:62:65
   |
55 |         lambda: &Lambda<'_, PlayerCreateLambdaArgs<'a>, DomainPlayer>,
   |         ------ lifetime `'1` appears in the type of `lambda`
...
61 |         let shirt_next_value = Box::new(|model: String| {
   |                                         --------------- value captured here
62 |             self::Shirt::shirt_get_next_and_increase(self, &mut tx, model)
   |                                                                 ^^ borrowed value does not live long enough
...
65 |         let domain_player = lambda(PlayerCreateLambdaArgs { shirt_next_value }).await?;
   |                                                             ---------------- this usage requires that `tx` is borrowed for `'1`
...
76 |     }
   |     - `tx` dropped here while still borrowed

error[E0499]: cannot borrow `tx` as mutable more than once at a time
  --> src/main.rs:71:34
   |
55 |         lambda: &Lambda<'_, PlayerCreateLambdaArgs<'a>, DomainPlayer>,
   |         ------ lifetime `'1` appears in the type of `lambda`
...
61 |         let shirt_next_value = Box::new(|model: String| {
   |                                         --------------- first mutable borrow occurs here
62 |             self::Shirt::shirt_get_next_and_increase(self, &mut tx, model)
   |                                                                 -- first borrow occurs due to use of `tx` in closure
...
65 |         let domain_player = lambda(PlayerCreateLambdaArgs { shirt_next_value }).await?;
   |                                                             ---------------- this usage requires that `tx` is borrowed for `'1`
...
71 |                 .fetch_one(&mut *tx)
   |                                  ^^ second mutable borrow occurs here

Some errors have detailed explanations: E0499, E0597.
For more information about an error, try `rustc --explain E0499`.