🚀 Mastering Type Constraints: The IsSpecializationOf Concept in C++20

I’ve always had a passion for C++ metaprogramming. There’s something incredibly satisfying about moving logic from runtime to compile-time, creating interfaces that are both flexible and type-safe.

With C++20 Concepts, the game has changed, allowing us to express intent more clearly than ever. Today, I want to share a pattern I find particularly useful: the IsSpecializationOf concept.

The Challenge

If you want to sum a std::vector of any numeric type, you might start with a basic template. While it works, things get complicated when you need to handle multiple vectors of different types simultaneously or restrict template arguments to specific container shapes.

To gain more control, we need a way to check if a type is a specialization of a specific template (like std::vector).

The Implementation

#include <vector>
#include <numeric>

template <typename T>
auto sum_vector(const std::vector<T>& vec) -> T {
    return std::accumulate(vec.begin(), vec.end(), T{});
}

namespace details {
    // Primary template: defaults to false
    template <class, template <class...> class>
    inline constexpr bool isSpecializationOf = false;

    // Partial specialization: matches if the type is Template<Ts...>
    template <template <class...> class Template, class... Ts>
    inline constexpr bool isSpecializationOf<Template<Ts...>, Template> = true;
} // namespace details

// The C++20 Concept
template <class T, template <class...> class Template>
concept IsSpecializationOf = details::isSpecializationOf<T, Template>;

// Constrain the parameter pack to only allow std::vector specializations
auto sum_all_vectors(const IsSpecializationOf<std::vector> auto& ... vecs)
// Ensure all vectors contain arithmetic types (int, float, etc.)
requires ((std::is_arithmetic_v<typename std::decay_t<decltype(vecs)>::value_type> && ...)) {
    // Use a fold expression to sum everything into a double
    return (std::accumulate(vecs.begin(), vecs.end(), 0.0) + ...);
}

// Usage:
std::vector<int>    v1{1, 2};
std::vector<float>  v2{3.5f, 4.5f};
std::vector<double> v3{10.0, 20.0};

double total = sum_all_vectors(v1, v2, v3); // Result: 41.0

Why I love this approach:

Intent-Based Programming: Your function signature explicitly states: "I only accept things that are specializations of std::vector."
Variadic Beauty: It leverages fold expressions and concepts to handle an arbitrary number of containers cleanly.
Better Errors: If you accidentally pass a std::list, the compiler gives a clear error about the failed concept requirement rather than a cryptic error deep inside the function body.

Are you exploring C++20 Concepts in your current projects? What are your favorite metaprogramming patterns? Let's talk in the comments!