On Thu, Oct 3, 2013 at 8:16 AM, Wvv <vitea3v@rambler.ru> wrote:

> Your first two cases will be fixed in 7.10, as Applicative finally becomes
a superclass of Monad.

Sure, newclassses not about Applicative and Monads only.
This question is more wider.

Must Apply be a superclass of Bind?
Must Bind be a superclass of Monad?
So, must Monad has 2 superclasses at once: Bind and Applicative?

Must Semigroupoids be a superclass of Category?
Must Category be a superclass of Arrow?

There is no theoretical problem here, just a practical one. It would be resolved by solving your 4th problem, for which you don't need newclasses. Consider:

š š {-# LANGUAGE ConstraintKinds #-}

š š class Functor f where { fmap :: (a -> b) -> f a -> f b }

š š class Functor f => Apply f where { (<*>) :: f (a -> b) -> f a -> f b }

š š class Apply f => Applicative f where { pure :: a -> f a }

š š class Apply f => Bind f where { (=<<) :: (a -> f b) -> f a -> f b }

š š type Monad f = (Applicative f, Bind f)

š š return :: Monad f => a -> f a

š š return = pure

I might have made some mistakes in the exact hierarchy, but something like this should work. There are no problems with having hierarchies like this, as far as I'm aware.

The current problem is that nobody wants to use this hierarchy: to get a Monad instance, you have to write four separate instances for your type. What would be nicer is a feature (ConstraintSynonymInstances?) where something like this can be written:

š š instance (Functor Maybe, Apply Maybe, Monad Maybe) where

š š š š fmap _ Nothing = Nothing

š š š š fmap f (Just x) = Just (f x)

š š š š Just f <*> Just x = Just (f x)

š š š š _ <*> _ = Nothing

š š š š pure = Just

š š š š f =<< Just x = f x

š š š š _ =<< Nothing = Nothing

This would be sugar for

š š instance Functor Maybe where { fmap = ... }

š š instance Apply Maybe where { (<*>) = ... }

š š instance Monad Maybe where { pure = ... ; (=<<) = ... }

and the last would be sugar for

š š instance Applicative Maybe where { pure = ... }

š š instance Bind Maybe where { (=<<) = ... }

You don't need any new keywords for this, because the above does not conflict with the existing rules for instance declarations.

> Also, I don't see why it would be a misfeature to have Eq as a superclass
> of Ord, or Functor as a superclass of Applicative.

I see 2 reasons:
1) class functions in reality don't depend of superclass functions
2) Haskell can't check if superclass instance is correspond with class laws

Again, I don't see why that makes it a misfeature.