static arrays becoming value types

[Andrei Alexandrescu]

language_fan wrote:
> Wed, 21 Oct 2009 10:48:34 -0500, Andrei Alexandrescu thusly wrote:
> 
>> language_fan wrote:
>>> Wed, 21 Oct 2009 11:07:29 -0400, Robert Jacques thusly wrote:
>>>> My issue was that all your example _showed_ was nominal typing. Though
>>>> I didn't mention it by name, I did mention that if SOL tuples had
>>>> structural typing, it might would be a different story. (Well,
>>>> until/if opImplicitCast was implemented, as it would allow for
>>>> structural typing.)
>>> Why do you insist on using nominal typing for tuples and the library
>>> defined "literal". If I want plain old tuples without any kind of type
>>> name, why should I care about extra hand waving needed to make it work.
>> I'm late in this dialog, but I'm not seeing an impediment here. What
>> does it matter to you that tuples actually have a name vs. not having a
>> name at all?
> 
> Using tuples in D is a major pain in the ass. In fact it has been made so 
> hard that people start avoiding the feature like plague.

How do you know what "people" do?

> I wrote some 
> test code to reveal how inconsistent their semantics are. Note that you 
> need the built-in tuples for some stuff, like assigning and mixed value/
> type tuples. Stuples can only be used as values and when the auto-
> flattening is not desired.
> 
>>>> STARTS HERE
> 
> template Tuple(T...) { alias T Tuple; }

Why do you define Tuple instead of using the standard std.typecons.tuple?

> struct STuple(T...) {
>   T t;
> }

Why do you insist on defining another tuple type instead of using the 
one provided by the standard library?

> void main() {
>   Tuple!(int,int) a; // typeof(this) *is* the official tuple type
>   STuple!(int,int) b;  // this is actually a struct
> 
>   a = Tuple!(1,1);  // ok

That doesn't work for me at all (with std.typecons.Tuple). I think there 
is confusion about a couple of things. One is that Tuple!(int, int) is a 
type that contains two ints, whereas Tuple!(1, 1) is a type that 
contains two compile-time integral values. So if you write:

a = Tuple!(1, 1);

that is as good syntactically as:

a = int;

which I hope you agree shouldn't quite go through. Write this:

Tuple!(int,int) a;
a = tuple(1, 1);

or this:

auto a = tuple(1, 1);

>   // Tuple!(int,int) a2 = Tuple!(1,1); // WTF? Error: cannot implicitly 
> convert expression (tuple(1,1)) of type (int, int) to int

Yeah, WTF that doesn't work either:

int a2 = int;

>   auto a3 = Tuple!(1,1); // ok

Not ok on my machine, nor it should be ok as this is also not ok:

auto a3 = int;

>   b = STuple!(int,int)(1,1); // no easier way? make_tuple!(1,1) ?

Yeah try tuple(1, 1) in conjunction with std.typecons.Tuple.

>   STuple!(int,int) b2 = STuple!(int,int)(1,1); // ok, but very verbose

Well write this:

auto stuple(T...)(T args) {
     return STuple!(T)(args);
}

>   auto e1 = a[0];  // ok

This doesn't work because of a bug in the compiler, but this does with 
std.typecons.Tuple:

auto e1 = a.field[0];

etc. etc. etc.

I'm sure you make a couple of good points, but they are difficult to 
find. I suggest you peruse std.typecons.Tuple and submit any bugs you 
find to bugzilla.


Andrei