On Saturday, 12 September 2015 at 10:44:05 UTC, Pierre Krafft
wrote:
myfunc({return "x:"~x~"y:"-y;});
is infered to mean myfunc((x,y){return "x:"~x~"y:"-y;});
while
myfunc({return "y:"~y~"x:"~x;});
is infered to mean myfunc((y,x){return "y:"~y~"x:"~x;});
which is not what I expect since the lambda I want is
myfunc((x,y){return "y:"~y~"x:"~x;});
This can lead to subtle bugs which are very hard to see.
I don't think this is what the OP was suggesting. As far as I
understand, the suggestion was that the lambda's arguments would
be inferred from the function argument in higher order's function
signature - not from the ones used in the lambda's body as you
suggest.
So, `myfunc` will be declared as:
void myfunc(string delegate(string x, string y)) { // ...
And when the compiler see `myfunc({return "x:"~x~"y:"-y;});`,
it'll see that `x` and `y` appear in the function argument's
definition and match them accordingly. This means that
`myfunc({/*...*/})` will be inferred to `myfunc((x,y) {/*...*/})`
no matter what the order of argument usage in the lambda's body
is - because in the function's signature the arguments are `x`
and `y` in that order.
