What good is the monad instance of Cont?

Question

I'm playing around with CPS and Control.Monad.Cont and wonder what we gain by noticing the monadic structure. For code like this:

sumOfSquares'cps :: Cont r Int -> Cont r Int -> Cont r Int
sumOfSquares'cps x y = x >>= \x' ->
                       y >>= \y' ->
                       return (x'*x' + y'*y')

Can easily be rewritten as

type Cont' r a = (a -> r) -> r

sos'cps :: Cont' r Int -> Cont' r Int -> Cont' r Int
sos'cps x y = \k -> x $ \x' -> 
                    y $ \y' -> 
                    k (x'*x' + y'*y') 

Don't get me wrong, but I can't see the sensation here apart from being able to use do notation and a newtype. I don't think that callCC is dependent on the monad instance either.

I'm lacking imagination to come up with an example. What do we actually get for declaring Cont r a monad?

Answer 1

You could ask the same question of any Monad. Off the top of my head, I can think of three advantages:

1. You get access to the huge collection of functions that are designed to work with Monads.
2. You can use do-notation.
3. You can stack up monad transformers to create something more powerful.

This also allows you to reason better about your code, since you can rely on identity and associative properties and the like.

Answer 2

One obvious advantage is that you can use the combinators defined for Monads (and Functors). For example, your function could be written using liftM2:

sumOfSquares'cps :: Cont r Int -> Cont r Int -> Cont r Int
sumOfSquares'cps = liftM2 sumSquares
  where sumSquares x y = x * x + y * y

this function does not rely on the monad being Cont and could be written with a more general type e.g.

sumOfSquaresM :: Monad m => m Int -> m Int -> m Int