digitalmars.D.learn - T : T*
- Jonathan M Davis (18/18) Apr 13 2012 I'd just like to verify that my understanding of T : T* in this template...
- Jakob Ovrum (20/46) Apr 13 2012 First, the argument type must match the form T*. The T can be any
- Jonathan M Davis (5/27) Apr 13 2012 Thanks for the info. Clearly, : does not mean quite the same thing in al...
-
Stewart Gordon
(8/13)
Apr 18 2012
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
Apr 13 2012
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
Apr 13 2012
Jonathan M Davis <jmdavisProg gmx.com>
On Friday, April 13, 2012 21:04:07 Jakob Ovrum wrote:
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
Thanks for the info. Clearly, : does not mean quite the same thing in all
cases (in particular, when the same template parameter is on both sides of
it).
- Jonathan M Davis
Apr 13 2012
On 13/04/2012 19:47, 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*)<snip>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.<snip> Yes. It's more or less syntactic saccharin for struct S(U : T*, T) { T t; } Stewart.
Apr 18 2012