Closures as function parameters in Swift - Mini Project: Build & Apply

Closures as function parameters

📖 Scenario: You are building a simple app that processes a list of numbers. You want to apply different operations to these numbers using small pieces of code called closures. Closures are like little helpers you can pass around to do tasks.

🎯 Goal: Learn how to pass closures as parameters to functions in Swift. You will create a function that takes a list of numbers and a closure to process each number. Then you will use this function with different closures to see different results.

📋 What You'll Learn

Create an array of integers named numbers with the values 1, 2, 3, 4, 5

Create a closure variable named multiplyByTwo that takes an Int and returns an Int by multiplying the input by 2

Create a function named processNumbers that takes an array of Int called nums and a closure parameter named operation of type (Int) -> Int, and returns an array of Int

Inside processNumbers, use a for loop to apply operation to each number in nums and collect the results in a new array

Call processNumbers with numbers and multiplyByTwo, then print the result

💡 Why This Matters

🌍 Real World

Passing closures as parameters is common in apps to customize behavior, like sorting lists, filtering data, or handling user actions.

💼 Career

Understanding closures and how to pass them to functions is essential for Swift developers working on iOS apps, enabling flexible and clean code.

1

Create the numbers array

Create an array called numbers with the exact values 1, 2, 3, 4, 5.

Swift

# Create the array 'numbers' with values 1, 2, 3, 4, 5
# Your code here

Hint

Use square brackets [] to create an array and separate values with commas.

2

Create a closure to multiply by two

Create a closure variable named multiplyByTwo that takes an Int parameter called number and returns the number multiplied by 2.

Swift

let numbers = [1, 2, 3, 4, 5]
# Create the closure 'multiplyByTwo' that multiplies input by 2
# Your code here

Hint

Use the syntax { parameter in expression } to create a closure.

3

Create the function that takes a closure

Create a function named processNumbers that takes two parameters: an array of Int called nums and a closure called operation of type (Int) -> Int. The function should return an array of Int. Inside the function, use a for loop with variable num to apply operation to each number in nums and collect the results in a new array called results. Return results at the end.

Swift

let numbers = [1, 2, 3, 4, 5]

let multiplyByTwo: (Int) -> Int = { number in
    return number * 2
}

# Create the function 'processNumbers' with parameters 'nums' and 'operation'
# Use a for loop with variable 'num' to apply 'operation'
# Collect results in 'results' array and return it
# Your code here

Hint

Remember to create an empty array before the loop and append results inside the loop.

4

Call the function and print the result

Call the function processNumbers with the array numbers and the closure multiplyByTwo. Store the result in a variable called processedNumbers. Then print processedNumbers.

Swift

let numbers = [1, 2, 3, 4, 5]

let multiplyByTwo: (Int) -> Int = { number in
    return number * 2
}

func processNumbers(nums: [Int], operation: (Int) -> Int) -> [Int] {
    var results: [Int] = []
    for num in nums {
        results.append(operation(num))
    }
    return results
}

# Call 'processNumbers' with 'numbers' and 'multiplyByTwo'
# Store in 'processedNumbers' and print it
# Your code here

Hint

Use let processedNumbers = processNumbers(nums: numbers, operation: multiplyByTwo) and then print(processedNumbers).

Practice

1.

What is the main purpose of passing a closure as a function parameter in Swift?

easy

A. To allow the function to execute custom code provided by the caller

B. To make the function run faster

C. To prevent the function from returning a value

D. To declare a global variable inside the function

Solution

1. Step 1: Understand what a closure is

   A closure is a block of code that can be passed around and executed later.

2. Step 2: Understand why closures are passed to functions

   Passing a closure lets the function run custom code without changing its own code.

3. Final Answer:

   To allow the function to execute custom code provided by the caller -> Option A

4. Quick Check:

   Closures customize function behavior = A [OK]

Hint: Closures let functions run your code inside them [OK]

Common Mistakes:

• Thinking closures speed up the function
• Confusing closures with variables
• Believing closures stop function returns

2.

Which of the following is the correct syntax to declare a function that takes a closure parameter with no input and no return value?

func performAction(____) { }

easy

A. action: () => Void

B. action: Void -> ()

C. action: () -> () -> Void

D. action: () -> Void

Solution

1. Step 1: Recall closure syntax in Swift

   A closure with no input and no return is written as () -> Void.

2. Step 2: Match syntax to function parameter

   The parameter should be named and typed as action: () -> Void.

3. Final Answer:

   action: () -> Void -> Option D

4. Quick Check:

   Closure type syntax = D [OK]

Hint: Closure type: inputs in (), arrow, then return type [OK]

Common Mistakes:

• Using 'Void -> ()' which is invalid
• Adding extra arrows like '() -> () -> Void'
• Using '=>' which is not Swift syntax

3.

What will be printed when the following Swift code runs?

func greet(action: () -> String) {
    print("Greeting: " + action())
}

greet { "Hello, Swift!" }

medium

A. Hello, Swift!

B. Greeting: action

C. Greeting: Hello, Swift!

D. Error: Missing return type

Solution

1. Step 1: Understand the function call

   The function greet takes a closure that returns a String and prints "Greeting: " plus the closure's result.

2. Step 2: Evaluate the closure passed

   The closure returns "Hello, Swift!", so the print statement outputs "Greeting: Hello, Swift!".

3. Final Answer:

   Greeting: Hello, Swift! -> Option C

4. Quick Check:

   Closure returns string printed with prefix = A [OK]

Hint: Closure returns string, function prints with prefix [OK]

Common Mistakes:

• Expecting just the closure string without prefix
• Confusing closure name with output
• Thinking code causes error

4.

Identify the error in this Swift function that takes a closure parameter:

func repeatTask(times: Int, task: () -> Void) {
    for _ in 1...times {
        task
    }
}

medium

A. The closure 'task' is not called with parentheses

B. The loop range should start from 0

C. The closure parameter must return a value

D. The function must return a value

Solution

1. Step 1: Check how the closure is used inside the loop

   The code uses 'task' without parentheses, so the closure is not executed.

2. Step 2: Correct closure call syntax

   To run the closure, it must be called as 'task()' with parentheses.

3. Final Answer:

   The closure 'task' is not called with parentheses -> Option A

4. Quick Check:

   Call closure with () to execute = C [OK]

Hint: Call closures with () to run them [OK]

Common Mistakes:

• Forgetting parentheses to call closure
• Changing loop range unnecessarily
• Expecting closure to return value when void

5.

Given this function that filters numbers using a closure, how would you call it to get only even numbers?

func filterNumbers(_ numbers: [Int], using condition: (Int) -> Bool) -> [Int] {
    var result = [Int]()
    for number in numbers {
        if condition(number) {
            result.append(number)
        }
    }
    return result
}

Choose the correct call:

hard

A. filterNumbers([1,2,3,4]) { number in number * 2 }

B. filterNumbers([1,2,3,4]) { $0 % 2 == 0 }

C. filterNumbers([1,2,3,4]) { _ in true }

D. filterNumbers([1,2,3,4]) { $0 > 5 }

Solution

1. Step 1: Understand the closure parameter

   The closure takes an Int and returns Bool to decide if number is included.

2. Step 2: Identify condition for even numbers

   Even numbers satisfy number % 2 == 0, so closure should return true for those.

3. Step 3: Match correct call

   filterNumbers([1,2,3,4]) { $0 % 2 == 0 } uses shorthand $0 % 2 == 0, which returns true for even numbers.

4. Final Answer:

   filterNumbers([1,2,3,4]) { $0 % 2 == 0 } -> Option B

5. Quick Check:

   Closure returns true for even numbers = B [OK]

Hint: Use $0 % 2 == 0 to filter even numbers [OK]

Common Mistakes:

• Returning number * 2 instead of Bool
• Returning always true to get all numbers
• Filtering numbers greater than 5 instead of even