In Haskell Applicatives are considered stronger than Functor that means we can define Functor using Applicative like

```
-- Functor
fmap :: (a -> b) -> f a -> f b
fmap f fa = pure f <*> fa

```

and Monads are considered stronger than Applicatives & Functors that means.

```
-- Functor
fmap :: (a -> b) -> f a -> f b
fmap f fa = fa >>= return . f

-- Applicative
pure :: a -> f a
pure = return

(<*>) :: f (a -> b) -> f a -> f b
(<*>) = ???  -- Can we define this in terms return & bind? without using "ap" 

```

I have read that Monads are for sequencing actions. But I feel like the only thing a Monad can do is Join or Flatten and the rest of its capabilities comes from Applicatives. 

```
join :: m (m a) -> m a
-- & where is the sequencing in this part? I don't get it.

```

If Monad is really for sequencing actions then How come we can define Applicatives (which are not considered to strictly operate in sequence, some kind of parallel computing)?

As monads are Monoids in the Category of endofunctors. There are Commutative monoids as well, which necessarily need not work in order. That means the Monad instances for Commutative Monoids also need an ordering?

**Edit:** 
I found an excellent page
**<http://wiki.haskell.org/What_a_Monad_is_not>**