Why generics are needed in Rust

Introduction

Generics let us write code that works with many types without repeating it. This saves time and keeps code clean.

When you want a function to work with different types of data, like numbers or text.

When you want to create a data structure, like a list, that can hold any type of item.

When you want to avoid writing the same code again for different types.

When you want your code to be flexible but still safe and clear.

Syntax

Rust

fn function_name<T>(param: T) {
    // code using param
}

struct StructName<T> {
    field: T,
}

The <T> means a generic type named T. You can use any name, but T is common.

Generics work with functions, structs, enums, and traits in Rust.

Examples

This function can print any type that can be shown as text.

Rust

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

This struct can hold coordinates of any type, like integers or floats.

Rust

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

We create points with different types using the same struct.

Rust

let int_point = Point { x: 5, y: 10 };
let float_point = Point { x: 1.0, y: 4.0 };

Sample Program

This program shows how one function can print different types using generics.

Rust

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

fn main() {
    print_item(42);
    print_item("hello");
}

Important Notes

Generics help avoid repeating code for each type.

Rust checks types at compile time to keep code safe.

You can add rules (called traits) to generics to require certain abilities.

Summary

Generics let you write flexible, reusable code.

They work by using placeholders for types.

Rust ensures your generic code is safe and clear.