Design Patterns, the Go way

Ensure a type has only one instance, and provide a single, well-defined point of access to it.

Define an interface for creating an object, but let the implementation decide which concrete type to instantiate.

Provide an interface for creating families of related objects without specifying their concrete types.

Construct a complex object step by step, separating how it's built from its final representation.

Create new objects by cloning an existing, configured instance instead of building one from scratch.

Convert the interface of a type into another interface clients expect, letting otherwise-incompatible types work together.

Decouple an abstraction from its implementation so the two can vary independently, instead of multiplying into N×M types.

Treat individual objects and compositions of objects uniformly through one common interface.

Attach new behavior to an object by wrapping it in another object of the same interface — without changing the original's type.

Provide a single, simplified interface over a complex subsystem, so clients don't have to orchestrate its parts.

Share common immutable state across many objects to slash memory use, keeping only per-instance data separate.

Provide a stand-in for another object that implements the same interface, to control access to it.

Pass a request along a chain of handlers until one of them handles it, decoupling sender from receiver.

Turn a request into a standalone object, letting you parameterize, queue, log, and undo operations.

Define a grammar for a simple language and an interpreter that evaluates sentences by walking an expression tree.

Provide a way to access the elements of a collection sequentially without exposing its underlying representation.

Centralize communication between objects in a mediator, so they don't refer to each other directly.

Capture and externalize an object's internal state so it can be restored later — without violating its encapsulation.

Define a one-to-many dependency so that when one object changes state, all its dependents are notified automatically.

Let an object alter its behavior when its internal state changes, as if it changed class.

Define a family of interchangeable algorithms, encapsulate each one, and select which to use at runtime.

Define the skeleton of an algorithm once, deferring the steps that vary to per-type implementations.

Add new operations to a set of object types without modifying those types, by moving each operation into a visitor.

Process a stream of data through a series of stages connected by channels, where each stage is a goroutine.

Distribute work across multiple goroutines (fan-out) and merge their results back into one stream (fan-in).

Bound concurrency by feeding jobs to a fixed number of long-lived worker goroutines.

Produce a stream of values from a goroutine over a channel, lazily and on demand.

Wrap a value stream so that ranging over it also stops cleanly the moment a cancellation signal fires.

Propagate cancellation, deadlines, and request-scoped values across API boundaries and goroutine trees with context.Context.

Limit how many goroutines may run a section of code (or hold a resource) at the same time.

Run a group of goroutines, wait for them all, capture the first error, and cancel the rest automatically.

Broadcast events to many dynamic subscribers through a broker, decoupling producers from consumers.