Closures as function parameters in Swift - Step-by-Step Execution

Concept Flow - Closures as function parameters

Define function with closure parameter

↓

Call function, pass closure

↓

Function executes closure

↓

Closure runs, returns result

↓

Function uses closure result

↓

End

This flow shows how a function takes a closure as a parameter, calls it, and uses its result.

Execution Sample

Swift

func greetUser(action: () -> String) {
    let message = action()
    print(message)
}

greetUser { "Hello, Swift!" }

This code defines a function that takes a closure returning a string, calls it, and prints the message.

Execution Table

Step	Action	Evaluation	Result
1	Define function greetUser with closure parameter	No execution yet	Function ready to be called
2	Call greetUser with closure { "Hello, Swift!" }	Closure passed as argument	Function starts execution
3	Inside greetUser, call closure action()	Closure runs	"Hello, Swift!"
4	Assign closure result to message	message = "Hello, Swift!"	message holds "Hello, Swift!"
5	Print message	print("Hello, Swift!")	Output: Hello, Swift!
6	Function greetUser ends	No more code	Execution complete

💡 Function ends after printing the closure's returned string.

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
message	undefined	"Hello, Swift!"	"Hello, Swift!"	"Hello, Swift!"

Key Moments - 3 Insights

Why do we call action() inside the function?

Because action is a closure passed in, calling action() runs the closure and gets its returned value, as shown in step 3 of the execution_table.

What type of value does the closure return?

The closure returns a String, which is assigned to the variable message in step 4 of the execution_table.

Can the closure be written outside the function call?

Yes, but here it is passed inline for simplicity, as shown in step 2 of the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of message after step 4?

A "Hello, Swift!"

B undefined

C Closure itself

D nil

💡 Hint

Check the variable_tracker row for message after step 4.

At which step does the closure actually run?

A Step 4

B Step 2

C Step 3

D Step 5

💡 Hint

Look at the execution_table action and evaluation columns for when action() is called.

If the closure returned "Hi!" instead, what would be printed?

A "Hello, Swift!"

B "Hi!"

C Nothing

D Error

💡 Hint

The printed output depends on the closure's return value shown in step 5.

Concept Snapshot

func functionName(parameter: () -> ReturnType) {
  let result = parameter()
  // use result
}

Call with closure:
functionName { returnValue }

The closure runs inside the function when called as parameter().

Full Transcript

This example shows how a Swift function can take a closure as a parameter. The function greetUser takes a closure named action that returns a String. When greetUser is called, it runs the closure by calling action(), stores the returned string in message, and prints it. The closure is passed inline as { "Hello, Swift!" }. The execution steps show defining the function, calling it with the closure, running the closure, assigning its result, printing, and ending. The variable message starts undefined and holds the closure's returned string after step 3. Key points include understanding that calling action() runs the closure and returns its value, which the function uses. The quiz checks understanding of when the closure runs, what message holds, and how changing the closure affects output.

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