On Sunday, 6 March 2016 at 17:35:38 UTC, Seb wrote:
Hey all,
I wanted to relive the discussion on named arguments and ping
for its current status.
There is a bunch of examples to show how needed a unified
solution for this problem is, let me give you one from phobos
[2].
```
// I want to allow downsizing
iota(10).sliced!(Yes.replaceArrayWithPointer,
Yes.allowDownsize)(4);
```
There is of course the alternative solution that an author
overloads his function to the utmost, but this results in
complexity and duplicated code (see e.g. redBlackTree in phobos
[3]).
Currently the best solution AFAICT is to use a struct to pass
such flags, like
```
struct Options{int x; int y=1; int z=2;}
auto fun(Options options)
{
return options.x + options.y + options.z;
}
Options options = {x: 4, z: 3};
auto a=fun(options);
```
There are also other workarounds as discussed in [1] (e.g. with
CTFE string analysis [4]).
I general there two solutions to this problem
1) get true named parameters support in D (probably complicated)
2) allow struct inits in functions - e.g. fun({x: 4})
For 2) Jacob Carlborg has proposed something similar three
years ago. In his case he proposed anonymous structs which
might be more generally applicable, however just created the
struct seems easier and allows more
It doesn't seem that complicated to me as the compiler already
knows the type of the argument.
Using structs is not ideal, because one can't require
parameters, but this can be solved by having those parameters
as normal ones like `sliced(4, {allowDownsize: true})` and it
creates some maybe unnecessary overhead.
However it is probably the easiest solution right now.
What are your thoughts on this issue?
On a side note: many templated functions are also complicated
and experiencing this issue, so it also might be worth to think
about this issue too ;-)
Cheers,
What about this idea? A new word "as" or something similar.
You have defined:
int fun(int x=100, int y=100, int r=100){...}
int xpos=100;
int ypos=100;
int radius=50;
Now you are allowed to call:
fun(xpos,ypos,radius); // normal nothing has changed!
Call with "as":
fun(ypos as y, xpos as x, radius as r); // different order!
or
fun(radius as r); // defaults values are used.
<=>
fun(,,radius);
The compiler is looking for the right mapping?
