Hello,

I took some code snippet from some sample D code and modified it a bit:

template TCopy(T, V) {
  private int i = 2;
	
  void copy(out T to, out V to2, T from) {
    to = from;
    to2 = from;
    writeln("i: ", i);
  }
}

void main(string[] args)
{
	int x = 2;
	int y = 2;
	alias myCopy = TCopy!(int, int);	
	myCopy.copy(x, y, 37);
	writeln("x: ", x, " y: ", y);
}

My question is now why I have to declare and alias as in

alias myCopy = TCopy!(int, int);

If I define auto instead of alias, it does not compile. My question is why defining auto does not work. I would consider this more intuitive.

Thanks, Bienlein

On Friday, 4 April 2014 at 13:23:48 UTC, Bienlein wrote:
> Hello,
>
> I took some code snippet from some sample D code and modified it a bit:
>
> template TCopy(T, V) {
>   private int i = 2;
> 	
>   void copy(out T to, out V to2, T from) {
>     to = from;
>     to2 = from;
>     writeln("i: ", i);
>   }
> }
>
> void main(string[] args)
> {
> 	int x = 2;
> 	int y = 2;
> 	alias myCopy = TCopy!(int, int);	
> 	myCopy.copy(x, y, 37);
> 	writeln("x: ", x, " y: ", y);
> }
>
> My question is now why I have to declare and alias as in
>
> alias myCopy = TCopy!(int, int);
>
> If I define auto instead of alias, it does not compile. My question is why defining auto does not work. I would consider this more intuitive.
>
> Thanks, Bienlein

"auto" is used to declare an instance, or an object.
"alias" is used to declare a name.

What you are currently doing is saying "the function TCopy!(int, int) can now be refered to as myCopy". You aren't actually creating any data.

> "auto" is used to declare an instance, or an object.
> "alias" is used to declare a name.
>
> What you are currently doing is saying "the function TCopy!(int, int) can now be refered to as myCopy". You aren't actually creating any data.

All right, thanks. Then I create an instance:

auto myCopy = new TCopy!(int, int);	
alias myCopy = new TCopy!(int, int);	

Neither nor compiles now. How can? Seems to me a template is not a class in that sense ?!

On Fri, 04 Apr 2014 09:35:57 -0400, Bienlein <jeti789@web.de> wrote:

>
>> "auto" is used to declare an instance, or an object.
>> "alias" is used to declare a name.
>>
>> What you are currently doing is saying "the function TCopy!(int, int) can now be refered to as myCopy". You aren't actually creating any data.
>
> All right, thanks. Then I create an instance:
>
> auto myCopy = new TCopy!(int, int);	
> alias myCopy = new TCopy!(int, int);	
>
> Neither nor compiles now. How can? Seems to me a template is not a class in that sense ?!

A template is not a structure or class, it is a template. It's basically lexically checked, but not semantically. Once you define it's types and parameters, then the compiler basically substitutes those in, and compiles the result.

Note that a class template:

class C(T)
{
}

is short for this:

template C(T)
{
   class C
   {
   }
}

-Steve

On Friday, 4 April 2014 at 13:23:48 UTC, Bienlein wrote:
> template TCopy(T, V) {
[...]
> }

On Friday, 4 April 2014 at 13:35:58 UTC, Bienlein wrote:
> auto myCopy = new TCopy!(int, int);	
> alias myCopy = new TCopy!(int, int);	
>
> Neither nor compiles now. How can? Seems to me a template is not a class in that sense ?!

Templates are not classes, yes. You can make a class template:

class TCopy(T, V) {...}

The template instance TCopy!(int, int) then is a class type which
can be newed, etc.

The same works with structs, functions, interfaces. Add some
(template) parameters and it becomes a template that instantiates
to the corresponding entity.

On Friday, 4 April 2014 at 13:23:48 UTC, Bienlein wrote:
> Hello,
>
> I took some code snippet from some sample D code and modified it a bit:
>
> template TCopy(T, V) {
>   private int i = 2;
> 	
>   void copy(out T to, out V to2, T from) {
>     to = from;
>     to2 = from;
>     writeln("i: ", i);
>   }
> }
>
> void main(string[] args)
> {
> 	int x = 2;
> 	int y = 2;
> 	alias myCopy = TCopy!(int, int);	
> 	myCopy.copy(x, y, 37);
> 	writeln("x: ", x, " y: ", y);
> }
>
> My question is now why I have to declare and alias as in
>
> alias myCopy = TCopy!(int, int);
>
> If I define auto instead of alias, it does not compile. My question is why defining auto does not work. I would consider this more intuitive.
>
> Thanks, Bienlein


When you type TCopy!(int, int) you are not creating an expression with a return variable. TCopy!(int, int) has no return variable so auto can't work(What would be the return value?).

All TCopy is, is a compile time container that contains a variable i and a method copy. It contains no return value, hence auto can't work.

Now, TCopy!(int, int).i or TCopy!(int, int).copy are "things" that are in the template that can be used.

About the only thing you could do is use an eponymous template like



> template TCopy(T, V) {
>   private int i = 2;
> 	
>   void copy(out T to, out V to2, T from) {
>     to = from;
>     to2 = from;
>     writeln("i: ", i);
>   }

    T TCopy() { return null; }
> }

then

auto x = TCopy!(int, int)(someTvalue);

then x would be of type T, the return value of the TCopy function(not the template because it doesn't have a return value).