module Identity where

import MonadIO
import MonadTrans

newtype Identity a =
    Identity { runIdentity :: a }
    deriving (Eq, Show)

instance Functor Identity where
    fmap f (Identity a) = Identity (f a)

instance Applicative Identity where
    pure = Identity
    (Identity f) <*> (Identity a) = Identity (f a)

newtype IdentityT f a =
    IdentityT { runIdentityT :: f a }
    deriving (Eq, Show)

instance (Functor m)
  => Functor (IdentityT m) where
      fmap f (IdentityT fa) = IdentityT (fmap f fa)

instance (Applicative m)
  => Applicative (IdentityT m) where
      pure x = IdentityT (pure x)

      (IdentityT fab) <*> (IdentityT fa) =
          IdentityT (fab <*> fa)

instance (Monad m)
  => Monad (IdentityT m) where
      return = pure

      (IdentityT ma) >>= f = IdentityT $ ma >>= runIdentityT . f

instance (MonadIO m)
  => MonadIO (IdentityT m) where
      liftIO = IdentityT . liftIO

instance MonadTrans IdentityT where
    lift = IdentityT