32 · Result Builder와 DSL

@resultBuilder
enum TextBuilder {
    static func buildBlock(_ parts: String...) -> String { parts.joined(separator: " ") }
    static func buildOptional(_ p: String?) -> String { p ?? "(없음)" }
    static func buildEither(first: String) -> String { "first:" + first }
    static func buildEither(second: String) -> String { "second:" + second }
    static func buildArray(_ parts: [String]) -> String { parts.joined(separator: ",") }
}

func render(@TextBuilder _ body: () -> String) -> String { body() }

let flag = true
print(render {
    "안녕"
    "Swift"
    if flag { "조건참" }          // buildOptional
    if flag { "A" } else { "B" }  // buildEither
    for i in 1...3 { "\(i)" }     // buildArray
})

안녕 Swift 조건참 first:A 1,2,3

$ swiftc -dump-ast rb.swift 2>/dev/null \
    | grep -oE 'build(Block|Optional|Either|Array)' | sort | uniq -c

   3 buildArray
  10 buildBlock
   6 buildEither
   4 buildOptional

@resultBuilder
enum NoLoop {
    static func buildBlock(_ p: String...) -> String { p.joined() }
    // buildArray 를 정의하지 않았다
}
func f(@NoLoop _ body: () -> String) -> String { body() }

_ = f {
    for i in 1...3 { "\(i)" }   // ❌ 이 빌더는 루프를 지원하지 않는다
}

error: closure containing control flow statement cannot be used with
       result builder 'NoLoop'

struct Rule {
    let check: (String) -> String?      // nil 이면 통과, 아니면 에러 메시지
}

@resultBuilder
enum RuleBuilder {
    // 컴포넌트 타입을 [Rule] 하나로 통일한다 — 아래 함정 콜아웃 참고
    static func buildExpression(_ r: Rule) -> [Rule] { [r] }
    static func buildBlock(_ parts: [Rule]...) -> [Rule] { parts.flatMap { $0 } }
    static func buildOptional(_ r: [Rule]?) -> [Rule] { r ?? [] }
    static func buildEither(first: [Rule]) -> [Rule] { first }
    static func buildEither(second: [Rule]) -> [Rule] { second }
    static func buildArray(_ parts: [[Rule]]) -> [Rule] { parts.flatMap { $0 } }
}

func validator(@RuleBuilder _ body: () -> [Rule]) -> (String) -> [String] {
    let rules = body()
    return { input in rules.compactMap { $0.check(input) } }
}

let strict = true
let validate = validator {
    Rule { $0.isEmpty ? "비어 있습니다" : nil }
    Rule { $0.count > 20 ? "너무 깁니다" : nil }
    if strict {
        Rule { $0.contains(" ") ? "공백이 있습니다" : nil }
    }
}
print(validate("hello world"))

["공백이 있습니다"]

// ❌ 빌더까지 만들 이유가 없다
let rules1 = validator { Rule { ... }; Rule { ... } }

// ✅ 두세 개 모으는 일이면 배열이 더 명확하고 학습 비용이 0이다
let rules2: [Rule] = [Rule { ... }, Rule { ... }]

@resultBuilder
enum Report {
    static func buildExpression(_ n: Int) -> [String] { ["int:\(n)"] }
    static func buildExpression(_ s: String) -> [String] { ["str:\(s)"] }
    static func buildBlock(_ parts: [String]...) -> [String] { parts.flatMap { $0 } }
    static func buildFinalResult(_ parts: [String]) -> String { parts.joined(separator: ", ") }
}
func render(@Report _ body: () -> String) -> String { body() }

print(render { 1; "둘"; 3 })

int:1, str:둘, int:3

@resultBuilder
enum Concat {
    static func buildPartialBlock(first: String) -> String { first }
    static func buildPartialBlock(accumulated: String, next: String) -> String {
        accumulated + "|" + next
    }
}
func make(@Concat _ body: () -> String) -> String { body() }

print(make {
    "a"; "b"; "c"; "d"; "e"; "f"; "g"; "h"; "i"; "j"; "k"; "l"   // 12개
})

a|b|c|d|e|f|g|h|i|j|k|l

@resultBuilder
enum Fixed {
    static func buildBlock(_ a: String) -> String { a }
    static func buildBlock(_ a: String, _ b: String) -> String { a + b }
    static func buildBlock(_ a: String, _ b: String, _ c: String) -> String { a + b + c }
}
func f(@Fixed _ body: () -> String) -> String { body() }
print(f { "a"; "b"; "c"; "d" })   // 4개

arity.swift:8:26: error: extra argument in call

struct Pair<A, B> { let a: A; let b: B }

@resultBuilder
enum TupleBuilder {
    static func buildPartialBlock<A>(first: A) -> A { first }
    static func buildPartialBlock<A, B>(accumulated: A, next: B) -> Pair<A, B> {
        Pair(a: accumulated, b: next)
    }
}
func build<T>(@TupleBuilder _ body: () -> T) -> T { body() }

let t = build { 1; "둘"; 3.0 }      // Pair<Pair<Int, String>, Double>
print(type(of: t))

Pair<Pair<Int, String>, Double>

struct Query { let clauses: [String]; var sql: String { "WHERE " + clauses.joined(separator: " AND ") } }

@resultBuilder
enum QueryBuilder {
    static func buildExpression(_ s: String) -> [String] { [s] }        // 입구에서 [String]으로
    static func buildBlock(_ parts: [String]...) -> [String] { parts.flatMap { $0 } }
    static func buildOptional(_ p: [String]?) -> [String] { p ?? [] }
    static func buildFinalResult(_ parts: [String]) -> Query { Query(clauses: parts) }
}
func query(@QueryBuilder _ body: () -> Query) -> Query { body() }

let onlyActive = true
let q = query {
    "age >= 18"
    if onlyActive { "status = 'active'" }
}
print(q.sql)

WHERE age >= 18 AND status = 'active'

@resultBuilder
enum B {
    static func buildBlock(_ p: String...) -> String { p.joined(separator: " ") }
    static func buildOptional(_ p: String?) -> String { p ?? "" }
}
func f(@B _ body: () -> String) -> String { body() }
let flag = true
print(f {
    "시작"
    guard flag else { return }     // ❌
    "끝"
})

no.swift:10:23: error: cannot use explicit 'return' statement in the body of
                result builder 'B'

let flag = true
print(f {
    "시작"
    let mid = flag ? "가운데-참" : "가운데-거짓"   // 값을 만들지 않는 선언 — OK
    mid
    "끝"
})

시작 가운데-참 끝

// ❌ 빌더 안에서 탈출하려는 시도
// let v = f { "시작"; guard ok else { return }; "끝" }

// ✅ 빌더를 부를지 말지를 밖에서 결정한다
func content(ok: Bool) -> String? {
    guard ok else { return nil }        // 여기서는 평범한 함수라 return 자유
    return f {
        "시작"
        "끝"
    }
}
print(content(ok: true) as Any, content(ok: false) as Any)

Optional("시작 끝") nil

let items = ["a", "b", "c"]
let isEmpty = items.isEmpty
let summary = "\(items.count)개"

print(f {
    "목록"
    if isEmpty { "비어 있음" }      // 조건이 단순해서 읽기 쉽다
    summary
})

목록  3개

  그룹 1개 →  0.17초  ✅ 성공
  그룹 2개 →  3.25초  ❌ 실패
  그룹 3개 →  3.44초  ❌ 실패

let x: Double = 1.0 + 1 * 2 - 1 + 1 * 2 - 1
print(x)

th_2.swift:1:5: error: the compiler is unable to type-check this expression in
               reasonable time; try breaking up the expression into distinct
               sub-expressions

(a) let d: Double = 1.0
    let x: Double = d + 1 * 2 - 1 + 1 * 2 - 1 + 1 * 2 - 1 + 1 * 2 - 1
                                              →  0.17초  ✅

(b) let x: Double = 1.0 + 1.0 * 2.0 - 1.0 + 1.0 * 2.0 - 1.0 + …
                                              →  0.16초  ✅

(c) let x: Double = 1.0 + 1 * 2 - 1 + 1 * 2 - 1 + 1 * 2 - 1 + 1 * 2 - 1
                                              →  3.51초  ❌

(d) (c)를 두 줄로 쪼갬                          →  3.23초  ❌

(e) let x: Int = 1 + 1 * 2 - 1 + 1 * 2 - 1 + …  →  0.16초  ✅

$ swiftc -Xfrontend -warn-long-expression-type-checking=100 -c file.swift -o /dev/null

file.swift:1:17: warning: expression took 3290ms to type-check (limit: 100ms)

$ swiftc -Xfrontend -warn-long-function-bodies=200 -c file.swift -o /dev/null

# Xcode: Build Settings → Other Swift Flags (Debug 구성)
-Xfrontend -warn-long-expression-type-checking=200
-Xfrontend -warn-long-function-bodies=300

# SPM
.target(name: "App", swiftSettings: [
    .unsafeFlags(["-Xfrontend", "-warn-long-expression-type-checking=200",
                  "-Xfrontend", "-warn-long-function-bodies=300"])
])

let one: Double = 1.0
let two: Double = 2.0
let x: Double = one + one * two - one + one * two - one + one * two - one
print(x)

4.0

@resultBuilder
enum Layout {
    static func buildBlock(_ p: String...) -> String { p.joined(separator: " / ") }
}
func layout(@Layout _ body: () -> String) -> String { body() }

let base: Double = 8.0
let scale: Double = 1.5

// ✅ 계산을 먼저, 선언은 단순하게
let padding = base * scale
let margin  = base * scale * 2

print(layout {
    "padding=\(padding)"
    "margin=\(margin)"
})

padding=12.0 / margin=24.0