Trait Bounds

Bounds constrain generic parameters so code can call trait methods safely: T: Display, where clauses, and multiple bounds with +.

Recipe

use std::fmt::Display;
 
fn print_all<T: Display>(items: &[T]) {
    for item in items {
        println!("{item}");
    }
}
 
fn compare<T>(a: T, b: T) -> T
where
    T: PartialOrd,
{
    if a > b { a } else { b }
}

When to reach for this: Any generic function using trait methods; prefer where for readable complex bounds.

Working Example

use std::fmt::{Debug, Display};
 
fn report<T>(value: T) -> String
where
    T: Debug + Display,
{
    format!("user sees {value}, debug {value:?}")
}
 
fn main() {
    println!("{}", report(42));
}

What this demonstrates:

• Multiple bounds Debug + Display
• where clause separates bounds from signature
• Bounds checked at compile time per monomorphized T
• Violation fails at call site with clear error

Deep Dive

impl Trait sugar

fn f(x: impl Display) == fn f<T: Display>(x: T) for one parameter.

Higher-ranked bounds

for<'a> for fns needing any lifetime - advanced with Fn traits.

Lifetime bounds

T: 'a - values in T cannot borrow shorter than 'a.

Gotchas

• Bound too weak - Missing method on T. Fix: Add trait to bound list.
• Bound too strong - Limits usable types. Fix: Split functions or use trait objects.
• Conflicting blanket impls - Two overlapping auto impls. Fix: Avoid impossible blanket patterns.
• where clause explosion - Unreadable. Fix: Type aliases type SerializeMap = ....
• impl Trait in return not object-safe mix - Cannot return different impl Trait types. Fix: Enum or Box<dyn Trait>.

Alternatives

FAQs

Related

• Generics
• Common Standard Traits
• Static vs Dynamic Dispatch
• Blanket & Conditional Impls

Stack versions: This page was written for Rust 1.97.0 (edition 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, and Polars 0.46+.