1383 – Implicit Function Instantiation with typesafe-variadic of delegates doesn't work

I have a template function, with a single Tuple template parameter, where the arguments to the function are typesafe variadic delegates, where each delegate takes arguments defined by the Tuple. It will not implicitly deduce the elements of the Tuple:
CODE
================
/* parts of Curry() taken from the digitalmars.com template examples */
void delegate(U) Curry(A, U...)(void delegate(A,U) dg,A arg)
{
 struct ArgRecord {
 A arg;
 typeof(dg) callback;
 void OpCall(U args) { callback(arg,args); }
 }
 auto temp = new ArgRecord;
 temp.arg = arg;
 temp.callback = dg;
 return &temp.OpCall;
}
/* the intent of this template is to take 2 or more delegates with the
 * the same argument types and return a new delegate which will call
 * each delegate in sequence, passing it the arguments delivered.
 */
void delegate(A) Seq(A...)(void delegate(A)[] dgs...)
{
 return Curry(delegate void(void delegate(A)[] dgs1,A args)
 {
 foreach(dg; dgs1)
 dg(args);
 },
 dgs);
}
struct Foo {
 void fred(int i) {}
}
void main() {
 void delegate(int) tmp;
 auto bob = new Foo;
 auto dan = new Foo;
 tmp = Seq!(int)(&bob.fred); // this works
 tmp = Seq!(int)(&bob.fred, &dan.fred); // this works
 tmp = Seq (&bob.fred); // this doesn't
 tmp = Seq (&bob.fred, &dan.fred); // neither does this
}
=========
DMD OUTPUT:
=========
baz.d(45): template baz.Seq(A...) does not match any template declaration
baz.d(45): template baz.Seq(A...) cannot deduce template function from argument types (void delegate(int))
baz.d(45): Error: cannot implicitly convert expression ((Seq(A...))((&(*bob).fred))) of type int to void delegate(int)
baz.d(46): template baz.Seq(A...) does not match any template declaration
baz.d(46): template baz.Seq(A...) cannot deduce template function from argument types (void delegate(int),void delegate(int))
baz.d(46): Error: cannot implicitly convert expression ((Seq(A...))((&(*bob).fred),(&(*dan).fred))) of type int to void delegate(int)
Note that the template works fine if I explicitly instantiate it.

Actually it's much simpler than all that. IFTI with plain old typesafe variadic doesn't work.
void foo(T)(T[] x ...) {
}
void main() {
 foo(2,7,4);
}
iftivariadic.d(23): template iftivariadic.foo(T) does not match any function template declaration
iftivariadic.d(23): template iftivariadic.foo(T) cannot deduce template function from argument types !()(int,int,int)

Fixed dmd 1.031 and 2.015

Fix confirmed.