Add unzip

[bramtayl]

I finally switched to Ubuntu, and suddenly building and testing Base became much more manageable! I think this should be pretty close to good.

Closes #13942

[bramtayl]

CI failures unrelated, correct?

[bramtayl]

CI failures unrelated

[bramtayl]

@StefanKarpinski can you assign someone to review this?

[StefanKarpinski]

It feels like a lot of stuff to implement unzip. Here's a version that I cooked up:

"""
    unzip(itrs) -> Vector{<:Vector}

The `unzip` function takes an iterator of iterators and returns a vector of
vectors such that `zip(unzip(itrs)...) == map(itr->tuple(itr...), itrs)`.

# Examples

    julia> unzip(enumerate("Hello"))
    2-element Array{Array{T,1} where T,1}:
     [1, 2, 3]
     ['a', 'b', 'c']

    julia> unzip([[1, 'a'], [2.5, 'z'], [0, 'x']])
    2-element Array{Array{T,1} where T,1}:
     Real[1, 2.5, 0]
     ['a', 'z', 'x']

"""
function unzip(itrs)
    outer = iterate(itrs)
    outer === nothing && return []
    vals, state = outer
    vecs = Vector[[val] for val in vals]
    local n
    if Base.haslength(itrs)
        n = length(itrs)
        for vec in vecs
            sizehint!(vec, n)
        end
    end
    while true
        outer = iterate(itrs, state)
        outer === nothing && return vecs
        vals, state = outer
        for (j, val) = enumerate(vals)
            vec = vecs[j]
            if !(val isa eltype(vec))
                T = Base.promote_typejoin(typeof(val), eltype(vec))
                vec = vecs[j] = copyto!(similar(vec, T), vec)
                @isdefined(n) && sizehint!(vec, n)
            end
            push!(vec, val)
        end
    end
end

[StefanKarpinski]

I guess the question is what one wants unzip to do. Here's a simpler version that allows unzipping unevenly sized arrays—which is of questionable desirability—but makes it simpler to implement:

function unzip(itrs; uneven::Bool=false)
    n = Base.haslength(itrs) ? length(itrs) : -1
    vecs = Vector[]
    for itr in itrs
        for (j, x) in enumerate(itr)
            if length(vecs) < j
                v = [x]
                push!(vecs, v)
                n ≥ 0 && sizehint!(v, n)
            else
                v = vecs[j]
                if !(x isa eltype(v))
                    T = Base.promote_typejoin(typeof(x), eltype(v))
                    v = vecs[j] = copyto!(similar(v, T), v)
                    n ≥ 0 && sizehint!(v, n)
                end
                push!(v, x)
            end
        end
        uneven || length(first(vecs)) == length(last(vecs)) ||
            throw(ArgumentError("unzip called with uneven iterators"))
    end
    return vecs
end

Works the same on evenly sized arrays but here's an example with unevenly sized ones:

julia> unzip([[1, 'a'], [2.5, 'z', "extra"], [0, 'x']], uneven=true)
3-element Array{Array{T,1} where T,1}:
 Real[1, 2.5, 0]
 ['a', 'z', 'x']
 ["extra"]

This just goes through each iterable thing and collects into the vector at the corresponding index.