Generic type declaration in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a generic function with type constraint

What is the output of this Swift code using a generic function constrained to Comparable?

Swift

func findMax<T: Comparable>(_ a: T, _ b: T) -> T {
    return a > b ? a : b
}

let result = findMax(10, 20)
print(result)

A 20

B 10

C Compilation error due to missing type constraint

D Runtime error

💡 Hint

Think about which value is greater between 10 and 20.

The function findMax compares two values of a generic type T constrained to Comparable. It returns the greater value. Since 20 > 10, the output is 20.

❓ Predict Output

intermediate

Output of generic struct with multiple type parameters

What will be printed by this Swift code using a generic struct with two type parameters?

Swift

struct Pair<A, B> {
    var first: A
    var second: B
}

let pair = Pair(first: "Hello", second: 42)
print(pair.first, pair.second)

A Hello 42

B 42 Hello

C Runtime error

D Compilation error due to missing type constraints

💡 Hint

Look at the order of the properties in the struct.

The struct Pair holds two values of generic types A and B. The instance pair has first as "Hello" and second as 42, so printing them outputs "Hello 42".

🔧 Debug

advanced

Identify the error in generic class declaration

What error does this Swift code produce?

Swift

class Box<T> {
    var value: T
    init(value: T) {
        self.value = value
    }
}

let box = Box<Int>()

A No error, code runs fine

B Error: Generic type 'Box' requires 2 type parameters

C Error: Missing argument for parameter 'value' in call

D Error: Cannot infer generic parameter 'T'

💡 Hint

Check the initializer call and its parameters.

The class Box requires an argument value in its initializer. The code Box() calls the initializer without arguments, causing a missing argument error.

📝 Syntax

advanced

Which generic declaration is syntactically correct?

Which of the following Swift generic type declarations is syntactically correct?

A struct Container<T where T: Equatable> { var item: T }

B struct Container<T> where T Equatable { var item: T }

C struct Container<T Equatable> { var item: T }

D struct Container<T: Equatable> { var item: T }

💡 Hint

Remember the syntax for type constraints in generic declarations.

Option D correctly uses the syntax <T: Equatable> to constrain the generic type T. Options A, B, and D have syntax errors in the constraint declaration.

🚀 Application

expert

Result of using generic function with protocol and associated type

Given the following Swift code, what is the output?

Swift

protocol Container {
    associatedtype Item
    func add(_ item: Item)
    func count() -> Int
}

class Box<T>: Container {
    private var items = [T]()
    func add(_ item: T) {
        items.append(item)
    }
    func count() -> Int {
        items.count
    }
}

let box = Box<String>()
box.add("Swift")
box.add("Generics")
print(box.count())

A 0

B 2

C Runtime error

D Compilation error due to missing initializer

💡 Hint

Consider how many items are added before counting.

The class Box conforms to Container protocol with Item as T. Two strings are added, so count() returns 2.