Rust generics let you write flexible and reusable code that can work with different data types without repeating the same logic.

Instead of creating separate functions, structs, or enums for i32, f64, String, and other types, you can use a generic type parameter.

Generics are an important part of Rust because they help make code:

• Reusable
• Type-safe
• Cleaner
• Easier to maintain
• More flexible

This guide explains Rust generics with simple examples for beginners.

---

What Are Generics in Rust?

Generics are placeholders for types.

For example, imagine you want a function that returns the larger of two values.

Without generics, you might write separate functions:

fn largest_i32(a: i32, b: i32) -> i32 {
    if a > b {
        a
    } else {
        b
    }
}

And another one for f64:

fn largest_f64(a: f64, b: f64) -> f64 {
    if a > b {
        a
    } else {
        b
    }
}

Both functions contain almost the same logic.

Generics allow you to write the logic once and use it with different types.

A generic type is usually represented by a letter such as:

T
U
V

T commonly means “Type”.

---

Basic Syntax of Rust Generics

A generic type parameter is written inside angle brackets.

<T>

For example:

fn display_value<T>(value: T) {
}

Here:

• T is the generic type parameter.
• value has the type T.
• The actual type is decided when the function is called.

---

Generic Functions in Rust

Generic functions allow the same function to work with different data types.

Consider this example:

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

fn main() {
    print_value(10);
    print_value(25.5);
    print_value("Hello Rust");
}

Output:

10
25.5
Hello Rust

The same function works with:

i32
f64
&str

The Display part tells Rust that T must support formatted output with {}.

---

Why Does Rust Need Type Constraints?

You cannot perform every operation on every possible type.

For example:

fn largest<T>(a: T, b: T) -> T {
    if a > b {
        a
    } else {
        b
    }
}

Rust will produce an error because it does not know whether every possible T supports the > operator.

To fix this, you need a trait bound.

fn largest<T: PartialOrd>(a: T, b: T) -> T {
    if a > b {
        a
    } else {
        b
    }
}

Now Rust knows that T must support comparison.

Example:

fn largest<T: PartialOrd>(a: T, b: T) -> T {
    if a > b {
        a
    } else {
        b
    }
}

fn main() {
    let result1 = largest(10, 20);
    let result2 = largest(4.5, 2.1);

    println!("{}", result1);
    println!("{}", result2);
}

Output:

20
4.5

---

Generic Structs in Rust

Generics are not limited to functions.

You can also create generic structs.

For example:

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

Here both x and y must have the same type.

You can create an integer point:

let point1 = Point {
    x: 10,
    y: 20,
};

Or a floating-point point:

let point2 = Point {
    x: 5.5,
    y: 8.2,
};

Full example:

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

fn main() {
    let point1 = Point {
        x: 10,
        y: 20,
    };

    let point2 = Point {
        x: 2.5,
        y: 7.8,
    };

    println!("Point 1: {}, {}", point1.x, point1.y);
    println!("Point 2: {}, {}", point2.x, point2.y);
}

---

Using Multiple Generic Types

Sometimes a struct needs fields with different types.

You can use more than one generic parameter.

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

Now x and y can have different types.

Example:

fn main() {
    let point = Point {
        x: 10,
        y: 5.5,
    };
}

Here:

T = i32
U = f64

Another example:

struct UserData<T, U> {
    id: T,
    name: U,
}

fn main() {
    let user = UserData {
        id: 101,
        name: "Ankit",
    };

    println!("ID: {}", user.id);
    println!("Name: {}", user.name);
}

---

Generic Enums in Rust

Rust enums can also use generics.

Two common Rust enums already use generics:

Option<T>
Result<T, E>

Option

Option<T> represents a value that may or may not exist.

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

Example:

let age: Option<i32> = Some(25);

Here:

T = i32

Another example:

let username: Option<String> = Some(String::from("Ankit"));

Here:

T = String

---

Result<T, E>

Result<T, E> uses two generic types.

Conceptually:

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

Here:

• T represents a successful value.
• E represents an error value.

Example:

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err(String::from("Cannot divide by zero"))
    } else {
        Ok(a / b)
    }
}

In this example:

T = i32
E = String

---

Implementing Methods on Generic Structs

You can also create methods for generic structs.

Example:

struct BoxValue<T> {
    value: T,
}

impl<T> BoxValue<T> {
    fn get_value(&self) -> &T {
        &self.value
    }
}

Full example:

struct BoxValue<T> {
    value: T,
}

impl<T> BoxValue<T> {
    fn get_value(&self) -> &T {
        &self.value
    }
}

fn main() {
    let number = BoxValue {
        value: 100,
    };

    println!("{}", number.get_value());
}

Output:

100

The method works with any type stored inside BoxValue.

---

Methods for a Specific Generic Type

You can also create methods that are available only for a specific type.

Example:

struct Value<T> {
    data: T,
}

impl Value<i32> {
    fn double(&self) -> i32 {
        self.data * 2
    }
}

Now double() is available only when Value contains an i32.

Example:

fn main() {
    let value = Value {
        data: 20,
    };

    println!("{}", value.double());
}

Output:

40

---

Generic Functions with Multiple Types

A function can also accept multiple generic type parameters.

Example:

fn show_values<T: std::fmt::Display, U: std::fmt::Display>(
    first: T,
    second: U,
) {
    println!("{}", first);
    println!("{}", second);
}

Usage:

fn main() {
    show_values(100, "Rust");
}

Here:

T = i32
U = &str

---

Trait Bounds with Generics

Trait bounds define what a generic type must be able to do.

For example:

fn print_item<T: std::fmt::Display>(item: T) {
    println!("{}", item);
}

This means:

T can be any type,
but it must implement Display.

Another example:

fn compare<T: PartialOrd>(a: T, b: T) -> bool {
    a > b
}

This means T must support comparison.

---

Multiple Trait Bounds

A generic type can require more than one trait.

Example:

use std::fmt::Display;

fn show_and_compare<T: Display + PartialOrd>(a: T, b: T) {
    if a > b {
        println!("{} is larger", a);
    } else {
        println!("{} is larger or equal", b);
    }
}

Here T must implement both:

Display
PartialOrd

---

Using the where Clause

When multiple trait bounds make the function declaration difficult to read, Rust provides the where clause.

Instead of:

fn compare<T: std::fmt::Display + PartialOrd>(a: T, b: T) {
}

You can write:

fn compare<T>(a: T, b: T)
where
    T: std::fmt::Display + PartialOrd,
{
    if a > b {
        println!("{}", a);
    } else {
        println!("{}", b);
    }
}

The behavior is the same.

The where syntax can make larger generic functions easier to read.

---

Generic Example with Clone

Sometimes you need to create a copy of a generic value.

You can require the Clone trait.

fn duplicate<T: Clone>(value: T) -> (T, T) {
    (value.clone(), value)
}

Example:

fn main() {
    let text = String::from("Rust");

    let values = duplicate(text);

    println!("{}", values.0);
    println!("{}", values.1);
}

---

Generics with References

Generic functions can also receive references.

Example:

fn get_value<T>(value: &T) -> &T {
    value
}

Usage:

fn main() {
    let number = 50;

    let result = get_value(&number);

    println!("{}", result);
}

Using references prevents ownership from being moved unnecessarily.

---

Generic Struct Example

Here is a practical example using a generic API response.

struct ApiResponse<T> {
    success: bool,
    data: T,
}

You can use it with different data types.

For example:

fn main() {
    let number_response = ApiResponse {
        success: true,
        data: 100,
    };

    let text_response = ApiResponse {
        success: true,
        data: String::from("User loaded successfully"),
    };

    println!("{}", number_response.data);
    println!("{}", text_response.data);
}

This pattern is useful because the same response structure can hold many different types of data.

---

Another Practical Example: Generic Pair

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

impl<T> Pair<T> {
    fn new(first: T, second: T) -> Self {
        Self {
            first,
            second,
        }
    }
}

Usage:

fn main() {
    let numbers = Pair::new(10, 20);

    let words = Pair::new("Rust", "Generics");

    println!("{} {}", numbers.first, numbers.second);
    println!("{} {}", words.first, words.second);
}

The same Pair structure works with multiple types.

---

Generics vs Repeating Code

Without generics:

fn print_i32(value: i32) {
    println!("{}", value);
}

fn print_f64(value: f64) {
    println!("{}", value);
}

fn print_string(value: String) {
    println!("{}", value);
}

With generics:

use std::fmt::Display;

fn print_value<T: Display>(value: T) {
    println!("{}", value);
}

One generic function replaces several almost identical functions.

This is one of the main benefits of generics.

---

Do Rust Generics Affect Performance?

Rust uses a process known as monomorphization for many generic types.

During compilation, Rust creates specialized versions of generic code for the actual types being used.

For example:

print_value(10);
print_value(5.5);

The compiler can generate specialized code for the integer and floating-point versions.

Because much of this work happens at compile time, Rust generics usually provide abstraction without requiring the type-erasure style runtime overhead seen in some programming models.

---

Common Mistakes with Rust Generics

One common mistake is assuming that a generic type automatically supports every operation.

For example:

fn add<T>(a: T, b: T) -> T {
    a + b
}

This will not work for unrestricted T.

Rust needs to know that the type supports addition.

Another mistake is forcing two values to use the same generic type when they should be different.

For example:

struct Data<T> {
    id: T,
    name: T,
}

This means both id and name must have the same type.

If they need different types, use:

struct Data<T, U> {
    id: T,
    name: U,
}

---

Rust Generics Syntax Cheat Sheet

Use Case	Syntax
Generic Type	<T>
Two Generic Types	<T, U>
Generic Function	fn name<T>()
Generic Struct	struct Name<T>
Generic Enum	enum Name<T>
Trait Bound	<T: Trait>
Multiple Bounds	<T: Trait1 + Trait2>
Where Clause	where T: Trait
Generic Implementation	impl<T> Name<T>

---

When Should You Use Generics?

Generics are useful when the same logic should work with multiple types.

Common situations include:

• Collection types
• Reusable data structures
• API response models
• Utility functions
• Libraries
• Generic containers
• Reusable algorithms

You should avoid adding generics when only one concrete type is needed and generic behavior does not provide any real benefit.

---

Final Thoughts

Rust generics allow developers to write reusable code without giving up type safety.

Instead of creating separate functions or structures for every possible data type, you can use generic type parameters such as T and U.

The most important concepts to remember are:

• <T> defines a generic type.
• Generic functions work with multiple types.
• Generic structs and enums can store different types.
• Trait bounds restrict which types can be used.
• where clauses make complex constraints easier to read.
• Option<T> and Result<T, E> are common real-world examples of Rust generics.
• Rust compiles generic code efficiently through monomorphization.

Once you understand basic generics and trait bounds, you can create much more reusable and flexible Rust programs.