Lazy broadcasting macro

README.md

@@ -81,6 +81,18 @@ julia> B = BroadcastArray(+, A, 2);
 julia> B == A .+ 2
 true
 ```
+Such arrays can also be created using the macro `@~` which acts on ordinary 
+broadcasting expressions: 
+```julia
+julia> C = rand(1000)';
+
+julia> D = @~ exp.(C)
+
+julia> E = @~ @. 2 + log(C)
+
+julia> @btime sum(@~ C .* C'; dims=1) # without `@~`, 1.438 ms (5 allocations: 7.64 MiB) 
+  74.425 μs (7 allocations: 8.08 KiB)
+```
 
 ## Multiplication
 

REQUIRE

@@ -1,3 +1,4 @@
 julia 0.7
 FillArrays 0.3
 StaticArrays 0.8.3
+MacroTools

src/lazybroadcasting.jl

@@ -37,9 +37,76 @@ getindex(B::BroadcastArray{<:Any,1}, kr::AbstractVector{<:Integer}) =
 
 copy(bc::Broadcasted{<:LazyArrayStyle}) = BroadcastArray(bc)
 
-# issue 16: sum(b, dims=(1,2,3)) faster than sum(b)
-Base._sum(b::BroadcastArray{T,N}, ::Colon) where {T,N} = first(Base._sum(b, ntuple(identity, N)))
-Base._prod(b::BroadcastArray{T,N}, ::Colon) where {T,N} = first(Base._prod(b, ntuple(identity, N)))
+# Replacement for #18.
+# Could extend this to other similar reductions in Base... or apply at lower level? 
+# for (fname, op) in [(:sum, :add_sum), (:prod, :mul_prod),
+#                     (:maximum, :max), (:minimum, :min),
+#                     (:all, :&),       (:any, :|)]
+function Base._sum(f, A::BroadcastArray, ::Colon)
+    bc = A.broadcasted
+    T = Broadcast.combine_eltypes(f ∘ bc.f, bc.args) 
+    out = zero(T)
+    @simd for I in eachindex(bc)
+        @inbounds out += f(bc[I])
+    end
+    out
+end
+function Base._prod(f, A::BroadcastArray, ::Colon)
+    bc = A.broadcasted
+    T = Broadcast.combine_eltypes(f ∘ bc.f, bc.args) 
+    out = one(T)
+    @simd for I in eachindex(bc)
+        @inbounds out *= f(bc[I])
+    end
+    out
+end
+
+# Macros for lazy broadcasting, #21 WIP
+# based on @dawbarton  https://discourse.julialang.org/t/19641/20
+# and @tkf            https://github.com/JuliaLang/julia/issues/19198#issuecomment-457967851
+# and @chethega      https://github.com/JuliaLang/julia/pull/30939
+
+export @~
+
+lazy(::Any) = throw(ArgumentError("function `lazy` exists only for its effect on broadcasting, see the macro @~"))
+struct LazyCast{T}
+    value::T
+end
+Broadcast.broadcasted(::typeof(lazy), x) = LazyCast(x)
+Broadcast.materialize(x::LazyCast) = BroadcastArray(x.value)
+
+"""
+    @~ expr
+
+Macro for creating lazy `BroadcastArray`s. 
+Expects a broadcasting expression, possibly created by the `@.` macro:
+```
+julia> @~ A .+ B ./ 2
+
+julia> @~ @. A + B / 2
+```
+"""
+macro ~(ex)
+    checkex(ex)
+    esc( :( $lazy.($ex) ) )
+end
+
+using MacroTools 
+
+function checkex(ex)
+    if @capture(ex, (arg__,) = val_ ) 
+        if arg[2]==:dims
+            throw(ArgumentError("@~ is capturing keyword arguments, try with `; dims = $val` instead of a comma"))
+        else
+            throw(ArgumentError("@~ is probably capturing capturing keyword arguments, try with ; or brackets"))
+        end
+    end
+    if @capture(ex, (arg_,rest__) ) 
+        throw(ArgumentError("@~ is capturing more than one expression, try $name($arg) with brackets"))
+    end
+    ex
+end
+
 
 BroadcastStyle(::Type{<:BroadcastArray{<:Any,N}}) where N = LazyArrayStyle{N}()
 BroadcastStyle(L::LazyArrayStyle{N}, ::StaticArrayStyle{N}) where N = L

test/runtests.jl

@@ -164,14 +164,28 @@ end
 
 @testset "BroadcastArray" begin
     A = randn(6,6)
+
     B = BroadcastArray(exp, A)
+    B′ = @~ exp.(A)
+    B′′ = @~ @. exp(A)
     @test Matrix(B) == exp.(A)
+    @test Matrix(B′) == exp.(A)
+    @test Matrix(B′′) == exp.(A)
 
     C = BroadcastArray(+, A, 2)
+    C′ = @~ A .+ 2
+    C′′ = @~ @. A + 2
     @test C == A .+ 2
+    @test C′ == A .+ 2
+    @test C′′ == A .+ 2
+
     D = BroadcastArray(+, A, C)
+    D′ = @~ A + C
+    D′′ = @~ @. A + C
     @test D == A + C
-
+    @test D′ == A + C
+    @test D′′ == A + C
+
     @test sum(B) ≈ sum(exp, A)
     @test sum(C) ≈ sum(A .+ 2)