Reused vec in loop

[yyw]

fn test() {
    let mut vec = vec![];
    for i in 0..1000000000 {
        let s = format!("hello world {}", i);
        vec.push(s.as_str());
        vec.iter().for_each(|s| println!("do something: {}", s));
        vec.clear();
    }
}

In a situation like this, Vec runs into a lifetime issue, showing the error s does not live long enough. However, by looking at the code we can tell that s will be removed from the Vec after the loop ends, so there is actually no problem. In such scenarios, how can we reuse the Vec and resolve the lifetime issue—either in a safe or unsafe way?

[nerditation]

add this line after vec.clear():

    vec.clear();
+   vec = vec.into_iter().map(|_| unreachable!()).collect();

UPDATE:

since this was selected as the answer, you can read previous threads on the same topic for detailed explanation, such as:

Cleared Vec still holding onto borrow

The following code won't compile as I'm assigning to s which is borrowed by v. I understand that this would invalidate the reference, however because I've drained v before the assignment, there should be no references left to invalidate. Is there something I'm missing here? fn main() { let mut v: Vec<&str> = Vec::new(); let mut s = String::from("Foo"); v.push(&s); v.drain(..).for_each(|s| println!("{s}")); s = String::from("Bar"); v.push(&s); } I can workaroun…

Pattern: how to reuse a `Vec<&str>` across loop iterations?

In a previous question an answer was partially found: Review of unsafe usage. I've reduced the problem a bit more and really feel like there is a pattern for doing this that I'm missing. I don't want to re-allocate the vec each loop. The answer in the link above is good, but really constrains things like propagating errors and storing the cache on a struct etc. Is there a simpler way? use std::{ error::Error, io::{BufRead, BufReader}, }; use regex::Regex; const DATA: &[u8] = b" This…

[increasing]

The wild linker authors explained a trick to solve this exact problem a couple weeks ago. Wild Performance Tricks | David Lattimore
In the section "Buffer reuse".

[tczajka]

A one-liner to replace vec.clear():

vec = vec.into_iter().filter_map(|_| None).collect();

[fuji-184]

For extra context, we may focus on explaining the root cause of the issue and why the new code fixes it. Adding the reasoning not only helps prevent the same or similar mistakes in the future, but also makes the answer more valuable for the original poster and others who might read it later and he does not know it yet. In other words, Q&A like this can be a great learning resource

In Rust, every .into() means it moves/consumes the value. If you use .iter(), it borrows/references the value, while .into_iter() moves/consumes it

Additionally, any .as_() method is also borrowing/referencing the value, such as .as_str()

CMIIW :>

[yyw]

Really appreciate you taking the time to write this up.

[mati865]

In the future it should be more convenient: Tracking Issue for `Vec::recycle` · Issue #148227 · rust-lang/rust · GitHub