```rust
// Define a struct named `Person`
// with three fields: `first_name`,
// `last_name`, and `age`.
struct Person {
    first_name: String,
    last_name: String,
    age: u32,
}

// Implement a method for the `Person` struct.
impl Person {
    fn full_name(&self) -> String {
        format!("{} {}", self.first_name, self.last_name)
    }
}

fn main() {
    // Create a new instance of the `Person` struct.
    let person = Person {
        first_name: String::from("John"),
        last_name: String::from("Doe"),
        age: 30,
    };

    // Access the fields of the `Person` struct.
    println!("First Name: {}", person.first_name);
    println!("Last Name: {}", person.last_name);
    println!("Age: {}", person.age);

    // Call the method on the `Person` instance.
    let full_name = person.full_name();
    println!("Full Name: {}", full_name);
}
```

Example of Struct - Rust Programming

Traits in Rust are a way to define shared behavior among different types. They are similar to interfaces in languages like Java or TypeScript. Traits define a set of methods that can be implemented by any type that wants to adhere to that behavior. Traits provide a way to define common functionality.

Traits - Rust Programming

Structs are user-defined data types that allow you to group related values of different data types under one name. They are similar to structures in C/C++ or objects in other languages. They are primarily used to organize and represent data.

University of Michigan - Ann Arbor

Immutable references, which are also called shared references, enable you to retrieve a value without making any changes to it. Numerous immutable references can exist concurrently to a value.

Immutable Reference - Rust Programming

Mutable references, also known as exclusive references, allow you to access and modify a value. However, only one mutable reference to a value can exist within a given scope, ensuring that no data races occur.

Mutable Reference - Rust Programming

rust-lang.org

```rust
fn main() {
    let s1 = String::from("hello");

    // Pass an immutable reference to the function
    let len = calculate_length(&s1);

    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}
// s goes out of scope, but since
// it's a reference, nothing is freed
```

Example of Immutable Reference - Rust Programming

Struct - Rust Programming

```rust
fn main() {
    let mut s1 = String::from("hello");

    // Pass a mutable reference to the function
    change(&mut s1);

    println!("{}", s1);
}

fn change(s: &mut String) {
    s.push_str(", world");
}
// s goes out of scope, but since
// it's a mutable reference, nothing is freed
```

Learn Before

Related

Learn After