CODEWITHSUNDEEP
rust
Chris
Chris

Reputation: 570

Is there an elegant solution to modifying a structure while iterating?

I'm trying to build a vector of points that are changed while iterating over them:

struct Point {
    x: i16,
    y: i16,
}

fn main() {
    let mut points: Vec<Point> = vec![];
    // unsure if point is mutable
    points.push(Point { x: 10, y: 10 });
    // thus trying it explicitly
    let mut p1 = Point { x: 20, y: 20 };
    points.push(p1);

    for i in points.iter() {
        println!("{}", i.x);
        i.x = i.x + 10;
    }
}

When compiling, I get the error:

error[E0594]: cannot assign to immutable field `i.x`
  --> src/main.rs:16:9
   |
16 |         i.x = i.x + 10;
   |         ^^^^^^^^^^^^^^ cannot mutably borrow immutable field

As I learned here, Rust doesn't allow modifying the structure while iterating over it, thus the error.

How do I modify it in an elegant way? If I read this answer and get it right then the following comes to my mind:

  1. pop the item from the vector, modify it and push it back.
  2. create a temporary structure where I push the changed items to and replace original structure with the temporary one outside the loop (how?).

While I think I can get (1) working, I'm not really happy about all this pop's and push's (is this high-performance anyhow?). Concerning (2), I have no idea how to get it working - if this would work at all.

Questions:

  1. Is (2) an solution and if yes, how would it look like?
  2. Are there any other solutions?
  3. What's the advantage or disadvantage of the different solutions, especially with respect to performance?

Upvotes: 26

Views: 17209

Answers (2)

Rufus
Rufus

Reputation: 5566

Not the best option in your specific case, but option 2 would look something like this (we can iterate over the collected result directly to skip the temporary Vec variable). This would be useful if you're modifying an element not pointed at by the iterator.

    for (idx, point) in points
        .iter()
        .enumerate()
        .map(|(a, b)| (a, *b)) // Clone the Points (by dereferencing)
        .collect::<Vec<(usize, Point)>>() // collect the iterator, i.e. creating the temporary Vec
    {
        println!("{}", point.x);
        points[idx].x = point.x + 10;
    }

Upvotes: -1

user395760
user395760

Reputation:

You cannot modify the structure you are iterating over, that is, the vector points. However, modifying the elements that you get from the iterator is completely unproblematic, you just have to opt into mutability:

for i in points.iter_mut() {

Or, with more modern syntax:

for i in &mut points {

Mutability is opt-in because iterating mutably further restricts what you can do with points while iterating. Since mutable aliasing (i.e. two or more pointers to the same memory, at least one of which is &mut) is prohibited, you can't even read from points while the iter_mut() iterator is around.

Upvotes: 34

Related Questions