Almost six months after Swift 5.8, version 5.9 of Apple’s open-source programming language was released. The current release introduces macros and has a bidirectional connection to C++. It also brings the first approaches to the ownership concept, which is intended to be an essential part of Swift 6.
Short and concise
Macros add previously defined content to parts of the source code before compilation. Swift’s implementation is based more on Rust’s macro system than on the simple macros in C or C++, where macros are simple placeholders for text modules that are replaced before compilation.
Swift 5.9 has two types of Markos: freestanding and attached. The former are with
# excellent, and Swift calls the macro’s implementation when compiling. The following code uses this
function()–Macro from the standard Swift library:
func myFunction() print ("Das Programm befindet sich in der Funktion \(#function)")
The macro replaces
#function by the function name, with which the above code outputs “The program is in the function myFunction()”.
Attached macros help, among other things, when working with Swift protocols, as the following code snippet from the Swift documentation shows
OptionSet-Protocol automatically filled with a series of constants:
// Makro-Variante @OptionSet<Int> struct SundaeToppings private enum Options: Int case nuts case cherry case fudge // Manuelle Umsetzung ohne Makros struct SundaeToppings: OptionSet let rawValue: Int static let nuts = SundaeToppings(rawValue: 1 << 0) static let cherry = SundaeToppings(rawValue: 1 << 1) static let fudge = SundaeToppings(rawValue: 1 << 2)
Interaction with C++
Another important innovation is bidirectional interoperability with C++, which allows external functions to be used directly from Swift, as shown by an example from the Swift blog that uses the C++ function
// Clang module 'PromptResponder' #pragma once #include <vector> std::vector<std::string> generatePromptResponse(std::string prompt);
from Swift calls:
import PromptResponder let codeLines = generatePromptResponse("Write Swift code that prints hello world") .map(String.init) .filter !$0.isEmpty for line in codeLines print(line)
Swift 5.9 also introduces the first hints of an ownership concept for variables, which is not as strict and basic as in Rust, but should help optimize memory management. Among other things, this eliminates the need to count the individual references of the values. The new operator
consume declares the lifetime of a variable to be over, so that when it is assigned, the old variable loses its validity. According to the instruction
let b = consume a
b the value of
aand subsequent attempts
a access trigger an error. The operator can also be used to create a variable
_ = consume a
Other innovations in Swift 5.9 such as parameter packs for passing a flexible number of parameters and direct variable assignments in if and switch statements can be found in the Swift blog.
There is no information in the blog post about the further roadmap of the upcoming major version, which has already cast its shadow in Swift 5.8.