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

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

#if MIN_VERSION_mtl(2,2,0)
import Control.Monad.Except
#else
import Control.Monad.Error
#endif

import Control.Applicative
import Control.Monad.Trans.Cont as Cont (ContT, liftLocal)
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
#if !MIN_VERSION_base(4,11,0)
import Data.Semigroup
#endif

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

newtype ContextErrorT c e m a =
  ContextErrorT { 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 :: ContextErrorT c e m a -> c -> m (Either e a)
runContextErrorT ContextErrorT c e m a
k c
c = ContextErrorT c e m a
-> c
-> (e -> m (Either e a))
-> (c -> a -> m (Either e a))
-> m (Either e a)
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 (Either e a -> m (Either e a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Either e a -> m (Either e a))
-> (e -> Either e a) -> e -> m (Either e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> Either e a
forall a b. a -> Either a b
Left) ((a -> m (Either e a)) -> c -> a -> m (Either e a)
forall a b. a -> b -> a
const ((a -> m (Either e a)) -> c -> a -> m (Either e a))
-> (a -> m (Either e a)) -> c -> a -> m (Either e a)
forall a b. (a -> b) -> a -> b
$ Either e a -> m (Either e a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Either e a -> m (Either e a))
-> (a -> Either e a) -> a -> m (Either e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Either e a
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 :: ContextError c e a -> c -> Either e a
runContextError ContextError c e a
k c
c = Identity (Either e a) -> Either e a
forall a. Identity a -> a
runIdentity (Identity (Either e a) -> Either e a)
-> Identity (Either e a) -> Either e a
forall a b. (a -> b) -> a -> b
$ ContextError c e a
-> c
-> (e -> Identity (Either e a))
-> (c -> a -> Identity (Either e a))
-> Identity (Either e a)
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 (Either e a -> Identity (Either e a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Either e a -> Identity (Either e a))
-> (e -> Either e a) -> e -> Identity (Either e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> Either e a
forall a b. a -> Either a b
Left) ((a -> Identity (Either e a)) -> c -> a -> Identity (Either e a)
forall a b. a -> b -> a
const ((a -> Identity (Either e a)) -> c -> a -> Identity (Either e a))
-> (a -> Identity (Either e a)) -> c -> a -> Identity (Either e a)
forall a b. (a -> b) -> a -> b
$ Either e a -> Identity (Either e a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Either e a -> Identity (Either e a))
-> (a -> Either e a) -> a -> Identity (Either e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Either e a
forall a b. b -> Either a b
Right)

instance Functor (ContextErrorT c e m) where
  fmap :: (a -> b) -> ContextErrorT c e m a -> ContextErrorT c e m b
fmap a -> b
f ContextErrorT c e m a
e = (forall b. c -> (e -> m b) -> (c -> b -> m b) -> m b)
-> ContextErrorT c e m b
forall c e (m :: * -> *) a.
(forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
ContextErrorT ((forall b. c -> (e -> m b) -> (c -> b -> m b) -> m b)
 -> ContextErrorT c e m b)
-> (forall b. c -> (e -> m b) -> (c -> b -> m b) -> m b)
-> ContextErrorT c e m b
forall a b. (a -> b) -> a -> b
$ \c
c e -> m b
err c -> b -> m b
ret -> ContextErrorT c e m a -> c -> (e -> m b) -> (c -> a -> m b) -> m b
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' (b -> m b) -> (a -> b) -> a -> m b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f)

instance Applicative (ContextErrorT c e m) where
  pure :: a -> ContextErrorT c e m a
pure a
a = (forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m 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 b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
 -> ContextErrorT c e m a)
-> (forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
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 <*> :: ContextErrorT c e m (a -> b)
-> ContextErrorT c e m a -> ContextErrorT c e m b
<*> ContextErrorT c e m a
ae = (forall b. c -> (e -> m b) -> (c -> b -> m b) -> m b)
-> ContextErrorT c e m b
forall c e (m :: * -> *) a.
(forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
ContextErrorT ((forall b. c -> (e -> m b) -> (c -> b -> m b) -> m b)
 -> ContextErrorT c e m b)
-> (forall b. c -> (e -> m b) -> (c -> b -> m b) -> m b)
-> ContextErrorT c e m b
forall a b. (a -> b) -> a -> b
$ \c
c e -> m b
err c -> b -> m b
ret ->
    ContextErrorT c e m (a -> b)
-> c -> (e -> m b) -> (c -> (a -> b) -> m b) -> m b
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 -> ContextErrorT c e m a -> c -> (e -> m b) -> (c -> a -> m b) -> m b
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'' (b -> m b) -> (a -> b) -> a -> m b
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 :: ContextErrorT c e m a
empty = (forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m 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 b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
 -> ContextErrorT c e m a)
-> (forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
forall a b. (a -> b) -> a -> b
$ \c
_ e -> m b
err c -> a -> m b
_ -> e -> m b
err ([Char] -> e
forall a. HasCallStack => [Char] -> a
error [Char]
"empty ContextErrorT")
  {-# INLINE empty #-}

  ContextErrorT c e m a
ae <|> :: ContextErrorT c e m a
-> ContextErrorT c e m a -> ContextErrorT c e m a
<|> ContextErrorT c e m a
be = (forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m 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 b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
 -> ContextErrorT c e m a)
-> (forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
forall a b. (a -> b) -> a -> b
$ \c
c e -> m b
err c -> a -> m b
ret ->
    ContextErrorT c e m a -> c -> (e -> m b) -> (c -> a -> m b) -> m b
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 -> ContextErrorT c e m a -> c -> (e -> m b) -> (c -> a -> m b) -> m b
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 e -> 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
  return :: a -> ContextErrorT c e m a
return a
a = (forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m 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 b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
 -> ContextErrorT c e m a)
-> (forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
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 return #-}

  ContextErrorT c e m a
ma >>= :: ContextErrorT c e m a
-> (a -> ContextErrorT c e m b) -> ContextErrorT c e m b
>>= a -> ContextErrorT c e m b
fb =
    (forall b. c -> (e -> m b) -> (c -> b -> m b) -> m b)
-> ContextErrorT c e m b
forall c e (m :: * -> *) a.
(forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
ContextErrorT ((forall b. c -> (e -> m b) -> (c -> b -> m b) -> m b)
 -> ContextErrorT c e m b)
-> (forall b. c -> (e -> m b) -> (c -> b -> m b) -> m b)
-> ContextErrorT c e m b
forall a b. (a -> b) -> a -> b
$ \c
c e -> m b
err c -> b -> m b
ret ->
      ContextErrorT c e m a -> c -> (e -> m b) -> (c -> a -> m b) -> m b
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 ((c -> a -> m b) -> m b) -> (c -> a -> m b) -> m b
forall a b. (a -> b) -> a -> b
$ \c
c' a
a ->
        ContextErrorT c e m b -> c -> (e -> m b) -> (c -> b -> m b) -> m b
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 :: ContextErrorT c e m a
mzero = ContextErrorT c e m a
forall (f :: * -> *) a. Alternative f => f a
empty
  {-# INLINE mzero #-}

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

instance MonadTrans (ContextErrorT c e) where
  lift :: m a -> ContextErrorT c e m a
lift m a
act = (forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m 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 b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
 -> ContextErrorT c e m a)
-> (forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
forall a b. (a -> b) -> a -> b
$ \c
c e -> m b
_ c -> a -> m b
ret -> m a
act m a -> (a -> m b) -> m b
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 = m s -> ContextErrorT c e m s
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m s
forall s (m :: * -> *). MonadState s m => m s
get
  put :: s -> ContextErrorT c e m ()
put = m () -> ContextErrorT c e m ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> ContextErrorT c e m ())
-> (s -> m ()) -> s -> ContextErrorT c e m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> m ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put
  state :: (s -> (a, s)) -> ContextErrorT c e m a
state = m a -> ContextErrorT c e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> ContextErrorT c e m a)
-> ((s -> (a, s)) -> m a) -> (s -> (a, s)) -> ContextErrorT c e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (s -> (a, s)) -> m a
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 :: (a, w) -> ContextErrorT c e m a
writer = m a -> ContextErrorT c e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> ContextErrorT c e m a)
-> ((a, w) -> m a) -> (a, w) -> ContextErrorT c e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, w) -> m a
forall w (m :: * -> *) a. MonadWriter w m => (a, w) -> m a
writer
  tell :: w -> ContextErrorT c e m ()
tell = m () -> ContextErrorT c e m ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> ContextErrorT c e m ())
-> (w -> m ()) -> w -> ContextErrorT c e m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. w -> m ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell
  listen :: ContextErrorT c e m a -> ContextErrorT c e m (a, w)
listen ContextErrorT c e m a
m = (forall b. c -> (e -> m b) -> (c -> (a, w) -> m b) -> m b)
-> ContextErrorT c e m (a, w)
forall c e (m :: * -> *) a.
(forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
ContextErrorT ((forall b. c -> (e -> m b) -> (c -> (a, w) -> m b) -> m b)
 -> ContextErrorT c e m (a, w))
-> (forall b. c -> (e -> m b) -> (c -> (a, w) -> m b) -> m b)
-> ContextErrorT c e m (a, w)
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) <- m (Either e (c, a)) -> m (Either e (c, a), w)
forall w (m :: * -> *) a. MonadWriter w m => m a -> m (a, w)
listen (ContextErrorT c e m a
-> c
-> (e -> m (Either e (c, a)))
-> (c -> a -> m (Either e (c, a)))
-> m (Either e (c, a))
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 (Either e (c, a) -> m (Either e (c, a))
forall (m :: * -> *) a. Monad m => a -> m a
return (Either e (c, a) -> m (Either e (c, a)))
-> (e -> Either e (c, a)) -> e -> m (Either e (c, a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> Either e (c, a)
forall a b. a -> Either a b
Left) (((c, a) -> m (Either e (c, a))) -> c -> a -> m (Either e (c, a))
forall a b c. ((a, b) -> c) -> a -> b -> c
curry (Either e (c, a) -> m (Either e (c, a))
forall (m :: * -> *) a. Monad m => a -> m a
return (Either e (c, a) -> m (Either e (c, a)))
-> ((c, a) -> Either e (c, a)) -> (c, a) -> m (Either e (c, a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c, a) -> Either e (c, a)
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 :: ContextErrorT c e m (a, w -> w) -> ContextErrorT c e m a
pass ContextErrorT c e m (a, w -> w)
m = (forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m 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 b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
 -> ContextErrorT c e m a)
-> (forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
forall a b. (a -> b) -> a -> b
$ \c
c e -> m b
err c -> a -> m b
ret -> m (b, w -> w) -> m b
forall w (m :: * -> *) a. MonadWriter w m => m (a, w -> w) -> m a
pass (m (b, w -> w) -> m b) -> m (b, w -> w) -> m b
forall a b. (a -> b) -> a -> b
$ do
    Either e (c, (a, w -> w))
res <- ContextErrorT c e m (a, w -> w)
-> c
-> (e -> m (Either e (c, (a, w -> w))))
-> (c -> (a, w -> w) -> m (Either e (c, (a, w -> w))))
-> m (Either e (c, (a, w -> w)))
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 (Either e (c, (a, w -> w)) -> m (Either e (c, (a, w -> w)))
forall (m :: * -> *) a. Monad m => a -> m a
return (Either e (c, (a, w -> w)) -> m (Either e (c, (a, w -> w))))
-> (e -> Either e (c, (a, w -> w)))
-> e
-> m (Either e (c, (a, w -> w)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> Either e (c, (a, w -> w))
forall a b. a -> Either a b
Left) (((c, (a, w -> w)) -> m (Either e (c, (a, w -> w))))
-> c -> (a, w -> w) -> m (Either e (c, (a, w -> w)))
forall a b c. ((a, b) -> c) -> a -> b -> c
curry (Either e (c, (a, w -> w)) -> m (Either e (c, (a, w -> w)))
forall (m :: * -> *) a. Monad m => a -> m a
return (Either e (c, (a, w -> w)) -> m (Either e (c, (a, w -> w))))
-> ((c, (a, w -> w)) -> Either e (c, (a, w -> w)))
-> (c, (a, w -> w))
-> m (Either e (c, (a, w -> w)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c, (a, w -> w)) -> Either e (c, (a, w -> w))
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)) -> (b -> (b, w -> w)) -> m b -> m (b, w -> w)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (\b
b -> (b
b, w -> w
f)) (m b -> m (b, w -> w)) -> m b -> m (b, w -> w)
forall a b. (a -> b) -> a -> b
$ c -> a -> m b
ret c
c' a
a
      Left e
e -> (b -> (b, w -> w)) -> m b -> m (b, w -> w)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (\b
b -> (b
b, w -> w
forall a. a -> a
id)) (m b -> m (b, w -> w)) -> m b -> m (b, w -> w)
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 = m r -> ContextErrorT c e m r
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m r
forall r (m :: * -> *). MonadReader r m => m r
ask
  local :: (r -> r) -> ContextErrorT c e m a -> ContextErrorT c e m a
local r -> r
f ContextErrorT c e m a
m = (forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m 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 b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
 -> ContextErrorT c e m a)
-> (forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
forall a b. (a -> b) -> a -> b
$ \c
c e -> m b
err c -> a -> m b
ret ->
    (r -> r) -> m b -> m b
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local r -> r
f (ContextErrorT c e m a -> c -> (e -> m b) -> (c -> a -> m b) -> m b
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 :: (r -> a) -> ContextErrorT c e m a
reader = m a -> ContextErrorT c e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> ContextErrorT c e m a)
-> ((r -> a) -> m a) -> (r -> a) -> ContextErrorT c e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (r -> a) -> m a
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 :: (c -> e) -> ContextErrorT c e m a
throwInContext c -> e
f = (forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m 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 b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
 -> ContextErrorT c e m a)
-> (forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
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 b. c -> (e -> m b) -> (c -> c -> m b) -> m b)
-> ContextErrorT c e m c
forall c e (m :: * -> *) a.
(forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
ContextErrorT ((forall b. c -> (e -> m b) -> (c -> c -> m b) -> m b)
 -> ContextErrorT c e m c)
-> (forall b. c -> (e -> m b) -> (c -> c -> m b) -> m b)
-> ContextErrorT c e m c
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 :: (c -> c) -> ContextErrorT c e m a -> ContextErrorT c e m a
localContext c -> c
f ContextErrorT c e m a
m = (forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m 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 b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
 -> ContextErrorT c e m a)
-> (forall b. c -> (e -> m b) -> (c -> a -> m b) -> m b)
-> ContextErrorT c e m a
forall a b. (a -> b) -> a -> b
$ \c
c e -> m b
err c -> a -> m b
ret ->
    ContextErrorT c e m a -> c -> (e -> m b) -> (c -> a -> m b) -> m b
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 b. c -> (e -> m b) -> (c -> () -> m b) -> m b)
-> ContextErrorT c e 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 b. c -> (e -> m b) -> (c -> () -> m b) -> m b)
 -> ContextErrorT c e m ())
-> (forall b. c -> (e -> m b) -> (c -> () -> m b) -> m b)
-> ContextErrorT c e m ()
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 :: (c -> e) -> ContT r m a
throwInContext = m a -> ContT r m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> ContT r m a)
-> ((c -> e) -> m a) -> (c -> e) -> ContT r m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> e) -> m a
forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> e) -> m a
throwInContext
    askContext :: ContT r m c
askContext = m c -> ContT r m c
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m c
forall c e (m :: * -> *). MonadContextError c e m => m c
askContext
    localContext :: (c -> c) -> ContT r m a -> ContT r m a
localContext = m c
-> ((c -> c) -> m r -> m r)
-> (c -> c)
-> ContT r m a
-> ContT r m a
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 m c
forall c e (m :: * -> *). MonadContextError c e m => m c
askContext (c -> c) -> m r -> m r
forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> c) -> m a -> m a
localContext
    modifyContext :: (c -> c) -> ContT r m ()
modifyContext = m () -> ContT r m ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> ContT r m ())
-> ((c -> c) -> m ()) -> (c -> c) -> ContT r m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> c) -> m ()
forall c e (m :: * -> *).
MonadContextError c e m =>
(c -> c) -> m ()
modifyContext

#if MIN_VERSION_mtl(2, 2, 0)

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

#else

instance (Error e', MonadContextError c e m) =>
         MonadContextError c e (ErrorT e' m) where
    throwInContext = lift . throwInContext
    askContext = lift askContext
    localContext = mapErrorT . localContext
    modifyContext = lift . modifyContext

#endif

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

instance MonadContextError c e m =>
         MonadContextError c e (MaybeT m) where
    throwInContext :: (c -> e) -> MaybeT m a
throwInContext = m a -> MaybeT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> MaybeT m a) -> ((c -> e) -> m a) -> (c -> e) -> MaybeT m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> e) -> m a
forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> e) -> m a
throwInContext
    askContext :: MaybeT m c
askContext = m c -> MaybeT m c
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m c
forall c e (m :: * -> *). MonadContextError c e m => m c
askContext
    localContext :: (c -> c) -> MaybeT m a -> MaybeT m a
localContext = (m (Maybe a) -> m (Maybe a)) -> MaybeT m a -> MaybeT m a
forall (m :: * -> *) a (n :: * -> *) b.
(m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b
mapMaybeT ((m (Maybe a) -> m (Maybe a)) -> MaybeT m a -> MaybeT m a)
-> ((c -> c) -> m (Maybe a) -> m (Maybe a))
-> (c -> c)
-> MaybeT m a
-> MaybeT m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> c) -> m (Maybe a) -> m (Maybe a)
forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> c) -> m a -> m a
localContext
    modifyContext :: (c -> c) -> MaybeT m ()
modifyContext = m () -> MaybeT m ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> MaybeT m ())
-> ((c -> c) -> m ()) -> (c -> c) -> MaybeT m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> c) -> m ()
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 :: (c -> e) -> ReaderT r m a
throwInContext = m a -> ReaderT r m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> ReaderT r m a)
-> ((c -> e) -> m a) -> (c -> e) -> ReaderT r m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> e) -> m a
forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> e) -> m a
throwInContext
    askContext :: ReaderT r m c
askContext = m c -> ReaderT r m c
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m c
forall c e (m :: * -> *). MonadContextError c e m => m c
askContext
    localContext :: (c -> c) -> ReaderT r m a -> ReaderT r m a
localContext = (m a -> m a) -> ReaderT r m a -> ReaderT r m a
forall (m :: * -> *) a (n :: * -> *) b r.
(m a -> n b) -> ReaderT r m a -> ReaderT r n b
mapReaderT ((m a -> m a) -> ReaderT r m a -> ReaderT r m a)
-> ((c -> c) -> m a -> m a)
-> (c -> c)
-> ReaderT r m a
-> ReaderT r m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> c) -> m a -> m a
forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> c) -> m a -> m a
localContext
    modifyContext :: (c -> c) -> ReaderT r m ()
modifyContext = m () -> ReaderT r m ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> ReaderT r m ())
-> ((c -> c) -> m ()) -> (c -> c) -> ReaderT r m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> c) -> m ()
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 :: (c -> e) -> WriterT w m a
throwInContext = m a -> WriterT w m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> WriterT w m a)
-> ((c -> e) -> m a) -> (c -> e) -> WriterT w m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> e) -> m a
forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> e) -> m a
throwInContext
    askContext :: WriterT w m c
askContext = m c -> WriterT w m c
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m c
forall c e (m :: * -> *). MonadContextError c e m => m c
askContext
    localContext :: (c -> c) -> WriterT w m a -> WriterT w m a
localContext = (m (a, w) -> m (a, w)) -> WriterT w m a -> WriterT w m a
forall (m :: * -> *) a w (n :: * -> *) b w'.
(m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
Lazy.mapWriterT ((m (a, w) -> m (a, w)) -> WriterT w m a -> WriterT w m a)
-> ((c -> c) -> m (a, w) -> m (a, w))
-> (c -> c)
-> WriterT w m a
-> WriterT w m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> c) -> m (a, w) -> m (a, w)
forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> c) -> m a -> m a
localContext
    modifyContext :: (c -> c) -> WriterT w m ()
modifyContext = m () -> WriterT w m ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> WriterT w m ())
-> ((c -> c) -> m ()) -> (c -> c) -> WriterT w m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> c) -> m ()
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 :: (c -> e) -> WriterT w m a
throwInContext = m a -> WriterT w m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> WriterT w m a)
-> ((c -> e) -> m a) -> (c -> e) -> WriterT w m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> e) -> m a
forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> e) -> m a
throwInContext
    askContext :: WriterT w m c
askContext = m c -> WriterT w m c
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m c
forall c e (m :: * -> *). MonadContextError c e m => m c
askContext
    localContext :: (c -> c) -> WriterT w m a -> WriterT w m a
localContext = (m (a, w) -> m (a, w)) -> WriterT w m a -> WriterT w m a
forall (m :: * -> *) a w (n :: * -> *) b w'.
(m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
Strict.mapWriterT ((m (a, w) -> m (a, w)) -> WriterT w m a -> WriterT w m a)
-> ((c -> c) -> m (a, w) -> m (a, w))
-> (c -> c)
-> WriterT w m a
-> WriterT w m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> c) -> m (a, w) -> m (a, w)
forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> c) -> m a -> m a
localContext
    modifyContext :: (c -> c) -> WriterT w m ()
modifyContext = m () -> WriterT w m ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> WriterT w m ())
-> ((c -> c) -> m ()) -> (c -> c) -> WriterT w m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> c) -> m ()
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 :: (c -> e) -> StateT s m a
throwInContext = m a -> StateT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> StateT s m a)
-> ((c -> e) -> m a) -> (c -> e) -> StateT s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> e) -> m a
forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> e) -> m a
throwInContext
    askContext :: StateT s m c
askContext = m c -> StateT s m c
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m c
forall c e (m :: * -> *). MonadContextError c e m => m c
askContext
    localContext :: (c -> c) -> StateT s m a -> StateT s m a
localContext = (m (a, s) -> m (a, s)) -> StateT s m a -> StateT s m a
forall (m :: * -> *) a s (n :: * -> *) b.
(m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b
Lazy.mapStateT ((m (a, s) -> m (a, s)) -> StateT s m a -> StateT s m a)
-> ((c -> c) -> m (a, s) -> m (a, s))
-> (c -> c)
-> StateT s m a
-> StateT s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> c) -> m (a, s) -> m (a, s)
forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> c) -> m a -> m a
localContext
    modifyContext :: (c -> c) -> StateT s m ()
modifyContext = m () -> StateT s m ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> StateT s m ())
-> ((c -> c) -> m ()) -> (c -> c) -> StateT s m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> c) -> m ()
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 :: (c -> e) -> StateT s m a
throwInContext = m a -> StateT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> StateT s m a)
-> ((c -> e) -> m a) -> (c -> e) -> StateT s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> e) -> m a
forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> e) -> m a
throwInContext
    askContext :: StateT s m c
askContext = m c -> StateT s m c
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m c
forall c e (m :: * -> *). MonadContextError c e m => m c
askContext
    localContext :: (c -> c) -> StateT s m a -> StateT s m a
localContext = (m (a, s) -> m (a, s)) -> StateT s m a -> StateT s m a
forall (m :: * -> *) a s (n :: * -> *) b.
(m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b
Strict.mapStateT ((m (a, s) -> m (a, s)) -> StateT s m a -> StateT s m a)
-> ((c -> c) -> m (a, s) -> m (a, s))
-> (c -> c)
-> StateT s m a
-> StateT s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> c) -> m (a, s) -> m (a, s)
forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> c) -> m a -> m a
localContext
    modifyContext :: (c -> c) -> StateT s m ()
modifyContext = m () -> StateT s m ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> StateT s m ())
-> ((c -> c) -> m ()) -> (c -> c) -> StateT s m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> c) -> m ()
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 :: (c -> e) -> RWST r w s m a
throwInContext = m a -> RWST r w s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> RWST r w s m a)
-> ((c -> e) -> m a) -> (c -> e) -> RWST r w s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> e) -> m a
forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> e) -> m a
throwInContext
    askContext :: RWST r w s m c
askContext = m c -> RWST r w s m c
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m c
forall c e (m :: * -> *). MonadContextError c e m => m c
askContext
    localContext :: (c -> c) -> RWST r w s m a -> RWST r w s m a
localContext = (m (a, s, w) -> m (a, s, w)) -> RWST r w s m a -> RWST r w s m a
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 ((m (a, s, w) -> m (a, s, w)) -> RWST r w s m a -> RWST r w s m a)
-> ((c -> c) -> m (a, s, w) -> m (a, s, w))
-> (c -> c)
-> RWST r w s m a
-> RWST r w s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> c) -> m (a, s, w) -> m (a, s, w)
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 = m () -> RWST r w s m ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> RWST r w s m ())
-> ((c -> c) -> m ()) -> (c -> c) -> RWST r w s m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> c) -> m ()
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 :: (c -> e) -> RWST r w s m a
throwInContext = m a -> RWST r w s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> RWST r w s m a)
-> ((c -> e) -> m a) -> (c -> e) -> RWST r w s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> e) -> m a
forall c e (m :: * -> *) a.
MonadContextError c e m =>
(c -> e) -> m a
throwInContext
    askContext :: RWST r w s m c
askContext = m c -> RWST r w s m c
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m c
forall c e (m :: * -> *). MonadContextError c e m => m c
askContext
    localContext :: (c -> c) -> RWST r w s m a -> RWST r w s m a
localContext = (m (a, s, w) -> m (a, s, w)) -> RWST r w s m a -> RWST r w s m a
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 ((m (a, s, w) -> m (a, s, w)) -> RWST r w s m a -> RWST r w s m a)
-> ((c -> c) -> m (a, s, w) -> m (a, s, w))
-> (c -> c)
-> RWST r w s m a
-> RWST r w s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> c) -> m (a, s, w) -> m (a, s, w)
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 = m () -> RWST r w s m ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> RWST r w s m ())
-> ((c -> c) -> m ()) -> (c -> c) -> RWST r w s m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> c) -> m ()
forall c e (m :: * -> *).
MonadContextError c e m =>
(c -> c) -> m ()
modifyContext