In modern C++, variadic templates allow us to work with an arbitrary number of template arguments. However, anyone who has delved deep into Template Metaprogramming (TMP) knows that "parameter packs" (the Ts... in a template) are quite elusive. They aren't objects, they aren't types, and they aren't quite arrays. They are a language construct that can only be expanded in specific contexts.
To harness the power of these packs, we need a way to "capture" them, move them around, and manipulate them without immediate expansion. This is where TypePack comes in.
The Problem: Why Can't We Just Use Packs?
A pack of types is not a first-class citizen in C++. You cannot store a pack in a variable, nor can you create a using alias for a raw pack.
Consider the following illegal code:
template <typename... Ts>
struct Error {
using MyPack = Ts...;
};
Because of this limitation, if you want to pass a collection of types to another metafunction or store them for later use, you must wrap them in a container.
The std::tuple Example
The most common example of a pack container in the Standard Library is std::tuple.
std::tuple<int, double, char> myData;
While std::tuple is great for storing values of different types, it carries overhead because it’s a concrete class designed for runtime use. For pure compile-time metaprogramming, we need something lighter—a "type-only" container.
The Implementation: TypePack
TypePack is a minimalist structure designed to hold a pack of types. It inherits from std::type_identity to make it easier to refer to the pack's own type in complex transformations.
#include <type_traits>
template <class... Ts>
struct TypePack : std::type_identity<TypePack<Ts...>> {
};
By wrapping Ts... inside TypePack, the pack becomes part of a single, concrete type. You can now pass this TypePack to other templates, nest it, or return it from a metafunction.
Validation and Examples
To ensure our TypePack behaves as expected, we can use static_assert. These tests verify that different instances of TypePack are recognized as unique types and that they correctly inherit their own identity.
using EmptyPack = TypePack<>;
static_assert(!std::is_same_v<EmptyPack, TypePack<int>>);
using MyTypes = TypePack<int, float, double>;
static_assert(std::is_same_v<MyTypes::type, MyTypes>);
using Nested = TypePack<TypePack<int, int>, char>;
static_assert(std::is_same_v<Nested::type, TypePack<TypePack<int, int>, char>>);
Conclusion
TypePack is the foundation of our library. By wrapping a variadic pack into a struct, we bypass the language limitations that prevent us from treating packs as entities. We have moved from a raw, "unstable" pack to a stable, nameable type.
In the next part, we will explore how to calculate the size of a TypePack and how to get individual types from it.
