This is core issue 728, which was filed before generic lambdas were a thing. You mentioned generic lambdas and that they were identical to local classes with corresponding member template operator(). However, they actually aren’t, and the differences are related to implementation characteristics. Consider template <typename T> class X { template <typename> void foo() { … Read more
What are the two lines declaring overloaded, just above int main(), mean? The first one template<class… Ts> struct overloaded : Ts… { using Ts::operator()…; }; is a classic class/struct declaration/definition/implementation. Valid from C++11 (because use variadic templates). In this case, overloaded inherits from all template parameters and enables (using row) all inherited operator(). This is … Read more
I think this is a subtle implementation of a Monad-like thing, specifically something in the same spirit of the continuation monad. Monads are a functional programming construction used to simulate state between different steps of a computation (Remember that a functional language is stateless). What a monad does is to chain different functions, creating a … Read more
Perfect capture in C++20 template <typename … Args> auto f(Args&& … args){ return [… args = std::forward<Args>(args)]{ // use args }; } C++17 and C++14 workaround In C++17 we can use a workaround with tuples: template <typename … Args> auto f(Args&& … args){ return [args = std::make_tuple(std::forward<Args>(args) …)]()mutable{ return std::apply([](auto&& … args){ // use args … Read more
C++14 generic lambdas are a very cool way to generate a functor with an operator () that looks like this: template <class T, class U> auto operator()(T t, U u) const; But not like this: template <class T> auto operator()(T t1, T t2) const; // Same type please Nor like this: template <class T, std::size_t … Read more