Protocol composition in Swift - Deep Dive

Overview - Protocol composition

What is it?

Protocol composition in Swift lets you combine multiple protocols into one requirement. It means a type must follow all the protocols listed together. This helps write flexible and clear code by grouping behaviors without creating new protocols.

Why it matters

Without protocol composition, you would need to create many new protocols for every combination of behaviors. This would clutter your code and make it hard to manage. Protocol composition solves this by letting you mix and match protocols on the fly, making your code more reusable and easier to understand.

Where it fits

You should know what protocols are and how to use them before learning protocol composition. After this, you can explore advanced protocol features like protocol inheritance and associated types to write even more powerful abstractions.

Mental Model

Core Idea

Protocol composition means requiring a type to conform to multiple protocols at once by combining them into a single requirement.

Think of it like...

It's like asking a person to have multiple skills before hiring them, such as speaking English and knowing how to drive. Instead of creating a new job title for every skill combo, you just say they must have both skills.

┌─────────────────────────────┐
│       Protocol Composition   │
├─────────────┬───────────────┤
│ Protocol A  │ Protocol B    │
├─────────────┴───────────────┤
│ Combined Requirement: A & B │
└─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Swift Protocols

Concept: Protocols define a blueprint of methods and properties that a type can adopt.

In Swift, a protocol is like a contract. For example: protocol Drivable { func drive() } Any type that adopts Drivable must implement the drive() method.

Result

You can create types that promise to have certain behaviors, making your code more organized.

Understanding protocols is essential because protocol composition builds on combining these contracts.

2

Foundation

Conforming to Multiple Protocols

Concept: A type can adopt more than one protocol to gain multiple behaviors.

For example: protocol Flyable { func fly() } struct FlyingCar: Drivable, Flyable { func drive() { print("Driving") } func fly() { print("Flying") } } FlyingCar has both drive and fly abilities.

Result

Types can have multiple capabilities by conforming to several protocols.

Knowing that types can adopt many protocols sets the stage for combining protocol requirements.

3

Intermediate

Using Protocol Composition Syntax

🤔Before reading on: do you think you can require a type to conform to two protocols by listing them with a comma? Commit to your answer.

Concept: Swift uses & to combine protocols into one requirement called protocol composition.

You can write a function that accepts any type conforming to both Drivable and Flyable: func operate(vehicle: Drivable & Flyable) { vehicle.drive() vehicle.fly() } This means vehicle must have both drive() and fly() methods.

Result

You can require multiple behaviors without creating a new protocol.

Understanding the & syntax unlocks flexible and reusable code by combining protocols on demand.

4

Intermediate

Protocol Composition with Variables and Parameters

🤔Before reading on: do you think protocol composition can be used only in function parameters or also in variable declarations? Commit to your answer.

Concept: Protocol composition can be used anywhere a type is expected, including variables and constants.

Example: var vehicle: Drivable & Flyable vehicle = FlyingCar() vehicle.drive() vehicle.fly() This variable can hold any type that conforms to both protocols.

Result

You can store and pass around values that meet multiple protocol requirements easily.

Knowing protocol composition works beyond parameters helps write more general and flexible code.

5

Intermediate

Combining More Than Two Protocols

Concept: You can combine any number of protocols using & to require multiple behaviors.

Example: protocol Floatable { func float() } func test(vehicle: Drivable & Flyable & Floatable) { vehicle.drive() vehicle.fly() vehicle.float() } This requires the vehicle to support all three behaviors.

Result

Protocol composition scales to many protocols, making it very powerful.

Understanding this scalability helps design complex requirements without new protocols.

6

Advanced

Protocol Composition with Associated Types

🤔Before reading on: do you think protocol composition works seamlessly with protocols that have associated types? Commit to your answer.

Concept: Protocols with associated types can be combined, but require careful handling with type constraints.

Example: protocol Container { associatedtype Item func append(_ item: Item) } protocol Resettable { func reset() } func resetAndAppend(container: inout C, item: C.Item) { container.reset() container.append(item) } You combine protocols with associated types using generics and constraints.

Result

You can compose complex protocols but must manage associated types explicitly.

Knowing how to combine protocols with associated types avoids common compiler errors and unlocks advanced abstractions.

7

Expert

Runtime Behavior and Existential Types

🤔Before reading on: do you think protocol composition creates a new type at runtime or just a type constraint? Commit to your answer.

Concept: Protocol composition creates an existential type that can hold any value conforming to all protocols, but this has runtime costs and limitations.

When you write Drivable & Flyable, Swift creates a type that can hold any instance conforming to both. This is called an existential type. It uses dynamic dispatch to call methods, which can be slower than static dispatch. Also, you cannot access members not in the combined protocols. Example: let vehicle: Drivable & Flyable = FlyingCar() // vehicle can only call drive() and fly(), nothing else. Understanding this helps optimize and avoid pitfalls.

Result

You get flexible types but must be aware of performance and access limits.

Knowing the runtime nature of protocol composition helps write efficient and safe Swift code.

Under the Hood

Protocol composition creates an existential container that can hold any instance conforming to all listed protocols. At runtime, Swift uses dynamic dispatch to call methods on this container. The compiler generates metadata describing the combined protocols and uses it to verify conformance and method availability. This allows flexible code but adds a layer of indirection compared to concrete types.

Why designed this way?

Swift's protocol-oriented design encourages flexible abstractions without inheritance. Protocol composition avoids explosion of protocol types by letting developers combine existing protocols on demand. This design balances type safety, flexibility, and code reuse without forcing new protocol declarations for every combination.

┌───────────────────────────────┐
│ Protocol Composition Type      │
│ (Existential Container)        │
├───────────────┬───────────────┤
│ Protocol A    │ Protocol B    │
├───────────────┴───────────────┤
│ Holds any instance conforming │
│ to both A and B               │
├───────────────────────────────┤
│ Dynamic Dispatch Table         │
│ for method calls              │
└───────────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does protocol composition create a new protocol type? Commit to yes or no.

Common Belief: Protocol composition creates a new protocol that you can reuse like any other protocol.

Reality: Protocol composition is a type constraint, not a new protocol. It cannot be named or reused as a standalone protocol.

Why it matters: Thinking it creates a new protocol leads to confusion and misuse, such as trying to extend or adopt it directly.

Quick: Can you access properties or methods not declared in the composed protocols? Commit to yes or no.

Common Belief: When using protocol composition, you can access any property or method of the underlying type.

Reality: You can only access members declared in the combined protocols. Other members are hidden.

Why it matters: Expecting full access causes compiler errors and confusion about what members are available.

Quick: Does protocol composition always improve performance? Commit to yes or no.

Common Belief: Using protocol composition makes code faster because it combines protocols efficiently.

Reality: Protocol composition uses dynamic dispatch which can be slower than static dispatch with concrete types.

Why it matters: Assuming performance gains may lead to inefficient code in performance-critical areas.

Quick: Can protocol composition be used with protocols that have associated types without extra work? Commit to yes or no.

Common Belief: Protocol composition works seamlessly with all protocols, including those with associated types.

Reality: Protocols with associated types require generics and constraints to compose properly; direct composition is limited.

Why it matters: Ignoring this leads to compiler errors and frustration when combining complex protocols.

Expert Zone

1

Protocol composition creates an existential type that hides the concrete type, which affects method dispatch and type casting.

2

Combining protocols with associated types requires generic constraints, which can complicate function signatures and type inference.

3

Protocol composition cannot be extended or inherited from, so you must use typealiases or new protocols for reusable combinations.

When NOT to use

Avoid protocol composition when you need to reuse the combined protocol multiple times or extend it. Instead, define a new protocol that inherits from the required protocols. Also, avoid it in performance-critical code where static dispatch is preferred.

Production Patterns

In real-world Swift code, protocol composition is often used in function parameters and variables to accept flexible inputs. It's common in delegate patterns, dependency injection, and testing to require multiple capabilities without creating many protocols.

Connections

Multiple Inheritance (OOP)

Protocol composition is similar to multiple inheritance but safer and more flexible.

Understanding protocol composition helps grasp how Swift avoids the complexity of multiple inheritance by using protocol contracts instead.

Type Classes (Haskell)

Protocol composition resembles combining type classes to require multiple behaviors.

Knowing this connection shows how different languages solve the problem of combining capabilities in types.

Set Intersection (Mathematics)

Protocol composition acts like the intersection of sets, requiring membership in all sets (protocols).

This mathematical view clarifies why a type must satisfy all protocols in the composition.

Common Pitfalls

#1 Trying to extend a protocol composition directly.

Wrong approach:

extension Drivable & Flyable {
func honk() { print("Honk!") }
}

Correct approach:

protocol DrivableFlyable: Drivable, Flyable {
func honk()
}

extension DrivableFlyable {
func honk() { print("Honk!") }
}

Root cause:

Protocol composition is a type constraint, not a protocol, so it cannot be extended.

#2 Expecting to access properties not in the composed protocols.

Wrong approach:

func test(vehicle: Drivable & Flyable) {
vehicle.drive()
vehicle.fly()
vehicle.stop() // Error: stop() not in protocols
}

Correct approach:

Add stop() to one of the protocols or create a new protocol including it, then compose:

protocol Stoppable {
func stop()
}

func test(vehicle: Drivable & Flyable & Stoppable) {
vehicle.drive()
vehicle.fly()
vehicle.stop()
}

Root cause:

Only members declared in the composed protocols are accessible.

#3 Using protocol composition with protocols having associated types without generics.

Wrong approach:

func process(item: Container & Resettable) { /* ... */ } // Error: associatedtype issue

Correct approach:

func process(item: C) { /* ... */ }

Root cause:

Protocols with associated types require generic constraints for composition.

Key Takeaways

Protocol composition lets you require multiple protocol conformances in one place without creating new protocols.

It uses the & symbol to combine protocols and can be used in parameters, variables, and generics.

Protocol composition creates an existential type that hides the concrete type and uses dynamic dispatch.

You cannot extend or reuse protocol compositions as standalone protocols; use new protocols for that.

Combining protocols with associated types requires generics and careful type constraints.