More on multiple return values [was: Re: Multiple return values]

[bearophile]

I don't like 'out' function arguments, from a logic point of view they feel 
unnatural and backwards (while 'ref' arguments are meaningful from a computer 
science point of view). I'd even like to see 'out' arguments deprecated when 
multiple return values are introduced as a bit of built-in syntax sugar for 
tuple de-structuring.

Beside their bad look, D 'out' arguments have some semantic characteristic 
that's bad:

Currently D allows you to write code like this, where foo lacks any assignment 
to its 'out' argument (I think the Ada compiler raises a compilation error 
here):


void foo(out int x, out int y) {}
void main() {}


The D compiler also sees nothing wrong in code like this:


void foo(out int x, out int y) {
    x = 3;
    y = 4;
}
void main() {
    int x = 1;
    int y = 2;
    foo(x, y);
}


But to me this looks like possible bug waiting to happen, because the values 1 
and 2 of x and y are always ignored, so they are always useless assignment (and 
at the call point you don't write something like this:  foo(out x, out y);  so 
you don't see that the x and y values will be ignored by foo).


A tuple syntax to return and unpack values (the pull request is already in 
GitHub) avoids all three problems, because the syntax is more logical, it's 
less easy to return values from foo without initializing them, and there is 
less risk of losing values of the return tuple if you initialize variables in 
place:


(int x, int y) foo() {
    return tuple(3, 4);
}
void main() {
    (int x, int y) = foo(); 
    // auto (x, y) = foo(); // supported alternative
}

Bye,
bearophile