Cont.hs

{-# LANGUAGE FlexibleContexts     #-}
{-# LANGUAGE RebindableSyntax     #-}
{-# LANGUAGE UndecidableInstances #-}

-- | This module is a duplication of the Control.Monad.Cont module, from the\
-- mtl.
module Control.Monad.Constrained.Cont
  (MonadCont(..)
  ,ContT(..)
  ,cont
  ,mapContT
  ,withContT
  ,runCont
  ,mapCont
  ,withCont)where

import           Control.Monad.Constrained

import           Control.Monad.Trans.Cont         hiding (callCC)
import qualified Control.Monad.Trans.Cont         as Cont

import qualified Control.Monad.Trans.Except       as Except
import qualified Control.Monad.Trans.Identity     as Identity
import qualified Control.Monad.Trans.Maybe        as Maybe
import qualified Control.Monad.Trans.Reader       as Reader
import qualified Control.Monad.Trans.State.Lazy   as State.Lazy
import qualified Control.Monad.Trans.State.Strict as State.Strict

import qualified Prelude

-- | A class for monads which can embed continuations.
class Monad m => MonadCont m where
    {- | @callCC@ (call-with-current-continuation)
    calls a function with the current continuation as its argument.
    Provides an escape continuation mechanism for use with Continuation monads.
    Escape continuations allow to abort the current computation and return
    a value immediately.
    They achieve a similar effect to 'Control.Monad.Error.throwError'
    and 'Control.Monad.Error.catchError'
    within an 'Control.Monad.Error.Error' monad.
    Advantage of this function over calling @return@ is that it makes
    the continuation explicit,
    allowing more flexibility and better control
    (see examples in "Control.Monad.Cont").

    The standard idiom used with @callCC@ is to provide a lambda-expression
    to name the continuation. Then calling the named continuation anywhere
    within its scope will escape from the computation,
    even if it is many layers deep within nested computations.
    -}
    callCC :: ((a -> m b) -> m a) -> m a

instance MonadCont (ContT r m) where
    callCC = Cont.callCC

instance (MonadCont m, Prelude.Monad (Unconstrained m)) =>
         MonadCont (Maybe.MaybeT m) where
    callCC = Maybe.liftCallCC callCC

instance MonadCont m => MonadCont (Reader.ReaderT r m) where
    callCC = Reader.liftCallCC callCC

instance (MonadCont m, Prelude.Monad (Unconstrained m)) =>
         MonadCont (State.Lazy.StateT s m) where
    callCC = State.Lazy.liftCallCC callCC

instance (MonadCont m, Prelude.Monad (Unconstrained m)) =>
         MonadCont (State.Strict.StateT s m) where
    callCC = State.Strict.liftCallCC callCC

instance MonadCont m => MonadCont (Identity.IdentityT m) where
    callCC = Identity.liftCallCC callCC

instance (MonadCont m, Prelude.Monad (Unconstrained m)) =>
         MonadCont (Except.ExceptT e m) where
    callCC = Except.liftCallCC callCC