I think I got what exactly was the change of ghc 7.10. basically it only adds a constraint Applicative on the Monad class, and same with Functor/Applicative. it doesn't automatically write implied instances, but just forces one to actually write said instances of those superclasses. In short you can't anymore make monads without making Applicatives, "beforehand" (even though order is not important).<br><br>In my opinion it's pretty shitty. I totally agree that it's (partially) more mathematically correct, and that's great. yet in my opinion, given superclasses can always be derived from their subclasses, it should be mathematically automatic to prove superclass instances by proving any subclass thereof. Otherwise it's forcing the programmer to do even more possibly-useless work (we don't always need applicative and functors for every use of a new monad, do we?) without gaining anything in return but a very abstract idea of "correctness". in short i think if they wanted mathematical correctness they should have added automatic instanciation of superclasses, with possibility to override the default definitions, like they do so with some superfluous methods.<br><br>Not that write functors or applicative functor instances is actually heavywork, of course, thankfully.<br><br>I kinda wonder, can we define Applicative methods in function of Monad methods, even though those latter can only be type-valid if the Applicative instance is already created and checked? or maybe we can write a class-neutral version (without constraints)?<br>Say something like that:<br>> -------- version one, with constraints<br>> mkAp :: (Monad m, Applicative m) => m (a -> b) -> m a -> m b<br>> mkAp mf ma = mf >>= \f -> ma >>= \a -> return $ f a<br>> -- (not entirely sure on the necessary constraints of this type signature...)<br>> instance Functor f => Applicative f where<br>>   <*> = mkAp<br>>      -- the value is automatically different depending on the instance right?<br>>   pure = return<br><br>course, I'm pretty sure mkAp == ap, aka the monad equivalent of (<*>) is automatically defined at instanciation of the monad. But i think to remember it uses fmap, and in theory the idea is that neither instances of Functor or Applicative would yet exist. All depends on the possibility to define a superclass instance in terms of a subclass instance.<br><br>> -------- version two, without class -- can we use type constructors in signature without classes?<br>> mkAp :: (**signature of bind**) -> (a -> m a) -> (( m (a -> b) -> m a -> m b  ))<br>> mkAp bind return mf ma = ... -- defined in terms of those given class-independent functions<br><br>I'mma check myself but if it fails i wonder if anyone knows a way around?<br>