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

[Andrei Alexandrescu]

On 7/21/11 7:27 PM, Simen Kjaeraas wrote:
> 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");

A similar method was proposed by a Phobos contributor (Shoo I think?) at 
a point under a different name. I rejected it because it was difficult 
to make safe (it saved the addresses of its arguments). Yours is safe 
though, but doesn't allow expressions e.g.

unpack!(a[0], a[1]) = tuple(1, 1);

It's an interesting idea though.


Andrei