Protocol with associated types in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a protocol with associated type conformance

What is the output of this Swift code using a protocol with an associated type?

Swift

protocol Container {
    associatedtype Item
    mutating func append(_ item: Item)
    func count() -> Int
    subscript(i: Int) -> Item { get }
}

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

var stack = IntStack()
stack.append(10)
stack.append(20)
print(stack.count())
print(stack[1])

A 2\n20

B 1\n10

C 2\n10

D 1\n20

💡 Hint

Think about how many items are appended and what is at index 1.

The IntStack struct conforms to Container with Item as Int. Two items (10 and 20) are appended, so count() returns 2. The item at index 1 is the second appended item, 20.

🧠 Conceptual

intermediate

Understanding associatedtype constraints

Given the protocol below, which statement about the associatedtype is true?

Swift

protocol Identifiable {
    associatedtype ID: Comparable
    var id: ID { get }
}

A The associatedtype ID must be an Int.

B The associatedtype ID must conform to Comparable, so any type used must support comparison.

C The associatedtype ID must be a class type.

D The associatedtype ID can be any type without restrictions.

💡 Hint

Look at the ': Comparable' part in the associatedtype declaration.

The associatedtype ID has a constraint ': Comparable', meaning any type used for ID must conform to Comparable protocol.

🔧 Debug

advanced

Identify the error in protocol with associated type usage

What error will this Swift code produce?

Swift

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

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

A Missing mutating keyword on append method

B No error, code compiles successfully

C Cannot convert value of type 'Int' to expected argument type 'String'

D Type 'StringStack' does not conform to protocol 'Container' because 'append' parameter type does not match associatedtype 'Item'

💡 Hint

Check the parameter type of append compared to the associatedtype Item.

The protocol requires append(_ item: Item) where Item is inferred as String from items array. The struct's append uses Int parameter, causing a mismatch and conformance error.

📝 Syntax

advanced

Correct syntax for protocol with associated type and default implementation

Which option correctly defines a protocol with an associated type and provides a default implementation for a method?

A

protocol Summable {
    associatedtype Number
    func sum(_ a: Number, _ b: Number) -> Number
}
extension Summable {
    func sum(_ a: Number, _ b: Number) -> Number {
        return a - b
    }
}

B

protocol Summable {
    associatedtype Number
    func sum(_ a: Number, _ b: Number) -> Number
}
extension Summable {
    func sum(a: Number, b: Number) -> Number {
        return a + b
    }
}

C

protocol Summable {
    associatedtype Number
    func sum(_ a: Number, _ b: Number) -> Number
}
extension Summable {
    func sum(_ a: Number, _ b: Number) -> Number {
        return a + b
    }
}

D

protocol Summable {
    associatedtype Number
    func sum(_ a: Number, _ b: Number) -> Number
}
extension Summable {
    func sum(_ a: Number, _ b: Number) -> Number {
        return a * b
    }
}

💡 Hint

Check method signature and operator used in default implementation.

Option C correctly matches the method signature and uses the + operator for sum. Options B has wrong parameter labels, C and D use wrong operators for sum.

🚀 Application

expert

Implement a generic function using protocol with associated types

Which option correctly implements a generic function that takes any Container and returns the first item?

Swift

protocol Container {
    associatedtype Item
    func count() -> Int
    subscript(i: Int) -> Item { get }
}

func firstItem<C: Container>(_ container: C) -> C.Item? {
    // Fill in the blank
}

A return container.count() > 0 ? container[0] : nil

B return container.count > 0 ? container[0] : nil

C return container[0]

D return container.first

💡 Hint

Check how to safely access the first element using count and subscript.

Option A safely checks if count() > 0 before accessing container[0]. Option A risks out-of-bounds error. Option A uses count property which does not exist (count() is a method). Option A uses 'first' which is not defined in protocol.