Protocol extensions with default implementations in Swift - Step-by-Step Execution

Concept Flow - Protocol extensions with default implementations

Define Protocol

↓

Add Extension with Default Impl

↓

Create Struct/Class conforming Protocol

↓

Call Method

↓

Has Impl?

↓

Run Impl

This flow shows how a protocol defines requirements, extensions add default methods, and conforming types use either their own or the default implementations.

Execution Sample

Swift

protocol Greetable {
    func greet()
}

extension Greetable {
    func greet() {
        print("Hello from default implementation!")
    }
}

struct Person: Greetable {}

let p = Person()
p.greet()

Defines a protocol with a greet method, provides a default greet in an extension, then a struct uses the default greet.

Execution Table

Step	Action	Evaluation	Result
1	Define protocol Greetable with greet()	Protocol created	Greetable protocol ready
2	Add extension to Greetable with default greet()	Default method added	Default greet() prints message
3	Define struct Person conforming to Greetable	Person created	Person conforms to Greetable but no greet() method
4	Create instance p of Person	Instance created	p is Person instance
5	Call p.greet()	Check if Person has greet()	No greet() in Person
6	Use default greet() from extension	Run default greet()	Prints: Hello from default implementation!

💡 Execution stops after default greet() prints message

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	Final
p	nil	nil	nil	nil	Person instance	Person instance

Key Moments - 2 Insights

Why does p.greet() call the default implementation even though Person doesn't define greet()?

Because Person conforms to Greetable but does not provide its own greet(), Swift uses the default greet() from the protocol extension as shown in execution_table step 5 and 6.

What happens if Person defines its own greet() method?

If Person defines greet(), that method is called instead of the default. The default is only used when the conforming type lacks its own implementation.

Visual Quiz - 3 Questions

Look at the execution_table at step 5, what does Swift check when calling p.greet()?

A If p is nil

B If Person has its own greet() method

C If protocol Greetable has any methods

D If greet() is a static method

💡 Hint

Refer to execution_table step 5 where it checks if Person has greet()

At which step does the default greet() method get executed?

A Step 6

B Step 4

C Step 5

D Step 3

💡 Hint

See execution_table step 6 where default greet() runs

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

A Step 6 would call a different protocol method

B Step 6 would be skipped

C Step 6 would call Person's greet() instead of default

D Step 6 would cause a compile 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 uses default if no own implementation

Default implementations provide shared behavior without requiring each type to implement.

Full Transcript

This visual trace shows how Swift protocols can have default method implementations via extensions. First, a protocol named Greetable is defined with a greet() method requirement. Then, an extension adds a default greet() method that prints a message. A struct Person conforms to Greetable but does not implement greet() itself. When we create an instance p of Person and call p.greet(), Swift checks if Person has its own greet() method. Finding none, it uses the default greet() from the protocol extension, printing the message. This demonstrates how default implementations let conforming types share common behavior without writing the method themselves. If Person had its own greet(), that would be called instead of the default. This helps beginners understand protocol extensions as a way to provide reusable default code.

Practice

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

easy

A. To allow protocols to store properties

B. To create new classes that inherit from protocols

C. To enforce that all conforming types must implement every method

D. To provide default method implementations that all conforming types can use

Solution

1. Step 1: Understand protocol extensions

   Protocol extensions allow adding methods or properties with default behavior to protocols.

2. Step 2: Identify the purpose of default implementations

   Default implementations let conforming types use common code without writing it themselves.

3. Final Answer:

   To provide default method implementations that all conforming types can use -> Option D

4. Quick Check:

   Default implementations = shared code for all [OK]

Hint: Default implementations give shared code to all conforming types [OK]

Common Mistakes:

• Thinking protocols can store properties
• Confusing protocol inheritance with extensions
• Believing all methods must be implemented manually

2. Which of the following is the correct syntax to add a default implementation for a protocol method in Swift?

easy

A. extension MyProtocol { func greet() { print(\"Hello\") } }

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

C. func greet() in MyProtocol { print(\"Hello\") }

D. MyProtocol { func greet() { print(\"Hello\") } }"

Solution

1. Step 1: Recall syntax for protocol extensions

   Default implementations are added inside an extension of the protocol.

2. Step 2: Check each option

   extension MyProtocol { func greet() { print(\"Hello\") } } correctly uses extension MyProtocol { func greet() { ... } }. Others misuse keywords or structure.

3. Final Answer:

   extension MyProtocol { func greet() { print("Hello") } } -> Option A

4. Quick Check:

   Use extension to add defaults [OK]

Hint: Use 'extension ProtocolName' to add default methods [OK]

Common Mistakes:

• Trying to put method bodies inside protocol declaration
• Using 'extension' inside protocol block
• Omitting the 'extension' keyword

3. Consider the code below:

protocol Speaker {
    func speak()
}

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

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

struct Robot: Speaker {}

let p = Person()
p.speak()

let r = Robot()
r.speak()

What is the output when this code runs?

medium

A. Person speaking
Robot speaking

B. Speaking from extension
Speaking from extension

C. Person speaking
Speaking from extension

D. Compilation error

Solution

1. Step 1: Understand method resolution for protocol extensions

   If a conforming type provides its own method, it overrides the default from the extension.

2. Step 2: Analyze the structs

   Person implements speak() so it prints "Person speaking". Robot does not implement it, so uses default "Speaking from extension".

3. Final Answer:

   Person speaking Speaking from extension -> Option C

4. Quick Check:

   Own method overrides default extension [OK]

Hint: Own method overrides default extension method [OK]

Common Mistakes:

• Assuming default is always called
• Expecting Robot to cause error
• Confusing protocol declaration with implementation

4. The following code tries to add a default implementation for describe() in a protocol extension, but it causes a compile error. What is the mistake?

protocol Describable {
    func describe()
}

extension Describable {
    func describe
    {
        print("Default description")
    }
}

medium

A. Protocol cannot have methods without bodies

B. Missing parentheses after method name in extension

C. Extension cannot provide method implementations

D. Missing 'func' keyword in extension

Solution

1. Step 1: Check method syntax in extension

   Method definitions require parentheses even if no parameters are present.

2. Step 2: Identify the error

   The extension method func describe is missing parentheses () after the name.

3. Final Answer:

   Missing parentheses after method name in extension -> Option B

4. Quick Check:

   Method syntax needs () even if empty [OK]

Hint: Always include () after method name in definitions [OK]

Common Mistakes:

• Omitting parentheses in method declaration
• Thinking protocol methods must have bodies
• Believing extensions can't implement methods

5. You want to create a protocol Identifiable with a property id and a default method identify() that prints the id. How would you write the protocol and extension so that conforming types can use the default identify() without extra code?

hard

A. protocol Identifiable { var id: String { get } }\nextension Identifiable { func identify() { print(\"ID: \(id)\") } }

B. protocol Identifiable { func identify() }\nextension Identifiable { var id: String { return \"default\" } }

C. protocol Identifiable { var id: String }\nextension Identifiable { func identify() { print(id) } }

D. protocol Identifiable { var id: String { get set } }\nextension Identifiable { func identify() { print(\"ID: \(id)\") } }"

Solution

1. Step 1: Define protocol with read-only property

   Use var id: String { get } to require an id property that conforming types must provide.

2. Step 2: Provide default identify() method in extension

   Extension adds identify() that prints the id using string interpolation.

3. Final Answer:

   protocol Identifiable { var id: String { get } }\nextension Identifiable { func identify() { print("ID: \(id)") } } -> Option A

4. Quick Check:

   Protocol requires id; extension adds identify() [OK]

Hint: Require property with { get } and add method in extension [OK]

Common Mistakes:

• Using var id: String without { get } or { get set }
• Trying to provide stored properties in protocol extension
• Defining identify() in protocol but not implementing in extension