On 7/21/11 7:27 PM, Simen Kjaeraas wrote:
On Fri, 22 Jul 2011 02:06:48 +0200, Jonathan M Davis
<[email protected]> 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
>
> <[email protected]> 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
