Writing getter/setter properties in Rust

Question

I'm writing a very simple getter/setting model that I would like to start using in Rust for simplicity reasons using struct and impl.

struct Person {
    firstName: String,
    lastName: String,
}

impl Person {
    fn get_first_name(&mut self) -> String { return self.firstName; }
    fn get_last_name(&mut self) -> String {  return self.lastName; }

    fn set_first_name(&mut self, x: String) { self.firstName = x; }
    fn set_last_name(&mut self, x: String) { self.lastName = x; }

    fn default() -> Person {
        Person {firstName: "".to_string(), lastName: "".to_string()}
    }
}

fn main() {
    let mut my_person : Person = Person{ ..Person::default() };

    my_person.set_first_name("John".to_string());
    my_person.set_last_name("Doe".to_string());

    println!("{}", my_person.firstName);
    println!("{}", my_person.lastName);
}

When I run this snippet I get the following error.

src\main.rs:7:53: 7:57 error: cannot move out of borrowed content [E0507]
src\main.rs:7     fn get_first_name(&mut self) -> String { return self.firstName; }
                                                                  ^~~~
src\main.rs:8:53: 8:57 error: cannot move out of borrowed content [E0507]
src\main.rs:8     fn get_last_name(&mut self) -> String {  return self.lastName; }
                                                                  ^~~~
error: aborting due to 2 previous errors
Could not compile `sandbox`.

Can someone point out the mistake to me since I'm very new to Rust?

Tips on writing this snippet better would be accepted too. I'm always looking for easier/faster readability.

Answer 1

Ok, the specific problem here is not being able to move out of borrowed content. This has been answered numerous times before under a variety of conditions, not to mention the chapter on the subject of ownership in the Rust Book.

The more interesting one is about getters and setters. Yes, you can write them in Rust, but they may not be the best choice.

Before I go on, I just want to note that there is absolutely no reason to require &mut self on a getter... unless you intend to modify the value as part of removing the value, but then you're not really dealing with a getter any more.

Secondly, you should not clone in a getter. This is hugely wasteful if all the user wants to do is, for example, read from the value. It's better to return an immutable borrow, from which the user can clone if they need to.

Anyway, if you're writing these because you want some kind of logic run in order to validate new values, keep using setters. Otherwise, you could do something like this:

#[derive(Default)]
struct Person {
    first_name: String,
    last_name: String,
}

impl Person {
    // Immutable access.
    fn first_name(&self) -> &str {
        &self.first_name
    }
    fn last_name(&self) -> &str {
        &self.last_name
    }

    // Mutable access.
    fn first_name_mut(&mut self) -> &mut String {
        &mut self.first_name
    }
    fn last_name_mut(&mut self) -> &mut String {
        &mut self.last_name
    }
}

fn main() {
    let mut my_person = Person::default();

    *my_person.first_name_mut() = String::from("John");
    *my_person.last_name_mut() = "Doe".into();

    println!("first_name: {}", my_person.first_name());
    println!("last_name: {}", my_person.last_name());
    
    // Can't do this efficiently with getter/setter!
    {
        let s = my_person.last_name_mut();
        s.truncate(2);
        s.push('w');
    }

    println!("first_name: {}", my_person.first_name());
    println!("last_name: {}", my_person.last_name());
}

This gives users more-or-less direct access to the fields, without actually giving them direct access to the fields. In addition to writing new values, this also allows users to mutate existing values in-place, which can be important for large, heap-allocated things.

In addition, I made a few other changes:

• You can just mechanically derive Default; there's no reason in this case to write it yourself.

• Conventional style is snake_case for fields.

• The way you created the Person was needlessly roundabout.

Answer 2

Your getter method borrows self. When your return self.name, you're moving name from a borrowed reference which is not allowed. You should return a copy of name.

Also, You do not need to pass a mutable reference to self in the getter methods since you are not modifying the internal struct.

Therefore, your getter methods should be:

fn get_first_name(&self) -> &str {
    self.first_name.as_str()
}
fn get_last_name(&self) -> &str {
    self.last_name.as_str()
}

Answer 3

As the compiler points out, the mistake you are making is trying to move a value out of a variable that is behind a reference, but that explanation alone can be difficult to grasp on its surface without understanding why the move is occurring, and why it is "behind a reference", which IMO is not so obvious to the untrained eye so I'll try to explain that.

References are distinct types

In the signature of both get_first_name() and get_last_name() you have declared the parameter as &mut self. This means that in the body of these functions, the variable self has type &mut Person (pronounced "mutable reference to Person"), not Person. These two types are distinct and as with any pair of distinct types, there are different rules governing how you can use them, so it is important to think of them as different types.

Moving Rules

The &mut Person and Person types share a lot of similarities in how they can be used (specifically, those related to the Person API), but one major difference between how they can be used is that you can move values out of the fields of a Person instance, but not out of the fields of a &mut Person or a &Person: such types are said to be "behind a reference" or "borrowed"

Non Copy values have move semantics

Any value that has a type which does not implement the Copy trait moves whenever it is

• assigned to a variable
• passed into a function or method
• returned from a function or method

The body of your function is return self.firstName and this is trying to return the value in the firstName field to the caller. This value is of type String, which does not implement Copy, therefore this line means "move the value stored in the firstName field out of the struct instance to the caller of get_first_name(). But, since self is of type &mut Person, this is not allowed.

Answer 4

You can try to implement some kind of GettterSetter stuff. For example:

struct Person {
    first_name: Gettter<String>,
    last_name: GettterSetter<String>,
}

impl Person {
    fn new() -> Self {
        Self { 
            first_name: Gettter::new(|_| /*do_your_stuff_on_get*/),
            last_name: GettterSetter::new(
              |_| /*do_your_stuff_on_get*/,
              |val| /*do_your_stuff_on_set*/
            ),
        }
    }
}