[GHC] #13733: Simplify constraints on RULES LHS

[GHC]

#13733: Simplify constraints on RULES LHS
-------------------------------------+-------------------------------------
        Reporter:  nomeata           |                Owner:  (none)
            Type:  feature request   |               Status:  new
        Priority:  normal            |            Milestone:
       Component:  Compiler          |              Version:  8.3
      Resolution:                    |             Keywords:
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 nomeata):

 Oh, yes, the library author can! But someone downstream does not have the
 ability to change the
 {{{
 instance Eq [a] where
   x == y = rhs
 }}}
 to the above format.

 Similarly if they want to write
 {{{
 data T = … deriving Show
 }}}

 In both cases I would consider consider your approach an work-around that,
 well, works around the fact that an instance method does not have a
 Haskell-adressable name.

 So what am I proposing?… now, before I propose something, let me phrase
 clearly what I want to achieve: **I want to write rules that apply to an
 instance method.**

 (Your approach does not quite achieve that. What it does achieve is that I
 no longer want to address instance methods, as I can now adress `eqT`,
 which works fine in many cases. But this does not work if the instance
 declaration is out of my control.)


 There may be several ways of achieving this goal. One way would be:
 **Simplify constraints of rules with the current instances and apply
 class-op rules on the LHS of rules.**

 This way, the user’s rule
 {{{
 forall (xs :: [Integer]). xs == xs = True
 }}}
 gets desugared to
 {{{
     forall (xs_a1Hd :: [Integer]).
       == @ [Integer] ($fEq[] @ Integer $fEqInteger) xs_a1Hd xs_a1Hd
       = GHC.Types.True
 }}}
 (compare that with the rule above, which has a pattern variable $dEq_a1Jv
 for the `Eq [Integer]` dictionary), and then gentle simplification
 (including class-op) on the left turns this into
 {{{
   forall (xs_a1Hd :: [Integer]).
     GHC.Classes.$fEq[]_$c== @Integer $fEqInteger xs_a1Hd xs_a1Hd
       = GHC.Types.True
 }}}
 which – how convenient – is precisely the code we want to match, in the
 form the simplifier puts it.

 This machinery should allow the rule author to address any concrete
 instance method, in his module or an imported module, by using the class
 method with a sufficiently precise type.

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