functor

Suppose I have a few nested functors, e.g. List[Option[Int]] and need to call the map of the most inner one. Now I am using nested maps : scala> val opts: List[Option[Int]] = List(Some(0), Some(1)) opts: List[Option[Int]] = List(Some(0), Some(1)) scala> opts.map(o => o.map(_ + 1)) res0: List[Option[Int]] = List(Some(1), Some(2)) What if I have 3 nesting levels, for instance ? Is there any simple alternative to nested maps ? Yes, this is possible with scalaz.Functor: scala> import scalaz.Functor import scalaz.Functor scala> import scalaz.std.list._ import scalaz.std.list._ scala> import scalaz

I looked at past discussion but could not see why any of the answers are actually correct. Applicative <*> :: f (a -> b) -> f a -> f b Monad (>>=) :: m a -> (a -> m b) -> m b So if I get it right, the claim is that >>= cannot be written by only assuming the existence of <*> Well, let's assume I have <*> . And I want to create >>= . So I have f a . I have f (a -> b) . Now when you look at it, f (a -> b) can be written as (a -> b) (if something is a function of x, y , z - then it's also a function of x, y). So from the existence of <*> we get (a -> b) -> f a -> f b which again can be written as

I've found some good examples of functors on SO like this one, and all the convincing examples seem to use state in the class that defines operator() . I came across an example in a book that defines the function call operator without having state, and I can't help but feel like this is an awkward usage, and that a normal style function pointer, would be better than using operator() in every way here - less code, less variables (you have to instantiate the comparators), its probably more efficient due to the instantiation, and no loss of meaning or encapsulation (since it's just one function).

Why does the for_each call on functor doesn't update sum::total at the end? struct sum { sum():total(0){}; int total; void operator()(int element) { total+=element; } }; int main() { sum s; int arr[] = {0, 1, 2, 3, 4, 5}; std::for_each(arr, arr+6, s); cout << s.total << endl; // prints total = 0; } for_each takes the functor by value - so it is copied. You can e.g. use a functor which is initialized with a pointer to an external int. struct sum { sum(int * t):total(t){}; int * total; void operator()(int element) { *total+=element; } }; int main() { int total = 0; sum s(&total); int arr[] = {0,

I have this code: #include <iostream> #include <functional> struct A { int operator()(int i) const { std::cout << "F: " << i << std::endl; return i + 1; } }; int main() { A a; std::tr1::function<int(int)> f = std::tr1::ref(a); std::cout << f(6) << std::endl; } The aim is to pass the functor object by a reference_wrapper, in a way to avoid useless copy costructor calls. I expect the following output: F: 6 7 It works correctly with GCC >= 4.4.0, Visual Studio 2008 and with boost by substituting std::tr1 namespace with boost. It only doesn't work with the new Visual Studio 2010 both Express Beta

I'm trying to figure out what exactly are the rules for deriving Functor in Haskell. I've seen message postings about it, and I've seen test code about it, but I can't seem to find official documentation about what the rules are. Can someone please clarify and/or point me to the right place? To use deriving Functor you must enable the DeriveFunctor language pragma and apply it to a polymorphic type which has a covariant final type variable---in other words, a type which admits a valid Functor instance. It'll then derive the "obvious" Functor instance. There's been some concern in the past that

A recent question asked generally about boundaries between various Haskell classes. I came up with Handler as an example of a valid Functor with no sensible instance of Apply **, where class Functor f => Apply f where (<.>) :: f (a -> b) -> f a -> f b -- optional bits omitted. However, I've not yet been able to find an example of a valid Functor that cannot be made a valid (if senseless) instance of Apply . The fact that Apply has had (see update) but a single law, (.) <$> u <.> v <.> w = u <.> (v <.> w) seems to make this rather tricky. pigworker (Conor McBride) previously gave an example of