GitLab

Take the Alt type class as an example, which is Alternative without the empty method:

{-# Language ConstrainedClassMethods #-}
{-# Language DerivingVia             #-}

import Control.Applicative

class Functor f => Alt f where
  (<!>) :: f a -> f a -> f a

  some :: Applicative f => f a -> f [a]
  some v = some_v
    where many_v = some_v <!> pure []
          some_v = (:) <$> v <*> many_v

  many :: Applicative f => f a -> f [a]
  many v = many_v
    where many_v = some_v <!> pure []
          some_v = (:) <$> v <*> many_v

The applicative constraints on the methods means we cannot derive Alt.

If we try to derive it (say via []) GHC fails to coerce between Applicative [] and Applicative List.

instance Alt [] where
  (<!>) = (<>)

newtype List a = List [a] 
  -- • Couldn't match type ‘[]’ with ‘List’
  --     arising from the coercion of the method ‘many’
  --       from type ‘forall a. Applicative [] => [a] -> [[a]]’
  --         to type ‘forall a. Applicative List => List a -> List [a]’
  -- • When deriving the instance for (Alt List)
  --
  -- .. same for ‘some’
  deriving (Functor, Applicative, Alt)
  via []

GHC can make use of the provenence of the Applicative instance: we know that that Applicative List was derived via Applicative [] using coerce-based deriving (either newtype, via) and so the dictionaries can be considered Coercible (?). If not I'm curious if this fails.¹

This is not the first time I want this (I forgot in what context though), let me know if it's sensible/useful.

---

¹ Instead of coercing method-by-method could coerce-based deriving coerce the whole dictionary?