module Control.Monad.Ology.Specific.ComposeT
    ( ComposeT(..)
    , composeTUnlift
    , composeTWUnlift
    , liftOuterComposeT
    , liftInnerComposeT
    , liftOuterComposeTWithUnlift
    , liftInnerComposeTWithUnlift
    ) where

import Control.Monad.Ology.General
import Control.Monad.Ology.Specific.ComposeInner
import Import

-- | Compose two monad transformers.
type ComposeT :: TransKind -> TransKind -> TransKind
newtype ComposeT (outerT :: TransKind) (innerT :: TransKind) (m :: Type -> Type) (a :: Type) = MkComposeT
    { forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
ComposeT outerT innerT m a -> outerT (innerT m) a
unComposeT :: outerT (innerT m) a
    } deriving (forall a b.
a -> ComposeT outerT innerT m b -> ComposeT outerT innerT m a
forall a b.
(a -> b)
-> ComposeT outerT innerT m a -> ComposeT outerT innerT m b
forall (f :: Type -> Type).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a b.
Functor (outerT (innerT m)) =>
a -> ComposeT outerT innerT m b -> ComposeT outerT innerT m a
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a b.
Functor (outerT (innerT m)) =>
(a -> b)
-> ComposeT outerT innerT m a -> ComposeT outerT innerT m b
<$ :: forall a b.
a -> ComposeT outerT innerT m b -> ComposeT outerT innerT m a
$c<$ :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a b.
Functor (outerT (innerT m)) =>
a -> ComposeT outerT innerT m b -> ComposeT outerT innerT m a
fmap :: forall a b.
(a -> b)
-> ComposeT outerT innerT m a -> ComposeT outerT innerT m b
$cfmap :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a b.
Functor (outerT (innerT m)) =>
(a -> b)
-> ComposeT outerT innerT m a -> ComposeT outerT innerT m b
Functor, forall a. a -> ComposeT outerT innerT m a
forall a b.
ComposeT outerT innerT m a
-> ComposeT outerT innerT m b -> ComposeT outerT innerT m a
forall a b.
ComposeT outerT innerT m a
-> ComposeT outerT innerT m b -> ComposeT outerT innerT m b
forall a b.
ComposeT outerT innerT m (a -> b)
-> ComposeT outerT innerT m a -> ComposeT outerT innerT m b
forall a b c.
(a -> b -> c)
-> ComposeT outerT innerT m a
-> ComposeT outerT innerT m b
-> ComposeT outerT innerT m c
forall (f :: Type -> Type).
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 {outerT :: TransKind} {innerT :: TransKind}
       {m :: Type -> Type}.
Applicative (outerT (innerT m)) =>
Functor (ComposeT outerT innerT m)
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
Applicative (outerT (innerT m)) =>
a -> ComposeT outerT innerT m a
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a b.
Applicative (outerT (innerT m)) =>
ComposeT outerT innerT m a
-> ComposeT outerT innerT m b -> ComposeT outerT innerT m a
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a b.
Applicative (outerT (innerT m)) =>
ComposeT outerT innerT m a
-> ComposeT outerT innerT m b -> ComposeT outerT innerT m b
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a b.
Applicative (outerT (innerT m)) =>
ComposeT outerT innerT m (a -> b)
-> ComposeT outerT innerT m a -> ComposeT outerT innerT m b
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a b c.
Applicative (outerT (innerT m)) =>
(a -> b -> c)
-> ComposeT outerT innerT m a
-> ComposeT outerT innerT m b
-> ComposeT outerT innerT m c
<* :: forall a b.
ComposeT outerT innerT m a
-> ComposeT outerT innerT m b -> ComposeT outerT innerT m a
$c<* :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a b.
Applicative (outerT (innerT m)) =>
ComposeT outerT innerT m a
-> ComposeT outerT innerT m b -> ComposeT outerT innerT m a
*> :: forall a b.
ComposeT outerT innerT m a
-> ComposeT outerT innerT m b -> ComposeT outerT innerT m b
$c*> :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a b.
Applicative (outerT (innerT m)) =>
ComposeT outerT innerT m a
-> ComposeT outerT innerT m b -> ComposeT outerT innerT m b
liftA2 :: forall a b c.
(a -> b -> c)
-> ComposeT outerT innerT m a
-> ComposeT outerT innerT m b
-> ComposeT outerT innerT m c
$cliftA2 :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a b c.
Applicative (outerT (innerT m)) =>
(a -> b -> c)
-> ComposeT outerT innerT m a
-> ComposeT outerT innerT m b
-> ComposeT outerT innerT m c
<*> :: forall a b.
ComposeT outerT innerT m (a -> b)
-> ComposeT outerT innerT m a -> ComposeT outerT innerT m b
$c<*> :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a b.
Applicative (outerT (innerT m)) =>
ComposeT outerT innerT m (a -> b)
-> ComposeT outerT innerT m a -> ComposeT outerT innerT m b
pure :: forall a. a -> ComposeT outerT innerT m a
$cpure :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
Applicative (outerT (innerT m)) =>
a -> ComposeT outerT innerT m a
Applicative, forall a. ComposeT outerT innerT m a
forall a.
ComposeT outerT innerT m a -> ComposeT outerT innerT m [a]
forall a.
ComposeT outerT innerT m a
-> ComposeT outerT innerT m a -> ComposeT outerT innerT m a
forall (f :: Type -> Type).
Applicative f
-> (forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
forall {outerT :: TransKind} {innerT :: TransKind}
       {m :: Type -> Type}.
Alternative (outerT (innerT m)) =>
Applicative (ComposeT outerT innerT m)
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
Alternative (outerT (innerT m)) =>
ComposeT outerT innerT m a
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
Alternative (outerT (innerT m)) =>
ComposeT outerT innerT m a -> ComposeT outerT innerT m [a]
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
Alternative (outerT (innerT m)) =>
ComposeT outerT innerT m a
-> ComposeT outerT innerT m a -> ComposeT outerT innerT m a
many :: forall a.
ComposeT outerT innerT m a -> ComposeT outerT innerT m [a]
$cmany :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
Alternative (outerT (innerT m)) =>
ComposeT outerT innerT m a -> ComposeT outerT innerT m [a]
some :: forall a.
ComposeT outerT innerT m a -> ComposeT outerT innerT m [a]
$csome :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
Alternative (outerT (innerT m)) =>
ComposeT outerT innerT m a -> ComposeT outerT innerT m [a]
<|> :: forall a.
ComposeT outerT innerT m a
-> ComposeT outerT innerT m a -> ComposeT outerT innerT m a
$c<|> :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
Alternative (outerT (innerT m)) =>
ComposeT outerT innerT m a
-> ComposeT outerT innerT m a -> ComposeT outerT innerT m a
empty :: forall a. ComposeT outerT innerT m a
$cempty :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
Alternative (outerT (innerT m)) =>
ComposeT outerT innerT m a
Alternative, forall a. a -> ComposeT outerT innerT m a
forall a b.
ComposeT outerT innerT m a
-> ComposeT outerT innerT m b -> ComposeT outerT innerT m b
forall a b.
ComposeT outerT innerT m a
-> (a -> ComposeT outerT innerT m b) -> ComposeT outerT innerT m b
forall (m :: Type -> Type).
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
forall {outerT :: TransKind} {innerT :: TransKind}
       {m :: Type -> Type}.
Monad (outerT (innerT m)) =>
Applicative (ComposeT outerT innerT m)
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
Monad (outerT (innerT m)) =>
a -> ComposeT outerT innerT m a
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a b.
Monad (outerT (innerT m)) =>
ComposeT outerT innerT m a
-> ComposeT outerT innerT m b -> ComposeT outerT innerT m b
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a b.
Monad (outerT (innerT m)) =>
ComposeT outerT innerT m a
-> (a -> ComposeT outerT innerT m b) -> ComposeT outerT innerT m b
return :: forall a. a -> ComposeT outerT innerT m a
$creturn :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
Monad (outerT (innerT m)) =>
a -> ComposeT outerT innerT m a
>> :: forall a b.
ComposeT outerT innerT m a
-> ComposeT outerT innerT m b -> ComposeT outerT innerT m b
$c>> :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a b.
Monad (outerT (innerT m)) =>
ComposeT outerT innerT m a
-> ComposeT outerT innerT m b -> ComposeT outerT innerT m b
>>= :: forall a b.
ComposeT outerT innerT m a
-> (a -> ComposeT outerT innerT m b) -> ComposeT outerT innerT m b
$c>>= :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a b.
Monad (outerT (innerT m)) =>
ComposeT outerT innerT m a
-> (a -> ComposeT outerT innerT m b) -> ComposeT outerT innerT m b
Monad, forall a. String -> ComposeT outerT innerT m a
forall (m :: Type -> Type).
Monad m -> (forall a. String -> m a) -> MonadFail m
forall {outerT :: TransKind} {innerT :: TransKind}
       {m :: Type -> Type}.
MonadFail (outerT (innerT m)) =>
Monad (ComposeT outerT innerT m)
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
MonadFail (outerT (innerT m)) =>
String -> ComposeT outerT innerT m a
fail :: forall a. String -> ComposeT outerT innerT m a
$cfail :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
MonadFail (outerT (innerT m)) =>
String -> ComposeT outerT innerT m a
MonadFail, forall a. IO a -> ComposeT outerT innerT m a
forall (m :: Type -> Type).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
forall {outerT :: TransKind} {innerT :: TransKind}
       {m :: Type -> Type}.
MonadIO (outerT (innerT m)) =>
Monad (ComposeT outerT innerT m)
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
MonadIO (outerT (innerT m)) =>
IO a -> ComposeT outerT innerT m a
liftIO :: forall a. IO a -> ComposeT outerT innerT m a
$cliftIO :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
MonadIO (outerT (innerT m)) =>
IO a -> ComposeT outerT innerT m a
MonadIO, forall a.
(a -> ComposeT outerT innerT m a) -> ComposeT outerT innerT m a
forall (m :: Type -> Type).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
forall {outerT :: TransKind} {innerT :: TransKind}
       {m :: Type -> Type}.
MonadFix (outerT (innerT m)) =>
Monad (ComposeT outerT innerT m)
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
MonadFix (outerT (innerT m)) =>
(a -> ComposeT outerT innerT m a) -> ComposeT outerT innerT m a
mfix :: forall a.
(a -> ComposeT outerT innerT m a) -> ComposeT outerT innerT m a
$cmfix :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
MonadFix (outerT (innerT m)) =>
(a -> ComposeT outerT innerT m a) -> ComposeT outerT innerT m a
MonadFix, forall a. ComposeT outerT innerT m a
forall a.
ComposeT outerT innerT m a
-> ComposeT outerT innerT m a -> ComposeT outerT innerT m a
forall (m :: Type -> Type).
Alternative m
-> Monad m
-> (forall a. m a)
-> (forall a. m a -> m a -> m a)
-> MonadPlus m
forall {outerT :: TransKind} {innerT :: TransKind}
       {m :: Type -> Type}.
MonadPlus (outerT (innerT m)) =>
Monad (ComposeT outerT innerT m)
forall {outerT :: TransKind} {innerT :: TransKind}
       {m :: Type -> Type}.
MonadPlus (outerT (innerT m)) =>
Alternative (ComposeT outerT innerT m)
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
MonadPlus (outerT (innerT m)) =>
ComposeT outerT innerT m a
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
MonadPlus (outerT (innerT m)) =>
ComposeT outerT innerT m a
-> ComposeT outerT innerT m a -> ComposeT outerT innerT m a
mplus :: forall a.
ComposeT outerT innerT m a
-> ComposeT outerT innerT m a -> ComposeT outerT innerT m a
$cmplus :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
MonadPlus (outerT (innerT m)) =>
ComposeT outerT innerT m a
-> ComposeT outerT innerT m a -> ComposeT outerT innerT m a
mzero :: forall a. ComposeT outerT innerT m a
$cmzero :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
MonadPlus (outerT (innerT m)) =>
ComposeT outerT innerT m a
MonadPlus)

liftOuterComposeT ::
       forall outerT innerT m a. (MonadTransTunnel outerT, MonadTrans innerT, TransConstraint Monad innerT, Monad m)
    => outerT m a
    -> ComposeT outerT innerT m a
liftOuterComposeT :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
(MonadTransTunnel outerT, MonadTrans innerT,
 TransConstraint Monad innerT, Monad m) =>
outerT m a -> ComposeT outerT innerT m a
liftOuterComposeT outerT m a
oma =
    case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @Monad @innerT @m of
        Dict (Monad (innerT m))
Dict -> forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
outerT (innerT m) a -> ComposeT outerT innerT m a
MkComposeT forall a b. (a -> b) -> a -> b
$ forall (t :: TransKind) (m1 :: Type -> Type) (m2 :: Type -> Type).
(MonadTransHoist t, Monad m1, Monad m2) =>
(m1 --> m2) -> t m1 --> t m2
hoist forall (t :: TransKind) (m :: Type -> Type) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift outerT m a
oma

liftInnerComposeT ::
       forall outerT innerT m a. (MonadTrans outerT, TransConstraint Monad innerT, Monad m)
    => innerT m a
    -> ComposeT outerT innerT m a
liftInnerComposeT :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
(MonadTrans outerT, TransConstraint Monad innerT, Monad m) =>
innerT m a -> ComposeT outerT innerT m a
liftInnerComposeT innerT m a
ima =
    case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @Monad @innerT @m of
        Dict (Monad (innerT m))
Dict -> forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
outerT (innerT m) a -> ComposeT outerT innerT m a
MkComposeT forall a b. (a -> b) -> a -> b
$ forall (t :: TransKind) (m :: Type -> Type) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift innerT m a
ima

liftOuterComposeTWithUnlift ::
       forall outerT innerT m r. (MonadTransTunnel outerT, MonadTransUnlift innerT, MonadTunnelIOInner m)
    => ((forall a. ComposeT outerT innerT m a -> outerT m a) -> outerT m r)
    -> ComposeT outerT innerT m r
liftOuterComposeTWithUnlift :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) r.
(MonadTransTunnel outerT, MonadTransUnlift innerT,
 MonadTunnelIOInner m) =>
((forall a. ComposeT outerT innerT m a -> outerT m a)
 -> outerT m r)
-> ComposeT outerT innerT m r
liftOuterComposeTWithUnlift (forall a. ComposeT outerT innerT m a -> outerT m a) -> outerT m r
call =
    case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @MonadIO @innerT @m of
        Dict (MonadIO (innerT m))
Dict ->
            forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
outerT (innerT m) a -> ComposeT outerT innerT m a
MkComposeT forall a b. (a -> b) -> a -> b
$
            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 =>
outerT m1 a -> m1 (Tunnel outerT a)
tun -> 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 innerT
unlift -> forall (m1 :: Type -> Type) a.
Monad m1 =>
outerT m1 a -> m1 (Tunnel outerT a)
tun forall a b. (a -> b) -> a -> b
$ (forall a. ComposeT outerT innerT m a -> outerT m a) -> outerT m r
call forall a b. (a -> b) -> a -> b
$ \(MkComposeT outerT (innerT m) a
ttma) -> forall (t :: TransKind) (m1 :: Type -> Type) (m2 :: Type -> Type).
(MonadTransHoist t, Monad m1, Monad m2) =>
(m1 --> m2) -> t m1 --> t m2
hoist Unlift MonadTunnelIOInner innerT
unlift outerT (innerT m) a
ttma

liftInnerComposeTWithUnlift ::
       forall outerT innerT m r. (MonadTransUnlift outerT, MonadTransUnlift innerT, MonadTunnelIOInner m)
    => ((forall a. ComposeT outerT innerT m a -> innerT m a) -> innerT m r)
    -> ComposeT outerT innerT m r
liftInnerComposeTWithUnlift :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) r.
(MonadTransUnlift outerT, MonadTransUnlift innerT,
 MonadTunnelIOInner m) =>
((forall a. ComposeT outerT innerT m a -> innerT m a)
 -> innerT m r)
-> ComposeT outerT innerT m r
liftInnerComposeTWithUnlift (forall a. ComposeT outerT innerT m a -> innerT m a) -> innerT m r
call =
    case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @MonadTunnelIOInner @innerT @m of
        Dict (MonadTunnelIOInner (innerT m))
Dict -> forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
outerT (innerT m) a -> ComposeT outerT innerT m a
MkComposeT forall a b. (a -> b) -> a -> b
$ 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 outerT
unlift -> (forall a. ComposeT outerT innerT m a -> innerT m a) -> innerT m r
call forall a b. (a -> b) -> a -> b
$ \(MkComposeT outerT (innerT m) a
ttma) -> Unlift MonadTunnelIOInner outerT
unlift outerT (innerT m) a
ttma

composeTUnlift ::
       forall c outerT innerT. (MonadTransUnlift innerT, TransConstraint c innerT)
    => Unlift c outerT
    -> Unlift c innerT
    -> Unlift c (ComposeT outerT innerT)
composeTUnlift :: forall (c :: (Type -> Type) -> Constraint) (outerT :: TransKind)
       (innerT :: TransKind).
(MonadTransUnlift innerT, TransConstraint c innerT) =>
Unlift c outerT
-> Unlift c innerT -> Unlift c (ComposeT outerT innerT)
composeTUnlift Unlift c outerT
ua Unlift c innerT
ub (MkComposeT outerT (innerT m) a
tatbma) = Unlift c innerT
ub forall a b. (a -> b) -> a -> b
$ forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type) a.
(TransConstraint c t, c m) =>
(c (t m) => t m a) -> t m a
withTransConstraintTM @c forall a b. (a -> b) -> a -> b
$ Unlift c outerT
ua outerT (innerT m) a
tatbma

composeTWUnlift ::
       forall c outerT innerT. (MonadTransUnlift innerT, TransConstraint c innerT)
    => WUnlift c outerT
    -> WUnlift c innerT
    -> WUnlift c (ComposeT outerT innerT)
composeTWUnlift :: forall (c :: (Type -> Type) -> Constraint) (outerT :: TransKind)
       (innerT :: TransKind).
(MonadTransUnlift innerT, TransConstraint c innerT) =>
WUnlift c outerT
-> WUnlift c innerT -> WUnlift c (ComposeT outerT innerT)
composeTWUnlift (MkWUnlift Unlift c outerT
ua) (MkWUnlift Unlift c innerT
ub) = forall (c :: (Type -> Type) -> Constraint) (t :: TransKind).
Unlift c t -> WUnlift c t
MkWUnlift forall a b. (a -> b) -> a -> b
$ forall (c :: (Type -> Type) -> Constraint) (outerT :: TransKind)
       (innerT :: TransKind).
(MonadTransUnlift innerT, TransConstraint c innerT) =>
Unlift c outerT
-> Unlift c innerT -> Unlift c (ComposeT outerT innerT)
composeTUnlift @c Unlift c outerT
ua Unlift c innerT
ub

instance (MonadTrans outerT, MonadTrans innerT, TransConstraint Monad innerT) => MonadTrans (ComposeT outerT innerT) where
    lift :: forall (m :: Type -> Type) a.
Monad m =>
m a -> ComposeT outerT innerT m a
lift (m a
ma :: m a) =
        case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @Monad @innerT @m of
            Dict (Monad (innerT m))
Dict -> forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
outerT (innerT m) a -> ComposeT outerT innerT m a
MkComposeT forall a b. (a -> b) -> a -> b
$ 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 (t :: TransKind) (m :: Type -> Type) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m a
ma

instance (TransConstraint Functor outerT, TransConstraint Functor innerT) =>
             TransConstraint Functor (ComposeT outerT innerT) where
    hasTransConstraint ::
           forall m. Functor m
        => Dict (Functor (ComposeT outerT innerT m))
    hasTransConstraint :: forall (m :: Type -> Type).
Functor m =>
Dict (Functor (ComposeT outerT innerT m))
hasTransConstraint =
        case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @Functor @innerT @m of
            Dict (Functor (innerT m))
Dict ->
                case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @Functor @outerT @(innerT m) of
                    Dict (Functor (outerT (innerT m)))
Dict -> forall (a :: Constraint). a => Dict a
Dict

instance (TransConstraint Applicative outerT, TransConstraint Applicative innerT) =>
             TransConstraint Applicative (ComposeT outerT innerT) where
    hasTransConstraint ::
           forall m. Applicative m
        => Dict (Applicative (ComposeT outerT innerT m))
    hasTransConstraint :: forall (m :: Type -> Type).
Applicative m =>
Dict (Applicative (ComposeT outerT innerT m))
hasTransConstraint =
        case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @Applicative @innerT @m of
            Dict (Applicative (innerT m))
Dict ->
                case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @Applicative @outerT @(innerT m) of
                    Dict (Applicative (outerT (innerT m)))
Dict -> forall (a :: Constraint). a => Dict a
Dict

instance (TransConstraint Monad outerT, TransConstraint Monad innerT) => TransConstraint Monad (ComposeT outerT innerT) where
    hasTransConstraint ::
           forall m. Monad m
        => Dict (Monad (ComposeT outerT innerT m))
    hasTransConstraint :: forall (m :: Type -> Type).
Monad m =>
Dict (Monad (ComposeT outerT innerT m))
hasTransConstraint =
        case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @Monad @innerT @m of
            Dict (Monad (innerT m))
Dict ->
                case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @Monad @outerT @(innerT m) of
                    Dict (Monad (outerT (innerT m)))
Dict -> forall (a :: Constraint). a => Dict a
Dict

instance (TransConstraint MonadIO outerT, TransConstraint Monad innerT, TransConstraint MonadIO innerT) =>
             TransConstraint MonadIO (ComposeT outerT innerT) where
    hasTransConstraint ::
           forall m. MonadIO m
        => Dict (MonadIO (ComposeT outerT innerT m))
    hasTransConstraint :: forall (m :: Type -> Type).
MonadIO m =>
Dict (MonadIO (ComposeT outerT innerT m))
hasTransConstraint =
        case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @MonadIO @innerT @m of
            Dict (MonadIO (innerT m))
Dict ->
                case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @MonadIO @outerT @(innerT m) of
                    Dict (MonadIO (outerT (innerT m)))
Dict -> forall (a :: Constraint). a => Dict a
Dict

instance (TransConstraint MonadFail outerT, TransConstraint Monad innerT, TransConstraint MonadFail innerT) =>
             TransConstraint MonadFail (ComposeT outerT innerT) where
    hasTransConstraint ::
           forall m. MonadFail m
        => Dict (MonadFail (ComposeT outerT innerT m))
    hasTransConstraint :: forall (m :: Type -> Type).
MonadFail m =>
Dict (MonadFail (ComposeT outerT innerT m))
hasTransConstraint =
        case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @MonadFail @innerT @m of
            Dict (MonadFail (innerT m))
Dict ->
                case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @MonadFail @outerT @(innerT m) of
                    Dict (MonadFail (outerT (innerT m)))
Dict -> forall (a :: Constraint). a => Dict a
Dict

instance (TransConstraint MonadFix outerT, TransConstraint Monad innerT, TransConstraint MonadFix innerT) =>
             TransConstraint MonadFix (ComposeT outerT innerT) where
    hasTransConstraint ::
           forall m. MonadFix m
        => Dict (MonadFix (ComposeT outerT innerT m))
    hasTransConstraint :: forall (m :: Type -> Type).
MonadFix m =>
Dict (MonadFix (ComposeT outerT innerT m))
hasTransConstraint =
        case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @MonadFix @innerT @m of
            Dict (MonadFix (innerT m))
Dict ->
                case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @MonadFix @outerT @(innerT m) of
                    Dict (MonadFix (outerT (innerT m)))
Dict -> forall (a :: Constraint). a => Dict a
Dict

instance (TransConstraint MonadPlus outerT, TransConstraint Monad innerT, TransConstraint MonadPlus innerT) =>
             TransConstraint MonadPlus (ComposeT outerT innerT) where
    hasTransConstraint ::
           forall m. MonadPlus m
        => Dict (MonadPlus (ComposeT outerT innerT m))
    hasTransConstraint :: forall (m :: Type -> Type).
MonadPlus m =>
Dict (MonadPlus (ComposeT outerT innerT m))
hasTransConstraint =
        case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @MonadPlus @innerT @m of
            Dict (MonadPlus (innerT m))
Dict ->
                case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @MonadPlus @outerT @(innerT m) of
                    Dict (MonadPlus (outerT (innerT m)))
Dict -> forall (a :: Constraint). a => Dict a
Dict

instance (MonadTransHoist outerT, MonadTransHoist innerT) => MonadTransHoist (ComposeT outerT innerT) where
    hoist ::
           forall m1 m2. (Monad m1, Monad m2)
        => (m1 --> m2)
        -> ComposeT outerT innerT m1 --> ComposeT outerT innerT m2
    hoist :: forall (m1 :: Type -> Type) (m2 :: Type -> Type).
(Monad m1, Monad m2) =>
(m1 --> m2)
-> ComposeT outerT innerT m1 --> ComposeT outerT innerT m2
hoist m1 --> m2
f (MkComposeT outerT (innerT m1) a
ma) =
        case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @Monad @innerT @m1 of
            Dict (Monad (innerT m1))
Dict ->
                case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @Monad @innerT @m2 of
                    Dict (Monad (innerT m2))
Dict -> forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
outerT (innerT m) a -> ComposeT outerT innerT m a
MkComposeT forall a b. (a -> b) -> a -> b
$ forall (t :: TransKind) (m1 :: Type -> Type) (m2 :: Type -> Type).
(MonadTransHoist t, Monad m1, Monad m2) =>
(m1 --> m2) -> t m1 --> t m2
hoist (forall (t :: TransKind) (m1 :: Type -> Type) (m2 :: Type -> Type).
(MonadTransHoist t, Monad m1, Monad m2) =>
(m1 --> m2) -> t m1 --> t m2
hoist m1 --> m2
f) outerT (innerT m1) a
ma

instance (MonadTransTunnel outerT, MonadTransTunnel innerT) => MonadTransTunnel (ComposeT outerT innerT) where
    type Tunnel (ComposeT outerT innerT) = ComposeInner (Tunnel outerT) (Tunnel innerT)
    tunnel ::
           forall m2 r. Monad m2
        => ((forall m1 a. Monad m1 => ComposeT outerT innerT m1 a -> m1 (ComposeInner (Tunnel outerT) (Tunnel innerT) a)) -> m2 (ComposeInner (Tunnel outerT) (Tunnel innerT) r))
        -> ComposeT outerT innerT m2 r
    tunnel :: forall (m2 :: Type -> Type) r.
Monad m2 =>
((forall (m1 :: Type -> Type) a.
  Monad m1 =>
  ComposeT outerT innerT m1 a
  -> m1 (ComposeInner (Tunnel outerT) (Tunnel innerT) a))
 -> m2 (ComposeInner (Tunnel outerT) (Tunnel innerT) r))
-> ComposeT outerT innerT m2 r
tunnel (forall (m1 :: Type -> Type) a.
 Monad m1 =>
 ComposeT outerT innerT m1 a
 -> m1 (ComposeInner (Tunnel outerT) (Tunnel innerT) a))
-> m2 (ComposeInner (Tunnel outerT) (Tunnel innerT) r)
call =
        case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @Monad @innerT @m2 of
            Dict (Monad (innerT m2))
Dict ->
                forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
outerT (innerT m) a -> ComposeT outerT innerT m a
MkComposeT forall a b. (a -> b) -> a -> b
$
                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 =>
outerT m1 a -> m1 (Tunnel outerT a)
unlift1 ->
                    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 =>
innerT m1 a -> m1 (Tunnel innerT a)
unlift2 ->
                        forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap forall (inner :: Type -> Type) (outer :: Type -> Type) a.
ComposeInner inner outer a -> outer (inner a)
unComposeInner forall a b. (a -> b) -> a -> b
$
                        (forall (m1 :: Type -> Type) a.
 Monad m1 =>
 ComposeT outerT innerT m1 a
 -> m1 (ComposeInner (Tunnel outerT) (Tunnel innerT) a))
-> m2 (ComposeInner (Tunnel outerT) (Tunnel innerT) r)
call forall a b. (a -> b) -> a -> b
$ \(MkComposeT outerT (innerT m1) a
ff :: _ m1 _) ->
                            case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @Monad @innerT @m1 of
                                Dict (Monad (innerT m1))
Dict -> forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap forall (inner :: Type -> Type) (outer :: Type -> Type) a.
outer (inner a) -> ComposeInner inner outer a
MkComposeInner forall a b. (a -> b) -> a -> b
$ forall (m1 :: Type -> Type) a.
Monad m1 =>
innerT m1 a -> m1 (Tunnel innerT a)
unlift2 forall a b. (a -> b) -> a -> b
$ forall (m1 :: Type -> Type) a.
Monad m1 =>
outerT m1 a -> m1 (Tunnel outerT a)
unlift1 forall a b. (a -> b) -> a -> b
$ outerT (innerT m1) a
ff

instance (MonadTransCoerce outerT, MonadTransCoerce innerT, TransConstraint Monad innerT) =>
             MonadTransCoerce (ComposeT outerT innerT) where
    transCoerce ::
           forall m1 m2. Coercible m1 m2
        => Dict (Coercible (ComposeT outerT innerT m1) (ComposeT outerT innerT m2))
    transCoerce :: forall (m1 :: Type -> Type) (m2 :: Type -> Type).
Coercible m1 m2 =>
Dict
  (Coercible (ComposeT outerT innerT m1) (ComposeT outerT innerT m2))
transCoerce =
        case forall (t :: TransKind) (m1 :: Type -> Type) (m2 :: Type -> Type).
(MonadTransCoerce t, Coercible m1 m2) =>
Dict (Coercible (t m1) (t m2))
transCoerce @innerT @m1 @m2 of
            Dict (Coercible (innerT m1) (innerT m2))
Dict ->
                case forall (t :: TransKind) (m1 :: Type -> Type) (m2 :: Type -> Type).
(MonadTransCoerce t, Coercible m1 m2) =>
Dict (Coercible (t m1) (t m2))
transCoerce @outerT @(innerT m1) @(innerT m2) of
                    Dict (Coercible (outerT (innerT m1)) (outerT (innerT m2)))
Dict -> forall (a :: Constraint). a => Dict a
Dict

instance (MonadTransUnlift outerT, MonadTransUnlift innerT) => MonadTransUnlift (ComposeT outerT innerT) where
    liftWithUnlift ::
           forall m r. MonadIO m
        => (Unlift MonadTunnelIOInner (ComposeT outerT innerT) -> m r)
        -> ComposeT outerT innerT m r
    liftWithUnlift :: forall (m :: Type -> Type) r.
MonadIO m =>
(Unlift MonadTunnelIOInner (ComposeT outerT innerT) -> m r)
-> ComposeT outerT innerT m r
liftWithUnlift Unlift MonadTunnelIOInner (ComposeT outerT innerT) -> m r
call =
        case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @MonadIO @innerT @m of
            Dict (MonadIO (innerT m))
Dict ->
                forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
outerT (innerT m) a -> ComposeT outerT innerT m a
MkComposeT forall a b. (a -> b) -> a -> b
$
                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 outerT
unlift1 ->
                    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 innerT
unlift2 ->
                        Unlift MonadTunnelIOInner (ComposeT outerT innerT) -> m r
call forall a b. (a -> b) -> a -> b
$ \(MkComposeT outerT (innerT m) a
t1t2ma) ->
                            Unlift MonadTunnelIOInner innerT
unlift2 forall a b. (a -> b) -> a -> b
$ forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type) a.
(TransConstraint c t, c m) =>
(c (t m) => t m a) -> t m a
withTransConstraintTM @MonadTunnelIOInner forall a b. (a -> b) -> a -> b
$ Unlift MonadTunnelIOInner outerT
unlift1 outerT (innerT m) a
t1t2ma
    getDiscardingUnlift ::
           forall m. Monad m
        => ComposeT outerT innerT m (WUnlift MonadTunnelIOInner (ComposeT outerT innerT))
    getDiscardingUnlift :: forall (m :: Type -> Type).
Monad m =>
ComposeT
  outerT
  innerT
  m
  (WUnlift MonadTunnelIOInner (ComposeT outerT innerT))
getDiscardingUnlift =
        case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @Monad @innerT @m of
            Dict (Monad (innerT m))
Dict ->
                forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
outerT (innerT m) a -> ComposeT outerT innerT m a
MkComposeT forall a b. (a -> b) -> a -> b
$
                forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type) a.
(TransConstraint c t, c m) =>
(c (t m) => t m a) -> t m a
withTransConstraintTM @Monad forall a b. (a -> b) -> a -> b
$ do
                    WUnlift MonadTunnelIOInner outerT
unlift1 <- forall (t :: TransKind) (m :: Type -> Type).
(MonadTransUnlift t, Monad m) =>
t m (WUnlift MonadTunnelIOInner t)
getDiscardingUnlift
                    WUnlift MonadTunnelIOInner innerT
unlift2 <- forall (t :: TransKind) (m :: Type -> Type) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (t :: TransKind) (m :: Type -> Type).
(MonadTransUnlift t, Monad m) =>
t m (WUnlift MonadTunnelIOInner t)
getDiscardingUnlift
                    forall (m :: Type -> Type) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (c :: (Type -> Type) -> Constraint) (outerT :: TransKind)
       (innerT :: TransKind).
(MonadTransUnlift innerT, TransConstraint c innerT) =>
WUnlift c outerT
-> WUnlift c innerT -> WUnlift c (ComposeT outerT innerT)
composeTWUnlift WUnlift MonadTunnelIOInner outerT
unlift1 WUnlift MonadTunnelIOInner innerT
unlift2

instance (MonadTransAskUnlift outerT, MonadTransAskUnlift innerT) => MonadTransAskUnlift (ComposeT outerT innerT) where
    askUnlift ::
           forall m. Monad m
        => ComposeT outerT innerT m (WUnlift Monad (ComposeT outerT innerT))
    askUnlift :: forall (m :: Type -> Type).
Monad m =>
ComposeT outerT innerT m (WUnlift Monad (ComposeT outerT innerT))
askUnlift =
        case forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type).
(TransConstraint c t, c m) =>
Dict (c (t m))
hasTransConstraint @Monad @innerT @m of
            Dict (Monad (innerT m))
Dict ->
                forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
outerT (innerT m) a -> ComposeT outerT innerT m a
MkComposeT forall a b. (a -> b) -> a -> b
$
                forall (c :: (Type -> Type) -> Constraint) (t :: TransKind)
       (m :: Type -> Type) a.
(TransConstraint c t, c m) =>
(c (t m) => t m a) -> t m a
withTransConstraintTM @Monad forall a b. (a -> b) -> a -> b
$ do
                    WUnlift Monad outerT
unlift1 <- forall (t :: TransKind) (m :: Type -> Type).
(MonadTransAskUnlift t, Monad m) =>
t m (WUnlift Monad t)
askUnlift
                    WUnlift Monad innerT
unlift2 <- forall (t :: TransKind) (m :: Type -> Type) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (t :: TransKind) (m :: Type -> Type).
(MonadTransAskUnlift t, Monad m) =>
t m (WUnlift Monad t)
askUnlift
                    forall (m :: Type -> Type) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (c :: (Type -> Type) -> Constraint) (outerT :: TransKind)
       (innerT :: TransKind).
(MonadTransUnlift innerT, TransConstraint c innerT) =>
WUnlift c outerT
-> WUnlift c innerT -> WUnlift c (ComposeT outerT innerT)
composeTWUnlift WUnlift Monad outerT
unlift1 WUnlift Monad innerT
unlift2