Agent Skills: Zero-Cost Abstraction

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:

1. What abstraction is needed?

   • Same behavior, different types → trait
   • Different behavior, same type → enum
   • No abstraction needed → concrete type

2. When is type known?

   • Compile time → generics (static dispatch)
   • Runtime → trait objects (dynamic dispatch)

3. 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 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? |

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

| 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 |

Syntax Comparison

// 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

| 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

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