What is interaction between F.() broadcasting and keyword args?

General Usage
1

How does F.(a, b; c=d) work with respect to broadcasting? I understand that the arguments a, b will be broadcast. What about the keyword argument?

3 Likes
2

F.(a, b; c=d) is equivalent to broadcast((a,b) -> F(a, b; c=d), a, b). That is, it does not broadcast over the keyword arguments, but instead passes them inside the closure.

11 Likes
3

Any workaround to broadcast the keyword arguments? Should I lower these to a _func?

1 Like
4

Just call broadcast explicitly and you can use whatever arguments you want.

3 Likes
5

This is suppose to be a friendly end-user API… I ended up lowering the function and checking whether any of the arguments where AbstractVector to decide on whether to broadcast or not. Poor man type dispatch since there are too many combinations for a simple type dispatch.

6

I came across this thread after encountering a similar situation. The code below seems to offer a feasible solution. Note that there might be a small performance penalty for very simple functions, such as the example below, but it seems to be negligible in most cases.

f(a,b) = a + b
f(;a,b) = f.(a,b)

Output:

julia> f(;a=1,b=2)
3

julia> f(;a=1,b=[1,2])
2-element Array{Int64,1}:
 2
 3
7

A simple solution is to define a wrapper function:

wrap(a, b, c) = f(a, b; c=c)
wrap.(A, B, C) # broadcasts on three args.
1 Like
8

Is this documented somewhere? In the sense one can rely on this behavior and it won’t change except in 2.0.

I can’t find mention of keyword args in Single- and multi-dimensional Arrays · The Julia Language.

9

It should be documented; I’ve made a PR: document behavior of keywords in dot calls by stevengj · Pull Request #44033 · JuliaLang/julia · GitHub

2 Likes
10

Great, thanks.

11 
d = 10
x = (;a= 1:3, b=2:4)

f(d;a,b) = d + a * b

one way to apply f to the elements of a and b is:

using DataFramesMeta

@rtransform DataFrame(x) :f = f(d; AsTable(:)... )

Ideally I’d like to write

f.(d; x... )

Will this be supported in 2.0 ?
Is there a better way now? without a function specific wrapper.
I don’t think broacast works due to the named tuple

12

Maybe DataPipes.jl does what you want?

And if you use StructArrays.jl you can seamlessly convert between named tuple of vectors and vector of names tuples

13

Thanks Peter. I couldn’t find that in StructArrays.jl but found it in SplitApplyCombine.jl. So this works

@pipe invert(x) .|> f(d; _... )

Do you know if f.(d; x... ) will be supported in a later version ?

14

For future self:

I recently ran into a similar issue with this, but my situation was slightly more complicated in that I needed to splat a NamedTuple into the keywords of a function (because not all of the arguments may exist). In addition, the keys of the NamedTuple needed to be sorted. So, I ended up writing

@generated function foo(::Val{snames}, ::Val{unames}, vals...) where {snames,unames}
    svals_exprs = []
    for sn in snames
        i = findfirst(un -> un == sn, unames)::Int
        push!(svals_exprs, :(getfield(vals, $i)))
    end
    return quote
        NamedTuple{snames}(($(svals_exprs...),))
    end
end
N = 3;
X = map(_-> (; a=1,b=2), 1:N);
KU = (:b, :a) # unsorted keys
KS = (:a, :b) # sorted keys
A = map(i->2,1:N);
B = map(i->3,1:N);
nt = (;b=B, a=A);
foo.(Val(KS), Val(KU), nt...)
bc = Base.Broadcast.broadcasted(foo, Val(KS), Val(KU), nt...)
Base.materialize(bc)