Opened 14 years ago

Closed 14 years ago

Last modified 48 years ago

#189 closed bug (Fixed)

Malformed Predicate w/ Template Haskell

Reported by: jcast Owned by: nobody
Priority: normal Milestone:
Component: Compiler (Type checker) Version: 6.0.1
Keywords: Cc:
Operating System: Architecture:
Type of failure: None/Unknown Test Case:
Blocked By: Blocking:
Related Tickets: Differential Rev(s):
Wiki Page:


The following two modules:

 --- Cut ---

module ScratchTemplates where

import Language.Haskell.THSyntax

newtype Interaction a = Interaction a deriving Show

ret = Interaction

instance Monad Interaction where
  return = Interaction
  Interaction x >>= f = f x

instance Functor Interaction where
  fmap f x = x >>= return . f

interactionT t = tcon (TconName "Interaction") `tapp` t

class Flatten a b | a -> b where
  flatten :: a -> b

flattenT :: TypQ -> TypQ -> TypQ
flattenT t t' = tvar "Flatten" `tapp` t `tapp` t

baseType t = sequence [
  inst (return []) (flattenT t t)
       [val (pvar "flatten") (normal (var "id")) []],
  inst (return []) (flattenT (interactionT t)
(interactionT t))
       [val (pvar "flatten") (normal (var "id")) []]]

instance Flatten a b =>
         Flatten (Interaction (Interaction a))
(Interaction b) where
  flatten a = a >>= id >>= return . flatten

module Main where

import Monad
import ScratchTemplates
import Language.Haskell.THSyntax

$(baseType (tcon (Tuple 0)))

instance Flatten String String where
  flatten a = a

instance Flatten (Interaction String) (Interaction
String) where
  flatten a = a

instance Flatten b c => Combine String b (String, c) where
  combine a b = liftM2 (,) a (fmap flatten b)

instance Flatten Int Int where
  flatten a = a

class Combine a b c | a b -> c where
  combine :: Interaction a -> Interaction b ->
Interaction c

instance Combine () b b where
  combine a b = b

instance Flatten b c => Combine Int b (Int, c) where
  combine a b = do
    x <- a
    y <- fmap flatten b
    return (x, y)

instance (Flatten b c, Combine a c d) =>
          Flatten (Interaction a, Interaction b)
(Interaction d) where
  flatten (a, b) = combine a (fmap flatten b)

main = main

 --- Cut here ---

loaded into ghci -fglasgow-exts produce the following
error message:

Compiling ScratchTemplates ( ScratchTemplates.hs,
interpreted )
Compiling Main             ( scratch.hs, interpreted )
ghc-6.0.1: panic! (the `impossible' happened, GHC
version 6.0.1):
	Malformed predicate

Please report it as a compiler bug to,

Change History (2)

comment:1 Changed 14 years ago by simonpj

Logged In: YES 

This bug turns out to be simply that Template Haskell is only 
set up for Haskell 98, whereas Jon Cast wants to manipulate 
multi-parameter type clases.

Should we add multi-param type classes to THSyntax?  Does 
anyone feel like doing it?  It's a fairly routine matter, but it 
does mean changing the data type.  (Another reason to use 
bracket syntax!)

comment:2 Changed 14 years ago by simonpj

Status: assignedclosed
Logged In: YES 

Fixed in the HEAD
Note: See TracTickets for help on using tickets.