Traits in Rust: From Fundamentals to Monomorphic Zero-Cost Code

Introduction: Why Do We Need Traits?

#

Imagine we are building a fitness application with different exercise types: Pushups and Plank. Both need to calculate calories burned, but do so using different logic:

struct Pushups {
    reps: u32,
}

struct Plank {
    duration_sec: u32,
}

impl Pushups {
    fn calories_burned(&self) -> u32 {
        self.reps * 1
    }
}

impl Plank {
    fn calories_burned(&self) -> u32 {
        self.duration_sec * 2
    }
}

Now we face a software engineering problem—writing a single function to calculate total calories burned across any workout exercises. Without abstractions, we would be forced to duplicate the function implementation for every distinct type.

How Rust Solves This Problem

#

In many programming languages, this problem is solved using interfaces or base classes. However, without explicit type bounds, error messages often pop up deep inside template instantiation code, accompanied by massive compiler tracebacks.

Rust solves this problem using Traits—explicit behavioral contracts.

First, we declare the Workout behavioral contract:

pub trait Workout {
    fn calories_burned(&self) -> u32;
}

Next, we declare that our structs implement this trait:

impl Workout for Pushups {
    fn calories_burned(&self) -> u32 {
        self.reps * 1
    }
}

impl Workout for Plank {
    fn calories_burned(&self) -> u32 {
        self.duration_sec * 2
    }
}

Now we can write a single unified function using a trait bound (T: Workout):

fn total_calories<T: Workout>(exercises: &[T]) -> u32 {
    exercises.iter().map(|e| e.calories_burned()).sum()
}

What Happens Under the Hood?

#

The compiler does not invoke a single dynamic virtual method at runtime. Instead, it generates a specialized function copy for every concrete type at compile time (monomorphization). As a result, you gain clean architectural flexibility with the raw speed of pure C (Zero-cost abstractions).

Try our step-by-step interactive example below: in step 1, you will observe a compiler error when attempting to call a method on an unbounded type T, and in step 2—its resolution via the Workout trait:

 1// ?compile_fail
 2struct Pushups {
 3    reps: u32,
 4}
 5
 6impl Pushups {
 7    fn calories_burned(&self) -> u32 {
 8        self.reps * 1
 9    }
10}
11
12// Attempting to write a generic function WITHOUT a trait bound T
13fn total_calories<T>(exercises: &[T]) -> u32 {
14    exercises.iter().map(|e| e.calories_burned()).sum()
15}
16
17fn main() {
18    let pushups = vec![Pushups { reps: 20 }, Pushups { reps: 30 }];
19    let total = total_calories(&pushups);
20    println!("Total calories: {}", total);
21}
22

 1pub trait Workout {
 2    fn calories_burned(&self) -> u32;
 3}
 4
 5struct Pushups {
 6    reps: u32,
 7}
 8
 9struct Plank {
10    duration_sec: u32,
11}
12
13impl Workout for Pushups {
14    fn calories_burned(&self) -> u32 {
15        self.reps * 1
16    }
17}
18
19impl Workout for Plank {
20    fn calories_burned(&self) -> u32 {
21        self.duration_sec * 2
22    }
23}
24
25// Unified generic function with Trait Bound constraint (T: Workout)
26fn total_calories<T: Workout>(exercises: &[T]) -> u32 {
27    exercises.iter().map(|e| e.calories_burned()).sum()
28}
29
30fn main() {
31    let pushups = vec![Pushups { reps: 20 }, Pushups { reps: 30 }];
32    let planks = vec![Plank { duration_sec: 60 }, Plank { duration_sec: 45 }];
33
34    println!("Pushup calories: {}", total_calories(&pushups));
35    println!("Plank calories: {}", total_calories(&planks));
36}
37

1. What Are Traits & Basic Syntax

#

A Trait is a specification of a set of methods that a type must be capable of executing. A trait itself stores no data payload; it strictly declares behavior.

Let’s declare a simple trait Say and implement it for a Dog struct. By Rust convention, trait and struct names are written in CamelCase.

// Declare the contract: anything implementing Say can "say" something
pub trait Say {
    fn say(&self);
}

struct Dog;

// Implement the contract for Dog
impl Say for Dog {
    fn say(&self) {
        println!("Woof!");
    }
}

Now, when we instantiate a Dog, we can invoke the method using dot syntax:

let dog = Dog;
dog.say(); // Outputs: Woof!

2. Anatomy of Trait Members

#

Inside a trait, you can declare more than just instance methods.

Instance Methods and Associated Functions

#

• Instance Methods: Receive self, &self, or &mut self as their first argument. Called on an instance (dog.say()).
• Associated Functions: Do not take self as the first argument. These act as “static methods” called via namespace syntax (Dog::species()).

pub trait Animal {
    fn name(&self) -> &str;        // Instance method
    fn species() -> &'static str; // Associated function without self
}

struct Dog;

impl Animal for Dog {
    fn name(&self) -> &str { "Rex" }
    fn species() -> &'static str { "Canis lupus" }
}

// Associated function call:
println!("Species: {}", Dog::species());

Default Implementations

#

We can provide a default function body directly inside the trait declaration. Implementing types can either inherit this default behavior or override it when needed:

pub trait Greet {
    fn hello(&self) {
        println!("Hello!"); // Default implementation
    }
}

struct Student;
impl Greet for Student {} // Empty impl body — uses default behavior

Associated Constants

#

Traits can declare constants whose values are specified during implementation for concrete types. Their names are written in UPPER_SNAKE_CASE:

pub trait HasId {
    const ID: usize;
}

struct User;
impl HasId for User {
    const ID: usize = 42;
}

3. Marker Traits: Copy vs. Clone

#

Rust features two fundamental traits that dictate how data payloads are copied in memory:

let a = String::from("abc");
let b = a; // Move (ownership moves to b, 'a' is no longer accessible)

let x = 5;
let y = x; // Copy (value of x is implicitly copied, both variables accessible)

The Copy trait is a subtrait of Clone (trait Copy: Clone {}). You cannot make a type Copy without also implementing Clone.

• Primitive numeric types (i32, f64), bool, char implement Copy natively.
• For custom structs, we can derive them automatically: #[derive(Copy, Clone)].

4. Generics, Trait Bounds, and impl Trait

#

Generics (generic types) allow writing structs and functions that operate across arbitrary data types.

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

Trait Bounds

#

When we want to perform operations on generic type T, we apply Trait Bounds:

impl<T> Point<T>
where 
    T: std::ops::Add<Output=T> // Restricting type T to addition contract
{
    fn add(self, other: Self) -> Self {
        Self {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

Ergonomic impl Trait in Arguments

#

For most standard functions in Rust, instead of verbose fn foo<T: Trait>(x: T), a more concise syntax is preferred: impl Trait:

fn print_workout(w: impl Workout) {
    println!("Calories: {}", w.calories_burned());
}

Both forms are fundamentally equivalent: the compiler transforms impl Trait into a generic function at compile time.

5. Monomorphization Mechanics

#

Unlike languages like Java or C# where generics are erased at runtime, or Python where everything is checked dynamically, Rust utilizes monomorphization.

When the compiler encounters generic code, it inspects all concrete types passed into the function calls and generates physical function copies for every distinct type during compilation.

// Generic source code
fn foo<T>(x: T) { ... }

foo(5);       // Called with i32
foo("Hello"); // Called with &str

Under the hood, the compiler conceptually transforms this into two concrete functions:

fn foo_i32(x: i32) { ... }
fn foo_str(x: &str) { ... }

Advantages of Monomorphization:

#

• Zero-Cost Abstractions: Execution runs at raw machine speed because types are fixed upfront—no runtime type checks or dynamic dispatch overhead.
• Aggressive Inlining: The compiler can easily inline short function bodies directly into call sites.

Disadvantages of Monomorphization:

#

• Slower Compile Times: The compiler must compile and optimize multiple generated function copies.
• Binary Code Bloat: Machine code size expands as duplicate function copies accumulate.

Explore traits and static polymorphism in action in our interactive code slides below:

 1pub trait Say {
 2    fn say(&self) -> String;
 3}
 4
 5struct Dog;
 6
 7impl Say for Dog {
 8    fn say(&self) -> String {
 9        "Woof!".to_string()
10    }
11}
12
13fn main() {
14    let dog = Dog;
15    println!("Dog says: {}", dog.say());
16}
17

 1pub trait HasId {
 2    const ID: usize;
 3    type Err;
 4    fn from_str(s: &str) -> Result<Self, Self::Err> where Self: Sized;
 5}
 6
 7struct MyStruct;
 8
 9impl HasId for MyStruct {
10    const ID: usize = 10;
11    type Err = std::convert::Infallible;
12    fn from_str(_s: &str) -> Result<Self, Self::Err> {
13        Ok(MyStruct)
14    }
15}
16
17fn main() {
18    println!("Struct ID: {}", MyStruct::ID);
19    let _s = MyStruct::from_str("test").unwrap();
20}
21

 1// ?hidden:start
 2use std::fmt;
 3// ?hidden:end
 4
 5// We cannot implement Display for Vec<i32> directly as both are foreign types.
 6// But we can wrap Vec inside our custom tuple struct (Newtype)!
 7struct MyVec(Vec<i32>);
 8
 9impl fmt::Display for MyVec {
10    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11        write!(f, "My vector with {} elements", self.0.len())
12    }
13}
14
15fn main() {
16    let my_vec = MyVec(vec![100, 200, 300]);
17    println!("{}", my_vec);
18}
19

 1// Trait used as a constraint
 2trait Loud {
 3    fn loud_say(&self) -> String;
 4}
 5
 6// Generic struct
 7struct Point<T> {
 8    x: T,
 9    y: T,
10}
11
12// Blanket implementation: implement Loud for any Point<T> if T implements Loud
13impl<T: Loud> Loud for Point<T> {
14    fn loud_say(&self) -> String {
15        format!("X: {}, Y: {}", self.x.loud_say(), self.y.loud_say())
16    }
17}
18
19struct Dog;
20impl Loud for Dog {
21    fn loud_say(&self) -> String {
22        "WOOF!".to_string()
23    }
24}
25
26fn main() {
27    let p = Point { x: Dog, y: Dog };
28    println!("Point shouts: {}", p.loud_say());
29}
30

 1// ?hidden:start
 2use std::mem::size_of;
 3// ?hidden:end
 4
 5trait A {
 6    fn get(&self) -> &str;
 7}
 8
 9trait B {
10    fn get(&self) -> &str;
11}
12
13struct S;
14
15impl A for S {
16    fn get(&self) -> &str { "implementation A" }
17}
18
19impl B for S {
20    fn get(&self) -> &str { "implementation B" }
21}
22
23fn main() {
24    let s = S;
25    // s.get(); // Compile error: method name get is ambiguous!
26    
27    // Fully Qualified Syntax resolves the conflict:
28    let from_a = <S as A>::get(&s);
29    let from_b = <S as B>::get(&s); 
30    
31    // Turbofish for explicit type specification:
32    let float_size = size_of::<f64>();
33    
34    println!("A: {}, B: {}, f64 size: {}", from_a, from_b, float_size);
35}
36

Test Your Knowledge!

#

Take a short quiz to consolidate your understanding of traits and static polymorphism in Rust.