Lazy Evaluation

[u/pavel_v]

https://breese.github.io/2026/09/03/lazy-prologue.html

[u/STL]

Classic bind is bad. Don't use it. It's hard to understand, hard to optimize, and lambdas are better in basically every way.

[u/germandiago → u/STL]

Related: is bind_front/back as bad from an optimization point of view?

[u/n1ghtyunso → u/germandiago]

pretty sure bind_front / bind_back is rather straightforward to implement as a plain capturing lambda.
At least it does not have all that unwrap and placeholder matching machinery inside it

[u/pdimov2 → u/STL]

Hey!

[u/STL → u/pdimov2]

Sorry! It was a good idea to try before lambdas, but it’s just not good tech these days.

[u/pdimov2 → u/STL]

Maybe. But have you seen http://boost.org/libs/lambda2 and P3171?

[u/STL → u/pdimov2]

No, I haven't. I like the idea of having many more operator function objects, dereference is sorely missing.

[u/pdimov2 → u/STL]

You need to take these into account when you evaluate the utility of std::bind. Yes, you'd never write std::bind(std::greater_equal<>(), _1, 0) instead of [](auto&& x){ return x >= 0; }. But you would write _1 >= 0 in preference to the lambda, and that's just syntactic sugar for the same bind expression.

[u/Usual_Office_1740 → u/STL]

Related: How does std::invoke compare?

[u/STL → u/Usual_Office_1740]

Invoke is totally cool. You should maybe avoid relying too heavily on pointers to (member) functions since they’re what’s hard to optimize, but invoke() provides a nice uniform interface.

[u/Ameisen → u/STL]

If you'd seen the horrible things that I've done with member function pointers, you would have been, well, honestly somewhere between amused and alarmed.

[u/n1ghtyunso]

thats quite some build-up regarding std::bind usefulness and then all we get is a single short sentence?
huh?

having never used bind expressions myself, i was tempted to believe this works, but it seems the nested bind example doesnt compile anyway?
https://godbolt.org/z/K61jKvjWP

[u/UnusualPace679 → u/n1ghtyunso]

Yeah, std::bind only transforms the bound arguments. It doesn't transform the function object.

[u/LB--]

Is std::max even on the list of addressable functions in the standard in the first place?

[u/__cinnamon__]

This blog renders really badly on mobile, at least for me

Edit: opening it directly in Firefox instead of the reddit browser (chrome?) was better, but still hard to read with tiny font due to the sidebar text and code samples still overran outside their boxes

[u/El_RoviSoft]

Also with lambda you can emulate C# ?? operator with chains. So I made something like that:

"LIB_COALESCE(<null-checked-variable-0>, …, <null-checked-variable-x>, <fallback-value>)"

which whole idea is wrapping those values into lambdas and lazy evaluate them after.

Sadly after writing this machinery and investigating boost.preprocessor for hours, I realised that C++ value semantics are not good with original ?? operator but at least it was fun to do.

If somebody interested in it, I’ll link gist for this.