Traits and Trait Objects in Rust

Welcome to this lesson on Traits and Trait Objects in Rust! In previous lessons, you learned about foundational Rust concepts such as structs, enums, and generics. These are crucial for building reusable and flexible code. Now, we'll dive into traits and trait objects, which allow you to define shared behavior for different types. Understanding these concepts will enable you to write more expressive and maintainable code.

By the end of this lesson, you will understand how traits define common behavior, how to implement traits with default methods, how to use associated types and constants within traits, and how traits interact with generics through trait bounds. You'll also learn about the differences between static and dynamic dispatch and their performance implications. Let's explore these ideas step by step.

Traits work closely with generics through trait bounds, which specify that a generic type parameter must implement a particular trait. This enables static dispatch, where the compiler generates specific code for each type via monomorphization (this term sounds familiar, right? If not, check the previous unit!).

For example, we can define a generic function print_area that accepts any type T implementing the Shape trait:

fn print_area<T: Shape>(shape: &T) {
    println!("The area is {}", shape.area());
}

Here, T: Shape is a trait bound that ensures T implements Shape. This allows print_area to work with any shape type that implements the trait. That is, we can now use print_area with both Circles and Rectangles:

fn main() {
    let circle = Circle { radius: 5.0 };
    let rectangle = Rectangle { width: 4.0, height: 6.0 };

    print_area(&circle);     // The area is 78.54
    print_area(&rectangle);  // The area is 24.0
}

This demonstrates how trait bounds and generics allow us to write functions that can operate on any type that implements a given trait, providing flexibility and type safety.