{-# 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 = (r -> r) -> ReaderT r m a -> ReaderT r m a
forall r (m :: Type -> Type) a.
(r -> r) -> ReaderT r m a -> ReaderT r m a
local ((r -> r) -> ReaderT r m a -> ReaderT r m a)
-> (r -> r) -> ReaderT r m a -> ReaderT r m a
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 = Dict (Functor (ReaderT s m))
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 = Dict (Applicative (ReaderT s m))
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 = Dict (Monad (ReaderT s m))
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 = Dict (MonadIO (ReaderT s m))
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 = Dict (MonadFail (ReaderT s m))
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 = Dict (MonadFix (ReaderT s m))
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 = Dict (MonadPlus (ReaderT s m))
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 = Dict (Coercible (ReaderT r m1) (ReaderT r m2))
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 = m a -> ReaderT r m a
forall (m :: Type -> Type) a. Monad m => m a -> ReaderT r m a
forall (t :: TransKind) (m :: Type -> Type) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> ReaderT r m a) -> m a -> ReaderT r m a
forall a b. (a -> b) -> a -> b
$ Exc m -> m a
forall a. Exc m -> m a
forall (m :: Type -> Type) a. MonadException m => Exc m -> m a
throwExc Exc m
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 (m1 :: Type -> Type) a.
  Monad m1 =>
  ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a))
 -> m (Tunnel (ReaderT r) a))
-> ReaderT r m a
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
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 (m1 :: Type -> Type) a.
   Monad m1 =>
   ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a))
  -> m (Tunnel (ReaderT r) a))
 -> ReaderT r m a)
-> ((forall (m1 :: Type -> Type) a.
     Monad m1 =>
     ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a))
    -> m (Tunnel (ReaderT r) a))
-> ReaderT r m a
forall a b. (a -> b) -> a -> b
$ \forall (m1 :: Type -> Type) a.
Monad m1 =>
ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a)
unlift -> m (Tunnel (ReaderT r) a)
-> (Exc m -> m (Tunnel (ReaderT r) a)) -> m (Tunnel (ReaderT r) a)
forall a. m a -> (Exc m -> m a) -> m a
forall (m :: Type -> Type) a.
MonadException m =>
m a -> (Exc m -> m a) -> m a
catchExc (ReaderT r m a -> m (Tunnel (ReaderT r) a)
forall (m1 :: Type -> Type) a.
Monad m1 =>
ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a)
unlift ReaderT r m a
tma) ((Exc m -> m (Tunnel (ReaderT r) a)) -> m (Tunnel (ReaderT r) a))
-> (Exc m -> m (Tunnel (ReaderT r) a)) -> m (Tunnel (ReaderT r) a)
forall a b. (a -> b) -> a -> b
$ \Exc m
e -> ReaderT r m a -> m (Tunnel (ReaderT r) a)
forall (m1 :: Type -> Type) a.
Monad m1 =>
ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a)
unlift (ReaderT r m a -> m (Tunnel (ReaderT r) a))
-> ReaderT r m a -> m (Tunnel (ReaderT r) a)
forall a b. (a -> b) -> a -> b
$ Exc (ReaderT r m) -> ReaderT r m a
handler Exc m
Exc (ReaderT r m)
e

instance TransConstraint MonadException (ReaderT r) where
    hasTransConstraint :: forall (m :: Type -> Type).
MonadException m =>
Dict (MonadException (ReaderT r m))
hasTransConstraint = Dict (MonadException (ReaderT r m))
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 = m a -> ReaderT r m a
forall (m :: Type -> Type) a. Monad m => m a -> ReaderT r m a
forall (t :: TransKind) (m :: Type -> Type) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> ReaderT r m a) -> m a -> ReaderT r m a
forall a b. (a -> b) -> a -> b
$ e -> m a
forall a. e -> m a
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 = Dict (MonadThrow e (ReaderT r m))
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 (m1 :: Type -> Type) a.
  Monad m1 =>
  ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a))
 -> m (Tunnel (ReaderT r) a))
-> ReaderT r m a
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
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 (m1 :: Type -> Type) a.
   Monad m1 =>
   ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a))
  -> m (Tunnel (ReaderT r) a))
 -> ReaderT r m a)
-> ((forall (m1 :: Type -> Type) a.
     Monad m1 =>
     ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a))
    -> m (Tunnel (ReaderT r) a))
-> ReaderT r m a
forall a b. (a -> b) -> a -> b
$ \forall (m1 :: Type -> Type) a.
Monad m1 =>
ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a)
unlift -> m (Tunnel (ReaderT r) a)
-> (e -> m (Tunnel (ReaderT r) a)) -> m (Tunnel (ReaderT r) a)
forall a. m a -> (e -> m a) -> m a
forall e (m :: Type -> Type) a.
MonadCatch e m =>
m a -> (e -> m a) -> m a
catch (ReaderT r m a -> m (Tunnel (ReaderT r) a)
forall (m1 :: Type -> Type) a.
Monad m1 =>
ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a)
unlift ReaderT r m a
ma) ((e -> m (Tunnel (ReaderT r) a)) -> m (Tunnel (ReaderT r) a))
-> (e -> m (Tunnel (ReaderT r) a)) -> m (Tunnel (ReaderT r) a)
forall a b. (a -> b) -> a -> b
$ \e
e -> ReaderT r m a -> m (Tunnel (ReaderT r) a)
forall (m1 :: Type -> Type) a.
Monad m1 =>
ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a)
unlift (ReaderT r m a -> m (Tunnel (ReaderT r) a))
-> ReaderT r m a -> m (Tunnel (ReaderT r) a)
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 = Dict (MonadCatch e (ReaderT r m))
forall (a :: Constraint). a => Dict a
Dict

instance MonadOuter m => MonadOuter (ReaderT r m) where
    getExtract :: ReaderT r m (WExtract (ReaderT r m))
getExtract =
        (r -> m (WExtract (ReaderT r m)))
-> ReaderT r m (WExtract (ReaderT r m))
forall r (m :: Type -> Type) a. (r -> m a) -> ReaderT r m a
ReaderT ((r -> m (WExtract (ReaderT r m)))
 -> ReaderT r m (WExtract (ReaderT r m)))
-> (r -> m (WExtract (ReaderT r m)))
-> ReaderT r m (WExtract (ReaderT r m))
forall a b. (a -> b) -> a -> b
$ \r
r -> do
            MkWExtract Extract m
maa <- m (WExtract m)
forall (m :: Type -> Type). MonadOuter m => m (WExtract m)
getExtract
            WExtract (ReaderT r m) -> m (WExtract (ReaderT r m))
forall a. a -> m a
forall (m :: Type -> Type) a. Monad m => a -> m a
return (WExtract (ReaderT r m) -> m (WExtract (ReaderT r m)))
-> WExtract (ReaderT r m) -> m (WExtract (ReaderT r m))
forall a b. (a -> b) -> a -> b
$ Extract (ReaderT r m) -> WExtract (ReaderT r m)
forall (m :: Type -> Type). Extract m -> WExtract m
MkWExtract (Extract (ReaderT r m) -> WExtract (ReaderT r m))
-> Extract (ReaderT r m) -> WExtract (ReaderT r m)
forall a b. (a -> b) -> a -> b
$ \(ReaderT r -> m a
rma) -> m a -> a
Extract m
maa (m a -> a) -> m a -> a
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 = Dict (MonadOuter (ReaderT s m))
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 = (m1 --> m2) -> ReaderT r m1 --> ReaderT r m2
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 = (r -> m r) -> ReaderT r m r
forall r (m :: Type -> Type) a. (r -> m a) -> ReaderT r m a
ReaderT ((r -> m r) -> ReaderT r m r) -> (r -> m r) -> ReaderT r m r
forall a b. (a -> b) -> a -> b
$ \r
r -> (Identity r -> r) -> m (Identity r) -> m r
forall a b. (a -> b) -> m a -> m b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap Identity r -> r
forall a. Identity a -> a
runIdentity (m (Identity r) -> m r) -> m (Identity r) -> m r
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 (m1 :: Type -> Type) a.
  Monad m1 =>
  ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a))
 -> m (Tunnel (ReaderT r) r))
-> (forall (m1 :: Type -> Type) a.
    Monad m1 =>
    ReaderT r m1 a -> m1 (Tunnel (ReaderT r) a))
-> m (Tunnel (ReaderT r) r)
forall a b. (a -> b) -> a -> b
$ \(ReaderT r -> m1 a
smr) -> (a -> Tunnel (ReaderT r) a) -> m1 a -> m1 (Tunnel (ReaderT r) a)
forall a b. (a -> b) -> m1 a -> m1 b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Identity a
a -> Tunnel (ReaderT r) a
forall a. a -> Identity a
Identity (m1 a -> m1 (Tunnel (ReaderT r) a))
-> m1 a -> m1 (Tunnel (ReaderT r) a)
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 MonadTunnelIO (ReaderT r) -> m r) -> ReaderT r m r
liftWithUnlift Unlift MonadTunnelIO (ReaderT r) -> m r
call = (r -> m r) -> ReaderT r m r
forall r (m :: Type -> Type) a. (r -> m a) -> ReaderT r m a
ReaderT ((r -> m r) -> ReaderT r m r) -> (r -> m r) -> ReaderT r m r
forall a b. (a -> b) -> a -> b
$ \r
r -> Unlift MonadTunnelIO (ReaderT r) -> m r
call (Unlift MonadTunnelIO (ReaderT r) -> m r)
-> Unlift MonadTunnelIO (ReaderT r) -> m r
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 MonadTunnelIO t) m --> t m
readerTUnliftToT :: forall (t :: TransKind) (m :: Type -> Type).
(MonadTransUnlift t, MonadTunnelIO m) =>
ReaderT (WUnlift MonadTunnelIO t) m --> t m
readerTUnliftToT ReaderT (WUnlift MonadTunnelIO t) m a
rma = (Unlift MonadTunnelIO t -> m a) -> t m a
forall (m :: Type -> Type) r.
MonadIO m =>
(Unlift MonadTunnelIO t -> m r) -> t m r
forall (t :: TransKind) (m :: Type -> Type) r.
(MonadTransUnlift t, MonadIO m) =>
(Unlift MonadTunnelIO t -> m r) -> t m r
liftWithUnlift ((Unlift MonadTunnelIO t -> m a) -> t m a)
-> (Unlift MonadTunnelIO t -> m a) -> t m a
forall a b. (a -> b) -> a -> b
$ \Unlift MonadTunnelIO t
tr -> ReaderT (WUnlift MonadTunnelIO t) m a
-> WUnlift MonadTunnelIO t -> m a
forall r (m :: Type -> Type) a. ReaderT r m a -> r -> m a
runReaderT ReaderT (WUnlift MonadTunnelIO t) m a
rma (WUnlift MonadTunnelIO t -> m a) -> WUnlift MonadTunnelIO t -> m a
forall a b. (a -> b) -> a -> b
$ Unlift MonadTunnelIO t -> WUnlift MonadTunnelIO t
forall (c :: (Type -> Type) -> Constraint) (t :: TransKind).
Unlift c t -> WUnlift c t
MkWUnlift t m a -> m a
t m --> m
Unlift MonadTunnelIO 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 <- ReaderT (WUnlift Monad t) m (WUnlift Monad t)
forall (m :: Type -> Type) r. Monad m => ReaderT r m r
ask
    m a -> ReaderT (WUnlift Monad t) m a
forall (m :: Type -> Type) a.
Monad m =>
m a -> ReaderT (WUnlift Monad t) m a
forall (t :: TransKind) (m :: Type -> Type) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> ReaderT (WUnlift Monad t) m a)
-> m a -> ReaderT (WUnlift Monad t) m a
forall a b. (a -> b) -> a -> b
$ t m a -> m a
t m --> m
Unlift Monad t
unlift t m a
tma