Mfrhtyj

c++14 introduced generic lambdas that made it possible to write following:

auto func = (auto a, auto b){

    return a + b;

};

auto Foo = func(2, 5);

auto Bar = func("hello", "world");

It is very clear that this generic lambda func works just like a templated function func would work.

Why did the C++ committee decide to add template syntax for generic lamda?

C++14 generic lambdas are a very cool way to generate a functor with an operator () that looks like this:

template <class T, class U>

auto operator()(T t, U u) const;

But not like this:

template <class T>

auto operator()(T t1, T t2) const; // Same type please

Nor like this:

template <class T, std::size_t N>

auto operator()(std::array<T, N> const &) const; // Only `std::array` please

Nor like this (although this gets a bit tricky to actually use):

template <class T>

auto operator()() const; // No deduction

C++14 lambdas are fine, but C++20 allows us to implement these cases without hassle.

Since you can use templated lambdas in C++20, you can restrict your types in an easier way than an SFINAE expression:

auto lambda = <typename T>(std::vector<T> t){};

This lambda will work only with vector types.

The proposal that was accepted into C++20 has a lengthy motivation section, with examples. The premise of it is this:

There are a few key reasons why the current syntax for defining
generic lambdas is deemed insufficient by the author. The gist of it is
that some things that can be done easily with normal function templates
require significant hoop jumping to be done with generic lambdas, or
can’t be done at all.The author thinks that lambdas are valuable
enough that C++ should support them just as well as normal function
templates.

Following that are quite a few examples.

The new "familiar template syntax" for lambdas introduced in C++20
makes constructs such as for_types and for_range viable and way more
readable compared to C++17 alternatives.

(source: compile-time iteration with C++20 lambdas)

Another interesting thing that can be done on both C++14 and C++17 generic lambdas is directly calling operator() by explicitly passing a template parameter:

C++14:

   auto l = (auto){ };

   l.template operator()<int>(0);

C++20:

  auto l = <typename T>(){ };

  l.template operator()<int>();

The C++14 example above is quite useless: there's no way of referring to the type provided to operator() in the body of the lambda without giving the argument a name and using decltype. Additionally, we're forced to pass an argument even though we might not need it.

The C++20 example shows how T is easily accessible in the body of the lambda and that a nullary lambda can now be arbitrarily templated. This is going to be very useful for the implementation of the aforementioned compile-time constructs