Generic function declaration in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a generic swap function

What is the output of this Swift code that uses a generic function to swap two values?

Swift

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

var x = 5
var y = 10
swapValues(&x, &y)
print("x = \(x), y = \(y)")

A Compilation error due to generic function

B x = 5, y = 10

C x = 0, y = 0

D x = 10, y = 5

💡 Hint

Think about what the swap function does to the values passed by reference.

The generic function swaps the values of x and y by using inout parameters. After calling swapValues, x becomes 10 and y becomes 5.

❓ Predict Output

intermediate

Output of generic function with different types

What is the output of this Swift code using a generic function that prints the type and value?

Swift

func printValue<T>(_ value: T) {
    print("Value: \(value), Type: \(type(of: value))")
}

printValue(42)
printValue("Hello")

A Value: 42, Type: String\nValue: Hello, Type: Int

B Value: 42, Type: Int\nValue: Hello, Type: String

C Value: 42, Type: Optional<Int>\nValue: Hello, Type: Optional<String>

D Compilation error due to type mismatch

💡 Hint

The generic function accepts any type and prints its value and type.

The generic function printValue prints the value and its actual type. 42 is Int and "Hello" is String.

❓ Predict Output

advanced

Output of generic function with constraints

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
}

print(findMax(3, 7))
print(findMax("apple", "banana"))

A Compilation error due to missing Comparable conformance

B 3\napple

C 7\nbanana

D Runtime error due to type mismatch

💡 Hint

The function returns the greater of two Comparable values.

The function findMax returns the larger value between a and b. 7 is greater than 3, and "banana" is lexicographically greater than "apple".

🔧 Debug

advanced

Identify the error in this generic function declaration

What error does this Swift code produce when compiling?

Swift

func printFirstElement<T>(array: [T]) -> T {
    return array[0]
}

print(printFirstElement(array: []))

A Runtime error: Index out of range

B Compilation error: Missing return statement

C Compilation error: Generic type T not specified

D No error, prints nil

💡 Hint

Consider what happens when accessing the first element of an empty array.

The function tries to return the first element of an empty array, causing a runtime crash due to index out of range.

🧠 Conceptual

expert

Understanding generic function type inference

Given the generic function below, what is the inferred type of T when calling foo(5) and foo("test") respectively?

Swift

func foo<T>(_ value: T) -> String {
    return "Value is \(value)"
}

// Calls:
// foo(5)
// foo("test")

A T is Int for foo(5) and String for foo("test")

B T is always Any for all inputs

C T is always String regardless of input

D Compilation error due to ambiguous type inference

💡 Hint

Generic functions infer T based on the argument type at each call.

The compiler infers T as Int when foo(5) is called and as String when foo("test") is called, allowing the function to work with different types.

Practice

1. What is the purpose of declaring a generic function in Swift using <T>?

easy

A. To allow the function to work with any data type without rewriting code

B. To restrict the function to only work with integers

C. To make the function run faster by using a specific type

D. To create a function that only works with strings

Solution

1. Step 1: Understand generic function purpose

   Generic functions use placeholders like <T> to accept any data type.

2. Step 2: Analyze options

   Only To allow the function to work with any data type without rewriting code correctly states that generics allow code reuse for many types without rewriting.

3. Final Answer:

   To allow the function to work with any data type without rewriting code -> Option A

4. Quick Check:

   Generic functions = flexible type use [OK]

Hint: Generics mean one function fits many types [OK]

Common Mistakes:

• Thinking generics limit types instead of generalizing
• Confusing generics with type-specific functions
• Assuming generics improve speed directly

2. Which of the following is the correct syntax to declare a generic function named swapValues in Swift?

easy

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

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

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

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

Solution

1. Step 1: Identify correct generic syntax

   Generic functions declare type placeholders inside angle brackets after the function name, like <T>.

2. Step 2: Check parameter types

   func swapValues<T>(a: T, b: T) { } correctly uses <T> and parameters of type T. func swapValues(a: T, b: T) { } misses <T>. func swapValues<T>(a: Int, b: Int) { } uses Int which is not generic. func swapValues(a: T, b: U) { } uses two generic types but swap usually uses one.

3. Final Answer:

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

4. Quick Check:

   Generic syntax = func name<T>(...) [OK]

Hint: Generic type <T> goes right after function name [OK]

Common Mistakes:

• Forgetting <T> after function name
• Using concrete types instead of generic placeholders
• Mixing multiple generic types unnecessarily

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

func printValue<T>(value: T) {
    print("Value is \(value)")
}
printValue(value: 42)
printValue(value: "Hello")

medium

A. Compilation error due to type mismatch

B. Value is 42\nValue is Hello

C. Value is Hello\nValue is Hello

D. Value is 42\nValue is 42

Solution

1. Step 1: Understand generic function behavior

   The function printValue accepts any type T and prints it.

2. Step 2: Analyze calls with different types

   First call passes an integer 42, second passes a string "Hello". Both print correctly.

3. Final Answer:

   Value is 42 Value is Hello -> Option B

4. Quick Check:

   Generic function prints any type value [OK]

Hint: Generic functions accept any type without error [OK]

Common Mistakes:

• Assuming generic functions only accept one type per program
• Expecting type mismatch error for different calls
• Confusing output order

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

func compareValues<T>(a: T, b: T) -> Bool {
    return a > b
}

medium

A. Remove generic and use Int type instead

B. No error, function is correct

C. Change return type to Int

D. Add constraint: to allow '>' operator

Solution

1. Step 1: Understand operator usage in generics

   The '>' operator requires the type to conform to Comparable protocol.

2. Step 2: Add constraint to generic type

   Adding <T: Comparable> ensures T supports '>' operator.

3. Final Answer:

   Add constraint: <T: Comparable> to allow '>' operator -> Option D

4. Quick Check:

   Generic constraints needed for operators [OK]

Hint: Use when comparing generics [OK]

Common Mistakes:

• Ignoring protocol constraints for operators
• Changing return type unnecessarily
• Removing generics instead of fixing constraints

5. You want to write a generic function findFirstIndex that returns the first index of a value in an array. Which declaration correctly uses generics and constraints to achieve this?

hard

A. func findFirstIndex(array: [T], value: T) -> Int? {
for (index, element) in array.enumerated() {
if element == value {
return index
}
}
return nil
}

B. func findFirstIndex<T>(array: [T], value: T) -> Int? {
for (index, element) in array.enumerated() {
if element == value {
return index
}
}
return nil
}

C. func findFirstIndex(array: [Int], value: Int) -> Int? {
for (index, element) in array.enumerated() {
if element == value {
return index
}
}
return nil
}

D. func findFirstIndex(array: [T], value: T) -> Int? {
for (index, element) in array.enumerated() {
if element == value {
return index
}
}
return nil
}

Solution

1. Step 1: Understand equality requirement

   To compare elements with '==', type T must conform to Equatable.

2. Step 2: Check generic constraints and function logic

   func findFirstIndex(array: [T], value: T) -> Int? { for (index, element) in array.enumerated() { if element == value { return index } } return nil } correctly declares T: Equatable and uses a loop to find the first matching index.

3. Final Answer:

   func findFirstIndex<T: Equatable>(array: [T], value: T) -> Int? { ... } -> Option A

4. Quick Check:

   Equality check needs Equatable constraint [OK]

Hint: Use when checking equality in generics [OK]

Common Mistakes:

• Omitting Equatable constraint causing compile error
• Using Comparable instead of Equatable unnecessarily
• Restricting to Int instead of generic type