rust-types

Static dispatch uses generics and monomorphization for zero-cost performance, while dynamic dispatch uses trait objects for runtime flexibility. Choose generics for performance-critical code and trait objects when you need heterogeneous collections or runtime polymorphism at API boundaries.

The type-state pattern encodes state transitions into the type system, making invalid states unrepresentable at compile time. It uses PhantomData and marker traits to ensure objects follow a valid lifecycle, guaranteeing safety without runtime checks.

Use PhantomData in Rust generic structs when you need to indicate ownership or variance relationships without storing actual data. It allows you to track type parameters for type-safety abstractions and implement traits that require specific type associations.

Design polymorphic Rust interfaces by combining generics for static dispatch, trait objects for dynamic dispatch, and type-driven patterns like sealed traits. This balances API ergonomics with compile-time guarantees for library boundaries.

Sealed traits prevent external crates from implementing your traits by using a private internal module marker. This ensures type-safe abstractions and maintains API stability by restricting trait implementation to types defined within your library.

Using impl Trait enables static dispatch through monomorphization, offering better performance than dyn Trait. However, dyn Trait provides dynamic dispatch flexibility for heterogeneous collections, creating a trade-off between compile-time speed and runtime polymorphism.