Generics and Functions

Generics allow you to write flexible, reusable code, avoiding duplication of logic for different data types. Instead of defining multiple functions or structures for different types (like i32, f64, or String), we can use a generic type parameter, conventionally represented by the letter T.

The Rust compiler manages generics using a process called monomorphization: during compilation, it generates a copy of the generic code for each concrete type that is actually used. This means there is zero runtime performance overhead.

Generic Functions

To define a generic function, we insert the type parameter <T> right after the function name and before the argument list:

fn print_value<T: std::fmt::Debug>(value: T) {
    println!("Value: {:?}", value);
}

In generic functions, we can use the generic type T for both argument types and return types:

fn identity<T>(value: T) -> T {
    value
}

Generic Structs

We can also use generic type parameters inside structures (struct) to define flexible fields:

struct KeyValuePair<K, V> {
    key: K,
    value: V,
}

fn main() {
    let pair = KeyValuePair {
        key: String::from("age"),
        value: 30,
    };
}

In an impl block for a generic struct, we must declare the type parameter <T> immediately after the impl keyword to indicate we are implementing methods on a generic structure:

struct Container<T> {
    value: T,
}

impl<T> Container<T> {
    fn new(value: T) -> Self {
        Container { value }
    }

    fn value(&self) -> &T {
        &self.value
    }
}

Try it yourself

Exercise 1: The Point Struct

Exercise 2: Reversing a Tuple with swap

Exercise 3: The Container Struct