Goto en Haskell: ¿Puede alguien explicar este efecto aparentemente loco del uso de la mónada de continuación?

Desde este hilo (Control.Mónada.Cont fun, 2005), Tomasz Zielonka introdujo una función (comentada de una manera clara y agradable por Thomas Jäger). Tomasz toma el argumento (una función) de un cuerpo callCC y lo devuelve para su uso posterior con las siguientes dos definiciones:

import Control.Monad.Cont
...
getCC :: MonadCont m => m (m a)
getCC = callCC (\c -> let x = c x in return x)

getCC' :: MonadCont m => a -> m (a, a -> m b)
getCC' x0 = callCC (\c -> let f x = c (x, f) in return (x0, f))

También se mencionan en Haskellwiki. Usándolos, puede parecerse a la semántica de goto en haskell, que se ve muy bien:

import Control.Monad.Cont

getCC' :: MonadCont m => a -> m (a, a -> m b)
getCC' x0 = callCC (\c -> let f x = c (x, f) in return (x0, f))

main :: IO ()
main = (`runContT` return) $ do
    (x, loopBack) <- getCC' 0
    lift (print x)
    when (x < 10) (loopBack (x + 1))
    lift (putStrLn "finish")

Esto imprime los números 0 a 10.

Aquí viene el punto interesante. Usé esto junto con el escritor Mónada para resolver un cierto problema. Mi código se ve como el siguiente:

{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, UndecidableInstances #-}

import Control.Monad.Cont
import Control.Monad.Writer

getCC :: MonadCont m => m (m a)
getCC = callCC (\c -> let x = c x in return x)

getCC' :: MonadCont m => a -> m (a, a -> m b)
getCC' x0 = callCC (\c -> let f x = c (x, f) in return (x0, f))

-- a simple monad transformer stack involving MonadCont and MonadWriter
type APP= WriterT [String] (ContT () IO)

runAPP :: APP a -> IO ()
runAPP a= runContT (runWriterT a) process
      where process (_,w)= do
               putStrLn $ unlines w
               return ()

driver :: Int -> APP ()
driver k = do
   tell [ "The quick brown fox ..." ]
   (x,loop) <- getCC' 0
   collect x
   when (x<k) $ loop (x+1) 

collect :: Int -> APP ()
collect n= tell [ (show n) ] 

main :: IO ()
main = do
   runAPP $ driver 4

Cuando compila y ejecuta este código, la salida es:

The quick brown fox ...
4

Los números del cero al tres son tragados en algún lugar en la profunda oscuridad de este ejemplo.

Ahora, en "Real World Haskell" O'Sullivan, Goerzen y Stewart estados

"El apilamiento de transformadores de mónada es análogo a las funciones de composición. Si cambiamos el orden en el que aplicamos funciones y luego obtenemos diferentes resultados, no nos sorprenderemos. Lo mismo ocurre con los transformadores de mónada." (Mundo Real Haskell, 2008, P. 442)

Se me ocurrió la idea de intercambiar los transformadores de arriba:

--replace in the above example
type APP= ContT () (WriterT [String] IO)
...
runAPP a = do
    (_,w) <- runWriterT $ runContT a (return . const ())
    putStrLn $ unlines w

Sin embargo, esto no se compilará porque no hay una definición de instancia para MonadWriter en Control.Mónada.Cont (que es por lo que hace poco hice esta pregunta .)

Agregamos una instancia dejando escuchar y pasar undefined:

instance (MonadWriter w m) => MonadWriter w (ContT r m) where
  tell = lift . tell
  listen = undefined
  pass = undefined

Agrega esas líneas, compila y ejecuta. Todos los números están impresos.

¿Qué ha pasado en el ejemplo anterior?