Custom result builder declaration in Swift

Introduction

Custom result builders help you create a special way to build complex values step-by-step using simple code blocks.

When you want to write clean code that builds complex data like HTML or UI layouts.

When you want to let others write simple code that creates complicated results behind the scenes.

When you want to combine multiple pieces of data or views in a clear and readable way.

When you want to create your own mini-language inside Swift for building things.

When you want to avoid writing repetitive code for assembling parts into a whole.

Syntax

Swift

@resultBuilder
struct BuilderName {
    static func buildBlock(_ components: ComponentType...) -> ResultType {
        // Combine components into one result
    }

    // Optional: other static build methods like buildIf, buildEither, buildArray
}

The @resultBuilder attribute marks a type as a result builder.

Inside, you define static methods to tell Swift how to combine parts.

Examples

This builder joins multiple strings with commas.

Swift

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

This builder adds up all integer parts.

Swift

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

Sample Program

This program defines a custom result builder called StringBuilder that joins strings with spaces. It also supports optional parts with buildIf. The makeSentence function uses this builder to create a sentence from code blocks.

Swift

import Foundation

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

    static func buildIf(_ component: String?) -> String {
        component ?? ""
    }
}

func makeSentence(@StringBuilder content: () -> String) -> String {
    content()
}

let sentence = makeSentence {
    "Hello"
    if true {
        "world!"
    }
}

print(sentence)

Important Notes

Result builders let you write code that looks like normal blocks but creates complex results.

You can add methods like buildIf, buildEither, and buildArray to handle conditions and loops.

Use @resultBuilder before your builder struct to tell Swift it is a builder.

Summary

Custom result builders let you create special ways to combine code parts into one result.

They make your code cleaner and easier to read when building complex data.

Define static methods inside a @resultBuilder struct to control how parts combine.

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