SWPatterns.com

Memento - Rust

The Memento pattern captures and externalizes the internal state of an object without violating encapsulation. This allows restoring an object to a previous state. Here, a Gist struct holds the text content, and the GistMemento stores a snapshot of that content at a specific time. The Gist provides a method to create a …

Mediator - Rust

The Mediator pattern defines an object that encapsulates how a set of objects interact. It promotes loose coupling by preventing objects from referring to each other explicitly, and instead, they communicate through the mediator. This centralizes control and simplifies object interactions.

The Rust code implements a …

Iterator - Rust

The Iterator pattern is a design pattern that provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation. It defines an interface for traversal and allows for multiple traversals without disrupting the underlying data.

The Rust code below demonstrates this …

Interpreter - Rust

The Interpreter pattern defines a way to evaluate a language grammar given a representation of that grammar. It allows you to define rules for processing strings or expressions, and then interpret them. This implementation focuses on evaluating simple arithmetic expressions (addition and subtraction) containing …

Command - Rust

The Command pattern encapsulates a request as an object, allowing parameterization of clients with different requests, queuing or logging of requests, and support for undoable operations. This implementation uses Rust’s FnOnce trait to define commands as closures that can be executed once. A CommandManager holds …

Chain of Responsibility - Rust

The Chain of Responsibility pattern promotes decoupling the sender of a request from its receivers by passing the request along a chain of handlers. Each handler decides either to process the request or to pass it to the next handler in the chain. This allows for flexible request processing without tightly coupling the …

Extension Object - Rust

The Extension Object pattern allows adding new functionality to existing objects without modifying their core code. This is achieved by creating a separate “extension” object that holds the new methods and data, and then associating it with the original object. In Rust, this is naturally implemented using …

Module - Rust

The Module pattern organizes code into logical units, enhancing reusability, maintainability, and preventing naming conflicts. In Rust, modules are defined using the mod keyword. This example demonstrates a simple module structure with a public function and a private one. The pub keyword controls visibility, making …

Proxy - Rust

The Proxy pattern provides a surrogate or placeholder for another object to control access to it. This is useful for scenarios like lazy initialization, access control, or logging. In this Rust example, we have a Subject trait representing the real object, a RealSubject implementing that trait, and a Proxy that holds a …

Flyweight - Rust

The Flyweight pattern aims to minimize memory usage by sharing common parts of objects. It’s useful when dealing with a large number of similar objects. The pattern separates the object’s state into intrinsic (shared) and extrinsic (unique) components. The Flyweight interface defines a method to operate on …