Csdrhrt

I implemented a Visit function (on a variant) that checks that the currently active type in the variant matches the function signature (more precisely the first argument). Based on this nice answer.
For example

#include <variant>

#include <string>

#include <iostream>



template<typename Ret, typename Arg, typename... Rest>

Arg first_argument_helper(Ret(*) (Arg, Rest...));



template<typename Ret, typename F, typename Arg, typename... Rest>

Arg first_argument_helper(Ret(F::*) (Arg, Rest...));



template<typename Ret, typename F, typename Arg, typename... Rest>

Arg first_argument_helper(Ret(F::*) (Arg, Rest...) const);



template <typename F>

decltype(first_argument_helper(&F::operator())) first_argument_helper(F);



template <typename T>

using first_argument = decltype(first_argument_helper(std::declval<T>()));



std::variant<int, std::string> data="abc";

template <typename V>

void Visit(V v){

using Arg1 = typename std::remove_const_t<std::remove_reference_t<first_argument<V>>>;//... TMP magic to get 1st argument of visitor + remove cvr, see Q 43526647

if (! std::holds_alternative<Arg1>(data)) {

std::cerr<< "alternative mismatchn";

return;

}

v(std::get<Arg1>(data));

}

int main(){

    Visit((const int& i){std::cout << i << "n"; });

    Visit((const std::string& s){std::cout << s << "n"; });

    // Visit((auto& x){}); ugly kabooom

}

This works, but it explodes with a user unfriendly compile time error when users passes a generic (e.g. (auto&){}) lambda. Is there a way to detect this and give nice static_assert() about it?
Would also be nice if it worked with function templates as well, not just with lambdas.

Note that I do not know what possible lambdas do, so I can not do some clever stuff with Dummy types since lambdas may invoke arbitrary functions on types.
In other words I can not try to call lambda in 2 std::void_t tests on int and std::string and if it works assume it is generic because they might try to call .BlaLol() on int and string.

Is there a way to detect this and give nice static_assert about it?

I suppose you can use SFINAE over operator() type.

Follows an example

#include <type_traits>



template <typename T>

constexpr auto foo (T const &)

   -> decltype( &T::operator(), bool{} )

 { return true; }



constexpr bool foo (...)

 { return false; }



int main()

 {

   auto l1 = (int){ return 0; };

   auto l2 = (auto){ return 0; };



   static_assert( foo(l1), "!" );

   static_assert( ! foo(l2), "!" );

 }

Instead of a bool, you can return std::true_type (from foo() first version) or std::false_type (from second version) if you want to use it through decltype().

Would also be nice if it worked with function templates as well, not just with lambdas.

I don't think it's possible in a so simple way: a lambda (also a generic lambda) is an object; a template function isn't an object but a set of objects. You can pass an object to a function, not a set of objects.

But the preceding solution should works also for classes/structs with operator()s: when there is a single, non template, operator(), you should get 1 from foo(); otherwise (no operator(), more than one operator(), template operator()), foo() should return 0.

Yet another simpler option:

#include <type_traits>

...

template <typename V>

void Visit(V v) {

   class Auto {};

   static_assert(!std::is_invocable<V, Auto&>::value);

   static_assert(!std::is_invocable<V, Auto*>::value);

   ...

}

The Auto class is just an invented type impossible to occur in the V parameters. If V accepts Auto as an argument it must be a generic.

I tested in coliru and I can confirm the solution covers these cases:

Visit((auto x){}); // nice static assert

Visit((auto *x){}); // nice static assert

Visit((auto &x){}); // nice static assert

Visit((auto &&x){}); // nice static assert

I'm not sure if that would cover all the possible lambdas that you don't know which are :)

#include <variant>

#include <string>

#include <iostream>



template <class U, typename T = void>

struct can_be_checked : public std::false_type {};



template <typename U>

struct can_be_checked<U, std::enable_if_t< std::is_function<U>::value > >  :  public std::true_type{};



template <typename U>

struct can_be_checked<U, std::void_t<decltype(&U::operator())>> :  public std::true_type{};





template<typename Ret, typename Arg, typename... Rest>

Arg first_argument_helper(Ret(*) (Arg, Rest...));



template<typename Ret, typename F, typename Arg, typename... Rest>

Arg first_argument_helper(Ret(F::*) (Arg, Rest...));



template<typename Ret, typename F, typename Arg, typename... Rest>

Arg first_argument_helper(Ret(F::*) (Arg, Rest...) const);



template <typename F>

decltype(first_argument_helper(&F::operator())) first_argument_helper(F);



template <typename T>

using first_argument = decltype(first_argument_helper(std::declval<T>()));



std::variant<int, std::string> data="abc";





template <typename V>

void Visit(V v){

    if constexpr ( can_be_checked<std::remove_pointer_t<decltype(v)>>::value )

    {

        using Arg1 = typename std::remove_const_t<std::remove_reference_t<first_argument<V>>>;//... TMP magic to get 1st argument of visitor + remove cvr, see Q 43526647

        if (! std::holds_alternative<Arg1>(data)) 

        {

            std::cerr<< "alternative mismatchn";

            return;

        }

        v(std::get<Arg1>(data));

    }

    else

    {

        std::cout << "it's a template / auto lambda " << std::endl;

    }





}



template <class T>

void foo(const T& t)

{

    std::cout <<t << " foo n";

}



void fooi(const int& t)

{

    std::cout <<t << " fooi " << std::endl;

}



int main(){

    Visit((const int& i){std::cout << i << std::endl; });

    Visit((const std::string& s){std::cout << s << std::endl; });

    Visit((auto& x){std::cout <<x << std::endl;}); // it's a template / auto lambda*/

    Visit(foo<int>);



    Visit<decltype(fooi)>(fooi);

    Visit(fooi);                 





    // Visit(foo); // => fail ugly

}

I don't know if it's you want, but you can, with that static_assert if an auto lambda is passed as parameter.

I think it's not possible to do the same for template function, but not sure.