Corresponding alias pattern as template argument

Question

Consider the following code :

#include <type_traits> template<template<class...> class T, class... U> struct is_specialization_of : std::false_type{}; template<template<class...> class T, class... U> struct is_specialization_of<T, T<U...>> : std::true_type{}; template<class T, class U = int> struct test{}; // (1) ok static_assert(is_specialization_of<test, test<int>>::value, "1"); template<class T> using alias = test<T>; // (2) fails static_assert(is_specialization_of<alias, alias<int>>::value, "2"); int main() { } 

Why (2), i.e. static_assert that uses an alias pattern fails?

How is the process of subtracting the template argument in (2) different from the method in (1)?

Answer 1

This is CWG issue 1286 . The question is: are alias and test equivalent? There used to be an example in [temp.type], which suggested that y and z are of the same type:

 template<template<class> class TT> struct X { }; template<class> struct Y { }; template<class T> using Z = Y<T>; X<Y> y; X<Z> z; 

The example was adjusted as part of CWG defect 1244 - which correctly indicated that in [temp.alias] , which actually indicates that the alias patterns are equivalent to their patterns. The only wording there refers to the equivalence of specialized alias patterns:

When the template identifier refers to the specialization of the alias template , it is equivalent to the associated type obtained by substituting its template arguments for the template parameters in the identifier type of the alias template.

Apparently, the intention is that y and z are of the same type in this example, which means that z and y actually equivalent. But if and until the wording of the resolution is adopted, it is not. Today alias and test not equivalent, but alias<int> and test<int> . This means that is_specialization_of<alias, alias<int>> is is_specialization_of<alias, test<int>> where alias is unique from test , which does not correspond to your partial specialization and therefore will be false_type .

Moreover, even with the adoption of the wording in No. 1286, test and alias are still not equivalent for the obvious reason that test accepts two template parameters, and the alias accepts one template parameter. The example in the permission statement mimics your example and clarifies the intention here:

 template<typename T, U = T> struct A; // ... template<typename V> using D = A<V>; // not equivalent to A: // different number of parameters 

Answer 2

I think that the name of the alias template without a list of template templates is not equivalent to the name of the associated type. Since the standard defines only one such situation:

14.5.7 Alias ​​Templates [temp.alias]

2. When the template identifier refers to the specialization of the alias template, it is equivalent to the associated type obtained by substituting its argument templates for the template parameters in the template alias type identifier. [Note: the alias template name is never displayed.-End note]

and this one works fine :

 static_assert(is_specialization_of<test, alias<int>>::value, "2");