@resultBuilder attribute in Swift - Time & Space Complexity

Time Complexity: @resultBuilder attribute

O(n)

Understanding Time Complexity

We want to understand how the time it takes to build results grows when using the @resultBuilder attribute in Swift.

Specifically, how does the number of steps change as we add more parts to the builder?

Scenario Under Consideration

Analyze the time complexity of this simple result builder usage.

@resultBuilder
struct SimpleBuilder {
  static func buildBlock(_ components: String...) -> String {
    components.joined(separator: ", ")
  }
}

func makeList(@SimpleBuilder content: () -> String) -> String {
  content()
}

let result = makeList {
  "Apple"
  "Banana"
  "Cherry"
}

This code combines multiple strings into one using a result builder.

Identify Repeating Operations

Look for repeated actions that take time.

• Primary operation: Joining all string components into one string.
• How many times: The join operation processes each component once.

How Execution Grows With Input

As you add more strings, the join operation must handle each one.

Input Size (n)	Approx. Operations
10	About 10 string joins
100	About 100 string joins
1000	About 1000 string joins

Pattern observation: The work grows directly with the number of items added.

Final Time Complexity

Time Complexity: O(n)

This means the time to build the result grows in a straight line as you add more parts.

Common Mistake

[X] Wrong: "Using a result builder makes building results instant no matter how many parts there are."

[OK] Correct: Even with a result builder, each part must be processed, so time grows with the number of parts.

Interview Connect

Understanding how result builders work helps you explain how Swift handles complex code blocks efficiently.

Self-Check

What if the builder combined nested builders instead of just strings? How would that affect the time complexity?