Multiple return values...

[Andrei Alexandrescu]

On 3/15/12 5:44 PM, foobar wrote:
> On Thursday, 15 March 2012 at 18:23:57 UTC, Andrei Alexandrescu wrote:
>>
>> I understand how the draw of reaching for new syntax is extremely
>> alluring. I used to fall for it much more often, but over years I have
>> hardened myself to resist it, and I think that made me a better
>> language designer. In this stage of D, I think we should all have an
>> understanding that adding syntax is not a win. Instead, it is an
>> acknowledgment that the existing language, for all its might, is
>> unable to express the desired abstraction. This is sometimes fine
>> (such as in the case of introducing multiple new symbols from one
>> tuple), but generally the question is not "why couldn't we add syntax
>> X?" but instead "why should we add syntax X?"
>>
>>
>> Andrei
>
> I agree that this is an acknowledgement of the current language's
> inability to express the abstraction. That's why many people ask for it
> to be added in the first place. We should add this syntax because it
> *is* impossible ATM to implement the required abstraction.

I think this is a reasonable request:

(auto a, b) = fun();

--->

static assert(fun().length == 2);
auto __t = fun();
auto a = __t[0];
auto b = __t[1];

To express the idiom in the example, the programmer needs to do the 
expansion by hand, which is verbose and introduces unnecessary symbols. 
So the language as is has an expressiveness problem (albeit not a 
pernicious one) that is nice to solve.

It doesn't seem to me this is a reasonable request:

a, b = b, a;

--->

auto __t0 = b;
auto __t1 = a;
a = __t1;
b = __t0;

This is because the alternative swap(a, b) is not only competitive, but 
arguably better at least in some respects.

> A good design should strive to provide general features instead of
> special cases (E.g. swap is limited to the 2-tuple case). Also, why
> force an overhead of a function call on such a basic feature as
> assignment? Is swap usually inlined by the compiler?

Sorry, this is grasping at straws.

1. swap can be easily generalized to take any number of arguments. I'm 
very happy that's possible, we've expended great efforts on making 
variadic functions as powerful as they are. But nobody asked for swap 
with many arguments until now. Which segues into...

2. When was the last time you needed to swap arbitrary numbers of 
elements, and so badly and frequently, you needed a new language feature 
for that?

3. Function overhead is solved by inlining, not by adding new features. 
That improves all functions, not only swap.


Andrei