Where Clauses

use std::fmt::Display;

fn describe<T>(item: T) -> String
where
    T: Display,
{
    format!("Item: {}", item)
}

fn main() {
    println!("{}", describe(99));
}

use std::fmt::{Debug, Display};

fn compare<T, U>(a: T, b: U) -> String
where
    T: Display,
    U: Debug,
{
    format!("{} vs {:?}", a, b)
}

fn main() {
    println!("{}", compare(5, vec![1, 2]));
}

fn print_all<T>(items: Vec<T>)
where
    T: std::fmt::Display,
{
    for item in items {
        println!("{}", item);
    }
}

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

fn largest<T: PartialOrd + Copy>(items: &[T]) -> T
where
    T: std::fmt::Debug,
{
    let mut largest = items[0];
    for &item in items {
        if item > largest {
            largest = item;
        }
    }
    largest
}

fn main() {
    let numbers = [3, 7, 2, 9, 4];
    println!("{:?}", largest(&numbers));
}

1. Cramming many trait bounds directly into a generic parameter list, making the function signature hard to read, instead of using a where clause.
2. Assuming where clauses can express something inline bounds cannot -- they are equivalent in power, just more readable for complex cases.
3. Forgetting a where clause still needs each bound to be satisfiable by the actual types used when the function is called.

• where clauses move trait bounds out of the angle brackets into a dedicated section after the function signature.
• They are functionally equivalent to inline bounds, but greatly improve readability for functions with multiple constrained parameters.
• where clauses can express bounds on complex types, such as Vec<T> needing T: Clone.
• Idiomatic Rust prefers where clauses once a function has more than one or two simple bounds.