Can we simplify Dynamic?

[David Feuer]

Currently,

data Dynamic = Dynamic TypeRep Obj
               deriving Typeable
where
type Obj = Any

As a result, all of the operations must be implemented "by hand" using
unsafeCoerce. The more obvious representation these days would seem to be

data Dynamic where
  Dynamic :: Typeable a => a -> Dynamic

Most of the operations then become trivial applications of Typeable
functions.    The only exceptions seem to be  dynApply and dynApp. That
there are exceptions strikes me as quite unfortunate. The easiest fix is
inspired by the fact that Data.Dynamic uses

funResultTy :: TypeRep -> TypeRep -> Maybe TypeRep

from Data.Typeable to decide whether to coerce. It seems reasonable to add
a more informative version, something like

applyTypeable :: (Typeable f, Typeable a) =>
   proxy f ->
   proxy a ->
   (forall b . (Typeable b, f ~ (a -> b)) => r) ->
   Maybe r

On the other hand, it would be really cool if there were some more general
way to get type-level information out of Typeable instances, pattern
matching on the type constructors.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/libraries/attachments/20150928/13d4b8ce/attachment.html>