Struct Destructuring in Julia
Two days ago LWN published my article about the new features arriving with version 1.7 of Julia. One new syntax feature that I only had space to treat briefly is a new form of destructuring. Here I want to explain in more detail why this can be useful.
In Julia you can define a struct like this:
struct S a b end
This is usually how we define new datatypes.
If we instantiate the struct with
newS = S(4, 5), we can access the two properties of
newS.b, which yield 4 and 5. This is existing syntax.
The new feature allows us to destructure this way:
(; a, b) = newS
a has the value 4 and
b has the value 5.
The field names on the left must exist in the struct. Otherwise, you get an error:
(; a, x) = newS ERROR: type S has no field x
This might seem at first glance to be of limited utility. In current Julia, you can already do this:
a, b = newS.a, newS.b
So the new syntax is a bit more concise.
However, the real advantage of the new destructuring may be in providing a succinct way to define functions that take keyword arguments.
The standard way to define a function that takes, say, one positional argument and two keyword arguments
b is like this:
f(d; a, b) = (a + b)/d
And you call it with
f(2; a=3, b=4), which yields 3.5.
But in the next version of Julia we can define it this way:
f2(d, (; a, b)) = (a + b)/d
This looks like it takes two positional arguments, but consider what happens if we make the call
When the function interprets its arguments,
d will get the value 2, and
(; a, b) will get the value
newS; but, with the new destructuring, this will assign 3 to
a and 4 to
b, so it’s the same as calling
f(2; a=3, b=4). We can store other values for
b in different instantiations of
S, and pass them in to
f2 as needed.
The new syntax can aid expressiveness, especially if you want to create a function that takes many keyword arguments. In practice, you may want to ensure that the struct you pass in has the right type by defining
f2 this way:
f2(d, (; a, b)::S) = (a + b)/d
As I work on my Julia book I revisit completed chapters to update them with useful new features in the language and various packages as they come out or get close to release. In this way I hope that it will be as up-to-date, when it arrives, as a print book can be.