"Structs and Traits: Instance and Call"

Putting It All Together: Instantiation and Calling

You've already defined a trait and implemented it. The final step is surprisingly straightforward. Once a trait is implemented for a struct, the trait's methods become available on instances of that struct, just as if they were regular methods defined directly on the struct itself.

The process is two-fold:

1. Instantiate the struct: You create an instance of your struct just like you normally would.
2. Call the method: You use dot notation (.) on the instance to call the method from the trait.

Let's watch a short video that demonstrates this final step. It continues with the Summary trait example we've seen before, creating instances of NewsArticle and SocialPost and then calling the summarize method on them.

As you saw in the video, after all the setup of defining and implementing the trait, using it is as simple as:

// 1. Instantiate the struct
let article = NewsArticle { ... };

// 2. Call the trait method on the instance
println!("{}", article.summarize());

This seamless integration is a key design feature of Rust. The compiler knows that NewsArticle implements Summary, so it makes the summarize method available on any NewsArticle instance.

A Complete, Self-Contained Example

To help solidify all three steps we've covered in this course, let's look at one complete, practical example that shows defining, implementing, and using a trait all in one place.

The following resource provides a Shape trait with two structs, Circle and Rectangle, that implement it.

This Shape example is a classic use case for traits. It lets you define a common interface for a group of related types, enabling you to treat them uniformly while respecting their individual differences in behavior.

Your Turn: Putting It All into Practice

Now, let's do one final exercise to put your knowledge to the test. Below are the definitions and implementations for an Animal trait and two structs, Dog and Cat.

Your task is to write the main function to make the code run and produce the expected output.

// Trait definition
trait Animal {
    fn speak(&self) -> String;
}

// Structs
struct Dog;
struct Cat;

// Implementations
impl Animal for Dog {
    fn speak(&self) -> String {
        "Woof!".to_string()
    }
}

impl Animal for Cat {
    fn speak(&self) -> String {
        "Meow!".to_string()
    }
}

// YOUR TASK: Write the main function here.
// It should:
// 1. Create an instance of a Dog.
// 2. Print what the dog says by calling its `speak` method.
// 3. Create an instance of a Cat.
// 4. Print what the cat says by calling its `speak` method.

fn main() {
    // Your code goes here!
}

Copy the code above into an editor or the Rust Playground and complete the main function.

fn main() {
    // 1. Create an instance of a Dog.
    let my_dog = Dog;

    // 2. Print what the dog says.
    println!("The dog says: {}", my_dog.speak());

    // 3. Create an instance of a Cat.
    let my_cat = Cat;

    // 4. Print what the cat says.
    println!("The cat says: {}", my_cat.speak());
}

The dog says: Woof!
The cat says: Meow!

Conclusion and Next Steps

Congratulations! You have successfully completed this course and now understand the full, fundamental workflow of using traits in Rust.

Key Takeaways from this Lesson:

• To use a trait method, you first instantiate the struct that implements it.
• You then call the method using dot notation (instance.method()) just like any other method.
• Traits allow different types to share method names while having unique, type-specific behavior.

Course Recap:
Over these three lessons, we've covered the core cycle of traits:

1. Defining a shared interface with trait.
2. Implementing that interface for a concrete type with impl Trait for Type.
3. Using the shared behavior by creating an instance and calling the methods.

You now have a solid foundation in one of Rust's most important and powerful features.

Where to Go from Here?
This is just the beginning. If you're curious to learn more, here are some topics that build directly on what you've learned:

• Traits as Parameters: Writing functions that accept any type that implements a particular trait (e.g., fn print_summary(item: &impl Summary)).
• Trait Bounds: A more general way of using traits with generic type parameters.
• Standard Library Traits: Exploring common traits provided by Rust itself, such as Display (for custom printing), Debug (for developer-focused printing), and Clone (for creating copies of objects).

Thank you for taking this course. Happy coding in Rust