iterator: improve type inference for Filter

[aviatesk]

This addresses type inference issues with filtered list comprehensions reported in #59111. The root cause is the compiler's inability to perform type refinement in cases like:

let t::Tuple{Any,Any}
    x, y = t
    if x isa Int
        return t # still `::Tuple{Any,Any}`
    end
    nothing
end

Fixing this fundamentally would require extensive improvements to
abstract interpretation. As a workaround, I improved the iterators.jl
implementation to avoid this pattern.

One implementation consideration: if iterate(f.itr, state...) always
returns Union{Nothing,Tuple{Any,Any}}, the if y isa Tuple{Any,Any}
branch should be unnecessary. However, it's unclear whether we can
safely assume this for the iterate interface, so I kept the branch for
now.

[vtjnash]

AFAIK, it is permitted for any two-element struct to be returned (such as NamedTuple or Pair), as long as it implements indexing corresponding to fields

[aviatesk]

AFAIK, it is permitted for any two-element struct to be returned (such as NamedTuple or Pair), as long as it implements indexing corresponding to fields

Okay, then I guess we probably need to update the docstring for iterate (https://docs.julialang.org/en/v1.13-dev/base/collections/#Base.iterate) too..

[adienes]

whether or not the inner iterator uses or is allowed to use a Pair or a Tuple, why does Filter have to pass that choice along?

[martinholters]

But even if iterate((f.itr, state...) returns some non-tuple, it should still be ok for iterate(f, state...) to always return a tuple, no?

[martinholters]

Heh, within a second :)

[aviatesk]

Indeed, from the view point of iterate(::Filter), it might not be a problem to force it to return Tuple{Any,Any}.

[Keno]

Actually I think the previous change may be better. When iterators don't return tuples, ther s often a reason, e.g. to avoid excessive specialization. While I agree it is legal to return the tuple, I'm not sure it's useful.

[aviatesk]

That's certainly true. There's a possibility that other implementations of iterate are manually calling iterate(::Filter). It's a question of whether to avoid breaking such cases or to prioritize type inference results. I don't have a strong opinion on this honestly. Since Tuple{Any,Any} can cover most cases, the previous implementation might be safer and more convenient.

[nsajko]

Is there an actual example of an iterator that returns Union{Nothing, Collection} where !(Collection <: Tuple{Any,Any})?

[aviatesk]

There are lots of cases. You can easily write such a custom iterate implementation while satisfying the iterator protocol.