Generic Struct

A generic struct in Rust is a composite data type parameterized over one or more types. By declaring type parameters within angle brackets (<T>) immediately following the struct name, the struct defers the concrete type resolution of its fields until instantiation. The Rust compiler resolves these generics at compile time through a process called monomorphization, generating specific, statically-typed implementations for each concrete type used, ensuring zero runtime overhead.

Syntax and Declaration

Type parameters are declared in the struct signature and then applied to the types of the internal fields.

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

In this definition, T represents a single concrete type. Because both x and y are typed as T, they must be instantiated with the exact same type. Attempting to mix types (e.g., assigning an i32 to x and an f64 to y) will result in a compiler error.

To allow fields to hold different types, multiple type parameters must be declared:

struct Pair<T, U> {
    first: T,
    second: U,
}

Implementation Blocks (impl)

When defining methods for a generic struct, the type parameters must be declared on the impl block before they can be applied to the struct name. This tells the compiler that the impl block is generic over T.

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

You can also write implementation blocks targeting a specific concrete type. Methods defined in this block will only be available to instances of the struct instantiated with that exact type.

impl Point<f32> {
    fn distance_from_origin(&self) -> f32 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

Trait Bounds

Type parameters can be constrained using trait bounds, ensuring that the generic type implements specific behavior. While trait bounds can be placed directly on the struct definition, idiomatic Rust typically places them on the impl block to avoid redundant bound declarations across the codebase.

Bound on the impl block (Idiomatic):

impl<T: std::fmt::Display> Point<T> {
    fn print_coordinates(&self) {
        println!("({}, {})", self.x, self.y);
    }
}

Bound on the struct definition (Strict):

struct BoundedPoint<T: std::fmt::Display> {
    x: T,
    y: T,
}

Unused Type Parameters and PhantomData

Rust enforces strict rules regarding generic parameters: every type parameter declared in the struct signature must be consumed by at least one field. If a type parameter is required for logical or type-state purposes but does not represent data stored in memory, the compiler will reject the definition.

To bypass this, you must use std::marker::PhantomData<T>. This is a zero-sized type that tells the compiler to act as though the struct owns an instance of T, preserving the type parameter without affecting the struct’s memory layout.

use std::marker::PhantomData;

struct StateMachine<T> {
    state_id: u32,
    _marker: PhantomData<T>,
}

Master Rust with Deep Grasping Methodology!

Learn More