Mais uma vez tentando entender Cont em Haskell

mais_uma_vez.hs

newtype Cont final a = Cont { runCont :: (a -> final) -> final }

{-
  f :: a -> b
  suspensa :: Cont final a
  fmap f suspensa :: Cont final b
-}

instance Functor (Cont final) where
  fmap f suspensa = Cont $ \_pure ->
    runCont suspensa $ \a ->
      _pure (f a)

{-
  pure :: a -> Cont final a
  _pure :: a -> final

  ------------------------------------------------------------

  (<*>) :: Cont final (a -> b) -> Cont final a -> Cont final b

            :: final
  /‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾\
   runCont suspensaF $ \f -> ...
                        o--------------> :: a -> b
                      \_________/
                       :: (a -> b) -> final
  \_________________/
    :: ((a -> b) -> final) -> final


            :: final
  /‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾\
   runCont suspensaX $ \x -> ...
                        o--------------> :: a
                      \_________/
                       :: a -> final
  \_________________/
    :: (a -> final) -> final

-}


instance Applicative (Cont final) where
  pure x = Cont $ \_pure -> _pure x
  (<*>) suspensaF suspensaX =
    Cont $ \_pure -> -- _pure :: b -> final
      runCont suspensaF $ \f -> -- f :: a -> b
                                -- \f -> ... :: (a -> b) -> final
        runCont suspensaX $ \a -> -- a :: a
                                  -- \a -> ... :: a -> final
          _pure (f a) -- f a :: b; _pure (f a) :: final

instance Monad (Cont final) where
  return = pure
  (>>=) suspensaX f =
    Cont $ \_pure -> -- _pure :: b -> final
      runCont suspensaX $ \x -> -- x :: a
        runCont (f x) $ \b -> -- f x :: Cont final b
                              -- \b -> ... :: b -> final
                              -- b :: b
          _pure b             -- _pure b :: final

callCC :: ((a -> Cont final b) -> Cont final a) -> Cont final a
callCC cc = -- cc :: (a -> Cont final b) -> Cont final a
  Cont $ \_pure -> -- _pure :: a -> final
    runCont (cc (\a -> -- a :: a
                   Cont $ \_b -> -- _b :: b -> final
                    _pure a)) -- _pure a :: final
            _pure
    -- runCont :: Cont final a -> (a -> final) -> final