[GHC] #8214: 'Untouchable' error in list comprehension

[GHC]

#8214: 'Untouchable' error in list comprehension
----------------------------------------------+----------------------------
        Reporter:  MartijnVanSteenbergen      |            Owner:
            Type:  bug                        |           Status:  closed
        Priority:  normal                     |        Milestone:
       Component:  Compiler (Type checker)    |          Version:  7.6.3
      Resolution:  invalid                    |         Keywords:
Operating System:  Unknown/Multiple           |     Architecture:
 Type of failure:  GHC rejects valid program  |  Unknown/Multiple
       Test Case:                             |       Difficulty:  Unknown
        Blocking:                             |       Blocked By:
                                              |  Related Tickets:
----------------------------------------------+----------------------------
Changes (by simonpj):

 * status:  new => closed
 * resolution:   => invalid


Comment:

 The error message is obscure (I'm sorry about that) but it's right.

 Consider these two variants
 {{{
 foo1 = map (\X -> ()) []

 foo2 = map f []
     where
        f X = ()
 }}}
 (Incidentally, in HEAD it makes no difference whether or not `foo` has a
 signature `foo :: Bool`, nor `foo1` or `foo2`.)

 It's easiest to think about `foo2`.  What is `f`'s type?  Well, you say,
 `f :: X a -> ()`. But suppose X had been defined
 {{{
 data X1 a where X :: X ()
 }}}
 Then `f` could also have type `f :: X a -> a`.  This is the classic
 example of not having most general types for GADTs.  GHC isn't clever
 enough to exploit the fact that in the particular example you give there
 is only one type; the
 [http://haskell.org/haskellwiki/Simonpj/Talk:OutsideIn Outside-In
 algorithm] rejects `f`.

 In `foo` the question is "what is the type of `[ () | X <- [] ]`.  If we
 had type `X1` then it could be `[()]` or `forall a. [a]`.  In this case it
 doesn't matter what the answer is, but if there was overloading involved
 it might.

 Solution: tell GHC which type the list has, thus:
 {{{
 foo = null ([ () | X <- [] ] :: [()])
 }}}
 This looks a bit stupid in this very cut-down example, but I suspect it'd
 make more sense in a real program.

 Simon

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