GHC determine illegal kind for standalone deriving with Deriving via

Happy to release GHC 8.6.1-alpha1! I used it to test new extensions, and then I met below errors:

$ ghci-8.6.0.20180627
GHCi, version 8.6.0.20180627: http://www.haskell.org/ghc/  :? for help
Prelude> :set -XDerivingVia -XStandaloneDeriving
Prelude> newtype FunctorWrapped f a = FunctorWrapped (f a)
Prelude> deriving via f instance Functor f => Functor (FunctorWrapped f)

<interactive>:3:33: error:
    • Expected kind ‘* -> *’, but ‘f’ has kind ‘*’
    • In the first argument of ‘Functor’, namely ‘f’
      In the stand-alone deriving instance for
        ‘Functor f => Functor (FunctorWrapped f)’

<interactive>:3:62: error:
    • Expected kind ‘* -> *’, but ‘f’ has kind ‘*’
    • In the first argument of ‘FunctorWrapped’, namely ‘f’
      In the first argument of ‘Functor’, namely ‘(FunctorWrapped f)’
      In the stand-alone deriving instance for
        ‘Functor f => Functor (FunctorWrapped f)’

However,

newtype FunctorWrapped f a = FunctorWrapped (f a)
    deriving Functor via f

is passed through on GHC 8.6.1-alpha1.

Is this a bug or my misunderstand?

Trac metadata

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

mentioned in issue #14331

changed milestone to %8.6.1

changed weight to 5

added Tbug Trac import labels

added deriving label

This is indeed a known limitation of the way deriving declarations are typechecked.

Short answer: You can work around the issue by introducing an explicit type signature, i.e.,

deriving via (f :: * -> *) instance Functor f => Functor (FunctorWrapped f)

Long answer: Any type variables quantified by via are kind-checked in isolation, without any information that might be gleaned from bidirectionally kind-checking the instance head. This means that GHC sees:

deriving via f ...

And hastily concludes that f is of kind *. Bummer.

We (kosmikus, Iceland_jack, and I) discussed this at some length in https://github.com/RyanGlScott/ghc/issues/29, and came to the conclusion that we might be able to fix this issue by introducing fresh unification variables when kind-checking, then unifying, and then generalizing/skolemizing if there are any unfilled unification variables left. This bears a close resemblance to the algorithm described in #14331, so I'm going to claim that this ticket is blocked by #14331.

Trac metadata

Trac field	Value
BlockedBy	- → #14331

Replying to [ticket:15376#comment:156826 RyanGlScott]:

This is indeed a known limitation of the way deriving declarations are typechecked.

I understand. Thank you for your comment.

changed milestone to %8.8.1

These won't be fixed for in GHC 8.6.

changed milestone to %8.10.1

Bumping milestones of low-priority tickets.

mentioned in issue #16455 (closed)

added Pnormal label

changed milestone to %9.0.1

marked #18488 (closed) as a duplicate of this issue

marked this issue as related to #18488 (closed)

mentioned in issue #18488 (closed)

Another example from #18488 (closed):

{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE StandaloneDeriving #-}

class C t
newtype Tag t a = T a
newtype Tag' t a = T' a

instance (C t, Eq t) => Eq (Tag t a)
deriving via (Tag t a) instance (C t, Eq t) => Eq (Tag' t a)

• Expected a type, but ‘t’ has kind ‘k’
• In the first argument of ‘Eq’, namely ‘t’
  In the stand-alone deriving instance for
    ‘(C t, Eq t) => Eq (Tag' t a)’

The Eq t part of the instance context should be enough to inform the typechecker that t is of kind Type, not k.

changed milestone to %9.2.1

removed milestone %9.2.1

added DerivingVia label

added program incorrectly rejected label

marked this issue as related to #20680 (closed)

mentioned in issue #20680 (closed)

As observed in #20680 (closed), the programs in this issue now panic when compiled with GHC 9.2.1 or later. For example:

λ> :set -XDerivingVia -XStandaloneDeriving
λ> newtype FunctorWrapped f a = FunctorWrapped (f a)
λ> deriving via f instance Functor f => Functor (FunctorWrapped f)

<interactive>:3:33: error:ghc: panic! (the 'impossible' happened)
  (GHC version 9.2.1:
        No skolem info:
  [k_aAi]
  Call stack:
      CallStack (from HasCallStack):
        callStackDoc, called at compiler/GHC/Utils/Panic.hs:181:37 in ghc:GHC.Utils.Panic
        pprPanic, called at compiler/GHC/Tc/Errors.hs:2888:17 in ghc:GHC.Tc.Errors

Please report this as a GHC bug:  https://www.haskell.org/ghc/reportabug

I'm investigating why these panics happen in 9.2.1 but not in 9.0 or earlier in #20680 (closed).

marked this issue as related to #21514 (closed)

mentioned in issue #21514 (closed)

mentioned in issue #22302 (closed)

mentioned in issue #24968 (closed)

marked this issue as related to #24968 (closed)