NamedTuple unpacking (and also struct unpacking)

[mauro3]

During JuliaCon discussion with @ahojukka5, I figured it would be cool to have NamedTuple unpacking in function arguments which honors the names of the named tuple. Currently we have:

julia> nt = (a=1, b=2)

julia> f((b,)) = b                                                                                                                                        
f (generic function with 1 method)                                                                                                                          

julia> f(nt)                                                                                                                                                 
1                                                                                                                                                            

instead, I'd think this would be more intuitive:

julia> f(nt)                                                                                                                                                 
2

Similarly it could work for structs:

julia> struct A; a; b end                                                                                                                                    
                                                                                                                                                             
julia> aa = A(1,2)                                                                                                                                            
A(1, 2)                                                                                                                                                      
                                                                                                                                                             
julia> f(aa)                                                                                                                                                  
2

(Unfortunately, this needs a 2.0 label)

Edit: fixed unneeded/confusing default-value method-defs.

[JeffBezanson]

(b,) already means positional unpacking, so the syntax would have to be (; b,) or (b=b,).

[mauro3]

That would then look:

 f((;a, )) = 2a
# or
f(x, y, (;a, b)) = x+y+a+b

Could be good. The only potential problem could be that it would be easy to miss the ; and then silently do positional unpacking.

The (b=b,) syntax seems a bit verbose.

As a bonus, this would be non-breaking.

Edit: fixed unneeded/confusing default-value method-defs.

[StefanKarpinski]

The (b=b,) syntax seems a bit verbose.

No more verbose than the calling syntax and it would allow restructuring the named value to a variable with a different name. It's currently pretty common to see stuff like this:

something = ...
f(a, b, c; something=something)

If we had a shorthand for the case where the local name matches the keyword name then it would also make sense to use that same syntax for destructuring when the names match. Spitballing, it could be:

f(a, b, c, =something)
f(a, b, c, something=)

I think I prefer the former.

[JeffBezanson]

It has been proposed before (I believe by @davidanthoff ) to make (; x) shorthand for (; x = x). In fact there is commented-out code for it in julia-syntax.scm. Also (; a.x) can be shorthand for (; x = a.x). These are currently syntax errors.

[JeffreySarnoff]

I use myfuction(x; keyword::T) .. myfunction_doingless(y, keyword=keyword) .. end with frequency.

when we are free to use some unicode as shorthand

x⥍ ≝ x = x

[JeffreySarnoff]

(with frequency .. about 80GHz today)

[mauro3]

Also (; a.x) can be shorthand for (; x = a.x).

How would it be known what a is when the function is called?

IMO, this feature is orthogonal to kwargs. It makes sense to name-unpack the fields of a positional argument (using the syntax of #28579 (comment)):

f(x, y, (;a, b); kw1=1, kw2=y) = ...

f(1,2, (a=3, b=8, u=9))

and also name-unpack a kwarg:

g(x, y; kw1=1, (;a, b)=p, kw2=y) = ...

g(1,2, p=(a=7, b=9, u=8))

Thus a syntax working for both should be found. I think above seems reasonable.

[tpapp]

Somewhat related: I am experimenting with a package called EponymTuples.jl, which allows replacing

f((a, b)::NamedTuple{(:a, :b), <: Tuple{Any, Int}}) = ...

(a = a, b = b, c = 3)

with

f(@eponymargs(a, b::Int)) = ...

@eponymtuple(a, b, c = 3)

I find it helpful for cases when I don't want to introduce and name a struct for passing around a large number of parameters.

[marius311]

I happily noticed recently in the News.md for 1.5 that #34331 was merged, which I find super useful.

At this point the language seems perfectly set up to implement the Issue here, with the syntax being that a named tuple on the LHS means unpacking into those names. It gives a great symmetry between packing/unpacking named/unnamed arguments:

# pack named or unnamed arguments
foo(x,y)
foo(;x,y)

# unpack named or unnamed arguments
(x,y) = bar()
(;x,y) = bar()

If getproperty is used to do the unpacking, then it works for structs and NamedTuples and is type stable, and you can always do (;x,y) = (;dict_like...) for other stuff. Or a separate interface can be defined like @mauro3's @unpack.

A nice testament to the consistency of all of this is that you would have that both of these are valid and a no-op as you'd expect:

# valid but no-op
(x,y) = (x,y)
(;x,y) = (;x,y)

Would be great if something like this could be considered.

[CameronBieganek]

Agreed. I'm particularly interested in the destructuring of structs and named tuples in function arguments. If we had that feature, then we would have ~70% of the pattern matching capabilities of ML languages. The only parts we would be missing are

• pattern matching on values rather than types
• destructuring a collection into the head and tail of the collection (useful for recursion)

[JeffreySarnoff]

Someone show me exactly what should happen given what?

[CameronBieganek]

Someone show me exactly what should happen given what?

Good question. The original post seems to focus on unpacking in function arguments, which is the part I'm most interested in. So, the syntax might look like the following:

Named tuple unpacking in positional function arguments

# define
foo(q, (; x, z)) = q + x + z

# call
foo(1, (x=2, y=3, z=4))  # returns 7

Struct unpacking in positional function arguments

I think struct unpacking in function arguments requires a separate syntax. Perhaps something like this:

struct A
    x
    y
    z
end

# define
bar(q, A x z) = q + x + z

# call
a = A(2, 3, 4)
bar(1, a)  # returns 7

[quinnj]

@JeffreySarnoff, the idea is like this:

struct T
    x::Int
    y::Float64
end

t = T(10, 3.14)
nt = (a=1, b=2, c=3)

(;x, y) = t
(;a, b, c) = nt

so the (;x, y) syntax on the LHS is a way to declare/make several variables that get their value by calling getproperty(x, :sym) on the RHS.

Javascript has this (in recent versions).

[JeffreySarnoff]

thx