Is it possible to make a template variable in lambda signature generic?

Question

Suppose you have a function that takes a std::vector of any type and processes it in some way:

template<typename T>
void foo(std::vector<T> &vec) {
    // work with vec
}

Since C++14, we are able to achieve the same thing with lambdas. In this case, we call them generic lambdas, since we introduce a template-like deduction to them:

auto foo_lambda = [](std::vector<auto> &vec) {
    // work with vec
};

But our options seem quite limited to me. Suppose that I not only have to introduce a type deduction, but I also need to introduce template values. For example, let's change std::vector to std::array:

template<typename T, std::size_t size>
void foo(std::array<T, size> &arr) {
    // work with arr
}

When dealing with template functions, we are able to introduce a template value, which can be used to match argument's needs. Neat.

I wanted to achieve the same functionality with generic lambdas, but I was unable to do so.

Is there a way to introduce a similar, deduced value to a lambda expression so any std::arrays can be used with said lambda, similarily to the second version of the foo() function above?

EDIT: As stated in the comments by Evg, my vector<auto> syntax is non-standard GCC extension. For details see this answer referring to this document.

`[](std::vector&)` is not a valid syntax: *a template-argument cannot be a type that contains `auto`* (MSVS). Probably, it is a GCC extension. — Evg, Oct 20 '18 at 21:20
I think, I can: see [this answer](https://stackoverflow.com/a/26454851/1625187) and the [document](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0428r2.pdf) it refers to. — Evg, Oct 20 '18 at 21:38
Thank you. I added that comment to my question as an edit-explanation — Fureeish, Oct 20 '18 at 21:42

score 5 · Accepted Answer · answered Oct 20 '18 at 21:24

You can use some dedicated type trait:

#include <type_traits>
#include <utility>
#include <array>

template<typename x_Whatever> struct
is_array: ::std::false_type {};

template<typename x_Item, ::std::size_t x_items_count> struct
is_array<::std::array<x_Item, x_items_count>>: ::std::true_type {};

int main()
{
    auto Do_SomethingWithArray
    {
        [](auto & should_be_array)
        {
            static_assert
            (
                is_array
                <
                    ::std::remove_reference_t<decltype(should_be_array)>
                >::value
            );            
        }
    };
    ::std::array<int, 3> a{};
    Do_SomethingWithArray(a); // Ok
    int x{};
    Do_SomethingWithArray(x); // error
}

online compiler

I suppose `static_assert` is the little trick that I missed. Thank you! — Fureeish, Oct 20 '18 at 21:39

max66 · Answer 2 · 2018-10-20T21:40:04.987

4

Is there a way to introduce a similar, deduced value to a lambda expression so any std::arrays can be used with said lambda, similarily to the second version of the foo() function above?

Yes. But, unfortunately, starting (presumably) from C++20

auto foo_lambda = []<typename T, std::size_t S>(std::array<T, S> & arr)
 { /* ... */ };

In C++14/C++17 you can use decltype() to extract what you need.

In the std::array case, something as

auto foo_lambda = [](auto & arr)
 {
   using T = typename std::remove_reference_t<decltype(arr)>::value_type;
   std::size_t S = arr.size();

   // ...
 };

With other types, you can develop custom type traits to extract the needed elements starting from decltype(arr).

edited Oct 20 '18 at 21:40

answered Oct 20 '18 at 21:25

max66

65,235
10
71
111

I don't want my lambda to accept any type, as in your second snippet. The part about `C++20` is very promising though. Upvoted – Fureeish Oct 20 '18 at 21:28
@Evg - And a missed `typename` and a couple of missed semicolon; bad evening. You're right; thanks; corrected. – max66 Oct 20 '18 at 21:34
2

@Fureeish - Unfortunately we're in 2017 and C++20 is waited for 2020 (and a good support for it... in 2021? In 2023?). In C++14/C++17, I suggest the custom type-traits way; see the VTT's answer for an interesting example. – max66 Oct 20 '18 at 21:38

score 0 · Answer 3 · answered Oct 20 '18 at 21:29

Your vector<auto> syntax is wrong.

You can tear apart the type of the auto parameter in the return type/body of the lambda using helper functions and trait classes.

\http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0428r1.pdf is a proposal to add []<template T>( std::vector<T>& ){} to the lamguage. Something like it should be in c++20.

I've done double lambdas before:

template<class T>struct tag_t{using type=T;};
template<class T>constexpr tag_t<T> tag{};
template<class Tag>using type_t=typename Tag::type;

auto f = [](auto tag_T){ return []( std::vector<type_t<decltype(tag_T)>> const& v){ /* code */ }; };

and use like:

f(tag<int>)( std::vector<int>{} );

where we use values as template type parameters.

Is it possible to make a template variable in lambda signature generic?

3 Answers3