monads

How to convert this map/flatMap into a for comprehension, and please explain how it works, thanks. def compute2(maybeFoo: Option[Foo]): Option[Int] = maybeFoo.flatMap { foo => foo.bar.flatMap { bar => bar.baz.map { baz => baz.compute } } } Your code can be translated into this: def compute2(maybeFoo: Option[Foo]): Option[Int] = for { foo <- maybeFoo bar <- foo.bar baz <- bar.baz } yield baz.compute Quotes from Programming in Scala, Second Edition : Generally, a for expression is of the form: for ( seq ) yield expr Here, seq is a sequence of generators, definitions, and filters, with semi

The Haskell wikibook asserts that Instances of MonadPlus are required to fulfill several rules, just as instances of Monad are required to fulfill the three monad laws. ... The most essential are that mzero and mplus form a monoid. A consequence of which is that mplus must be associative. The Haskell wiki agrees. However, Oleg, in one of his many backtracking search implementations , writes that -- Generally speaking, mplus is not associative. It better not be, -- since associative and non-commutative mplus makes the search -- strategy incomplete. Is it kosher to define a non-associative mplus

When browsing Hackage, most of the monads have a Lazy and a Strict version. What is the difference exactly? Can you highlight it with some examples for the common monads (State, Reader, Writer)? I don't know of a separation into lazy and strict for the reader monad, the reason for the State(T) and Writer(T) separation doesn't apply there. The difference between the lazy and strict Writer and State monads resp. their monad transformers is the implementation of the monadic bind (>>=) , fmap etc. In the strict versions, the implementation pattern-matches on the pair ( (result, state) , resp.

Can anybody explain why exceptions may be thrown outside the IO monad, but may only be caught inside it? One of the reasons is the denotational semantics of Haskell . One of the neat properties of (pure) Haskell functions is their monotonicity -- more defined argument yields more defined value. This property is very important e.g. to reason about recursive functions (read the article to understand why). Denotation of exception by definition is the bottom, _|_ , the least element in poset corresponding to the given type. Thus, to satisfy monotonicity requirement, the following inequality needs

I recently discovered this little scala example called Simple interpreter using monads : object simpleInterpreter { case class M[A](value: A) { def bind[B](k: A => M[B]): M[B] = k(value) def map[B](f: A => B): M[B] = bind(x => unitM(f(x))) def flatMap[B](f: A => M[B]): M[B] = bind(f) } def unitM[A](a: A): M[A] = M(a) def showM(m: M[Value]): String = m.value.toString(); type Name = String trait Term; case class Var(x: Name) extends Term case class Con(n: int) extends Term case class Add(l: Term, r: Term) extends Term case class Lam(x: Name, body: Term) extends Term case class App(fun: Term, arg

My question is about the sequence function in Prelude , the signature of which is as follows: sequence :: Monad m => [m a] -> m [a] I understand how this function works for List of Maybe s. For example, applying sequence on [Just 3, Just 9] gives Just [3, 9] . I noticed that applying sequence on List of List s gives its Cartesian Product. Can someone please help me understand how/why this happens? Peter Wortmann This works because using lists as monads in Haskell makes them model indeterminism. Consider: sequence [[1,2],[3,4]] By definition this is the same as: do x <- [1,2] y <- [3,4] return

I'm trying to grasp the State Monad and with this purpose I wanted to write a monadic code that would generate a sequence of random numbers using a Linear Congruential Generator (probably not good, but my intention is just to learn the State Monad, not build a good RNG library). The generator is just this (I want to generate a sequence of Bool s for simplicity): type Seed = Int random :: Seed -> (Bool, Seed) random seed = let (a, c, m) = (1664525, 1013904223, 2^32) -- some params for the LCG seed' = (a*seed + c) `mod` m in (even seed', seed') -- return True/False if seed' is even/odd Don't