Protocol inheritance in Swift - Deep Dive

Overview - Protocol inheritance

What is it?

Protocol inheritance in Swift means one protocol can adopt the requirements of another protocol. This allows a new protocol to include all the rules of the original protocol plus add more rules. It helps organize and reuse sets of behaviors that types must follow. Think of it as building on top of existing agreements to create more detailed ones.

Why it matters

Without protocol inheritance, you would have to repeat the same requirements in many protocols, making code harder to maintain and understand. Protocol inheritance lets you create clear, reusable contracts for your code, so different parts can work together smoothly. This saves time and reduces mistakes when building apps or systems.

Where it fits

Before learning protocol inheritance, you should understand basic Swift protocols and how they define requirements for types. After mastering protocol inheritance, you can explore protocol composition, protocol extensions, and advanced Swift features like associated types and generics.

Mental Model

Core Idea

Protocol inheritance lets one protocol include all the rules of another, creating a chain of requirements that types must follow.

Think of it like...

It's like a family recipe where a new recipe inherits all the ingredients and steps from a parent recipe but adds extra ingredients or steps to make a special dish.

┌───────────────┐
│  Protocol A   │
│ (basic rules) │
└──────┬────────┘
       │ inherits
┌──────▼────────┐
│  Protocol B   │
│ (A's rules +  │
│  extra rules) │
└───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding basic protocols

Concept: Learn what a protocol is and how it defines rules for types.

In Swift, a protocol is like a blueprint that says what properties or methods a type must have. For example, a protocol named 'Drivable' might require a 'drive()' method. Any type that says it conforms to 'Drivable' must have that method.

Result

You know how to create a simple protocol and make a type follow it.

Understanding protocols is essential because protocol inheritance builds on this idea of defining rules for types.

2

Foundation

Conforming types to protocols

Concept: Learn how types follow protocols by implementing required methods and properties.

When a class, struct, or enum says it conforms to a protocol, it promises to implement all the required parts. For example, a 'Car' struct conforming to 'Drivable' must have a 'drive()' method. This ensures the type behaves as expected.

Result

You can create types that follow protocols and fulfill their contracts.

Knowing how types conform to protocols helps you see why combining protocols with inheritance is powerful.

3

Intermediate

Creating protocols that inherit others

🤔Before reading on: do you think a protocol that inherits another must re-define all its requirements? Commit to yes or no.

Concept: Protocols can inherit from one or more other protocols, gaining all their requirements automatically.

You can write a protocol that says it inherits from another protocol. For example: protocol Vehicle { func start() } protocol Car: Vehicle { func openTrunk() } Here, 'Car' inherits 'Vehicle', so any 'Car' must implement both 'start()' and 'openTrunk()'.

Result

Protocols can build on each other, creating layered requirements.

Understanding that protocols inherit requirements without repeating them helps you write cleaner, more organized code.

4

Intermediate

Multiple protocol inheritance

🤔Before reading on: can a protocol inherit from more than one protocol at the same time? Commit to yes or no.

Concept: A protocol can inherit from multiple protocols, combining their requirements.

Swift allows a protocol to inherit from several protocols separated by commas. For example: protocol Flyable { func fly() } protocol Swimmable { func swim() } protocol Duck: Flyable, Swimmable { func quack() } Any type conforming to 'Duck' must implement 'fly()', 'swim()', and 'quack()'.

Result

Protocols can combine multiple behaviors into one contract.

Knowing multiple inheritance lets you mix and match behaviors flexibly without repeating code.

5

Intermediate

Using protocol inheritance in practice

Concept: Learn how to use inherited protocols to write flexible and reusable code.

By defining protocols that inherit others, you can write functions or types that work with any type conforming to a complex set of rules. For example: func operate(vehicle: Vehicle) { vehicle.start() } func load(car: Car) { car.openTrunk() } This separation lets you write code that works with general or specific behaviors.

Result

You can design code that adapts to different levels of capability.

Understanding this helps you build scalable and maintainable codebases.

6

Advanced

Protocol inheritance and associated types

🤔Before reading on: do you think protocols with associated types can be inherited without restrictions? Commit to yes or no.

Concept: Protocols with associated types add complexity to inheritance and require careful handling.

Some protocols define associated types as placeholders for types used inside them. When inheriting such protocols, you must ensure the associated types are compatible or constrained. For example: protocol Container { associatedtype Item func append(_ item: Item) } protocol Stack: Container { func pop() -> Item? } Here, 'Stack' inherits 'Container' and uses the same associated type 'Item'.

Result

You learn how inheritance works with more complex protocol features.

Knowing this prevents confusion and errors when combining protocols with generics.

7

Expert

Protocol inheritance and runtime behavior

🤔Before reading on: does protocol inheritance affect how Swift checks conformance at runtime? Commit to yes or no.

Concept: Protocol inheritance influences how Swift performs type checking and dispatches methods at runtime.

When a type conforms to a protocol that inherits others, Swift ensures it meets all inherited requirements. At runtime, Swift uses protocol witness tables to find the correct method implementations. This layered structure allows efficient method calls even with multiple inherited protocols.

Result

You understand the performance and safety benefits of protocol inheritance.

Understanding runtime mechanics helps you write protocols that are both flexible and efficient.

Under the Hood

Swift protocols use a structure called a protocol witness table to keep track of which methods and properties a type implements for each protocol. When a protocol inherits another, its witness table includes entries for all inherited requirements. This allows Swift to call the right method implementations dynamically, even if the exact type is unknown at compile time.

Why designed this way?

Protocol inheritance was designed to promote code reuse and clear abstraction without forcing concrete inheritance hierarchies. It allows types to conform to multiple behaviors flexibly. The witness table approach balances dynamic dispatch with performance, avoiding the overhead of full class inheritance while supporting polymorphism.

┌─────────────┐
│ Protocol A  │
│ Requirements│
└──────┬──────┘
       │
┌──────▼──────┐
│ Protocol B  │
│ Inherits A  │
│ + New Req.  │
└──────┬──────┘
       │
┌──────▼──────┐
│ Type X      │
│ Conforms to │
│ Protocol B  │
└─────────────┘

At runtime:
Type X's witness table includes all methods from Protocol A and B.

Myth Busters - 4 Common Misconceptions

Quick: Does a protocol that inherits another protocol require types to implement only the new methods? Commit to yes or no.

Common Belief: Types only need to implement the new methods declared in the inheriting protocol.

Reality: Types must implement all methods from the inherited protocols as well as the new ones.

Why it matters: If you forget to implement inherited methods, your code won't compile, causing confusion and wasted time.

Quick: Can a protocol inherit from a class in Swift? Commit to yes or no.

Common Belief: Protocols can inherit from classes to gain their properties and methods.

Reality: Protocols cannot inherit from classes; they can only inherit from other protocols.

Why it matters: Misunderstanding this leads to incorrect designs and compiler errors.

Quick: Does multiple protocol inheritance cause the diamond problem like in some languages? Commit to yes or no.

Common Belief: Multiple protocol inheritance causes diamond problem conflicts.

Reality: Swift protocols avoid the diamond problem because they only declare requirements, not implementations.

Why it matters: Knowing this prevents unnecessary fear of using multiple inheritance in protocols.

Quick: Can protocol inheritance change the associated types of the inherited protocol? Commit to yes or no.

Common Belief: You can change associated types when inheriting a protocol.

Reality: Associated types must remain consistent or be constrained; you cannot arbitrarily change them in inheritance.

Why it matters: Misusing associated types breaks type safety and causes confusing errors.

Expert Zone

1

Protocol inheritance does not inherit implementations, only requirements, which means default implementations in protocol extensions are not inherited automatically.

2

When multiple protocols have conflicting requirements, the conforming type must resolve the conflict explicitly, which can be subtle in complex inheritance chains.

3

Protocols with associated types and inheritance require careful use of 'where' clauses to constrain types and avoid ambiguous or unsatisfiable requirements.

When NOT to use

Avoid protocol inheritance when you need to share actual code implementations; use class inheritance or protocol extensions with default implementations instead. Also, if your protocols become too complex with many inherited requirements, consider composition or breaking them into smaller protocols.

Production Patterns

In real-world Swift projects, protocol inheritance is used to define layered capabilities, such as a 'Readable' protocol inherited by 'Writable' to create a 'ReadWritable' protocol. This helps organize code by capability levels and allows flexible API design. It's also common in frameworks to define base protocols that others extend for specialized behaviors.

Connections

Interface inheritance in object-oriented programming

Protocol inheritance in Swift is similar to interface inheritance in languages like Java or C#, where interfaces can extend other interfaces.

Understanding interface inheritance helps grasp how protocols build on each other to define richer contracts without implementation.

Trait composition in Rust

Both protocol inheritance and Rust's trait composition allow combining multiple behavior contracts into one, but Rust traits can also provide default implementations.

Comparing these shows different ways languages balance code reuse and abstraction.

Legal contract clauses

Protocol inheritance is like legal contracts where a new contract includes all clauses of an earlier contract plus adds new ones.

This connection highlights how layered agreements ensure all previous rules apply, helping understand the purpose of inheritance.

Common Pitfalls

#1 Forgetting to implement inherited protocol requirements

Wrong approach:

protocol Vehicle {
func start()
}

protocol Car: Vehicle {
func openTrunk()
}

struct MyCar: Car {
func openTrunk() {
print("Trunk opened")
}
// Missing start() implementation
}

Correct approach:

struct MyCar: Car {
func start() {
print("Engine started")
}
func openTrunk() {
print("Trunk opened")
}
}

Root cause:

Misunderstanding that conforming to an inherited protocol requires implementing all inherited methods.

#2 Trying to inherit a protocol from a class

Wrong approach:

protocol MyProtocol: UIViewController {
func doSomething()
}

Correct approach:

protocol MyProtocol {
func doSomething()
}

Root cause:

Confusing protocols with classes and expecting protocols to inherit class behavior.

#3 Assuming protocol inheritance copies default implementations

Wrong approach:

protocol A {
func greet()
}

extension A {
func greet() { print("Hello") }
}

protocol B: A {
func greet()
}

struct S: B {}

let s = S()
s.greet() // Error: greet() not implemented

Correct approach:

struct S: B {
func greet() { print("Hello") }
}

let s = S()
s.greet() // Prints Hello

Root cause:

Believing protocol inheritance includes default implementations from extensions, which it does not.

Key Takeaways

Protocol inheritance allows one protocol to include all requirements of another, building layered contracts for types.

Types conforming to inherited protocols must implement all inherited requirements, not just the new ones.

Protocols can inherit from multiple protocols, combining behaviors without causing conflicts like class inheritance might.

Protocol inheritance affects runtime method dispatch through witness tables, enabling flexible and efficient polymorphism.

Understanding protocol inheritance helps write clean, reusable, and scalable Swift code that models complex behaviors clearly.