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.