Where clauses for complex constraints in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of generic function with where clause

What is the output of this Swift code using a generic function with a where clause?

Swift

func describe<T>(value: T) where T: CustomStringConvertible, T: Comparable {
    if value > value {
        print("Impossible")
    } else {
        print("Value is \(value)")
    }
}
describe(value: 5)

A Runtime error

B Impossible

C Value is 5

D Compilation error due to where clause

💡 Hint

Think about the comparison and the where clause constraints.

The function requires T to conform to CustomStringConvertible and Comparable. The comparison value > value is always false, so the else branch runs, printing "Value is 5".

🧠 Conceptual

intermediate

Purpose of where clauses in Swift generics

What is the main purpose of using a where clause in Swift generic declarations?

A To add constraints on generic types for more specific behavior

B To declare variables inside a generic function

C To create a new type alias

D To handle errors in generic functions

💡 Hint

Think about how generics can be limited to certain types.

Where clauses allow you to specify conditions on generic types, such as conforming to protocols or matching types, enabling more precise and safe code.

🔧 Debug

advanced

Identify the error in this generic function with where clause

What error does this Swift code produce?

Swift

func compare<T, U>(a: T, b: U) where T == U, T: Comparable {
    if a < b {
        print("a is less")
    } else {
        print("a is not less")
    }
}
compare(a: 3, b: "3")

A Type mismatch error at call site

B Runtime crash due to invalid cast

C Compilation error: missing protocol conformance

D No error, prints "a is less"

💡 Hint

Check the types passed to the function and the where clause.

The where clause requires T and U to be the same type, but the call passes Int and String, causing a type mismatch error at compile time.

📝 Syntax

advanced

Correct syntax for where clause with multiple constraints

Which option shows the correct syntax for a generic function with multiple where clause constraints?

Swift

func process<T>(item: T) where ... {
    // implementation
}

A T: Equatable, T: Hashable

B T: Equatable & Hashable

C T: Equatable, Hashable

D T: Equatable && Hashable

💡 Hint

Swift uses a specific symbol to combine protocol constraints in where clauses.

The correct syntax uses & to combine multiple protocol constraints in a where clause: where T: Equatable & Hashable.

🚀 Application

expert

Using where clause to restrict protocol extension

Given this protocol and extension, what will be the output of calling example() on an instance of MyStruct?

Swift

protocol ExampleProtocol {
    associatedtype Item
    func example()
}

extension ExampleProtocol where Item: Numeric {
    func example() {
        print("Numeric Item")
    }
}

struct MyStruct: ExampleProtocol {
    typealias Item = Int
}

let instance = MyStruct()
instance.example()

A Compilation error: missing example() implementation

B No output

C Runtime error

D Numeric Item

💡 Hint

Check the protocol extension and the associated type constraint.

The extension provides a default implementation of example() only when Item conforms to Numeric. Since MyStruct's Item is Int (which is Numeric), the extension method is used, printing "Numeric Item".