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