On Friday, 13 April 2012 at 18:47:55 UTC, Jonathan M Davis wrote:
I'd just like to verify that my understanding of T : T* in this
template is
correct:
struct S(T : T*)
{
T t;
}
It's my understanding that it's requiring that the template
argument be
implicitly convertible to a pointer to that type. However, as
this
stackoverflow question shows:
http://stackoverflow.com/questions/10145779/why-this-template-parameters-
constraint-doesnt-work
it appears that the compiler is instead taking this to mean
that the pointer
part of the type should be stripped from the template
argument's type. Given
some of the bizarre stuff that happens with is expressions and
the like, it's
not out of the question that I'm just misunderstanding what the
compiler is
supposed to do with T : T* in this case (though I don't think
so), so I'd like
to verify it.
- Jonathan M Davis
First, the argument type must match the form T*. The T can be any
type; there is only one constraint here, the pointer head. So
obviously, the argument type must be a pointer to anything to
match T*, e.g. void*, shared(int)**, immutable(int)* etc. If it
doesn't match, the template is dropped from the overload set.
If it does match, the newly created symbol T refers to the role
of T in the parameter specialization. For arguments void*,
shared(int)** and immutable(int)*, that would be void,
shared(int)* and immutable(int) respectively.
Most forms of the `is` primary expression (IsExpression) are
dedicated to allowing the same type inspection abilities (and
some more) outside of template parameter lists, hence reading the
documentation of IsExpression is a good idea [1]. In particular,
it reveals that when the type specialization is dependent on the
symbol identifier (e.g. there's a T in the T specialization) the
resulting symbol refers to the deduced type; otherwise it is an
alias of the type specialization, which explains the two uses you
mention.
[1] http://dlang.org/expression.html#IsExpression
