Structural Patterns in Scala

Structural patterns in Scala are less about reproducing object-oriented class diagrams and more about shaping boundaries cleanly. Scala gives you traits, case classes, sealed hierarchies, objects, extension methods, higher-order functions, and immutable data. Those features let you solve the same structural problems as classic patterns, but often with smaller and more explicit designs.

This chapter is best read as a set of boundary decisions:

• use Adapter when two APIs do not fit and one side should stay unchanged
• use Bridge when a stable abstraction must vary independently from its implementation
• use Composite when tree-shaped data and recursive behavior belong together
• use Decorator when you need to wrap behavior at the edge without mutating the wrapped type
• use Facade when a subsystem needs one cleaner entry point
• use Flyweight when many values can safely share immutable intrinsic state
• use Proxy when access, laziness, remoteness, or policy should sit between client and target
• use Extension Methods when call-site ergonomics matter but ownership of the original type does not
• use Module Pattern when the primary structural problem is code organization, encapsulation, and assembly

In Scala, the main design question is usually not “which named pattern fits?” It is “where should this boundary live, and which language feature makes that boundary obvious?” The strongest solutions tend to preserve referential transparency where possible, keep mutation near the edges, and avoid introducing extra object hierarchies just to imitate catalog examples.

In this section

• Adapter Pattern in Scala Design Patterns
  Explore the Adapter Pattern in Scala, a key structural design pattern for bridging incompatible interfaces using traits, wrappers, and extension methods.
• Bridge Pattern in Scala: Separating Abstraction from Implementation
  Explore the Bridge Pattern in Scala, a structural design pattern that separates abstraction from implementation to keep capability models independent from platform-specific behavior.
• Composite Pattern in Scala: Mastering Tree Structures with Case Classes and Sealed Traits
  Explore the Composite Pattern in Scala, leveraging case classes and sealed traits to model recursive tree structures with immutable data and uniform operations.
• Decorator Pattern in Scala: Enhancing Flexibility and Extensibility
  Explore the Decorator Pattern in Scala, leveraging wrappers, traits, and middleware-style composition to layer behavior around an existing component.
• Facade Pattern: Simplifying Complex Systems in Scala
  Explore the Facade Pattern in Scala, a structural design pattern that provides a simplified interface to a subsystem while keeping the deeper system available where needed.
• Flyweight Pattern in Scala: Efficient Data Sharing
  Explore the Flyweight Pattern in Scala, focusing on efficient data sharing through immutability, cached values, and careful separation of intrinsic and extrinsic state.
• Proxy Pattern in Scala: Comprehensive Guide for Expert Developers
  Explore the Proxy Pattern in Scala, its implementation using wrappers, lazy values, and policy boundaries to control access to objects and services.
• Extension Methods in Scala: Enhancing Code Flexibility and Reusability
  Explore how extension methods in Scala improve call-site ergonomics and support lightweight structural adaptation without changing the underlying type.
• Scala Module Pattern: Organizing Code into Reusable Units
  Explore the Module Pattern in Scala, a structural design approach that organizes code with packages, objects, traits, and explicit wiring to keep boundaries clear.