Why can't we specialize concepts?

Question

The syntax that works for classes does not work for concepts:

template <class Type>
concept C = requires(Type t) {
    // ...
};


template <class Type>
concept C<Type*> = requires(Type t) {
    // ...
};

MSVC says for the line of the "specialization": error C7606: 'C': concept cannot be explicitly instantiated, explicitly specialized or partially specialized.

Why cannot concepts be specialized? Is there a theoretical reason?

Answer 1

Because it would ruin constraint normalization and subsumption rules.

As it stands now, every concept has exactly and only one definition. As such, the relationships between concepts are known and fixed. Consider the following:

template<typename T>
concept A = atomic_constraint_a<T>;

template<typename T>
concept B = atomic_constraint_a<T> && atomic_constraint_b<T>;

By C++20's current rules, B subsumes A. This is because, after constraint normalization, B includes all of the atomic constraints of A.

If we allow specialization of concepts, then the relationship between B and A now depends on the arguments supplied to those concepts. B<T> might subsume A<T> for some Ts but not other Ts.

But that's not how we use concepts. If I'm trying to write a template that is "more constrained" than another template, the only way to do that is to use a known, well-defined set of concepts. And those definitions cannot depend on the parameters to those concepts.

The compiler ought to be able to compute whether one constrained template is more constrained than another without having any template arguments at all. This is important, as having one template be "more constrained" than another is a key feature of using concepts and constraints.

Ironically, allowing specialization for concepts would break (constrained) specialization for other templates. Or at the very least, it'd make it really hard to implement.

Answer 2

In addition to the great answer from Nicol Bolas:

Concepts are a bit special, because they don't behave like other templated things:

13.7.9 Concept definitions

⁽⁵⁾ A concept is not instantiated ([temp.spec]).
[Note 1: A concept-id ([temp.names]) is evaluated as an expression. A concept cannot be explicitly instantiated ([temp.explicit]), explicitly specialized ([temp.expl.spec]), or partially specialized ([temp.spec.partial]). — end note]

Due to concepts not being able to be instantiated they also can't be specialized.

I'm not sure on why the standard decided to not make them specializable, given that it's easy to emulate specializations.

---

While you can't specialize concepts directly, there are quite a few ways you can work around the problem.

You can use any type of constant expression in a concept - so you could use a templated variable (which can be specialized) and just wrap it up into a concept - the standard does this for quite a few of its own concepts as well, e.g. std::is_intergral:

template<class T> struct is_integral;

// is_integral is specialized for integral types to have value == true
// and all others are value == false

template<class T>
inline constexpr bool is_integral_v = is_­integral<T>::value;

template<class T>
concept integral = is_­integral_­v<T>;

So you could easily write a concept that has specializations like this: godbolt example

struct Foo{};
struct Bar{};

template<class T>
constexpr inline bool is_addable_v = requires(T t) {
    { t + t } -> std::same_as<T>;
};

// Specializations (could also use other requires clauses here)
template<>
constexpr inline bool is_addable_v<Foo> = true;

template<class T>
constexpr inline bool is_addable_v<T&&> = true;

template<class T>
concept is_addable = is_addable_v<T>; 

int main() {
    static_assert(is_addable<int>);
    static_assert(is_addable<Foo>);
    static_assert(!is_addable<Bar>);
    static_assert(is_addable<Bar&&>);
}

Or by using a class:

template<class T>
struct is_addable_v : std::true_type {};

template<>
struct is_addable_v<struct FooBar> : std::false_type {};

template<class T>
concept is_addable = is_addable_v<T>::value; 

Or even a constexpr lambda: godbolt example

// pointers must add to int
// everything else must add to double
template<class T>
concept is_special_addable = ([](){
    if constexpr(std::is_pointer_v<T>)
        return requires(std::remove_pointer_t<T> t) {
            { t + t } -> std::same_as<int>;
        };
    else
        return requires(T t) {
            { t + t } -> std::same_as<double>;
        };
})(); 

int main() {
    static_assert(is_special_addable<double>);
    static_assert(is_special_addable<int*>);
    static_assert(!is_special_addable<double*>);
    static_assert(!is_special_addable<int>);
}

So while concepts can't be specialized on their own, it's easy to achieve the same effect with existing language features.