allow to give default implementatoions for methods of base class

14 Aug 2006

      Hello Jon,

Monday, August 14, 2006, 1:49:58 PM, you wrote:
...
...
...
instance Monad [] where
    fmap = map
    return x = [x]
    join = concat
i support this idea. [...]
...
I'm not sure it's quite right. Surely it only makes sense if
it defines all the (necessary) superclass methods -- in
other words, what you are doing is defining an instance,
just omitting the "instance Functor []" line, which doesn't
seem like a great advantage.
This shrinks size of code that is especially important when writing
a lot of small instances. second, it allows me to think that all the
methods belongs to the same class instead of specifying each and every class:

class Show s => Stream s where
  sTell :: ..
class Stream s => OutputStream s where
  sPutChar :: ..

instance Show s where
  show = ..
instance Stream s where
  sTell = ..
instance OutputStream s where
  sPutChar = ..

i might prefer to write just

instance OutputStream s where
  sPutChar = ..
  sTell = ..
  show = ..

- and as you can see i also changed the ordering/grouping of
operations. of course it's just syntax sugar, but i like it - it will
shrink class declarations and bring them closer to OOP style when
derived class also "owns" all the methods of base classes
...
If we are going to play around
with this stuff, here's another suggestion that solves my
original problem more neatly:
...
In a class declaration, a superclass context is a
requirement that instances of the class have instances of
the superclass; this is similar to the type declarations of
the methods. We could have had
...
class Monad m where
      instance Functor m
      (>>=):: ...
...
instead of
...
class Functor m => Monad m where
      (>>=):: ...
...
of course, there's no reason to do that, but what I'm
proposing is that we allow default instance declarations in
class declarations in much the same way as default methods:
...
...
class Functor m => Monad m where
i think, you mean:
...
...
class Monad m where
      instance Functor m where
               fmap f =  (>>= return . f)
      (>>=):: ...
      return:: ...
      join:: ...
i support this too. but bringing these two ideas together the class
declaration should look as

class Functor m => Monad m where
      fmap f =  (>>= return . f)
      (>>=):: ...
      return:: ...
      join:: ...

and instance declaration should be:

instance Monad [] where
    fmap = map
    return x = [x]
    join = concat

instead of:
...
instance Monad [] where
    return x = [x]
    join = concat
    instance Functor [] where
             fmap = map
this proposal should be named as subj, independent of syntax form used

--
Best regards,
 Bulat                            mailto:Bulat.Ziganshin@gmail.com

allow to give default implementatoions for methods of base class

Bulat Ziganshin