Protocol extensions for shared behavior in Swift - Step-by-Step Execution

Concept Flow - Protocol extensions for shared behavior

Define Protocol

↓

Add Extension with Default Methods

↓

Create Struct/Class conforming Protocol

↓

Call Method on Instance

↓

Use Default Implementation if no override

↓

Override Possible in Conforming Type

This flow shows how a protocol is defined, extended with default behavior, and how conforming types use or override that behavior.

Execution Sample

Swift

protocol Greetable {
    func greet()
}

extension Greetable {
    func greet() { print("Hello from protocol extension") }
}

struct Person: Greetable {}

let p = Person()
p.greet()

Defines a protocol with a greet method, provides a default greet implementation in an extension, then calls greet on a conforming struct instance.

Execution Table

Step	Action	Evaluation	Result
1	Define protocol Greetable with greet()	Protocol created	Greetable protocol exists
2	Extend Greetable with default greet()	Default method added	greet() prints 'Hello from protocol extension'
3	Define struct Person conforming to Greetable	Person created	Person conforms to Greetable, no greet() override
4	Create instance p of Person	Instance created	p is Person instance
5	Call p.greet()	No override found, use extension method	Prints: Hello from protocol extension

💡 Method call completed, default implementation used because Person has no override

Variable Tracker

Variable	Start	After Step 4	After Step 5
p	nil	Person instance created	Person instance remains unchanged

Key Moments - 2 Insights

Why does p.greet() print the message even though Person has no greet() method?

Because the protocol extension provides a default implementation of greet(), which is used when the conforming type does not override it (see execution_table step 5).

Can Person provide its own greet() method?

Yes, if Person defines its own greet(), that method overrides the default from the protocol extension (not shown here but implied by the flow).

Visual Quiz - 3 Questions

Look at the execution_table, what happens at step 5 when p.greet() is called?

A Person's own greet() method is called

B Compilation error because greet() is missing

C Default greet() from protocol extension is called

D Nothing happens

💡 Hint

See execution_table row 5: No override found, default method used

According to variable_tracker, what is the state of variable p after step 4?

A p is nil

B p is a Person instance

C p is a Greetable protocol type

D p is undefined

💡 Hint

Check variable_tracker row for p after step 4

If Person had its own greet() method, how would step 5 change in the execution_table?

A It would call Person's greet() instead of the default

B It would cause a runtime error

C It would still call the default greet()

D It would cause a compilation error

💡 Hint

Recall key_moments answer about overriding default implementations

Concept Snapshot

protocol ProtocolName {
    func method()
}

extension ProtocolName {
    func method() { /* default code */ }
}

struct Type: ProtocolName {}

// Calling method() on Type instance uses default unless overridden

Full Transcript

This example shows how Swift protocols can be extended to provide default behavior. First, a protocol named Greetable is defined with a greet() method requirement. Then, an extension adds a default implementation of greet() that prints a message. A struct Person conforms to Greetable but does not implement greet() itself. When we create an instance of Person and call greet(), the default implementation from the protocol extension runs, printing the message. This demonstrates how protocol extensions allow shared behavior without requiring every conforming type to implement the method. If Person provided its own greet(), that would override the default. The execution table traces each step from defining the protocol to calling the method, and the variable tracker shows the state of the instance. The quiz questions test understanding of default method usage and overriding.

Practice

1. What is the main purpose of using protocol extensions in Swift?

easy

A. To store data inside protocols

B. To add shared behavior to multiple types without repeating code

C. To create new classes that inherit from protocols

D. To prevent types from conforming to protocols

Solution

1. Step 1: Understand protocol extensions

   Protocol extensions allow adding default method or property implementations to protocols.

2. Step 2: Identify the benefit

   This lets many types share behavior without rewriting the same code.

3. Final Answer:

   To add shared behavior to multiple types without repeating code -> Option B

4. Quick Check:

   Protocol extensions = shared behavior [OK]

Hint: Protocol extensions add default behavior to many types [OK]

Common Mistakes:

• Thinking protocols can store data
• Confusing protocol extensions with inheritance
• Believing protocol extensions prevent conformance

2. Which of the following is the correct syntax to add a default method greet() to a protocol Greeter using an extension?

easy

A. extension Greeter: greet() { print("Hello") }

B. protocol Greeter { extension func greet() { print("Hello") } }

C. extension Greeter { func greet() { print("Hello") } }

D. protocol Greeter { func greet() { print("Hello") } }

Solution

1. Step 1: Recall protocol extension syntax

   To add default behavior, use extension ProtocolName { func method() { ... } }.

2. Step 2: Check each option

   extension Greeter { func greet() { print("Hello") } } correctly uses extension Greeter { func greet() { ... } }. Others misuse protocol or extension syntax.

3. Final Answer:

   extension Greeter { func greet() { print("Hello") } } -> Option C

4. Quick Check:

   Extension syntax = extension ProtocolName { func ... } [OK]

Hint: Use 'extension ProtocolName { func ... }' for default methods [OK]

Common Mistakes:

• Putting method inside protocol body with implementation
• Using 'extension' keyword inside protocol declaration
• Trying to add method with colon syntax

3. Consider this Swift code:

protocol Vehicle {
    func start()
}

extension Vehicle {
    func start() {
        print("Starting vehicle")
    }
}

struct Car: Vehicle {}

let myCar = Car()
myCar.start()

What will be printed when this code runs?

medium

A. Starting vehicle

B. No output

C. Compile error: missing start() implementation

D. Runtime error

Solution

1. Step 1: Understand protocol and extension

   The protocol Vehicle requires a start() method. The extension provides a default implementation.

2. Step 2: Check struct Car conformance

   Car conforms to Vehicle but does not implement start(), so it uses the default from the extension.

3. Final Answer:

   Starting vehicle -> Option A

4. Quick Check:

   Default method runs if not overridden [OK]

Hint: Default extension methods run if type doesn't override [OK]

Common Mistakes:

• Expecting compile error for missing method
• Thinking no output will print
• Confusing runtime error with missing implementation

4. This code tries to add a default method to a protocol but causes an error:

protocol Speaker {
    func speak()
}

extension Speaker {
    func speak() {
        print("Speaking")
    }
}

struct Person: Speaker {
    func speak() {
        print("Hello")
    }
}

let p = Person()
p.speak()

What is the error and how to fix it?

medium

A. No error; output is 'Hello'

B. Error: protocol method cannot have default implementation; remove extension

C. Error: struct must mark speak() as 'override'; add 'override' keyword

D. Error: protocol must declare speak() as optional

Solution

1. Step 1: Analyze protocol and extension

   Protocol Speaker requires speak(). Extension provides default implementation.

2. Step 2: Check struct Person implementation

   Person implements speak(), overriding the default. This is allowed and correct.

3. Final Answer:

   No error; output is 'Hello' -> Option A

4. Quick Check:

   Override default method by implementing in type [OK]

Hint: Implementing method in type overrides default extension [OK]

Common Mistakes:

• Thinking default methods cause errors
• Trying to use 'override' keyword in struct
• Believing protocol methods must be optional

5. You want to add a shared method describe() to multiple unrelated types Cat and Dog without repeating code. Which approach using protocol extensions is best?

hard

A. Add a global function describe() that takes Any type

B. Add describe() method separately in Cat and Dog structs

C. Use class inheritance from a base class with describe() method

D. Create a protocol Animal with describe() and add default implementation in extension; make Cat and Dog conform

Solution

1. Step 1: Identify shared behavior need

   Both Cat and Dog need the same describe() method without repeating code.

2. Step 2: Use protocol with extension

   Define protocol Animal with describe(), then provide default describe() in protocol extension. Make Cat and Dog conform to Animal.

3. Final Answer:

   Create a protocol Animal with describe() and add default implementation in extension; make Cat and Dog conform -> Option D

4. Quick Check:

   Protocol extension = shared behavior for unrelated types [OK]

Hint: Use protocol + extension for shared methods across types [OK]

Common Mistakes:

• Repeating code in each type
• Using class inheritance when types are unrelated
• Using global functions losing type safety