yes, that helps. also thanks to lennart and chris, i think i got it working. ... and have more questions: is there any difference between these two? if they are equivalent, why the two different ways to say it? data X where X :: (Resource a) => a -> X data Y = forall a . (Resource a) => Y a and now it gets interesting: i need instances for Rs on Show, Read, Eq, Ord. Show is very simple, but Read? if i look at a string, it's already to late to decide which type is has, right? same problem with Eq: i could first check whether the rsNames match and if so, go ahead and compare the two resource class instances inside Rs. but the type system would never know whether this is safe or not. solution: add methods rsEq, rsOrd to the Resource class and use them to instantiate Eq, and Ord respectively. this is not pretty, but not particularly ugly either, and it works. but this still doesn't work for Read, right? m. On Thu, Mar 16, 2006 at 01:37:36PM +0100, Geest, G. van den wrote:

To: Matthias Fischmann , haskell-cafe@haskell.org From: "Geest, G. van den" Date: Thu, 16 Mar 2006 13:37:36 +0100 Subject: RE: [Haskell-cafe] how would this be done? type classes? existentialtypes?

Try using a GADT:

data Rs where Rs :: Resource a => a -> Rs

class Resource a where resourceName :: a -> String

instance Resource String where resourceName x = "String"

instance Resource Int where resourceName x = "Int"

resName (Rs x) = resourceName x

resNames = map resName

test = resNames [Rs "Hi", Rs (1::Int) ]

The most important observations is that when pattern matching on (Rs x) we cannot make any assumptions about x, except using the class members of Resource.

We hope this will help you,

Gerrit (and the rest of the ST-lab)

-----Original Message----- From: haskell-cafe-bounces@haskell.org on behalf of Matthias Fischmann Sent: Thu 3/16/2006 12:57 PM To: haskell-cafe@haskell.org Subject: [Haskell-cafe] how would this be done? type classes? existentialtypes?

hi,

this is one of those situations that always make scheme and perl hackers laugh at me: i have written a piece of code that is intuitively clear, and now i am trying to turn it into something that compiles. and here it goes.

i have a type class that looks something like this:

class Resource a where resourceName :: a -> String resourceAdvance :: a -> a resourceStarved :: a -> Bool resourceSpend :: a -> Int -> a resourceEarn :: a -> Int -> a

resource types are rice, crude oil, pizza, software code, and so on. they all have a different internal structure and the same abstract interface, that's why i have defined this type class.

now i want to create a list of a type similar to

[r1, r2, r3] :: (Resource a) => [a]

but with r1 being pizza, r2 being crude oil, and so on. my first idea was this:

data Rs = forall a . (Resource a) => Rs a unRs (Rs a) = a rsName :: Rs -> String rsName = resourceName . unRs ...

and then export Rs as an abstract data type. this would allow for lists of type [Rs], which is exactly what i want.

but what is the type of unRs? or better: can i make it type at all? and isn't this solution a little redundant and verbose? should i do it like in the example for existentially quantified types in the ghc manual?

http://www.haskell.org/ghc/docs/latest/html/users_guide/type-extensions.html

but wouldnt't the code become really messy? or should i do the type class and instances, and then do Rs the existentially quantified way, with all class methods arguments to the Rs constructor? or is there a completely different way to do this (besides using scheme or perl :-)?

thanks, matthias

-----Original Message----- From: haskell-cafe-bounces@haskell.org on behalf of Matthias Fischmann Sent: Thu 3/16/2006 12:57 PM To: haskell-cafe@haskell.org Subject: [Haskell-cafe] how would this be done? type classes? existentialtypes?

hi,

this is one of those situations that always make scheme and perl hackers laugh at me: i have written a piece of code that is intuitively clear, and now i am trying to turn it into something that compiles. and here it goes.

i have a type class that looks something like this:

class Resource a where resourceName :: a -> String resourceAdvance :: a -> a resourceStarved :: a -> Bool resourceSpend :: a -> Int -> a resourceEarn :: a -> Int -> a

resource types are rice, crude oil, pizza, software code, and so on. they all have a different internal structure and the same abstract interface, that's why i have defined this type class.

now i want to create a list of a type similar to

[r1, r2, r3] :: (Resource a) => [a]

but with r1 being pizza, r2 being crude oil, and so on. my first idea was this:

data Rs = forall a . (Resource a) => Rs a unRs (Rs a) = a rsName :: Rs -> String rsName = resourceName . unRs ...

and then export Rs as an abstract data type. this would allow for lists of type [Rs], which is exactly what i want.

but what is the type of unRs? or better: can i make it type at all? and isn't this solution a little redundant and verbose? should i do it like in the example for existentially quantified types in the ghc manual?

http://www.haskell.org/ghc/docs/latest/html/users_guide/type-extensions.html

but wouldnt't the code become really messy? or should i do the type class and instances, and then do Rs the existentially quantified way, with all class methods arguments to the Rs constructor? or is there a completely different way to do this (besides using scheme or perl :-)?

thanks, matthias

-- Institute of Information Systems, Humboldt-Universitaet zu Berlin web: http://www.wiwi.hu-berlin.de/~fis/ e-mail: fis@wiwi.hu-berlin.de tel: +49 30 2093-5742 fax: +49 30 2093-5741 office: Spandauer Strasse 1, R.324, 10178 Berlin, Germany pgp: AD67 CF64 7BB4 3B9A 6F25 0996 4D73 F1FD 8D32 9BAA