Is this pure?

Base.@pure which_key(tuple::NTuple{N, Symbol}, key::Symbol) where N =
    map(x -> x == key, tuple)


According to the definition in #414, further discussed in #14324, it seems so:

julia> which_key(tuple::NTuple{N, Symbol}, key::Symbol) where N =
           map(x -> x == key, tuple)
which_key (generic function with 1 method)

julia> a1 = (:x,:y,:z); a2 = (:x,:y,:z);

julia> k1 = :x; k2 = :x;

julia> a1 === a2

julia> k1 === k2

julia> which_key(a1, k1) === which_key(a2, k2)

But I see you commented on that second issue, so I doubt this comment is of any use to you!


I would generally discourage using the @pure annotations. It’s primary usage is for inference and it is hard to use correctly.


You need the @pure annotation here to get constant propagation.


It’s true that it is computing a pure result, since we can inline the map call to create an equivalent function that makes it more apparent that we’re only using pure functions:

which_key(tuple::Tuple{}, key::Symbol) = ()
which_key(tuple::Tuple{Vararg{Symbol}}, key::Symbol) =
    (first(tuple) === key, which_key(Base.tail(tuple), key)...)

Although, if you try code_typed on this, you’ll soon discover that IPO constant-propagation gets disabled by recursion, so I’d guess that probably doesn’t help as much as you might have liked. (and after several minutes of playing with this, I can say that it’s surprisingly hard to bypass that heuristic – which is nice since it means that at least it’s fairly robust to style changes.)

In the end, I decided the most feasible way to bypass it was just to give in and use a generated function after moving everything into the type-domain, so, um, yeah, this:

which_key4(tuple::NTuple{N, Symbol}, key::Symbol) =
    _which_key4(Val(tuple), Val(key))
_which_key4(::Val{tuple}, ::Val{key}) where {tuple, key} =
    ntuple(i -> tuple[i] === key, Val(length(tuple)))

An even more minimal implementation (e.g. the same as above after more manual inlining):

which_key(tuple::Tuple{Vararg{Symbol}}, key::Symbol) =
    _which_key(key, tuple...)
_which_key(key::Symbol) = ()
Base.@pure _which_key(key::Symbol, first::Symbol, tail...) =
    (first === key, _which_key(key, tail...)...)


Ok, great! Since I have an expert here, to get constant propagation to work recursively, I need to define my own tail function:

Base.@pure argtail(x, rest...) = rest
tail(x) = argtail(x...)

Again, a @pure annotation is necessary here, even though argtail seems very pure.


Also, would it be kosher to take off the type restrictions?

Base.@pure which_key(tuple::Tuple, key) where N =
    map(x -> x == key, tuple)


No, it’s not pure without the restrictions.

It seems like argtail just needs an update to the inference code