Static vs. Dynamic Dispatch

Rust supports both static dispatch (generics and impl Trait) and dynamic dispatch (dyn Trait trait objects), allowing you to choose the trade-off between runtime speed, compile time, binary size, and collection heterogeneity on a per-interface basis.

Head-to-Head Comparison

Combining Static and Dynamic Dispatch: The Thin-Wrapper Pattern

Standard library functions such as std::fs::read_to_string(path: impl AsRef<Path>) use a hybrid pattern to get the ergonomics of generics without binary code bloat: a tiny generic outer function converts the parameter into a concrete reference or trait object and immediately delegates to a non-generic inner function:

trait Formatter {
    fn format_kv(&self, key: &str, value: &str) -> String;
}

struct EnvFormatter;

impl Formatter for EnvFormatter {
    fn format_kv(&self, key: &str, value: &str) -> String {
        format!("{key}={value}")
    }
}

// Thin generic entry point (inlined at call site) -> delegates to `&dyn Formatter`:
pub fn render_config(fmt: impl Formatter, entries: &[(&str, &str)]) -> String {
    render_config_dyn(&fmt, entries)
}

// Compiled only ONCE in the binary regardless of how many `Formatter` types exist:
fn render_config_dyn(fmt: &dyn Formatter, entries: &[(&str, &str)]) -> String {
    entries
        .iter()
        .map(|(k, v)| fmt.format_kv(k, v))
        .collect::<Vec<_>>()
        .join("\n")
}

fn main() {
    let pairs = [("HOST", "0.0.0.0"), ("PORT", "8080")];
    println!("{}", render_config(EnvFormatter, &pairs));
}

HOST=0.0.0.0
PORT=8080

Decision Guide: When to Choose Each

1. Default to static dispatch (<T: Trait>) for small, hot-path operations (iterators, numeric traits, comparators, serialization primitives) where inlining is critical.
2. Choose dynamic dispatch (&dyn Trait / Box<dyn Trait>) when you need heterogeneous collections (Vec<Box<dyn Plugin>>), runtime dependency injection, or to shrink compile times and binary size at high-level architectural boundaries (such as HTTP middleware, database drivers, or log sinks).
3. Choose an enum when you need heterogeneous storage over a fixed, closed set of known types without vtable or heap overhead.