Traits & Generics Highlights Summary

Every highlight bullet from the 12 pages in this section, gathered on one page and grouped by the page it came from.

Rust's Trait System as Interface Design

• A trait describes a capability a type has, not a category a type belongs to
• Generics are resolved at compile time via monomorphization - one specialized copy per type used
• Trait objects (dyn Trait) resolve calls at runtime through a vtable, trading speed for flexibility
• Choosing between them is a question about when the concrete type needs to be known

Traits Basics

• Traits define shared behavior for types
• impl Trait for Type provides trait implementation
• Trait methods can have default implementations
• T: Display constrains generic type parameters
• impl Trait hides concrete return types
• dyn Trait enables runtime dispatch via vtables

Default Methods & Supertraits

• Default methods provide shared logic for trait implementors
• Supertraits require prerequisite behavior for a trait
• Implement Display first if a supertrait requires it
• Avoid infinite recursion by calling required methods, not self default
• Use a private supertrait in a module to seal a trait
• Override default methods by providing a method in the impl block

Generics

• Generics parameterize types and functions for type-safe, zero-cost reuse
• Use generics for containers, algorithms, and reusable APIs
• Monomorphization generates specialized code for each concrete type
• Monomorphization can increase binary size; use dyn Trait to avoid bloat
• Add T: Trait bounds when generic types lack necessary methods
• Functions, structs, enums, and impls accept type, const, and lifetime parameters

Trait Bounds

• Bounds constrain generic parameters to enable trait method calls
• Use where clauses for readable complex trait bounds
• Multiple bounds combine with + for a single type parameter
• Bounds are checked at compile time for type safety
• impl Trait provides syntactic sugar for single parameter bounds
• Avoid impl Trait in return types when different types are possible

Trait Objects & Dynamic Dispatch

• Use dyn Trait for runtime polymorphism with differing concrete types
• dyn Trait is a fat pointer containing data and a vtable
• Box enables heap allocation and type erasure
• Object safety is required for traits used with dyn
• Avoid dyn in hot paths due to performance cost of indirect calls
• Use dyn Debug + Display to combine multiple trait objects

Static vs Dynamic Dispatch

• Static dispatch monomorphizes code at compile time for performance
• Dynamic dispatch uses vtables at runtime for flexibility
• Use static dispatch with generics or impl Trait
• Use dynamic dispatch with dyn Trait for runtime polymorphism
• Avoid dyn in hot loops due to measurable overhead
• Enable LTO for release builds to help static dispatch

Associated Types & Constants

• Associated types simplify APIs by replacing generic parameters
• Each implementor chooses associated types and constants
• Use associated types for one natural output type per implementor
• Associated types block some object safety (dyn) uses
• Specify associated types in the impl block, not at the call site
• Multiple Item types require a generic method parameter instead

Operator Overloading

• Rust overloads operators using traits in std::ops
• Implement Add for types like Vec2 to enable + syntax
• Define the Output associated type for operator traits
• Avoid operator overloading for unclear or confusing semantics
• Implement AddAssign for += and IndexMut for m[i] = v
• Operator precedence cannot be changed in Rust

Blanket & Conditional Impls

• Blanket implementations apply a trait to all types meeting bounds
• Conditional impls add constraints on custom types
• Overlapping blanket impls cause E0119 conflicts
• Use a newtype wrapper to implement local traits for foreign types
• Avoid blanket implementations for Serde traits
• Test for duplicate impl errors in CI

Common Standard Traits

• Standard library traits appear everywhere in Rust code
• Derive traits like Debug, Clone, PartialEq, Eq, Hash, Default
• Use From/Into for type conversions
• Implement AsRef/AsMut for cheap reference views
• Deref/DerefMut enable smart pointer coercion
• Avoid deriving Ord on floats as it is not total

Traits & Generics Best Practices

• Keep traits focused with a single responsibility
• Prefer associated types for one output per implementation
• Document object safety and Send/Sync expectations for consumers
• Use where clauses for complex generic bounds
• Newtype to implement local traits on foreign types
• Implement Debug on public types for supportability