[GHC] #9429: Alternative to type family Any

[GHC]

#9429: Alternative to type family Any
-------------------------------------+-------------------------------------
              Reporter:  mboes       |            Owner:
                  Type:  feature     |           Status:  new
  request                            |        Milestone:
              Priority:  normal      |          Version:  7.9
             Component:  Compiler    |         Keywords:
            Resolution:              |     Architecture:  Unknown/Multiple
      Operating System:              |       Difficulty:  Unknown
  Unknown/Multiple                   |       Blocked By:
       Type of failure:              |  Related Tickets:  9097, 9380
  None/Unknown                       |
             Test Case:              |
              Blocking:              |
Differential Revisions:              |
-------------------------------------+-------------------------------------

Comment (by mboes):

 * If I declare `MyAny`, then as goldfire pointed out, it can only have a
 kind of the form `-> *`. As it is, if rank1dynamic uses a datatype of
 fixed kind, as for `MyAny`, then I will need many, many of those
 datatypes, defined a priori. To handle multiple type variables, as in the
 example given previously, I need a family `MyAny1`, `MyAny2`, `MyAny3`,
 etc... Along an orthogonal dimension, to handle multiple kinds, I will
 need multiple `MyAny`s, i.e. `MyAny1_s`, `MyAny1_ss`, `MyAny2_s`,
 `MyAny2_ss`, etc (where `MyAny_s` is of kind `*`, `MyAny_ss` is o f kind
 `* -> *`, etc). And even with that proliferation of datatypes, I still
 wouldn't be able to handle type variables of user-defined kind, or even of
 `Constraint` kind.

  The beauty of the `Any` type in this use case is that because it inhabits
 all kinds, I can use `Any` to instantiate the first type variable, `Any
 Any` to instantiate the second, `Any Any Any` to instantiate the third,
 etc. Moreover, I can still use those no matter the kinds of the type
 variables. I only need a single datatype, to serve as a proxy for an
 arbitrary number of type variables, each of arbitrary kind.

 * A larger end-to-end example will take a little while to write, but I'll
 try to do so tonight. At this point, if it can clarify things, let's just
 say that any message that gets sent over the wire needs an accompanying
 `TypeRep` of its type in order for the receiver to make sense of the
 payload. Sometimes the payload is a function, and sometimes that function
 is polymorphic and can be called by the receiver at any argument type. We
 can't represent polymorphic types directly, so for a function of type
 `forall a. a -> a`, we send the `TypeRep` for `Any -> Any` instead.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/9429#comment:25>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler