Applicative Identity

[Dan Doel]

Hello,

I ran into a tiny snag recently, attempting to write a library for a monad + 
transformer. If one uses MTL, it typically nice to be able to do something 
like the following:

    newtype FooT m a = FooT { runFooT :: ... }

    ... instances for FooT

    newtype Foo a = Foo { unFoo :: FooT Identity a }
        deriving (Functor, Monad, ...)

Since the normal monad is just the case of the transformer parameterized by 
the Identity monad. However, we now have the Control.Applicative library, 
which sits in between Functors and Monads, so it seems reasonable to provide 
instances of those, as well. However, Identity (and, for that matter, all of 
the monads in MTL, I think) lacks an appropriate instance for Applicative, so 
generalized deriving can't be used there.

On the other side, Control.Applicative has a newtype WrappedMonad, which 
provides such instances for an arbitrary monad. However, it has the reverse 
problem: There are no Monad (and related) instances for WrappedMonad. So, it 
seems that the full gamut of instances can't be automatically derived in this 
way, as the libraries currently stand.

Now, this clearly isn't a dire situation, but it might be nice to fill in one 
or both of these gaps so the libraries play a little nicer with each other. 
For instance, I think the Identity instance is as simple as:

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

And, of course, in general, one can fill in the MTL instances as easily as:

    instance Applicative MTLType where
        pure  = return
        (<*>) = ap

Although it may be less trivial with transformers (though I assume Applicative 
a => Applicative (T a) aren't too hard).

Many thanks,
Dan Doel