It has turned out that many applications do not require monad functionality but only those of applicative functors. Monads allow you to run actions depending on the outcomes of earlier actions.
do text <- getLine if null text then putStrLn "You refuse to enter something?" else putStrLn ("You entered " ++ text)
This is obviously necessary in some cases, but in other cases it is disadvantageous.
Consider an extended IO monad which handles automated closing of allocated resources. This is possible with a monad.
openDialog, openWindow :: String -> CleanIO () liftToCleanup :: IO a -> CleanIO a runAndCleanup :: CleanIO a -> IO a runAndCleanup $ do text <- liftToCleanup getLine if null text then openDialog "You refuse to enter something?" else openWindow ("You entered " ++ text)
The (fictive) functions
could not only open dialogs and windows but could also register some cleanup routine in the
runAndCleanup would first run the opening actions and afterwards the required cleanup actions.
I.e. if the dialog was opened, the dialog must be closed, but not the window.
That is, the cleanup procedure depends on the outcomes of earlier actions.
Now consider the slightly different task, where functions shall register initialization routines
that shall be run before the actual action takes place.
(See the original discussion started by Michael T. Richter in Haskell-Cafe:
Practical Haskell Question)
This is impossible in the monadic framework.
Consider the example above where the choice between
depends on the outcome of
You cannot run initialization code for either
because you do not know which one will be called before executing
If you eliminate this dependency, you end up in an applicative functor
and there you can do the initialization trick.
You could write
initializeAndRun $ liftA2 (liftToInit getLine) (writeToWindow "You requested to open a window")
writeToWindow registers an initialization routine which opens the window.
If you have the variables
f :: a -> b -> c a :: f a b :: f b
you can combine them in the following ways with the same result of type
pure f <*> a <*> b
liftA2 f a b
But how to cope with
let and sharing in the presence of effects?
Consider the non-functorial expression:
x :: x g :: x -> y h :: y -> y -> z let y = g x in h y y
Very simple. Now we like to generalize this to
fx :: f x fg :: f (x -> y) fh :: f (y -> y -> z)
However, we note that
let fy = fg <*> fx in fh <*> fy <*> fy
runs the effect of
fy writes something to the terminal then
fh <*> fy <*> fy writes twice. This could be intended, but how can we achieve, that the effect is run only once and the result is used twice?
Actually, using the
liftA commands we can pull results of applicative functors into a scope where we can talk exclusively about functor results and not about effects. Note that functor results can also be functions. This scope is simply a function, which contains the code that we used in the non-functorial setting.
liftA3 (\x g h -> let y = g x in h y y) fx fg fh
The order of effects is entirely determined by the order of arguments to
Some advantages of applicative functors
- Code that uses only the
Applicativeinterface is more general than code that uses the
Monadinterface, because there are more applicative functors than monads. The
ZipListis an applicative functor on lists, where
liftA2is implemented by
zipWith. It is a typical example of an applicative functor that is not a monad.
- Programming with
Applicativehas a more applicative/functional feel. Especially for newbies, it may encourage functional style even when programming with effects. Monad programming with do notation encourages a more sequential & imperative style.
From the Monad Transformer Library we are used to have two flavours of every monad: a base monad like
State and a transformer variant
StateT. In the transformers package we even have only monad transformers except the
So where are applicative transformers? The answer is, that in most situations, we do not need special transformers for applicative functors since they can be combined in a generic way.
h :: f (g (a -> b)) a :: f (g a) liftA2 (<*>) h a :: f (g b)
liftA2 (<*>) is essentially the definition for
for the composition of the functors
This is implemented in the TypeCompose library as type constructor
O and in transformers library in module
Data.Functor.Compose. The first one needs a lot of type extensions, whereas the second one is entirely Haskell 98.
It can be useful to use the applicative composition even when you have a monad transformer at hand. In the example above
f might be
Writer (Sum Int) that is used for counting the number of involved applicative actions. Since in an applicative functor the number of run actions is independent from interim results, the writer can count the actions at compile time.
It is not true that transformers are unnecessary for applicatives, though. Consider
State s (IO a) == s -> (s, IO a), which behaves like an applicative with the above trick, but it is different from
StateT s IO a == s -> IO (s, a). The latter is more useful in some situations, and it is not a composition of any two applicatives.
How to switch from monads
- Start using
liftM2, etc or
apwhere you can, in place of
(>>=). You will often encounter code like
do x <- fx y <- fy return (g x y)
- It can be rewritten to
liftM2 g fx fy. In general, whenever the choice or construction of monadic actions does not depend on the outcomes of previous monadic actions, then it should be possible to rewrite everything with
- When you notice you're only using those monad methods, then import
liftA2, etc, and
(<*>). If your function signature was
Monad m => ..., change to
Applicative m => ...(and maybe rename
Applicative functors were introduced by several people under different names:
- Ross Paterson called them Sequence
- Conor McBride called them Idiom
- The same kind of structure is used in the UU Parsing-Combinators.