applicative

I've read this article , but didn't understand last section. The author says that Monad gives us context sensitivity, but it's possible to achieve the same result using only an Applicative instance: let maybeAge = (\futureYear birthYear -> if futureYear < birthYear then yearDiff birthYear futureYear else yearDiff futureYear birthYear) <$> (readMay futureYearString) <*> (readMay birthYearString) It's uglier for sure without do-syntax, but beside that I don't see why we need Monad. Can anyone clear this up for me? Here's a couple of functions that use the Monad interface. ifM :: Monad m => m

I just read the following from typeclassopedia about the difference between Monad and Applicative . I can understand that there is no join in Applicative . But the following description looks vague to me and I couldn't figure out what exactly is meant by "the result" of a monadic computation/action. So, if I put a value into Maybe , which makes a monad, what is the result of this "computation"? Let’s look more closely at the type of (>>=). The basic intuition is that it combines two computations into one larger computation. The first argument, m a, is the first computation. However, it would

I know that Monad can be expressed in Scala as follows: trait Monad[F[_]] { def flatMap[A, B](f: A => F[B]): F[A] => F[B] } I see why it is useful. For example, given two functions: getUserById(userId: Int): Option[User] = ... getPhone(user: User): Option[Phone] = ... I can easily write function getPhoneByUserId(userId: Int) since Option is a monad: def getPhoneByUserId(userId: Int): Option[Phone] = getUserById(userId).flatMap(user => getPhone(user)) ... Now I see Applicative Functor in Scala: trait Applicative[F[_]] { def apply[A, B](f: F[A => B]): F[A] => F[B] } I wonder when I should use it

The standard-library Haskell typeclasses MonadPlus , Alternative , and Monoid each provide two methods with essentially the same semantics: An empty value: mzero , empty , or mempty . An operator a -> a -> a that joins values in the typeclass together: mplus , <|> , or mappend . All three specify these laws to which instances should adhere: mempty `mappend` x = x x `mappend` mempty = x Thus, it seems the three typeclasses are all providing the same methods. ( Alternative also provides some and many , but their default definitions are usually sufficient, and so they're not too important in