3 Cool new features of Swift 5.9 😍

Now also in Swift…

01. Using if and switch as expressions

Until Swift 5.9, the keywords if and switch could only be used as statements.

This meant that it wasn’t possible to directly assign the result of an if or a switch to a variable or to pass it as an argument.

if and switch can now be used as expressions!

This means that these awful nested ternary expressions can now be replaced by much more readable if conditions:

Even better, this new feature also works with conditional binding:

02. Parameter Packs

If you’ve ever had to write code that needed to handle an unknown number of generic types, you’ve probably learned the hard way that Swift didn’t offer support for variadic generics.

And that the best you could do would be to implement multiple overloads, that would handle up to a certain number of generic arguments:

And even though this approach looks a bit ridiculous, major first party frameworks like SwiftUI and Combine used to rely on this trick!

Unfortunately, it has a major drawback: since you can’t implement an infinite number of overloads, there will always be a limit on the number of arguments your function can handle:

Have you ever wondered why a SwiftUI view couldn’t support more than 10 child views? Now you know the answer!

But if you open Xcode 15 and try to add 11 child to a SwiftUI view, you will notice that this limitation is now gone.

This is thanks to a new feature of Swift 5.9 called Parameter Packs:

Using the keyword each, we are able to declare a Parameter Pack.

And then, through the keyword repeat we are able to use this Parameter Pack, for instance to declare the arguments of a function or to define a tuple type:

Thanks to this new syntax, our function evaluate() is now able to handle any arbitrary number of arguments.

However, be careful: there’s a reason why this feature is called Parameter Packs and not Variadic Generics!

It’s because how you handle a Parameter Pack is still a bit limited: for instance, it’s not yet possible to iterate over each individual argument the function will receive.

#03 — Macros

Back in 2019, Swift had introduced Property Wrappers, which enabled us to nicely encapsulate many boilerplate codes.

This year, the language goes even further with the introduction of Macros, which are nothing less than small compiler plugins capable of generating code on your behalf.

Here’s the typical boilerplate code that a macro can generate for you: defining a convenience computed property for each of the cases in an enum.

In Swift 5.9 you can remove this boilerplate code and instead implement a macro called @CaseDetection:

At compile time, this macro will then be expanded by the Swift compiler in order to produce the generated code:

That’s it: these were the 3 new features of Swift 5.9, I wanted to introduce you to..!!!

I wish you an amazing week! 🙌

Rejection is better than fake promises… 🤔