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 <fis at wiwi.hu-berlin.de>, haskell-cafe at haskell.org> From: "Geest, G. van den" <G.vandenGeest at students.uu.nl>
> 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 at haskell.org on behalf of Matthias Fischmann
> Sent: Thu 3/16/2006 12:57 PM
> To: haskell-cafe at 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 at haskell.org on behalf of Matthias Fischmann
> Sent: Thu 3/16/2006 12:57 PM
> To: haskell-cafe at 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 at 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
-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 189 bytes
Desc: Digital signature
Url : http://www.haskell.org//pipermail/haskell-cafe/attachments/20060316/a637d750/attachment.bin