Why this template parameters con­straint doesn't work? - templates

Question

Reading templates-revisited:
struct S(T : T*) {
T t; // t is supposed to be of type 'int*', but it's of type 'int', why?
}
void main() {
int x = 123;
S!(int*) s;
static assert(is(typeof(s.t) == typeof(&x)));
}
The above code doesn't compile.
Strangely enough, the following does compile:
struct S(T : int*) {
T t;
}
void main() {
int x = 123;
S!(int*) s;
static assert(is(typeof(s.t) == typeof(&x)));
}
I don't understand this behavior. An explanation would be appreciated.

Answer 1

When a type specialization (the type after the colon) is dependent on the parameter identifier, such as T : T*, the resulting identifier refers to the role of the identifier (T) in the type specialization (the deduced type) if there was a match.
Otherwise, if the specialization is independent, such as T : int*, the resulting identifier is an alias of the type specialization.
Examples:
=========================================================
Argument T | Specialization | Result
=========================================================
void | T : void | void
char | T : void | <no match>
int* | T : T* | int
immutable(char)[] | T : T[] | immutable(char)
immutable(char)[] | T : immutable(T)[] | char
=========================================================
When there is a mismatch for an argument passed to a template parameter, the template is dropped from the overload set. An error is raised if the overload set becomes empty before a match is found.
When there is a mismatch in an IsExpression (the is(...) primary expression), the result is false and no symbols are introduced into scope.

Answer 2

As explained in the Argument Deduction section of http://dlang.org/template.html, when deducing the types of template arguments:
If there is no type spe­cial­iza­tion for the pa­ra­me­ter, the type of the pa­ra­me­ter is set to the tem­plate ar­gu­ment.
If the type spe­cial­iza­tion is de­pen­dent on a type pa­ra­me­ter, the type of that pa­ra­me­ter is set to be the
cor­re­spond­ing part of the type ar­gu­ment.
If after all the type ar­gu­ments are ex­am­ined there are any type pa­ra­me­ters left with no type as­signed, they are as­signed types
cor­re­spond­ing to the tem­plate ar­gu­ment in the same po­si­tion in
the Tem­plateAr­gu­mentList.
If ap­ply­ing the above rules does not re­sult in ex­actly one type for each tem­plate pa­ra­me­ter, then it is an error.
And the example that corresponds to your case is:
template TBar(T : T*) { }
alias TBar!(char*) Foo3; // (2) T is deduced to be char
So, what you're seeing in your first example is expected behavior. Because the T is on both sides, T ends up being evaluated to what would result in the template argument being T*. So, since the template argument is int*, T* would be int*, and T ends up being int. What you have is very similar to std.traits.pointerTarget:
/**
Returns the target type of a pointer.
*/
template pointerTarget(T : T*)
{
alias T pointerTarget;
}
Your second example compiles, because that template is requiring that T be implicitly convertible to int*. And since int* is implicitly convertible to itself, when you pass int* as the template argument, it works. What's causing you trouble is when T is on both sides, because then the right-hand side of the expression is dependent on the left.
Now, I assume that what you actually intend to test here is that the template argument is a pointer? If that's the case, then you should use std.traits.isPointer:
struct S(T)
if(isPointer!T)
{
T t;
}