Add Iterators.cat

[CameronBieganek]

Is there any appetite for an Iterators.cat function? I often use Iterators.flatten like this:

Iterators.flatten((itr1, itr2, itr3))

But it feels kind of silly to put the iterators in a tuple just so I can concatenate them. I think a more natural syntax would be

Iterators.cat(itr1, itr2, itr3)

where Iterators.cat is a Vararg function.

(Copied and pasted from this Discourse post.)

[lungben]

This one-liner should already do it - or am I missing some edge cases?

import Base
Base.Iterators.cat(args...) = Iterators.flatten(args)

A = [1, 2, 3]
B = [3, 4, 5]
for i in Iterators.cat(A, B, A)
    @show i
end

[lungben]

An alternative would be to add the vararg version as a new method to Iterators.flatten instead of a new function.
On the other hand, the name "cat" is well established for such purposes.

[CameronBieganek]

Yeah, Base.Iterators.cat(args...) = Iterators.flatten(args) works fine. But I wonder if that implementation is the most efficient that iterator concatenation can be? I haven't studied the flatten source code.

[CameronBieganek]

Inspired by the discussion in this thread, I think it would make sense for the API of Iterators.cat to be a little different from that provided by an implementation like

Base.Iterators.cat(args...) = Iterators.flatten(args)

In the linked Discourse discussion, it was pointed out that Iterators.flatten allows the element types of the flattened iterators to be different, and thus the element type of the flattened iterator is unknown:

julia> using Base.Iterators

julia> Base.IteratorEltype(flatten((1:3, repeated(0))))
Base.EltypeUnknown()

julia> eltype(flatten((1:3, repeated(0))))
Any

So, I think there's a definite need here for an Iterators.cat with the API that only iterators with the same element types are allowed, otherwise an exception will be thrown. In other words, the contract for Iterators.cat will be that if

eltype(itr1) == eltype(itr2) == T

then

eltype(Iterators.cat(itr1, itr2)) == T