[Moving Values] Accessing fields of a borrowed struct instance

[paschaldev]

In Chapter 5 (An Example program using stucts), the example uses a scalar type u32 for the Rectangle struct with this note underneath

... note that accessing fields of a borrowed struct instance does not move the field values, which is why you often see borrows of structs

https://doc.rust-lang.org/book/ch05-02-example-structs.html

I tried to write the Struct and referenced a string in the update_user function as seen in the image below. The compiler raised an error

   |   ^^^^^^^^^ move occurs because `user.name` has type `String`, which does not implement the `Copy` trait

Is that statement correct or do I not fully understand what it mean? Or does the statement only apply to types that implements the Copy trait? Can anyone explain what the problem is?

[StefanSalewski]

Yes I agree, that sentence does not really help. After some thinking, I read it finally as "read access". I think, when you have a reference to some struct, read access of a field is always allowed, e.g. you can read a character of a string. For your example, your function update_user() tries to return the name field, which is a move operation, as Rust avoids copies by default. So this is obviously not allowed.

PS: Do you have good reasons to post a picture, instead of plain text, that we can easier read and even copy and test? Or were you just testing the camera of your new smartphone?

[StefanSalewski]

A complete example for this would be

struct T {
    a: String,
}

fn main() {
    let mut t = T { a: "X".to_owned() };
    f(&mut t);
}

fn f(x: &mut T) {
    println!("{}", &x.a[0..1]); // read access to field
    x.a.replace_range(0..1, "Y"); // write access to field
    println!("{}", &x.a[0..1]);
    // let h = x.a; // error[E0507]: cannot move out of `x.a` which is behind a mutable reference
}

So we can read and modify fields of a struct, but we can not move a string out of a struct. Because, typically, if a struct is passed by reference to a function, the caller would like to continue using that struct after the function call. If no further usage is required, we could pass the struct by value.

I am unsure if this explanation makes sense in a book, or is too obvious. I might actually add it to my own book, but that one has already 500 pages, and my intention was initially to create a compact book.

[paschaldev]

Yes I agree, that sentence does not really help. After some thinking, I read it finally as "read access". I think, when you have a reference to some struct, read access of a field is always allowed, e.g. you can read a character of a string. For your example, your function update_user() tries to return the name field, which is a move operation, as Rust avoids copies by default. So this is obviously not allowed.

PS: Do you have good reasons to post a picture, instead of plain text, that we can easier read and even copy and test? Or were you just testing the camera of your new smartphone?

Hahahaha I wanted to show the terminal output as is that was why I sent a screenshot

[paschaldev]

A complete example for this would be

struct T {
a: String,
}

fn main() {
let mut t = T { a: "X".to_owned() };
f(&mut t);
}

fn f(x: &mut T) {
println!("{}", &x.a[0..1]); // read access to field
x.a.replace_range(0..1, "Y"); // write access to field
println!("{}", &x.a[0..1]);
// let h = x.a; // error[E0507]: cannot move out of x.a which is behind a mutable reference
}

So we can read and modify fields of a struct, but we can not move a string out of a struct. Because, typically, if a struct is passed by reference to a function, the caller would like to continue using that struct after the function call. If no further usage is required, we could pass the struct by value.

I am unsure if this explanation makes sense in a book, or is too obvious. I might actually add it to my own book, but that one has already 500 pages, and my intention was initially to create a compact book.

Thank you so much, this is way clearer now. I really appreciate the explanation. Is your book public?

[StefanSalewski]

Is your book public?

Yes, the online version is available at https://rust-for-c-programmers.com/

For the macros and async chapters I have still no idea who might write that. And if we will create a printed version is still uncertain.

[StefanSalewski]

I have finally decided to add that clarification to my book, see https://rust-for-c-programmers.com/ch9/9_2_defining_instantiating_and_accessing_structs.html#925-field-access-on-borrowed-structs. It might appear quite obvious, but for some readers that clarification might be useful, and it takes not that much space and is fast to read.