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 newtype ((forall a b.
 (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)
-> Functor (ComposeT outerT innerT m)
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
$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
fmap :: forall a b.
(a -> b)
-> ComposeT outerT innerT m a -> ComposeT outerT innerT m b
$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
<$ :: forall a b.
a -> ComposeT outerT innerT m b -> ComposeT outerT innerT m a
Functor, Functor (ComposeT outerT innerT m)
Functor (ComposeT outerT innerT m) =>
(forall a. a -> ComposeT outerT innerT m a)
-> (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 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
    -> ComposeT outerT innerT m b -> ComposeT outerT innerT m a)
-> Applicative (ComposeT outerT innerT m)
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
$cpure :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
Applicative (outerT (innerT m)) =>
a -> ComposeT outerT innerT m a
pure :: forall a. a -> 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 -> b)
-> ComposeT outerT innerT m a -> ComposeT outerT innerT m b
<*> :: forall a b.
ComposeT outerT innerT m (a -> b)
-> ComposeT outerT innerT m a -> ComposeT outerT innerT m b
$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
liftA2 :: forall a b c.
(a -> b -> c)
-> ComposeT outerT innerT m a
-> ComposeT outerT innerT m b
-> ComposeT outerT innerT m c
$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
*> :: 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 a
<* :: forall a b.
ComposeT outerT innerT m a
-> ComposeT outerT innerT m b -> ComposeT outerT innerT m a
Applicative, Applicative (ComposeT outerT innerT m)
Applicative (ComposeT outerT innerT m) =>
(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 a.
    ComposeT outerT innerT m a -> ComposeT outerT innerT m [a])
-> (forall a.
    ComposeT outerT innerT m a -> ComposeT outerT innerT m [a])
-> Alternative (ComposeT outerT innerT m)
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
$cempty :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
Alternative (outerT (innerT m)) =>
ComposeT outerT innerT m a
empty :: forall 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
<|> :: forall a.
ComposeT outerT innerT m 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]
some :: 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]
many :: forall a.
ComposeT outerT innerT m a -> ComposeT outerT innerT m [a]
Alternative, Applicative (ComposeT outerT innerT m)
Applicative (ComposeT outerT innerT m) =>
(forall a b.
 ComposeT outerT innerT m a
 -> (a -> ComposeT outerT innerT m b) -> ComposeT outerT innerT m b)
-> (forall a b.
    ComposeT outerT innerT m a
    -> ComposeT outerT innerT m b -> ComposeT outerT innerT m b)
-> (forall a. a -> ComposeT outerT innerT m a)
-> Monad (ComposeT outerT innerT m)
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
$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
>>= :: 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
-> ComposeT outerT innerT m b -> ComposeT outerT innerT m b
>> :: forall a b.
ComposeT outerT innerT m a
-> ComposeT outerT innerT m b -> ComposeT outerT innerT m b
$creturn :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
Monad (outerT (innerT m)) =>
a -> ComposeT outerT innerT m a
return :: forall a. a -> ComposeT outerT innerT m a
Monad, Monad (ComposeT outerT innerT m)
Monad (ComposeT outerT innerT m) =>
(forall a. String -> ComposeT outerT innerT m a)
-> MonadFail (ComposeT outerT innerT m)
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
$cfail :: 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
MonadFail, Monad (ComposeT outerT innerT m)
Monad (ComposeT outerT innerT m) =>
(forall a. IO a -> ComposeT outerT innerT m a)
-> MonadIO (ComposeT outerT innerT m)
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
$cliftIO :: 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
MonadIO, Monad (ComposeT outerT innerT m)
Monad (ComposeT outerT innerT m) =>
(forall a.
 (a -> ComposeT outerT innerT m a) -> ComposeT outerT innerT m a)
-> MonadFix (ComposeT outerT innerT m)
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
$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
mfix :: forall a.
(a -> ComposeT outerT innerT m a) -> ComposeT outerT innerT m a
MonadFix, Monad (ComposeT outerT innerT m)
Alternative (ComposeT outerT innerT m)
(Alternative (ComposeT outerT innerT m),
 Monad (ComposeT outerT innerT m)) =>
(forall a. ComposeT outerT innerT m a)
-> (forall a.
    ComposeT outerT innerT m a
    -> ComposeT outerT innerT m a -> ComposeT outerT innerT m a)
-> MonadPlus (ComposeT outerT innerT m)
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
$cmzero :: forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
MonadPlus (outerT (innerT m)) =>
ComposeT outerT innerT m a
mzero :: forall 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
mplus :: forall a.
ComposeT outerT innerT m a
-> ComposeT outerT innerT m a -> 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 -> outerT (innerT m) a -> ComposeT outerT innerT m a
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
outerT (innerT m) a -> ComposeT outerT innerT m a
MkComposeT (outerT (innerT m) a -> ComposeT outerT innerT m a)
-> outerT (innerT m) a -> ComposeT outerT innerT m a
forall a b. (a -> b) -> a -> b
$ (m --> innerT m) -> outerT m --> outerT (innerT m)
forall (m1 :: Type -> Type) (m2 :: Type -> Type).
(Monad m1, Monad m2) =>
(m1 --> m2) -> outerT m1 --> outerT m2
forall (t :: TransKind) (m1 :: Type -> Type) (m2 :: Type -> Type).
(MonadTransHoist t, Monad m1, Monad m2) =>
(m1 --> m2) -> t m1 --> t m2
hoist m a -> innerT m a
m --> innerT m
forall (m :: Type -> Type) a. Monad m => m a -> innerT m a
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 -> outerT (innerT m) a -> ComposeT outerT innerT m a
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
outerT (innerT m) a -> ComposeT outerT innerT m a
MkComposeT (outerT (innerT m) a -> ComposeT outerT innerT m a)
-> outerT (innerT m) a -> ComposeT outerT innerT m a
forall a b. (a -> b) -> a -> b
$ innerT m a -> outerT (innerT m) a
forall (m :: Type -> Type) a. Monad m => m a -> outerT m a
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, MonadTunnelIO 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,
 MonadTunnelIO 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 ->
            outerT (innerT m) r -> ComposeT outerT innerT m r
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
outerT (innerT m) a -> ComposeT outerT innerT m a
MkComposeT (outerT (innerT m) r -> ComposeT outerT innerT m r)
-> outerT (innerT m) r -> ComposeT outerT innerT m r
forall a b. (a -> b) -> a -> b
$
            ((forall (m1 :: Type -> Type) a.
  Monad m1 =>
  outerT m1 a -> m1 (Tunnel outerT a))
 -> innerT m (Tunnel outerT r))
-> outerT (innerT m) r
forall (m :: Type -> Type) r.
Monad m =>
((forall (m1 :: Type -> Type) a.
  Monad m1 =>
  outerT m1 a -> m1 (Tunnel outerT a))
 -> m (Tunnel outerT r))
-> outerT 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 =>
   outerT m1 a -> m1 (Tunnel outerT a))
  -> innerT m (Tunnel outerT r))
 -> outerT (innerT m) r)
-> ((forall (m1 :: Type -> Type) a.
     Monad m1 =>
     outerT m1 a -> m1 (Tunnel outerT a))
    -> innerT m (Tunnel outerT r))
-> outerT (innerT m) r
forall a b. (a -> b) -> a -> b
$ \forall (m1 :: Type -> Type) a.
Monad m1 =>
outerT m1 a -> m1 (Tunnel outerT a)
tun -> (Unlift MonadTunnelIO innerT -> m (Tunnel outerT r))
-> innerT m (Tunnel outerT r)
forall (m :: Type -> Type) r.
MonadIO m =>
(Unlift MonadTunnelIO innerT -> m r) -> innerT m r
forall (t :: TransKind) (m :: Type -> Type) r.
(MonadTransUnlift t, MonadIO m) =>
(Unlift MonadTunnelIO t -> m r) -> t m r
liftWithUnlift ((Unlift MonadTunnelIO innerT -> m (Tunnel outerT r))
 -> innerT m (Tunnel outerT r))
-> (Unlift MonadTunnelIO innerT -> m (Tunnel outerT r))
-> innerT m (Tunnel outerT r)
forall a b. (a -> b) -> a -> b
$ \Unlift MonadTunnelIO innerT
unlift -> outerT m r -> m (Tunnel outerT r)
forall (m1 :: Type -> Type) a.
Monad m1 =>
outerT m1 a -> m1 (Tunnel outerT a)
tun (outerT m r -> m (Tunnel outerT r))
-> outerT m r -> m (Tunnel outerT r)
forall a b. (a -> b) -> a -> b
$ (forall a. ComposeT outerT innerT m a -> outerT m a) -> outerT m r
call ((forall a. ComposeT outerT innerT m a -> outerT m a)
 -> outerT m r)
-> (forall a. ComposeT outerT innerT m a -> outerT m a)
-> outerT m r
forall a b. (a -> b) -> a -> b
$ \(MkComposeT outerT (innerT m) a
ttma) -> (innerT m --> m) -> outerT (innerT m) --> outerT m
forall (m1 :: Type -> Type) (m2 :: Type -> Type).
(Monad m1, Monad m2) =>
(m1 --> m2) -> outerT m1 --> outerT m2
forall (t :: TransKind) (m1 :: Type -> Type) (m2 :: Type -> Type).
(MonadTransHoist t, Monad m1, Monad m2) =>
(m1 --> m2) -> t m1 --> t m2
hoist innerT m a -> m a
innerT m --> m
Unlift MonadTunnelIO innerT
unlift outerT (innerT m) a
ttma

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

composeTUnlift ::
       forall c outerT 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).
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) = innerT m a -> m a
innerT m --> m
Unlift c innerT
ub (innerT m a -> m a) -> innerT m a -> m a
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 ((c (innerT m) => innerT m a) -> innerT m a)
-> (c (innerT m) => innerT m a) -> innerT m a
forall a b. (a -> b) -> a -> b
$ outerT (innerT m) a -> innerT m a
outerT (innerT m) --> innerT m
Unlift c outerT
ua outerT (innerT m) a
tatbma

composeTWUnlift ::
       forall c outerT 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).
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) = Unlift c (ComposeT outerT innerT)
-> WUnlift c (ComposeT outerT innerT)
forall (c :: (Type -> Type) -> Constraint) (t :: TransKind).
Unlift c t -> WUnlift c t
MkWUnlift (Unlift c (ComposeT outerT innerT)
 -> WUnlift c (ComposeT outerT innerT))
-> Unlift c (ComposeT outerT innerT)
-> WUnlift c (ComposeT outerT innerT)
forall a b. (a -> b) -> a -> b
$ forall (c :: (Type -> Type) -> Constraint) (outerT :: TransKind)
       (innerT :: TransKind).
TransConstraint c innerT =>
Unlift c outerT
-> Unlift c innerT -> Unlift c (ComposeT outerT innerT)
composeTUnlift @c outerT m a -> m a
outerT m --> m
Unlift c outerT
ua innerT m a -> m a
innerT m --> m
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 -> outerT (innerT m) a -> ComposeT outerT innerT m a
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
outerT (innerT m) a -> ComposeT outerT innerT m a
MkComposeT (outerT (innerT m) a -> ComposeT outerT innerT m a)
-> outerT (innerT m) a -> ComposeT outerT innerT m a
forall a b. (a -> b) -> a -> b
$ innerT m a -> outerT (innerT m) a
forall (m :: Type -> Type) a. Monad m => m a -> outerT m a
forall (t :: TransKind) (m :: Type -> Type) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (innerT m a -> outerT (innerT m) a)
-> innerT m a -> outerT (innerT m) a
forall a b. (a -> b) -> a -> b
$ m a -> innerT m a
forall (m :: Type -> Type) a. Monad m => m a -> innerT m a
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 -> Dict (Functor (ComposeT outerT innerT m))
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 -> Dict (Applicative (ComposeT outerT innerT m))
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 -> Dict (Monad (ComposeT outerT innerT m))
forall (a :: Constraint). a => Dict a
Dict

instance (TransConstraint MonadIO outerT, 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 -> Dict (MonadIO (ComposeT outerT innerT m))
forall (a :: Constraint). a => Dict a
Dict

instance (TransConstraint MonadFail outerT, 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 -> Dict (MonadFail (ComposeT outerT innerT m))
forall (a :: Constraint). a => Dict a
Dict

instance (TransConstraint MonadFix outerT, 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 -> Dict (MonadFix (ComposeT outerT innerT m))
forall (a :: Constraint). a => Dict a
Dict

instance (TransConstraint MonadPlus outerT, 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 -> Dict (MonadPlus (ComposeT outerT innerT m))
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 -> outerT (innerT m2) a -> ComposeT outerT innerT m2 a
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
outerT (innerT m) a -> ComposeT outerT innerT m a
MkComposeT (outerT (innerT m2) a -> ComposeT outerT innerT m2 a)
-> outerT (innerT m2) a -> ComposeT outerT innerT m2 a
forall a b. (a -> b) -> a -> b
$ (innerT m1 --> innerT m2)
-> outerT (innerT m1) --> outerT (innerT m2)
forall (m1 :: Type -> Type) (m2 :: Type -> Type).
(Monad m1, Monad m2) =>
(m1 --> m2) -> outerT m1 --> outerT m2
forall (t :: TransKind) (m1 :: Type -> Type) (m2 :: Type -> Type).
(MonadTransHoist t, Monad m1, Monad m2) =>
(m1 --> m2) -> t m1 --> t m2
hoist ((m1 --> m2) -> innerT m1 --> innerT m2
forall (m1 :: Type -> Type) (m2 :: Type -> Type).
(Monad m1, Monad m2) =>
(m1 --> m2) -> innerT m1 --> innerT m2
forall (t :: TransKind) (m1 :: Type -> Type) (m2 :: Type -> Type).
(MonadTransHoist t, Monad m1, Monad m2) =>
(m1 --> m2) -> t m1 --> t m2
hoist m1 a -> m2 a
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 ->
                outerT (innerT m2) r -> ComposeT outerT innerT m2 r
forall (outerT :: TransKind) (innerT :: TransKind)
       (m :: Type -> Type) a.
outerT (innerT m) a -> ComposeT outerT innerT m a
MkComposeT (outerT (innerT m2) r -> ComposeT outerT innerT m2 r)
-> outerT (innerT m2) r -> ComposeT outerT innerT m2 r
forall a b. (a -> b) -> a -> b
$
                ((forall (m1 :: Type -> Type) a.
  Monad m1 =>
  outerT m1 a -> m1 (Tunnel outerT a))
 -> innerT m2 (Tunnel outerT r))
-> outerT (innerT m2) r
forall (m :: Type -> Type) r.
Monad m =>
((forall (m1 :: Type -> Type) a.
  Monad m1 =>
  outerT m1 a -> m1 (Tunnel outerT a))
 -> m (Tunnel outerT r))
-> outerT 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 =>
   outerT m1 a -> m1 (Tunnel outerT a))
  -> innerT m2 (Tunnel outerT r))
 -> outerT (innerT m2) r)
-> ((forall (m1 :: Type -> Type) a.
     Monad m1 =>
     outerT m1 a -> m1 (Tunnel outerT a))
    -> innerT m2 (Tunnel outerT r))
-> outerT (innerT m2) r
forall a b. (a -> b) -> a -> b
$ \forall (m1 :: Type -> Type) a.
Monad m1 =>
outerT m1 a -> m1 (Tunnel outerT a)
unlift1 ->
                    ((forall (m1 :: Type -> Type) a.
  Monad m1 =>
  innerT m1 a -> m1 (Tunnel innerT a))
 -> m2 (Tunnel innerT (Tunnel outerT r)))
-> innerT m2 (Tunnel outerT r)
forall (m :: Type -> Type) r.
Monad m =>
((forall (m1 :: Type -> Type) a.
  Monad m1 =>
  innerT m1 a -> m1 (Tunnel innerT a))
 -> m (Tunnel innerT r))
-> innerT 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 =>
   innerT m1 a -> m1 (Tunnel innerT a))
  -> m2 (Tunnel innerT (Tunnel outerT r)))
 -> innerT m2 (Tunnel outerT r))
-> ((forall (m1 :: Type -> Type) a.
     Monad m1 =>
     innerT m1 a -> m1 (Tunnel innerT a))
    -> m2 (Tunnel innerT (Tunnel outerT r)))
-> innerT m2 (Tunnel outerT r)
forall a b. (a -> b) -> a -> b
$ \forall (m1 :: Type -> Type) a.
Monad m1 =>
innerT m1 a -> m1 (Tunnel innerT a)
unlift2 ->
                        (ComposeInner (Tunnel outerT) (Tunnel innerT) r
 -> Tunnel innerT (Tunnel outerT r))
-> m2 (ComposeInner (Tunnel outerT) (Tunnel innerT) r)
-> m2 (Tunnel innerT (Tunnel outerT r))
forall a b. (a -> b) -> m2 a -> m2 b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap ComposeInner (Tunnel outerT) (Tunnel innerT) r
-> Tunnel innerT (Tunnel outerT r)
forall (inner :: Type -> Type) (outer :: Type -> Type) a.
ComposeInner inner outer a -> outer (inner a)
unComposeInner (m2 (ComposeInner (Tunnel outerT) (Tunnel innerT) r)
 -> m2 (Tunnel innerT (Tunnel outerT r)))
-> m2 (ComposeInner (Tunnel outerT) (Tunnel innerT) r)
-> m2 (Tunnel innerT (Tunnel outerT r))
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 (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))
-> (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)
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 -> (Tunnel innerT (Tunnel outerT a)
 -> ComposeInner (Tunnel outerT) (Tunnel innerT) a)
-> m1 (Tunnel innerT (Tunnel outerT a))
-> m1 (ComposeInner (Tunnel outerT) (Tunnel innerT) 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 Tunnel innerT (Tunnel outerT a)
-> ComposeInner (Tunnel outerT) (Tunnel innerT) a
forall (inner :: Type -> Type) (outer :: Type -> Type) a.
outer (inner a) -> ComposeInner inner outer a
MkComposeInner (m1 (Tunnel innerT (Tunnel outerT a))
 -> m1 (ComposeInner (Tunnel outerT) (Tunnel innerT) a))
-> m1 (Tunnel innerT (Tunnel outerT a))
-> m1 (ComposeInner (Tunnel outerT) (Tunnel innerT) a)
forall a b. (a -> b) -> a -> b
$ innerT m1 (Tunnel outerT a) -> m1 (Tunnel innerT (Tunnel outerT a))
forall (m1 :: Type -> Type) a.
Monad m1 =>
innerT m1 a -> m1 (Tunnel innerT a)
unlift2 (innerT m1 (Tunnel outerT a)
 -> m1 (Tunnel innerT (Tunnel outerT a)))
-> innerT m1 (Tunnel outerT a)
-> m1 (Tunnel innerT (Tunnel outerT a))
forall a b. (a -> b) -> a -> b
$ outerT (innerT m1) a -> innerT m1 (Tunnel outerT a)
forall (m1 :: Type -> Type) a.
Monad m1 =>
outerT m1 a -> m1 (Tunnel outerT a)
unlift1 (outerT (innerT m1) a -> innerT m1 (Tunnel outerT a))
-> outerT (innerT m1) a -> innerT m1 (Tunnel outerT a)
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 -> Dict
  (Coercible (ComposeT outerT innerT m1) (ComposeT outerT innerT m2))
forall (a :: Constraint). a => Dict a
Dict

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