let alertController = UIAlertController(
    title: "Deleção",
    message: "Você tem certeza?",
    preferredStyle: .alert
)
let deleteAction = UIAlertAction(title: "Deletar", style: .destructive) { _ in
    // Executar deleção
}
let cancelAction = UIAlertAction(title: "Cancelar", style: .cancel)
alertController.addAction(deleteAction)
alertController.addAction(cancelAction)
present(alertController, animated: true)

let alertController = Alert(title: "Deleção"", message: "Tem certeza?"") {
    Action.destructive("Excluir"") {
        // Executar exclusão
    }
    Action.cancel("Cancelar"")
}
present(alertController, animated: true)

struct Action {
    let title: String
    let style: UIAlertAction.Style
    let action: () -> Void
}

func makeAlertController(title: String,
                         message: String,
                         style: UIAlertController.Style,
                         actions: [Action]) -> UIAlertController {
    let controller = UIAlertController(
        title: title,
        message: message,
        preferredStyle: style
    )
    for action in actions {
        let uiAction = UIAlertAction(title: action.Note: Se pensarmos em views e SwiftUI, isso faz sentido. De múltiplas subviews (os componentes para o @ViewBuilder), o buildBlock criará uma superview que contém todas as subviews.
No nosso caso, o tipo Component é um array de ações, então o método buildBlock pode ser escrito da seguinte forma:
@_functionBuilder
struct ActionBuilder {

    typealias Component = [Action]

    static func buildBlock(_ children: Component...) -> Component {
        return children.flatMap { $0 }
    }
}
Agora que temos nosso ActionBuilder, vamos usá-lo para recuperar um array de ações e passá-lo à função makeAlertController.
func Alert(title: String,
           message: String,@ActionBuilder 
let alertController = 
@_functionBuilder
struct ActionBuilder {

    
extension Action {
    static func default(_ title
let alertController = Alert(title: "Deleção", message: "Tem certeza?") {
    Action.destructive("Excluir") {
        // Realizar exclusão
    }
    Action.
@_functionBuilder
struct ActionBuilder {

    typealias Component = 
@_functionBuilder
struct ActionBuilder {

    typealias Component = [Action]

    static func buildBlock(_ children: Component...) -> Component { return children.flatMap { $0 } }
    static func buildIf(_ component: Component?) -> Component { return component ?? [] }
    static func buildEither(first component: Component) -> Component { return component }
    static func buildEither(second component: Component) -> Component { return component }
}
E isso faz nosso código compilar novamente com condições if / else.
Loops
No momento, não temos nenhuma maneira de iterar sobre um array de strings e criar ações com elas.
Se tentarmos, sempre encontramos o mesmo erro do compilador.
let alertController = Alert(title: "Title", message: "Message") { for string in ["Action1", "Action2"] { Action.default(string) { print(string) } } }

// erro: closure containing control flow statement cannot be used with function builder
Uma maneira de resolver este problema é criar uma função auxiliar que gera uma lista de ações para cada elemento de uma sequência e, em seguida, agrupa todas essas listas de ações em uma única.
func ForIn<S