Get index and value of variadic template at compile time

Question

I have a function that looks like this

template <typename... Rets, typename... Args>
std::tuple<Rets...> call_nn(std::string_view query, Args... args)
{
  pqxx::work w(con_);
  pqxx::row res = w.exec_params1(pqxx::zview(query), args...);
  w.commit();
  return // std::tuple<Rets...>((res[std::index_sequence_for<Rets>{}].as<Rets>())...); doesn't work
}

pqxx::row represents one row of result table from postgres. It supports getting column value as res[0].as<int>().

The problem is that I don't know how to expand the variadic template argument to access the type index and the type itself. What should I put instead of ????

return std::tuple(ret[/*???*/].as<Rets>()...);

I tried to define int i = 0 and expand like res[i++].as<Rets>()... but then compiler gives warning

Multiple unsequenced modifications to 'i'

so maybe there are some better ways to expand return statement to something like example below without runtime variables

return std::tuple(ret[0].as<X>(), ret[1].as<Y>(), /*...*/ ret[n].as<Z>() );

Answer 1

You want to create a second parameter pack for the values in index_sequence:

template <typename... Rets, std::size_t... Idxs, typename... Args>
std::tuple<Rets...> call_nn(std::index_sequence<Idxs...>, std::string_view query, Args&... args)
{
  pqxx::work w(con_);
  pqxx::row res = w.exec_params1(pqxx::zview(query), args...);
  w.commit();
  return std::tuple<Rets...>((res[Idxs].as<Rets>())...);
}

template <typename... Rets, typename... Args>
std::tuple<Rets...> call_nn(std::string_view query, Args... args)
{
    return call_nn<Rets...>(std::index_sequence_for<Rets...>{}, query, args...);
}

Answer 2

Since C++20, lambda expressions can have an explicit template parameter list. Calling a lambda immediately after definition has become a pervasive modern idiom. Combination of the two ideas is very common in variadic template programming. But the primary rule - as ever - is that all parameter packs in a pack expansion expression are expanded together and are required to have the same size:

return [&res] <std::size_t ... i>
       (std::index_sequence<i...>) {
       return std::tuple{ res[i].as<Rets>()... };
} (std::index_sequence_for<Rets...>{});

Notice that in the inner return statement, i and Rets are expanded simultaneously.

In the above code I have used the C++20 CTAD syntax to shorten the code sequence a bit; that's why tuple is not followed by <Rets...>. Explicit argument list in such cases is normally used for conversions, or when class arguments can't be totally deduced from constructor parameters.