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.
I always found one of the really practical use cases of arrows to be **stream programming**.

Look at this:

```
data Stream a = Stream a (Stream a)
data SF a b = SF (a -> (b, SF a b))

```

`SF a b` is a synchronous stream function.
You can define a function from it that transforms `Stream a` into `Stream b` that never hangs and always outputs one `b` for one `a`:

```
(<<$>>) :: SF a b -> Stream a -> Stream b
SF f <<$>> Stream a as = let (b, sf') = f a
                         in  Stream b $ sf' <<$>> as

```

There is an `Arrow` instance for `SF`. In particular, you can *compose* `SF`s:

```
(>>>) :: SF a b -> SF b c -> SF a c

```

Now try to do this in monads. It doesn't work well. You might say that `Stream a == Reader Nat a` and thus it's a monad, but the monad instance is very inefficient. Imagine the type of `join`:

```
join :: Stream (Stream a) -> Stream a

```

You have to extract the diagonal from a stream of streams. This means `O(n)` complexity for the `n`th element, but using the `Arrow` instance for `SF`s gives you `O(1)` in principle! (And also deals with time and space leaks.)