Calling a lambda for each nth argument of multiple tuples? - c++

Question

I am trying to write a code that invokes a lambda with input arguments extracted from a variadic set of tuples. However, my attempt does not compile:
#include <iostream>
#include <tuple>
#include <utility>
#include <type_traits>
template <typename ...>
struct first_of;
template <typename T, typename ... Args>
struct first_of<T, Args...> {
using type = std::decay_t<T>;
};
template <typename T>
struct first_of<T> {
using type = std::decay_t<T>;
};
template <typename ... T>
using first_of_t = typename first_of<T...>::type;
template <typename Fn, typename... Tuples, std::size_t... Idxs>
void run_impl(Fn&& fn, std::index_sequence<Idxs...>, Tuples... t) {
auto temp = {(fn(std::get<Idxs>(t)...), true)...};
(void)temp;
}
template <typename Fn, typename... Tuples>
void run(Fn&& fn, Tuples&&... tuples) {
run_impl(std::forward<Fn>(fn), std::make_index_sequence<std::tuple_size<first_of_t<Tuples...>>::value>{}, std::forward<Tuples>(tuples)...);
}
int main() {
auto a = std::make_tuple(1, 2.34, "one");
auto b = std::make_tuple(32, 5.34, "two");
auto print = [](auto& f, auto& g) { std::cout << f << ", " << g << std::endl; };
run(print, a, b);
}
I am expecting the following output:
1, 32
2.34, 5.34
one, two
I am using c++14, so unfortunately, no fold expressions.
Here is the godbolt link to the code: https://godbolt.org/z/G19n5z

Answer 1

The easiest way to do this is to just add another layer of indirection, having run_impl delegate to another function that does the actual calling. I took the liberty of renaming your function to call_transposed():
template <std::size_t I, typename Fn, typename... Tuples>
void call_with_nth(Fn&& fn, Tuples&&... t) {
fn(std::get<I>(std::forward<Tuples>(t))...);
}
template <typename Fn, std::size_t... Idxs, typename... Tuples>
void call_transposed_impl(Fn&& fn, std::index_sequence<Idxs...>, Tuples&&... t) {
auto temp = {(call_with_nth<Idxs>(fn, std::forward<Tuples>(t)...), true)...};
(void)temp;
}
template <typename Fn, typename... Tuples>
void call_transposed(Fn&& fn, Tuples&&... tuples) {
call_transposed_impl(
std::forward<Fn>(fn),
std::make_index_sequence<std::tuple_size<first_of_t<Tuples...>>::value>{},
std::forward<Tuples>(tuples)...);
}
Godbolt link
I'm not certain why your code did not work, but I suspect that the std::get<Idxs>(t)... is trying to expand both packs Idxs and t at the same time, leaving you with no pack to expand later. This code avoids the problem by only dealing with a single pack at a time.