[GHC] #14605: Core Lint error

20 Dec 2017

      #14605: Core Lint error
-------------------------------------+-------------------------------------
           Reporter:  Iceland_jack   |             Owner:  (none)
               Type:  bug            |            Status:  new
           Priority:  normal         |         Milestone:
          Component:  Compiler       |           Version:  8.2.2
           Keywords:  TypeInType,    |  Operating System:  Unknown/Multiple
  DeferredTypeErrors                 |
       Architecture:                 |   Type of failure:  None/Unknown
  Unknown/Multiple                   |
          Test Case:                 |        Blocked By:
           Blocking:                 |   Related Tickets:
Differential Rev(s):                 |         Wiki Page:
-------------------------------------+-------------------------------------
 This piece of code fails when run with `ghci -ignore-dot-ghci -fdefer-
 type-errors -dcore-lint bug.hs`, maybe same as my previous #14584.

 {{{#!hs
 {-# Language DerivingStrategies #-}
 {-# Language GeneralizedNewtypeDeriving #-}
 {-# Language InstanceSigs #-}
 {-# Language KindSignatures #-}
 {-# Language PolyKinds #-}
 {-# Language ScopedTypeVariables #-}
 {-# Language TypeApplications #-}
 {-# Language TypeFamilies #-}
 {-# Language TypeInType #-}
 {-# Language TypeOperators #-}
 {-# Language UndecidableInstances #-}

 import Data.Kind
 import Data.Functor.Identity
 import Data.Functor.Product

 type a <-> b = a -> b -> Type

 class Iso (iso :: a <-> b) where
   iso :: a -> b
   osi :: b -> a

 data Iso_Bool :: Either () () <-> Bool

 instance Iso Iso_Bool where

 class Representable f where
   type Rep f :: Type

   index    :: f a -> (Rep f -> a)
   tabulate :: (Rep f -> a) -> f a

 class Comonad w where
   extract   :: w a -> a
   duplicate :: w a -> w (w a)

 newtype Co f a = Co (f a) deriving newtype (Functor, Representable)

 instance (Representable f, Monoid (Rep f)) => Comonad (Co f) where
   extract = (`index` mempty)

 newtype WRAP (iso::old <-> new) f a = WRAP (f a)

 instance (Representable f, Rep f ~ old, Iso iso) => Representable (WRAP
 (iso :: old <-> new) f) where
   type Rep (WRAP (iso :: old <-> new) f) = new

   index :: WRAP iso f a -> (new -> a)
   index (WRAP fa) = index fa . osi @old @new @iso

   tabulate :: (new -> a) -> WRAP iso f a
   tabulate gen = WRAP $
     tabulate (gen . iso @old @new @iso)

 newtype PAIR a = PAIR (Co (WRAP Iso_Bool (Product Identity Identity)) a)
   deriving newtype
     Comonad
 }}}

 I unfortunately don't have time to find a more minimal example. Core
 linter vomits a lot of errors on 8.2.1 & 8.3.20171208.

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