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.

Practice

1. What does protocol inheritance in Swift allow you to do?

easy

A. Create instances of protocols directly

B. Inherit properties and methods from a class

C. Override methods in a protocol

D. Create a new protocol that includes requirements from one or more existing protocols

Solution

1. Step 1: Understand protocol inheritance concept

   Protocol inheritance lets you build new protocols by combining existing ones, so the new protocol requires all combined features.

2. Step 2: Compare options with concept

   Only Create a new protocol that includes requirements from one or more existing protocols correctly describes creating a new protocol that inherits requirements from existing protocols.

3. Final Answer:

   Create a new protocol that includes requirements from one or more existing protocols -> Option D

4. Quick Check:

   Protocol inheritance = create combined protocols [OK]

Hint: Protocol inheritance combines requirements from multiple protocols [OK]

Common Mistakes:

• Confusing protocol inheritance with class inheritance
• Thinking protocols can be instantiated
• Believing protocols can override methods

2. Which of the following is the correct syntax to declare a protocol AdvancedProtocol that inherits from BasicProtocol in Swift?

easy

A. protocol AdvancedProtocol: BasicProtocol {}

B. protocol AdvancedProtocol inherits BasicProtocol {}

C. protocol AdvancedProtocol extends BasicProtocol {}

D. protocol AdvancedProtocol implements BasicProtocol {}

Solution

1. Step 1: Recall Swift protocol inheritance syntax

   In Swift, a protocol inherits from another by listing the parent protocol after a colon (:).

2. Step 2: Match syntax with options

   Only protocol AdvancedProtocol: BasicProtocol {} uses the correct syntax: protocol NewProtocol: ExistingProtocol {}.

3. Final Answer:

   protocol AdvancedProtocol: BasicProtocol {} -> Option A

4. Quick Check:

   Protocol inheritance syntax uses colon (:) [OK]

Hint: Use colon (:) to inherit protocols in Swift [OK]

Common Mistakes:

• Using 'inherits' or 'extends' keywords which are invalid in Swift
• Using 'implements' keyword which is for classes, not protocols
• Missing the colon between protocol names

3. Given the following code, what will be the output when example.printInfo() is called?

protocol A {
    func printInfo()
}
protocol B: A {
    func printExtra()
}
class Example: B {
    func printInfo() {
        print("Info from A")
    }
    func printExtra() {
        print("Extra from B")
    }
}
let example = Example()
example.printInfo()

medium

A. Info from A

B. Extra from B

C. No output, compile error

D. Info from A\nExtra from B

Solution

1. Step 1: Understand protocol inheritance and class conformance

   Protocol B inherits from A, so class Example must implement both printInfo() and printExtra(). It does.

2. Step 2: Identify which method is called

   The code calls example.printInfo(), which prints "Info from A".

3. Final Answer:

   Info from A -> Option A

4. Quick Check:

   Calling printInfo() prints "Info from A" [OK]

Hint: Match called method to implemented function output [OK]

Common Mistakes:

• Confusing which method is called
• Expecting both methods to print automatically
• Thinking protocol inheritance affects method output

4. What is wrong with the following Swift code?

protocol P1 {
    func method1()
}
protocol P2: P1 {
    func method2()
}
class MyClass: P2 {
    func method2() {
        print("Method 2")
    }
}

medium

A. P2 cannot inherit from P1

B. method2() should not be implemented in MyClass

C. MyClass must implement method1() because P2 inherits from P1

D. MyClass should be a protocol, not a class

Solution

1. Step 1: Analyze protocol inheritance and class conformance

   Protocol P2 inherits from P1, so any class conforming to P2 must implement all methods from P1 and P2.

2. Step 2: Check implemented methods in MyClass

   MyClass implements only method2() but misses method1(), causing a compile error.

3. Final Answer:

   MyClass must implement method1() because P2 inherits from P1 -> Option C

4. Quick Check:

   Inherited protocol methods must be implemented [OK]

Hint: Implement all inherited protocol methods in conforming class [OK]

Common Mistakes:

• Ignoring inherited protocol requirements
• Thinking only new protocol methods must be implemented
• Confusing class and protocol roles

5. You have two protocols:

protocol Vehicle {
    func start()
}
protocol ElectricVehicle: Vehicle {
    func charge()
}

You want to create a class ElectricCar that conforms to ElectricVehicle. Which implementation correctly satisfies all protocol requirements?

hard

A. class ElectricCar: ElectricVehicle {
func start() { print("Starting") }
}

B. class ElectricCar: ElectricVehicle {
func start() { print("Starting") }
func charge() { print("Charging") }
}

C. class ElectricCar: Vehicle {
func charge() { print("Charging") }
}

D. class ElectricCar: ElectricVehicle {
func charge() { print("Charging") }
}

Solution

1. Step 1: Understand protocol inheritance requirements

   ElectricVehicle inherits from Vehicle, so conforming types must implement both start() and charge().

2. Step 2: Check each class implementation

   class ElectricCar: ElectricVehicle { func start() { print("Starting") } func charge() { print("Charging") } } implements both methods, fulfilling all requirements. Options B and D miss charge() or start(). class ElectricCar: Vehicle { func charge() { print("Charging") } } does not conform to ElectricVehicle.

3. Final Answer:

   class ElectricCar: ElectricVehicle { func start() { print("Starting") } func charge() { print("Charging") } } -> Option B

4. Quick Check:

   Implement all inherited protocol methods in class [OK]

Hint: Implement all methods from inherited protocols in your class [OK]

Common Mistakes:

• Implementing only one protocol method
• Conforming to wrong protocol
• Missing methods from inherited protocols