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:

1. Adding a #[derive(Clone)] attribute to my Attribute struct
2. 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?

Answer 1

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.