Trait Bounds

use std::fmt::Display;

fn print_it<T: Display>(item: T) {
    println!("Item: {}", item);
}

fn main() {
    print_it(42);
    print_it("text");
}

use std::fmt::Debug;

fn show<T: Debug + Clone>(item: T) {
    let copy = item.clone();
    println!("{:?}", copy);
}

fn main() {
    show(vec![1, 2, 3]);
}

use std::fmt::Display;

fn announce(item: impl Display) {
    println!("Announcing: {}", item);
}

fn main() {
    announce("New release");
}

use std::fmt::Display;

fn combine<T, U>(a: T, b: U) -> String
where
    T: Display,
    U: Display,
{
    format!("{} and {}", a, b)
}

fn main() {
    println!("{}", combine(1, "two"));
}

1. Trying to call a trait's method inside a generic function without first constraining the type parameter with that trait.
2. Writing overly restrictive trait bounds that exclude types which would otherwise work fine.
3. Confusing impl Trait parameter syntax with generic <T: Trait> syntax -- they're closely related but not always interchangeable.

• A trait bound, written T: TraitName, restricts a generic type parameter to types implementing that trait.
• Multiple bounds can be combined with +, e.g. T: Debug + Clone.
• impl Trait in a parameter position is shorthand syntax for a simple, single-use trait bound.
• where clauses offer an alternative, more readable syntax for expressing bounds, especially with multiple parameters.