[GHC] #7633: Checkable "minimal complete definitions"

[GHC]

#7633: Checkable "minimal complete definitions"
-----------------------------+----------------------------------------------
Reporter:  shachaf           |          Owner:                  
    Type:  feature request   |         Status:  new             
Priority:  normal            |      Component:  Compiler        
 Version:  7.6.1             |       Keywords:                  
      Os:  Unknown/Multiple  |   Architecture:  Unknown/Multiple
 Failure:  None/Unknown      |      Blockedby:                  
Blocking:                    |        Related:  6028            
-----------------------------+----------------------------------------------
 #6028 suggested warning on cyclic unimplemented defaults. This doesn't
 work for the reasons mentioned there, among others (also e.g.
 [http://hackage.haskell.org/packages/archive/base/4.6.0.0/doc/html
 /Control-Applicative.html#g:2 `Alternative`] has mutually recursive `some`
 and `many` methods, which shouldn't be warned about). Figuring out when to
 warn automatically seems hard.

 But Haskell already has an ad-hoc mechanism for specifying which methods
 need to be implemented: A "minimal complete definition" specified in the
 comments of almost every class definition that has optional methods.
 Unfortunately comments are aren't compiler-checked. It seems that the
 simplest solution would be to specify these in a way that the compiler can
 understand.

 The obvious approach is to add a pragma for it in the class definition. In
 particular, one could write a pragma for each "minimal set" of
 definitions, and the compiler could warn if none of them are implemented
 (and suggest which methods to implement). This lets us keep the
 convenience of default method implementations without losing safety.
 Without any pragmas, the compiler could fall back to the set "all methods
 without defaults", which is what it uses now.

 It might look something like this:

 {{{
 class Functor m => Monad m where
   return :: a -> m a

   (>>=) :: m a -> (a -> m b) -> m b
   m >>= f = join (fmap f m)

   join :: m (m a) -> m a
   join m = m >>= id

   {-# MINIMAL return, join #-}
   {-# MINIMAL return, (>>=) #-}

 class Eq a where
   (==), (/=) :: a -> a -> Bool
   x == y = not (x /= y)
   x /= y = not (x == y)
   {-# MINIMAL (==) #-}
   {-# MINIMAL (/=) #-}
 }}}

-- 
Ticket URL: <http://hackage.haskell.org/trac/ghc/ticket/7633>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler