Hacker News Reader

Comment by TeMPOraL | Hacker News Reader

A slightly saner syntax, compared to:

  const auto iAmANestedFun = [stuff](stuff) -> stuff { ... }

Particularly, if we could assume that nested functions automatically and properly capture the arguments to the parent function.

View on HN

Not sure I like implicit capture more than explicit capture but there's [=] if you need it. Also, the return value as the article mentions is optional, so most lambdas look like

    const auto nestedfunc = [=](a,b) { /* */ };

Which isn't that much different to me than

    { /* some scope */
        function nestedfunc(a,b) { /* */ }
    }

const and auto are needed but because it's C++. Beyond that, you have an equals sign which is needed here but [=] which is three characters. Again, small differences, not sure why it looks that much worse.

Now that we know lambdas they are fine, but to answer the question "why is there a book" in the beginning of the thread, it is more or less because it is not as obvious as gcc's c extension.

What is so cryptic that there needs to be a separate syntax change?

    auto triple = [](auto x){ return 3 * x; };

Ye well nothing when we have already are to lambdas.

No need to spell each variable nor give a return type:

   auto f = [&](...) { ... };

That covers the majority of cases.

> Particularly, if we could assume that nested functions automatically and properly capture the arguments to the parent function.

well, how would you do that ?

I don’t know any other language with lambdas which requires me to spell out explicitly which variables it should close over... so you tell me how Java, Scala, Clojure, Kotlin, Python, JavaScript, Rust, Go, C# and tens of others managed this clearly impossible feat of engineering.

Forced heap allocation and GC of course that would be unacceptable in C++.

IIRC Rust uses capture modifiers similar to C++.

Rust is not really the same as C++ here, you get "the compiler infers how to capture things" as the default behavior, and "take everything by value", which happens with the "move" keyword. We've found that these two cases cover the vast, vast, vast majority of usage, and so C++-style specific capture modifiers aren't necessary. You can emulate C++ style stuff by taking references outside of the closure and using move to capture only the reference.

> I don’t know any other language with lambdas which requires me to spell out explicitly which variables it should close over

PHP closures have to specify which variables they close over, and whether it's done by-val or by-ref [0].

Nowadays there's also a shorthand single-expression-closure syntax that closes implicitly and by value [1].

[0]: https://www.php.net/manual/en/functions.anonymous.php#exampl...

[1]: https://www.php.net/manual/en/functions.arrow.php

By having the compiler generate the equivalent of [&args...], where args are names of arguments in the parent function's header.

why [&args...] and not [args...] ? do you really want to capture by reference when you're setting a lambda as a callback ? (likewise in the other direction - tons of arguments for every default, already debated ad nauseam)

And why specifically args instead of all locals?

You mean like this? https://godbolt.org/z/jvG3hY

Reply on news.ycombinator.com