Reduced to get rid of library dependencies:

template <typename Return, typename... ArgTypes>
    struct function
    {
        template<typename Functor> function(Functor) { }
    };

template <typename Return, typename FirstType, typename... ArgTypes>
    int
    curry(function<Return(FirstType,ArgTypes...)> func, FirstType)
    {
        return 0;
    }


int main()
{
    return curry( [](int x) -> double { return static_cast<double>(x); }, 10 );
}

Thanks Jon, let's add Jason in CC.

The error is not bug because C++0x Lambda is not a std::function (or boost::function and so on...).
C++0x Lambda is a unique, unnamed non-union class type. (written in n3126, 5.1.2.3. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3126.pdf)

Therefore compiler is unable to deduce template parameters that are Return, FirstType and ArgTypes.

If you want to call function with implicitly template arguments deduction, you should use variable, cast or constructor call like following code.

example:
  int main()
  {
    // using variable
    function< double( int ) > f = []( int x ) { return static_cast< double >( x ); };
    curry( f, 10 );

    // or casting
    curry( static_cast< function< double( int ) > >( []( int x ) { return static_cast< double >( x ); } ), 10 );

    // or calling constructor
    curry( function< double( int ) >( []( int x ) { return static_cast< double >( x ); } ), 10 );
  }

(In reply to comment #3)
> 
> Therefore compiler is unable to deduce template parameters that are Return,
> FirstType and ArgTypes.

Right, the lambda can be converted to double(*)(int) but that doesn't help. 

There is no valid conversion sequence that allows the compiler to deduce the template arguments.

Here's a version without a lambda:

template <typename Return, typename... ArgTypes>
    struct function
    {
        template<typename Functor> function(Functor) { }
    };

template <typename Return, typename FirstType, typename... ArgTypes>
    int
    curry(function<Return(FirstType,ArgTypes...)> func, FirstType)
    {
        return 0;
    }

double f(int x) { return static_cast<double>(x); }

int main()
{
    return curry( f, 10 );
}

And here's an even simpler version without variadic templates or any other C++0x features:

template <typename R>
    struct function
    {
        template<typename F> function(F) { }
    };

template <typename R>
    int
    curry(function<R> func)
    {
        return 0;
    }

double f(int x) { return x; }

int main()
{
    return curry( f );
}


G++ is correct to reject this, there's no way to deduce R

I think I did a bad job describing the issue, and I think that it's still a problem. I'd like to clarify it if I can. The following code works:

    template <typename Return, typename... Args> 
    int curry(function<Return(double)> func) // NOTE: double
    { 
        return 0; 
    } 

    int f(double x) 
    { 
        return 0; 
    } 

    int main() 
    { 
        curry<int, double>(f); 
    }

While this does not:

    template <typename Return, typename... Args> 
    int curry(function<Return(Args...)> func) // NOTE: Args...
    { 
        return 0; 
    } 

    int f(double x) 
    { 
        return 0; 
    } 

    int main() 
    { 
        curry<int, double>(f); 
    }

Even though the template parameter pack Args expands to double, GCC is unable to match f to the type function<int(double)> if I use Args..., where it was able to with the first example where I used double explicitly.

This is the error I receive:

    error: no matching function for call to ‘curry(int (&)(double))’

Thanks for your time.

(In reply to comment #6)
> Even though the template parameter pack Args expands to double, GCC is unable
> to match f to the type function<int(double)> if I use Args..., where it was
> able to with the first example where I used double explicitly.

It seems different issue. At least initially report is not a bug.

You should write new bug report, correct this report or find similar bug reports.

Most simple issue code is following:

template < typename... >
struct S
{
    S( int );
};

template < typename... T >
void f( S< T... > );

void g( void )
{
    f< int >( 0 );
}

(In reply to comment #6)
> I think I did a bad job describing the issue, and I think that it's still a
> problem. I'd like to clarify it if I can. The following code works:
> 
>     template <typename Return, typename... Args> 
>     int curry(function<Return(double)> func) // NOTE: double

Here, Args can never be deduced, so must be given explicitly.

>     { 
>         return 0; 
>     } 
> 
>     int f(double x) 
>     { 
>         return 0; 
>     } 
> 
>     int main() 
>     { 
>         curry<int, double>(f); 

Args... must be {double}
It is not possible to call curry() without giving all template args, so the compiler knows that the only viable specialisation is where Args...=double


>     }
> 
> While this does not:
> 
>     template <typename Return, typename... Args> 
>     int curry(function<Return(Args...)> func) // NOTE: Args...

Here Args... appears in a parameter and can be deduced.

>     { 
>         return 0; 
>     } 
> 
>     int f(double x) 
>     { 
>         return 0; 
>     } 
> 
>     int main() 
>     { 
>         curry<int, double>(f); 
>     }
> 
> Even though the template parameter pack Args expands to double, GCC is unable
> to match f to the type function<int(double)> if I use Args..., where it was

How does it know the template parameter pack expands to double? Maybe it expands to {double,T} and you want T to be deduced. Or maybe {double,T,U}

If you passed a function<int(double)> it could deduce Args, but passing f requires a user-defined conversion to an unknown type, so deduction cannot succeed.

Jonathan, you're absolutely right. After some patient explanation by Johannes Schaub (litb) and Eelis van der Weegen (eelis) on IRC (FreeNode/##C++), I realize that GCC's behaviour here is standards-compliant. (Johannes directed me to 14.8.1/9 and 14.8.1/6 and 14.8.2.1/4 of n3126).

Standards-compliant behaviour.