Proposal: Applicative => Monad: Call for consensus

[Henning Thielemann]

Bas van Dijk schrieb:

> The patch for base makes a few changes:
> 
> 1) Make Applicative a superclass of Monad. So the new hierarchy becomes:
> 
> class  Functor f  where
>     fmap        :: (a -> b) -> f a -> f b
> 
>     (<$)        :: a -> f b -> f a
>     (<$)        =  fmap . const
> 
> class Functor f => Applicative f where
>     pure :: a -> f a
> 
>     (<*>) :: f (a -> b) -> f a -> f b
> 
>     (*>) :: f a -> f b -> f b
>     a *> b = fmap (const id) a <*> b
> 
>     (<*) :: f a -> f b -> f a
>     a <* b = fmap const a <*> b
> 
> class Applicative m => Monad m  where
>     (>>=) :: forall a b. m a -> (a -> m b) -> m b

Is the explicit 'forall' intended?

>     m >>= f = join $ fmap f m
> 
>     join :: m (m a) -> m a
>     join m = m >>= id
> 
>     (>>) :: forall a b. m a -> m b -> m b
>     (>>) = (*>)
> 
>     return :: a -> m a
>     return = pure
> 
>     fail :: String -> m a
>     fail s = error s
> 
> 2) Make 'join' a method of Monad.

Is there a need for it?

> 3) Export Applicative(pure, (<*>), (*>), (<*)) from the Prelude.
> (Maybe we shouldn't export the (*>) and (<*) methods.)

No, please avoid that. Importing Applicative explicitly is completely ok
for me. I use (<*>) already for scalar product in NumericPrelude. For me
it looks like a commutative operator, which Applicative.<*> is not. The
existence of (<*>) in Applicative module is ok for me, but I do not want
name clashes with it when automatically imported by Prelude.

If at all, Functor stuff should be moved from Control.Applicative and
Control.Monad to a new module Control.Functor (and could be re-exported
by Control.Applicative and Control.Monad for compatibility reasons).
Then fmap could be renamed to 'map' and used as F.map (using "import
qualified Control.Functor as F"). All those infix operators for Monad
and Functor are not so important for me to be imported automatically
from Prelude. Thus I would not like to move Applicative in this direction.

> 4) Also export the join method from the Prelude.

no please, as above

> 5) Add Applicative instances for all monads in base.

+1

> 6) Add a Monad instance for ((,) a): (There are already Functor and
> Applicative instances for it.)

That is, a Writer instance?

I am uncertain about it, because using it may hide a bug. So far I am
happy with Writer from transformers package. Using Writer explicitly
shows everybody, what I am doing and that I do it intentionally.

> The patch for ghc simply adds Applicative instances for all monads in
> ghc. Also included in the ghc patch bundle are some refactoring
> patches that will make the transition easier:
> 
> * Added (<>) = mappend to compiler/utils/Util.hs.
> * Add a Monoid instance for AGraph and remove the <*> splice operator.
> Instead of <*>, the (<>) = mappend operator is now used to splice AGraphs.
> This change is needed because <*> clashes with the Applicative apply
> operator <*>, which is probably going to be exported from the Prelude
> when the new Monad hierarchy is going through. (Simply hiding <*> from
> the Prelude is also possible of course. However, I think this makes
> things easier to understand)

For me this is another argument against automatic import of (<*>).

> * Make SDoc an abstract newtype and add a Monoid instance for it.
> The (<>) combinator of SDocs is removed and replaced by the more
> general (<>) = mappend combinator from Util.

An infix operator for monoids would be nice, indeed. Why not use
something that resembles (++), which is the "mappend" for lists? I am
uncertain. Maybe something containing '+' looks too commutative. :-) But
'<>' looks too much like 'not equal' in other languages.