Why generics provide type safety in Swift - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a generic function that returns the same type it receives.

Swift

func identity<T>([1]: T) -> T {
    return value
}

Drag options to blanks, or click blank then click option'

Aelement

Bitem

Cinput

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Using a parameter name that is not declared, causing a compile error.

The parameter name value matches the return type T and is used inside the function.

2fill in blank

medium

Complete the code to declare a generic struct with a property of generic type.

Swift

struct Box<[1]> {
    var content: T
}

Drag options to blanks, or click blank then click option'

AV

BU

CT

DX

Attempts:

3 left

💡 Hint

Common Mistakes

Using a generic parameter name that does not match the property type.

The generic type parameter T is used to define the type of the property content.

3fill in blank

hard

Fix the error in the generic function declaration by completing the missing generic type parameter.

Swift

func swapValues<[1]>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

Drag options to blanks, or click blank then click option'

AT

BU

CV

DW

Attempts:

3 left

💡 Hint

Common Mistakes

Using a generic parameter that does not match the function parameters.

The generic type parameter T must be declared to match the parameter types.

4fill in blank

hard

Fill both blanks to create a generic function that compares two values of the same type.

Swift

func areEqual<[1]>(_ a: [2], _ b: T) -> Bool {
    return a == b
}

Drag options to blanks, or click blank then click option'

AT

BU

Attempts:

3 left

💡 Hint

Common Mistakes

Using different generic type parameters for parameters that must be the same type.

The generic type parameter T is declared and used as the type of both parameters to ensure they are the same type.

5fill in blank

hard

Fill all three blanks to create a generic function that returns the first element of an array of any type.

Swift

func firstElement<[1]>(of array: [[2]]) -> [3]? {
    return array.first
}

Drag options to blanks, or click blank then click option'

AT

DU

Attempts:

3 left

💡 Hint

Common Mistakes

Using different generic type parameters for the array and return type.

The generic type parameter T is declared and used consistently for the array element type and the return type.

Practice

1. Why do generics in Swift provide type safety?

easy

A. They convert all types to strings automatically.

B. They allow any type without restrictions, so errors are ignored.

C. They only work with integer types.

D. They ensure the types used match the expected types at compile time.

Solution

1. Step 1: Understand generics role in type checking

   Generics let you write code that works with any type but still checks that the types match when used.

2. Step 2: Recognize compile-time safety

   This checking happens during compilation, so errors are caught early before running the program.

3. Final Answer:

   They ensure the types used match the expected types at compile time. -> Option D

4. Quick Check:

   Generics = Compile-time type matching [OK]

Hint: Generics check types before running code to avoid errors [OK]

Common Mistakes:

• Thinking generics allow any type without checks
• Believing generics convert types automatically
• Assuming generics only work with specific types

2. Which of the following is the correct syntax to declare a generic function that swaps two values in Swift?

easy

A. func swapValues<T>(a: inout T, b: inout T) {}

B. func swapValues(a: T, b: T) {}

C. func swapValues<T>(a: T, b: T) -> T {}

D. func swapValues<T>(a: T, b: T) {}

Solution

1. Step 1: Identify generic function syntax

   Generic functions use angle brackets <T> after the function name to declare a type parameter.

2. Step 2: Check parameter usage for swapping

   Swapping requires inout parameters to modify the original variables.

3. Final Answer:

   func swapValues<T>(a: inout T, b: inout T) {} -> Option A

4. Quick Check:

   Generic function with inout parameters = func swapValues<T>(a: inout T, b: inout T) {} [OK]

Hint: Generic functions use <T> and inout for swapping [OK]

Common Mistakes:

• Omitting <T> after function name
• Not using inout for parameters to swap
• Returning a value when not needed

3. What will be the output of this Swift code?

func printItem<T>(item: T) {
    print("Item: \(item)")
}
printItem(item: 42)
printItem(item: "Hello")

medium

A. Item: 42
Item: Hello

B. Item: 42\nItem: 42

C. Item: Hello\nItem: Hello

D. Compilation error due to type mismatch

Solution

1. Step 1: Understand generic function behavior

   The function printItem accepts any type T and prints it using string interpolation.

2. Step 2: Analyze calls with different types

   First call passes an integer 42, second call passes a string "Hello". Both are valid and print accordingly.

3. Final Answer:

   Item: 42 Item: Hello -> Option A

4. Quick Check:

   Generic function prints each item correctly [OK]

Hint: Generic functions adapt to each type passed [OK]

Common Mistakes:

• Expecting type mismatch error
• Assuming output repeats same value
• Confusing string interpolation syntax

4. Identify the error in this generic Swift function and fix it:

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

medium

A. No error, function works for all types.

B. Error: '+' operator not defined for all types T; constrain T to Numeric.

C. Error: Missing return type; should be '-> Int'.

D. Error: Parameters should be optional types.

Solution

1. Step 1: Analyze operator usage with generics

   The '+' operator only works with types that support addition, not all types T.

2. Step 2: Apply type constraint to fix error

   Constrain T to Numeric protocol to ensure '+' is valid for T.

3. Final Answer:

   Error: '+' operator not defined for all types T; constrain T to Numeric. -> Option B

4. Quick Check:

   Operator '+' requires Numeric constraint [OK]

Hint: Add constraints to generic types when using operators [OK]

Common Mistakes:

• Assuming '+' works for any generic type
• Ignoring need for protocol constraints
• Changing return type unnecessarily

5. You want to create a generic function that returns the middle element of an array. Which approach ensures type safety and works for any array type in Swift?

hard

A. func middleElement<T>(array: [T]) -> T? { return array[array.count / 2] }

B. func middleElement<T>(array: [T]) -> T { return array[array.count / 2] }

C. func middleElement<T>(array: [T]) -> T? { guard !array.isEmpty else { return nil }; return array[array.count / 2] }

D. func middleElement(array: [Any]) -> Any { return array[array.count / 2] }

Solution

1. Step 1: Handle empty array safely

   Returning an optional T? allows safely returning nil if the array is empty.

2. Step 2: Use generic type T for any element type

   Using <T> keeps the function flexible and type safe for any array element type.

3. Step 3: Return middle element only if array is not empty

   Guard statement prevents runtime error by checking array is not empty before accessing element.

4. Final Answer:

   func middleElement<T>(array: [T]) -> T? { guard !array.isEmpty else { return nil }; return array[array.count / 2] } -> Option C

5. Quick Check:

   Generic + optional return + safety check = func middleElement<T>(array: [T]) -> T? { guard !array.isEmpty else { return nil }; return array[array.count / 2] } [OK]

Hint: Use optional return and guard for safe generic array access [OK]

Common Mistakes:

• Not handling empty arrays causing runtime errors
• Returning non-optional type risking crashes
• Using [Any] losing type safety