> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Rust 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 (``) 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. ```rust theme={"dark"} struct Point { 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: ```rust theme={"dark"} struct Pair { 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`. ```rust theme={"dark"} impl Point { 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. ```rust theme={"dark"} impl Point { 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):** ```rust theme={"dark"} impl Point { fn print_coordinates(&self) { println!("({}, {})", self.x, self.y); } } ``` **Bound on the struct definition (Strict):** ```rust theme={"dark"} struct BoundedPoint { 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`. 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. ```rust theme={"dark"} use std::marker::PhantomData; struct StateMachine { state_id: u32, _marker: PhantomData, } ```

Tired of Poor Rust Skills? Fix That With Deep Grasping! Learn More