support multi-arg push! and unshift!

[stevengj]

This patch extends push! and unshift! to accept multiple arguments: push!(A, items...) and unshift!(A, items...), whenever the 1-item versions are defined. For example:

julia> push!([1,2,3], 4,5)
5-element Array{Int64,1}:
 1
 2
 3
 4
 5

julia> unshift!([1,2,3], 4,5)
5-element Array{Int64,1}:
 4
 5
 1
 2
 3

Note that the ordering of the arguments is the same as their ordering in the resulting array (so the items are pushed from left to right, but unshifted from right to left). This seems sensible to me (changing the ordering is a bit surprising), it mirrors append! and prepend!, and e.g. the Javascript push/unshift functions have the same semantics.

By default, these are implemented in terms of the 1-item versions. Specific types could, of course, define specialized multi-argument versions, e.g. push!(A::Array, items...) could be defined to grow the array by several items at once and avoid overhead. But this is an optimization that can be done later if it seems important. The main thing is that this patch does not introduce any performance regressions, it just increases convenience.

[stevengj]

(On a separate note, I feel like there should be fallback versions of append!, prepend!, and empty! for AbstractArray that simply unshift/pop repeatedly ...)

[kmsquire]

I like it.

I'm curious about the overhead of splatting. Would it be any slower if we removed append! and prepend! entirely, and used this interface instead?

[stevengj]

At the very least, splatting has to make an extra copy of the data to convert it to a tuple, so that can't be good if you have a large array...

[StefanKarpinski]

I think that append! and prepend! should probably stay. @JeffBezanson should probably have the final word, but I'm fairly certain that he's not going to be pro-splatting.

[stevengj]

Just to be clear, I'm not proposing eliminating prepend and append. I think they have to stay for performance and memory reasons, not to mention convenience. That's not what this patch is about.

[kmsquire]

@stevengj, I don't think there was any misunderstanding.

More related to this request, this behavior would conflict with @StefanKarpinski's suggestion in #3439 (comment), regarding the potential use of push!(A, idx, item) instead of insert!(A, idx, item)

[JeffBezanson]

I'm fine with this change, but I think it would be better for implementers of push! to handle multiple arguments, rather than implementing it on top of the 1-argument version. That leads to a more efficient implementation where the array is grown only once, knowing how many arguments were passed.

[stevengj]

@JeffBezanson, I agree, but I figured that kind of optimization could be done later; this version is no worse than what we have now.