Restricted Types and Infinite Loops

[Simon David Foster]

Hi,

(I've attached the full code for this problem)

First I'll explain the problem description, I have two class ClassA and
ClassB, the former has two parameters and the latter has one. The second
parameter of ClassA is constrained by ClassB.

class ClassB a where
class ClassB b => ClassA a b where

Because I wish to effectively pass the context of ClassA around, I need
to create a pair of dictionary types (as in Restricted Data Types in
Haskell, Hughes 99), one to represent ClassA (DictClassA) and one to
represent ClassB (DictClassB). DictClassA also contains a term of type
DictClassB since ClassA is a subclass of ClassB. I should then be able
to call all the functions of ClassB via the appropriate term of
DictClassA, like so (assuming we want to use func2);

*Test> func2D (classBD (dict::DictClassA Int String)) "hello"
"bye"

So far so good, but now suppose I want Class A to have the further
constraint

class (Data (DictClassA a) b, ClassB b) => ClassA a b where

(so as to make ClassA a subclass of Data)

If we now try and do

*Test> func2D (classBD (dict::DictClassA Int String)) "hello"

We go into an infinite loop. Why? The expression still type-checks ok
and I can't see what it is trying to do. All the functions of ClassA can
be accessed ok, but not ClassB. 

*Test> funcD ((dict::DictClassA Int String)) "hello" 5
"hello"

Is it something to do with ClassB only having one parameter?

I'm running GHC 20041231.

-Si.

-- 
Simon David Foster <s.d.f at btinternet.com>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: Test.hs
Type: text/x-haskell
Size: 1100 bytes
Desc: not available
Url : http://www.haskell.org//pipermail/glasgow-haskell-users/attachments/20050127/b525462d/Test.bin