Why generics provide type safety in Swift - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of generic function with type safety

What is the output of this Swift code using generics?

Swift

func echo<T>(_ value: T) -> T {
    return value
}

let result = echo("Hello")
print(result)

A nil

B Hello

C Optional("Hello")

D Type error at compile time

💡 Hint

Think about how generics keep the type consistent.

The generic function echo returns the same type it receives. Since it receives a String, it returns a String. So the output is Hello.

🧠 Conceptual

intermediate

Why do generics prevent type errors?

Why do generics in Swift help prevent type errors?

A They enforce that the same type is used consistently, catching mismatches at compile time

B They convert all types to strings automatically

C They allow any type without restrictions, so errors are ignored

D They delay type checking until runtime

💡 Hint

Think about when type errors are caught.

Generics enforce consistent use of the same type throughout the code, so if you try to mix types, the compiler will catch it before running the program.

🔧 Debug

advanced

Identify the type safety error in generic code

What error will this Swift code produce?

Swift

func add<T>(_ a: T, _ b: T) -> T {
    return a + b
}

let result = add(5, 10)

A Runtime error: Cannot add values

B Output: 15

C Compile-time error: Binary operator '+' cannot be applied to two 'T' operands

D No error, output is 510

💡 Hint

Consider what operators are available for generic types.

The generic type T does not guarantee that '+' operator is defined. The compiler cannot apply '+' to generic types without constraints, so it raises a compile-time error.

❓ Predict Output

advanced

Output of generic struct with type safety

What is the output of this Swift code using a generic struct?

Swift

struct Box<T> {
    var value: T
}

let intBox = Box(value: 42)
print(intBox.value)

A 42

B Optional(42)

C Compile-time error: Missing initializer

D nil

💡 Hint

Think about how generics store values.

The generic struct Box stores a value of type T. Here it stores an Int 42, so printing intBox.value outputs 42.

🧠 Conceptual

expert

How do generics improve code safety and reusability?

Choose the best explanation for how generics improve both safety and reusability in Swift code.

A Generics delay type checking until runtime, allowing more flexible but less safe code

B Generics force all types to be converted to a single type, simplifying code but risking runtime errors

C Generics automatically generate multiple copies of code for each type, increasing code size without safety benefits

D Generics allow writing code that works with any type while ensuring type correctness at compile time, reducing bugs and duplication

💡 Hint

Think about compile-time checks and code reuse.

Generics let you write one piece of code that works with many types safely by checking types at compile time. This reduces bugs and avoids writing similar code multiple times.