Structures
Structs are like structs/classes in other languages. Structs have fields. We can instantiate structs.
struct User {
active: bool,
username: String,
email: String,
age: u32
}
let user1 = User {
email: String::from("user1@gmail.com"),
username: String::from("user1"),
active: true,
age: 20
};
Only mutable instances may be mutated:
let mut user2 = User {
email: String::from("user2@gmail.com"),
username: String::from("user2"),
active: true,
age: 19
};
user2.active = false;
Shortcuts
A bit like in JS, we can use the shorter way to instantiate objects:
fn create_object(username: String, email: String) -> User {
User {
username,
email, // or email: email
active: false,
age: 100
}
}
Also, we can create an instances based on other instances:
let user3 = User {
email: String::from("user3@example.com"),
..user2 // must come last
};
Tuple Structs
Tuples may be defined with a name, like this:
struct Color(i32, i32, i32);
struct Point(i32, i32, i32);
let black = Color(0, 0, 0);
let origin = Point(0, 0, 0);
The fields don’t have names, sometimes it’s ok for simple types.
Unit-like Structs
Structs may be completely empty:
struct AlwaysEqual;
let subject = AlwaysEqual;
It’s useful with traits.
Methods
Methods are defined outside of struct definition:
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn area(&self) -> u32 {
self.width * self.height
}
fn can_hold(&self, other: &Rectangle) -> bool {
self.width > other.width && self.height > other.height
}
}
The first paramtere of a method is &self
. It’s a sugar syntax for self: &Self
. We could also not use reference, or add mut
. The first case is rare
because it would take ownership. It could be useful if a method is supposed to
transform an object info something else end the original object would not be
needed anymore.
We can invoke methods like this:
let r = Rectangle();
let area = r.area(); // or Rectangle::area(&r);
Static methods
Methods may be defined as non-associated if they do not require an actual
instance of a type. In such a case, there is no need for the first parameter to
be Self
. Example of such a function is String::from()
. It’s also useful for
constuctors.