[Haskell-cafe] Re: Re: type class question

[Jules Bean]

Peter Padawitz wrote:
>>> So the fundep would solve the problem.
> 
> But, actually, it doesn't :-(

But actually, it does!

Ben Franksen's answer from yesterday compiles fine for me if I add the 
missing fundep, block -> command.

Your original code compiles without error, given the fundep. Exact code 
I compiled attached at the bottom of this document. You may have to 
repair long lines!

Incidentally, I question why the "compFoo" are methods. Why not just 
make them polymorphic functions? They don't look like you expect 
instances to change them. The code continues to compile if I make them 
functions and amend their signatures as required.

Jules

{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies #-}

type Block   = [Command]
data Command = Skip | Assign String IntE | Cond BoolE Block Block | Loop 
BoolE Block
data IntE    = IntE Int | Var String | Sub IntE IntE | Sum [IntE] | Prod 
[IntE]
data BoolE   = BoolE Bool | Greater IntE IntE | Not BoolE

class Java block command intE boolE | block -> command, command -> intE, 
intE -> boolE, boolE -> block
   where block_ :: [command] -> block
         skip :: command
         assign :: String -> intE -> command
         cond :: boolE -> block -> block -> command
         loop :: boolE -> block -> command
         intE_ :: Int -> intE
         var :: String -> intE
         sub :: intE -> intE -> intE
         sum_ :: [intE] -> intE
         prod :: [intE] -> intE
         boolE_ :: Bool -> boolE
         greater :: intE -> intE -> boolE
         not_ :: boolE -> boolE
         compBlock :: Block -> block
         compBlock = block_ . map compCommand
         compCommand :: Command -> command
         compCommand Skip           = skip
         compCommand (Assign x e)   = assign x (compIntE e)
         compCommand (Cond be cs cs') = cond (compBoolE be) (compBlock 
cs) (compBlock cs')
         compCommand (Loop be cs)    = loop (compBoolE be) (compBlock cs)
         compIntE :: IntE -> intE
         compIntE (IntE i)   = intE_ i
         compIntE (Var x)    = var x
         compIntE (Sub e e') = sub (compIntE e) (compIntE e')
         compIntE (Sum es)   = sum_ (map compIntE es)
         compIntE (Prod es)  = prod (map compIntE es)
         compBoolE :: BoolE -> boolE
         compBoolE (BoolE b)      = boolE_ b
         compBoolE (Greater e e') = greater (compIntE e) (compIntE e')
         compBoolE (Not be)       = not_ (compBoolE be)