Generics

This lesson covers generics, which let you write one function that works with many types.

Generics use the <T> notation to declare a type variable whose actual type is decided later. The same logic can then be reused across different types.

The sample code defines fn largest<T: PartialOrd + Copy>(list: &[T]) -> T and finds the largest value in a slice of numbers. PartialOrd is the constraint (the trait bound) meaning "can be compared".

A common early stumble is specifying those trait bounds. Whatever you want to do with the generic type T — compare it, copy it — has to be stated explicitly as a constraint.

In professional work, much of the standard library, including Vec and Option, is implemented with generics.

📖 Reference code

fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
    let mut result = list[0];
    for &item in list {
        if item > result {
            result = item;
        }
    }
    result
}

fn main() {
    let numbers = vec![34, 50, 25, 100, 65];
    println!("Largest: {}", largest(&numbers));
}

✍️ Your code

Type your code, then press "Run"

🧪 This site can't compile or run Rust directly, so it checks on the spot whether what you typed matches the reference code (scoring happens entirely in your browser — nothing is sent anywhere).