Multiple return values...

[bearophile]

Simen K.:

> Now, a pattern that our productive friend bearophile posted earlier was  
> this:
> 
> int[] foo();
> 
> (auto a, b) = foo();
> 
> --->
> 
> auto __t = foo();
> assert( __t.length > 0 );
> auto a = __t[0];
> auto b = __t[1..$];
> 
> Is this something we might also want?

That's not a good idea, because you don't know much about what 'b' contains.

Time ago I have written an example vaguely like that, but it was in the Python3 version. So a more similar translation is:

auto (a, $b) = foo();

The $ means: 'unpack all the remaining items inside the b tuple'. A similar syntax is cute to have, but it's not that important because it's not a very common need. And if people think it's so important, then it's possible to add it later (it's a purely incremental feature over the basic tuple unpacking syntax).

What's more commonly userful instead is tuple unpacking in foreach (this isn't the final syntax, it's just an idea) (Hara is willing to support this first one):

void spam((int x, int y)) {}
auto bar = [tuple(1,2,), tuple(3,4)];
foreach (tuple(x, y); bar) {}

And in function signatures (this is not the same as using tupleof at the call point):

void spam(tuple(int x, int y)) {}
spam(tuple(1,2))

Bye,
bearophile