How to retrieve a user-defined type from a for loop?

Question

I defined an Attribute type and I have a Vec<Attribute> that I am looping over to retrieve the "best" one. This was similar to my first attempt:

#[derive(Debug)]
struct Attribute;

impl Attribute {
    fn new() -> Self {
        Self
    }
}

fn example(attrs: Vec<Attribute>, root: &mut Attribute) {
    let mut best_attr = &Attribute::new();
    for a in attrs.iter() {
        if is_best(a) {
            best_attr = a;
        }
    }
    *root = *best_attr;
}

// simplified for example
fn is_best(_: &Attribute) -> bool {
    true
}

I had the following compile error:

error[E0507]: cannot move out of borrowed content
  --> src/lib.rs:17:13
   |
17 |     *root = *best_attr;
   |             ^^^^^^^^^^ cannot move out of borrowed content

After some searching for a solution, I resolved the error by doing the following:

Adding a #[derive(Clone)] attribute to my Attribute struct
Replacing the final statement with *root = best_attr.clone();

I don't fully understand why this works, and I feel like this is a rough solution to the problem I was having. How does this resolve the error, and is this the correct way to solve this problem?

Not a Rust expert, but IIRC it's because `root` has different scope than `best_attr`, and `best_attr`'s memory could be reclaimed by the time `root` would have a chance to reference it. So it's not allowed. `clone()` provides a scope-compatible copy, so it's allowed. — WeaponsGrade, Nov 15 '14 at 04:06
Short answer: it boils down to Rust’s ownership model. Only one thing can own a piece of data at a time. — Chris Morgan, Nov 15 '14 at 04:58
Note that creating a default attribute first is wasteful, instead you could probably set `best_attr` to `None`, and then have `best_attr = Some(a)` in your loop. Of course, it would require having some pattern matching at the end. — Matthieu M., Nov 15 '14 at 14:45

score 2 · Accepted Answer · edited Feb 05 '19 at 01:09

You are experiencing the basis of the Rust memory model:

every object can (and must!) be owned by only exactly one other object
most types are never implicitly copied and always moved (there are some exceptions: types that implement Copy)

Take this code for example:

let x = String::new();
let y = x;
println!("{}", x);

it generates the error:

error[E0382]: borrow of moved value: `x`
 --> src/main.rs:4:20
  |
3 |     let y = x;
  |             - value moved here
4 |     println!("{}", x);
  |                    ^ value borrowed here after move
  |
  = note: move occurs because `x` has type `std::string::String`, which does not implement the `Copy` trait

x, of type String, is not implicitly copyable, and thus has been moved into y. x cannot be used any longer.

In your code, when you write *root = *best_attr, you are first dereferencing the reference best_attr, then assigning the dereferenced value to *root. Your Attribute type is not Copy, thus this assignment should be a move.

Then, the compiler complains:

cannot move out of borrowed content

Indeed, best_attr is an immutable reference, which does not allow you to take ownership of the value behind it (it doesn't even allow modifying it). Allowing such a move would put the object owning the value behind the reference in an undefined state, which is exactly what Rust aims to prevent.

In this case, your best option is indeed to create a new object with the same value as the first one, which is exactly what the trait Clone is made for.

#[derive(Clone)] allows you to mark your structs as Clone-able, as long as all of their fields are Clone. In more complex cases, you'll have to implement the trait by hand.

How to retrieve a user-defined type from a for loop?

1 Answers1