D has a few ways of writing lambda expressions / anonymous functions:

    x => doSomething()
    { doSomething(); }
    (){ doSomething(); }

While the flexibility is great, there's a hidden issue for those programmers who come from different languages and are used to writing:

    x => { doSomething(); doSomethingElse(); }

At first glance, this may seem okay but what's actually happening is that this is a lambda returning a lambda. The correct way would be to rewrite this as one of:

    x => { doSomething(); doSomethingElse(); }()
    (x){ doSomething(); doSomethingElse(); }

This particular issue as popped up twice in the last couple days alone and presumably many more times in the past:

http://forum.dlang.org/thread/qsayoktyffczskrnmgxu@forum.dlang.org
http://forum.dlang.org/thread/thgyqyarccinzuqhcjtf@forum.dlang.org

I'm proposing that we add a warning to the compiler for this particular case. If the programmer intended to return a lambda, then rewrite the expression as one of:

    x => (){ doSomething(); doSomethingElse(); }
    x => ({ doSomething(); doSomethingElse(); })

On Monday, 2 May 2016 at 15:52:34 UTC, Xinok wrote:
> I'm proposing that we add a warning to the compiler for this particular case. If the programmer intended to return a lambda, then rewrite the expression as one of:

I agree, forcing people to rewrite it is a good idea.

On 02.05.2016 19:31, Adam D. Ruppe wrote:
> On Monday, 2 May 2016 at 15:52:34 UTC, Xinok wrote:
>> I'm proposing that we add a warning to the compiler for this
>> particular case. If the programmer intended to return a lambda, then
>> rewrite the expression as one of:
>
> I agree, forcing people to rewrite it is a good idea.

I don't think { ... } as shorthand for (){ ... } is necessary or particularly useful in the first place.

On Monday, 2 May 2016 at 20:11:53 UTC, Timon Gehr wrote:
> I don't think { ... } as shorthand for (){ ... } is necessary or particularly useful in the first place.

Indeed. I don't think =>x as a shorthand for {return x;} is really worth it either... D has a ridiculous number of variations on function syntax.

But I don't expect any of them to be removed either.

On 02.05.2016 22:20, Adam D. Ruppe wrote:
> On Monday, 2 May 2016 at 20:11:53 UTC, Timon Gehr wrote:
>> I don't think { ... } as shorthand for (){ ... } is necessary or
>> particularly useful in the first place.
>
> Indeed. I don't think =>x as a shorthand for {return x;} is really worth
> it either... D has a ridiculous number of variations on function syntax.
> ...

function int delegate()delegate(int)(int y){ return (x)const=>{ return x+y;}; }; // :o)

(=>x is not valid.)

> But I don't expect any of them to be removed either.

Most of them don't hurt much (unlike { ... }). It's quite annoying that function definition syntax and delegate literal syntax are inconsistent though. E.g. lambda syntax should be usable for named functions (int x()=>3;).