The point being made here is heavily obfuscated to my eye due to the seemingly needless use of std::invoke when working with the lambda cases (which, even if useful for some reason, is not needed to make the point of this article), but when I finally figured out what is being requested all I could think of is "that functionality of std::bind is horrific and surprising and despite going into this article thinking that of course bind solves a slightly different problem to lambdas in a more readable way, you have now convinced me that std::bind should be deprecated ASAP" (though as it came into existence in the same version of C++ as lambda functions, I mostly end up questioning why it ever existed).

Essentially, in order to provide something that sort of feels like lambda functions, but entirely in templates, the placeholder arguments do not end up locked to a single expression--instead of returning something semantically like a function, std::bind returns something that might be better described as a partial syntax tree that happens to be something you can call as a function, at which point it is only then wrapped up as a function and all subexpression parameters are bound to arguments--and so if you bind something and include in it a bound function, that function is not passed as a value like you would expect: its parameter is hoisted and it becomes a call expression in the new bound composite. The author likes this behavior for some reason, but I can't figure out why it would ever be considered to be a feature and it is trivially simulated with lambdas (while the opposite is not true).