The Evolutions of Lambdas in C++14, C++17 and C++20

Post by adamrezich » Mon, Dec 13, 2021, 7:17 PM UTC

MauranKilom wrote: post #33

vitus wrote: post #23

> Even if you don’t need to handle several types, this can be useful to avoid repetition and make the code more compact and readable. ... > namespace1::namespace2::namespace3::ACertainTypeOfWidget Deeply nested namespaces are problematic in themselves due to namespace resolution (e.g. see https://abseil.io/tips/130 ), but templates should never be an answer to "my type is too long to type out". You're hurting yoursel…

> templates should never be an answer to "my type is too long to type out" Eh, in some cases it's a wash. std::vector > objects; // ... auto it = std::find_if(objects.begin(), objects.end(), [](auto& widget) { return widget->x == 1; }); Sure, you could repeat the type `std::unique_ptr ` in the lambda, but that's just noise. You don't spell out the types like that either in, say, C#. Yes, compilation time is an epsilo…

Post by klyrs » Mon, Dec 13, 2021, 9:23 PM UTC

gsliepen wrote: post #26

bruce343434 wrote: post #3

Earlier quoted context omitted.

syntactical disambiguation, there's already something called "the most vexing parse". C++ is full of little holes like these and getting rid of auto would surely at least double compile times or at worst make parsing C++ actually impossible.

Yes, those things creep up in various places. Some are fixed, like when you have std::vector > where it used to give an error because it thought >> was an operator. But recently I discovered this one: int x[100] = {}; // just a regular array int val = x[[]{return 42;}()]; // compile error! Once again, greedy parsing is the culprit; here it thinks [[ is the start of an attribute.

Post by kllrnohj » Mon, Dec 13, 2021, 10:00 PM UTC

tialaramex wrote: post #45

cjfd wrote: post #27

Earlier quoted context omitted.

Yes, deeply nested namespaces are not nice. I think boost really dropped the ball on this. boost::asio::ip::tcp should have been boost::tcp. Are they trying to be as bad as java?

As the article explains it's not "as bad as Java" it's worse, what Java does actually makes sense in Java, maybe you have to type slightly more characters but Java is already a verbose language best suited to heavy tool-assist. However it doesn't make sense in C++ because the benefits Java gets don't apply and the price is heavier. There are a bunch of things like this in C++ where superficially C++ feature X is like…

Post by gpderetta » Mon, Dec 13, 2021, 10:19 PM UTC

nickysielicki wrote: post #66

steerablesafe wrote: post #14

Earlier quoted context omitted.

That is not really the same. `std::function` is a heavy-weight type-erased wrapper over callable types.

Unfortunately it’s the only way to get a recursive lambda, as far as I’m aware.

Post by vitus » Mon, Dec 13, 2021, 11:34 PM UTC

MauranKilom wrote: post #33

vitus wrote: post #23

> Even if you don’t need to handle several types, this can be useful to avoid repetition and make the code more compact and readable. ... > namespace1::namespace2::namespace3::ACertainTypeOfWidget Deeply nested namespaces are problematic in themselves due to namespace resolution (e.g. see https://abseil.io/tips/130 ), but templates should never be an answer to "my type is too long to type out". You're hurting yoursel…

> templates should never be an answer to "my type is too long to type out" Eh, in some cases it's a wash. std::vector > objects; // ... auto it = std::find_if(objects.begin(), objects.end(), [](auto& widget) { return widget->x == 1; }); Sure, you could repeat the type `std::unique_ptr ` in the lambda, but that's just noise. You don't spell out the types like that either in, say, C#. Yes, compilation time is an epsilo…

    std::unique_ptr widget = std::make_unique();

    using UniqueWidget = std::unique_ptr;
    // ...
    std::vector objects;
    // ...
    auto it = std::find_if(objects.begin(), objects.end(), [](UniqueWidget&) { return widget->x == 1; });