deriving Applicative in haskell

Question

Why wouldn't GHC derive Applicative for KO ?

#!/usr/bin/env stack
-- stack --resolver lts-17.10 script

{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}

newtype KO a = KO a deriving (Functor, Applicative) -- doesn't derive Applicative

newtype OK f a = OK (f a) deriving (Functor, Applicative) -- that's ok

main :: IO ()
main = print "hello"

• Can't make a derived instance of ‘Applicative KO’ (even with cunning GeneralizedNewtypeDeriving): cannot eta-reduce the representation type enough • In the newtype declaration for ‘KO’typecheck

if you :i Applicative you'll see this: type Applicative :: (* -> *) -> Constraint - so a type can be applicative if it's kind is * -> * (the container is applicative - like [] or Maybe - not [a], Maybe a) - that's why it is not working - your newtype is a wrapper for any type - if you'd make an instance for OK you would do Applicative f => instance Applicative (OK f) (Ok f : * -> *) - try to write an instance for KO yourself - there is one (basically Identity - look it up) - but it's not what you would expect from a newtype wrapper — Random Dev
If the Identity behaviour is what you want, you could use DerivingVia and say newtype KO a = KO a deriving (Functor, Applicative) via Identity — kosmikus
@Carsten, fwiw, :i Functor also shows type Functor :: (* -> *) -> Constraint. Why doesn't Functor pose the same problem, then? — Enlico
@Enlico Functor doesn't pose the same problem because it is using a different instance generation method. My answer has some details and a link to the full documentation. — Daniel Wagner

Daniel Wagner Daniel Wagner · Accepted Answer · 2021-05-04T16:02:31

GHC has four ways of creating instances:

stock: write new implementations of each of the class's methods from scratch via pattern matching and the like
newtype: when declaring a newtype that wraps a type that already has an instance, reuse that instance, inserting and removing newtype wrappers at the appropriate moments
anyclass: declare an instance with no method definitions (hence using default implementations for every method, if there are any)
via: a generalization of newtype, it lets you inherit the instance from any other type with visibly the same representation, again by inserting/removing newtype wrappers at appropriate moments

In your code snippet, the stock method is used to derive Functor because you have turned on DeriveFunctor. There is currently no stock derivation for Applicative, though. The via method only ever fires when explicitly requested, and you have not turned on DeriveAnyClass, so the only option left is newtype, so GHC attempts to inherit an instance from the wrapped type. Then it runs into trouble, because Applicative is supposed to be for container types, and the contained type isn't one, so it complains.

This explains the Functor vs Applicative difference for your first snippet. For the first vs second snippet difference for Applicative, we need only observe that after unwrapping the second one, we do have a container type; hence you get an Applicative instance for OK any time its f argument has one.

See also the documentation on deriving strategies.

deriving Applicative in haskell

3 Answers