Capturing values from context in Swift - Time & Space Complexity

Time Complexity: Capturing values from context

O(n)

Understanding Time Complexity

When we capture values from context in Swift, we often use closures that remember variables from outside their own code. Understanding how this affects the time it takes to run is important.

We want to see how the program's work grows as the input or captured data changes.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

func makeIncrementer(amount: Int) -> () -> Int {
    var total = 0
    return {
        total += amount
        return total
    }
}

let incrementByTen = makeIncrementer(amount: 10)
for _ in 1...5 {
    print(incrementByTen())
}
    

This code creates a closure that captures a variable from its surrounding context and updates it each time the closure runs.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The closure increments and returns the captured variable total.
• How many times: The closure runs 5 times in the loop.

How Execution Grows With Input

Each time the closure runs, it does a simple addition and returns a value. The work grows directly with how many times we call the closure.

Input Size (n)	Approx. Operations
10	10 additions and returns
100	100 additions and returns
1000	1000 additions and returns

Pattern observation: The number of operations grows in a straight line with the number of times the closure is called.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows directly with how many times the closure is executed.

Common Mistake

[X] Wrong: "Capturing a variable inside a closure makes the code run slower each time because it copies all data every call."

[OK] Correct: The closure only keeps a reference to the variable, so each call just updates that one value, not copying all data repeatedly.

Interview Connect

Understanding how closures capture and use variables helps you explain how your code manages memory and speed. This skill shows you can think about how code runs, not just what it does.

Self-Check

What if the closure captured a large array and modified it each time? How would the time complexity change?