Parameter pack, capture clause and initializers - c++

Question

Note: this question is for the sake of curiosity.
Consider the documentation for the lambda and the one for the parameter pack.
The following code is legal:
template<typename... T>
void f(T... t) {
auto lambda = [t...](){ /* do something */ };
// do something else
}
The same goes without saying for this one:
void f(int i) {
auto lambda = [i = i](){ /* do something */ };
// do something else
}
I was wondering if it's possible to define an initializer in the capture clause for a parameter pack.
Something like this:
template<typename... Args>
void f(Args&&... args) {
auto lambda = [params = std::forward<Args>(args)...](){ /* do something */ };
// do something else
}
Ok, I suspect it doesn't make sense, but it gives an idea at least.
Is there any viable solution to do that?
Please, do not ask me why I would do that. I don't want to do that. As I said, it's for the sake of curiosity.

Answer 1

Nope.
Best you can do is:
template<typename... Args>
void f(Args&&... args) {
auto lambda = [params = std::make_tuple(std::forward<Args>(args)...)]()
{ /* do something */ };
// do something else
}
then interact with params as a tuple, including using get.
I find you end up having to leave the world of lambdas to unpack the elements again. Probably you could do it with a helper like this:
template<std::size_t...Is, class F>
decltype(auto) unpack_impl( std::index_sequence<Is...>, F&& f ) {
return std::forward<F>(f)(std::integral_constant<std::size_t, Is>{}...);
}
template<std::size_t N, class F>
decltype(auto) unpack( F&& f ) {
return unpack_impl( std::make_index_sequence<N>{}, std::forward<F>(f) );
}
which takes a template non-type argument N, then generates a pack of integral_constants with constexpr operator size_t and values 0 through N-1, and passes those to a lambda you pass unpack.
Example use:
template<typename... Args>
auto print_later(Args&&... args) {
auto lambda = [params = std::make_tuple(std::forward<Args>(args)...)](
auto&& stream
)
{
unpack<sizeof...(Args)>( [&](auto...Is){
using discard=int[];
(void)discard{0,(void(
stream << std::get<Is>( params )
),0)...
};
});
};
return lambda;
}
Notice the Is being passed to the inner lambda. Basically this technique let us unpack a parameter pack and get its values in an expandible context without having to create a new explicit template function; instead, we create a variadic lambda, and use the types of the arguments (or constexpr operations on them) to get the unpack results.
The above is a function that takes a package of arguments, and returns a function that takes a stream and prints them all.
live example
The unpack function can be made much more generic; at least, have it take a integer_sequence, and in the end even a variation could take a pack of types directly.