Protocol conformance via extension in Swift - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is protocol conformance via extension in Swift?

It means adding the ability for a type to follow a protocol by writing the required methods or properties inside an extension, not in the original type definition.

beginner

Why use extensions to conform to protocols in Swift?

Extensions help organize code by separating protocol requirements from the main type code, making it cleaner and easier to read.

intermediate

Can you add stored properties in an extension to conform to a protocol?

No, extensions cannot add stored properties. They can only add computed properties, methods, or make a type conform to a protocol.

beginner

Example: How to make a struct conform to a protocol using an extension?

Define the struct first, then create an extension for it that implements the protocol's required methods or properties.

intermediate

What happens if a type already conforms to a protocol but you add conformance again in an extension?

Swift will give an error because a type can only conform to a protocol once. You can add methods in extensions but not duplicate conformance.

What can you NOT add in a Swift extension to help conform to a protocol?

A Stored properties

B Computed properties

C Methods

D Protocol conformance

Extensions cannot add stored properties, only computed properties, methods, or protocol conformance.

Why might you use an extension to conform to a protocol?

A To delete existing methods

B To add stored properties

C To change the original type's stored properties

D To organize code better

Extensions help organize code by separating protocol conformance from the main type definition.

If a struct conforms to a protocol in an extension, where must the protocol methods be implemented?

A Inside the extension

B Inside the original struct definition

C Outside both the struct and extension

D In a different file only

When conforming via extension, the required protocol methods must be implemented inside that extension.

Can a class conform to multiple protocols using multiple extensions?

A Only if the class is final

B No, only one protocol per class is allowed

C Yes, each extension can add conformance to a different protocol

D Only if the protocols are related

A class can conform to multiple protocols by using separate extensions for each protocol.

What error occurs if you try to declare the same protocol conformance twice for a type?

A Syntax error

B Duplicate conformance error

C Runtime crash

D No error, it is allowed

Swift does not allow duplicate protocol conformance declarations for the same type.

Explain how protocol conformance via extension works in Swift and why it is useful.

Think about how extensions let you add features without changing the original type.

Describe the limitations of extensions when adding protocol conformance in Swift.

Remember what extensions can and cannot do compared to the original type.

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