Filter(f, tuple)

[mcabbott]

Closes #30418

[mcabbott]

Test failure should be fixed by #32965?

To be able to filter by type, it's tempting to add something like this, working around the lack of isa(T), #32018, but probably too weird:

@generated function _filter(T::DataType, x::Tuple, r::Tuple{})
    out = []
    for (d,t) in enumerate(x.parameters)
        if t isa T
            push!(out, :( x[$d] ))
        end
    end
    :( ($(out...),) )
end

[StefanKarpinski]

Yes, I can confirm that the doctest failure was my fault and unrelated to this :sheepish_grin:

[tkf]

I'd suggest something simpler:

filter(f, t::Tuple) = _filterargs(f, t...)
_filterargs(f) = ()
_filterargs(f, x, xs...) =
    f(x) ? (x, _filterargs(f, xs...)...) : _filterargs(f, xs...)

It can handle isa in lambda:

julia> f(::Type{T}) where T = filter(x -> x isa T, (0, 1.0, 2, 3.0))
f (generic function with 1 method)

julia> @code_typed f(Int)
CodeInfo(
1 ─ %1 = Core.tuple(0, 2)::Tuple{Int64,Int64}
└──      return %1
) => Tuple{Int64,Int64}

[mcabbott]

I played with a few variants, this one is fast on the things I was testing:

@btime filter(x->x>2, (1,2,3,4,5)) # 19.337 ns this PR, 527.370 ns tkf's, 1.250 μs my most compact

But @tkf's is faster on x -> x isa Int

@btime filter(x -> x isa Int, (0,true,1,2.0,π,4)) # 17.555 ns this PR, 1.696 ns tkf's
@btime filter(Int, (0,true,1,2.0,π,4)) # 0.029 ns with @generated

But I don't know exactly what is fair in timing such things, @btime () -> f(Int) with the above f gives 0.029 ns for both variants.

[mcabbott]

Polite bump — what can I do to push this along?

[StefanKarpinski]

@JeffBezanson, please merge if this looks acceptable to you.

[tkf]

Actually, here is an even simpler and better approach equivalent to #32968 (comment) (for short tuples):

filter(f, xs::Tuple) = afoldl((ys, x) -> f(x) ? (ys..., x) : ys, (), xs...)

@mcabbott IMHO, I think you need to re-write your code. For example, filter(x -> x !== nothing, (1, missing, 2)) cannot be inferred with your version but my versions can. Generally, I think it's a better approach to not use tail-recursion on fixed-length data structures like tuple (see, e.g., foldl and map for tuples). IIUC, this is because the compiler does not like recursion when the arguments are not simplifying.

[mcabbott]

Thanks, that’s very neat, I did not know about afoldl. That now seems better & faster than mine in all respects. So I will replace the PR with two lines once I’ve checked a bit more… tests so far are here:
https://gist.github.com/mcabbott/1a6db9914ec6b941db6d2218b65de000

[mcabbott]

Done! I also added a news item.

[mcabbott]

Bump: @JeffBezanson can you review when you have a minute?

[mcabbott]

Bump?

Red X is from win32, "cp: cannot stat 'dist-extras/7z.*’”, surely unrelated.