Lesson 18 of 20

7 mins read

Traits, Shared Behavior & Generics

In Plain English

Traits define shared behavior across distinct types (similar to interfaces in other languages). Generics allow writing reusable functions and data structures with trait bounds (e.g. T: Summary) enforced at compile time with zero runtime dispatch cost (monomorphization).

The Mental Model

"A trait is like a universal electrical outlet standard: any device that implements the Plug trait (phone charger, kettle, laptop) can draw power from the wall without the wall needing to know the specific brand of device."

Deep Dive: How It Works

Trait Definition: pub trait Describable { fn describe(&self) -> String; }

Implementing Traits: impl Describable for User { fn describe(&self) -> String { ... } }

Monomorphization: The compiler generates specialized machine code for each concrete type used with generics, resulting in raw native speed.

Syntax Blueprint

fn print_summary<T: Describable>(item: &T) { println!("{}", item.describe()); }

Trait bounds constrain generic type parameters to types that implement required behavior.

Core Rules to Remember

Shared Interfaces: Traits specify method contracts that types must fulfill.

Zero Runtime Overhead: Static dispatch via monomorphization runs as fast as hand-specialized functions.

Default Implementations: Traits can provide fallback method bodies that types can override.

Common Beginner Traps & How to Fix Them

Mistake:Trying to call a trait method without importing the trait into scope.

Why it happens: Trait methods are only visible when the trait itself is in scope.

How to fix: Add use path::to::Trait; at the top of the file.

Pro Tip: Use where clauses for clean trait bounds on complex signatures: fn process<T, U>(a: T, b: U) where T: Clone, U: Debug.

Live Interactive Example

Hit Run Code to see it live

Trait Definition and Generic Dispatch

Rust 1.78 / rustc

Output Console

Click "Run Code" to view the rendered output.

How it works: The generic function display_entity accepts any type implementing Formattable.

Your Turn: Micro Challenge

No pressure! Edit the starter code below and test your solution with instant feedback.

Micro Exercise

Implement Printable trait on a struct

Define trait Printable { fn print_info(&self); }
Create struct Device { name: String }; and implement Printable for Device to print "Device: {name}".
In main(), let d = Device { name: String::from("ZenChip") }; d.print_info();

Sandbox Output

Click "Run & Check" to test your solution.

Finished reading and practicing?

Mark this lesson as completed to update your course progress.