[GHC] #11715: Constraint vs *

[GHC]

#11715: Constraint vs *
-------------------------------------+-------------------------------------
        Reporter:  bgamari           |                Owner:
            Type:  bug               |               Status:  new
        Priority:  high              |            Milestone:  8.2.1
       Component:  Compiler (Type    |              Version:  8.0.1-rc1
  checker)                           |
      Resolution:                    |             Keywords:  Typeable
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:                    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by goldfire):

 Flipping back through this ticket, I see that my new comment:47 seems to
 appear out of the blue. I also see @int-index advocating for dropping the
 distinction between `Constraint` and `Type` entirely.... but a quick skim
 doesn't show others agreeing with this direction of travel. I ''do'' think
 @int-index's approach (allowing `Int => ...`) is plausible, but I still am
 not convinced it's a good idea. If it's the ''only'' way to solve the
 original ticket, then perhaps it would be worth revisiting, but I'm not
 keen to start down that road.

 @int-index, you have argued well for your cause, but I, personally, need
 to see others agree with you and want these features before getting on
 board. It's not a matter of soundness or implementation, but of the kind
 of features and properties we wish Haskell to have.

 Responding more directly to comment:50:

 1. That's true I suppose. We could also say, though, that `RuntimeRep`
 tells us the calling convention, not just the runtime representation.
 Constraints and regular types ''do'' have different calling conventions in
 Haskell code.

 2. This goes back to my paragraphs above, in this comment.

 3. `reflection` is an abuse of GHC, using an undocumented feature of the
 implementation. I do understand that many people use this undocumented
 feature, and so we could look at a way of saving `reflection`, but I don't
 see this as an argument against my proposal. We could always come up with
 another way to support `reflection` without newtype-classes.

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