How to push additional element to Vec<&Vec>?

Question

I am trying to accomplish something rather simple, but not sure how to do it in Rust.

I have a Vec<&Vec>, something like the below example.

[
 ["a1", "b2", "c3"],
 ["d1", "e2", "f3"],
 ["g1", "h2", "i3"]
]

I want to push an additional string at the end of each vector.

[
 ["a1", "b2", "c3", "something"],
 ["d1", "e2", "f3", "something"],
 ["g1", "h2", "i3", "something"]
]

What I've tried so far is below:

vec_of_strings
    .iter_mut()
    .map(|x| x.clone().push("something".to_string()))
    .collect::<Vec<_>>();

println!("{:?}", vec_of_strings);

But the output is showing that nothing is appended.

Answer 1

What you're doing creates a new Vec, it does not modify the exist ones. Indeed, the existing ones cannot be modified as you are borrowing them immutably (the & in Vec<&Vec<_>>).

Note that using .iter_mut() instead of .iter() is pointless here as you aren't mutating the elements.

Additionally, Vec::push() doesn't return anything, so the .to_string() invocation should be giving you a compile-time error. (I assume you meant to call this on the string literal instead.)

Fixing the above issues:

let new_vec_of_strings = vec_of_strings
  .iter()
  .map(|x| {
    let mut x = x.clone();
    x.push("something".to_string());
    x
  })
  .collect::<Vec<_>>();

println!("{:?}", new_vec_of_strings);

However, this all seems like an XY problem -- there is probably a better way to accomplish whatever your goal is.

Answer 2

If I understand correctly, You need to return a vec in map.

fn main() {
    let mut vec_of_strings = vec![
        vec!["a1", "b2", "c3"], 
        vec!["d1", "e2", "f3"], 
        vec!["g1", "h2", "i3"]
    ];
    println!("{:?}", vec_of_strings);
    
    let vec_of_strings: Vec<Vec<&str>> = vec_of_strings.iter_mut().map(|x| {x.push("something"); x.clone()}).collect();
    println!("{:?}", vec_of_strings);
}

Rust Playground

Answer 3

I think there's a misunderstanding on what the map method was made for. This methodis generally used for data transformations where the original values remain unchanged. What you are really doing here is causing a side effect, and the map method does not help you at all here.

Just use a for loop. It's not like you're saving keystrokes by using map and interators.

However, you mentioned you have a Vec<&Vec>. Having this type seems unfit for your purpose. Cloning the entire vec just to add 1 element is terrible for performance.

I see 2 choices: either have it fully owned, i.e. Vec<Vec>, or just make the inner Vecs mutable, as in Vec<&mut Vec>.

This is the first option, and I think this is the most idiomatic:

fn main() {
    let mut vec_of_strings = vec![
        vec!["a1", "b2", "c3"], 
        vec!["d1", "e2", "f3"], 
        vec!["g1", "h2", "i3"]
    ];
 
    for vec in vec_of_strings.iter_mut() {
        vec.push("something");
    }
    
    println!("{vec_of_strings:?}");
}

If having it in an owned form is not acceptable, then another option is to use Vec<&mut Vec>:

fn main() {
    fn main() {
    let mut vec_of_strings = vec![
        vec!["a1", "b2", "c3"], 
        vec!["d1", "e2", "f3"], 
        vec!["g1", "h2", "i3"]
    ];
    
    //suppose somehow a function gave you this:
    let vec_of_mut_strings: Vec<&mut Vec<_>> = vec_of_strings
        .iter_mut()
        .collect();
    
    for vec in vec_of_mut_strings {
        vec.push("something");
    }
    
    //notice that the original vec_of_strings change
    println!("{vec_of_strings:?}");
}
}

Answer 4

I assume your output looks like this:

[(), (), ()]

Here are some suggestions:

• Prefer using for_each for mutations instead of map:

  vec_of_strings
      .iter_mut()
      .for_each(|x| {
          x.push("something");
      });
  
  println!("{:?}", vec_of_strings);
  

  Note that this assumes that the vec_of_strings is defined similarly as such:

  let mut vec1 = vec!["a1", "b2", "c3"];
  let mut vec2 = vec!["d1", "e2", "f3"];
  let mut vec3 = vec!["g1", "h2", "i3"];
  let mut vec_of_strings: Vec<&mut Vec<&str>> = vec![&mut vec1, &mut vec2, &mut vec3];
  

  Playground

• The function in .map in your example doesn't return anything because Vec::push doesn't return the vector.

  Separate x to another line to return the vector.

  vec_of_strings.iter_mut()
      .map(|x| {
          x.push("something");
          x
      })
      .collect::<Vec<&str>>();
  

  Note that this assumes that the vec_of_strings is defined similarly as such:

  let mut vec1 = vec!["a1", "b2", "c3"];
  let mut vec2 = vec!["d1", "e2", "f3"];
  let mut vec3 = vec!["g1", "h2", "i3"];
  let mut vec_of_strings: Vec<&mut Vec<&str>> = vec![&mut vec1, &mut vec2, &mut vec3];
  

  Playground

• You might also like to be more explicit with the type of the vector elements (&str) when using map:

      .collect::<Vec<&str>>();
  

  instead of

      .collect::<Vec<_>>();
  

  which was inferred as Vec<()> by the compiler because of the return type of Vec::push in map (hence the output).

Answer 5

A solution that keeps the original format extending each array by one entry:

vec_of_strings
    .iter_mut()
    .map(|a| {
        let mut v = a.to_vec();
        v.push("something");
        let arr: [&str; 4] = v.try_into().unwrap();
        arr
    })
    .collect::<Vec<[&str; 4]>>();

Playground