use a boolean operator for any/all, not bitwise

and add more comprehensive tests

Author: mbauman

base/reduce.jl

@@ -29,6 +29,9 @@ mul_prod(x::BitSignedSmall, y::BitSignedSmall) = Int(x) * Int(y)
 mul_prod(x::BitUnsignedSmall, y::BitUnsignedSmall) = UInt(x) * UInt(y)
 mul_prod(x::Real, y::Real)::Real = x * y
 
+and_all(x,y) = Bool(x && y)
+or_any(x,y) = Bool(x || y)
+
 ## foldl && mapfoldl
 
 function mapfoldl_impl(f::F, op::OP, nt, itr) where {F,OP}
@@ -336,8 +339,8 @@ reduce_empty(::typeof(+), ::Type{T}) where {T} = zero(T)
 reduce_empty(::typeof(+), ::Type{Bool}) = zero(Int)
 reduce_empty(::typeof(*), ::Type{T}) where {T} = one(T)
 reduce_empty(::typeof(*), ::Type{<:AbstractChar}) = ""
-reduce_empty(::typeof(&), ::Type{Bool}) = true
-reduce_empty(::typeof(|), ::Type{Bool}) = false
+reduce_empty(::typeof(and_all), ::Type{T}) where {T} = true
+reduce_empty(::typeof(or_any), ::Type{T}) where {T} = false
 
 reduce_empty(::typeof(add_sum), ::Type{T}) where {T} = reduce_empty(+, T)
 reduce_empty(::typeof(add_sum), ::Type{T}) where {T<:BitSignedSmall}  = zero(Int)

base/reducedim.jl

@@ -45,7 +45,7 @@ end
 initarray!(a::AbstractArray{T}, f, ::Union{typeof(min),typeof(max),typeof(_extrema_rf)},
     init::Bool, src::AbstractArray) where {T} = (init && mapfirst!(f, a, src); a)
 
-for (Op, initval) in ((:(typeof(&)), true), (:(typeof(|)), false))
+for (Op, initval) in ((:(typeof(and_all)), true), (:(typeof(or_any)), false))
     @eval initarray!(a::AbstractArray, ::Any, ::$(Op), init::Bool, src::AbstractArray) = (init && fill!(a, $initval); a)
 end
 
@@ -173,8 +173,8 @@ end
 reducedim_init(f::Union{typeof(abs),typeof(abs2)}, op::typeof(max), A::AbstractArray{T}, region) where {T} =
     reducedim_initarray(A, region, zero(f(zero(T))), _realtype(f, T))
 
-reducedim_init(f, op::typeof(&), A::AbstractArrayOrBroadcasted, region) = reducedim_initarray(A, region, true)
-reducedim_init(f, op::typeof(|), A::AbstractArrayOrBroadcasted, region) = reducedim_initarray(A, region, false)
+reducedim_init(f, op::typeof(and_all), A::AbstractArrayOrBroadcasted, region) = reducedim_initarray(A, region, true)
+reducedim_init(f, op::typeof(or_any), A::AbstractArrayOrBroadcasted, region) = reducedim_initarray(A, region, false)
 
 # specialize to make initialization more efficient for common cases
 
@@ -994,7 +994,7 @@ _all(a, ::Colon)                           = _all(identity, a, :)
 
 for (fname, op) in [(:sum, :add_sum), (:prod, :mul_prod),
                     (:maximum, :max), (:minimum, :min),
-                    (:all, :&),       (:any, :|),
+                    (:all, :and_all), (:any, :or_any),
                     (:extrema, :_extrema_rf)]
     fname! = Symbol(fname, '!')
     _fname = Symbol('_', fname)

test/reducedim.jl

@@ -720,3 +720,38 @@ end
     @test_broken @inferred(maximum(exp, A; dims = 1))[1] === missing
     @test_broken @inferred(extrema(exp, A; dims = 1))[1] === (missing, missing)
 end
+
+some_exception(op) = try return (Some(op()), nothing); catch ex; return (nothing, ex); end
+reduced_shape(sz, dims) = ntuple(d -> d in dims ? 1 : sz[d], length(sz))
+
+@testset "Ensure that calling, e.g., sum(empty; dims) has the same behavior as sum(empty)" begin
+    @testset "$r(Array{$T}(undef, $sz); dims=$dims)" for
+        r in (minimum, maximum, findmin, findmax, extrema, sum, prod, mapreduce, all, any, count),
+        T in (Int, Union{Missing, Int}, Number, Union{Missing, Number}, Bool, Union{Missing, Bool}, Any),
+        sz in ((0,), (0,1), (1,0), (0,0), (0,0,1), (1,0,1)),
+        dims in (1, 2, 3, 4, (1,2), (1,3), (2,3,4), (1,2,3))
+
+        A = Array{T}(undef, sz)
+        rsz = reduced_shape(sz, dims)
+
+        v, ex = some_exception() do; r(A); end
+        if isnothing(v)
+            @test_throws typeof(ex) r(A; dims)
+        else
+            actual = fill(something(v), rsz)
+            @test isequal(r(A; dims), actual)
+            @test eltype(r(A; dims)) === eltype(actual)
+        end
+
+        for f in (identity, abs, abs2)
+            v, ex = some_exception() do; r(f, A); end
+            if isnothing(v)
+                @test_throws typeof(ex) r(f, A; dims)
+            else
+                actual = fill(something(v), rsz)
+                @test isequal(r(f, A; dims), actual)
+                @test eltype(r(f, A; dims)) === eltype(actual)
+            end
+        end
+    end
+end