On Fri, 2011-09-23 at 23:46 +0100, Duncan Coutts wrote:

On 23 September 2011 21:25, Maciej Marcin Piechotka wrote:

...

The problem of backward compatibility have been the main obstacle against adopting Functor f => (Pointed f =>?) => Applicative f => Monad f.

This proposition is to add following default instances[1]:

Sorry, I'm confused! The [1] link is about default superclass instances, not default signatures. As I understand it, default superclass instances are not implemented yet.

Ups. You're right.

I fully support the general aim and default superclass instances look like a very sensible way of addressing the problem. It's just not clear to me how the default signatures you're suggesting here get us closer to the goal.

Perhaps you can explain it a bit more. I suspect other people on this list don't quite get it either.

From example in link [2]. If we had:

class Functor f where fmap :: (a -> b) -> f a -> f b default fmap :: Applicative f => (a -> b) -> f a -> f b f `fmap` m = pure f <*> m (<$) :: a -> f b -> f a (<$) = fmap . const

class Functor f => Pointed f where point :: a -> f a default point :: Applicative f => a -> f a point = pure

class Pointed f => Applicative f where pure :: a -> f a default pure :: Monad f => a -> f a pure = return (<*>) :: f (a -> b) -> f a -> f b default (<*>) :: Monad f => f (a -> b) -> f a -> f b f <*> v = liftM2 ($) f v (*>) :: f a -> f b -> f b (*>) = liftA2 (const id) (<*) :: f a -> f b -> f a (<*) = liftA2 const

class Applicative f => Monad f where return :: a -> f a (>>=) :: f a -> (a -> f b) -> f b (>>) :: f a -> f b -> f b m >> k = m >>= const k

Then having:

data List a = List a (List a) | Empty

instance Monad List where return x = List x Empty Empty >>= _ = Empty List v vs >>= f = List (f v) (vs >>= f)

is sufficient to use (in current GHC) to use: test = Empty <*> List 1 Empty Hence adding default instances + fixing the hierarchy seems to be sufficient to have backward compatibility for instance declaration.

...

default fmap :: Applicative f => (a -> b) -> f a -> f b f `fmap` m = pure f <*> m default pure :: Monad f => a -> f a pure = return default (<*>) :: Monad f => f (a -> b) -> f a -> f b (<*>) = liftM2 ($)

Duncan

Regards

On 24 September 2011 09:20, Antoine Latter wrote:

From what I understand (I haven't tried the extension yet) you would still need an instance declaration, even if it had no body:

Yes you would indeed. While I already said I liked this idea, I do see one complication: as also explained in the DefaulSuperclassInstances[1] proposal there can be multiple ways of defining fmap: default fmap :: Applicative f => (a -> b) -> f a -> f b fmap = Control.Applicative.liftA default fmap :: Traversable f => (a -> b) -> f a -> f b fmap = Data.Traversable.fmapDefault Which do we choose? I'm happy with liftA but others might disagree. With regard to [1], is there already a plan to implement them? And if so, when is it expected to be finished? If it takes some time, this might be a temporary solution. Regards, Bas [1] http://hackage.haskell.org/trac/ghc/wiki/DefaultSuperclassInstances

On Sat, 2011-09-24 at 02:20 -0500, Antoine Latter wrote:

On Sat, Sep 24, 2011 at 1:50 AM, Maciej Marcin Piechotka wrote:

...

On Fri, 2011-09-23 at 23:46 +0100, Duncan Coutts wrote:

...

On 23 September 2011 21:25, Maciej Marcin Piechotka wrote:

...

The problem of backward compatibility have been the main obstacle against adopting Functor f => (Pointed f =>?) => Applicative f => Monad f.

This proposition is to add following default instances[1]:

Sorry, I'm confused! The [1] link is about default superclass instances, not default signatures. As I understand it, default superclass instances are not implemented yet.

Ups. You're right.

...

I fully support the general aim and default superclass instances look like a very sensible way of addressing the problem. It's just not clear to me how the default signatures you're suggesting here get us closer to the goal.

Perhaps you can explain it a bit more. I suspect other people on this list don't quite get it either.

From example in link [2]. If we had:

...

class Functor f where fmap :: (a -> b) -> f a -> f b default fmap :: Applicative f => (a -> b) -> f a -> f b f `fmap` m = pure f <*> m (<$) :: a -> f b -> f a (<$) = fmap . const

class Functor f => Pointed f where point :: a -> f a default point :: Applicative f => a -> f a point = pure

class Pointed f => Applicative f where pure :: a -> f a default pure :: Monad f => a -> f a pure = return (<*>) :: f (a -> b) -> f a -> f b default (<*>) :: Monad f => f (a -> b) -> f a -> f b f <*> v = liftM2 ($) f v (*>) :: f a -> f b -> f b (*>) = liftA2 (const id) (<*) :: f a -> f b -> f a (<*) = liftA2 const

class Applicative f => Monad f where return :: a -> f a (>>=) :: f a -> (a -> f b) -> f b (>>) :: f a -> f b -> f b m >> k = m >>= const k

Then having:

...

data List a = List a (List a) | Empty

instance Monad List where return x = List x Empty Empty >>= _ = Empty List v vs >>= f = List (f v) (vs >>= f)

is sufficient to use (in current GHC) to use:

test = Empty <*> List 1 Empty

Hence adding default instances + fixing the hierarchy seems to be sufficient to have backward compatibility for instance declaration.

From what I understand (I haven't tried the extension yet) you would still need an instance declaration, even if it had no body:

...

instance Applicative List where instance Functor List where

to use the default methods.

Antoine

Withe the current implementation in GHC you wouldn't. At least the above statement compiled fine (with full code in linked post). Regards

On Sat, 2011-09-24 at 13:32 +0200, Bas van Dijk wrote:

On 24 September 2011 12:49, Maciej Marcin Piechotka wrote:

...

...

From what I understand (I haven't tried the extension yet) you would still need an instance declaration, even if it had no body:

...

instance Applicative List where instance Functor List where

to use the default methods.

Antoine

Withe the current implementation in GHC you wouldn't. At least the above statement compiled fine (with full code in linked post).

Are you sure?

If I run the following code in GHC:

---------------------------------------------------------------------------------- {-# LANGUAGE DefaultSignatures, NoImplicitPrelude #-}

import Data.Function ((.), ($), const, id, flip) import Data.List (concatMap)

class Functor f where fmap :: (a -> b) -> f a -> f b default fmap :: Applicative f => (a -> b) -> f a -> f b f `fmap` m = pure f <*> m (<$) :: a -> f b -> f a (<$) = fmap . const

(<$>) :: Functor f => (a -> b) -> f a -> f b (<$>) = fmap

class Functor f => Pointed f where point :: a -> f a default point :: Applicative f => a -> f a point = pure

class Pointed f => Applicative f where pure :: a -> f a default pure :: Monad f => a -> f a pure = return (<*>) :: f (a -> b) -> f a -> f b default (<*>) :: Monad f => f (a -> b) -> f a -> f b f <*> v = liftM2 ($) f v (*>) :: f a -> f b -> f b (*>) = liftA2 (const id) (<*) :: f a -> f b -> f a (<*) = liftA2 const

liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c liftA2 f a b = f <$> a <*> b

class Applicative f => Monad f where return :: a -> f a (>>=) :: f a -> (a -> f b) -> f b (>>) :: f a -> f b -> f b m >> k = m >>= const k

liftM2 :: (Monad m) => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r liftM2 f m1 m2 = m1 >>= \x1 -> m2 >>= \x2 -> return (f x1 x2)

instance Monad [] where return x = [x] (>>=) = flip concatMap ----------------------------------------------------------------------------------

I get the expected:

No instance for (Applicative []) arising from the superclasses of an instance declaration Possible fix: add an instance declaration for (Applicative []) In the instance declaration for `Monad []'

Adding these fixes it:

instance Applicative [] instance Pointed [] instance Functor []

Regards,

Bas

My error. I believed that complaining about missing main is the last error reported by ghc (it turns out to be one of the first). Regards