Protocol conformance in Swift - Step-by-Step Execution

Concept Flow - Protocol conformance

Define Protocol

↓

Create Struct/Class

↓

Declare conformance to Protocol

↓

Implement required properties/methods

↓

Use instance as Protocol type

↓

Call protocol methods/properties

This flow shows how a type declares it follows a protocol, implements required parts, and then can be used through the protocol.

Execution Sample

Swift

protocol Greetable {
    func greet() -> String
}

struct Person: Greetable {
    func greet() -> String { "Hello!" }
}

let p = Person()
print(p.greet())

Defines a protocol with a greet method, a struct that conforms by implementing greet, then calls greet.

Execution Table

Step	Action	Evaluation	Result
1	Define protocol Greetable with greet()	Protocol created	Greetable protocol exists
2	Define struct Person conforming to Greetable	Person type created	Person struct exists, promises to implement greet()
3	Implement greet() in Person	Method greet() returns "Hello!"	Person now conforms to Greetable
4	Create instance p of Person	p is Person	p created
5	Call p.greet()	Calls Person.greet()	Returns "Hello!"
6	Print result	Output to console	Hello!
7	End	Program ends	Execution stops

💡 Program ends after printing "Hello!"

Variable Tracker

Variable	Start	After Step 4	After Step 5	Final
p	undefined	Person instance	Person instance	Person instance

Key Moments - 3 Insights

Why must Person implement the greet() method?

Because the protocol Greetable requires it. The execution_table row 3 shows Person implements greet(), fulfilling the protocol contract.

Can we create a Person without implementing greet()?

No, Swift requires all protocol methods to be implemented. The execution_table row 2 shows Person promises to implement greet(), so skipping it causes an error.

What happens when we call p.greet()?

The Person's greet() method runs and returns "Hello!" as shown in execution_table row 5.

Visual Quiz - 3 Questions

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

A "Hello!"

B "Hi!"

C No output

D Error

💡 Hint

Check execution_table row 5 where p.greet() returns "Hello!"

At which step does Person promise to implement the protocol method?

A Step 1

B Step 2

C Step 4

D Step 5

💡 Hint

Look at execution_table row 2 where Person declares conformance

If Person did not implement greet(), what would happen?

A Program runs normally

B Runtime error

C Compile-time error

D greet() returns nil

💡 Hint

Refer to key_moments question 2 about required implementation

Concept Snapshot

protocol ProtocolName {
    func requiredMethod() -> ReturnType
}

struct TypeName: ProtocolName {
    func requiredMethod() -> ReturnType { ... }
}

- Protocol defines required methods/properties.
- Types declare conformance and implement all requirements.
- Instances can be used via protocol interface.

Full Transcript

This example shows how to define a protocol named Greetable with a required method greet(). Then a struct Person declares it conforms to Greetable and implements the greet() method returning "Hello!". We create an instance p of Person and call p.greet(), which prints "Hello!". The execution steps trace defining the protocol, creating the struct, implementing the method, creating an instance, calling the method, and printing the output. Key points include that the struct must implement all protocol methods to conform, and calling the method runs the struct's implementation. The quiz checks understanding of output, conformance declaration, and consequences of missing implementations.