It is not obvious why one is not allowed; nested functions were proposed a long time ago in N0295 which says: We discuss the introduction of nested functions into C++. Nested functions are well understood and their introduction requires little effort from either compiler vendors, programmers, or the committee. Nested functions offer significant advantages, […] … Read more
UDATE. See this new library providing functor and monad operators for plain callback-based functions that do not have the issues with theneables: https://github.com/dmitriz/cpsfy The JS Promise is neither a Functor nor an Applicative nor a Monad It is not a functor, because the composition preservation law (sending compositions of functions to compositions of their images) … Read more
I’ve accidently written a Haskell Functors Tutorial I’ll answer your question using examples, and I’ll put the types underneath in comments. Watch out for the pattern in the types. fmap is a generalisation of map Functors are for giving you the fmap function. fmap works like map, so let’s check out map first: map (subtract … Read more
At least four good reasons: Separation of concerns In your particular example, the functor-based approach has the advantage of separating the iteration logic from the average-calculation logic. So you can use your functor in other situations (think about all the other algorithms in the STL), and you can use other functors with for_each. Parameterisation You … Read more
Has anyone noticed that the accepted answer only works with trivial cases? The only way that function<>::target() will return an object that can be bound to a C callback, is if it was constructed with an object that can be bound to a C callback. If that’s the case, then you could have bound it … Read more
You can write function_traits class as shown below, to discover the argument types, return type, and number of arguments: template<typename T> struct function_traits; template<typename R, typename …Args> struct function_traits<std::function<R(Args…)>> { static const size_t nargs = sizeof…(Args); typedef R result_type; template <size_t i> struct arg { typedef typename std::tuple_element<i, std::tuple<Args…>>::type type; }; }; Test code: struct … Read more
One of the primary goal when overloading operator() is to create a functor. A functor acts just like a function, but it has the advantages that it is stateful, meaning it can keep data reflecting its state between calls. Here is a simple functor example : struct Accumulator { int counter = 0; int operator()(int … Read more
Yes, it is valid. As for making it work with functors as well, the usual solution is something like this instead: template <typename F> void doOperation(F f) { int temp=0; f(temp); std::cout << “Result is ” << temp << std::endl; } which can now be called as either: doOperation(add2); doOperation(add3()); See it live The problem … Read more
A type constructor which is not a Functor: newtype T a = T (a -> Int) You can make a contravariant functor out of it, but not a (covariant) functor. Try writing fmap and you’ll fail. Note that the contravariant functor version is reversed: fmap :: Functor f => (a -> b) -> f a … 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