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.

Practice

1. What does it mean for a Swift type to conform to a protocol?

easy

A. It can only be a class, not a struct or enum.

B. It inherits all properties and methods from the protocol automatically.

C. It implements all required methods and properties defined by the protocol.

D. It must override all methods from the protocol.

Solution

1. Step 1: Understand protocol requirements

   A protocol defines methods and properties that a type must implement to conform.

2. Step 2: Check what conformance means

   Conforming means the type provides implementations for all required members.

3. Final Answer:

   It implements all required methods and properties defined by the protocol. -> Option C

4. Quick Check:

   Protocol conformance = Implement required members [OK]

Hint: Conformance means implementing all required protocol parts [OK]

Common Mistakes:

• Thinking conformance means inheritance
• Believing only classes can conform
• Assuming methods must be overridden

2. Which of the following is the correct syntax to declare that a struct conforms to a protocol named Drawable?

easy

A. struct Shape inherits Drawable { }

B. struct Shape : Drawable { }

C. struct Shape implements Drawable { }

D. struct Shape extends Drawable { }

Solution

1. Step 1: Recall Swift syntax for protocol conformance

   Swift uses a colon (:) after the type name to declare protocol conformance.

2. Step 2: Match syntax options

   Only struct Shape : Drawable { } uses the correct colon syntax for protocol conformance.

3. Final Answer:

   struct Shape : Drawable { } -> Option B

4. Quick Check:

   Protocol conformance syntax uses ':' [OK]

Hint: Use ':' after type name to conform to protocol [OK]

Common Mistakes:

• Using 'implements' or 'inherits' keywords
• Confusing inheritance with protocol conformance
• Using 'extends' which is not Swift syntax

3. What will be the output of this Swift code?

protocol Greetable {
    func greet() -> String
}

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

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

medium

A. Hello!

B. Error: Missing greet() implementation

C. nil

D. Hello! Person

Solution

1. Step 1: Check protocol and struct conformance

   The protocol requires a greet() method returning String. Person implements greet() returning "Hello!".

2. Step 2: Analyze print output

   Calling p.greet() returns "Hello!", so print outputs that string.

3. Final Answer:

   Hello! -> Option A

4. Quick Check:

   Implemented greet() returns "Hello!" [OK]

Hint: Implemented method returns string printed directly [OK]

Common Mistakes:

• Assuming missing implementation error
• Expecting default protocol method output
• Confusing print output with type description

4. Identify the error in this Swift code that tries to conform to the Equatable protocol:

struct Point: Equatable {
    var x: Int
    var y: Int
}

medium

A. Missing implementation of == operator function

B. Struct cannot conform to Equatable

C. Properties must be constants (let) to conform

D. No error, code compiles fine

Solution

1. Step 1: Understand Equatable conformance rules

   Swift automatically synthesizes == for structs with Equatable properties.

2. Step 2: Check struct properties and conformance

   Both x and y are Int (Equatable), so compiler provides == automatically.

3. Final Answer:

   No error, code compiles fine -> Option D

4. Quick Check:

   Automatic Equatable synthesis = No error [OK]

Hint: Swift auto-synthesizes Equatable for simple structs [OK]

Common Mistakes:

• Thinking manual == is always needed
• Believing structs can't conform
• Assuming properties must be let

5. Given this protocol and struct, how can you modify Vehicle to conform to CustomStringConvertible and print a description?

protocol CustomStringConvertible {
    var description: String { get }
}

struct Vehicle {
    var make: String
    var model: String
}

hard

A. Add extension Vehicle: CustomStringConvertible { var description: String { "\(make) \(model)" } }

B. Add func description() -> String { return "\(make) \(model)" } inside Vehicle

C. Add var description: String = "\(make) \(model)" inside Vehicle

D. Add override var description: String { "\(make) \(model)" } inside Vehicle

Solution

1. Step 1: Understand protocol property requirement

   CustomStringConvertible requires a read-only computed property 'description' of type String.

2. Step 2: Implement description correctly

   Implementing description as a computed property in an extension is the correct way.

3. Final Answer:

   Add extension Vehicle: CustomStringConvertible { var description: String { "\(make) \(model)" } } -> Option A

4. Quick Check:

   Computed property in extension = Correct conformance [OK]

Hint: Use computed property in extension for protocol conformance [OK]

Common Mistakes:

• Trying to add description as a method
• Using stored property instead of computed
• Using override keyword in struct