Breaking ";" rule with lambda functions

[Andrey Zherikov]

On Monday, 1 August 2022 at 14:15:31 UTC, pascal111 wrote:
> We all know the strange syntax of lambda function within filter 
> algorithm like "auto r = chain(a, b).filter!(a => a > 0);".

TBH I don't find lambda syntax strange - it's pretty nice and 
there are two forms (unlike in C++): short one (`a => a > 0`) and 
long one (`(a) { return a > 0; }`).

Compare to C++ lambda syntax: `[](auto a) { return a > 0; }`

> My note is, don't we break D rules by leaving ";" after lambda 
> function syntax?!

There is no breakage: `a => a > 0` in this example is a 
(template) parameter to `filter` function. You can rewrite it in 
different ways, like: `filter!((a) { return a > 0; })` or

```d
alias criteria = (a) { return a > 0; };
auto r = chain(a, b).filter!criteria;
```

or even longer:

```d
auto criteria(T)(T a)
{
     return a > 0;
}

auto r = chain(a, b).filter!criteria;
```

> Many of D rules are taken from C, we know that, so a general 
> basic rule is to put ";" after each statement

I think this is more or less correct but I personally like that I 
don't need to put ";" after definition of a class or struct 
unlike in C.

> so the previous statement of filter should be "auto r = 
> chain(a, b).filter!(a => a > 0;);"? Why D leaves ";" in this 
> case?

No. it should not. The statement here is `auto r = chain(a, 
b).filter!(a => a > 0);`, not `a => a > 0`. If you use longer 
version of lambda syntax then yes, you'll see ";" there: `auto r 
= chain(a, b).filter!((a) { return a > 0; });` but ";" is not 
after lambda function, it's inside because you have `{...}` 
function body (which, I believe, is defined as a sequence of 
statements so you have ";" there).

Again, both `a => a > 0` and `(a) { return a > 0; }` are just 
parameters to `filter` function. Parameters are not terminated 
with ";". This is the same as in C - you are not adding ";" after 
function parameter:
```cpp
auto is_even = [](int i){ return i%2 == 0; };
auto result = std::find(..., ..., is_even);
```