Chapter 10: Generic Data Types in Rust

Generics are abstract stand-ins for concrete types or other properties. In Rust, generic type parameters allow programmers to write flexible, reusable code without duplicating logic for every specific data type. Generics do not incur a runtime performance penalty, as Rust resolves generic declarations into concrete implementations at compile time.

1. The Core Problem: Code Duplication

Code duplication often occurs when the exact same algorithm needs to be executed across multiple data types. Consider a common task: finding the largest value in a list of elements.

When written directly inside a program's main routine, the logic might look like this for a list of 32-bit integers (i32):

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let mut largest = number_list[0];

    for number in number_list {
        if number > largest {
            largest = number;
        }
    }

    println!("The largest number is {}", largest);
}

If the program requires finding the largest number in a second vector, repeating the for loop logic leads to unnecessary code duplication:

fn main() {
    let number_list_1 = vec![34, 50, 25, 100, 65];
    let mut largest = number_list_1[0];
    for number in number_list_1 {
        if number > largest {
            largest = number;
        }
    }
    println!("The largest number is {}", largest);

    let number_list_2 = vec![102, 34, 6000, 89, 54];
    let mut largest = number_list_2[0];
    for number in number_list_2 {
        if number > largest {
            largest = number;
        }
    }
    println!("The largest number is {}", largest);
}

2. Step 1: Refactoring via Function Extraction

To clean up duplicated code, the first architectural step is to extract the concrete comparison logic into a standalone function.

fn get_largest(list: &[i32]) -> i32 {
    let mut largest = list[0];

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];
    let result = get_largest(&number_list);
    println!("The largest number is {}", result);

    let number_list_2 = vec![102, 34, 6000, 89, 54];
    let result = get_largest(&number_list_2);
    println!("The largest number is {}", result);
}

Extracting this function decouples the execution from the main body and simplifies logic maintenance.

3. Step 2: Limitations of Concrete Functions

While function extraction handles duplicate operations on a single type (i32), it fails when the same operation is needed on a different type, such as characters (char).

fn main() {
    let char_list = vec!['y', 'm', 'a', 'q'];

    // Compiler Error: Mismatched Types
    // Expected `i32`, found `char`
    let result = get_largest(&char_list); 
}

The Naive Fix: Duplicate Functions per Type

Without generics, supporting multiple data types requires creating dedicated, named functions for every single type:

fn get_largest_i32(list: &[i32]) -> i32 {
    let mut largest = list[0];
    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }
    largest
}

fn get_largest_char(list: &[char]) -> char {
    let mut largest = list[0];
    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }
    largest
}

This approach violates the DRY (Don't Repeat Yourself) principle. If the comparison logic ever needs to change, it must be updated in every typed copy of the function.

4. Generic Functions and Trait Bounds

Generics solve function duplication by replacing concrete types (i32, char) with abstract type parameters.

Generic Function Syntax

• Generic parameters are declared inside angle brackets (<T>) immediately following the function name.
• By standard Rust convention, generic parameters use short, uppercase identifiers starting with T (short for Type).

fn get_largest<T>(list: &[T]) -> T {
    // Logic goes here...
}

Understanding Compilation Errors on Generic Operators

If we naively rewrite the logic with generic type T:

// THIS WILL NOT COMPILE YET
fn get_largest<T>(list: &[T]) -> T {
    let mut largest = list[0];
    for &item in list.iter() {
        if item > largest { // Error: binary operation `>` cannot be applied to type `T`
            largest = item;
        }
    }
    largest
}

Note: Because T can be any possible type in Rust, the compiler cannot guarantee that T supports the greater-than (>) comparison operator or that elements of type T can be copied out of the slice.

Resolving Errors via Trait Bounds

To allow generic comparison and evaluation, T must be constrained using Trait Bounds (specifically PartialOrd for comparison and Copy for stack allocation):

fn get_largest<T: PartialOrd + Copy>(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];
    let result = get_largest(&number_list);
    println!("The largest number is {}", result); // 100

    let char_list = vec!['y', 'm', 'a', 'q'];
    let result = get_largest(&char_list);
    println!("The largest char is {}", result);   // 'y'
}

5. Generics in Struct Definitions

Structs can store fields of generic types, declared using angle brackets after the struct name.

Single Generic Type Parameter

When a struct uses a single generic parameter T, all fields assigned to T must strictly resolve to the same concrete type.

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let integer_point = Point { x: 5, y: 10 };       // Point<i32>
    let float_point = Point { x: 1.0, y: 4.0 };     // Point<f64>

    // Compiler Error: Mismatched Types
    // `x` is i32, so `y` is expected to be i32, but found f64
    // let invalid_point = Point { x: 5, y: 4.0 }; 
}

Multiple Generic Type Parameters

To allow fields inside a struct to possess distinct, heterogeneous types, specify multiple comma-separated generic parameters (e.g., T and U).

struct Point<T, U> {
    x: T,
    y: U,
}

fn main() {
    let both_integer = Point { x: 5, y: 10 };           // Point<i32, i32>
    let both_float = Point { x: 1.0, y: 4.0 };         // Point<f64, f64>
    let mixed_point = Point { x: 5, y: 4.0 };          // Point<i32, f64>
    let string_char_point = Point { x: "A", y: 'c' };  // Point<&str, char>
}

6. Generics in Enum Definitions

Like structs, enums hold generic data types across their variants. The standard library relies heavily on generic enums for error handling and optional values.

The Option<T> Enum

Option<T> abstracts the presence or absence of a value of any generic type T:

enum Option<T> {
    Some(T),
    None,
}

The Result<T, E> Enum

Result<T, E> uses two generic parameters to manage operations that may return a successful value (T) or an error (E):

enum Result<T, E> {
    Ok(T),
    Err(E),
}

7. Method Implementations with Generics (impl)

When implementing methods on generic structs or enums, generic type parameters must be declared immediately after impl so Rust recognizes the type inside the brackets as a generic parameter rather than a concrete type.

struct Point<T> {
    x: T,
    y: T,
}

// impl<T> informs Rust that T is generic, not a concrete type name
impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };
    println!("p.x = {}", p.x());
}

Note: The identifier name chosen in the impl parameter block is completely independent of the parameter name in the original struct definition. Writing impl<U> Point<U> is functionally identical to impl<T> Point<T>.

8. Specialized Method Implementations

Rust allows methods to be attached to concrete instantiations of a generic struct without generic parameters on the impl block. This limits method access to specific type instances.

struct Point<T> {
    x: T,
    y: T,
}

// Generic implementation for all types T
impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

// Specialized implementation restricted to Point<f64>
impl Point<f64> {
    fn distance_from_origin(&self) -> f64 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

fn main() {
    let p_int = Point { x: 5, y: 10 };
    let p_float = Point { x: 3.0, y: 4.0 };

    let x1 = p_int.x();    // Valid
    let x2 = p_float.x();  // Valid

    // p_int.distance_from_origin(); 
    // ERROR: method `distance_from_origin` not found on `Point<i32>`

    let dist = p_float.distance_from_origin(); // Valid: returns 5.0
}

9. Combining Struct Generics and Method Generics

A method defined within a generic struct implementation can introduce its own separate generic parameters, independent of those declared on the struct.

The mixup Pattern

In the example below, a method mixup takes a Point<T, U> instance and combines its x field with the y field of a secondary incoming Point<V, W> instance:

struct Point<T, U> {
    x: T,
    y: U,
}

impl<T, U> Point<T, U> {
    fn mixup<V, W>(self, other: Point<V, W>) -> Point<T, W> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
}

fn main() {
    let p1 = Point { x: 5, y: 10.4 };           // Point<i32, f64>
    let p2 = Point { x: "Hello", y: 'c' };       // Point<&str, char>

    let p3 = p1.mixup(p2);                      // Produces Point<i32, char>

    println!("p3.x = {}, p3.y = {}", p3.x, p3.y); // Output: p3.x = 5, p3.y = c
}

Data Flow Execution

Initial Instances:
p1: Point<i32, f64>    => x: 5,       y: 10.4
p2: Point<&str, char>  => x: "Hello", y: 'c'
      |
      | Calling p1.mixup(p2)
      v
Returned Instance:
p3: Point<i32, char>   => x: self.x (5), y: other.y ('c')

10. Performance and Compile-Time Execution: Monomorphization

A critical feature of Rust generics is that they are zero-cost abstractions. Using generic types does not make your program run any slower than it would with concrete types.

Monomorphization Process

Rust achieves zero-cost generics using Monomorphization. Monomorphization is the process of turning generic code into concrete code by filling in the specific types used at compile time.

Source Code vs. Compiled Code Comparison

1. Written Source Code:

fn main() {
    let integer = Some(5);
    let float = Some(5.0);
}

2. Generated Code Post-Monomorphization (Conceptual output from compiler):

enum Option_i32 {
    Some(i32),
    None,
}

enum Option_f64 {
    Some(f64),
    None,
}

fn main() {
    let integer = Option_i32::Some(5);
    let float = Option_f64::Some(5.0);
}

Because the compiler expands generic definitions into dedicated type implementations during compilation, runtime performance matches that of hand-written concrete functions.

Technical Summary Matrix

Summary and Key Takeaways

• Code Deduplication: Generics allow developers to express algorithms abstractly without writing duplicated functions or structures for every data type.
• Explicit Parameter Scoping: Generic identifiers (typically T, U, V) are declared inside angle brackets (<T>) following function, struct, or enum names.
• Field Constraints: In struct definitions with a single generic parameter (Point<T>), all generic fields must resolve to the identical concrete type at instantiation.
• Multiple Generics: Use separate generic parameters (Point<T, U>) to allow structural fields to accept distinct types simultaneously.
• Trait Bounds: Standard operations (such as > comparison) cannot be performed on plain generic parameters without declaring trait bounds (PartialOrd, Copy).
• Targeted Method Logic: Methods can be bound generically (impl<T> Point<T>) to serve all instances, or concretely (impl Point<f64>) to target specialized configurations.
• Zero-Cost Abstractions: Rust generics incur zero runtime execution cost because monomorphization expands generic code into dedicated concrete structures during compilation.