Why Custom result builder declaration in Swift? - Purpose & Use Cases

The Big Idea

What if you could write complex code as simply as telling a story?

The Scenario

Imagine you want to create a complex user interface or build a structured data format by writing many nested function calls or manual object creations.

It feels like stacking blocks one by one without any help to organize or simplify the process.

The Problem

Manually writing all the nested calls or object creations is slow and confusing.

You often make mistakes with commas, brackets, or order, and the code becomes hard to read and maintain.

The Solution

Custom result builders let you write code in a clear, natural way that looks like a simple list or block.

The builder automatically transforms your code into the complex structure behind the scenes, saving time and reducing errors.

Before vs After

✗ Before

let view = VStack { Text("Hello") Text("World") }

✓ After

@resultBuilder struct MyBuilder { ... } MyBuilder.build { Text("Hello") Text("World") }

What It Enables

It enables writing clean, readable, and expressive code that feels like natural language but builds complex results automatically.

Real Life Example

SwiftUI uses custom result builders to let you design user interfaces by simply listing views inside braces, making UI code easy and fun to write.

Key Takeaways

Manual nested code is hard and error-prone.

Custom result builders simplify complex code into clear blocks.

They make your code easier to read, write, and maintain.

Practice

1. What is the main purpose of declaring a @resultBuilder in Swift?

easy

A. To handle errors automatically in functions

B. To create a new data type like a class or struct

C. To optimize memory usage during runtime

D. To define how multiple code parts combine into a single result

Solution

1. Step 1: Understand the role of @resultBuilder

   A @resultBuilder is used to customize how multiple code blocks combine into one result, making code cleaner.

2. Step 2: Compare with other options

   Options A, B, and D describe unrelated concepts like error handling, data types, and optimization, which are not the purpose of result builders.

3. Final Answer:

   To define how multiple code parts combine into a single result -> Option D

4. Quick Check:

   Result builder = combine code parts [OK]

Hint: Result builders combine code parts into one result [OK]

Common Mistakes:

• Confusing result builders with classes or structs
• Thinking result builders handle errors
• Assuming result builders optimize memory

2. Which of the following is the correct way to start declaring a custom result builder in Swift?

easy

A. @resultBuilder struct MyBuilder { static func buildBlock() -> String { "" } }

B. @resultBuilder class MyBuilder { func buildBlock() {} }

C. class MyBuilder { func buildBlock() -> Int { 0 } }

D. struct MyBuilder { static func buildBlock() {} }

Solution

1. Step 1: Identify correct syntax for result builder

   A custom result builder must be declared with @resultBuilder attribute on a struct, and have static methods like buildBlock returning a value.

2. Step 2: Check each option

   @resultBuilder struct MyBuilder { static func buildBlock() -> String { "" } } correctly uses @resultBuilder, declares a struct, and has a static buildBlock method returning a String. The other options miss the attribute, use class instead of struct, or have non-static buildBlock.

3. Final Answer:

   @resultBuilder struct MyBuilder { static func buildBlock() -> String { "" } } -> Option A

4. Quick Check:

   Result builder = @resultBuilder + struct + static methods [OK]

Hint: Use @resultBuilder on a struct with static buildBlock method [OK]

Common Mistakes:

• Using class instead of struct for result builder
• Forgetting the @resultBuilder attribute
• Making buildBlock non-static

3. Given this custom result builder and usage, what is the output?

 @resultBuilder
struct IntSumBuilder {
    static func buildBlock(_ numbers: Int...) -> Int {
        numbers.reduce(0, +)
    }
}

func sum(@IntSumBuilder _ content: () -> Int) -> Int {
    content()
}

let result = sum {
    5
    10
    3
}
print(result)

medium

A. 5103

B. 18

C. Error: buildBlock requires array

D. 0

Solution

1. Step 1: Understand buildBlock behavior

   The buildBlock method takes multiple Int values and sums them using reduce(0, +).

2. Step 2: Evaluate the sum call

   The closure passed to sum returns three Int values: 5, 10, and 3. The builder sums them: 5 + 10 + 3 = 18.

3. Final Answer:

   18 -> Option B

4. Quick Check:

   Sum of 5, 10, 3 = 18 [OK]

Hint: buildBlock sums all Int inputs passed in closure [OK]

Common Mistakes:

• Thinking values concatenate as strings
• Expecting buildBlock to receive an array instead of variadic
• Confusing output with zero or error

4. Identify the error in this custom result builder declaration:

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

medium

A. buildBlock must be static

B. buildBlock must return Int

C. struct cannot be used with @resultBuilder

D. buildBlock cannot take variadic parameters

Solution

1. Step 1: Check method requirements in result builder

   Methods like buildBlock inside a @resultBuilder must be declared as static so they can be called without an instance.

2. Step 2: Analyze the given code

   The buildBlock method is missing the static keyword, which causes a compile error.

3. Final Answer:

   buildBlock must be static -> Option A

4. Quick Check:

   buildBlock method = static [OK]

Hint: buildBlock must always be static in result builders [OK]

Common Mistakes:

• Omitting static keyword on buildBlock
• Thinking buildBlock must return Int always
• Believing struct can't be used with @resultBuilder

5. You want to create a custom result builder that builds a dictionary from key-value pairs written inside a closure. Which of the following buildBlock implementations correctly combines multiple (String, Int) tuples into a single dictionary?

hard

A. static func buildBlock(_ pairs: (String, Int)...) -> [String: Int] { pairs.map { [$0.0: $0.1] } }

B. static func buildBlock(_ pairs: [(String, Int)]) -> [String: Int] { pairs.reduce([:]) { $0 + $1 } }

C. static func buildBlock(_ pairs: (String, Int)...) -> [String: Int] { Dictionary(uniqueKeysWithValues: pairs) }

D. static func buildBlock(_ pairs: (String, Int)...) -> [(String, Int)] { pairs }

Solution

1. Step 1: Understand the goal

   The builder should combine multiple key-value pairs into a single dictionary.

2. Step 2: Analyze each option

   static func buildBlock(_ pairs: (String, Int)...) -> [String: Int] { Dictionary(uniqueKeysWithValues: pairs) } uses Dictionary(uniqueKeysWithValues:) which correctly creates a dictionary from tuples. static func buildBlock(_ pairs: [(String, Int)]) -> [String: Int] { pairs.reduce([:]) { $0 + $1 } } tries to reduce with + which is invalid for dictionaries. static func buildBlock(_ pairs: (String, Int)...) -> [String: Int] { pairs.map { [$0.0: $0.1] } } maps to an array of dictionaries, not a single dictionary. static func buildBlock(_ pairs: (String, Int)...) -> [(String, Int)] { pairs } returns an array of tuples, not a dictionary.

3. Final Answer:

   static func buildBlock(_ pairs: (String, Int)...) -> [String: Int] { Dictionary(uniqueKeysWithValues: pairs) } -> Option C

4. Quick Check:

   Use Dictionary(uniqueKeysWithValues:) to combine tuples [OK]

Hint: Use Dictionary(uniqueKeysWithValues:) to build dictionary from tuples [OK]

Common Mistakes:

• Returning array of dictionaries instead of one dictionary
• Using invalid + operator to combine dictionaries
• Returning array of tuples instead of dictionary