WIP: a more principled take on dimensional reduction inits

base/array.jl

@@ -651,7 +651,7 @@ function _collect(::Type{T}, itr, isz::SizeUnknown) where T
 end
 
 # make a collection similar to `c` and appropriate for collecting `itr`
-_similar_for(c, ::Type{T}, itr, isz, shp) where {T} = similar(c, T)
+_similar_for(c, ::Type{T}, itr, isz, shp) where {T} = similar(c, T, shp)
 
 _similar_shape(itr, ::SizeUnknown) = nothing
 _similar_shape(itr, ::HasLength) = length(itr)::Integer
@@ -731,6 +731,12 @@ collect(A::AbstractArray) = _collect_indices(axes(A), A)
 
 collect_similar(cont, itr) = _collect(cont, itr, IteratorEltype(itr), IteratorSize(itr))
 
+struct _Allocator{T}
+    f::T
+end
+similar(f::_Allocator, ::Type{T}, dims) where {T} = f.f(T, dims)
+collect_allocator(f::F, itr) where {F} = _collect(_Allocator(f), itr, IteratorEltype(itr), IteratorSize(itr))
+
 _collect(cont, itr, ::HasEltype, isz::Union{HasLength,HasShape}) =
     copyto!(_similar_for(cont, eltype(itr), itr, isz, _similar_shape(itr, isz)), itr)
 

base/broadcast.jl

@@ -234,6 +234,9 @@ Base.similar(::Broadcasted{ArrayConflict}, ::Type{ElType}, dims) where ElType =
     similar(Array{ElType, length(dims)}, dims)
 Base.similar(::Broadcasted{ArrayConflict}, ::Type{Bool}, dims) =
     similar(BitArray, dims)
+# As well as the default behavior
+Base.similar(::Broadcasted, ::Type{ElType}, dims) where ElType =
+    similar(Array{ElType, length(dims)}, dims)
 
 @inline Base.axes(bc::Broadcasted) = _axes(bc, bc.axes)
 _axes(::Broadcasted, axes::Tuple) = axes

base/deprecated.jl

@@ -532,6 +532,10 @@ end
 
 # BEGIN 1.12 deprecations
 
+function reducedim_initarray end
+const _dep_message_reducedim_initarray = ", these internals have been removed. To customize the array returned by dimensional reductions, implement mapreduce_similar instead"
+deprecate(Base, :reducedim_initarray)
+
 @deprecate isbindingresolved(m::Module, var::Symbol) true false
 
 """

base/fastmath.jl

@@ -401,19 +401,15 @@ minimum_fast(a; kw...) = Base.reduce(min_fast, a; kw...)
 maximum_fast(f, a; kw...) = Base.mapreduce(f, max_fast, a; kw...)
 minimum_fast(f, a; kw...) = Base.mapreduce(f, min_fast, a; kw...)
 
-Base.reducedim_init(f, ::typeof(max_fast), A::AbstractArray, region) =
-    Base.reducedim_init(f, max, A::AbstractArray, region)
-Base.reducedim_init(f, ::typeof(min_fast), A::AbstractArray, region) =
-    Base.reducedim_init(f, min, A::AbstractArray, region)
-
 maximum!_fast(r::AbstractArray, A::AbstractArray; kw...) =
     maximum!_fast(identity, r, A; kw...)
 minimum!_fast(r::AbstractArray, A::AbstractArray; kw...) =
     minimum!_fast(identity, r, A; kw...)
 
-maximum!_fast(f::Function, r::AbstractArray, A::AbstractArray; init::Bool=true) =
-    Base.mapreducedim!(f, max_fast, Base.initarray!(r, f, max, init, A), A)
-minimum!_fast(f::Function, r::AbstractArray, A::AbstractArray; init::Bool=true) =
-    Base.mapreducedim!(f, min_fast, Base.initarray!(r, f, min, init, A), A)
+maximum!_fast(f::Function, r::AbstractArray, A::AbstractArray; init::Bool=true) = init ?
+    Base.mapreduce!(f, max_fast, r, A) : Base.mapreducedim!(f, max_fast, r, A)
+
+minimum!_fast(f::Function, r::AbstractArray, A::AbstractArray; init::Bool=true) = init ?
+    Base.mapreduce!(f, min_fast, r, A) : Base.mapreducedim!(f, min_fast, r, A)
 
 end

base/reduce.jl

@@ -251,8 +251,7 @@ foldr(op, itr; kw...) = mapfoldr(identity, op, itr; kw...)
 @noinline function mapreduce_impl(f, op, A::AbstractArrayOrBroadcasted,
                                   ifirst::Integer, ilast::Integer, blksize::Int)
     if ifirst == ilast
-        @inbounds a1 = A[ifirst]
-        return mapreduce_first(f, op, a1)
+        throw(AssertionError("mapreduce_impl must not be called with only one element"))
     elseif ilast - ifirst < blksize
         # sequential portion
         @inbounds a1 = A[ifirst]
@@ -356,6 +355,7 @@ reduce_empty(::typeof(mul_prod), ::Type{T}) where {T<:BitUnsignedSmall} = one(UI
 
 reduce_empty(op::BottomRF, ::Type{T}) where {T} = reduce_empty(op.rf, T)
 reduce_empty(op::MappingRF, ::Type{T}) where {T} = mapreduce_empty(op.f, op.rf, T)
+reduce_empty(op::MappingRF{<:Any,<:BottomRF}, ::Type{T}) where {T} = mapreduce_empty(op.f, op.rf.rf, T)
 reduce_empty(op::FilteringRF, ::Type{T}) where {T} = reduce_empty(op.rf, T)
 reduce_empty(op::FlipArgs, ::Type{T}) where {T} = reduce_empty(op.f, T)
 
@@ -1050,7 +1050,9 @@ argmin(itr) = findmin(itr)[2]
 
 ## count
 
-_bool(f) = x->f(x)::Bool
+_assert_bool(x) = x::Bool
+_bool(f) = _assert_bool ∘ f
+mapreduce_empty(::ComposedFunction{typeof(_assert_bool), <:Any}, ::typeof(add_sum), itr) = false+false
 
 """
     count([f=identity,] itr; init=0)::Integer