Some thoughts about C and D, return data through parameters

[ketmar]

cosinus wrote:

> So my question is would it be a good idea to have some kind of implicit 
> declarations of variables that are used as parameters:
>
> ```D
> int add(decl ref int c, int a, int b);
>
> // ...
>
> // c is unknown here
>
> if(add(c, 123, 456)) {
>      writeln("error!");
> }
> // c is implicit declared at the function-call above.
> assert(c == 579);
> ```

D already has one such construct, `foreach`. and it is a huge misdesign. it 
is *absolutely* not clear from the code that `c` is introduced by a 
function call. exactly like with `foreach (c; ...)`, any sane person 
expects that just using variable name without any type prepended means 
"let's use already declared variable `c`". the ONLY place where this 
uniformity is broken now is `foreach`, and this is already bad.

note that D devs stubbornly insists that `auto` is not a type placeholder, 
but a storage qualifier, like `static`, so you can't write `foreach (auto 
c; ...)` (and compiler rejects such code). yet, `if (auto c = ...)` is 
perfectly allowed, and here `auto` is type placeholder. talking about 
consistency, yeah.

anyway, adding yet another broken promise (aka illogical inconsistency) 
into language won't do any good. each inconsistency makes code harder to 
read and understand.