BTW here is a brief introduction to functors, applicatives and monads:
Functors are types that define the operation fmap (<$> in infix form). fmap has the following type and properties:
fmap :: Functor f => (a -> b) -> f a -> f b
fmap id a == a
fmap (f . g) == fmap f . fmap g
Applicatives are functors that also define the operations 'pure' (which puts something into an applicative) and <*> (sequential application).
These functions have the following types and properties:
pure :: Functor f => a -> f a
(<*>) :: Functor f => f (a -> b) -> f a -> fb
pure id <*> v == v --identity
pure f <*> pure x == pure (f x) --homomorphism
u <*> pure y == pure ($ y) <*> u --interchange
pure (.) <*> u <*> v <*> w == u <*> (v <*> w) --composition
Monads are applicatives that also define a 'join' operation. The monad bind operator >>= can be defined in terms of 'join' and 'pure'.
There is also the monad composition operator >=>. These have the following types, definitions and properties:
join :: Monad m => m (m a) -> m a
(>>=) a b = join $ fmap b a
(>=>) f g = \x -> f x >>= g
pure >=> f = f
f >=> pure = pure
(f >=> g) >=> h = f >=> (g >=> h)
Interestingly enough, monads were added to Haskell before applicatives. Doing an operation using applicative operations is often faster than doing the same operation using monadic operations, so try to use applicative functions.
Functors, applicatives and monads also have some additional operators, but they can all be derived from those covered in this introduction. (An exception is liftA2 for applicatives because some applicatives may define <*> in terms of liftA2 instead of the other way around)
Monads have a 'return' function but it does the exact same thing as 'pure'.
Sorry if I screwed anything up, hope this helps
