```rust
// Define a trait named `Speak`
// with a single method `speak`.
trait Speak {
    fn speak(&self);
}

// Define a struct named `Human`.
struct Human {
    name: String,
}

// Implement the `Speak` trait for the `Human` struct.
impl Speak for Human {
    fn speak(&self) {
        println!("Hello, my name is {}.", self.name);
    }
}

// Define a struct named `Dog`.
struct Dog {
    name: String,
}

// Implement the `Speak` trait for the `Dog` struct.
impl Speak for Dog {
    fn speak(&self) {
        println!("Woof! My name is {}.", self.name);
    }
}

fn main() {
    // Create instances of `Human` and `Dog`.
    let person = Human {
        name: String::from("Alice"),
    };
    let dog = Dog {
        name: String::from("Buddy"),
    };

    // Call the `speak` method, which is
    // implemented via the `Speak` trait.
    person.speak();
    dog.speak();

    // Alternatively, use a function that takes
    // a reference to a `Speak` trait object.
    introduce_speaker(&person);
    introduce_speaker(&dog);
}

fn introduce_speaker(speaker: &dyn Speak) {
    speaker.speak();
}
```

Example of Trait - Rust Programming

Macros in Rust are a way to define reusable chunks of code that are expanded at compile time. They are similar to macros in C/C++ and Lisp-like languages. Macros allow you to write code that generates other code, which can help reduce boilerplate and repetitive code. They can be used to create custom control structures or other constructs.

Macros - 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.

University of Michigan - Ann Arbor

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.

Struct - Rust Programming

rust-lang.org

```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);
}
```

Learn Before

Related

Learn After