#include <string>
    #include <iostream>
    #include <tuple>
    #include <vector>

    namespace detail
    {
        template<int... Is>
        struct seq { };

        template<int N, int... Is>
        struct gen_seq : gen_seq<N - 1, N - 1, Is...> { };

        template<int... Is>
        struct gen_seq<0, Is...> : seq<Is...> { };

        template<typename T, typename F, int... Is>
        void for_each(T&& t, F f, seq<Is...>)
        {
            auto l = { (f(std::get<Is>(std::forward<T>(t))), 0)... };
        }
    }

    template<typename... Ts, typename F>
    void for_each_in_tuple(std::tuple<Ts...> const& t, F f)
    {
        detail::for_each(t, f, detail::gen_seq<sizeof...(Ts)>());
    }

    template<typename... Ts>
    struct TupleOfVectors
    {
        std::tuple<std::vector<Ts>...> t;

        void do_something_to_each_vec()
        {
            for_each_in_tuple(t, tuple_vector_functor());
        }

        struct tuple_vector_functor
        {
            template<typename T>
            void operator () (T const &v)
            {
                std::cout << "{ ";
                bool first = true;
                for (auto const& x : v)
                {
                    if (!first) { std::cout << ", "; };
                    std::cout << x;
                    first = false;
                }
                std::cout << " }" << std::endl;
            }
        };
    };

    int main()
    {
        TupleOfVectors<int, double, std::string> tv;
        std::get<0>(tv.t).push_back(42);
        std::get<0>(tv.t).push_back(1729);

        std::get<1>(tv.t).push_back(3.14);

        std::get<2>(tv.t).push_back("Hello");
        std::get<2>(tv.t).push_back("World");
        std::get<2>(tv.t).push_back("of");
        std::get<2>(tv.t).push_back("Tuples!");

        tv.do_something_to_each_vec();
    }