Traits and generics

In plain English

A trait is a declaration of shared behaviour that lists method signatures, like a contract any type can promise to follow. You implement a trait for a type with an impl block, and the compiler checks that every method in the trait really exists on that type. A generic function is written with a type parameter in angle brackets, like fn with a T, so one function body can serve many concrete types. A trait bound such as T: Summary restricts a generic parameter to types that implement the trait, and impl Trait is a shorter way to write that bound in an argument or return position.

Step by step

1. 1Declare a trait with one or more method signatures.
2. 2Implement the trait for a struct in an impl block.
3. 3Write a generic function constrained by T: Summary.
4. 4Rewrite the same bound with impl Trait and compare the two forms.

trait Summary {
    fn summarize(&self) -> String;
}

struct Lesson {
    title: String,
    minutes: u32,
}

impl Summary for Lesson {
    fn summarize(&self) -> String {
        format!("{} ({} min)", self.title, self.minutes)
    }
}

fn print_summary<T: Summary>(item: &T) {
    println!("{}", item.summarize());
}

fn describe(item: &impl Summary) -> String {
    item.summarize()
}

fn main() {
    let lesson = Lesson {
        title: String::from("Traits and generics"),
        minutes: 14,
    };
    print_summary(&lesson);
    println!("{}", describe(&lesson));
}

Common mistakes

• Declaring a method in a trait but not implementing every one of them for a type fails to compile.
• Forgetting a bound on a generic means the body cannot call trait methods on the type parameter.
• Assuming a trait can hold fields is wrong; traits describe behaviour, not stored data.
• Using impl Trait where you need the concrete type again can be limiting, because the type is not named.