Compile-Time Polymorphism vs Runtime

In this lesson, you will learn how to choose between the performance of compile-time generics and the flexibility of runtime plugin architectures in your business logic.

Static vs. Dynamic Dispatch

In Rust, compile-time polymorphism (generics) uses static dispatch. When you write a function like fn process<T: Processor>(item: T), the compiler creates a specific version of that function for every type T you use. This is fast because the compiler can "inline" the code, removing the overhead of function calls.

Conversely, runtime polymorphism (trait objects) uses dynamic dispatch via &dyn Processor. Here, the compiler doesn't know the exact type at compile time; it uses a "vtable" (a lookup table) to find the correct method at runtime.

Business Logic Trade-offs

When designing a system, these two patterns serve different business needs:

1. Static Dispatch (Generics): Best for core business logic where performance is critical. If your system performs high-frequency math or tight-loop processing, monomorphization (the process of generating specific code) allows the compiler to optimize across function boundaries. However, it increases binary size and compile times.
2. Runtime Dispatch (Plugin Architecture): Best for systems that must be extended by third-party developers without recompiling the main binary. If you are building an application that loads external .so or .dll modules, you cannot use generics because the compiler cannot see those types yet. You must use dyn Trait to allow the main system to interact with unknown, external code.

// Static: High performance, fixed at compile-time
fn execute_fast<T: Handler>(h: T) { h.handle(); }

// Dynamic: Flexible, allows runtime loading of external plugins
fn execute_plugin(h: Box<dyn Handler>) { h.handle(); }

Choose static dispatch when you own all the types and care about every millisecond. Choose runtime dispatch when you need to decouple your system from its implementations or support hot-swapping plugins without a full system rebuild.

Key Takeaway: Use static dispatch for maximum performance in stable, internal code, and dynamic dispatch when your business requirements necessitate runtime flexibility and decoupled plugin support.