Serde Deserialize lifetime interfering with local variable lifetime - rust

Question

I am learning Rust and playing with Tokio, channels and Serde. I am having difficulty writing some very basic code:
use serde::{Deserialize, Serialize};
use tokio::sync::mpsc::{channel, Receiver};
struct WorkflowProcess {
rx: Receiver<String>,
}
#[derive(Deserialize, Serialize)]
struct Msg {
version: i32,
}
impl WorkflowProcess {
async fn process<'a, T: Deserialize<'a>>(&mut self, callback: impl Fn(T)) {
let r = self.rx.recv().await;
if let Some(v) = r {
let s: &str = v.as_str();
let deserialized: T = serde_json::from_str(s).unwrap();
callback(deserialized);
}
}
}
#[tokio::main]
async fn main() {
let (tx, rx) = channel::<String>(100);
let mut workflow = WorkflowProcess { rx };
let worker = tokio::spawn(async move {
let x = |msg: Msg| {
assert_eq!(
msg.version,
32
);
};
workflow.process(x).await;
});
let serialized = serde_json::to_string(&Msg { version: 32 }).unwrap();
tx.send(serialized).await;
worker.await;
}
Trying to compile gives me this error:
error[E0597]: `v` does not live long enough
--> src/main.rs:17:27
|
14 | async fn process<'a, T: Deserialize<'a>>(&mut self, callback: impl Fn(T)) {
| -- lifetime `'a` defined here
...
17 | let s: &str = v.as_str();
| ^^^^^^^^^^ borrowed value does not live long enough
18 | let deserialized: T = serde_json::from_str(s).unwrap();
| ----------------------- argument requires that `v` is borrowed for `'a`
19 | callback(deserialized);
20 | }
| - `v` dropped here while still borrowed
It seems to me the deserialized lifetime falls within the lifetime of v and s, but I am guessing 'a is not what I think it is. I wish there was a lifetime debugger/visualizer for Rust. Is 'a same as 'static in this case?
I know I can use DeserializeOwned, but I really wanted to get to the bottom of my misunderstanding.

Answer 1

You can use HRTB as #Jmb suggested in the comments:
impl WorkflowProcess {
async fn process<T>(&mut self, callback: impl Fn(T))
where
for<'a> T: Deserialize<'a>,
{
let r = self.rx.recv().await;
if let Some(v) = r {
let deserialized: T = {
let s: &str = v.as_str();
serde_json::from_str(s).unwrap()
};
callback(deserialized);
}
}
}
Playground