Align Base.Generator, map. Why Base.IteratorSize(zip()) == Base.IsInfinite()?

[goretkin]

zip and map (which is defined in terms of zip, by way of Base.Generator) produce results with length equal to the minimum length of the arguments:

julia> map(string, 1:5, 1:3, 1:4)
3-element Vector{String}:
 "111"
 "222"
 "333"

julia> collect(zip(1:5, 1:3, 1:4))
3-element Vector{Tuple{Int64, Int64, Int64}}:
 (1, 1, 1)
 (2, 2, 2)
 (3, 3, 3)

For zip, the minimum length across no iterators is defined as "infinity"
https://github.com/JuliaLang/julia/blame/ff001a4e1f5b7f949f5a2328520a7e78bc1957b4/base/iterators.jl#L388

julia> Base.IteratorSize(zip())
Base.IsInfinite()

which is the definition consistent with a recursive definition of the minimum (min(x, infinity) = x).

But I'm not sure why a 1-argument map is defined:

julia/base/abstractarray.jl

Line 2460 in 27d3931

map(f) = f()

julia> map(string)
""

Related: #39628

[jonas-schulze]

See also discussion starting at #35916 (comment)

[martinholters]

That map method was added in #17318 together with f.() begin equal to f(). For broadcast, that seems reasonable, as regarding combination of input sizes, 1 is the neutral element there. But thinking about it, having map(f) return an infinite stream of f() would be more consistent with the zip behavior. IIUC, that would basically make map(f, args...) = collect(f(xs...) for xs in zip(args...)) even for empty args, except that the collect then fails. So maybe map(f) actually should throw, but it's lazy cousin Iterators.map(f) should indeed give Iterators.repeated(f())? Or rather Base.Generator(xs -> f(xs...), zip()) so that f is lazily evaluated once per generated element instead of once eagerly upon construction? Indeed, should we add

Generator(f) = Generator(a->f(), zip()) 

as the zero-iterator version of

julia/base/generator.jl

Line 36 in 4c3829d

Generator(f, I1, I2, Is...) = Generator(a->f(a...), zip(I1, I2, Is...))

?