[GHC] #14547: Wrong warning by -Wincomplete-patterns

[GHC]

#14547: Wrong warning by -Wincomplete-patterns
-------------------------------------+-------------------------------------
        Reporter:  YoshikuniJujo     |                Owner:  (none)
            Type:  bug               |               Status:  patch
        Priority:  low               |            Milestone:
       Component:  Compiler          |              Version:  8.2.1
      Resolution:                    |             Keywords:  incomplete-
                                     |  patterns OverloadedLists,
                                     |  PatternMatchWarnings TypeFamilies
Operating System:  Linux             |         Architecture:  x86
 Type of failure:  Incorrect         |            Test Case:
  error/warning at compile-time      |  deSugar/should_compile/T14547
      Blocked By:                    |             Blocking:
 Related Tickets:                    |  Differential Rev(s):  Phab:D4624
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by sighingnow):

 Replying to [comment:7 simonpj]:

 Thanks for your explanation and analysis, Simon. I agree to add a note to
 explain this condition. Now I have some other thought with the `ListPat`
 case of `translatePat`.

 > You are checking that the function actually has type [t1] -> [t2], where
 normalise t1 = normalise t2.

 I think in fact we don't need to do the check. For `ListPat x lpats
 elem_ty (Just (pat_ty, _to_list))`, we know the `_to_list` have type:

 {{{
 toList :: l -> [Item l]
 }}}

 If we know the `pat_ty` (the `l` in toList's signature) is `[a]` (the List
 type), then we can conclude that `Item l = a`, in other words,
 `norm_elem_ty = norm_e_ty`. Because in `instance IsList [a]`, we have
 `type (Item [a]) = a`. Although we can give an instance IsList [Int] (more
 specific than the default IsList [a]), we can't overwrite the type family
 instance.

 The original comment says:

 > {{{
 > -- We have to ensure that the element types are exactly the same.
 > -- Otherwise, one may give an instance IsList [Int] (more specific than
 > -- the default IsList [a]) with a different implementation for `toList'
 > }}}

 However we can't achieve this goal without check the type of `_to_list`.
 In practice, we almost never define more specific IsList instance like
 `instance IsList [Int]`, we don't need to concern that case. So we can
 simplify the code as

 {{{#!hs
   ListPat x lpats elem_ty (Just (pat_ty, _to_list))
     | Just e_ty <- splitListTyConApp_maybe pat_ty
     -> translatePat fam_insts (ListPat x lpats e_ty Nothing)
     | otherwise
     -> mkCanFailPmPat pat_ty
 }}}

 Or should be check whether the type of `_to_list` is `[a] -> [a]` (the
 most general type) ? I don't think it's necessary for practical Haskell
 code. **I'm not sure if I understand this correctly.**

 Another silly question is that I still can't see why we need to concern
 about the view pattern for exhaustiveness checking of overloaded list. I
 think the `toList` and the `[a]` instance of `IsList` are different with
 ordinary view functions in view pattern. I will mention this in the note.

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