BuildOptional and buildEither in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift code using buildOptional?

Consider this Swift code snippet using buildOptional in a result builder. What will be printed?

Swift

import Foundation

@resultBuilder
struct TestBuilder {
    static func buildOptional(_ component: String?) -> String {
        return component ?? "No value"
    }

    static func buildBlock(_ component: String) -> String {
        return component
    }
}

func test() -> String {
    @TestBuilder var result: String {
        if Bool.random() {
            "Hello"
        }
    }
    return result
}

print(test())

A Always "Hello"

B Compilation error due to missing else

C Always "No value"

D "Hello" or "No value" depending on random condition

💡 Hint

buildOptional handles optional components in result builders, returning a default if nil.

The buildOptional function receives an optional String. If the if condition is true, it returns "Hello"; otherwise, nil. The buildOptional returns "No value" when nil is passed, so the output depends on the random condition.

❓ Predict Output

intermediate

What does this Swift code print using buildEither?

Given this Swift code using buildEither in a result builder, what will be the output?

Swift

import Foundation

@resultBuilder
struct EitherBuilder {
    static func buildEither(first component: String) -> String {
        return "First: " + component
    }

    static func buildEither(second component: String) -> String {
        return "Second: " + component
    }

    static func buildBlock(_ component: String) -> String {
        return component
    }
}

func test(flag: Bool) -> String {
    @EitherBuilder var result: String {
        if flag {
            "Option A"
        } else {
            "Option B"
        }
    }
    return result
}

print(test(flag: true))
print(test(flag: false))

A "First: Option A\nSecond: Option B"

B "Option A\nOption B"

C "First: Option A\nFirst: Option A"

D "First: Option A\nOption B"

E Compilation error due to ambiguous buildEither

💡 Hint

buildEither distinguishes between first and second branches in conditional statements inside result builders.

When flag is true, buildEither(first:) is called with "Option A", returning "First: Option A". When flag is false, buildEither(second:) is called with "Option A", returning "Second: Option A". So the output is "First: Option A\nSecond: Option A".

🔧 Debug

advanced

Why does this Swift code using buildEither cause a compilation error?

Examine this Swift code snippet using buildEither. Why does it fail to compile?

Swift

import Foundation

@resultBuilder
struct MyBuilder {
    static func buildEither(first component: Int) -> Int {
        return component
    }

    static func buildEither(second component: String) -> String {
        return component
    }

    static func buildBlock(_ component: Any) -> Any {
        return component
    }
}

func test(flag: Bool) -> Any {
    @MyBuilder var result: Any {
        if flag {
            42
        } else {
            "Answer"
        }
    }
    return result
}

A Using Any as return type is not allowed in result builders

B buildBlock must return the same type as buildEither

C buildEither methods have different return types causing ambiguity

D Missing buildOptional method causes error

💡 Hint

Result builder functions must have consistent return types to compile.

The buildEither methods return different types (Int and String), which causes the compiler to fail because it cannot unify the return type. Result builders require consistent types for buildEither methods.

🧠 Conceptual

advanced

How does buildOptional affect the output in a Swift result builder?

In Swift result builders, what role does buildOptional play when an optional component is present?

A It unwraps the optional and provides a default value if nil

B It forces the optional to be non-nil or causes a runtime error

C It ignores the optional component completely if nil

D It converts the optional to a string representation regardless of value

💡 Hint

Think about how optional values are handled inside result builders.

buildOptional is called when an optional component is present. It unwraps the optional and can provide a default or alternative value if the optional is nil, allowing the builder to continue gracefully.

❓ Predict Output

expert

What is the output of this complex Swift result builder using buildEither and buildOptional?

Analyze this Swift code using both buildEither and buildOptional in a result builder. What will it print?

Swift

import Foundation

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

    static func buildEither(first component: String) -> String {
        "First(\(component))"
    }

    static func buildEither(second component: String) -> String {
        "Second(\(component))"
    }

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

func complexTest(flag1: Bool, flag2: Bool) -> String {
    @ComplexBuilder var result: String {
        if flag1 {
            "A"
        } else {
            "B"
        }
        if flag2 {
            "C"
        }
    }
    return result
}

print(complexTest(flag1: true, flag2: true))
print(complexTest(flag1: false, flag2: false))

A "A, C" and "B"

B "First(A), C" and "Second(B), None"

C "First(A), C" and "Second(B), C"

D "First(A), C" and "Second(B)"

💡 Hint

buildEither wraps the if-else branches, buildOptional handles the optional second if.

For flag1 true, buildEither(first:) wraps "A" as "First(A)"; flag2 true includes "C". For flag1 false, buildEither(second:) wraps "B" as "Second(B)"; flag2 false means the second if is nil, so buildOptional returns "None". The joined result reflects these.