[Haskell-cafe] how would this be done? type classes? existential
lennart at augustsson.net
Thu Mar 16 07:39:25 EST 2006
You can't give unRs a type.
What I usually do in this situation is to make the Rs type
a Resource too.
instance Resource Rs where
resourceName (Rs a) = resourceName a
resourceAdvance (Rs a) = Rs (resourceAdvance a)
resourceStarved (Rs a) = resourceStarved a
resourceSpend (Rs a) i = Rs (resourceSpend a i)
resourceEarn (Rs a) i = Rs (resourceEarn a i)
And then you export Rs (with some mkRs=Rs if you export
it abstractly) and the Resource class. Then you can
use Rs to make your heterogeneous lists and class ops
to manipulate them.
Matthias Fischmann wrote:
> 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
> 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 :-)?
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
More information about the Haskell-Cafe