M04 Zero Cost

by actionbook5c40d3ad7851No license1.5K starsListed Oct 8, 2026Updated Oct 8, 2026Repository updated 6 weeks ago

CRITICAL: Use for generics, traits, zero-cost abstraction. Triggers: E0277, E0308, E0599, generic, trait, impl, dyn, where, monomorphization, static dispatch, dynamic dispatch, impl Trait, trait bound not satisfied, 泛型, 特征, 零成本抽象, 单态化

Instructions onlySoftware Development

AI-generated overview

Guides Rust developers in choosing generics, trait objects, and zero-cost abstractions and resolving related compiler errors.

What it does: This skill provides decision guidance for Rust polymorphism: when to use generics or impl Trait for static dispatch versus dyn Trait or Box for dynamic dispatch. It maps common compiler errors such as E0277, E0308, E0599, and E0038 to design questions, and includes quick-reference tables on dispatch cost, syntax comparison, object safety, and anti-patterns. It produces reasoning and recommendations rather than code files.
When to use it: Use it when working with Rust generics, trait bounds, impl Trait, dyn Trait, or monomorphization, or when encountering trait-related compiler errors. It is also useful when deciding between compile-time and runtime polymorphism or when designing abstractions over types.
Requirements: No tools, packages, or credentials are required; it is instructions only and ships no scripts.

Zero-Cost Abstraction

Layer 1: Language Mechanics

Core Question

Do we need compile-time or runtime polymorphism?

Before choosing between generics and trait objects:

Is the type known at compile time?
Is a heterogeneous collection needed?
What's the performance priority?

Error → Design Question

Error	Don't Just Say	Ask Instead
E0277	"Add trait bound"	Is this abstraction at the right level?
E0308	"Fix the type"	Should types be unified or distinct?
E0599	"Import the trait"	Is the trait the right abstraction?
E0038	"Make object-safe"	Do we really need dynamic dispatch?

Thinking Prompt

Before adding trait bounds:

What abstraction is needed?
- Same behavior, different types → trait
- Different behavior, same type → enum
- No abstraction needed → concrete type
When is type known?
- Compile time → generics (static dispatch)
- Runtime → trait objects (dynamic dispatch)
What's the trade-off priority?
- Performance → generics
- Compile time → trait objects
- Flexibility → depends

Trace Up ↑

When type system fights back:

E0277 (trait bound not satisfied)    ↑ Ask: Is the abstraction level correct?    ↑ Check: m09-domain (what behavior is being abstracted?)    ↑ Check: m05-type-driven (should use newtype?)

E0277 (trait bound not satisfied)    ↑ Ask: Is the abstraction level correct?    ↑ Check: m09-domain (what behavior is being abstracted?)    ↑ Check: m05-type-driven (should use newtype?)

Trace Down ↓

From design to implementation:

"Need to abstract over types with same behavior"    ↓ Types known at compile time → impl Trait or generics    ↓ Types determined at runtime → dyn Trait
"Need collection of different types"    ↓ Closed set → enum    ↓ Open set → Vec<Box<dyn Trait>>
"Need to return different types"    ↓ Same type → impl Trait    ↓ Different types → Box<dyn Trait>

"Need to abstract over types with same behavior"    ↓ Types known at compile time → impl Trait or generics    ↓ Types determined at runtime → dyn Trait
"Need collection of different types"    ↓ Closed set → enum    ↓ Open set → Vec<Box<dyn Trait>>
"Need to return different types"    ↓ Same type → impl Trait    ↓ Different types → Box<dyn Trait>

Quick Reference

Syntax Comparison

rust

// Static dispatch - type known at compile timefn process(x: impl Display) { }      // argument positionfn process<T: Display>(x: T) { }     // explicit genericfn get() -> impl Display { }         // return position
// Dynamic dispatch - type determined at runtimefn process(x: &dyn Display) { }      // referencefn process(x: Box<dyn Display>) { }  // owned

// Static dispatch - type known at compile timefn process(x: impl Display) { }      // argument positionfn process<T: Display>(x: T) { }     // explicit genericfn get() -> impl Display { }         // return position
// Dynamic dispatch - type determined at runtimefn process(x: &dyn Display) { }      // referencefn process(x: Box<dyn Display>) { }  // owned

Error Code Reference

Error	Cause	Quick Fix
E0277	Type doesn't impl trait	Add impl or change bound
E0308	Type mismatch	Check generic params
E0599	No method found	Import trait with `use`
E0038	Trait not object-safe	Use generics or redesign

Decision Guide

Scenario	Choose	Why
Performance critical	Generics	Zero runtime cost
Heterogeneous collection	`dyn Trait`	Different types at runtime
Plugin architecture	`dyn Trait`	Unknown types at compile
Reduce compile time	`dyn Trait`	Less monomorphization
Small, known type set	`enum`	No indirection

Object Safety

A trait is object-safe if it:

Doesn't have Self: Sized bound
Doesn't return Self
Doesn't have generic methods
Uses where Self: Sized for non-object-safe methods

Anti-Patterns

Anti-Pattern	Why Bad	Better
Over-generic everything	Compile time, complexity	Concrete types when possible
`dyn` for known types	Unnecessary indirection	Generics
Complex trait hierarchies	Hard to understand	Simpler design
Ignore object safety	Limits flexibility	Plan for dyn if needed

Related Skills

Source and attribution

Source:actionbook/rust-skillsinskills/m04-zero-costat commit5c40d3a

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

Persistent Error	Trace To	Question
Complex trait bounds	m09-domain	Is the abstraction right?
Object safety issues	m05-type-driven	Can typestate help?
Type explosion	m10-performance	Accept dyn overhead?

Pattern	Dispatch	Code Size	Runtime Cost
`fn foo<T: Trait>()`	Static	+bloat	Zero
`fn foo(x: &dyn Trait)`	Dynamic	Minimal	vtable lookup
`impl Trait` return	Static	+bloat	Zero
`Box<dyn Trait>`	Dynamic	Minimal	Allocation + vtable

When	See
Type-driven design	m05-type-driven
Domain abstraction	m09-domain
Performance concerns	m10-performance
Send/Sync bounds	m07-concurrency

M04 Zero Cost

Zero-Cost Abstraction

Core Question

Error → Design Question

Thinking Prompt

Trace Up ↑

Trace Down ↓

Quick Reference

Syntax Comparison

Error Code Reference

Decision Guide

Object Safety

Anti-Patterns

Related Skills

Source and attribution

More from actionbook/rust-skills

Rust Trait Explorer

Rust Symbol Analyzer

Rust Skill Creator

Rust Router

Rust Refactor Helper

Rust Daily

More in Software Development

Playground

M5 Onboard

Cardputer Buddy

Web Design Guidelines

Vercel React Native Skills

Vercel React Best Practices