Traits and Generics

# CHAPTER 17

Traits and Generics #

1. Chapter Introduction #

2. Learning Objectives #

• Understand and define Traits.

• Implement a Trait on custom Structs.

• Write functions that use Generics (<T>).

• Constrain Generics using Trait Bounds.

3. Defining and Implementing a Trait #

1. Define the Trait

// Define a Trait named Summary
pub trait Summary {
    // Method signature only! No body.
    fn summarize(&self) -> String;
}

2. Implement the Trait on Structs

struct Article {
    headline: String,
    author: String,
}

struct Tweet {
    username: String,
    content: String,
}

// Implement the trait for Article
impl Summary for Article {
    fn summarize(&self) -> String {
        format!("{}, by {}", self.headline, self.author)
    }
}

// Implement the trait for Tweet
impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("@{} tweeted: {}", self.username, self.content)
    }
}

Now, both Article and Tweet possess the .summarize() method, even though they hold completely different data!

4. Generics (<T>) #

Imagine you want a function that returns the largest of two values. Instead of writing largesti32(a: i32, b: i32) and largestf64(a: f64, b: f64), you use a Generic Type Parameter, conventionally named T.

// <T> means this function takes some abstract type T
fn display_anything<T>(item: T) {
    // (We will see why this doesn't compile perfectly in a second!)
}

5. Trait Bounds (Fixing Generics) #

We must constrain the Generic using a Trait Bound. We tell the compiler: "This function accepts any type T, *as long as T implements the Summary trait*."

// <T: Summary> is the Trait Bound!
fn notify<T: Summary>(item: &T) {
    println!("Breaking news! {}", item.summarize());
}

fn main() {
    let tweet = Tweet {
        username: String::from("alice"),
        content: String::from("Rust is awesome!"),
    };

    // We can pass our tweet to the generic function!
    notify(&tweet);
}

6. Default Trait Implementations #

pub trait Summary {
    // Default implementation
    fn summarize(&self) -> String {
        String::from("(Read more...)")
    }
}

// Empty implementation block uses the default!
impl Summary for Article {}

7. Generic Structs #

// A Point that can hold either integers or floats
struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let integer_point = Point { x: 5, y: 10 };
    let float_point = Point { x: 1.0, y: 4.0 };
}

8. Common Mistakes #

• Missing Trait Imports: If you want to use a Trait's methods on a struct, the Trait *must* be in scope. If you import a User struct from another file but forget to import its Summary trait, the compiler will say .summarize() not found.

• Forgetting Trait Bounds: Writing <T> and trying to do math on it (T + T). The compiler will stop you because it doesn't know if T is a number or a String! You must bound it (e.g., <T: std::ops::Add>).

9. Best Practices #

• Implement Standard Traits: Rust has many standard traits you should implement for your structs, such as Debug (allows printing with {:?}) and Display (allows printing with {}).

10. Exercises #

1. 1. Create a trait called Vehicle with a method honk() -> String.

1. 2. Create a Car struct and a Truck struct. Implement Vehicle for both.

1. 3. Write a generic function make_sound<T: Vehicle>(v: &T) that prints the honk.

11. MCQs with Answers #

Q8. Can a Struct have a Generic type, like struct Point<T>? a) Yes b) No Answer: a) Yes.

Q9. If a Struct implements a Trait that has a default method, do you have to write custom logic for that method? a) Yes b) No, you can provide an empty impl block to use the default Answer: b) No, you can use the default.

12. Interview Questions #

• Q: Explain Polymorphism in Rust. How is it achieved without Class Inheritance? (Answer: Through Traits and Generics).

• Q: What is a Trait Bound, and why is it necessary for compilation safety?

13. Summary #

14. Next Chapter Recommendation #