actionbook/rust-skills

m04-zero-cost

CRITICAL: Use for generics, traits, zero-cost abstraction.

Vedi sorgente

Come usare

  1. Copia il comando e controlla il pacchetto prima di installarlo nel tuo ambiente agente.
  2. Controlla strumenti, credenziali e ambienti richiesti nel documento originale.
  3. Descrivi input e risultato desiderato; confronta l’output con le fonti.
npx skills add https://github.com/actionbook/rust-skills --skill m04-zero-cost

Prima di iniziare

  • L’installazione non include abbonamenti, quote API o accesso ai file.
  • Stelle e installazioni indicano attività, non un test indipendente di qualità o sicurezza.
Documento Skill originale

Contenuto dal repository con titoli, esempi, codice, tabelle, link e immagini preservati.

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

ErrorDon't Just SayAsk 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:

  1. What abstraction is needed?
  • Same behavior, different types → trait
  • Different behavior, same type → enum
  • No abstraction needed → concrete type
  1. When is type known?
  • Compile time → generics (static dispatch)
  • Runtime → trait objects (dynamic dispatch)
  1. 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?)
Persistent ErrorTrace ToQuestion
Complex trait boundsm09-domainIs the abstraction right?
Object safety issuesm05-type-drivenCan typestate help?
Type explosionm10-performanceAccept dyn overhead?

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>

Quick Reference

PatternDispatchCode SizeRuntime Cost
fn foo<T: Trait>()Static+bloatZero
fn foo(x: &dyn Trait)DynamicMinimalvtable lookup
impl Trait returnStatic+bloatZero
Box<dyn Trait>DynamicMinimalAllocation + vtable

Syntax Comparison

rust
// Static dispatch - type known at compile time
fn process(x: impl Display) { }      // argument position
fn process<T: Display>(x: T) { }     // explicit generic
fn get() -> impl Display { }         // return position

// Dynamic dispatch - type determined at runtime
fn process(x: &dyn Display) { }      // reference
fn process(x: Box<dyn Display>) { }  // owned

Error Code Reference

ErrorCauseQuick Fix
E0277Type doesn't impl traitAdd impl or change bound
E0308Type mismatchCheck generic params
E0599No method foundImport trait with use
E0038Trait not object-safeUse generics or redesign

Decision Guide

ScenarioChooseWhy
Performance criticalGenericsZero runtime cost
Heterogeneous collectiondyn TraitDifferent types at runtime
Plugin architecturedyn TraitUnknown types at compile
Reduce compile timedyn TraitLess monomorphization
Small, known type setenumNo 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-PatternWhy BadBetter
Over-generic everythingCompile time, complexityConcrete types when possible
dyn for known typesUnnecessary indirectionGenerics
Complex trait hierarchiesHard to understandSimpler design
Ignore object safetyLimits flexibilityPlan for dyn if needed

Related Skills

WhenSee
Type-driven designm05-type-driven
Domain abstractionm09-domain
Performance concernsm10-performance
Send/Sync boundsm07-concurrency

Correlati per attività

dallo stesso repository

Altri Skills

Tutti gli Skills
actionbook
Community

domain-embedded

Use when developing embedded/nostd Rust. Keywords: embedded, nostd, microcontroller, MCU, ARM, RISC-V, bare metal, firmware, HAL, PAC, RTIC, embassy, interrupt, DMA, peripheral, GPIO, SPI, I2C, UART, embedded-hal, cortex-m, esp32, stm32, nrf, 嵌入式, 单片机, 固件, 裸机

Installazioni / 1h
1
GitHub Stars
1,6K
Aggiornato
23 ago
actionbook
Community

m15-anti-pattern

Use when reviewing code for anti-patterns. Keywords: anti-pattern, common mistake, pitfall, code smell, bad practice, code review, is this an anti-pattern, better way to do this, common mistake to avoid, why is this bad, idiomatic way, beginner mistake, fighting borrow checker, clone everywhere, unwrap in production, should I refactor, 反模式, 常见错误, 代码异味, 最佳实践, 地道写法

Installazioni / 1h
14
GitHub Stars
1,6K
Aggiornato
23 ago
actionbook
Community

coding-guidelines

Use when asking about Rust code style or best practices. Keywords: naming, formatting, comment, clippy, rustfmt, lint, code style, best practice, P.NAM, G.FMT, code review, naming convention, variable naming, function naming, type naming, 命名规范, 代码风格, 格式化, 最佳实践, 代码审查, 怎么命名

Installazioni / 1h
2
GitHub Stars
1,5K
Aggiornato
23 ago
actionbook
Community

m03-mutability

CRITICAL: Use for mutability issues. Triggers: E0596, E0499, E0502, cannot borrow as mutable, already borrowed as immutable, mut, &mut, interior mutability, Cell, RefCell, Mutex, RwLock, 可变性, 内部可变性, 借用冲突

Installazioni / 1h
2
GitHub Stars
1,5K
Aggiornato
23 ago