Why can't I pass lambda in constructor with user-defined deduction guide?

Question

I'm trying to create a proxy class for a function which takes Message as parameter.

template<typename MsgType>
using SendFunctor = void(*)(MsgType&);

struct Message {};

template<typename T>
struct Test {
    Test(T t) {
        Message msg;
        t(msg);
    }
};

template<typename MsgType>
Test(SendFunctor<MsgType>) -> Test<SendFunctor<MsgType>>;

Inside main then I simply declare a variable and everything works fine both with free functions and lambda

Test test([](Message&) { std::cout << "Hello2" << std::endl; });

However, after adding another template parameter to Test and modifying the deduction guide

template<typename MsgType, typename T>
struct Test {
    Test(T t) {
        Message msg;
        t(msg);
    }
};

template<typename MsgType>
Test(SendFunctor<MsgType>) -> Test<Message, SendFunctor<MsgType>>;

// or what I really want to achieve
// template<typename MsgType>
// Test(SendFunctor<MsgType>) -> Test<MsgType, SendFunctor<MsgType>>;

I got an error class template argument deduction failed. In fact, everything works fine if I pass a free function to the constructor.

Can someone please explain to me, why lambda here breaks the entire deduction? And how can I fix this?

Answer 1

it doesn't work in the first case either, you're using the default deduction guide.

---

when you're writing

Test test([](Message&) { std::cout << "Hello2" << std::endl; });

it's actually deduced to

Test<some_lambda_type> test([](Message&) { std::cout << "Hello2" << std::endl; });

---

You can write

Test test(+[](Message&){}); // + : convert it to function pointer

and both case should works.

Answer 2

Lambdas without captures can implicitly be converted to function pointers, so other answers are wrong in that regard.

The problem is that the compiler cannot infer a template parameter from the lambda's argument's type. Think of it that way, if you passed a generic lambda (taking auto as an argument), what should be deduced?

Your example works fine, the only problem is the template deduction. You can static_cast your lambda manually to SendFunctor<Message> and it works as expected (https://godbolt.org/z/K5eveEM3c).

Answer 3

lambda expression are objects (the type of that object is temporary defined by the compiler and any lambda has a different type) for which the compiler defines an operator(). In short there's no implicit conversion from lambda type to function pointer. In these cases I prefer to use std::function which has an adequate constructor to handle lambda expressions.

So a possible solution would be replace raw function pointer with std::function and encapsulate the lambda expression in a std::function to be passed to the constructor.

#include <functional>
#include <iostream>

template<typename MsgType>
using SendFunctor = std::function<void(MsgType&)>;

template<typename MsgType>
struct Test {
    Test(SendFunctor<MsgType> t) {
        MsgType msg;
        t(msg);
    }
};

struct Message {};

template<typename MsgType>
Test(SendFunctor<MsgType>) -> Test<Message>;

int main()
{
    SendFunctor<Message> f = [](Message&) { std::cout << "Hello2" << std::endl; };
    Test test(f);
}

here's a live test

---- EDIT

Playing around a bit, I also solved the ambiguity in your deduction guide by using a struct helper to deduce the argument that takes a lambda expression, thanks to this answer which you can read for completeness.

here's the helper struct deducing the argument type of a lambda.

template<class C>
struct Get_LambdaFirstArg;

template<class C, class R, class Arg>
struct Get_LambdaFirstArg<R(C::*)(Arg&)const>{
    using type = Arg;
};
template<class C, class R, class Arg>
struct Get_LambdaFirstArg<R(C::*)(Arg&)>{
    using type = Arg;
};

Here's the new deduction guide defined to handle lambda expressions.

template<typename LambdaType>
Test(LambdaType) -> Test<typename Get_LambdaFirstArg<decltype(&LambdaType::operator())>::type>;

and here's a minimal example:

#include <functional>
#include <iostream>

template<typename MsgType>
using SendFunctor = std::function<void(MsgType&)>;

template<typename MsgType>
struct Test {
    Test(SendFunctor<MsgType> t) {
        MsgType msg;
        t(msg);
    }
};

template<class C>
struct Get_LambdaFirstArg;

template<class C, class R, class Arg>
struct Get_LambdaFirstArg<R(C::*)(Arg&)const>{
    using type = Arg;
};
template<class C, class R, class Arg>
struct Get_LambdaFirstArg<R(C::*)(Arg&)>{
    using type = Arg;
};



struct Message {};

template<typename MsgType>
Test(SendFunctor<MsgType>) -> Test<Message>;

template<typename LambdaType>
Test(LambdaType) -> Test<typename Get_LambdaFirstArg<decltype(&LambdaType::operator())>::type>;

int main()
{
    Test test([](Message&) { std::cout << "Hello2" << std::endl; });
}

and here's a live test of that example.

-- EDIT finally i better tested the answer of @apple apple and it seems I was doing something wrong. Using the + to convert lambda to function pointer and solves the ambiguity in your deduction guide.