# Introduction

Recently I have written a post about @view and @views macros. In what followed I got a feedback, that the topic I touched there was indeed useful. Therefore for today I decided to write about another macro. This time I will share my thoughts on the @. macro.

This post was written under Julia 1.7.2.

# Understanding what @. macro does

The @. macro is used to inject broadcasting into every function call in an expression passed to it.

Let us have a look at its docstring:

Convert every function call or operator in expr into a “dot call” (e.g. convert f(x) to f.(x)), and convert every assignment in expr to a “dot assignment” (e.g. convert += to .+=).

If you want to avoid adding dots for selected function calls in expr, splice those function calls in with $. For example, @. sqrt(abs($sort(x))) is equivalent to sqrt.(abs.(sort(x))) (no dot for sort).

The @. marco is quite useful when we work with long expressions that involve several operations that we want to be broadcasted together. Here is a minimal example:

julia> using Statistics

julia> x = 1:10
1:10

julia> @. sin(x)^2 + cos(x)^2
10-element Vector{Float64}:
1.0
1.0
0.9999999999999999
1.0
0.9999999999999999
0.9999999999999999
0.9999999999999999
1.0
0.9999999999999999
1.0


Writing @. sin(x)^2 + cos(x)^2 is much more convenient than writing sin.(x).^2 .+ cos.(x).^2.

However, what if we wanted to compute variance of x? A direct approach would be to write this operation as:

julia> sum((x .- mean(x)) .^ 2) / (length(x) - 1)
9.166666666666666


As you can see I use broadcasting in only two places, while most of the operations are not broadcasted. If we wanted to use @. macro we would need to use $ escaping and write something like: julia> @.$/($sum((x -$mean(x)) ^ 2), $-($length(x), 1))
9.166666666666666


which is equivalent and ugly. You can check it by using @macroexpand:

julia> @macroexpand @. $/($sum((x - $mean(x))^2),$-($length(x), 1)) :(sum((^).((-).(x, mean(x)), 2)) / (length(x) - 1))  In this case also correct (but not equivalent) and simpler way would be: julia> @.$sum((x - $mean(x))^2) / ($length(x) - 1)
9.166666666666666


However, in this case you need to know and be sure that by not escaping-out the / and - function calls in the second part of the expression you will not affect the correctness of your calculation.

In summary, I do not use @. in complex expressions as it is usually hard to reason about it.

Let us now switch to some special cases of using @..

# Be careful with broadcasted assignment

Other common source of bugs when using @. is broadcasted assignment.

Let us analyze the following code:

julia> x = ["a", "b"]
2-element Vector{String}:
"a"
"b"

julia> x = @. length(x)
2-element Vector{Int64}:
1
1

julia> x
2-element Vector{Int64}:
1
1

julia> y = ["a", "b"]
2-element Vector{String}:
"a"
"b"

julia> @. y = length(y)
ERROR: MethodError: Cannot convert an object of type Int64 to an object of type String


In the case of x variable the @. macro is on the right hand side of the assignment. In this case we get a fresh binding of value to variable x.

In the case of y the @. encompasses the left hand side of the assignment. In this case the operation is in-place. Therefore in this case we get an error, because you cannot store integers in a vector of strings.

Things, of course, can be silently wrong, as in the following example of Vector{Char}, as Char supports conversion from integer:

julia> z = ['a', 'b']
2-element Vector{Char}:
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)
'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)

julia> @. z = length(z)
2-element Vector{Char}:
'\x01': ASCII/Unicode U+0001 (category Cc: Other, control)
'\x01': ASCII/Unicode U+0001 (category Cc: Other, control)

julia> z
2-element Vector{Char}:
'\x01': ASCII/Unicode U+0001 (category Cc: Other, control)
'\x01': ASCII/Unicode U+0001 (category Cc: Other, control)


# Incorrect handling of named tuples

Consider the following code:

julia> v = 1:3
1:3

julia> [x in (a=1, c=3) for x in v]
3-element Vector{Bool}:
1
0
1


We can rewrite it using broadcasting as:

julia> in.(v, Ref((a=1, c=3)))
3-element BitVector:
1
0
1


Now we think we could use the @. here as follows:

julia> @. in(v, $Ref((a=1, c=3))) ERROR: UndefVarError: c not defined  However, this fails as @. macro incorrectly handles = inside NamedTuple definition. We have to write: julia> @. in(v,$Ref((; a=1, c=3)))
3-element BitVector:
1
0
1


The ; at the beginning of NamedTuple definition gives an equivalent object but changes how the code expression is transformed by the Julia compiler and it works. Here is how we can check the difference in the representation of (a=1, c=3) and (; a=1, c=3):

julia> dump(:(a=1, c=3))
Expr
args: Array{Any}((2,))
1: Expr
args: Array{Any}((2,))
1: Symbol a
2: Int64 1
2: Expr
args: Array{Any}((2,))
1: Symbol c
2: Int64 3

julia> dump(:(; a=1, c=3))
Expr
args: Array{Any}((1,))
1: Expr
args: Array{Any}((2,))
1: Expr
args: Array{Any}((2,))
1: Symbol a
2: Int64 1
2: Expr

Fortunately the case of NamedTuple is not likely to be problematic in practice as it is extremely rare.
The @. macro can be very convenient. However, in my experience, you need to be careful when you use it as it is easy to get surprising results if you work with complex expressions. Out of the possible problematic situations I have covered in my post a most common one is forgetting to add \$ to avoid broadcasting of some function calls in a complex expression.