- A+

I'm trying to practice some template programming. Maybe there's a standard way to do this, and I would be thankful for such answers, but my main goal is to practice the template programming techniques, so I tried to implement it myself:

I need to concatenate multiple tuples, but as types, not like `std::cat_tuple`

does it. So I need something like `cat<std::tuple<int, float>, std::tuple<char, bool>, ...>`

to get `std::tuple<int, float, char, bool, ...>`

as a type.

My current attempt failed with a `is not a template`

error:

`/* Concat tuples as types: */ template <typename first_t, typename... rest_t> struct cat { using type = typename _cat<first_t, typename cat<rest_t...>::type>::type; ^^^^ cat is not a template }; template <typename first_t, typename second_t> struct cat<first_t, second_t> { using type = typename _cat<first_t, second_t>::type; ^^^^ cat is not a template }; // Concat two tuples: template <typename, typename> struct _cat; template <typename tuple_t, typename first_t, typename... rest_t> struct _cat<tuple_t, std::tuple<first_t, rest_t...>> { using type = typename _cat<typename append<first_t, tuple_t>::type, std::tuple<rest_t...>>::type; }; template <typename tuple_t, typename first_t> struct _cat<tuple_t, std::tuple<first_t>> { using type = typename append<first_t, tuple_t>::type; }; // Prepend element to tuple: template <typename, typename> struct prepend; template <typename elem_t, typename... tuple_elem_t> struct prepend<elem_t, std::tuple<tuple_elem_t...>> { using type = std::tuple<elem_t, tuple_elem_t...>; }; // Apppend element to tuple: template <typename, typename> struct append; template <typename elem_t, typename... tuple_elem_t> struct append<elem_t, std::tuple<tuple_elem_t...>> { using type = std::tuple<tuple_elem_t..., elem_t>; }; `

What may be causing the error?

Is this a good approach? It might be solved in a simpler way, but I wanted it to be multi-purpose (with the append/prepend operations etc.).

After reordering the definition a little, your code works fine.

I don't think that there are any guidelines for template meta programming. Probably due to the fact that the C++ committee is enhancing TMP "aggressively" and too few people is using TMP.

Here is my version of `Cat`

, it basically follows the same structure as yours:

`template <class, class> struct Cat; template <class... First, class... Second> struct Cat<std::tuple<First...>, std::tuple<Second...>> { using type = std::tuple<First..., Second...>; }; `