{-# LANGUAGE DeriveFunctor          #-}
{-# LANGUAGE FlexibleInstances      #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE MultiParamTypeClasses  #-}
{-# LANGUAGE RankNTypes             #-}
{-# LANGUAGE Safe                   #-}
{-# LANGUAGE UndecidableInstances   #-}

module Control.Monad.ContextError
  ( ContextErrorT
  , runContextErrorT
  , ContextError
  , runContextError
  , MonadContextError (..)
  ) where

import Control.Applicative
import Control.Monad (MonadPlus, mplus, mzero)
import Control.Monad.Trans.Class (MonadTrans, lift)
import Control.Monad.Trans.Cont as Cont (ContT, liftLocal)
import Control.Monad.Trans.Except (ExceptT, mapExceptT)
import Control.Monad.Trans.Identity (IdentityT, mapIdentityT)
import Control.Monad.Trans.Maybe (MaybeT, mapMaybeT)
import Control.Monad.Trans.Reader (ReaderT, mapReaderT)
import qualified Control.Monad.Trans.RWS.Lazy as Lazy (RWST, mapRWST)
import qualified Control.Monad.Trans.RWS.Strict as Strict (RWST, mapRWST)
import qualified Control.Monad.Trans.State.Lazy as Lazy (StateT, mapStateT)
import qualified Control.Monad.Trans.State.Strict as Strict (StateT, mapStateT)
import Control.Monad.Trans.Writer.Lazy as Lazy (WriterT, mapWriterT)
import Control.Monad.Trans.Writer.Strict as Strict (WriterT, mapWriterT)

import Control.Monad.State  (MonadState (..))
import Control.Monad.Reader (MonadReader (..))
import Control.Monad.Writer (MonadWriter (..))

import Data.Functor.Identity

----------------------------------------------------------------------
-- Monad

newtype ContextErrorT c e m a =
  ContextErrorT { forall c e (m :: * -> *) a.
ContextErrorT c e m a
-> forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b
unContextErrorT :: forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b }

runContextErrorT :: (Monad m) => ContextErrorT c e m a -> c -> m (Either e a)
runContextErrorT :: forall (m :: * -> *) c e a.
Monad m =>
ContextErrorT c e m a -> c -> m (Either e a)
runContextErrorT ContextErrorT c e m a
k c
c = forall c e (m :: * -> *) a.
ContextErrorT c e m a
-> forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b
unContextErrorT ContextErrorT c e m a
k c
c (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> Either a b
Left) (forall a b. a -> b -> a
const forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. b -> Either a b
Right)

type ContextError c e a = ContextErrorT c e Identity a

runContextError :: ContextError c e a -> c -> Either e a
runContextError :: forall c e a. ContextError c e a -> c -> Either e a
runContextError ContextError c e a
k c
c = forall a. Identity a -> a
runIdentity forall a b. (a -> b) -> a -> b
$ forall c e (m :: * -> *) a.
ContextErrorT c e m a
-> forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b
unContextErrorT ContextError c e a
k c
c (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> Either a b
Left) (forall a b. a -> b -> a
const forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. b -> Either a b
Right)

instance Functor (ContextErrorT c e m) where
  fmap :: forall a b.
(a -> b) -> ContextErrorT c e m a -> ContextErrorT c e m b
fmap a -> b
f ContextErrorT c e m a
e = forall c e (m :: * -> *) a.
(forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
ContextErrorT forall a b. (a -> b) -> a -> b
$ \c
c e -> m b
err c -> b -> m b
ret -> forall c e (m :: * -> *) a.
ContextErrorT c e m a
-> forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b
unContextErrorT ContextErrorT c e m a
e c
c e -> m b
err (\c
c' -> c -> b -> m b
ret c
c' forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f)

instance Applicative (ContextErrorT c e m) where
  pure :: forall a. a -> ContextErrorT c e m a
pure a
a = forall c e (m :: * -> *) a.
(forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
ContextErrorT forall a b. (a -> b) -> a -> b
$ \c
c e -> m b
_ c -> a -> m b
ret -> c -> a -> m b
ret c
c a
a
  {-# INLINE pure #-}

  ContextErrorT c e m (a -> b)
fe <*> :: forall a b.
ContextErrorT c e m (a -> b)
-> ContextErrorT c e m a -> ContextErrorT c e m b
<*> ContextErrorT c e m a
ae = forall c e (m :: * -> *) a.
(forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
ContextErrorT forall a b. (a -> b) -> a -> b
$ \c
c e -> m b
err c -> b -> m b
ret ->
    forall c e (m :: * -> *) a.
ContextErrorT c e m a
-> forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b
unContextErrorT ContextErrorT c e m (a -> b)
fe c
c e -> m b
err (\c
c' a -> b
f -> forall c e (m :: * -> *) a.
ContextErrorT c e m a
-> forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b
unContextErrorT ContextErrorT c e m a
ae c
c' e -> m b
err (\c
c'' -> c -> b -> m b
ret c
c'' forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f))
  {-# INLINE (<*>) #-}

instance (Semigroup e) => Alternative (ContextErrorT c e m) where
  -- FIXME: sane 'empty' needed!
  empty :: forall a. ContextErrorT c e m a
empty = forall c e (m :: * -> *) a.
(forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
ContextErrorT forall a b. (a -> b) -> a -> b
$ \c
_ e -> m b
err c -> a -> m b
_ -> e -> m b
err (forall a. HasCallStack => [Char] -> a
error [Char]
"empty ContextErrorT")
  {-# INLINE empty #-}

  ContextErrorT c e m a
ae <|> :: forall a.
ContextErrorT c e m a
-> ContextErrorT c e m a -> ContextErrorT c e m a
<|> ContextErrorT c e m a
be = forall c e (m :: * -> *) a.
(forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
ContextErrorT forall a b. (a -> b) -> a -> b
$ \c
c e -> m b
err c -> a -> m b
ret ->
    forall c e (m :: * -> *) a.
ContextErrorT c e m a
-> forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b
unContextErrorT ContextErrorT c e m a
ae c
c (\e
e -> forall c e (m :: * -> *) a.
ContextErrorT c e m a
-> forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b
unContextErrorT ContextErrorT c e m a
be c
c (\e
e' -> e -> m b
err (e
e forall a. Semigroup a => a -> a -> a
<> e
e')) c -> a -> m b
ret) c -> a -> m b
ret
  {-# INLINE (<|>) #-}

instance Monad (ContextErrorT c e m) where
  ContextErrorT c e m a
ma >>= :: forall a b.
ContextErrorT c e m a
-> (a -> ContextErrorT c e m b) -> ContextErrorT c e m b
>>= a -> ContextErrorT c e m b
fb =
    forall c e (m :: * -> *) a.
(forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
ContextErrorT forall a b. (a -> b) -> a -> b
$ \c
c e -> m b
err c -> b -> m b
ret ->
      forall c e (m :: * -> *) a.
ContextErrorT c e m a
-> forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b
unContextErrorT ContextErrorT c e m a
ma c
c e -> m b
err forall a b. (a -> b) -> a -> b
$ \c
c' a
a ->
        forall c e (m :: * -> *) a.
ContextErrorT c e m a
-> forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b
unContextErrorT (a -> ContextErrorT c e m b
fb a
a) c
c' e -> m b
err c -> b -> m b
ret
  {-# INLINE (>>=) #-}

instance (Semigroup e) => MonadPlus (ContextErrorT c e m) where
  mzero :: forall a. ContextErrorT c e m a
mzero = forall (f :: * -> *) a. Alternative f => f a
empty
  {-# INLINE mzero #-}

  mplus :: forall a.
ContextErrorT c e m a
-> ContextErrorT c e m a -> ContextErrorT c e m a
mplus = forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
(<|>)
  {-# INLINE mplus #-}

instance MonadTrans (ContextErrorT c e) where
  lift :: forall (m :: * -> *) a. Monad m => m a -> ContextErrorT c e m a
lift m a
act = forall c e (m :: * -> *) a.
(forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
ContextErrorT forall a b. (a -> b) -> a -> b
$ \c
c e -> m b
_ c -> a -> m b
ret -> m a
act forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= c -> a -> m b
ret c
c
  {-# INLINE lift #-}

instance MonadState s m => MonadState s (ContextErrorT c e m) where
  get :: ContextErrorT c e m s
get = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall s (m :: * -> *). MonadState s m => m s
get
  put :: s -> ContextErrorT c e m ()
put = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *). MonadState s m => s -> m ()
put
  state :: forall a. (s -> (a, s)) -> ContextErrorT c e m a
state = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state

instance MonadWriter w m => MonadWriter w (ContextErrorT c e m) where
  writer :: forall a. (a, w) -> ContextErrorT c e m a
writer = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall w (m :: * -> *) a. MonadWriter w m => (a, w) -> m a
writer
  tell :: w -> ContextErrorT c e m ()
tell = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell
  listen :: forall a. ContextErrorT c e m a -> ContextErrorT c e m (a, w)
listen ContextErrorT c e m a
m = forall c e (m :: * -> *) a.
(forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
ContextErrorT forall a b. (a -> b) -> a -> b
$ \c
c e -> m b
err c -> (a, w) -> m b
ret -> do
    (Either e (c, a)
res, w
w) <- forall w (m :: * -> *) a. MonadWriter w m => m a -> m (a, w)
listen (forall c e (m :: * -> *) a.
ContextErrorT c e m a
-> forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b
unContextErrorT ContextErrorT c e m a
m c
c (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> Either a b
Left) (forall a b c. ((a, b) -> c) -> a -> b -> c
curry (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. b -> Either a b
Right)))
    case Either e (c, a)
res of
      Left e
e -> e -> m b
err e
e
      Right (c
c', a
a) -> c -> (a, w) -> m b
ret c
c' (a
a, w
w)
  pass :: forall a. ContextErrorT c e m (a, w -> w) -> ContextErrorT c e m a
pass ContextErrorT c e m (a, w -> w)
m = forall c e (m :: * -> *) a.
(forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
ContextErrorT forall a b. (a -> b) -> a -> b
$ \c
c e -> m b
err c -> a -> m b
ret -> forall w (m :: * -> *) a. MonadWriter w m => m (a, w -> w) -> m a
pass forall a b. (a -> b) -> a -> b
$ do
    Either e (c, (a, w -> w))
res <- forall c e (m :: * -> *) a.
ContextErrorT c e m a
-> forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b
unContextErrorT ContextErrorT c e m (a, w -> w)
m c
c (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> Either a b
Left) (forall a b c. ((a, b) -> c) -> a -> b -> c
curry (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. b -> Either a b
Right))
    case Either e (c, (a, w -> w))
res of
      Right (c
c', (a
a, w -> w
f)) -> forall (f :: * -> *) a b. Applicative f => (a -> b) -> f a -> f b
liftA (\b
b -> (b
b, w -> w
f)) forall a b. (a -> b) -> a -> b
$ c -> a -> m b
ret c
c' a
a
      Left e
e -> forall (f :: * -> *) a b. Applicative f => (a -> b) -> f a -> f b
liftA (\b
b -> (b
b, forall a. a -> a
id)) forall a b. (a -> b) -> a -> b
$ e -> m b
err e
e

instance MonadReader r m => MonadReader r (ContextErrorT c e m) where
  ask :: ContextErrorT c e m r
ask = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall r (m :: * -> *). MonadReader r m => m r
ask
  local :: forall a.
(r -> r) -> ContextErrorT c e m a -> ContextErrorT c e m a
local r -> r
f ContextErrorT c e m a
m = forall c e (m :: * -> *) a.
(forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
ContextErrorT forall a b. (a -> b) -> a -> b
$ \c
c e -> m b
err c -> a -> m b
ret ->
    forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local r -> r
f (forall c e (m :: * -> *) a.
ContextErrorT c e m a
-> forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b
unContextErrorT ContextErrorT c e m a
m c
c e -> m b
err c -> a -> m b
ret)
  reader :: forall a. (r -> a) -> ContextErrorT c e m a
reader = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
reader

----------------------------------------------------------------------
-- Monad class stuff

class (Monad m) => MonadContextError c e m | m -> c e where
  throwInContext :: (c -> e) -> m a
  askContext     :: m c
  localContext  :: (c -> c) -> m a -> m a
  modifyContext   :: (c -> c) -> m ()

instance Monad m =>
         MonadContextError c e (ContextErrorT c e m) where
  throwInContext :: forall a. (c -> e) -> ContextErrorT c e m a
throwInContext c -> e
f = forall c e (m :: * -> *) a.
(forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
ContextErrorT forall a b. (a -> b) -> a -> b
$ \c
c e -> m b
err c -> a -> m b
_ -> e -> m b
err (c -> e
f c
c)
  askContext :: ContextErrorT c e m c
askContext = forall c e (m :: * -> *) a.
(forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
ContextErrorT forall a b. (a -> b) -> a -> b
$ \c
c e -> m b
_ c -> c -> m b
ret -> c -> c -> m b
ret c
c c
c
  localContext :: forall a.
(c -> c) -> ContextErrorT c e m a -> ContextErrorT c e m a
localContext c -> c
f ContextErrorT c e m a
m = forall c e (m :: * -> *) a.
(forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
ContextErrorT forall a b. (a -> b) -> a -> b
$ \c
c e -> m b
err c -> a -> m b
ret ->
    forall c e (m :: * -> *) a.
ContextErrorT c e m a
-> forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b
unContextErrorT ContextErrorT c e m a
m (c -> c
f c
c) e -> m b
err (\c
_ -> c -> a -> m b
ret c
c)
  modifyContext :: (c -> c) -> ContextErrorT c e m ()
modifyContext c -> c
f = forall c e (m :: * -> *) a.
(forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
ContextErrorT forall a b. (a -> b) -> a -> b
$ \c
c e -> m b
_ c -> () -> m b
ret -> c -> () -> m b
ret (c -> c
f c
c) ()

instance MonadContextError c e m =>
         MonadContextError c e (ContT r m) where
    throwInContext :: forall a. (c -> e) -> ContT r m a
throwInContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> e) -> m a
throwInContext
    askContext :: ContT r m c
askContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall c e (m :: * -> *). MonadContextError c e m => m c
askContext
    localContext :: forall a. (c -> c) -> ContT r m a -> ContT r m a
localContext = forall (m :: * -> *) r' r a.
Monad m =>
m r'
-> ((r' -> r') -> m r -> m r)
-> (r' -> r')
-> ContT r m a
-> ContT r m a
Cont.liftLocal forall c e (m :: * -> *). MonadContextError c e m => m c
askContext forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> c) -> m a -> m a
localContext
    modifyContext :: (c -> c) -> ContT r m ()
modifyContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *).
MonadContextError c e m =>
(c -> c) -> m ()
modifyContext

instance MonadContextError c e m =>
         MonadContextError c e (ExceptT e m) where
    throwInContext :: forall a. (c -> e) -> ExceptT e m a
throwInContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> e) -> m a
throwInContext
    askContext :: ExceptT e m c
askContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall c e (m :: * -> *). MonadContextError c e m => m c
askContext
    localContext :: forall a. (c -> c) -> ExceptT e m a -> ExceptT e m a
localContext = forall (m :: * -> *) e a (n :: * -> *) e' b.
(m (Either e a) -> n (Either e' b))
-> ExceptT e m a -> ExceptT e' n b
mapExceptT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> c) -> m a -> m a
localContext
    modifyContext :: (c -> c) -> ExceptT e m ()
modifyContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *).
MonadContextError c e m =>
(c -> c) -> m ()
modifyContext

instance MonadContextError c e m =>
         MonadContextError c e (IdentityT m) where
    throwInContext :: forall a. (c -> e) -> IdentityT m a
throwInContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> e) -> m a
throwInContext
    askContext :: IdentityT m c
askContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall c e (m :: * -> *). MonadContextError c e m => m c
askContext
    localContext :: forall a. (c -> c) -> IdentityT m a -> IdentityT m a
localContext = forall {k1} {k2} (m :: k1 -> *) (a :: k1) (n :: k2 -> *) (b :: k2).
(m a -> n b) -> IdentityT m a -> IdentityT n b
mapIdentityT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> c) -> m a -> m a
localContext
    modifyContext :: (c -> c) -> IdentityT m ()
modifyContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *).
MonadContextError c e m =>
(c -> c) -> m ()
modifyContext

instance MonadContextError c e m =>
         MonadContextError c e (MaybeT m) where
    throwInContext :: forall a. (c -> e) -> MaybeT m a
throwInContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> e) -> m a
throwInContext
    askContext :: MaybeT m c
askContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall c e (m :: * -> *). MonadContextError c e m => m c
askContext
    localContext :: forall a. (c -> c) -> MaybeT m a -> MaybeT m a
localContext = forall (m :: * -> *) a (n :: * -> *) b.
(m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b
mapMaybeT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> c) -> m a -> m a
localContext
    modifyContext :: (c -> c) -> MaybeT m ()
modifyContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *).
MonadContextError c e m =>
(c -> c) -> m ()
modifyContext

instance MonadContextError c e m =>
         MonadContextError c e (ReaderT r m) where
    throwInContext :: forall a. (c -> e) -> ReaderT r m a
throwInContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> e) -> m a
throwInContext
    askContext :: ReaderT r m c
askContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall c e (m :: * -> *). MonadContextError c e m => m c
askContext
    localContext :: forall a. (c -> c) -> ReaderT r m a -> ReaderT r m a
localContext = forall (m :: * -> *) a (n :: * -> *) b r.
(m a -> n b) -> ReaderT r m a -> ReaderT r n b
mapReaderT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> c) -> m a -> m a
localContext
    modifyContext :: (c -> c) -> ReaderT r m ()
modifyContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *).
MonadContextError c e m =>
(c -> c) -> m ()
modifyContext

instance (Monoid w, MonadContextError c e m) =>
         MonadContextError c e (Lazy.WriterT w m) where
    throwInContext :: forall a. (c -> e) -> WriterT w m a
throwInContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> e) -> m a
throwInContext
    askContext :: WriterT w m c
askContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall c e (m :: * -> *). MonadContextError c e m => m c
askContext
    localContext :: forall a. (c -> c) -> WriterT w m a -> WriterT w m a
localContext = forall (m :: * -> *) a w (n :: * -> *) b w'.
(m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
Lazy.mapWriterT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> c) -> m a -> m a
localContext
    modifyContext :: (c -> c) -> WriterT w m ()
modifyContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *).
MonadContextError c e m =>
(c -> c) -> m ()
modifyContext

instance (Monoid w, MonadContextError c e m) =>
         MonadContextError c e (Strict.WriterT w m) where
    throwInContext :: forall a. (c -> e) -> WriterT w m a
throwInContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> e) -> m a
throwInContext
    askContext :: WriterT w m c
askContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall c e (m :: * -> *). MonadContextError c e m => m c
askContext
    localContext :: forall a. (c -> c) -> WriterT w m a -> WriterT w m a
localContext = forall (m :: * -> *) a w (n :: * -> *) b w'.
(m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
Strict.mapWriterT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> c) -> m a -> m a
localContext
    modifyContext :: (c -> c) -> WriterT w m ()
modifyContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *).
MonadContextError c e m =>
(c -> c) -> m ()
modifyContext

instance MonadContextError c e m =>
         MonadContextError c e (Lazy.StateT s m) where
    throwInContext :: forall a. (c -> e) -> StateT s m a
throwInContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> e) -> m a
throwInContext
    askContext :: StateT s m c
askContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall c e (m :: * -> *). MonadContextError c e m => m c
askContext
    localContext :: forall a. (c -> c) -> StateT s m a -> StateT s m a
localContext = forall (m :: * -> *) a s (n :: * -> *) b.
(m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b
Lazy.mapStateT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> c) -> m a -> m a
localContext
    modifyContext :: (c -> c) -> StateT s m ()
modifyContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *).
MonadContextError c e m =>
(c -> c) -> m ()
modifyContext

instance MonadContextError c e m =>
         MonadContextError c e (Strict.StateT s m) where
    throwInContext :: forall a. (c -> e) -> StateT s m a
throwInContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> e) -> m a
throwInContext
    askContext :: StateT s m c
askContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall c e (m :: * -> *). MonadContextError c e m => m c
askContext
    localContext :: forall a. (c -> c) -> StateT s m a -> StateT s m a
localContext = forall (m :: * -> *) a s (n :: * -> *) b.
(m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b
Strict.mapStateT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> c) -> m a -> m a
localContext
    modifyContext :: (c -> c) -> StateT s m ()
modifyContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *).
MonadContextError c e m =>
(c -> c) -> m ()
modifyContext

instance (Monoid w, MonadContextError c e m) =>
         MonadContextError c e (Lazy.RWST r w s m) where
    throwInContext :: forall a. (c -> e) -> RWST r w s m a
throwInContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> e) -> m a
throwInContext
    askContext :: RWST r w s m c
askContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall c e (m :: * -> *). MonadContextError c e m => m c
askContext
    localContext :: forall a. (c -> c) -> RWST r w s m a -> RWST r w s m a
localContext = forall (m :: * -> *) a s w (n :: * -> *) b w' r.
(m (a, s, w) -> n (b, s, w')) -> RWST r w s m a -> RWST r w' s n b
Lazy.mapRWST forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> c) -> m a -> m a
localContext
    modifyContext :: (c -> c) -> RWST r w s m ()
modifyContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *).
MonadContextError c e m =>
(c -> c) -> m ()
modifyContext

instance (Monoid w, MonadContextError c e m) =>
         MonadContextError c e (Strict.RWST r w s m) where
    throwInContext :: forall a. (c -> e) -> RWST r w s m a
throwInContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> e) -> m a
throwInContext
    askContext :: RWST r w s m c
askContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall c e (m :: * -> *). MonadContextError c e m => m c
askContext
    localContext :: forall a. (c -> c) -> RWST r w s m a -> RWST r w s m a
localContext = forall (m :: * -> *) a s w (n :: * -> *) b w' r.
(m (a, s, w) -> n (b, s, w')) -> RWST r w s m a -> RWST r w' s n b
Strict.mapRWST forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> c) -> m a -> m a
localContext
    modifyContext :: (c -> c) -> RWST r w s m ()
modifyContext = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c e (m :: * -> *).
MonadContextError c e m =>
(c -> c) -> m ()
modifyContext