Trait bound

Constrain a generic parameter with <T: Trait>.

Trait bounds

A trait bound says which behaviours a generic type must have. Writing T: Display lets T values be printed with {} inside the function:

use std::fmt::Display;

fn cerceve<T: Display>(x: T) -> String {
    format!("[{}]", x)
}

println!("{} {}", cerceve(5), cerceve("a"));   // [5] [a]

The bound both permits the function body and restricts the caller: calling with a type that doesn't implement Display is a compile error.

Without a bound

Without a bound the compiler assumes nothing about T, and the error message says what's missing:

fn cerceve<T>(x: T) -> String {
    format!("[{}]", x)
}
// error[E0277]: `T` doesn't implement `std::fmt::Display`
// help: consider restricting type parameter `T`
//   fn cerceve<T: std::fmt::Display>(x: T)

Following the compiler's suggestion is often the fastest way to find the right bound.

Exercise Frame it

Write the function fn cerceve<T: Display>(x: T) -> String above. Print the results for 5, "a" and 2.5 on one line separated by spaces.

Show example solution

use std::fmt::Display;

fn cerceve<T: Display>(x: T) -> String {
    format!("[{}]", x)
}

fn main() {
    println!("{} {} {}", cerceve(5), cerceve("a"), cerceve(2.5));
}

Test yourself

Why doesn't <code>cerceve(vec![1, 2])</code> compile?
- It compiles
- Vec<i32> doesn't implement Display
- Vec can't be generic
- Two elements is too many
Show answer

Vec<i32> doesn't implement Display — Vectors print with {:?} (Debug); {} needs Display, which Vec doesn't implement.

Printable

fn cerceve<T: ____>(x: T) -> String {
    format!("[{}]", x)
}

Show answer

fn cerceve<T: Display>(x: T) -> String {
    format!("[{}]", x)
}

Bound and what it permits

T: Display

Printing with {}
T: Debug

Printing with {:?}
T: PartialOrd

< and > comparison
T: Clone

.clone()

Next lesson: Multiple bounds

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies