[GHC] #16146: Trivial partial type signature kills type inference in the presence of GADTs

[GHC]

#16146: Trivial partial type signature kills type inference in the presence of
GADTs
-------------------------------------+-------------------------------------
        Reporter:  goldfire          |                Owner:  (none)
            Type:  bug               |               Status:  new
        Priority:  normal            |            Milestone:
       Component:  Compiler          |              Version:  8.6.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 simonpj):

 It's not obvious what to do here.  Consider
 {{{
 f :: Int -> Int -> Int
 f x = (...blah...) :: forall a. a->a
 }}}
 Here the expression signature insists that `(..blah..)` has type `forall
 a. a->a` which is ''more general than'' the `Int -> Int` imposed by the
 signature for `f`.

 Now imagine a partial version of this:
 {{{
 f :: Int -> Int -> Int
 f x = (...blah...) :: forall a. a -> _
 }}}
 The same thing applies.  Because the partial signature may be more general
 than the expected type from "outside", it's hard to take advantage of the
 latter until we've worked out what the fleshed-out partial signature is
 (ie. in this case perhaps `forall a. a->a`).  Only then can we instantiate
 it to see if it is more general than `Int -> Int`.

 So while `(e :: _)` may be a no-op, that is not true of other partial type
 signatures.  Short of making it a magic, ad-hoc special case, I'm not sure
 how to do better.  Perhaps one could make a special case when the partial
 signature had no quantification.  But it sounds smelly to me.

 Why not just remove the `:: _`?  It's not doing anything useful.

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