Feature Request: Have a way to specialize on Type without making the argument restricted to Types only

[schlichtanders]

Because of this current julia bug #23618 it is often needed to explicitly demand for argument specialization for types like myfunc(thisshouldspecializeontypes::Type{T}) where T. The documentation states this clearly.

However this approach makes the argument only dispatch on Types. It would be very helpful to allow for marking an argument to also specialize on types, while still staying a generic argument.

There is currently no way to do so, however the current workaround is code duplication (or the use of a macro respectively). You need to create one function clause for the ::Type{T} case and one for the generic argument. Of course, all code needs to be duplicated, which relies on the argument specialization for types.

As an alternative to this code duplication, I want to suggest adding a macro similar to @nospecialize, named e.g. @specializetype which can be simply prepended to the respective argument and makes it work like a normal argument, but with specialization on types.

On discourse, some have responded that there wouldn't be a need for a generic argument which specializes on Types. I strongly disagree. Because of the above bug, any closure which may refer to a Type needs explicit specialization as of now. The use of closures for me is generic coding and should not require a special case for types.

julia version 1.7.1

[JeffBezanson]

f(x::T) where T does this. The documentation should be cleared up here; basically you want f(x::T) instead of f(x) or f(x::Type{T}) instead of f(x::Type).

[schlichtanders]

Hi @JeffBezanson that would be great, but unfortunately it does not work.

Here an example with all three cases:

myconvert(T, value) = T(value)

function outerfunc1(type, value)
    innerfunc(x) = myconvert(type, x)
    innerfunc(value)
end
function outerfunc2(type::T, value) where T
    innerfunc(x) = myconvert(type, x)
    innerfunc(value)
end
function outerfunc3(::Type{type}, value) where type
    innerfunc(x) = myconvert(type, x)
    innerfunc(value)
end

and here the test:

using Test
tostring(a) = "$a"

@inferred outerfunc1(tostring, 1) # "1"
@inferred outerfunc2(tostring, 1) # "1"
@inferred outerfunc3(tostring, 1) # MethodError

@inferred outerfunc1(Symbol, 1) # ERROR: return type Symbol does not match inferred return type Any
@inferred outerfunc2(Symbol, 1) # ERROR: return type Symbol does not match inferred return type Any
@inferred outerfunc3(Symbol, 1) # Symbol(1)

[schlichtanders]

@JeffBezanson can you please update the tags of this issue? To the best of my understanding (please see the example above) this is not a documentation issue

[adienes]

infers correctly on 1.12

also: my current understanding is that Type{T} where T is not legal #58899 (comment)