SWPatterns.com

Layered Architecture - Rust

The Layered Architecture pattern organizes an application into distinct layers, each performing a specific role. This promotes separation of concerns, making the application more maintainable, testable, and adaptable to change. Typically, layers include a Presentation (UI), Business Logic, and Data Access layer. My …

Snapshot - Rust

The Snapshot pattern captures and stores the internal state of an object at a specific point in time, allowing for rollback to that state. This is useful for implementing undo/redo functionality, checkpoints, or transaction management. The Rust implementation uses the Clone trait to create copies of the object’s …

Policy - Rust

The Policy pattern allows you to decouple the logic that determines if an operation is allowed from the operation itself. It achieves this by defining a “policy” – a trait or interface – that encapsulates the authorization rules. Different policies can be swapped in at runtime to change the behavior …

Specification - Rust

The Specification pattern is a functional approach to defining complex logic through composable predicates. Instead of embedding conditions directly within code, it encapsulates them as objects (in this case, structs with a call operator) that can be combined using logical operators like and, or, and not. This promotes …

Null Object - Rust

The Null Object pattern provides a substitute for a null or missing object. Instead of checking for null (or None in Rust), you request a null object, which implements the expected interface but has a default, harmless behavior. This simplifies code by eliminating conditional checks for null values.

The Rust …

Visitor - Rust

The Visitor pattern allows you to define a new operation without modifying the classes on which it operates. It’s achieved by moving the operation’s logic into a separate “visitor” object, which then traverses the object structure and applies the operation to each element. This is particularly …

Template Method - Rust

The Template Method pattern defines the skeleton of an algorithm in a base class, deferring some steps to subclasses. It allows subclasses to redefine certain steps of an algorithm without changing the algorithm’s structure. This promotes code reuse and avoids duplication.

The Rust implementation uses traits to …

Strategy - Rust

The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. It allows an algorithm to vary independently from the clients that use it. Here, we define a trait CompressionStrategy representing the compression algorithms. Concrete strategies like ZipCompression and …

State - Rust

The State pattern allows an object to alter its behavior when its internal state changes. It encapsulates different states into separate classes and provides a way to transition between them. This avoids using numerous conditional statements to handle state-specific logic.

The Rust code defines an enum State …

Observer - Rust

The Observer pattern defines a one-to-many dependency between objects. A subject maintains a list of its dependents, called observers, and automatically notifies them of any state changes. This promotes loose coupling; the subject doesn’t need to know concrete observer classes, only that they implement a common …