I tried to search the ng and dstress test cases, but there was nothing about these.

So here are the working ones:

  const a = [1,2];
  int[] b = [1,2];

  struct foo {
    const int[] c = [1,2];
    const d = [1,2];
  }

  void main() {
    const e = [1,2];
  }

These ones don't work:

  template Tuple(E...) { alias E Tuple; }
  alias Tuple!(0,1) TP;

  const a = [ TP ];
  int[] b = [ TP ];

  struct foo {
    const int[] c = [ TP ];
    const d = [ TP ];
  }

So, are these going to be fixed in future releases or is there some serious limitation in the template/tuple system that prevents any of these? Any workarounds that make use of tuples?

Jari-Matti Mäkelä wrote:
> I tried to search the ng and dstress test cases, but there was nothing about these.
> 
> So here are the working ones:
> 
>   const a = [1,2];
>   int[] b = [1,2];
> 
>   struct foo {
>     const int[] c = [1,2];
>     const d = [1,2];
>   }
> 
>   void main() {
>     const e = [1,2];
>   }
> 
> These ones don't work:
> 
>   template Tuple(E...) { alias E Tuple; }
>   alias Tuple!(0,1) TP;
> 
>   const a = [ TP ];
>   int[] b = [ TP ];
> 
>   struct foo {
>     const int[] c = [ TP ];
>     const d = [ TP ];
>   }
> 
> So, are these going to be fixed in future releases or is there some serious limitation in the template/tuple system that prevents any of these? Any workarounds that make use of tuples?

I'm not an expert on Tuples, but I don't think you can alias expression tuples like (0,1), for the same reason you can't alias 1 or 2.

The solution is the same: put it in a constant.

  typeof(Tuple!(0,1)) TP = Tuple!(0,1);

The problem here is that I'm not sure if assigning between tuples works, either.  I remember having to write a loop to do it...

> foreach( i, e ; tuple )
>     TP[i] = e;

To be honest, I haven't really played with expression tuples all that much, so I could be totally off-base.  None the less, something to think about :)

	-- Daniel

-- 
Unlike Knuth, I have neither proven or tried the above; it may not even make sense.

v2sw5+8Yhw5ln4+5pr6OFPma8u6+7Lw4Tm6+7l6+7D i28a2Xs3MSr2e4/6+7t4TNSMb6HTOp5en5g6RAHCP  http://hackerkey.com/

Daniel Keep kirjoitti:
> 
> Jari-Matti Mäkelä wrote:
>> I tried to search the ng and dstress test cases, but there was nothing about these.
>>
>> So here are the working ones:
>>
>>   const a = [1,2];
>>   int[] b = [1,2];
>>
>>   struct foo {
>>     const int[] c = [1,2];
>>     const d = [1,2];
>>   }
>>
>>   void main() {
>>     const e = [1,2];
>>   }
>>
>> These ones don't work:
>>
>>   template Tuple(E...) { alias E Tuple; }
>>   alias Tuple!(0,1) TP;
>>
>>   const a = [ TP ];
>>   int[] b = [ TP ];
>>
>>   struct foo {
>>     const int[] c = [ TP ];
>>     const d = [ TP ];
>>   }
>>
>> So, are these going to be fixed in future releases or is there some serious limitation in the template/tuple system that prevents any of these? Any workarounds that make use of tuples?
> 
> I'm not an expert on Tuples, but I don't think you can alias expression tuples like (0,1), for the same reason you can't alias 1 or 2.

I'm not an expert either. I found the aliasing from http://www.digitalmars.com/d/tuple.html.

"Expression Tuples

If a tuple's elements are solely expressions, it is called an ExpressionTuple."

"It can be used to create an array literal:
alias Tuple!(3, 7, 6) AT;

...
int[] a = [AT];         // same as [3,7,6]"

---

I forgot to mention that in the code I sent b) actually works, but a)
doesn't:

  template Tuple(E...) { alias E Tuple; }
  alias Tuple!(0,1) TP;

  const a = [ TP ]; // example a)

  void main() {
    static const b = [ TP ]; // example b)
  }

I have used code similar to b) a lot to precalculate tables in my code. I was just curious about the actual reasons to deny the use of a). AFAIK, it can be calculated in compile time and there is also evidence that the tuple in a literal syntax works elsewhere.

Something like

  template Tuple(E...) { alias E Tuple; }
  alias Tuple!(0,1) TP;

  const a = [ TP[0], TP[1] ];

also works, but the tuples really should have variable length in my code.

> 
> The solution is the same: put it in a constant.
> 
>   typeof(Tuple!(0,1)) TP = Tuple!(0,1);

Ok, I have to try this. Thanks. My first impression is that it does not work :)

test.d(2): Error: forward reference to type (int, int)
test.d(2): Error: cannot implicitly convert expression (tuple(0,1)) of
type (int, int) to (int, int)
Error: cannot cast int to (int, int)