C++ specialize a lambda for a certain type

Question

I was playing around with the lambda "overloading" as presented here, and quickly came to the point where I'd find it convenient to create specialized lambda closures. So I was first trial-and-error'ing a bit, with my most promising trial being

auto call_for_vector = [] template<typename T> (std::vector<T>) {};

However, a later look at the cppreference showed that neither this nor similar constructs seem to be allowed by the standard.

What is the reason why such specializations are not supported?

I know one can obtain this behaviour using SFINAE, but then it's less readable, harder to write and more error prone. Of course one can also simpy write a class with an appropriate operator(), but this is soo C++03 :-)

What use would be for such a syntax?:

One example, this would allow for an easy lambda "overload" like in the following code

template <class F1, class F2>
struct overload_set : F1, F2
{
    overload_set(F1 x1, F2 x2) : F1(x1), F2(x2) {}
    using F1::operator();
    using F2::operator();
};

template <class F1, class F2>
overload_set<F1,F2> overload(F1 x1, F2 x2)
{
    return overload_set<F1,F2>(x1,x2);
} 

auto f = overload(
         [](auto&& x){ std::cout<<"call by default"<<std::endl;},
         [] template<typename T>(std::vector<T>){std::cout<<"call for vector"<<std::endl;}
         );

One can obtain this behaviour e.g. by using SFINAE base on the technique in this answer, but again ... this sucks.

Is there an easy workaround to SFINAE for obtaining specific overloads?

well I guess you are familliar with std::function, which is the way to work with lasting functions. I guess lambdas are volatile in the sense that the standard wouldn't want you to store them as is — David Haim, Feb 14 '16 at 15:41
@David Haim: the above doesn't work with `std::function` either, as it needs a definite signature. — davidhigh, Feb 14 '16 at 15:43
you can templatetize std::function, `template std::function` you cannot do that with a lambda — David Haim, Feb 14 '16 at 15:46
@DavidHaim: yes, one can do `template std::function)> call_for_vector = [](auto x){};`, that's a variable template. But one needs to specify the type when calling it, e.g. `call_for_vector()`. As far I can see this doesn't help in the scenario above. — davidhigh, Feb 14 '16 at 15:52
Isn't `[](std::vector){}` what "concepts" are supposed to support ? — Piotr Skotnicki, Feb 14 '16 at 16:09
@PiotrSkotnicki: I also tried this and it would make sense to me from the standard excerpt in [this answer](http://stackoverflow.com/a/17233649/2412846): "For a generic lambda, the closure type has a public inline function call operator member template (14.5.2) whose template-parameter-list consists of one invented type template-parameter for each occurrence of auto in the lambda’s parameter-declaration-clause, in order of appearance." So when `auto` becomes a template parameter, then `(std::vector)` could be translated into `template operator()(std::vector)`. — davidhigh, Feb 14 '16 at 16:22
@davidhigh http://en.cppreference.com/w/cpp/language/constraints#Abbreviated_templates — Piotr Skotnicki, Feb 14 '16 at 18:19
I'd hate to close this as a dup (since you're reading my blog :P ) but I've been wondering the same thing [here](http://stackoverflow.com/q/31195156/2567683). Could you maybe rephrase and add "what use would there be for such a syntax", I might have a tiny piece of code that would be of interest — Nikos Athanasiou, Feb 20 '16 at 20:06
@NikosAthanasiou: Edited. Feel free to mark it what it is, but only after your answer ... your blog is good anyways ;-) — davidhigh, Feb 20 '16 at 20:28
@davidhigh It's ok now, since you ask the "what for"s apart from the "why"s — Nikos Athanasiou, Feb 20 '16 at 20:40

score 2 · Accepted Answer · edited May 23 '17 at 12:07

2

This type of coding may seem superfluous at first but there are some nice properties we can take advantage of. Regarding the post you mention, I was planning on a part 2, where I'd showcase a neat way of checking whether a type has a specific member (function or data). Say you want to check for a serialize member function; instead of using complicated mechanisms I discovered it gets as easy as :

auto hs = overload( 
    [ ](auto&& x) -> decltype(x.serialize(2), std::true_type{}) { 
        return{}; },       // ^^ this guy ^^ 
    [ ](...) -> std::false_type { return {}; });

demo

The specifics of standardese evolution can be found here, but the reason I posted this is to advocate for such a syntax which, had we have had it, the above could be extended to allow partial ordering among "overloaded" generic lambdas :

auto do_something = overload( 
    [ ]<class X>(shared_ptr<X> x) -> decltype(x.serialize(2), std::true_type{}) { 
        /*do something specific for shared ptrs of X */ return{}; },      
    [ ]<class X>(X& x) -> decltype(x.serialize(2), std::true_type{}) { 
        /*do a generic operation for other types that have serialize*/return{}; },      
    [ ](...) -> std::false_type { /*do nothing*/ return {}; });

edited May 23 '17 at 12:07

Community

1
1

answered Feb 20 '16 at 20:35

Nikos Athanasiou

29,616
15
87
153

2

ah, yes, so sfinae, but the modern (and shorter) way ... – davidhigh Feb 20 '16 at 20:37
could you add the reference to your other answer? I'd give it a hook then, and then let's close this thread in a large celebration as duplicate. – davidhigh Feb 20 '16 at 20:39
@davidhigh I have no other answer, I just made a similar q – Nikos Athanasiou Feb 20 '16 at 20:44
sorry, I meant [this question](http://stackoverflow.com/questions/31195156/is-or-will-be-the-use-of-familiar-template-syntax-in-lambda-expressions-allowe) ... so nobody misses it. – davidhigh Feb 20 '16 at 21:33
@davidhigh OK , will do – Nikos Athanasiou Feb 20 '16 at 22:43

C++ specialize a lambda for a certain type

1 Answers1