Есть задача одновременно обойти несколько std::tuple.

Для обхода одного std::tuple есть известный подход:

template <class Tuple, class F, std::size_t... I>
constexpr F for_each_impl(Tuple&& t, F&& f, std::index_sequence<I...>)
{
    return (void)std::initializer_list<int>{(std::forward<F>(f)(std::get<I>(std::forward<Tuple>}, f;
}

template <class Tuple, class F>
constexpr F for_each(Tuple&& t, F&& f)
{
    return for_each_impl(std::forward<Tuple>(t), std::forward<F>(f),
                         std::make_index_sequence<std::tuple_size<std::remove_reference_t<Tuple>>::value>{});
}

Пытаюсь переписать это дело под переменное количество std::tuple'ов одинаковой длины,
но не совсем понятно как правильно одновременно "распаковывать" sequence и tuple-аргумены (вообще возможно ли это?):

template <typename F, std::size_t... I, typename ...Tuples>
constexpr F for_each_variadic_impl(F&& f, std::index_sequence<I...>, Tuples&& ...tuples)
{
    return (void)std::initializer_list<int>{(std::forward<F>(f)(std::get<I>(std::forward<Tuples>(tuples))),0)...}, f;  // ошибка :)
}

template<typename Tuple1, typename... OtherTuples > 
struct tuple_size_helper
{
  static const std::size_t value = std::tuple_size<std::remove_reference_t<Tuple1>>::value;
};

template <typename F, typename ...Tuples>
constexpr F for_each_variadic(F&& f, Tuples&& ...tuples)
{
    return for_each_tuple_variadic_impl(
            std::forward<F>(f),
            std::make_index_sequence<tuple_size_helper<Tuples...>::value>{},
            std::forward<Tuples>(tuples)...);
}