add more defaults for reductions over empty arrays (#29919)

From discussion in #28535

Author: simonbyrne

base/reduce.jl

@@ -348,6 +348,9 @@ reduce_empty(::typeof(*), ::Type{<:AbstractChar}) = ""
 reduce_empty(::typeof(&), ::Type{Bool}) = true
 reduce_empty(::typeof(|), ::Type{Bool}) = false
 
+reduce_empty(::typeof(max), T) = typemin(T)
+reduce_empty(::typeof(min), T) = typemax(T)
+
 reduce_empty(::typeof(add_sum), ::Type{Union{}}) = _empty_reduce_error(add_sum, Union{})
 reduce_empty(::typeof(add_sum), ::Type{T}) where {T} = reduce_empty(+, T)
 reduce_empty(::typeof(add_sum), ::Type{T}) where {T<:SmallSigned}  = zero(Int)
@@ -373,8 +376,10 @@ mapreduce_empty(::typeof(identity), op, T) = reduce_empty(op, T)
 mapreduce_empty(::typeof(abs), op, T)      = abs(reduce_empty(op, T))
 mapreduce_empty(::typeof(abs2), op, T)     = abs2(reduce_empty(op, T))
 
-mapreduce_empty(f::typeof(abs),  ::typeof(max), T) = abs(zero(T))
-mapreduce_empty(f::typeof(abs2), ::typeof(max), T) = abs2(zero(T))
+mapreduce_empty(::typeof(abs),  ::typeof(max), T) = abs(zero(T))
+mapreduce_empty(::typeof(abs),  ::typeof(min), T) = typemax(abs(zero(T)))
+mapreduce_empty(::typeof(abs2), ::typeof(max), T) = abs2(zero(T))
+mapreduce_empty(::typeof(abs2),  ::typeof(min), T) = typemax(abs2(zero(T)))
 
 # For backward compatibility:
 mapreduce_empty_iter(f, op, itr, ItrEltype) =

test/reduce.jl

@@ -91,6 +91,10 @@ end
 @test mapreduce(abs2, *, Float64[]) === 1.0
 @test mapreduce(abs2, max, Float64[]) === 0.0
 @test mapreduce(abs, max, Float64[]) === 0.0
+@test mapreduce(abs2, min, Float64[]) === Inf
+@test mapreduce(abs, min, Float64[]) === Inf
+@test_throws ArgumentError mapreduce(abs2, &, Float64[])
+@test_throws ArgumentError mapreduce(abs2, |, Float64[])
 @test_throws ["reducing over an empty collection is not allowed",
               "consider supplying `init`"] mapreduce(abs2, &, Float64[])
 @test_throws str -> !occursin("Closest candidates are", str) mapreduce(abs2, &, Float64[])
@@ -260,6 +264,21 @@ prod2(itr) = invoke(prod, Tuple{Any}, itr)
 @test minimum(sin, []; init=1) == 1
 @test extrema(sin, []; init=(1, -1)) == (1, -1)
 
+@test maximum(Float64[]) === -Inf
+@test minimum(Float64[]) === +Inf
+
+@test maximum(Float32[]) === -Inf32
+@test minimum(Float32[]) === +Inf32
+
+@test maximum(abs, Int[]) === 0
+@test_throws ArgumentError minimum(abs, Int[])
+
+@test maximum(abs, Float64[]) === 0.0
+@test minimum(abs, Float64[]) === +Inf
+
+@test maximum(abs, Float32[]) === 0.0f0
+@test minimum(abs, Float32[]) === +Inf32
+
 @test maximum(5) == 5
 @test minimum(5) == 5
 @test extrema(5) == (5, 5)