[Haskell-cafe] how would this be done? type classes? existential types?

[Lennart Augustsson]

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.

	-- Lennart

Matthias Fischmann wrote:
> 
> 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
> 
> 
> ------------------------------------------------------------------------
> 
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe