deriving Typeable

[Simon Peyton-Jones]

| newtype Y e = Y { unY :: (e (Y e)) }
|     deriving(Data,Typeable,Show,Read,Eq)
| 
| gives
| E.hs:64:
|     Can't make a derived instance of `Typeable (Y e)'
|     (`Y' is parameterised over arguments of kind other than `*')
|     When deriving instances for type `Y'
| 
| Is there any way around this limitation other than manually expanding
Y
| everywhere I want to use it (which I really don't want to do)? Is the
| limitation inherent to the way Typeable works, or is it just that no
one
| has implemented it yet?

You'll want to read "Scrap more boilerplate" in my home page, for an
account of the Typeable classes.  In this case you can make Y Typeable
easily enough, like this (compile with -fglasgow-exts to make the scoped
type variable work):

newtype Y e = Y { unY :: (e (Y e)) } 

instance Typeable1 e => Typeable (Y e) where
   typeOf _ = mkTyConApp yTc [typeOf1 (undefined :: e ())]

yTc :: TyCon
yTc = mkTyCon "Main.Y"


This could be automated, but there's always an arbitrary limit on the
complexity of the kinds of the arguments -- until we get kind
polymorphism, that is!

Making Y an instance of Data is harder.  I'm not sure how to do that.
You'd need something like
	instance Data1 e => Data (Y e)
and we don't have a Data1 class yet.  

Simon