{-# 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 = Dict (Functor (IdentityT m))
forall (a :: Constraint). a => Dict a
Dict

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

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

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

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

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

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

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

instance MonadExtract m => MonadExtract (IdentityT m) where
    mToValue :: Extract (IdentityT m)
mToValue (IdentityT m a
ma) = m a -> a
Extract m
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 = Dict (MonadExtract (IdentityT m))
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 = m a -> IdentityT m a
forall (m :: Type -> Type) a. Monad m => m a -> IdentityT m a
forall (t :: TransKind) (m :: Type -> Type) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> IdentityT m a) -> m a -> IdentityT m a
forall a b. (a -> b) -> a -> b
$ Exc m -> m a
forall a. Exc m -> m a
forall (m :: Type -> Type) a. MonadException m => Exc m -> m a
throwExc Exc m
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 (m1 :: Type -> Type) a.
  Monad m1 =>
  IdentityT m1 a -> m1 (Tunnel IdentityT a))
 -> m (Tunnel IdentityT a))
-> IdentityT m a
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
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 =>
   IdentityT m1 a -> m1 (Tunnel IdentityT a))
  -> m (Tunnel IdentityT a))
 -> IdentityT m a)
-> ((forall (m1 :: Type -> Type) a.
     Monad m1 =>
     IdentityT m1 a -> m1 (Tunnel IdentityT a))
    -> m (Tunnel IdentityT a))
-> IdentityT m a
forall a b. (a -> b) -> a -> b
$ \forall (m1 :: Type -> Type) a.
Monad m1 =>
IdentityT m1 a -> m1 (Tunnel IdentityT a)
unlift -> m (Tunnel IdentityT a)
-> (Exc m -> m (Tunnel IdentityT a)) -> m (Tunnel IdentityT a)
forall a. m a -> (Exc m -> m a) -> m a
forall (m :: Type -> Type) a.
MonadException m =>
m a -> (Exc m -> m a) -> m a
catchExc (IdentityT m a -> m (Tunnel IdentityT a)
forall (m1 :: Type -> Type) a.
Monad m1 =>
IdentityT m1 a -> m1 (Tunnel IdentityT a)
unlift IdentityT m a
tma) ((Exc m -> m (Tunnel IdentityT a)) -> m (Tunnel IdentityT a))
-> (Exc m -> m (Tunnel IdentityT a)) -> m (Tunnel IdentityT a)
forall a b. (a -> b) -> a -> b
$ \Exc m
e -> IdentityT m a -> m (Tunnel IdentityT a)
forall (m1 :: Type -> Type) a.
Monad m1 =>
IdentityT m1 a -> m1 (Tunnel IdentityT a)
unlift (IdentityT m a -> m (Tunnel IdentityT a))
-> IdentityT m a -> m (Tunnel IdentityT a)
forall a b. (a -> b) -> a -> b
$ Exc (IdentityT m) -> IdentityT m a
handler Exc m
Exc (IdentityT m)
e

instance TransConstraint MonadException IdentityT where
    hasTransConstraint :: forall (m :: Type -> Type).
MonadException m =>
Dict (MonadException (IdentityT m))
hasTransConstraint = Dict (MonadException (IdentityT m))
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 = m a -> IdentityT m a
forall (m :: Type -> Type) a. Monad m => m a -> IdentityT m a
forall (t :: TransKind) (m :: Type -> Type) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> IdentityT m a) -> m a -> IdentityT m a
forall a b. (a -> b) -> a -> b
$ e -> m a
forall a. e -> m a
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 = Dict (MonadThrow e (IdentityT m))
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 (m1 :: Type -> Type) a.
  Monad m1 =>
  IdentityT m1 a -> m1 (Tunnel IdentityT a))
 -> m (Tunnel IdentityT a))
-> IdentityT m a
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
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 =>
   IdentityT m1 a -> m1 (Tunnel IdentityT a))
  -> m (Tunnel IdentityT a))
 -> IdentityT m a)
-> ((forall (m1 :: Type -> Type) a.
     Monad m1 =>
     IdentityT m1 a -> m1 (Tunnel IdentityT a))
    -> m (Tunnel IdentityT a))
-> IdentityT m a
forall a b. (a -> b) -> a -> b
$ \forall (m1 :: Type -> Type) a.
Monad m1 =>
IdentityT m1 a -> m1 (Tunnel IdentityT a)
unlift -> m (Tunnel IdentityT a)
-> (e -> m (Tunnel IdentityT a)) -> m (Tunnel IdentityT a)
forall a. m a -> (e -> m a) -> m a
forall e (m :: Type -> Type) a.
MonadCatch e m =>
m a -> (e -> m a) -> m a
catch (IdentityT m a -> m (Tunnel IdentityT a)
forall (m1 :: Type -> Type) a.
Monad m1 =>
IdentityT m1 a -> m1 (Tunnel IdentityT a)
unlift IdentityT m a
ma) ((e -> m (Tunnel IdentityT a)) -> m (Tunnel IdentityT a))
-> (e -> m (Tunnel IdentityT a)) -> m (Tunnel IdentityT a)
forall a b. (a -> b) -> a -> b
$ \e
e -> IdentityT m a -> m (Tunnel IdentityT a)
forall (m1 :: Type -> Type) a.
Monad m1 =>
IdentityT m1 a -> m1 (Tunnel IdentityT a)
unlift (IdentityT m a -> m (Tunnel IdentityT a))
-> IdentityT m a -> m (Tunnel IdentityT a)
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 = Dict (MonadCatch e (IdentityT m))
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) = m a -> Result (Exc m) a
forall a. m a -> Result (Exc m) a
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 = Dict (MonadInner (IdentityT m))
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 = Dict (MonadIdentity (IdentityT m))
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 = Dict (Coercible (IdentityT m1) (IdentityT m2))
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 = (m1 --> m2) -> IdentityT m1 --> IdentityT m2
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 = m r -> IdentityT m r
forall {k} (f :: k -> Type) (a :: k). f a -> IdentityT f a
IdentityT (m r -> IdentityT m r) -> m r -> IdentityT m r
forall a b. (a -> b) -> a -> b
$ (Identity r -> r) -> m (Identity r) -> m r
forall a b. (a -> b) -> m a -> m b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap Identity r -> r
forall a. Identity a -> a
runIdentity (m (Identity r) -> m r) -> m (Identity r) -> m r
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 (m1 :: Type -> Type) a.
  Monad m1 =>
  IdentityT m1 a -> m1 (Tunnel IdentityT a))
 -> m (Tunnel IdentityT r))
-> (forall (m1 :: Type -> Type) a.
    Monad m1 =>
    IdentityT m1 a -> m1 (Tunnel IdentityT a))
-> m (Tunnel IdentityT r)
forall a b. (a -> b) -> a -> b
$ \(IdentityT m1 a
ma) -> (a -> Identity a) -> m1 a -> m1 (Identity 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 a -> Identity a
forall a. a -> Identity a
Identity m1 a
ma

instance MonadOuter m => MonadOuter (IdentityT m) where
    getExtract :: IdentityT m (WExtract (IdentityT m))
getExtract =
        m (WExtract (IdentityT m)) -> IdentityT m (WExtract (IdentityT m))
forall {k} (f :: k -> Type) (a :: k). f a -> IdentityT f a
IdentityT (m (WExtract (IdentityT m))
 -> IdentityT m (WExtract (IdentityT m)))
-> m (WExtract (IdentityT m))
-> IdentityT m (WExtract (IdentityT m))
forall a b. (a -> b) -> a -> b
$ do
            MkWExtract Extract m
maa <- m (WExtract m)
forall (m :: Type -> Type). MonadOuter m => m (WExtract m)
getExtract
            WExtract (IdentityT m) -> m (WExtract (IdentityT m))
forall a. a -> m a
forall (m :: Type -> Type) a. Monad m => a -> m a
return (WExtract (IdentityT m) -> m (WExtract (IdentityT m)))
-> WExtract (IdentityT m) -> m (WExtract (IdentityT m))
forall a b. (a -> b) -> a -> b
$ Extract (IdentityT m) -> WExtract (IdentityT m)
forall (m :: Type -> Type). Extract m -> WExtract m
MkWExtract (Extract (IdentityT m) -> WExtract (IdentityT m))
-> Extract (IdentityT m) -> WExtract (IdentityT m)
forall a b. (a -> b) -> a -> b
$ m a -> a
Extract m
maa (m a -> a) -> (IdentityT m a -> m a) -> IdentityT m a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. IdentityT m a -> m a
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 MonadTunnelIO IdentityT -> m r) -> IdentityT m r
liftWithUnlift Unlift MonadTunnelIO IdentityT -> m r
call = m r -> IdentityT m r
forall {k} (f :: k -> Type) (a :: k). f a -> IdentityT f a
IdentityT (m r -> IdentityT m r) -> m r -> IdentityT m r
forall a b. (a -> b) -> a -> b
$ Unlift MonadTunnelIO IdentityT -> m r
call IdentityT m a -> m a
forall {k} (f :: k -> Type) (a :: k). IdentityT f a -> f a
Unlift MonadTunnelIO IdentityT
runIdentityT

instance MonadTransAskUnlift IdentityT

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