Named arguments

[bauss]

On Tuesday, 24 October 2017 at 22:08:57 UTC, Jonathan M Davis 
wrote:
> On Tuesday, October 24, 2017 13:36:00 H. S. Teoh via 
> Digitalmars-d wrote:
>> On Tue, Oct 24, 2017 at 01:22:41PM -0600, Jonathan M Davis via
>> > It also wouldn't play well with separate compilation unless 
>> > the parameter names were mangled into the function names, 
>> > and symbol names in D are already too often too long due to 
>> > idioms like Voldemort types creating really long symbol 
>> > names. Recent work on the compiler has reduced that problem, 
>> > but adding more information to mangled names would 
>> > definitely not help.
>>
>> [...]
>>
>> Nah.  Parameter names are a concept only necessary at 
>> compile-time.  All you need is to import the function 
>> declaration with the right parameter names, and on the 
>> caller's side the compiler will always emit the arguments in 
>> the right order.  So no need to mangle parameter names at all.
>
> Except that things get a bit interesting with regards to stuff 
> like .di files. Without the parameter names being mangled in, 
> it would be possible for the parameter names in the .di files 
> to not match the ones in the .d files. It's possible for that 
> now, but right now, it doesn't matter, whereas with named 
> arguments, it would matter. To some extent, you could probably 
> get away with it, because the code that compiles against the 
> .di files wouldn't normally be compiled against the .d files or 
> vice versa, but it means that switching whether you used the 
> .di files or the .d files could break code, whereas now, it 
> wouldn't.
>
> Now, .di files are kind of terrible to use anyway, but 
> introducing named arguments would just make them even more 
> fragile if the parameter names aren't part of the function's 
> mangled name.
>
> - Jonathan M Davis

Pardon me, but I don't understand how named arguments can break 
anything by being added, as long as you don't add an additional 
syntax to the function declaration.

void foo(int bar, int baz)
{
}

in .di

void foo(int bar, int baz);

...

Can be called like:

foo(1, 2);

foo(bar: 1, baz: 2); becomes foo(1, 2);

foo(baz: 2, bar: 1); becomes foo(1, 2); because it matches the 
argument index.

int bar = 1;
int baz = 2;
foo(bar, baz);