How to use this argument in this async lambda? - rust

Question

I'm trying the below code but I cannot understand how to fix the error, can you help me?
RUST PLAYGROUND DEMO: https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=977a9e7a5bb503e900818b8ff67daf7e
Code:
use std::{future::Future, pin::Pin, sync::Arc};
#[async_trait::async_trait]
pub trait PlayerTrait: Send + Sync {
async fn player_update<'a>(
&'a self,
input: PlayerInput,
lambda: &(dyn Fn(
PlayerLambdaArgs,
) -> Pin<Box<dyn Future<Output = Result<Player, String>> + Send + 'a>>
+ Sync),
) -> Result<Player, String>;
}
#[derive(Debug)]
pub struct Player {
pub name: String,
}
impl Player {
pub fn new(name: &str, team_id: i64) -> Result<Player, String> {
if team_id > 100 {
return Err("Sorry, this team is closed".to_string());
}
Ok(Player {
name: name.to_string(),
})
}
}
pub struct PlayerInput {
pub name: String,
}
pub struct PlayerLambdaArgs {
pub random_team_id: i64,
}
pub struct DBRepo {
pub db: String,
}
impl DBRepo {
pub fn new(db: String) -> Self {
Self { db }
}
}
#[async_trait::async_trait]
impl PlayerTrait for DBRepo {
async fn player_update<'a>(
&'a self,
_input: PlayerInput,
lambda: &(dyn Fn(
PlayerLambdaArgs,
) -> Pin<Box<dyn Future<Output = Result<Player, String>> + Send + 'a>>
+ Sync),
) -> Result<Player, String> {
// get from DB here
let random_team_id = 123;
let lambda_args = PlayerLambdaArgs { random_team_id };
let res = lambda(lambda_args).await?;
// do something with res here
Ok(Player { name: res.name })
}
}
#[tokio::main]
async fn main() {
let db_repo = Arc::new(DBRepo::new(String::from("hello")));
let input = PlayerInput {
name: "Bob".to_string(),
};
let player = db_repo
.player_update(input, &|args| {
Box::pin(async {
let player = Player::new(&input.name, args.random_team_id)?;
Ok(player)
})
})
.await;
dbg!(player);
}
Error:
Compiling playground v0.0.1 (/playground)
error[E0373]: async block may outlive the current function, but it borrows `args.random_team_id`, which is owned by the current function
--> src/main.rs:82:28
|
82 | Box::pin(async {
| ____________________________^
83 | | let player = Player::new(&input.name, args.random_team_id)?;
| | ------------------- `args.random_team_id` is borrowed here
84 | |
85 | | Ok(player)
86 | | })
| |_____________^ may outlive borrowed value `args.random_team_id`
|
note: async block is returned here
--> src/main.rs:82:13
|
82 | / Box::pin(async {
83 | | let player = Player::new(&input.name, args.random_team_id)?;
84 | |
85 | | Ok(player)
86 | | })
| |______________^
help: to force the async block to take ownership of `args.random_team_id` (and any other referenced variables), use the `move` keyword
|
82 | Box::pin(async move {
| ++++
For more information about this error, try `rustc --explain E0373`.
error: could not compile `playground` due to previous error

Answer 1

So, pretty much always, async closures must also be move. This also means that any closure they're inside must be move as well.
So the first thing to do is add move:
#[tokio::main]
async fn main() {
let db_repo = Arc::new(DBRepo::new(String::from("hello")));
let input = PlayerInput {
name: "Bob".to_string(),
};
let player = db_repo
.player_update(input, &(move |args| {
Box::pin(async move {
let player = Player::new(&input.name, args.random_team_id)?;
Ok(player)
})
}))
.await;
dbg!(player);
}
We're still getting some errors here around input.name. This is because we're trying to move input as an argument to player_update and as a capture of the closure and the async block.
So let's add a clone for the PlayerInput construction:
#[tokio::main]
async fn main() {
let db_repo = Arc::new(DBRepo::new(String::from("hello")));
let name = "Bob".to_string();
let input = PlayerInput {
name: name.clone(),
};
let player = db_repo
.player_update(input, &(move |args| {
Box::pin(async move {
let player = Player::new(&name, args.random_team_id)?;
Ok(player)
})
}))
.await;
dbg!(player);
}
This leads to one final move error. We can fix this by taking a reference to name outside the closure, instead of inside it:
#[tokio::main]
async fn main() {
let db_repo = Arc::new(DBRepo::new(String::from("hello")));
let name = "Bob".to_string();
let name = &name;
let input = PlayerInput {
name: name.clone(),
};
let player = db_repo
.player_update(input, &(move |args| {
Box::pin(async move {
let player = Player::new(name, args.random_team_id)?;
Ok(player)
})
}))
.await;
dbg!(player);
}
playground