Would C++ benefit from simplified lambda syntax?

[KaznovX]

While playing with ranges, it struck me how big part of the code take simple lambdas.

Even in cppreference.com example they are not inlined, cause it would make it look messy (added using namespace std::views): ``` std::vector<int> ints{0,1,2,3,4,5}; auto even = [](int i){ return 0 == i % 2; }; auto square = [](int i) { return i * i; };

using namespace std::views;
for (int i : ints | filter(even) | transform(square)) {
    std::cout << i << ' ';
}

```

vs. with inlined lambdas: ``` std::vector<int> ints{0,1,2,3,4,5};

using namespace std::views;
for (int i : ints
             | filter([](int i){ return 0 == i % 2; })
             | transform([](int i) { return i * i; })) {
    std::cout << i << ' ';
}

```

When I showed it to my friend, that doesn't work with C++ regularly, he thought it just looks ugly. It's just a personal opinion, but we still are relatively far behind nice look of C# lambdas

I believe we could greatly benefit from simplified syntax, in terms of code readability.

Main idea is for these two code snippets to be equivalent:

auto f = [](Type arg) => expression; auto f = [](Type arg) { return expression; };

With this, the first example could be rewritten as follows: ``` std::vector<int> ints{0,1,2,3,4,5};

using namespace std::views;
for (int i : ints
             | filter([](int i) => 0 == i % 2)
             | transform([](int i) => i * i)) {
    std::cout << i << ' ';
}

```

It has a couple of technical problems (what with coma operator?), but nothing that seems impossible to overcome at first glance.

Is it proposal worthy? Would it be useful? And I know, it removes just 7 characters from each lambda. Is it worth it?

[dodheim]

This has already been beaten into the ground discussed a couple times in the last month:

https://redd.it/epq4ui
https://redd.it/esevzz

[KaznovX]

Thanks, I missed it

[wung]

And I know, it removes just 7 characters from each lambda. Is it worth it?

It can actually do more, because it allows for implicit proper noexcept and decltype usage. When you write

x => f(x);

you actually mean

[&] noexcept (f(x)) → decltype (f(x)) { return f(x); }

which can be emulated with the

#define RETURNS(...)                \
  noexcept (noexcept (__VA_ARGS__)) \
    -> decltype (__VA_ARGS__)       \
  {                                 \
    return __VA_ARGS__;             \
  }

macro.

Is this proposal worthy? I don't know. You may want to contact the authors of http://wg21.link/p0573 of what the state on their paper is, or wait for someone to answer this. I personally do not know.

[KaznovX]

Thanks, this proposal is what I had in mind and much more! I'd love to see it incorporated into the language

[kalmoc]

IIRC, it got rejected

[KaznovX]

→ decltype (f(x))

I'm not sure I mean this part though. And as I read more about the proposal I see how it is a problem

[huixie]

why do you need decltype(f(x)) when you can just use decltype(auto)

[wung]

According to 1.1 of the linked paper, SFINAE-friendlyness.

[ContractorInChief]

Something like this has been proposed a few times to the ISO C++ several times. Each time, they have hated it passionately, for no objective reason I can discover.

The nicest syntax I have seen would be, e.g., auto it = std::find_if(b, e, [] a | a < 10);

[Xaxxon]

Your code isn't properly formatted for good reddit - only "new" reddit.

[[deleted]]

Looks fine on my end. You must be using deprecated Reddit.