Getting began with end result builders in Swift

The iOS software program engineers who use SwiftUI needs to be aware of this syntax:

VStack(alignment: .main) {
    Picture(lodge.image)
    Textual content(lodge.identify)
    Textual content(lodge.worth)
}

Contained in the block, there are three statements, that are a part of VStack. These statements are solely separated by newlines.

Basically, this code is telling you that you’ve got a vertical stack (VStack) that’s composed of three stacked elements, consisting of a picture (Picture), a textual content (Textual content), and one other textual content (Textual content).

Do you know which you can additionally use this syntax in common Swift code, not simply in SwiftUI?

This syntax is named end result builders, beforehand often called perform builders. Outcome builders have been part of Swift since v5.4, which signifies that you need to use this function in Linux. On this article, we’ll discover how one can write end result builders with the buildBlock perform, in addition to extra superior capabilities, like buildOptional, buildArray, and buildExpression.

We’ll cowl:

The significance of end result builders

To grasp the significance of end result builders, you could think about a state of affairs the place you don’t have the end result builders function.

For instance, as an alternative of utilizing a VStack that accepts elements that will likely be stacked vertically, you possibly can attempt to create a easy perform that accepts string elements that will likely be joined collectively. Say you feed the perform: "Howdy World!", "Howdy LogRocket!", "Howdy Swift!". It gives you this end result: "Howdy World!, Howdy LogRocket!, Howdy Swift!".

How are you going to do that? A easy means could be to create a perform that accepts elements:

func StringStack(_ a: String, _ b: String, _ c: String) -> String {
    a + ", " + b + ", " + c
}

Then, you can invoke this perform:

StringStack("Howdy World!", "Howdy LogRocket!", "Howdy Swift!")

It really works effectively, nevertheless it doesn’t look very clear. Even in the event you break up the arguments by line, it nonetheless appears ugly:

StringStack(
  "Howdy World!,
  "Howdy LogRocket!",
  "Howdy Swift!"
)

The comma ruins every part! But it surely’s not simply the annoying comma that we need to do away with. There’s additionally one other issue.

Say you mix these three strings with a comma however you need to have the choice to alter it to one thing else. You possibly can modify the perform:

func StringStack(_ separator: String, _ a: String, _ b: String, _ c: String) -> String {
    a + separator + " " + b + separator + " " + c
}

However once you execute this, the issue turns into apparent:

StringStack(
  "-",
  "Howdy World!,
  "Howdy LogRocket!",
  "Howdy Swift!"
)

Within the code block above, it’s onerous to tell apart whether or not you need to stack 4 strings collectively otherwise you need to stack three strings collectively, separated by a touch.

When you had been utilizing end result builders, you can do that:

StringStack(separator: "-") {
    "Howdy World!"
    "Howdy LogRocket!"
    "Howdy Swift!"
}

The separation of objectives between the separator and the string elements turns into crystal clear. The separator argument shouldn’t be lumped along with the strings that you just need to be a part of.

Establishing the Playground on XCode

Open XCode. Then create a Swift Playground app. After doing that, navigate to File within the menu and click on on New > Playground…. Give it the identify ResultBuildersPlayground. You’ll be greeted with the default code that imports UIKit and declares the variable greeting. Then, empty the code.

Nevertheless, as a result of the end result builders function on Swift doesn’t rely on iOS or Mac, you don’t have to make use of XCode. You should utilize Swift on Linux and even a web-based Swift compiler, like SwiftFiddle.

Constructing a end result builder with buildBlock

Persevering with from our final instance, say you need to convert the StringStack methodology into the declarative code. Add the next code to the Playground:

@resultBuilder class ConvertFunctionToResultBuilder {
    static func buildBlock(_ a: String, _ b: String, _ c: String) -> String {
        a + ", " + b + ", " + c
    }
}

Simply now, you created a category containing the buildBlock static methodology and annotated it with @resultBuilder. Inside buildBlock, you added the perform to mix the strings. ConvertFunctionToResultBuilder didn’t must be a category — it might be an enum or a struct. However inside the category/enum/struct, there have to be a static methodology known as buildBlock.

Subsequent, you possibly can create the declarative code as you’ll in SwiftUI:

@ConvertFunctionToResultBuilder func MyFirstDeclarativeCode() -> String {
    "Howdy World!"
    "Howdy LogRocket!"
    "Howdy Swift!"
}

Now, that’s extra prefer it. One final step earlier than you possibly can see the lead to its full glory!

Let’s execute the brand new perform:

print(MyFirstDeclarativeCode())

Lastly, you possibly can compile the code and run it. That is the end result:

Howdy World!, Howdy LogRocket!, Howdy Swift!

All is effectively! Besides, in the event you take a look at the implementation of the combining string operation, you possibly can solely settle for three elements. We need to be extra versatile.

You should utilize variadic arguments to attain this. Change the buildBlock methodology to one thing like this:

    static func buildBlock(_ strings: String...) -> String {
        strings.joined(separator: ", ")
    }

Then add one other string to MyFirstDeclarativeCode:

@ConvertFunctionToResultBuilder func MyFirstDeclarativeCode() -> String {
    "Howdy World!"
    "Howdy LogRocket!"
    "Howdy Swift!"
    "Howdy Outcome Builders!"
}

Recompile the code and run it to get this end result:

Howdy World!, Howdy LogRocket!, Howdy Swift!, Howdy Outcome Bulders!

Constructing an elective situation utilizing buildOptional

The contents contained in the block don’t must be easy like a string. They are often an if situation, that means the aspect can present up relying on a variable or a situation.

Suppose you need to create a breakfast for a visitor in your lodge. You possibly can create a end result builder for this function:

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

    static func buildOptional(_ drink: String?) -> String {
        return drink ?? ""
    }
}

Discover that there’s one other static perform known as buildOptional beside the required buildBlock.

You possibly can create one other perform that can show the true breakfast:

@BreakfastBuilder func makeBreakfast(_ drink: Bool) -> String {
    "Egg"
    "Bread"
    if drink {
        "Milk"
    }
}

Right here, you see that there’s a conditional assertion beside the same old strings. This conditional block will likely be executed and the end result will likely be despatched to buildOptional. The results of buildOptional will then be despatched to buildBlock together with different strings.

You possibly can execute it with completely different situations:

print(makeBreakfast(false))
print(makeBreakfast(true))

The breakfast will likely be completely different relying on whether or not you need to embrace a drink or not:

Egg, Bread, 
Egg, Bread, Milk

Utilizing buildEither to construct the if situation

With buildOptional, you could have an if situation with out an alternate department or the else situation. However with buildEither, you possibly can have that.

You should utilize the identical instance however this time with buildEither:

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

    static func buildEither(first drink: String) -> String {
        return drink
    }

    static func buildEither(second drink: String) -> String {
        return drink + " with sugar"
    }
}

So as an alternative of buildOptional, you added buildEither however you wanted two of those capabilities, not only one. Keep in mind you should have an if situation and an else situation in a block in a end result builder perform.

Then you possibly can annotate the perform with this end result builder:

@BreakfastBuilder2 func makeBreakfast2(_ drinkCoffee: Bool) -> String {
    "Egg"
    "Bread"
    if drinkCoffee {
        "Espresso"
    } else {
        "Tea"
    }
}

Espresso will likely be despatched to the primary buildEither, whereas Tea will likely be despatched to the second buildEither. You possibly can execute the perform to verify this:

print(makeBreakfast2(false))
print(makeBreakfast2(true))

That is the end result:

Egg, Bread, Tea with sugar
Egg, Bread, Espresso

Do not forget that the second buildEither appends the argument with with sugar.

Utilizing buildArray to make use of arrays

You utilize strings within the block of a perform that has been annotated with a end result builder. However wouldn’t or not it’s good in the event you might use an array of strings as effectively? For instance, you may need to group meals and drinks collectively.

That is the place buildArray is useful.

First, create a end result builder as follows:

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

    static func buildArray(_ drinks: [String]) -> String {
        "Drinks: " + drinks.joined(separator: ", ")
    }
}

This time, add buildArray, which accepts an array and returns a String, the identical sort because the argument that buildBlock accepts. The returned end result will likely be despatched to buildBlock later.

Now, add the perform that will likely be annotated with this end result builder:

@BreakfastBuilder3 func makeBreakfast3() -> String {
    "Egg"
    "Bread"
    for d in ["Coffee", "Tea"] {
        "(d)"
    }
}

To cross an array argument within the block, you don’t cross a literal array, however you create a for-loop assertion. In every iteration, add a component of an array. On this case, it’s a string. Later, all of those strings will likely be put in an array and despatched to buildArray.

Then you could execute this perform:

print(makeBreakfast3())

The end result exhibits the concatenated string from buildArray:

Egg, Bread, Drinks: Espresso, Tea

Utilizing buildExpression to simply accept completely different components in a block

In all of our earlier examples, we used String-typed components in a block. However what if you wish to use one other sort of aspect together with the string? You possibly can deal with completely different sorts of components by utilizing buildExpression in a block.

As traditional, create a end result builder:

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

    static func buildExpression(_ meals: String) -> String {
        meals
    }

    static func buildExpression(_ tissueAmount: Int) -> String {
        "(tissueAmount) items of tissue"
    }
}

You added two buildExpressions. One is for String, and it simply returns the argument as it’s. However the second buildExpression is extra attention-grabbing as a result of it accepts an integer. Then it interpolates the integer argument inside a string.

Now, it’s time to create a perform that accepts strings and an integer:

@BreakfastBuilder4 func makeBreakfast4() -> String {
    "Egg"
    "Bread"
    5
}

Egg and Bread will likely be despatched to the primary buildExpression. However 5 will likely be despatched to the second buildExpression. Then the outcomes from these two buildExpressions will likely be despatched to buildBlock.

Lastly, execute this perform:

print(makeBreakfast4())

The result’s as anticipated:

Egg, Bread, 5 items of tissue

Conclusion

On this article, we used the end result builders function that may make your code declarative just like the code in SwiftUI. We explored the rationale why we use end result builders, which is to make the code look cleaner. Then, we used @resultBuilder to create a end result builder with the buildBlock static methodology to outline the implementation of a block. Lastly, we realized different block builder strategies like buildOptional, buildEither, buildArray, and buildExpressions to create extra superior blocks.

This text solely scratched the floor of end result builders. There’s a lot extra you are able to do, like learn the way write DSL with end result builders. The code for this text is offered on this GitHub repository.