如何在 Swift 5.2 函数构建器中使用 buildExpression？

Question

我知道这是draft proposal。我尝试实现一个简单的 DSL 来构建字符串，如下所示：

@_functionBuilder
struct StringBuilder {
    static func buildExpression(_ string: String) -> [String] {
        [string]
    }
    static func buildBlock(_ children: [String]...) -> [String] {
        children.flatMap{ $0 }
    }
}

func s(separator: String = "", @StringBuilder _ makeString: () -> [String]) -> String {
    makeString().joined(separator: separator)
}

let z = s(separator: " ") {
   "this"
   "is"
   "cool"
}

但是，编译器抱怨“'String' 不能转换为 '[String]'”。这让我相信buildBlock 是目前实施的提案的唯一部分。 （这是可以理解的，因为在 SwiftUI 中他们正在构建视图的层次结构，所以这就是他们所需要的。）

这是正确的还是我做错了什么？ buildExpression的正确使用方法是什么？

ielyamani 的回答展示了如何构建一个有效的字符串构建器，例如我在上面的示例中使用的。但是，这并不能解决实际问题。我不是想建立一个字符串生成器。我正在尝试找出函数构建器。字符串生成器只是一个示例。例如，如果我们希望有一个接受整数的字符串生成器，理论上我们可以这样做：

@_functionBuilder
struct StringBuilder {
    static func buildExpression(_ int: Int) -> [String] {
        ["\(int)"]
    }

    // The rest of it implemented just as above
}

在这种情况下，当编译器遇到Int 时，它会调用buildExpression 来吐出我们的组件类型，在这种情况下是[String]。但正如 Martin R 在对此问题的评论中所说，buildExpression 目前尚未实施。

Answer 1

我今天也遇到了同样的问题，好像 buildExpression 没有实现。我最终通过使用协议“ComponentProtocol”然后创建“Expression：ComponentProtocol”和“Component：ComponentProtocol”来解决问题。现在对我有用。我希望它会在以后实施。

protocol ComponentProtocol: ExpressibleByIntegerLiteral, ExpressibleByStringLiteral  {
    var value: String { get }
}

struct Expression: ComponentProtocol {
    let _value: String
    var value: String { _value }
    init(_ value: String) { _value = value }
    init(integerLiteral value: Int) { self.init(value) }
    init(stringLiteral  value: String) { self.init(value) }
    init<E: CustomStringConvertible>(_ value: E) {_value = String(describing: value) }
}

struct Component: ComponentProtocol {
    let _values: [String]
    var value: String { _values.joined(separator: ", ") }
    init(integerLiteral value: Int) { self.init(value) }
    init(stringLiteral  value: String) { self.init(value) }
    init<E: CustomStringConvertible>(_ value: E) { _values = [String(describing: value)] }
    init<T: ComponentProtocol>(_ values: T...) { _values = values.map { $0.value } }
    init<T: ComponentProtocol>(_ values: [T]) { _values = values.map { $0.value } }
}

@_functionBuilder struct StringReduceBuilder {
    static func buildBlock<T: ComponentProtocol>(_ components: T ...) -> Component { Component(components) }

    static func buildEither<T: ComponentProtocol>(first: T) -> Component { Component(first.value) }
    static func buildEither<T: ComponentProtocol>(second: T) -> Component { Component(second.value) }
    static func buildOptional<T: ComponentProtocol>(_ component: T?) -> Component? {
        component == nil ? nil : Component(component!.value)
    }
}

func stringsReduce (@StringReduceBuilder block: () -> Component) -> Component {
    return block()
}

let result = stringsReduce {
    Expression(3)
    "one"
    Expression(5)
    Expression("2")
    83
}

let s2 = stringsReduce {
    if .random () { // random value Bool
        Expression(11)
    } else {
        Expression("another one")
    }
}

Answer 2

由于buildBlock(_:) 采用可变数量的字符串数组，因此可以使用：

let z = s(separator: " ") {
    ["this"]
    ["is"]
    ["cool"]
}

但这仍然很笨重。要获取字符串而不是字符串数组，请将此函数添加到 StringBuilder，它接受可变数量的字符串：

static func buildBlock(_ strings: String...) -> [String] {
    Array(strings)
}

现在你可以这样做了：

let z = s(separator: " ") {
    "Hello"
    "my"
    "friend!"
}

print(z)    //Hello my friend!