map! only works on AbstractArray

[simeonschaub]

Any reason for restricting the signature of map! to AbstractArray? I don't see why this shouldn't work:

julia> a, b = [1,2], (3,4)
([1, 2], (3, 4))

julia> map(*, a, b)
2-element Vector{Int64}:
 3
 8

julia> map!(*, a, a, b)
ERROR: MethodError: no method matching map!(::typeof(*), ::Vector{Int64}, ::Vector{Int64}, ::Tuple{Int64, Int64})
Closest candidates are:
  map!(::F, ::AbstractArray, ::AbstractArray) where F at abstractarray.jl:2259
  map!(::F, ::AbstractArray, ::AbstractArray, ::AbstractArray) where F at abstractarray.jl:2303
  map!(::F, ::AbstractArray, ::AbstractArray...) where F at abstractarray.jl:2350
  ...
Stacktrace:
 [1] top-level scope
   @ REPL[12]:1

[StefanKarpinski]

True: seems like only the output array needs to be restricted to AbstractArray.

[albheim]

Stumbled upon the same issue and wondered why map! was missing this functionality. This could maybe be something general that catches those cases (together with the multi argument ones mentioned in #23041).

function Base.map!(f, b::AbstractArray, a...)
    for (i,v) in enumerate(zip(a...))
        b[i] = f(v...)
    end
end

[bvdmitri]

I wouldn't use enumerate, but rather zip with the eachindex since there is no guarantee that the indexing of the output array is 1-based.

[albheim]

The current N-source implementation for map! requires the sources to be indexable, so it should work for tuples but not for generators.

Extending the type of the sources to be Union{Tuple, AbstractArray} initially seemed to work, though when tuples are involved the speed seems to go down a little.
What I later realised is that when the tuple was first julia crashed. It seems LinearIndices on a tuple does not create indices for the tuple, but assumes the tuple is the desired dimensions. This did not play well with @inbounds (as expected) and lead to the crash.

Doing a very simple version that captures remaining cases, and only requires the sources to be iterable is a lot slower.

function map!(f::F, dest::AbstractArray, As...) where {F}
    isempty(As) && throw(ArgumentError(
        """map! requires at least one "source" argument"""))
    for (i,v) in zip(eachindex(dest), zip(As...))
        dest[i] = f(v...)
    end
end

I don't know if it is preferable to just to have something simple to catch remaining cases, and then add more specialized methods for specific types when needed, or if is it preferable to skip it to avoid a slow path.