Use of invoke with parametric types

[willtebbutt]

Suppose I have a function foo with methods whose signatures are

foo(x::Real, y::Real)
foo(x::Number, y::Number)

and I wish to invoke the 2nd method from within the 1st. In this case we could define the first method as follows to achieve the desired behaviour:

function foo(x::Real, y::Real)
    # Do stuff specific to Reals, whatever that happens to be.
    invoke(foo, Tuple{Number, Number}, x, y)
end

Now suppose we had instead defined methods with the following signatures:

foo(x::T, y::T) where T<:Real
foo(x::T, y::T) where T<:Number

The seemingly natural thing to do is to invoke using the appropriate UnionAll:

function foo(x::T, y::T) where T<:Real
    # Do stuff specific to pairs of Reals.
    invoke(foo, Tuple{V, V} where V<:Number, x, y)
end

However, this doesn't appear to work, yielding the following error:

ERROR: TypeError: foo: in invoke, expected Type, got Type{Tuple{V,V} where V<:Number}

Tested on both

Julia Version 0.6.0
Commit 903644385b (2017-06-19 13:05 UTC)

and

Julia Version 0.7.0-DEV.730
Commit c2c37ef8c5 (2017-06-26 07:41 UTC)

to make sure I hadn't missed a change.

[JeffBezanson]

Yes, this capability is missing. There are still some code paths left that assume the type to look up is a direct Tuple type, but this can be fixed.

[jekbradbury]

Is there a general way to ask something like "which method would have been invoked, given these arguments, if this method didn't exist?"

[willtebbutt]

As it happens, I was trying to do exactly that when I ran into the above issue. I haven't found a solution that doesn't involve writing some code to examine the method table to determine which method is the next most specific, and then using invoke with whichever method is found's signature.