just as a note, the new version of DrIFT (which i now maintain)
has the ability to derive 'Typeable', which is used for the Strafunski
generic programming representation (which it also can derive..)
the homepage is now at 'http://repetae.net/john/computer/haskell/DrIFT'
I sort of fudged the Typeable derivation rule, if someone wanted to
robustify it, i would gladly accept patches.
I dont think that 'unsafe' need be added to Typeable since hopefully
people will never be creating instances themselves, with the instances
hidden behind DrIFT and/or 'deriving' clauses then they can be assured
of being correct (well... as correct as anything is :)) . Typeable
itself is not inherently unsafe, it is broken implementations of it
which are.
John
On Sun, Jun 02, 2002 at 12:11:49PM +1000, Andre Pang wrote:
> On Sat, Jun 01, 2002 at 07:56:39PM +0100, Alastair Reid wrote:
>
> > Your Typeable instance looks like this:
> >
> > > instance Typeable FootnoteData where
> > > typeOf _ = mkAppTy (mkTyCon "FootnoteData") [typeOf ("Foo" :: String), typeOf
>(7 :: Int)]
> >
> > This should be written:
> >
> > > instance Typeable FootnoteData where
> > > typeOf _ = mkAppTy fdtc [typeOf ("Foo" :: String), typeOf (7 :: Int)]
> > >
> > > fdtc = mkTyCon "FootnoteData"
> >
> > That is, the TyCon definition has to be a CAF (i.e., a top level
> > definition with no arguments). The reason is somewhat grubby but
> > comes down to 'things go much faster if you do this').
>
> I see, thanks. I'll try to update the documentation with this
> note.
>
> > While we're at it, I'd like to repeat my request that the word
> > 'unsafe' be made part of the classname Typeable or the method name
> > typeOf. The reason is that a badly written Typeable definition can
> > break typesafety. Here's a superficially plausible but broken
> > instance for IO which demonstrates it
> >
> > > instance Typeable (IO a) where
> > > typeOf _ = mkAppTy iotc []
> > >
> > > iotc = mkTyCon "IO"
> >
> > With this definition
> >
> > typeOf (return 1 :: IO Int) == typeOf (return () :: IO ())
> >
> > and so you can coerce back and forth between these types using
> > from/toDynamic.
>
> Ahem, this is what I actually did to get my Dynamic types working
> in the first place (oops) :). mkAppTy was being given an empty
> list of TypeReps, since I was confused about how to generate
> those TypeReps.
>
> It would be much neater if you could do something like
>
> instance Typeable Foo where
> typeOf _ = mkAppTy constructor [Char, Char, Int]
>
> This is what I expected the Dynamic module interface would look
> like, since when do you "typeOf 'a'" in GHCI, it does reply with
> "Char".
>
> I guess a possible workaround would be something like
>
> charT = typeOf ('a' :: Char)
>
> intT = typeOf (69 :: Int)
>
> instance Typeable Foo where
> typeOf _ = mkAppTy constructor [charT, charT, intT]
>
> which is what I'm doing right now. Maybe these type definitions
> can go into the Dynamic module itself?
>
>
> --
> #ozone/algorithm <[EMAIL PROTECTED]> - b.sc (comp. sci+psych)
> _______________________________________________
> Glasgow-haskell-users mailing list
> [EMAIL PROTECTED]
> http://www.haskell.org/mailman/listinfo/glasgow-haskell-users
>
--
---------------------------------------------------------------------------
John Meacham - California Institute of Technology, Alum. - [EMAIL PROTECTED]
---------------------------------------------------------------------------
_______________________________________________
Glasgow-haskell-users mailing list
[EMAIL PROTECTED]
http://www.haskell.org/mailman/listinfo/glasgow-haskell-users
