Protocol conformance via extension in Swift - Mini Project: Build & Apply

Protocol conformance via extension

📖 Scenario: Imagine you are building a simple app that manages different types of vehicles. You want all vehicles to be able to describe themselves with a short message.

🎯 Goal: You will create a protocol called VehicleDescription that requires a description method. Then, you will make a struct Car conform to this protocol using an extension. Finally, you will print the description of a Car instance.

📋 What You'll Learn

Create a protocol named VehicleDescription with a method func description() -> String

Create a struct named Car with a property model of type String

Use an extension to make Car conform to VehicleDescription

Implement the description() method inside the extension to return a string describing the car model

Create an instance of Car with model "Tesla Model S"

Print the result of calling description() on the Car instance

💡 Why This Matters

🌍 Real World

Protocols help define common behavior for different types in apps, making code easier to organize and extend.

💼 Career

Understanding protocol conformance via extensions is essential for writing clean, modular Swift code in iOS development.

1

Create the protocol and struct

Create a protocol called VehicleDescription with a method func description() -> String. Then create a struct called Car with a property model of type String.

Swift

# Create protocol VehicleDescription with method description() -> String
# Create struct Car with property model: String

Hint

Protocols define methods that types must implement. Structs hold data like the car model.

2

Add protocol conformance via extension

Use an extension to make Car conform to VehicleDescription. Implement the description() method inside the extension to return a string like "Car model: Tesla Model S" using the model property.

Swift

protocol VehicleDescription {
    func description() -> String
}

struct Car {
    let model: String
}

// Extend Car to conform to VehicleDescription
// Implement description() method

Hint

Extensions add protocol conformance outside the original struct. Use string interpolation to include the model.

3

Create a Car instance

Create a constant called myCar of type Car and set its model property to "Tesla Model S".

Swift

protocol VehicleDescription {
    func description() -> String
}

struct Car {
    let model: String
}

extension Car: VehicleDescription {
    func description() -> String {
        return "Car model: \(model)"
    }
}

// Create a Car instance named myCar with model "Tesla Model S"

Hint

Use let to create a constant instance with the exact model string.

4

Print the car description

Write a print statement to display the result of calling description() on myCar.

Swift

protocol VehicleDescription {
    func description() -> String
}

struct Car {
    let model: String
}

extension Car: VehicleDescription {
    func description() -> String {
        return "Car model: \(model)"
    }
}

let myCar = Car(model: "Tesla Model S")

// Print the description of myCar

Hint

Call description() on myCar inside print().

Practice

1. What is the main purpose of using an extension to conform a type to a protocol in Swift?

easy

A. To add protocol requirements to a type without modifying its original definition

B. To create a new subclass from an existing class

C. To override existing methods in a class

D. To declare a new protocol

Solution

1. Step 1: Understand protocol conformance

   Protocols define a set of methods or properties a type must implement.

2. Step 2: Role of extensions

   Extensions allow adding these implementations to a type without changing its original code.

3. Final Answer:

   To add protocol requirements to a type without modifying its original definition -> Option A

4. Quick Check:

   Extensions add protocol conformance without altering original type [OK]

Hint: Extensions add protocol methods without touching original code [OK]

Common Mistakes:

• Thinking extensions create subclasses
• Confusing extensions with method overriding
• Believing extensions declare new protocols

2. Which of the following is the correct syntax to make a struct Car conform to protocol Drivable using an extension?

easy

A. protocol Drivable extension Car { func drive() { print("Driving") } }

B. struct Car: Drivable { extension { func drive() { print("Driving") } } }

C. extension Drivable: Car { func drive() { print("Driving") } }

D. extension Car: Drivable { func drive() { print("Driving") } }

Solution

1. Step 1: Identify correct extension syntax

   Extensions use the format: extension TypeName: ProtocolName { ... }.

2. Step 2: Check each option

   extension Car: Drivable { func drive() { print("Driving") } } correctly extends Car to conform to Drivable and implements drive().

3. Final Answer:

   extension Car: Drivable { func drive() { print("Driving") } } -> Option D

4. Quick Check:

   Correct extension syntax = extension Car: Drivable { func drive() { print("Driving") } } [OK]

Hint: Use 'extension Type: Protocol { }' to conform [OK]

Common Mistakes:

• Placing extension inside struct
• Swapping type and protocol names
• Using 'protocol' keyword incorrectly

3. Consider the code below:

protocol Greetable {
    func greet() -> String
}

struct Person {
    let name: String
}

extension Person: Greetable {
    func greet() -> String {
        return "Hello, \(name)!"
    }
}

let p = Person(name: "Anna")
print(p.greet())

What is the output when this code runs?

medium

A. Hello, !

B. Hello, name!

C. "Hello, Anna!"

D. Error: Person does not conform to Greetable

Solution

1. Step 1: Check protocol conformance

   Person is extended to conform to Greetable by implementing greet() returning "Hello, \(name)!".

2. Step 2: Analyze output

   Creating Person with name "Anna" and calling greet() returns "Hello, Anna!" which is printed.

3. Final Answer:

   "Hello, Anna!" -> Option C

4. Quick Check:

   Extension adds greet() returning personalized string [OK]

Hint: Extension adds greet() returning personalized message [OK]

Common Mistakes:

• Expecting error due to missing conformance
• Ignoring string interpolation
• Assuming default greet() implementation

4. The following code tries to make Rectangle conform to Shape via extension, but it causes a compile error. What is the error?

protocol Shape {
    var area: Double { get }
}

struct Rectangle {
    var width: Double
    var height: Double
}

extension Rectangle: Shape {
    func area() -> Double {
        return width * height
    }
}

medium

A. Method 'area()' should be a computed property, not a function

B. Cannot extend a struct to conform to a protocol

C. Missing initializer in Rectangle

D. Protocol Shape requires a method named 'area()', not a property

Solution

1. Step 1: Check protocol requirement

   Shape requires a property area of type Double with a getter.

2. Step 2: Analyze extension implementation

   The extension implements area() as a method, but protocol expects a computed property var area: Double { get }.

3. Final Answer:

   Method 'area()' should be a computed property, not a function -> Option A

4. Quick Check:

   Property requirement needs computed property, not method [OK]

Hint: Match protocol property with computed property, not method [OK]

Common Mistakes:

• Implementing property as method
• Thinking structs can't conform via extension
• Ignoring protocol property vs method difference

5. You have a protocol Printable requiring a method printDetails(). You want to add this conformance to an existing class Book without changing its original code. Which approach correctly achieves this and allows printDetails() to print the book's title and author?

class Book {
    let title: String
    let author: String
    init(title: String, author: String) {
        self.title = title
        self.author = author
    }
}

hard

A. class Book: Printable {
func printDetails() {
print(title + author)
}
}

B. extension Book: Printable {
func printDetails() {
print("Title: \(title), Author: \(author)")
}
}

C. protocol Printable {
func printDetails()
}
extension Printable {
func printDetails() {
print("No details")
}
}

D. extension Printable: Book {
func printDetails() {
print(title + author)
}
}

Solution

1. Step 1: Understand requirement

   We want to add Printable conformance to Book without changing Book's original code.

2. Step 2: Use extension to conform

   extension Book: Printable { func printDetails() { print("Title: \(title), Author: \(author)") } } extends Book to conform to Printable and implements printDetails() accessing Book's properties.

3. Final Answer:

   extension Book: Printable { func printDetails() { print("Title: \(title), Author: \(author)") } } -> Option B

4. Quick Check:

   Extension adds protocol conformance and method using existing properties [OK]

Hint: Use extension on class to add protocol methods accessing properties [OK]

Common Mistakes:

• Trying to modify original class code
• Incorrectly extending protocol instead of class
• Not implementing required method