{-
  From: Marc van Dongen <dongen@cs.ucc.ie>
  Date: Sat, 31 May 1997 19:57:46 +0100 (BST)

   panic! (the `impossible' happened):
           tcLookupTyVar:a_r6F

   Please report it as a compiler bug to glasgow-haskell-bugs@dcs.gla.ac.uk.


If the instance definition for (*) at the end of this toy module
is replaced by the definition that is commented, this all compiles
fine. Strange, because the two implementations are equivalent modulo
the theory {(*) = multiply}.

Remove the `multiply :: a -> a -> a' part, and it compiles without
problems.


SPJ note: the type signature on "multiply" should be
        multiply :: Group a => a -> a -> a

-}

module ShouldSucceed( Group, Ring ) where

import qualified Prelude( Ord(..), Eq(..), Num(..) )
import Prelude hiding( Ord(..), Eq(..), Num(..) )

class Group a where
  compare     :: a -> a -> Prelude.Ordering
  fromInteger :: Integer -> a
  (+) :: a -> a -> a
  (-) :: a -> a -> a
  zero :: a
  one  :: a
  zero = fromInteger 0
  one  = fromInteger 1

-- class (Group a) => Ring a where
-- (*) :: a -> a -> a
-- (*) a b =
--                  case (compare a zero) of
--                    EQ -> zero
--                    LT -> zero - ((*) (zero - a) b)
--                    GT -> case compare a one of
--                            EQ -> b
--                            _  -> b + ((*) (a - one) b)

class (Group a) => Ring a where
  (*) :: a -> a -> a
  (*) a b = multiply a b
          where multiply :: Group b => b -> b -> b
                multiply a b
                  = case (compare a zero) of
                      EQ -> zero
                      LT -> zero - (multiply (zero - a) b)
                      GT -> case compare a one of
                              EQ -> b
                              _  -> b + (multiply (a - one) b)