Opened 4 years ago

Closed 4 years ago

Last modified 2 years ago

#10561 closed bug (fixed)

"deriving (Functor)" on a polykinded type produces ill-kinded instance

Reported by: rwbarton Owned by:
Priority: normal Milestone: 8.0.1
Component: Compiler Version: 7.11
Keywords: deriving Cc: RyanGlScott
Operating System: Unknown/Multiple Architecture: Unknown/Multiple
Type of failure: None/Unknown Test Case: deriving/should_compile/T10561
Blocked By: Blocking:
Related Tickets: Differential Rev(s):
Wiki Page:

Description

Arose in #10524, and new since 7.10.

rwbarton@morphism:/tmp$ ~/ghc/inplace/bin/ghc-stage2 --interactive
GHCi, version 7.11.20150615: http://www.haskell.org/ghc/  :? for help
Prelude> :set -XPolyKinds -XDeriveFunctor -ddump-deriv -fprint-explicit-kinds
Prelude> newtype Compose f g a = Compose (f (g a)) deriving Functor

==================== Derived instances ====================
Derived instances:
  instance forall (k_and :: BOX)
                  (f_ane :: k_and -> *)
                  (g_anf :: * -> k_and).
           (GHC.Base.Functor f_ane, GHC.Base.Functor g_anf) =>
           GHC.Base.Functor (Ghci1.Compose k_and * f_ane g_anf) where
    GHC.Base.fmap f_ang (Ghci1.Compose a1_anh)
      = Ghci1.Compose (GHC.Base.fmap (GHC.Base.fmap f_ang) a1_anh)
  

Generic representation:
  
  Generated datatypes for meta-information:
  
  Representation types:


Prelude> :i GHC.Base.Functor
class Functor (f :: * -> *) where
[...]

The context (GHC.Base.Functor f_ane, GHC.Base.Functor g_anf) is ill-kinded except when k_and = *.

Change History (6)

comment:1 Changed 4 years ago by RyanGlScott

Cc: RyanGlScott added

comment:2 Changed 4 years ago by Simon Peyton Jones <simonpj@…>

In 9a348640c5ddd63c3385d3722fb3ade38013a148/ghc:

Improve kind-checking for 'deriving' clauses

The main payload is in 'mk_functor_like_constraints' in
TcDeriv.inferConstraints.

This is moving towards a fix for Trac #10561

comment:3 Changed 4 years ago by simonpj

Resolution: fixed
Status: newclosed
Test Case: deriving/should_compile/T10561

This patch makes GHC complain before generating ill-kinded code via deriving.

#10524 contains the remaining open issue.

comment:4 Changed 4 years ago by thomie

Milestone: 8.0.1

comment:5 Changed 4 years ago by Ben Gamari <ben@…>

In aadde2b/ghc:

Deriving Functor-like classes should unify kind variables

While the deriving machinery always unifies the kind of the typeclass
argument with the kind of the datatype, this proves not to be sufficient
to produce well kinded instances for some poly-kinded datatypes. For
example:

```
newtype Compose (f :: k2 -> *) (g :: k1 -> k2) (a :: k1)
  = Compose (f (g a)) deriving Functor
```

would fail because only `k1` would get unified with `*`, causing the
following
ill kinded instance to be generated:

```
instance (Functor (f :: k2 -> *), Functor (g :: * -> k2)) =>
  Functor (Compose f g) where ...
```

To prevent this, we need to take the subtypes and unify their kinds with
`* -> *`.

Fixes #10524 for good.

Test Plan: ./validate

Reviewers: simonpj, hvr, austin, bgamari

Subscribers: thomie

Differential Revision: https://phabricator.haskell.org/D2097

GHC Trac Issues: #10524, #10561

comment:6 Changed 2 years ago by RyanGlScott

Keywords: deriving added
Note: See TracTickets for help on using tickets.