monads

Suppose I have this monadic class: case class Foo[A](xs: List[A]) { def map[B](f: A => B) = Foo(xs map f) def flatMap[B](f: A => Foo[B]) = Foo(xs flatMap f.andThen(_.xs)) def withFilter(p: A => Boolean) = { println("Filtering!") Foo(xs filter p) } } The following is from a 2.10.0 REPL session: scala> for { (a, b) <- Foo(List(1 -> "x")) } yield a res0: Foo[Int] = Foo(List(1)) And here's the same thing in 2.10.1: scala> for { (a, b) <- Foo(List(1 -> "x")) } yield a Filtering! res0: Foo[Int] = Foo(List(1)) This is completely unexpected (to me), and leads to particularly confusing errors in cases

Someone referenced "Crockford's law" recently with respect to monads. Google shows very little in the way of results. Anyone know what it is? Assuming "Crockford's Law" is The Curse that he mentions early in the video, he's referring to this common occurrence (described much more eloquently here ): person X doesn't understand monads person X works long and hard, and groks monads person X experiences amazing feeling of enlightenment, wonders why others are not similarly enlightened person X gives horrible, incomplete, inaccurate, oversimplified, and confusing explanation of monads to others

In Adjoint functors determine monad transformers, but where's lift? , Simon C has shown us the construction... newtype Three u f m a = Three { getThree :: u (m (f a)) } ... which, as the answers there discuss, can be given an instance Adjunction f u => MonadTrans (Three u f) ( adjunctions provides it as AdjointT ). Any Hask/Hask adjunction thus leads to a monad transformer; in particular, StateT s arises in this manner from the currying adjunction between (,) s and (->) s . My follow-up question is: does this construction generalise to other monad transformers? Is there a way to derive, say,

I have a Play! 2 for Scala application that needs to retrieve some data in JSON format from an external service. The Play! framework allows to make HTTP requests asynchronously by wrapping the response in a Promise . Promise is a monad that wraps a value that will be available in the future. This is fine, but in my case what I get from the web service is a JSON string. I have to parse it and the parsing might fail. So I have to wrap whatever I get into an Option . The result is that many of my methods are returning Promise[Option[Whatever]] . That is, a value of type Whatever that will be,

OK, so I know what the Applicative type class contains, and why that's useful. But I can't quite wrap my brain around how you'd use it in a non-trivial example. Consider, for example, the following fairly simple Parsec parser: integer :: Parser Integer integer = do many1 space ds <- many1 digit return $ read ds Now how the heck would you write that without using the Monad instance for Parser ? Lots of people claim that this can be done and is a good idea, but I can't figure out how exactly. integer :: Parser Integer integer = read <$> (many1 space *> many1 digit) Or integer = const read <$>