Why protocol-oriented programming matters in Swift - Challenge Your Understanding

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"
    }
}

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

A "Hello from Person"

B "Hello from protocol extension"

C Compilation error: protocol method not implemented

D Runtime error: method not found

💡 Hint

Remember that when a concrete type implements a protocol method, that implementation is called instead of the protocol extension's default.

The variable p is typed as Greetable, but the instance is Person. Since Person provides its own greet() method, that method is called, not the protocol extension's default.

🧠 Conceptual

intermediate

Why use protocols instead of base classes?

Which of the following is a key advantage of using protocols over base classes in Swift?

A Protocols allow multiple inheritance of behavior, while classes do not.

B Protocols can store properties with default values, classes cannot.

C Protocols automatically generate initializers for conforming types.

D Protocols enforce implementation of stored properties.

💡 Hint

Think about how Swift handles multiple inheritance and code reuse.

Swift classes support single inheritance only, but types can conform to multiple protocols, allowing multiple behavior inheritance.

🔧 Debug

advanced

Why does this protocol extension method not get called?

Given this code, why does the protocol extension method describe() not get called when using a concrete type?

Swift

protocol Describable {
    func describe() -> String
}

extension Describable {
    func describe() -> String {
        return "Default description"
    }
}

struct Item: Describable {
    // No describe() implementation here
}

let item = Item()
print(item.describe())

A Runtime error because <code>describe()</code> is not implemented in <code>Item</code>.

B Compilation error because <code>Item</code> does not implement <code>describe()</code>.

C "Default description" is printed because the extension provides a default implementation.

D "describe()" prints nothing because the method is empty.

💡 Hint

Protocol extensions can provide default implementations that conforming types inherit automatically.

Since Item does not implement describe(), the protocol extension's default is used, so "Default description" is printed.

📝 Syntax

advanced

Identify the syntax error in protocol conformance

Which option contains a syntax error when trying to conform to a protocol with an associated type?

Swift

protocol Container {
    associatedtype Item
    func append(_ item: Item)
}

struct IntStack: Container {
    var items = [Int]()
    func append(_ item: Int) {
        items.append(item)
    }
}

A

struct IntStack: Container {
    var items = [Int]()
    mutating func append(_ item: Int) {
        items = items + [item]
    }
}

B

struct IntStack: Container {
    var items = [Int]()
    mutating func append(_ item: Int) {
        items.append(item)
    }
}

C

struct IntStack: Container {
    var items = [Int]()
    func append(item: Int) {
        items.append(item)
    }
}

D

struct IntStack: Container {
    var items = [Int]()
    func append(_ item: Int) {
        items.append(item)
    }
}

💡 Hint

Consider whether the method modifies the struct's properties and what keyword is needed.

Since append modifies the items array, the method must be marked mutating in a struct. Option D misses this, causing a compiler error.

🚀 Application

expert

How does protocol-oriented programming improve code flexibility?

Which statement best explains how protocol-oriented programming improves flexibility in Swift code?

A It forces all types to inherit from a common base class, simplifying type hierarchies.

B It allows behavior to be shared through protocols and extensions without requiring inheritance, enabling composition.

C It restricts types to implement only one protocol, reducing complexity.

D It eliminates the need for generics by using protocols exclusively.

💡 Hint

Think about how protocols and extensions enable code reuse without inheritance.

Protocol-oriented programming encourages sharing behavior via protocols and extensions, allowing types to compose behavior flexibly without rigid class inheritance.