{-# LANGUAGE UndecidableInstances #-}

module Control.Monad.Trans.Compose.Transparent where

import Control.Monad.Trans.Class
import Control.Monad.Trans.Control
import Control.Monad.Trans.Control.Identity
import Control.Monad.Trans.Elevator
import Control.Monad.Trans.Identity

-- | A monad transformer, that passes through all instances via 'Elevator'.
--
-- This cannot be defined as a newtype, because we want all the instances, that are defined for
-- 'Elevator' to work for 'TransparentT'.
type TransparentT = Elevator NoT

runTransparentT :: TransparentT m a -> m a
runTransparentT :: forall (m :: * -> *) a. TransparentT m a -> m a
runTransparentT = forall {k} (f :: k -> *) (a :: k). IdentityT f a -> f a
runIdentityT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {k} (m :: k -> *) (a :: k). NoT m a -> IdentityT m a
unNoT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
Elevator t m a -> t m a
descend

-- | A newtype wrapper around 'IdentityT'.
--
-- This is used in 'TransparentT' to encourage the use of 'runTransparentT'.
newtype NoT m a = MkNoT {forall {k} (m :: k -> *) (a :: k). NoT m a -> IdentityT m a
unNoT :: IdentityT m a}
  deriving newtype (forall a b. a -> NoT m b -> NoT m a
forall a b. (a -> b) -> NoT m a -> NoT m b
forall (m :: * -> *) a b. Functor m => a -> NoT m b -> NoT m a
forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> NoT m a -> NoT m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> NoT m b -> NoT m a
$c<$ :: forall (m :: * -> *) a b. Functor m => a -> NoT m b -> NoT m a
fmap :: forall a b. (a -> b) -> NoT m a -> NoT m b
$cfmap :: forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> NoT m a -> NoT m b
Functor, forall a. a -> NoT m a
forall a b. NoT m a -> NoT m b -> NoT m a
forall a b. NoT m a -> NoT m b -> NoT m b
forall a b. NoT m (a -> b) -> NoT m a -> NoT m b
forall a b c. (a -> b -> c) -> NoT m a -> NoT m b -> NoT m c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
forall {m :: * -> *}. Applicative m => Functor (NoT m)
forall (m :: * -> *) a. Applicative m => a -> NoT m a
forall (m :: * -> *) a b.
Applicative m =>
NoT m a -> NoT m b -> NoT m a
forall (m :: * -> *) a b.
Applicative m =>
NoT m a -> NoT m b -> NoT m b
forall (m :: * -> *) a b.
Applicative m =>
NoT m (a -> b) -> NoT m a -> NoT m b
forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> NoT m a -> NoT m b -> NoT m c
<* :: forall a b. NoT m a -> NoT m b -> NoT m a
$c<* :: forall (m :: * -> *) a b.
Applicative m =>
NoT m a -> NoT m b -> NoT m a
*> :: forall a b. NoT m a -> NoT m b -> NoT m b
$c*> :: forall (m :: * -> *) a b.
Applicative m =>
NoT m a -> NoT m b -> NoT m b
liftA2 :: forall a b c. (a -> b -> c) -> NoT m a -> NoT m b -> NoT m c
$cliftA2 :: forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> NoT m a -> NoT m b -> NoT m c
<*> :: forall a b. NoT m (a -> b) -> NoT m a -> NoT m b
$c<*> :: forall (m :: * -> *) a b.
Applicative m =>
NoT m (a -> b) -> NoT m a -> NoT m b
pure :: forall a. a -> NoT m a
$cpure :: forall (m :: * -> *) a. Applicative m => a -> NoT m a
Applicative, forall a. a -> NoT m a
forall a b. NoT m a -> NoT m b -> NoT m b
forall a b. NoT m a -> (a -> NoT m b) -> NoT m b
forall {m :: * -> *}. Monad m => Applicative (NoT m)
forall (m :: * -> *) a. Monad m => a -> NoT m a
forall (m :: * -> *) a b. Monad m => NoT m a -> NoT m b -> NoT m b
forall (m :: * -> *) a b.
Monad m =>
NoT m a -> (a -> NoT m b) -> NoT m b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: forall a. a -> NoT m a
$creturn :: forall (m :: * -> *) a. Monad m => a -> NoT m a
>> :: forall a b. NoT m a -> NoT m b -> NoT m b
$c>> :: forall (m :: * -> *) a b. Monad m => NoT m a -> NoT m b -> NoT m b
>>= :: forall a b. NoT m a -> (a -> NoT m b) -> NoT m b
$c>>= :: forall (m :: * -> *) a b.
Monad m =>
NoT m a -> (a -> NoT m b) -> NoT m b
Monad)
  deriving newtype (forall (m :: * -> *). Monad m => Monad (NoT m)
forall (m :: * -> *) a. Monad m => m a -> NoT m a
forall (t :: (* -> *) -> * -> *).
(forall (m :: * -> *). Monad m => Monad (t m))
-> (forall (m :: * -> *) a. Monad m => m a -> t m a)
-> MonadTrans t
lift :: forall (m :: * -> *) a. Monad m => m a -> NoT m a
$clift :: forall (m :: * -> *) a. Monad m => m a -> NoT m a
MonadTrans, MonadTrans NoT
forall (m :: * -> *) a. Monad m => m (StT NoT a) -> NoT m a
forall (m :: * -> *) a. Monad m => (Run NoT -> m a) -> NoT m a
forall (t :: (* -> *) -> * -> *).
MonadTrans t
-> (forall (m :: * -> *) a. Monad m => (Run t -> m a) -> t m a)
-> (forall (m :: * -> *) a. Monad m => m (StT t a) -> t m a)
-> MonadTransControl t
restoreT :: forall (m :: * -> *) a. Monad m => m (StT NoT a) -> NoT m a
$crestoreT :: forall (m :: * -> *) a. Monad m => m (StT NoT a) -> NoT m a
liftWith :: forall (m :: * -> *) a. Monad m => (Run NoT -> m a) -> NoT m a
$cliftWith :: forall (m :: * -> *) a. Monad m => (Run NoT -> m a) -> NoT m a
MonadTransControl, MonadTransControl NoT
forall (m :: * -> *) a.
Monad m =>
((forall x. NoT m x -> m x) -> m a) -> NoT m a
forall (t :: (* -> *) -> * -> *).
MonadTransControl t
-> (forall (m :: * -> *) a.
    Monad m =>
    ((forall x. t m x -> m x) -> m a) -> t m a)
-> MonadTransControlIdentity t
liftWithIdentity :: forall (m :: * -> *) a.
Monad m =>
((forall x. NoT m x -> m x) -> m a) -> NoT m a
$cliftWithIdentity :: forall (m :: * -> *) a.
Monad m =>
((forall x. NoT m x -> m x) -> m a) -> NoT m a
MonadTransControlIdentity)

{-# WARNING NoT, MkNoT, unNoT "This is an implementation detail of 'TransparentT'." #-}