Is it possible to expand a parameter pack with a lambda function? - c++

Question

I think my question is a corner case, of how far you can go with parameter pack expansion and it's a little hard to explain, what I want. The idea is easiest to express with a little code, so lets have a look at the following lines:
// <main.cpp>
#include <tuple>
#include <iostream>
// this function is supposed to return a std::tuple of function objects
// for each template argument type, there should be one such function object,
// that takes a value of this type and returns its half.
template <class... arg_t>
auto make_divide_by_two_lambda_tuple() {
return std::make_tuple(
[](const arg_t& elem) -> arg_t
{
return elem/2;
}...
);
}
int main()
{
// lets initialise a tuple with our function
auto value = make_divide_by_two_lambda_tuple<int, float>();
/*
* If everything workes as planned, the tuple has this structure
* value<0> := [](const int&){ ... }
* value<1> := [](const float&){ ... }
*/
// and we are able to use our functions in the expected way
std::cout << "5/2 (int version) = " << std::get<0>(value)(5) << std::endl;
std::cout << "5/2 (float version) = " << std::get<1>(value)(5) << std::endl;
return 0;
}
For clang(4.0.1), this example compiles and run as I expect it to do:
$ clang++ -std=c++14 ../main.cpp
$ ./a.out
5/2 (int version) = 2
5/2 (float version) = 2.5
For g++(7.1.1), this example does fail to compile:
$ g++ -std=c++14 ../main.cpp
../main.cpp: In function ‘auto make_divide_by_two_lambda_tuple()’:
../main.cpp:7:28: error: parameter packs not expanded with ‘...’:
[](const arg_t& elem) -> arg_t
^~~~~
../main.cpp:7:28: note: ‘arg_t’
../main.cpp:7:28: error: parameter packs not expanded with ‘...’:
../main.cpp:7:28: note: ‘arg_t’
../main.cpp:10:4: error: expansion pattern ‘<lambda>’ contains no argument packs
}...
^~~
../main.cpp: In function ‘int main()’:
../main.cpp:15:10: error: ‘void value’ has incomplete type
auto value = make_divide_by_two_lambda_tuple<int, float>();
So it seems, that gcc is willing to use a parameter pack inside the argument list of a lambda expression. But using the whole lambda is stretching it too far for gcc to accept.
Is this use of lambda expressions undefined behaviour, or is one compiler (hopefully gcc) wrong?
PS.: I also checked the docs, but it only explains, where you can use parameter pack expansion, and not what statments you can expand.