Rust Patterns

Shared solutions for particular situations specific to programming in Rust.

Basic Patterns

Ownership & Borrowing

Pattern	Description	Resources
Ownership & Borrowing	Ownership ensure automatic memory clean up when a variable that owns data goes out of scope. This prevents memory leaks. Borrowing allows using a value without taking ownership of it. The borrowing rules prevent data races by ensuring that either multiple parts of the code can read the data, or one part can modify it, but not both at the same time. These are fundamental language features.	Rust Book, "Understanding Ownership".
RAII: Resource Acquisition Is Initialization	Manage resources memory, files, network connections by tying them to the lifetime of an object. Automatic cleanup via `Drop` trait.	Rust Book, "Understanding Ownership".
Interior Mutability	Allow mutation of data even when there are immutable references. Use `RefCell`, `Rc<RefCell<T>>`, `Cell` types.	`std::cell`, `std::sync::atomic`⮳ documentation. The Rust Book, "Interior Mutability".

Error Handling & Customization

Pattern	Description	Example/Resources
Error Handling	Represent the possibility of failure via `Result` or absence via `Option`. `Result` and `Option` are part of the prelude. Use `match`, `unwrap`, `expect`, and `?` operator. Crates like `anyhow`⮳ and `thiserror`⮳ can help with error management.	The Rust Book, "Error Handling".
`?` Operator	Propagate errors concisely.	The Rust Book, "Error Handling".
`From` Trait	Define conversions between types with `From`, often used for error handling.	Standard library documentation.

Error Handling

Recipe	Crates	Categories
Trigger and Handle Irrecoverable Panics
Provide a Fallback Value with `unwrap_or_else`
Return Recoverable Errors with `Result`
Propagate Errors with the `?` Operator
Avoid Discarding Errors During Error Conversions
Obtain the Backtrace in Complex Error Scenarios
Handle Errors Correctly in `main`

Error Customization

Recipe	Crates	Categories
`anyhow`
`thisError`
`miette`
`color-eyre`

Generics & Traits

Pattern	Description	Example/Resources
Generics	Write code that works with multiple types without needing to specify them explicitly.	The Rust Book, "Generic Types, Traits, and Lifetimes".
Traits	Define shared behavior that types can implement.	The Rust Book, "Traits".
Trait Objects	Dynamically dispatch to different implementations of a trait at runtime, using `Box<dyn Trait>` or `&dyn Trait`.	The Rust Book, "Using Trait Objects That Allow for Different Types".
Associated Types	Define types associated with a trait.	The Rust Book, "Associated Types".

Concurrency and Asynchronous Programming

Pattern	Description	Example/Resources
Threading	FIXME	`std::thread` and `std::sync` provide basic threading and synchronization primitives.
Atomically Reference Counting	Use `Arc` to share data safely between threads. Combine with `Mutex` or `RwLock` for mutable access.	The Rust Book, "Shared-State Concurrency".
Mutual Exclusion Lock	Use `Mutex` for protecting shared data from concurrent access.	The Rust Book, "Shared-State Concurrency".
Read-Write Lock	`RwLock` allows multiple readers or exclusive writers to access shared data.	Standard library documentation.
Channels	Communicate between threads using message passing.	The Rust Book, "Message Passing Concurrency".
Concurrent Data Structures		`crossbeam`⮳ offers advanced concurrent data structures.
Asynchronous Programming	Build asynchronous applications using e.g. the `tokio`⮳ asynchronous runtime, futures, tasks, and actors.	`tokio`⮳ crate documentation.

Functional Programming with Rust

Pattern	Description	Example/Resources
Closures	Use anonymous functions that can capture their environment. Fundamental language feature.	The Rust Book, "Closures".
Iterators	Access elements of a sequence. Fundamental language feature.	The `itertools`⮳ crate provides additional iterator adapters. The Rust Book, "Iterators".

Recipe	Crates	Categories
Compose Iterators
Use a general purpose sum type with `either`
Use Functional Programming Data Structures and Type-level Programming Tools with `frunk`
Create Immutable Data Structures with `im`

Other

Pattern	Description	Example/Resources
Macros	Code that generates other code at compile time. Fundamental language features.	Crates like `syn`⮳ and `quote`⮳ are used for procedural macros. The Rust Book, "Macros".
Unsafe Code	Bypass Rust's safety guarantees (use with caution).	The Rust Book, "Unsafe Rust". Rustonomicon.
FFI (Foreign Function Interface)	Interact with code written in other languages e.g., C.	The Rust Book, "Foreign Function Interface".

Design Patterns

Creational Patterns

Design Pattern	Description	Helpful Rust Crates	Notes
Builder	Constructing complex objects step-by-step.	`derive_builder`⮳ for code generation	Often implemented directly using structs and methods. `derive_builder`⮳ reduces boilerplate.
Factory	Creating objects of different types based on some criteria.	Often implemented directly using traits, enums, or closures.	Traits and generics are frequently used.
Abstract Factory	Creating families of related objects.	Often implemented directly using traits and generics
Singleton	Ensuring a class has only one instance.	Often implemented directly using static variables or lazy initialization	Can be implemented with `lazy_static`⮳ though often discouraged in modern Rust.

Builder Patterns

Recipe	Crates	Categories
`bon`
`derive_builder`
`typed-builder`

Structural Patterns

Design Pattern	Description	Helpful Rust Crates	Notes
Adapter	Making incompatible interfaces work together.	Often implemented directly using traits	Traits are key for implementing adapters.
Composite	Representing hierarchical tree-like structures.	Often implemented directly using structs and enums
Decorator	Adding behavior to objects dynamically.	Often implemented directly using traits	Traits are commonly used for decorators.
Facade	Providing a simplified interface to a complex system.		Usually a matter of structuring your code.
Flyweight	Sharing objects to reduce memory usage.	Often implemented directly using `Rc` or `Arc`	`Rc` and `Arc` are used for shared ownership.
Proxy	Controlling access to another object.	Often implemented directly	Can be implemented with custom types and dereferencing.

Behavioral Patterns

Design Pattern	Description	Helpful Rust Crates	Notes
Chain of Responsibility	Handling requests by passing them along a chain of handlers.	Often implemented directly using enums or function pointers
Command	Encapsulating a request as an object.	Often implemented directly using structs and closures	Closures can be helpful for command implementations.
Interpreter	Defining a grammatical representation for a language and providing an interpreter.	Parsing crates like `nom`⮳, `pest`⮳, `lalrpop`⮳ can be helpful
Iterator	Providing a way to access elements of a sequence.		Iterators are a core language feature. `itertools`⮳ provides additional iterator adaptors.
Mediator	Defining an object that controls how other objects interact.	Often implemented directly
Memento	Capturing and externalizing an object's internal state.	Often implemented directly using structs and serialization	`serde`⮳ can be useful for serialization.
Observer	Notifying interested parties when a state changes.	`event-listener`⮳	Helps with implementing the observer pattern.
State	Altering an object's behavior when its internal state changes.	Often implemented directly using enums.	Enums are often used to represent states.
Strategy	Choosing an algorithm at runtime.	Often implemented directly using trait objects or enums.	Trait objects or enums are commonly used.
Template Method	Defining the skeleton of an algorithm and letting subclasses define specific steps.	Often implemented directly using traits	Traits are helpful for defining the template.
Visitor	Adding new operations to objects without changing their classes.	Often implemented directly using traits	Traits are usually used for visitor implementations.
Dependency Injection	Providing dependencies to components.	Dependency injection frameworks (`shaku`) exist, but it's often handled manually, especially in smaller projects. `yew`⮳ uses dependency injection for its component system.

Code Examples for Rust Design Patterns

Recipe	Crates	Categories
Implement an Abstract Factory
Clone a Struct Storing a Boxed Trait Object	[![dyn-clone][c-dyn-clone-badge]][c-dyn-clone]
`pin-project` and `pin-project-lite`	[![pin-project][c-pin-project-badge]][c-pin-project][![pin-project-lite][c-pin-project-lite-badge]][c-pin-project-lite]
Implement the Typestate Pattern in Rust

Pattern	Description	Example/Resources
Parsing	`nom`⮳, `pest`⮳, `lalrpop`⮳	These crates are useful for parsing various input formats.
Serialization (Serde)	`serde`⮳, `serde_json`⮳, `serde_yml`⮳, `toml`⮳	`serde`⮳ is a powerful framework for serialization and deserialization.
CLI Argument Parsing	`clap`⮳, `structopt`⮳	These crates help with parsing command-line arguments.
Logging	`log`⮳, `env_logger`⮳, `tracing`⮳	`log`⮳ is a logging facade, and `env_logger`⮳ and `tracing`⮳ are logging implementations.
Testing	Built-in	Rust has built-in support for unit and integration testing. Crates like `rstest`⮳ can help with testing.
Asynchronous Programming	`tokio`⮳, `async-std`⮳, `futures`⮳	`tokio`⮳ and `async-std`⮳ are asynchronous runtimes. `futures`⮳ provides utilities for working with futures.

References

Rust Unofficial: patterns⮳.
Rust: state machine pattern⮳.