question on tuples and expressions

[leo]

>> Hi,
>> while I was reading the language specification I stumbled across the 
>> following problem:
>>
>> Tuple!(int, int) x = Tuple!(1, 2);  // doesn't compile
>> Tuple!(int, int) y = (1, 2);    // leads to y being (2, 2)
>>
>> How can I initialize a tuple by providing another tuple?
>>
>> I know it's still possible to assign each element of the tuple 
>> separately, I'm just wondering what sense it makes
>> to define an expression (1, 2) to be 2 of type int rather than (1, 2) of 
>> type (int, int).
>> Is there any case in which this would provide an advantage?
>>
>> Leo
>
> You have two mistakes, one for each lines of code :)
> But you were close to right solutions.
>
> 1) Tuple!(int, int) x = Tuple!(1, 2);  // doesn't compile
>
> Of course it doesn't, don't confuse type definition with a constructor 
> call. In this case, "Tuple!(int, int)" is a type, and so is "Tuple!(1, 2)" 
> (although template parameters are invalid; types are expected, not 
> expressions). We could rewrite this line as follows:
>

But template parameters also allow for expressions, so that tuples can also
be expression tuples.

> A x = B; // where A and B are type aliases
>
> What you need here is a constructor call:
>
> A x = A(1, 2);
>
> or
>
> Tuple!(int,int) x = Tuple!(int,int)(1, 2);
>

This wouldn't work since Tuple!(int, int) has no opCall

>
> 2) Tuple!(int, int) y = (1, 2);    // leads to y being (2, 2)
>
> Here is another quest - what does the following lines do?
>
> int x =  1, 2;
> int y = (1, 2);
>

The above doesn't compile, because it's actually a declaration of a variable
"int x = 1;" and another syntactically wrong one "int 2;". The comma is
associated with the DeclarationStatement, not the expression.
In the second line the parentheses tell the compiler to treat "1, 2" as an
expression.

> They are absolutely the same and both initialize variables to 2, that's 
> the way comma expression works (it evaluates all the expression and 
> returns result of last expression).
>
> Same here:
>
> "Tuple!(int, int) y = (1, 2);" == "Tuple!(int, int) y = 2;"
>
> If you want per-member struct initialization, you should use curly braces 
> instead:
>
> Tuple!(int, int) y = {1, 2};
>

Curly braces won't work either, because Tuple!(int, int) can not be
initialized per-member. I tried also
Tuple!(int, int) x;
x = (1, 2);  // here I get an error message "forward reference to type (int,
int)
x = {1, 2}; // this produces a lot of "found 'EOF' instead of statement"
errors

I compiled with dmd v1.038, v2.014 and v2.022
It's not like I would ever need to initialize a tuple like that, I'm just
curious
anyway, thanks for the answer

Leo