SWPatterns.com

Facade - Rust

The Facade pattern provides a simplified interface to a complex subsystem. It defines a high-level interface that hides the intricacies of the underlying components, making the subsystem easier to use. This example demonstrates a media player facade, simplifying interactions with audio and video components. The …

Decorator - Rust

The Decorator pattern dynamically adds responsibilities to an object. It provides a flexible alternative to subclassing for extending functionality. This implementation uses Rust’s trait objects and the Box type to achieve this. We define a Report trait with a display method. The SimpleReport is the concrete …

Composite - Rust

The Composite pattern allows you to treat individual objects and compositions of objects uniformly. It’s useful when you have hierarchical structures and want to perform operations on them without knowing whether you’re dealing with a leaf or a composite node. This Rust example represents a file system where files and …

Bridge - Rust

The Bridge pattern is a structural design pattern that lets you split an abstraction from its implementation so that objects can have different abstract interfaces. This is useful when you want to avoid a rigid hierarchy of classes. In this Rust example, we have an AudioPlayer abstraction and different AudioFormat …

Adapter - Rust

The Adapter pattern converts the interface of a class into another interface clients expect. This allows classes with incompatible interfaces to work together. Here, we adapt a CelsiusTemperature struct (legacy system) to be usable with functions expecting FahrenheitTemperature. We define a CelsiusToFahrenheitAdapter …

Service Locator - Rust

The Service Locator pattern provides a centralized way to access various services within an application. Instead of directly depending on concrete implementations, components request services from a central registry (the locator). This promotes loose coupling and makes it easier to swap out implementations.

The Rust …

Dependency Injection - Rust

Dependency Injection (DI) is a design pattern where a class receives its dependencies from external sources rather than creating them itself. This promotes loose coupling, making the code more testable, maintainable, and reusable. Our Rust example uses a simple struct NotificationService that requires a MessageSender …

Lazy Initialization - Rust

The Lazy Initialization pattern ensures that the creation of a resource-intensive object is deferred until it’s actually needed (accessed) for the first time. Subsequent accesses then return the already created instance. This avoids unnecessary initialization overhead, improving performance especially if the …

Object Pool - Rust

The Object Pool pattern manages a collection of reusable objects to reduce the overhead of frequent creation and destruction. It improves performance, especially with resource-intensive objects. This Rust implementation uses a RefCell to allow interior mutability within the pool, and Mutex for thread-safe access. The …

Multiton - Rust

The Multiton pattern ensures that only a specific number of instances of a class exist. It’s a relaxed version of the Singleton pattern, allowing for a limited concurrency or distribution of instances. This Rust implementation uses a static mutable vector to store the instances and a Mutex to provide thread-safe …