What is the stance on partial initializers when declaring multiplevariables of the same type?

[Simen Kjaeraas]

On Fri, 22 Jul 2011 02:06:48 +0200, Jonathan M Davis <jmdavisProg at gmx.com>  
wrote:

> On 2011-07-21 16:54, Andrei Alexandrescu wrote:
>> On 7/21/11 6:44 PM, Simen Kjaeraas wrote:
>> > On Thu, 21 Jul 2011 23:40:08 +0200, bearophile
>> >
>> > <bearophileHUGS at lycos.com> wrote:
>> >> Nick Sabalausky:
>> >>> Crazy, nutty, wacky idea...
>> >>>
>> >>> float (a, b, c) = 0.0;
>> >>
>> >> I'd like some syntax sugar for tuples in D (especially for their
>> >> unpacking), that syntax goes against one of the most natural ways to
>> >> define tuples. So it's not a good idea.
>> >
>> > It is highly unlikely that D will ever adopt that syntax for tuples,
>> > due to the previously much-discussed comma operator (which, while
>> > uncommon, is useful at times). I believe the syntax that came out on
>> > top in earlier discussions was the upended hamburger bun, or banana
>> > syntax:
>> >
>> > (| float f, string s |) foo = (| 1.2, "Eh, whut?" |);
>>
>> Here's a crazy idea:
>>
>> auto foo = tuple(1.2, "Eh, whut?");
>
> Is this particular case, a built-in syntax buys you nothing, as you
> demonstrate. I think that the case that Bearophile is always looking for  
> is
> something like this:
>
> int i;
> float f;
>
> (i, f) = tuple(5, 2.2);

Ten minutes of hacking later:

///////////////////////////////////////
import std.typecons;
import std.typetuple;

template getType( alias A ) {
     alias typeof( A ) getType;
}

template getType( T ) {
     alias T getType;
}

@property
auto unpack( T... )( Tuple!( staticMap!( getType, T ) ) args ) {
     foreach ( i, e; T ) {
         T[i] = args.field[i];
     }
}

unittest {
     int n;
     string s;

     unpack!(n,s) = tuple(4, "O HAI");

     assert(n == 4);
     assert(s == "O HAI");
}
////////////////////////////////////////////

Please note that this is not heavily tested, and will likely fail under
some (read: many) circumstances.

Adding some more magic, one could probably do things like:

int n;
unpack!(UNUSED, n, UNUSED) = tuple("foo", 4, "bar");


-- 
   Simen