Why can't I use this input? - rust

Question

I simplified a lot the code of my real project to narrowing down one issue I cannot understand how to fix.
Rust Explorer Playground here.
The code:
use std::{future::Future, pin::Pin, sync::Arc};
#[derive(Default)]
pub struct PlayerInput {
pub id: String,
pub name: String,
pub location: String,
// pub team: Box<Team>,
// others...
}
#[derive(Debug, sqlx::FromRow)]
pub struct DomainPlayer {
pub id: String,
pub name: String,
pub location: String,
pub shirt_number: i64,
// pub team: Box<Team>,
// others...
}
impl DomainPlayer {
fn new(id: &str, name: &str, location: &str, shirt_number: i64) -> Self {
Self {
id: id.to_string(),
name: name.to_string(),
location: location.to_string(),
shirt_number,
}
}
}
pub struct PlayerCreateLambdaArgs<'a> {
// other needed fields here
pub shirt_next_value: Box<
dyn FnOnce(&'a str) -> Pin<Box<dyn Future<Output = Result<i64, String>> + Send + 'a>>
+ Send
+ Sync
+ 'a,
>,
}
async fn player_create<'a>(
pool: Arc<sqlx::PgPool>,
_team_id: &'a str,
_input: &'a PlayerInput,
lambda: &(dyn for<'b> Fn(
PlayerCreateLambdaArgs<'b>,
) -> Pin<Box<dyn Future<Output = Result<DomainPlayer, String>> + Send + 'b>>
+ Sync
+ '_),
) -> Result<DomainPlayer, String> {
let mut tx = pool.begin().await.unwrap();
let domain_player = lambda(PlayerCreateLambdaArgs {
shirt_next_value: Box::new(|model: &str| {
Box::pin(shirt_get_next_and_increase(&mut tx, model))
}),
})
.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 fn shirt_get_next_and_increase(
tx: &mut sqlx::PgConnection,
model: &str,
) -> Result<i64, String> {
// Here I'm awaiting an async call for DB operations using the same DB transacion of the caller (_tx)...
dbg!(tx);
// use model here...
dbg!(model);
let res = 123;
Ok(res)
}
pub async fn handle(pool: Arc<sqlx::PgPool>, input: &PlayerInput) -> Result<DomainPlayer, String> {
let res = player_create(pool, "team", input, &|args| {
let input = input;
Box::pin(async move {
let shirt_number = (args.shirt_next_value)("player").await?;
let o = DomainPlayer::new(&input.id, &input.name, &input.location, shirt_number);
Ok(o)
})
})
.await?;
Ok(res)
}
#[tokio::main]
async fn main() -> Result<(), String> {
let pool = Arc::new(sqlx::PgPool::connect("fake_url").await.unwrap());
let new_player_input = PlayerInput {
id: "abc".to_string(),
name: "John".to_string(),
location: "Boston".to_string(),
};
let player = handle(pool.clone(), &new_player_input).await?;
dbg!(player);
Ok(())
}
The error:
error: lifetime may not live long enough
--> src/main.rs:104:9
|
100 | pub async fn handle(pool: Arc<sqlx::PgPool>, input: &PlayerInput) -> Result<DomainPlayer, String> {
| - let's call the lifetime of this reference `'1`
...
104 | / Box::pin(async move {
105 | | let shirt_number = (args.shirt_next_value)("player").await?;
106 | |
107 | | let o = DomainPlayer::new(&input.id, &input.name, &input.location, shirt_number);
108 | |
109 | | Ok(o)
110 | | })
| |__________^ returning this value requires that `'1` must outlive `'static`

Answer 1

Let's rewrite your handle a little bit, to make it easier to explain:
pub async fn handle(pool: Arc<sqlx::PgPool>, input: &PlayerInput) -> Result<DomainPlayer, String> {
let lambdaref: &(dyn for<'b> Fn(PlayerCreateLambdaArgs<'b>) -> Pin<Box<dyn Future<Output=Result<DomainPlayer, String>> + Send + 'b>> + Sync) = &|args: PlayerCreateLambdaArgs| {
let input = input;
Box::pin(async move {
let shirt_number = (args.shirt_next_value)("player").await?;
let o = DomainPlayer::new(&input.id, &input.name, &input.location, shirt_number);
Ok(o)
})
};
let res = player_create(pool, "team", input, lambdaref)
.await?;
Ok(res)
}
so lambdaref references a lambda, which takes a PlayerCreateLambdaArgs<'b> and produces a a boxed future guaranteed to live at least as long as 'b.
And it also captures input which we know lives at least as long as 'a.
So we can deduce, that 'a must live at least as long as 'b otherwise the boxed future couldn't live at least as long as 'b, as it needs access to input, too.
But 'b is not yet determined and can be chosen by the caller of the lamba. The caller of the lambda could choose to use a PlayerCreateLambdaArgs<'static> and therefore choose 'b to be 'static.
So rustc has to demand 'a to be 'static so the lambda can be called with every possible 'b.
If you can change player_create and PlayerCreateLambdaArgs, then you can
side step this issue. player_create already gets input and could just
hand it down to the lamba inside PlayerCreateLambdaArgs, too.
Like in https://www.rustexplorer.com/b/8vonk0
If you don't mind me saying, it looks all a bit convoluted, what is it, you really want to achieve?