Rust Generics and Traits

When writing software, copy-pasting the same code for different data types is a recipe for maintenance nightmares. If you write a function to find the largest number in a list of integers, you do not want to write it again for float numbers or strings.

In Rust, Generics and Traits are the dual tools that allow us to write highly reusable code that is completely type-safe and has zero runtime overhead.

In this post, we will unpack how generics and traits work, how they combine via trait bounds, and the compiler magic that makes them incredibly fast.

Generics: Type Placeholders#

Generics allow us to define structs, enums, and functions with placeholder types. Instead of hardcoding a type like i32 or String, we use a generic type parameter (conventionally named T).

Generic Data Structures#

A classic example is a Point struct. If we want a point that can hold coordinates of any type (integers, floats, etc.), we declare it with a generic type parameter:

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

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

rust

By putting <T> after the struct name, we tell the compiler that Point is generic over some type T.

Zero-Cost Abstraction: Monomorphization#

You might wonder: Does using generics slow down the program at runtime?

The answer is no. Rust compiles generic code using a process called monomorphization. At compile time, the compiler looks at all the concrete types used with your generic code and generates duplicate, specialized machine code for each type.

graph TD
    A["Point&lt;T&gt; (Source Code)"] --> B["Compiler (Monomorphization)"]
    B --> C["Point_i32 (Machine Code)"]
    B --> D["Point_f64 (Machine Code)"]

Because of this, there is absolutely no runtime performance penalty. It is just as fast as if you had written separate, non-generic structs.

Traits: Behavioral Contracts#

While generics let us work with any type, we often need to ensure those types possess specific behaviors. For example, if we want to print a point or sort a list, the types must support printing or comparison.

A Trait defines a set of methods that a type must implement to fulfill a specific behavior.

Defining and Implementing a Trait#

Let’s define a trait named Summary that requires any implementing type to provide a summarize method:

pub trait Summary {
    fn summarize(&self) -> String;
}

pub struct NewsArticle {
    pub headline: String,
    pub author: String,
    pub content: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{} by {}", self.headline, self.author)
    }
}

pub struct Tweet {
    pub username: String,
    pub content: String,
}

impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

rust

Now, we can call .summarize() on instances of both NewsArticle and Tweet.

Default Implementations#

Traits can also provide default behavior. If a type implements a trait, it can choose to override or keep the default method:

pub trait Summary {
    fn summarize(&self) -> String {
        String::from("(Read more...)")
    }
}

rust

Trait Bounds: Combining Generics and Traits#

The real power shines when we combine them. Trait Bounds restrict generic types so they are only accepted if they implement specific traits.

For example, let’s write a function that takes a generic item and prints its summary:

// T must implement the Summary trait
pub fn notify<T: Summary>(item: &T) {
    println!("Breaking news! {}", item.summarize());
}

rust

The `where` Clause#

For complex functions with multiple generic parameters, using inline trait bounds can make the signature hard to read. Rust provides the where clause to clean up the code:

// Hard to read:
fn some_function<T: Clone + Debug, U: Serialize + Clone>(t: &T, u: &U) {}

// Cleaned up with where:
fn some_function<T, U>(t: &T, u: &U) 
where
    T: Clone + Debug,
    U: Serialize + Clone,
{}

rust

Practical Example: Finding the Largest Item#

Let’s look at a practical function to find the largest item in a slice. To compare elements, the generic type T must implement the standard library’s PartialOrd trait:

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

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

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

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

rust

Without the PartialOrd trait bound, the compiler would reject this code because it does not know if every possible type T can be compared using the > operator.

Summary#

Generics are type placeholders that enable code reuse.
Monomorphization ensures generic code runs at native speed with zero runtime overhead.
Traits act as interfaces or contracts, defining what a type can do.
Trait Bounds allow generic functions to safely call methods on generic parameters by guaranteeing they implement specific traits.

In our next post, we will tackle Lifetimes, which work closely with generics to keep reference usage safe.

Generics: Type Placeholders#

Generic Data Structures#

Zero-Cost Abstraction: Monomorphization#

Traits: Behavioral Contracts#

Defining and Implementing a Trait#

Default Implementations#

Trait Bounds: Combining Generics and Traits#

The where Clause#

Practical Example: Finding the Largest Item#

Summary#

References#

The `where` Clause#