remove mapreduce methods that don't take an iterator argument

PR JuliaLang#52631 made `map` throw `MethodError` when called without an
iterator argument. That made `mapreduce` throw `MethodError` when
called without an iterator argument, too, something that was *not*
noticed back then. This change makes iteratorless `mapreduce` throw
before it can be called, instead of when it tries to call `map` (or
`Generator`) without passing it an iterator argument.

Now all of these functions should only have methods that take a
positive number of iterator arguments, which improves consistency:

1. `map`
2. `Iterators.map`
3. `foreach`
4. `reduce`
5. `foldl`
6. `foldr`
7. `mapreduce`
8. `mapfoldl`
9. `mapfoldr`
10. `Base.Generator`

Author: nsajko

base/reduce.jl

@@ -297,7 +297,7 @@ implementations may reuse the return value of `f` for elements that appear multi
 guaranteed left or right associativity and invocation of `f` for every value.
 """
 mapreduce(f, op, itr; kw...) = mapfoldl(f, op, itr; kw...)
-mapreduce(f, op, itrs...; kw...) = reduce(op, Generator(f, itrs...); kw...)
+mapreduce(f, op, itr, itrs...; kw...) = reduce(op, Generator(f, itr, itrs...); kw...)
 
 # Note: sum_seq usually uses four or more accumulators after partial
 # unrolling, so each accumulator gets at most 256 numbers

base/reducedim.jl

@@ -326,8 +326,8 @@ julia> mapreduce(isodd, |, a, dims=1)
 """
 mapreduce(f, op, A::AbstractArrayOrBroadcasted; dims=:, init=_InitialValue()) =
     _mapreduce_dim(f, op, init, A, dims)
-mapreduce(f, op, A::AbstractArrayOrBroadcasted...; kw...) =
-    reduce(op, map(f, A...); kw...)
+mapreduce(f, op, A::AbstractArrayOrBroadcasted, B::AbstractArrayOrBroadcasted...; kw...) =
+    reduce(op, map(f, A, B...); kw...)
 
 _mapreduce_dim(f, op, nt, A::AbstractArrayOrBroadcasted, ::Colon) =
     mapfoldl_impl(f, op, nt, A)

test/iterators.jl

@@ -1037,12 +1037,31 @@ let itr = (i for i in 1:9) # Base.eltype == Any
     @test collect(zip(repeat([Iterators.Stateful(itr)], 3)...)) == [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
 end
 
-@testset "no single-argument map methods" begin
-    maps = (tuple, Returns(nothing), (() -> nothing))
-    mappers = (Iterators.map, map, foreach)
-    for f ∈ maps, m ∈ mappers
-        @test !applicable(m, f)
-        @test !hasmethod(m, Tuple{typeof(f)})
+@testset "map/reduce/mapreduce without an iterator argument" begin
+    maps = map(Returns, (nothing, 3, 3:2, 3:3, (), (3,)))
+    mappers1 = (Iterators.map, map, foreach, reduce, foldl, foldr)
+    mappers2 = (mapreduce, mapfoldl, mapfoldr)
+
+    @testset "map/reduce" begin
+        @testset "r: $r" for r ∈ mappers1
+            @testset "f: $f" for f ∈ maps
+                @test_throws MethodError r(f)
+                @test !applicable(r, f)
+                @test !hasmethod(r, Tuple{typeof(f)})
+            end
+        end
+    end
+
+    @testset "mapreduce" begin
+        @testset "mr: $mr" for mr ∈ mappers2
+            @testset "f: $f" for f ∈ maps
+                @testset "g: $g" for g ∈ maps
+                    @test_throws MethodError mr(f, g)
+                    @test !applicable(mr, f, g)
+                    @test !hasmethod(mr, Tuple{typeof(f),typeof(g)})
+                end
+            end
+        end
     end
 end