Convenience functions for vals

[bramtayl]

No description provided.

[ararslan]

This isn't correct. T can be Array{S,N}, in which case eltype(Val{Array{S,N}}) should be S. I'd instead make this eltype(::Val{T}) where {T} = eltype(T).

[bramtayl]

Hmm maybe eltype isn't the right name for what I want. I just want a function that will turn Val{:a}() into :a

[GregPlowman]

However, might be consistent with this:

Julia-0.7.0-DEV> x = Vector{Array{Int,3}}()
0-element Array{Array{Int64,3},1}

Julia-0.7.0-DEV> eltype(x)
Array{Int64,3}

[JeffBezanson]

Val isn't a collection or the type of a collection so eltype is not appropriate here.

[bramtayl]

I mean I could just leave it out this PR, or choose another name? devalue?

[TotalVerb]

these methods seem to cover too many possibilities; I'd suggest to just write out all four combinations

[vtjnash]

Val shouldn't be used with booleans or places where you want to do computations.

[bramtayl]

Ive been using value algebra for significant performance gains in places like JuliennedArrays

[bramtayl]

Val shouldn't be used with booleans or places where you want to do computations.

Why

[vtjnash]

See previous attempts at doing this (#22518), the manual (https://docs.julialang.org/en/stable/manual/performance-tips/#Types-with-values-as-parameters-1), the equivalent discussions on lifting Nullablility, and discourse.

[bramtayl]

Sounds as if there is indeed a specific use case:

This might be worthwhile when the following are true:

> * You require CPU-intensive processing on each Car, and it becomes vastly more efficient if you know the Make and Model at compile time.
> * You have homogenous lists of the same type of Car to process, so that you can store them all in an Array{Car{:Honda,:Accord},N}.

[vtjnash]

No, that is saying the opposite: Val is useful for cases where you don't need to do arithmetic on it.

[bramtayl]

I'm not using this these functions to do arithmetic though...

[bramtayl]

If by arithmetic you mean repeated functions on different values. Instead, I'm doing the same function on the exact same list of values repeatedly.

[JeffBezanson]

I agree with @vtjnash that these cases should be handled by compiler constant folding instead of manually using Val. In particular ifelse shouldn't be necessary; if you have Val{x} then ifelse(x, ...) should already get constant folded.

[bramtayl]

It doesn't seem to be working though?

devalue(x::Val{T}) where T = T

Base.ifelse(switch::Val, new, old) = ifelse(devalue(switch), new, old)

tuple_mismatch_error(t...) = error("Mismatched tuples: leftovers $(t...)")

Base.getindex(into::Tuple{}, index::Tuple{}) = ()
Base.getindex(into::Tuple, index::Tuple{}) = tuple_mismatch_error(into)
Base.getindex(into::Tuple{}, index::Tuple) = tuple_mismatch_error(index)
Base.getindex(into::Tuple, index::Tuple) = begin
    next = getindex(tail(into), tail(index))
    ifelse(first(index), (first(into), next...), next)
end

@code_warntype getindex((1, "a", 3), (Val{true}(), Val{false}(), Val{true}()))

[bramtayl]

My follow-up pull request was going to be a type stable getindex and setindex for tuples.

[bramtayl]

Both of which will be needed for a type-stable mapslices.

[Cody-G]

I've also worked on this before, and I had trouble finding a way to get constant folding to work in the way that's necessary for a package like @bramtayl's JuliennedArrays (which already works well). I've also read the manual and any relevant issues/discourse discussions that I can find, and I'm very interested to learn what is the proper way to do this with Julia v0.7 master.

[bramtayl]

Constant folding seems very incomplete. Here's another example where constant folding is not working as expected so value wrapping is necessary:

devalue(::Val{T}) where T = T
value_wrap(f) = (x, args...) -> Val(f(devalue(x), args...))

fieldtypes(any) = fieldtypes(Val(any))
function fieldtypes(val_type::Val)
    Base.@pure inner_function(i) = value_wrap(fieldtype)(val_type, i)
    ntuple(inner_function, value_wrap(nfields)(val_type))
end

# doesn't constant fold
fieldtypes(atype) =
    ntuple(nfields(atype)) do
        fieldtype(atype, i)
    end

[bramtayl]

Am I correct in my understanding that constant propagation cannot survive passing through functions not known to the compiler as pure? If so, it severely limits the usefulness of constant propagation.

[bramtayl]

My understanding is that this is a non-issue with the now aggressive constant propogation