Protocol extensions for shared behavior in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of protocol extension method call

What is the output of this Swift code using protocol extensions?

Swift

protocol Greetable {
    func greet() -> String
}

extension Greetable {
    func greet() -> String {
        return "Hello from protocol extension"
    }
}

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

struct Robot: Greetable {}

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

A Compilation error: Robot does not implement greet()

B

Hello from Person
Hello from protocol extension

C

Hello from protocol extension
Hello from protocol extension

D

Hello from Person
Hello from Person

💡 Hint

Remember that structs can override protocol extension methods by implementing them directly.

Person implements greet(), so its method is called. Robot does not implement greet(), so it uses the protocol extension's default implementation.

🧠 Conceptual

intermediate

Protocol extension default implementation usage

Which statement about protocol extensions providing default implementations is true?

A Default implementations are ignored if the protocol is used as a type.

B Default implementations override any implementation in the conforming type.

C Protocol extensions cannot provide default implementations for protocol methods.

D Default implementations in protocol extensions are used only if the conforming type does not provide its own implementation.

💡 Hint

Think about how Swift chooses which method to call when both protocol extension and conforming type have the same method.

If a conforming type implements a method, that implementation is used. Otherwise, the protocol extension's default is used.

🔧 Debug

advanced

Why does this protocol extension method not get called?

Given this code, why does the protocol extension method not get called when using a protocol-typed variable?

Swift

protocol Drawable {
    func draw()
}

extension Drawable {
    func draw() {
        print("Drawing from extension")
    }
}

struct Circle: Drawable {
    func draw() {
        print("Drawing Circle")
    }
}

let shape: Drawable = Circle()
shape.draw()

A The Circle's draw() method is called because the variable is of protocol type and Circle implements draw().

B The protocol extension's draw() method is called because the variable is of protocol type.

C Compilation error because protocol extension methods cannot be called on protocol-typed variables.

D Runtime error because draw() is ambiguous.

💡 Hint

Consider how Swift dispatches protocol methods when called on a variable typed as the protocol.

When a protocol method is called on a variable typed as the protocol, Swift uses dynamic dispatch and calls the conforming type's implementation if it exists.

📝 Syntax

advanced

Which option causes a syntax error in protocol extension?

Which of the following protocol extension code snippets will cause a syntax error?

A

extension Sequence {
    func firstElement() -> Element? {
        return self.first
    }
}

B

extension Collection {
    func isNotEmpty() -> Bool {
        return !self.isEmpty
    }
}

C

extension Array {
    func reversedArray() -> Array {
        return self.reversed()
    }
}

D

extension Dictionary {
    func keysArray() -> [Key] {
        return Array(self.keys)
    }
}

💡 Hint

Check the return type and method used in the extension carefully.

The reversed() method returns a ReversedCollection>, not an Array. Returning it as Array without conversion causes a type mismatch error.

🚀 Application

expert

How many items are in the resulting dictionary?

Consider this Swift code using protocol extensions and conforming types. How many key-value pairs does the dictionary contain after execution?

Swift

protocol Identifiable {
    var id: String { get }
}

extension Identifiable {
    func info() -> String {
        return "ID: \(id)"
    }
}

struct User: Identifiable {
    var id: String
}

struct Admin: Identifiable {
    var id: String
    func info() -> String {
        return "Admin ID: \(id)"
    }
}

let users: [Identifiable] = [User(id: "u1"), Admin(id: "a1"), User(id: "u2")]

var dict = [String: String]()
for user in users {
    dict[user.id] = user.info()
}

print(dict.count)

A 3

B 2

C Compilation error

D 1

💡 Hint

Each user has a unique id used as dictionary key.

The array has three Identifiable items with unique ids. The loop adds all three to the dictionary, so count is 3.