[GHC] #10086: Disambiguate type variables using dictionaries

[GHC]

#10086: Disambiguate type variables using dictionaries
-------------------------------------+-------------------------------------
              Reporter:  jstolarek   |             Owner:
                  Type:  feature     |            Status:  new
  request                            |         Milestone:
              Priority:  normal      |           Version:  7.11
             Component:  Compiler    |  Operating System:  Unknown/Multiple
  (Type checker)                     |   Type of failure:  Other
              Keywords:              |        Blocked By:
          Architecture:              |   Related Tickets:
  Unknown/Multiple                   |
             Test Case:              |
              Blocking:              |
Differential Revisions:              |
-------------------------------------+-------------------------------------
 Consider this code:

 {{{#!hs
 type family TF t
 type instance TF (Maybe a) = Maybe a

 class Id f where
     idTF :: TF f -> TF f

 instance Id (Maybe a) where
     idTF x = x

 g = idTF (Just 'c')
 }}}

 Definition of `g` is rejected due to ambiguity:

 {{{
 Couldn't match expected type ‘TF f0’ with actual type ‘Maybe Char’
 The type variable ‘f0’ is ambiguous
 Relevant bindings include g :: TF f0 (bound at T6018.hs:18:1)
 In the first argument of ‘idTF’, namely ‘(Just 'c')’
 In the expression: idTF (Just 'c')
 }}}

 There are two ways to proceed:

 1. Introduce `Proxy` argument and disambiguate `f` with explicit type
 annotation.

 2. With injective type families (coming Real Soon Now) we can declare `TF`
 as injective and this code will compile. That obviously won't work if `TF`
 is not injective.

 I think we could do better here. `idTF` is a type class function and when
 it is called GHC uses a concrete implementation from a dictionary. But
 notice that if we have the dictionary we could equally well use it to
 disambiguate `f`. In this example we call `idTF` with a `Maybe Char`
 argument, which means we are using `Id (Maybe a)` instance. Knowing this
 we could infer that `f` is `Maybe a`.

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