Re: One document about Go

[bearophile]

Lurker:

>Combine the 2 things into one struct and return by value. Multi-value return 
>makes for hard to comprehend code. So, IMO, it's hardly syntactic sugar: it's 
>syntactic grafitti.<

You are very wrong, multiple return values are good, if they have a good enough 
syntax. Regarding this C/C++/D/Java/C#/etc are worse and Python and Go are 
better.

Multiple return values make code simpler to write, simpler to read and remove 
the need for silly and logically ridiculous features like "out" arguments (an 
input value that is a return? This is making things go backwards). D language 
isn't even able to tell if an "out" argument has being used before it is 
assigned inside the function (as C# compiler is able to, because in C# using 
uninitialized variables is an error) This is awful and surely worse than 
multiple return values.

import std.stdio: writeln;
import std.conv: to;

int foo(int x, out string s) {
    writeln(s);
    int result = x * x;
    s = to!string(result);
    return result;
}

void main () {
    string s;
    writeln(s);
    int r = foo(10, s);
    writeln(r);
}


A possible syntax for D multiple return values:


import std.stdio: writeln;
import std.conv: to;

(int, string) foo(int x) {
    int result = x * x;
    return (result, to!string(result));
}

void main () {
    (int r, string s) = foo(10);
    writeln(s);
    writeln(r);
}


The second is simpler to understand code and less bug-prone than the first.


An alternative syntax:

import std.stdio: writeln;
import std.conv: to;

[int, string] foo(int x) {
    int result = x * x;
    return [result, to!string(result)];
}

void main () {
    [int r, string s] = foo(10);
    writeln(s);
    writeln(r);
}

------------

Walter Bright:
> C got it right and it doesn't need fixing.

I have never programmed in Go, but keep in mind that Go designers are expert 
language designers and programmers. They aren't stupid people.

Anyway, this is not so important. Named arguments and multiple return values 
are quite more important (for D3).

Bye,
bearophile