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

module Control.Monad.Ology.Specific.ContT
    ( module Control.Monad.Trans.Cont
    , module Control.Monad.Ology.Specific.ContT
    ) where

import Control.Monad.Ology.General
import Control.Monad.Ology.Specific.ReaderT
import Control.Monad.Ology.Specific.StateT
import Control.Monad.Trans.Cont hiding (callCC)
import Control.Monad.Trans.Cont qualified as T
import Import

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

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

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

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

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

instance forall k (r :: k) (m :: k -> Type). MonadCont (ContT r m) where
    callCC :: forall a b. ((a -> ContT r m b) -> ContT r m a) -> ContT r m a
callCC = ((a -> ContT r m b) -> ContT r m a) -> ContT r m a
forall {k} a (r :: k) (m :: k -> Type) b.
((a -> ContT r m b) -> ContT r m a) -> ContT r m a
T.callCC

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

updateContT :: (m r -> m r) -> ContT r m ()
updateContT :: forall {k} (m :: k -> Type) (r :: k). (m r -> m r) -> ContT r m ()
updateContT m r -> m r
m = ((() -> m r) -> m r) -> ContT r m ()
forall {k} (r :: k) (m :: k -> Type) a.
((a -> m r) -> m r) -> ContT r m a
ContT (((() -> m r) -> m r) -> ContT r m ())
-> ((() -> m r) -> m r) -> ContT r m ()
forall a b. (a -> b) -> a -> b
$ \() -> m r
umr -> m r -> m r
m (m r -> m r) -> m r -> m r
forall a b. (a -> b) -> a -> b
$ () -> m r
umr ()

stateToReaderContT :: Monad m => StateT s m a -> ContT r (ReaderT s m) a
stateToReaderContT :: forall (m :: Type -> Type) s a r.
Monad m =>
StateT s m a -> ContT r (ReaderT s m) a
stateToReaderContT (StateT s -> m (a, s)
sma) =
    ((a -> ReaderT s m r) -> ReaderT s m r) -> ContT r (ReaderT s m) a
forall {k} (r :: k) (m :: k -> Type) a.
((a -> m r) -> m r) -> ContT r m a
ContT (((a -> ReaderT s m r) -> ReaderT s m r)
 -> ContT r (ReaderT s m) a)
-> ((a -> ReaderT s m r) -> ReaderT s m r)
-> ContT r (ReaderT s m) a
forall a b. (a -> b) -> a -> b
$ \a -> ReaderT s m r
c ->
        (s -> m r) -> ReaderT s m r
forall r (m :: Type -> Type) a. (r -> m a) -> ReaderT r m a
ReaderT ((s -> m r) -> ReaderT s m r) -> (s -> m r) -> ReaderT s m r
forall a b. (a -> b) -> a -> b
$ \s
olds -> do
            (a
a, s
news) <- s -> m (a, s)
sma s
olds
            ReaderT s m r -> s -> m r
forall r (m :: Type -> Type) a. ReaderT r m a -> r -> m a
runReaderT (a -> ReaderT s m r
c a
a) s
news

hoistContT :: (m1 r1 -> m2 r2) -> (m2 r2 -> m1 r1) -> ContT r1 m1 a -> ContT r2 m2 a
hoistContT :: forall {k} {k} (m1 :: k -> Type) (r1 :: k) (m2 :: k -> Type)
       (r2 :: k) a.
(m1 r1 -> m2 r2)
-> (m2 r2 -> m1 r1) -> ContT r1 m1 a -> ContT r2 m2 a
hoistContT m1 r1 -> m2 r2
m12 m2 r2 -> m1 r1
m21 (ContT (a -> m1 r1) -> m1 r1
amrmr) = ((a -> m2 r2) -> m2 r2) -> ContT r2 m2 a
forall {k} (r :: k) (m :: k -> Type) a.
((a -> m r) -> m r) -> ContT r m a
ContT (((a -> m2 r2) -> m2 r2) -> ContT r2 m2 a)
-> ((a -> m2 r2) -> m2 r2) -> ContT r2 m2 a
forall a b. (a -> b) -> a -> b
$ \a -> m2 r2
c -> m1 r1 -> m2 r2
m12 (m1 r1 -> m2 r2) -> m1 r1 -> m2 r2
forall a b. (a -> b) -> a -> b
$ (a -> m1 r1) -> m1 r1
amrmr (m2 r2 -> m1 r1
m21 (m2 r2 -> m1 r1) -> (a -> m2 r2) -> a -> m1 r1
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. a -> m2 r2
c)