Dealing with env - lifetime is getting difficult

[emabee]

Here's a mini version of code I destilled from my attempts to deal with env::args.

// Why does this fail, and how can I fix it?
use std::env;
fn main() {
    let mut vec0: Vec<&str> = vec![];
    let vec1: Vec<_> = env::args().collect();
    let s = vec1.get(0).unwrap();              // `vec1` does not live long enough
    vec0.push(&s);
}

// Note: this does compile:
// fn main() {
//     let mut vec0: Vec<&str> = vec![];
//     let vec1: Vec<_> = vec!["foo", "bar"];;
//     let s = vec1.get(0).unwrap();
//     vec0.push(&s);
// }

I'd appreciate some help and explanation - I've tried a lot already, using to_owned() etc.
What I wanted to do: learn rust by writing code. Here I wanted to deal with program parameters (intentionally ignoring the libs crates.io).

[shepmaster]

If you are asking for help, Stack Overflow, the Rust subreddit, or the IRC channel are all more likely places to get it.

[Stebalien]

Or the forum. Also, you might find #26623 useful.

[arielb1]

This isn't a bug in rustc.

[arielb1]

To be clear, your code doesn't have any use-after-free in it. It is just that a variables declared earlier (in your case, vec0) are required to be valid after variables declared later (in your case, vec1) are destroyed. This can be overcome easily, either by reordering the variables:

use std::env;
fn main() {
    let vec1: Vec<_> = env::args().collect();
    let mut vec0: Vec<&str> = vec![]; // NOTE: ordering
    let s = vec1.get(0).unwrap();
    vec0.push(&s);
}

Or you could even declare the variables simultaneously:

use std::env;
fn main() {
    let (vec1, mut vec0): (Vec<_>, Vec<&str>); // order doesn't matter this way
    vec1 = env::args().collect();
    vec0 = vec![];
    let s = vec1.get(0).unwrap();
    vec0.push(&s);
}

[emabee]

Got it, thanks!
And the difference to the second example (that would compile) is that with
let vec1: Vec<_> = env::args().collect();
a couple of new Strings come into life, so it does matter where within main() this happens, while
let vec1: Vec<_> = vec!["foo", "bar"];
manages references to 'static strings, which live even longer than any variable in main().