{-# OPTIONS -fno-warn-orphans #-}

module Control.Monad.Ology.Specific.ReaderT
    ( module Control.Monad.Trans.Reader
    , module Control.Monad.Ology.Specific.ReaderT
    ) where

import Control.Monad.Ology.General
import Control.Monad.Trans.Reader hiding (liftCallCC, liftCatch)
import Import

with :: r -> ReaderT r m a -> ReaderT r m a
with :: forall r (m :: Type -> Type) a. r -> ReaderT r m a -> ReaderT r m a
with r
r = forall r (m :: Type -> Type) a.
(r -> r) -> ReaderT r m a -> ReaderT r m a
local forall a b. (a -> b) -> a -> b
$ \r
_ -> r
r

instance TransConstraint Functor (ReaderT s) where
    hasTransConstraint :: forall (m :: Type -> Type).
Functor m =>
Dict (Functor (ReaderT s m))
hasTransConstraint = forall (a :: Constraint). a => Dict a
Dict

instance TransConstraint Applicative (ReaderT s) where
    hasTransConstraint :: forall (m :: Type -> Type).
Applicative m =>
Dict (Applicative (ReaderT s m))
hasTransConstraint = forall (a :: Constraint). a => Dict a
Dict

instance TransConstraint Monad (ReaderT s) where
    hasTransConstraint :: forall (m :: Type -> Type). Monad m => Dict (Monad (ReaderT s m))
hasTransConstraint = forall (a :: Constraint). a => Dict a
Dict

instance TransConstraint MonadIO (ReaderT s) where
    hasTransConstraint :: forall (m :: Type -> Type).
MonadIO m =>
Dict (MonadIO (ReaderT s m))
hasTransConstraint = forall (a :: Constraint). a => Dict a
Dict

instance TransConstraint MonadFail (ReaderT s) where
    hasTransConstraint :: forall (m :: Type -> Type).
MonadFail m =>
Dict (MonadFail (ReaderT s m))
hasTransConstraint = forall (a :: Constraint). a => Dict a
Dict

instance TransConstraint MonadFix (ReaderT s) where
    hasTransConstraint :: forall (m :: Type -> Type).
MonadFix m =>
Dict (MonadFix (ReaderT s m))
hasTransConstraint = forall (a :: Constraint). a => Dict a
Dict

instance TransConstraint MonadPlus (ReaderT s) where
    hasTransConstraint :: forall (m :: Type -> Type).
MonadPlus m =>
Dict (MonadPlus (ReaderT s m))
hasTransConstraint = forall (a :: Constraint). a => Dict a
Dict

instance MonadTransCoerce (ReaderT r) where
    transCoerce :: forall (m1 :: Type -> Type) (m2 :: Type -> Type).
Coercible m1 m2 =>
Dict (Coercible (ReaderT r m1) (ReaderT r m2))
transCoerce = forall (a :: Constraint). a => Dict a
Dict

instance MonadException m => MonadException (ReaderT r m) where
    type Exc (ReaderT r m) = Exc m
    throwExc :: forall a. Exc (ReaderT r m) -> ReaderT r m a
throwExc Exc (ReaderT r m)
e = forall (t :: TransKind) (m :: Type -> Type) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall (m :: Type -> Type) a. MonadException m => Exc m -> m a
throwExc Exc (ReaderT r m)
e
    catchExc :: forall a.
ReaderT r m a
-> (Exc (ReaderT r m) -> ReaderT r m a) -> ReaderT r m a
catchExc ReaderT r m a
tma Exc (ReaderT r m) -> ReaderT r m a
handler = forall (t :: TransKind) (m :: Type -> Type) r.
(MonadTransTunnel t, Monad m) =>
((forall (m1 :: Type -> Type) a.
  Monad m1 =>
  t m1 a -> m1 (Tunnel t a))
 -> m (Tunnel t r))
-> t m r
tunnel forall a b. (a -> b) -> a -> b
$ \forall (m1 :: Type -> Type) a.
Monad m1 =>
ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a)
unlift -> forall (m :: Type -> Type) a.
MonadException m =>
m a -> (Exc m -> m a) -> m a
catchExc (forall (m1 :: Type -> Type) a.
Monad m1 =>
ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a)
unlift ReaderT r m a
tma) forall a b. (a -> b) -> a -> b
$ \Exc m
e -> forall (m1 :: Type -> Type) a.
Monad m1 =>
ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a)
unlift forall a b. (a -> b) -> a -> b
$ Exc (ReaderT r m) -> ReaderT r m a
handler Exc m
e

instance TransConstraint MonadException (ReaderT r) where
    hasTransConstraint :: forall (m :: Type -> Type).
MonadException m =>
Dict (MonadException (ReaderT r m))
hasTransConstraint = forall (a :: Constraint). a => Dict a
Dict

instance MonadThrow e m => MonadThrow e (ReaderT r m) where
    throw :: forall a. e -> ReaderT r m a
throw e
e = forall (t :: TransKind) (m :: Type -> Type) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall e (m :: Type -> Type) a. MonadThrow e m => e -> m a
throw e
e

instance TransConstraint (MonadThrow e) (ReaderT r) where
    hasTransConstraint :: forall (m :: Type -> Type).
MonadThrow e m =>
Dict (MonadThrow e (ReaderT r m))
hasTransConstraint = forall (a :: Constraint). a => Dict a
Dict

instance MonadCatch e m => MonadCatch e (ReaderT r m) where
    catch :: forall a. ReaderT r m a -> (e -> ReaderT r m a) -> ReaderT r m a
catch ReaderT r m a
ma e -> ReaderT r m a
handler = forall (t :: TransKind) (m :: Type -> Type) r.
(MonadTransTunnel t, Monad m) =>
((forall (m1 :: Type -> Type) a.
  Monad m1 =>
  t m1 a -> m1 (Tunnel t a))
 -> m (Tunnel t r))
-> t m r
tunnel forall a b. (a -> b) -> a -> b
$ \forall (m1 :: Type -> Type) a.
Monad m1 =>
ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a)
unlift -> forall e (m :: Type -> Type) a.
MonadCatch e m =>
m a -> (e -> m a) -> m a
catch (forall (m1 :: Type -> Type) a.
Monad m1 =>
ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a)
unlift ReaderT r m a
ma) forall a b. (a -> b) -> a -> b
$ \e
e -> forall (m1 :: Type -> Type) a.
Monad m1 =>
ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a)
unlift forall a b. (a -> b) -> a -> b
$ e -> ReaderT r m a
handler e
e

instance TransConstraint (MonadCatch e) (ReaderT r) where
    hasTransConstraint :: forall (m :: Type -> Type).
MonadCatch e m =>
Dict (MonadCatch e (ReaderT r m))
hasTransConstraint = forall (a :: Constraint). a => Dict a
Dict

instance MonadOuter m => MonadOuter (ReaderT r m) where
    getExtract :: ReaderT r m (WExtract (ReaderT r m))
getExtract =
        forall r (m :: Type -> Type) a. (r -> m a) -> ReaderT r m a
ReaderT forall a b. (a -> b) -> a -> b
$ \r
r -> do
            MkWExtract Extract m
maa <- forall (m :: Type -> Type). MonadOuter m => m (WExtract m)
getExtract
            forall (m :: Type -> Type) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: Type -> Type). Extract m -> WExtract m
MkWExtract forall a b. (a -> b) -> a -> b
$ \(ReaderT r -> m a
rma) -> Extract m
maa forall a b. (a -> b) -> a -> b
$ r -> m a
rma r
r

instance TransConstraint MonadOuter (ReaderT s) where
    hasTransConstraint :: forall (m :: Type -> Type).
MonadOuter m =>
Dict (MonadOuter (ReaderT s m))
hasTransConstraint = forall (a :: Constraint). a => Dict a
Dict

instance MonadTransHoist (ReaderT r) where
    hoist :: forall (m1 :: Type -> Type) (m2 :: Type -> Type).
(Monad m1, Monad m2) =>
(m1 --> m2) -> ReaderT r m1 --> ReaderT r m2
hoist = forall (t :: TransKind) (m1 :: Type -> Type) (m2 :: Type -> Type).
(MonadTransTunnel t, Monad m1, Monad m2) =>
(m1 --> m2) -> t m1 --> t m2
tunnelHoist

instance MonadTransTunnel (ReaderT r) where
    type Tunnel (ReaderT r) = Identity
    tunnel :: forall (m :: Type -> Type) r.
Monad m =>
((forall (m1 :: Type -> Type) a.
  Monad m1 =>
  ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a))
 -> m (Tunnel (ReaderT r) r))
-> ReaderT r m r
tunnel (forall (m1 :: Type -> Type) a.
 Monad m1 =>
 ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a))
-> m (Tunnel (ReaderT r) r)
call = forall r (m :: Type -> Type) a. (r -> m a) -> ReaderT r m a
ReaderT forall a b. (a -> b) -> a -> b
$ \r
r -> forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Identity a -> a
runIdentity forall a b. (a -> b) -> a -> b
$ (forall (m1 :: Type -> Type) a.
 Monad m1 =>
 ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a))
-> m (Tunnel (ReaderT r) r)
call forall a b. (a -> b) -> a -> b
$ \(ReaderT r -> m1 a
smr) -> forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. a -> Identity a
Identity forall a b. (a -> b) -> a -> b
$ r -> m1 a
smr r
r

instance MonadTransUnlift (ReaderT r) where
    liftWithUnlift :: forall (m :: Type -> Type) r.
MonadIO m =>
(Unlift MonadTunnelIOInner (ReaderT r) -> m r) -> ReaderT r m r
liftWithUnlift Unlift MonadTunnelIOInner (ReaderT r) -> m r
call = forall r (m :: Type -> Type) a. (r -> m a) -> ReaderT r m a
ReaderT forall a b. (a -> b) -> a -> b
$ \r
r -> Unlift MonadTunnelIOInner (ReaderT r) -> m r
call forall a b. (a -> b) -> a -> b
$ \(ReaderT r -> m a
smr) -> r -> m a
smr r
r

instance MonadTransAskUnlift (ReaderT r)

readerTUnliftToT ::
       forall t m. (MonadTransUnlift t, MonadTunnelIO m)
    => ReaderT (WUnlift MonadTunnelIOInner t) m --> t m
readerTUnliftToT :: forall (t :: TransKind) (m :: Type -> Type).
(MonadTransUnlift t, MonadTunnelIO m) =>
ReaderT (WUnlift MonadTunnelIOInner t) m --> t m
readerTUnliftToT ReaderT (WUnlift MonadTunnelIOInner t) m a
rma = forall (t :: TransKind) (m :: Type -> Type) r.
(MonadTransUnlift t, MonadIO m) =>
(Unlift MonadTunnelIOInner t -> m r) -> t m r
liftWithUnlift forall a b. (a -> b) -> a -> b
$ \Unlift MonadTunnelIOInner t
tr -> forall r (m :: Type -> Type) a. ReaderT r m a -> r -> m a
runReaderT ReaderT (WUnlift MonadTunnelIOInner t) m a
rma forall a b. (a -> b) -> a -> b
$ forall (c :: (Type -> Type) -> Constraint) (t :: TransKind).
Unlift c t -> WUnlift c t
MkWUnlift Unlift MonadTunnelIOInner t
tr

tToReaderTUnlift :: MonadTunnelIO m => t m --> ReaderT (WUnlift Monad t) m
tToReaderTUnlift :: forall (m :: Type -> Type) (t :: TransKind).
MonadTunnelIO m =>
t m --> ReaderT (WUnlift Monad t) m
tToReaderTUnlift t m a
tma = do
    MkWUnlift Unlift Monad t
unlift <- forall (m :: Type -> Type) r. Monad m => ReaderT r m r
ask
    forall (t :: TransKind) (m :: Type -> Type) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ Unlift Monad t
unlift t m a
tma