First of all, remember how fmap is defined for applicatives: fmap f x = pure f <*> x This means that your example is the same as (fmap (+ 5) (* 3)) 4. The fmap function for functions is just composition, so your exact expression is the same as ((+ 5) . (* 3)) 4. … Read more
Output The applicative equivalent for >> is *>, so you can do ghci> :m Control.Applicative ghci> print 5 *> print 7 5 7 Input – a better case for Applicative import Control.Applicative data Company = Company {name :: String, size :: Int} deriving Show getCompany :: IO Company getCompany = Company <$> getLine <*> readLn … Read more
The monoid that’s referred to with “monoidal functor” is not a Monoid monoid, i.e. a value-level monoid. It’s a type-level monoid instead. Namely, the boring product monoid type Mempty = () type a <> b = (a,b) (You may notice that this is not strictly speaking a monoid; it’s only if you consider ((a,b),c) and … Read more
Well, I’m not terribly satisfied with the answers given so far, but I think the comments attached to them are a bit more compelling. So I’ll summarize here: I think there’s only one sensible Functor instance that follows from Applicative: fmap f fa = pure f <*> fa Assuming that’s unique, it makes sense that … Read more
A few footnotes to Lee’s answer: However, the bind function looks pretty weird. Why are f and g nested the other way around? Because bind is backwards. Compare (>>=) and its flipped version (=<<): (>>=) :: Monad m => m a -> (a -> m b) -> m b (=<<) :: Monad m => (a … Read more
TL;DR: some is one or more, many is 0 or more results collected from performing the same computation over and over by the familiar maximal munch rule. For this to make sense, some state passing (and alteration) must take place reducing the domain of possibilities somehow, otherwise it will repeat ad infinitum. And state passing … Read more
My favorite example is the “purely applicative Either”. We’ll start by analyzing the base Monad instance for Either instance Monad (Either e) where return = Right Left e >>= _ = Left e Right a >>= f = f a This instance embeds a very natural short-circuiting notion: we proceed from left to right and … Read more
The other two answers have given the detail of how this is calculated – but I thought I might chime in with a more “intuitive” answer to explain how, without going through a detailed calculation, one can “see” that the result must be 508. As you implied, every Applicative (in fact, even every Functor) can … Read more
To quote myself: So why bother with applicative functors at all, when we’ve got monads? First of all, it’s simply not possible to provide monad instances for some of the abstractions we want to work with—Validation is the perfect example. Second (and relatedly), it’s just a solid development practice to use the least powerful abstraction … Read more
MonadPlus and Monoid serve different purposes. A Monoid is parameterized over a type of kind *. class Monoid m where mempty :: m mappend :: m -> m -> m and so it can be instantiated for almost any type for which there is an obvious operator that is associative and which has a unit. … Read more