All right, here’s the plan: we’re going to determine which function object contains the operator() overload that would be chosen if we used a bare-bones overloader based on inheritance and using declarations, as illustrated in the question. We’re going to do that (in an unevaluated context) by forcing an ambiguity in the derived-to-base conversion for … Read more
After getting help from other answers and comments, and reading GCC source code and C++11 standard, I found that it is possible to parse a function type (its return type and its argument types) by using partial template specialization and function overloading. The following is a simple (and incomplete) example to implement something like std::function: … Read more
The C++ and C standards leaves a bunch of freedom to compilers. Compilers are free to count to 1 billion between every instruction, or only do so if an integer has a prime value in it. Decent “real” compilers don’t do this. This is a quality of implementation issue. Inlining function objects into something like … Read more
Update: This answer was the best solution in earlier versions of TypeScript, but there are better options available in newer versions (see other answers). The accepted answer works and might be required in some situations, but have the downside of providing no type safety for building up the object. This technique will at least throw … Read more
A functor is pretty much just a class which defines the operator(). That lets you create objects which “look like” a function: // this is a functor struct add_x { add_x(int val) : x(val) {} // Constructor int operator()(int y) const { return x + y; } private: int x; }; // Now you can … Read more