How do I efficiently build a vector and an index of that vector while processing a data stream?

Question

I have a struct Foo:

struct Foo {
    v: String,
    // Other data not important for the question
}

I want to handle a data st

Answer 1

The error is:

error: `s` does not live long enough
  --> :27:5
   |
16 |         let idx: usize = match hash.entry(&s) { //a
   |                                            - borrow occurs here
...
27 |     }
   |     ^ `s` dropped here while still borrowed
   |
   = note: values in a scope are dropped in the opposite order they are created

The note: at the end is where the answer is.

s must outlive hash because you are using &s as a key in the HashMap. This reference will become invalid when s is dropped. But, as the note says, hash will be dropped after s. A quick fix is to swap the order of their declarations:

let s = "aaa".to_string();
let mut hash = HashMap::<&str, usize>::new();

But now you have another problem:

error[E0505]: cannot move out of `s` because it is borrowed
  --> :22:33
   |
17 |         let idx: usize = match hash.entry(&s) { //a
   |                                            - borrow of `s` occurs here
...
22 |                 l.push(Foo { v: s }); //b
   |                                 ^ move out of `s` occurs here

This one is more obvious. s is borrowed by the Entry, which will live to the end of the block. Cloning s will fix that:

l.push(Foo { v: s.clone() }); //b

---

I only want to allocate s only once, not cloning it

But the type of Foo.v is String, so it will own its own copy of the str anyway. Just that type means you have to copy the s.

You can replace it with a &str instead which will allow it to stay as a reference into s:

struct Foo<'a> {
    v: &'a str,
}

pub fn main() {
    // s now lives longer than l
    let s = "aaa".to_string();
    let mut l = Vec::::new();
    {
        let mut hash = HashMap::<&str, usize>::new();

        let idx: usize = match hash.entry(&s) {
            Occupied(ent) => {
                *ent.get()
            }
            Vacant(ent) => {
                l.push(Foo { v: &s });
                ent.insert(l.len() - 1);
                l.len() - 1
            }
        };
    }
}

Note that, previously I had to move the declaration of s to before hash, so that it would outlive it. But now, l holds a reference to s, so it has to be declared even earlier, so that it outlives l.