www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - T : T*

reply "Jonathan M Davis" <jmdavisProg gmx.com> writes:
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
next sibling parent "Jakob Ovrum" <jakobovrum gmail.com> writes:
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
prev sibling next sibling parent Jonathan M Davis <jmdavisProg gmx.com> writes:
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
prev sibling parent Stewart Gordon <smjg_1998 yahoo.com> writes:
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*)

 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.

Yes. It's more or less syntactic saccharin for struct S(U : T*, T) { T t; } Stewart.
Apr 18 2012