Protocol conformance via extension in Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to make the struct conform to the protocol by adding the required property.

Swift

protocol Describable {
    var description: String { get }
}

struct Car: Describable {
    var make: String
    var model: String
    var description: String {
        return [1]
    }
}

Drag options to blanks, or click blank then click option'

Adescription

Bprint(make)

Cmake + model

D"\(make) \(model)"

Attempts:

3 left

💡 Hint

Common Mistakes

Returning a print statement instead of a string.

Using the property name 'description' inside itself causing recursion.

The description property must return a String. Using a string interpolation with make and model correctly returns the description.

2fill in blank

medium

Complete the extension to make Int conform to the protocol by implementing the required method.

Swift

protocol Squarable {
    func squared() -> Int
}

extension Int: Squarable {
    func squared() -> Int {
        return [1]
    }
}

Drag options to blanks, or click blank then click option'

Aself * self

Bself + self

Cself / self

Dself - self

Attempts:

3 left

💡 Hint

Common Mistakes

Using addition or subtraction instead of multiplication.

Dividing the number by itself which always returns 1.

To return the square of the integer, multiply self by self.

3fill in blank

hard

Fix the error in the extension to correctly conform to the protocol by implementing the required computed property.

Swift

protocol Identifiable {
    var id: String { get }
}

struct User {
    var name: String
}

extension User: Identifiable {
    var [1]: String {
        return name
    }
}

Drag options to blanks, or click blank then click option'

Aid

Bidentifier

Cname

DuserId

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different property name than the protocol requires.

Not implementing the property at all.

The protocol requires a property named 'id'. The extension must implement 'id' to conform.

4fill in blank

hard

Fill both blanks to complete the extension that makes Array conform to the protocol by implementing the required method.

Swift

protocol Summable {
    func sum() -> Int
}

extension Array: Summable where Element == Int {
    func sum() -> Int {
        return self.[1](0) { $0 [2] $1 }
    }
}

Drag options to blanks, or click blank then click option'

Areduce

B+

C*

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using * or - instead of + for summing.

Using map or filter instead of reduce.

The reduce method with initial 0 and + operator sums all elements in the array.

5fill in blank

hard

Fill all three blanks to complete the extension that makes String conform to the protocol by implementing the required computed property and method.

Swift

protocol TextRepresentable {
    var text: String { get }
    func shout() -> String
}

extension String: TextRepresentable {
    var [1]: String {
        return self
    }
    func [2]() -> String {
        return self.[3]()
    }
}

Drag options to blanks, or click blank then click option'

Atext

Bshout

Cuppercased

Dlowercased

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong property or method names.

Using 'lowercased()' instead of 'uppercased()' for shout.

The property 'text' returns self. The method 'shout' returns the uppercase version using 'uppercased()'.

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