template lambdas

C++20 позволяет лямбде объявлять явный шаблонный параметр в угловых скобках перед списком аргументов: []<class T>(T x) { ... } вместо неявного [](auto x) { ... } из C++14 (см. ../cpp14/generic-lambdas.html). Явный параметр даёт доступ к имени типа T прямо внутри тела лямбды — полезно для T{}-конструкций значения по умолчанию, sizeof(T), std::is_same_v<T, int> и подобных случаев, где нужен именно тип, а не просто значение параметра. Фича также поддерживает variadic template-параметры: []<class... Ts>(Ts... args) { ... }.C++20 lets a lambda declare an explicit template parameter in angle brackets before its argument list: []<class T>(T x) { ... } instead of C++14's implicit [](auto x) { ... } (see ../cpp14/generic-lambdas.html). The explicit parameter gives access to the name of type T directly inside the lambda's body — useful for T{} default-value construction, sizeof(T), std::is_same_v<T, int>, and similar cases that need the type itself, not just the parameter's value. The feature also supports variadic template parameters: []<class... Ts>(Ts... args) { ... }.

auto make_default = [](auto x) {
    using T = decltype(x);   // обходной путь, чтобы получить имя типа// a workaround to obtain the type's name
    return T{};
};
// не работает, если тип нужен без значения параметра// doesn't work if the type is needed without a parameter value

auto make_default = []<class T>(T x) {
    return T{};   // T доступен напрямую по имени// T is directly accessible by name
};

// variadic template-параметры лямбды:// variadic lambda template parameters:
auto sum_all = []<class... Ts>(Ts... args) {
    return (args + ...);
};

Как и C++14 generic lambda, лямбда с явным шаблонным параметром компилируется в замыкание с шаблонным operator() — сам механизм генерации кода не меняется. Разница исключительно в синтаксисе объявления шаблонного параметра: вместо того чтобы компилятор сам придумывал безымянный параметр шаблона для каждого auto, программист называет его явно в угловых скобках перед списком параметров функции, ровно как в обычном шаблоне.Like a C++14 generic lambda, a lambda with an explicit template parameter compiles down to a closure with a templated operator() — the underlying code-generation mechanism doesn't change. The difference is purely syntactic: instead of the compiler inventing an unnamed template parameter for each auto, the programmer names it explicitly in angle brackets before the function's parameter list, exactly as in an ordinary template.

// исходный код:// source code:
auto l = []<class T>(T x) { return sizeof(T) + sizeof(x); };

// компилятор генерирует эквивалент (концептуально):// the compiler generates the equivalent (conceptually):
struct __lambda_2 {
    template <class T>
    auto operator()(T x) const { return sizeof(T) + sizeof(x); }
};

// с C++14 auto-параметром пришлось бы писать так:// with a C++14 auto parameter you'd have had to write:
auto l2 = [](auto x) {
    using T = decltype(x);
    return sizeof(T) + sizeof(x);   // тот же результат, но опосредованно// the same result, but indirectly
};

Явный параметр T особенно окупается, когда он нужен не для вывода из значения аргумента, а как самостоятельная сущность внутри тела — например, для построения std::vector<T> из отдельных элементов типа T, или как ограничение через concept прямо в списке шаблонных параметров лямбды, без отдельного requires-предложения:The explicit parameter T pays off especially when it's needed not by deducing it from an argument value but as a first-class entity inside the body — for instance, to build a std::vector<T> out of individual elements of type T, or as a concept constraint written directly in the lambda's template parameter list, with no separate requires clause:

// T используется для std::vector<T> в теле, не только для типа параметра:// T is used for std::vector<T> in the body, not just as the parameter's type:
auto repeat_n = []<class T>(T value, std::size_t n) {
    return std::vector<T>(n, value);   // с decltype(value) пришлось бы вводить лишний using// with decltype(value) an extra using would be needed
};

// constraint через concept прямо на параметре лямбды:// a concept constraint directly on the lambda's parameter:
auto safe_divide = []<std::integral T>(T a, T b) {
    return b != 0 ? a / b : T{0};
};
// safe_divide(1.5, 2.0) — ошибка компиляции: double не удовлетворяет std::integral// safe_divide(1.5, 2.0) — compile error: double doesn't satisfy std::integral

• cppreference — Lambda expressions (раздел Template parameter list)(Template parameter list section)
• WG21 P0428 — Familiar template syntax for generic lambdas