Help creating tx retry function for PgConnection

[0xForerunner]

I’ve run into a rather tough lifetime issue.

/// Here database.pool is a connection pool
impl Database {
    /// Retries a transaction until it succeeds
    /// Note: Only errors originating from `Transaction::commit` are retried
    /// Errors originating from the transaction function are not retried
    pub async fn retry_tx<'a, 'b, S, F, O, E>(&self, f: S) -> Result<O, E>
    where
        F: Future<Output = Result<O, E>> + 'b,
        S: Fn(&'a mut sqlx::PgConnection) -> F + Send + Sync,
        E: From<sqlx::Error>,
        'a: 'b,
    {
        let mut res;
        let mut counter = 0;
        loop {
            let mut tx = self.pool.begin().await?;
            res = f(&mut tx).await;
            if res.is_err() {
                tx.rollback().await?;
                return res;
            }
            match tx.commit().await {
                Err(e) => {
                    counter += 1;
                    if counter > TX_RETRY_LIMIT {
                        return Err(e.into());
                    }
                }
                Ok(_) => break,
            }
        }
        res
    }

With the goal of building txs like this:

db.retry_tx(|tx| async { tx.execute(...).await; tx.execute(...).await; });

I’ve tried all sorts of lifetime shenanigans but rust seems convinced that borrowing &mut tx inside f is invalid. It feels like these lifetimes should work, but alas they do not.