Question: Arrows seem to be gaining popularity in the Haskell community, but it seems to me like Monads are more powerful. What is gained by using Arrows? Why can't Monads be used instead?

Answer: 
Every monad gives rise to an arrow

```
newtype Kleisli m a b = Kleisli (a -> m b)
instance Monad m => Category (Kleisli m) where
   id = Kleisli return
   (Kleisli f) . (Kleisli g) = Kleisli (\x -> (g x) >>= f)
instance Monad m => Arrow (Kleisli m) where
   arr f = Kleisli (return . f)
   first (Kleisli f) = Kleisli (\(a,b) -> (f a) >>= \fa -> return (fa,b))

```

But, there are arrows which are not monads. Thus, there are arrows which do things that you can't do with monads. A good example is the arrow transformer to add some static information

```
data StaticT m c a b = StaticT m (c a b)
instance (Category c, Monoid m) => Category (StaticT m c) where
   id = StaticT mempty id
   (StaticT m1 f) . (StaticT m2 g) = StaticT (m1 <> m2) (f . g)
instance (Arrow c, Monoid m) => Arrow (StaticT m c) where
   arr f = StaticT mempty (arr f)
   first (StaticT m f) = StaticT m (first f)

```

this arrow tranformer is usefull because it can be used to keep track of static properties of a program. For example, you can use this to instrument your API to statically measure how many calls you are making.
The question isn't quite right. It's like asking why would you eat oranges instead of apples, since apples seem more nutritious all around.

Arrows, like monads, are a way of expressing computations, but they have to obey a different set of [laws](http://www.haskell.org/ghc/docs/latest/html/libraries/base/Control-Arrow.html#t%3aArrow). In particular, the laws tend to make arrows nicer to use when you have function-like things.

The Haskell Wiki lists a [few introductions](http://www.haskell.org/haskellwiki/Arrow#External_links) to arrows. In particular, the [Wikibook](https://en.wikibooks.org/wiki/Haskell/Understanding_arrows) is a nice high level introduction, and the [tutorial](http://www.cse.chalmers.se/~rjmh/afp-arrows.pdf) by John Hughes is a good overview of the various kinds of arrows.

For a real world example, compare [this tutorial](http://jaspervdj.be/hakyll/tutorials/03-arrows.html) which uses Hakyll 3's arrow-based interface, with roughly [the same thing](http://jaspervdj.be/hakyll/tutorials/03-rules-routes-compilers.html) in Hakyll 4's monad-based interface.