为什么`move` 不随引用一起移动引用数据？

Question

This code does not compile...

fn main() {
    let data = "hi".to_string();
    let wrap = &data;
    std::thread::spawn(move || println!("{}", wrap));
}

...because data doesn't live inside the spawned thread:

error[E0597]: `data` does not live long enough
 --> src/main.rs:3:16
  |
3 |     let wrap = &data;
  |                ^^^^^ borrowed value does not live long enough
4 |     std::thread::spawn(move || println!("{}", wrap));
  |     ------------------------------------------------ argument requires that `data` is borrowed for `'static`
5 | }
  | - `data` dropped here while still borrowed

Why doesn't Rust move data like it does wrap ? Is there any way to force data to be moved along with with wrap ?

My real code looks more like this. I accept a message, parse it, and then send it to a thread for processing.

struct Message {
    data: Vec<u8>,
}
let message = Message {
    data: "{\"name\":\"Rust\"}".to_string(),
};

#[derive(Deserialize)]
struct Parsed<'a> {
    name: &'a str,
}
let parsed: Parsed = serde_json::from_slice(&message.data).unwrap();

std::thread::Builder::new()
    .name(parsed.name) // note: need some of the parsed data prior to moving into the thread...so cannot solve with JSON parsing inside thread
    .spawn(move || println("{}", parsed.name));

I know I could modify my Parsed struct to use String s instead of &'a str , but this reduces efficiency when the compiler should be able to move data just fine.

Answer 1

Why doesn't Rust move data like it does wrap

Several reasons - take your pick:

1. Because wrap is captured, not data , and the closure moves what is captured.

2. Because the move of data would immediately invalidate both wrap itself and other references to data if they exist. Also, the enclosing scope might itself need data for further access.

3. Because then there would be no way to have a closure that captures some values by move and some by reference. Currently you can make a closure move but still elect to capture certain values by reference simply by creating an explicit reference and capturing that. The feature you propose would make that impossible.