Limit inference based initialization to concrete cases.

Author: N5N3

base/reducedim.jl

@@ -124,45 +124,31 @@ function _reducedim_init(f, op, fv, fop, A, region)
 end
 
 # initialization when computing minima and maxima requires a little care
-for (f1, f2, initval, typeextreme) in ((:min, :max, :Inf, :typemax), (:max, :min, :(-Inf), :typemin))
-    @eval function reducedim_init(f, op::typeof($f1), A::AbstractArray, region)
-        # First compute the reduce indices. This will throw an ArgumentError
-        # if any region is invalid
-        ri = reduced_indices(A, region)
-
-        # Next, throw if reduction is over a region with length zero
-        any(i -> isempty(axes(A, i)), region) && _empty_reduce_error()
-
-        # Make a view of the first slice of the region
-        A1 = view(A, ri...)
-
-        if isempty(A1)
-            # If the slice is empty just return non-view version as the initial array
-            return copy(A1)
-        else
-            # otherwise use the min/max of the first slice as initial value
-            v0 = mapreduce(f, $f2, A1)
-
-            T = _realtype(f, promote_union(eltype(A)))
-            Tr = v0 isa T ? T : typeof(v0)
-
-            # but NaNs and missing need to be avoided as initial values
-            if (v0 == v0) === false
-                # v0 is NaN
-                v0 = $initval
-            elseif isunordered(v0)
-                # v0 is missing or a third-party unordered value
-                Tnm = nonmissingtype(Tr)
-                # TODO: Some types, like BigInt, don't support typemin/typemax.
-                # So a Matrix{Union{BigInt, Missing}} can still error here.
-                v0 = $typeextreme(Tnm)
-            end
-            # v0 may have changed type.
-            Tr = v0 isa T ? T : typeof(v0)
-
-            return reducedim_initarray(A, region, v0, Tr)
-        end
+function reducedim_init(f::F, op::Union{typeof(min),typeof(max)}, A::AbstractArray, region) where {F}
+    # First compute the reduce indices. This will throw an ArgumentError
+    # if any region is invalid
+    ri = reduced_indices(A, region)
+
+    # Next, throw if reduction is over a region with length zero
+    any(i -> isempty(axes(A, i)), region) && _empty_reduce_error()
+
+    # Make a view of the first slice of the region
+    A1 = view(A, ri...)
+
+    # Then we try to derive the container's eltype.
+    T = _return_type(f, Tuple{eltype(A)})
+    if isempty(A) || (isconcretetype(nonmissingtype(T)) &&  T === _return_type(op, Tuple{T,T}))
+        # Trust the inference result only when:
+        # 1.`nonmissingtype(T)` is concrete. And `T`'s `min`/`max` is well defined.
+        # 2. `A1` is empty.
+        return map!(f, reducedim_initarray(A,region,_InitialValue(),T), A1)
     end
+    # Otherwise, we'd better not rely on inference.
+    v0 = mapreduce(f, op, A1)                  # 1. Try to reduce A1
+    T = _realtype(f, promote_union(eltype(A))) # 2. A possible wrong guess.
+    Tr = v0 isa T ? T : typeof(v0)             # 3. If T is wrong. Use typeof(v0) instead.
+    # Note: `Tr` still might be wrong, but this can't be truely resolved except we reduce `A`.
+    return map!(f, reducedim_initarray(A,region,_InitialValue(),Tr), A1)
 end
 
 reducedim_init(f::Union{typeof(abs),typeof(abs2)}, op::typeof(max), A::AbstractArray{T}, region) where {T} =