Rust Traits Explained: 7 Generic Patterns Pros Swear By

Traits and generics are Rust's answer to code reuse without runtime cost. You'll write one function that works for integers, strings, and your own structs, with the compiler generating a specialized copy for each. No inheritance trees required.

The learning curve is real: bound errors read like riddles until you learn to add one bound at a time. You'll decode those messages here with small examples.

Don't cargo-cult dyn everywhere though. You'll benchmark static against dynamic dispatch and see the 18% gap that decides the choice. Abstractions stay free.

A trait is a contract: a set of method signatures a type promises to fulfill. trait Summary { fn summarize(&self) -> String; } says any implementor can produce a one-line description. Types opt in with impl Summary for Article.

Traits can ship default method bodies that implementors inherit or override. Defaults keep small traits ergonomic: add fn teaser(&self) once, and every implementor gains it. Override only where custom behavior matters.

Generics abstract over types with compile-time specialization. fn print_summary<T: Summary>(item: &T) accepts any type implementing Summary, and the compiler emits one optimized copy per concrete type used. Each copy inlines fully.

Bounds are the key: T: Summary means only summarizing types qualify. Missing bounds produce E0277 errors naming the exact trait. Add bounds one at a time and re-run cargo check between each.

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

struct Article {
    title: String,
}

impl Summary for Article {
    fn summarize(&self) -> String {
        format!("Reading: {}", self.title)
    }
}

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

fn main() {
    let a = Article { title: String::from("Rust") };
    print_summary(&a);
}

impl Trait in argument position is shorthand for a generic parameter. fn notify(item: &impl Summary) reads cleaner than fn notify<T: Summary>(item: &T) for single-bound cases. Use it for public APIs with one or two simple bounds.

For returns, impl Trait hides the concrete type while keeping static dispatch. fn factory() -> impl Summary returns exactly one hidden type. Callers use it through the trait without naming it.

use std::fmt::Display;

trait Labeled {
    fn label(&self) -> String;
}

impl<T: Display> Labeled for T {
    fn label(&self) -> String {
        format!("item: {}", self)
    }
}

fn main() {
    println!("{}", 42.label());
}