Coercible regression from 7.10 to HEAD

This started out with code that compiled on 7.10, but fails on HEAD (20150711):

{-# LANGUAGE TypeFamilies, StandaloneDeriving, UndecidableInstances #-}
module StandaloneDeriving where

type family F a

newtype D a = D (F a)

-- | This works on 7.10.1 and HEAD (20150711)
deriving instance Eq (F a) => Eq (D a)

-- | This works on 7.10.1, but fails on HEAD (20150711)
deriving instance Bounded (F a) => Bounded (D a)

which fails on HEAD with:

GHCi, version 7.11.20150711: http://www.haskell.org/ghc/  :? for help
[1 of 1] Compiling StandaloneDeriving ( StandaloneDeriving.hs, interpreted )

StandaloneDeriving.hs:12:1: error:
    Couldn't match representation of type ‘a0’ with that of ‘F a’
      arising from a use of ‘coerce’
    Relevant bindings include
      minBound :: D a (bound at StandaloneDeriving.hs:12:1)
    In the expression: coerce (minBound :: F a) :: D a
    In an equation for ‘minBound’:
        minBound = coerce (minBound :: F a) :: D a
    When typechecking the code for ‘minBound’
      in a derived instance for ‘Bounded (D a)’:
      To see the code I am typechecking, use -ddump-deriv
    In the instance declaration for ‘Bounded (D a)’

StandaloneDeriving.hs:12:1: error:
    Couldn't match representation of type ‘a1’ with that of ‘F a’
      arising from a use of ‘coerce’
    Relevant bindings include
      maxBound :: D a (bound at StandaloneDeriving.hs:12:1)
    In the expression: coerce (maxBound :: F a) :: D a
    In an equation for ‘maxBound’:
        maxBound = coerce (maxBound :: F a) :: D a
    When typechecking the code for ‘maxBound’
      in a derived instance for ‘Bounded (D a)’:
      To see the code I am typechecking, use -ddump-deriv
    In the instance declaration for ‘Bounded (D a)’
Failed, modules loaded: none.

Which I managed to reduce to:

{-# LANGUAGE TypeFamilies, FlexibleContexts #-}
module CoerceFail where

import Data.Coerce

type family F a

newtype D a = D (F a)

-- | This works on 7.10.1, but fails on HEAD (20150711)
coerceD :: Coercible (F a) (D a) => F a -> D a
coerceD = coerce

Which also works on 7.10.1 but fails on HEAD with:

GHCi, version 7.11.20150711: http://www.haskell.org/ghc/  :? for help
[1 of 1] Compiling CoerceFail       ( CoerceFail.hs, interpreted )

CoerceFail.hs:12:11: error:
    Couldn't match representation of type ‘a0’ with that of ‘F a’
      arising from a use of ‘coerce’
    Relevant bindings include
      coerceD :: F a -> D a (bound at CoerceFail.hs:12:1)
    In the expression: coerce
    In an equation for ‘coerceD’: coerceD = coerce

I don't know if this was never supposed to work, and the behaviour on HEAD is correct, or, if this is truly a regression from 7.10 to HEAD.

Trac metadata

Trac field	Value
Version	7.11
Type	Bug
TypeOfFailure	OtherFailure
Priority	normal
Resolution	Unresolved
Component	Compiler
Test case
Differential revisions
BlockedBy
Related
Blocking
CC
Operating system
Architecture

changed weight to 5

added Tbug Trac import labels

The example can be even further simplified to:

{-# LANGUAGE TypeFamilies #-}
module CoerceFail where

import Data.Coerce

type family F a

newtype D a = D (F a)

-- | This works on 7.10.1, but fails on HEAD (20150711)
coerceD :: F a -> D a
coerceD = coerce

changed weight to 10

assigned to @rae

Happily, this works with the tip of the ghc-7.10 branch.

Trac metadata

Trac field	Value
Priority	normal → highest

mentioned in commit 9f978b67

closed

All fixed now. Thanks for the report!

Trac metadata

Trac field	Value
Resolution	Unresolved → ResolvedFixed
Test case	→ typecheck/should_compile/T10642

I know it wasn't the point of the ticket, but I'm surprised that the derived instance for Bounded (a Haskell 2010-derivable class) uses coerce rather than just using the data constructor D.

For reasons I'm not quite sure of (performance, probably), the following classes are always derived using GND when derived for newtypes: Eq, Ord, Ix, Bounded. This is true in a file with no extensions enabled. I don't know precisely why Eq didn't trigger this bug, but it wasn't worth exploring.

Bounded is not derivable in the standard way for the D type, it needs StandaloneDeriving, which for newtypes seems to *always* use coerce.

As to why Eq didnt trigger the bug, is has to do with the fact that:

coerceDF :: (F a -> Int) -> (D a -> Int)
coerceDF = coerce

also didn't trigger the bug.

StandaloneDeriving and normal deriving use the same mechanisms. So StandaloneDeriving is no more likely to use coerce than normal deriving. This can most easily be seen when deriving Show.

changed milestone to %8.0.1

Milestone renamed

added Phighest label