How to extract type parameters that are used as upper bounds in `UnionAll`?

[frankwswang]

MWE:

julia> const DictPar{T, V} = Dict{T, <:V}
Dict{T, <:V} where {T, V}

julia> getPar(::Type{D}) where {T, V, D<:DictPar{T, V}} = (T, V)
getPar (generic function with 1 method)

julia> d = DictPar{Int, Real}
Dict{Int64, <:Real}

julia> getPar(d)
ERROR: UndefVarError: `V` not defined in static parameter matching
Suggestion: run Test.detect_unbound_args to detect method arguments that do not fully constrain a type parameter.

Is there a workaround to get V, assuming I don’t have access to instances of d but only d itself?

Thanks!

[nsajko]

I don’t think this is possible to achieve in a supported way. Some previous discussion:

Is there a way to capture an upper bound via dispatch?

As part of the logic of writing some function, I’d like to use the upper bound of some passed-in type’s argument. Is there any way to capture this upper bound cleanly via dispatch? Basically, I’d like the following: struct Foo{T<:Real} end capture_upper_bound(Foo{Real}) # should return Real capture_upper_bound(Foo{<:Real}) # should return Real capture_upper_bound(Foo{<:Int}) # should return Int capture_upper_bound(Foo{<:Number}) # should be a method error The following definition of c…

Deconstructing UnionAll types

The following naive definition is invalid, but you don’t realize it until you try it: julia> f(::Type{Set{<:W}} where W) = W f (generic function with 4 methods) Here goes… julia> f(Set{<:Integer}) ERROR: UndefVarError: `W` not defined I can get the functionality I wanted with a hack: julia> f_hack(t::Type{Set{<:W}} where W) = t.var.ub f_hack (generic function with 1 method) julia> f_hack(Set{<:Integer}) Integer So how do I do this with public API?

AFAIK, in Julia’s dispatch logic, a method static parameter must be uniquely determined, with it’s lower bound equal to its upper bound, to be defined in the method body. So “extracting an upper bound” seems like something that would require additional language features.