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

module Control.Monad.Ology.Specific.IdentityT
    ( module Control.Monad.Trans.Identity
    , module Control.Monad.Ology.Specific.IdentityT
    ) where

import Control.Monad.Ology.General
import Control.Monad.Trans.Identity hiding (liftCallCC, liftCatch)
import Import

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

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

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

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

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

instance TransConstraint MonadFix IdentityT where
    hasTransConstraint :: forall (m :: Type -> Type).
MonadFix m =>
Dict (MonadFix (IdentityT m))
hasTransConstraint = forall (a :: Constraint). a => Dict a
Dict

instance TransConstraint MonadPlus IdentityT where
    hasTransConstraint :: forall (m :: Type -> Type).
MonadPlus m =>
Dict (MonadPlus (IdentityT m))
hasTransConstraint = forall (a :: Constraint). a => Dict a
Dict

instance TransConstraint MonadOuter IdentityT where
    hasTransConstraint :: forall (m :: Type -> Type).
MonadOuter m =>
Dict (MonadOuter (IdentityT m))
hasTransConstraint = forall (a :: Constraint). a => Dict a
Dict

instance MonadExtract m => MonadExtract (IdentityT m) where
    mToValue :: Extract (IdentityT m)
mToValue (IdentityT m a
ma) = forall (m :: Type -> Type). MonadExtract m => Extract m
mToValue m a
ma

instance TransConstraint MonadExtract IdentityT where
    hasTransConstraint :: forall (m :: Type -> Type).
MonadExtract m =>
Dict (MonadExtract (IdentityT m))
hasTransConstraint = forall (a :: Constraint). a => Dict a
Dict

instance MonadException m => MonadException (IdentityT m) where
    type Exc (IdentityT m) = Exc m
    throwExc :: forall a. Exc (IdentityT m) -> IdentityT m a
throwExc Exc (IdentityT m)
e = 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 (m :: Type -> Type) a. MonadException m => Exc m -> m a
throwExc Exc (IdentityT m)
e
    catchExc :: forall a.
IdentityT m a
-> (Exc (IdentityT m) -> IdentityT m a) -> IdentityT m a
catchExc IdentityT m a
tma Exc (IdentityT m) -> IdentityT m a
handler = 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 =>
IdentityT m1 a -> m1 (Tunnel IdentityT a)
unlift -> forall (m :: Type -> Type) a.
MonadException m =>
m a -> (Exc m -> m a) -> m a
catchExc (forall (m1 :: Type -> Type) a.
Monad m1 =>
IdentityT m1 a -> m1 (Tunnel IdentityT a)
unlift IdentityT m a
tma) forall a b. (a -> b) -> a -> b
$ \Exc m
e -> forall (m1 :: Type -> Type) a.
Monad m1 =>
IdentityT m1 a -> m1 (Tunnel IdentityT a)
unlift forall a b. (a -> b) -> a -> b
$ Exc (IdentityT m) -> IdentityT m a
handler Exc m
e

instance TransConstraint MonadException IdentityT where
    hasTransConstraint :: forall (m :: Type -> Type).
MonadException m =>
Dict (MonadException (IdentityT m))
hasTransConstraint = forall (a :: Constraint). a => Dict a
Dict

instance MonadThrow e m => MonadThrow e (IdentityT m) where
    throw :: forall a. e -> IdentityT m a
throw e
e = 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 e (m :: Type -> Type) a. MonadThrow e m => e -> m a
throw e
e

instance TransConstraint (MonadThrow e) IdentityT where
    hasTransConstraint :: forall (m :: Type -> Type).
MonadThrow e m =>
Dict (MonadThrow e (IdentityT m))
hasTransConstraint = forall (a :: Constraint). a => Dict a
Dict

instance MonadCatch e m => MonadCatch e (IdentityT m) where
    catch :: forall a. IdentityT m a -> (e -> IdentityT m a) -> IdentityT m a
catch IdentityT m a
ma e -> IdentityT m a
handler = 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 =>
IdentityT m1 a -> m1 (Tunnel IdentityT a)
unlift -> forall e (m :: Type -> Type) a.
MonadCatch e m =>
m a -> (e -> m a) -> m a
catch (forall (m1 :: Type -> Type) a.
Monad m1 =>
IdentityT m1 a -> m1 (Tunnel IdentityT a)
unlift IdentityT m a
ma) forall a b. (a -> b) -> a -> b
$ \e
e -> forall (m1 :: Type -> Type) a.
Monad m1 =>
IdentityT m1 a -> m1 (Tunnel IdentityT a)
unlift forall a b. (a -> b) -> a -> b
$ e -> IdentityT m a
handler e
e

instance TransConstraint (MonadCatch e) IdentityT where
    hasTransConstraint :: forall (m :: Type -> Type).
MonadCatch e m =>
Dict (MonadCatch e (IdentityT m))
hasTransConstraint = forall (a :: Constraint). a => Dict a
Dict

instance MonadInner m => MonadInner (IdentityT m) where
    retrieveInner :: forall a. IdentityT m a -> Result (Exc (IdentityT m)) a
retrieveInner (IdentityT m a
ma) = forall (m :: Type -> Type) a.
MonadInner m =>
m a -> Result (Exc m) a
retrieveInner m a
ma

instance TransConstraint MonadInner IdentityT where
    hasTransConstraint :: forall (m :: Type -> Type).
MonadInner m =>
Dict (MonadInner (IdentityT m))
hasTransConstraint = forall (a :: Constraint). a => Dict a
Dict

instance MonadIdentity m => MonadIdentity (IdentityT m)

instance TransConstraint MonadIdentity IdentityT where
    hasTransConstraint :: forall (m :: Type -> Type).
MonadIdentity m =>
Dict (MonadIdentity (IdentityT m))
hasTransConstraint = forall (a :: Constraint). a => Dict a
Dict

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

instance MonadTransHoist IdentityT where
    hoist :: forall (m1 :: Type -> Type) (m2 :: Type -> Type).
(Monad m1, Monad m2) =>
(m1 --> m2) -> IdentityT m1 --> IdentityT m2
hoist = forall (t :: TransKind) (m1 :: Type -> Type) (m2 :: Type -> Type).
(MonadTransTunnel t, Monad m1, Monad m2) =>
(m1 --> m2) -> t m1 --> t m2
tunnelHoist

instance MonadTransTunnel IdentityT where
    type Tunnel IdentityT = Identity
    tunnel :: forall (m :: Type -> Type) r.
Monad m =>
((forall (m1 :: Type -> Type) a.
  Monad m1 =>
  IdentityT m1 a -> m1 (Tunnel IdentityT a))
 -> m (Tunnel IdentityT r))
-> IdentityT m r
tunnel (forall (m1 :: Type -> Type) a.
 Monad m1 =>
 IdentityT m1 a -> m1 (Tunnel IdentityT a))
-> m (Tunnel IdentityT r)
call = forall {k} (f :: k -> Type) (a :: k). f a -> IdentityT f a
IdentityT forall a b. (a -> b) -> a -> b
$ forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Identity a -> a
runIdentity forall a b. (a -> b) -> a -> b
$ (forall (m1 :: Type -> Type) a.
 Monad m1 =>
 IdentityT m1 a -> m1 (Tunnel IdentityT a))
-> m (Tunnel IdentityT r)
call forall a b. (a -> b) -> a -> b
$ \(IdentityT m1 a
ma) -> forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. a -> Identity a
Identity m1 a
ma

instance MonadOuter m => MonadOuter (IdentityT m) where
    getExtract :: IdentityT m (WExtract (IdentityT m))
getExtract =
        forall {k} (f :: k -> Type) (a :: k). f a -> IdentityT f a
IdentityT forall a b. (a -> b) -> a -> b
$ do
            MkWExtract Extract m
maa <- forall (m :: Type -> Type). MonadOuter m => m (WExtract m)
getExtract
            forall (m :: Type -> Type) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: Type -> Type). Extract m -> WExtract m
MkWExtract forall a b. (a -> b) -> a -> b
$ Extract m
maa forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall {k} (f :: k -> Type) (a :: k). IdentityT f a -> f a
runIdentityT

instance MonadTransUnlift IdentityT where
    liftWithUnlift :: forall (m :: Type -> Type) r.
MonadIO m =>
(Unlift MonadTunnelIOInner IdentityT -> m r) -> IdentityT m r
liftWithUnlift Unlift MonadTunnelIOInner IdentityT -> m r
call = forall {k} (f :: k -> Type) (a :: k). f a -> IdentityT f a
IdentityT forall a b. (a -> b) -> a -> b
$ Unlift MonadTunnelIOInner IdentityT -> m r
call forall {k} (f :: k -> Type) (a :: k). IdentityT f a -> f a
runIdentityT

instance MonadTransAskUnlift IdentityT

identityWUnlift :: WUnlift c IdentityT
identityWUnlift :: forall (c :: (Type -> Type) -> Constraint). WUnlift c IdentityT
identityWUnlift = forall (c :: (Type -> Type) -> Constraint) (t :: TransKind).
Unlift c t -> WUnlift c t
MkWUnlift forall {k} (f :: k -> Type) (a :: k). IdentityT f a -> f a
runIdentityT