## Deriving quantified methods

## Motivation

I was trying to derive `Data.Functor.Alt.Alt`

```
class Functor f => Alt f where
(<!>) :: f a -> f a -> f a
some :: Applicative f => f a -> f [a]
many :: Applicative f => f a -> f [a]
```

It's really `some`

and `many`

that get in the way, so let's work with `Alt'`

Now this is a bit tricky, should this be expected to compile?

```
{-# Language ConstrainedClassMethods #-}
{-# Language DerivingVia #-}
import Data.Functor.Identity
class Alt' f where
some :: Applicative f => f a -> f [a]
instance Alt' Identity where
some :: Identity a -> Identity [a]
some (Identity a) = Identity [a,a,a] -- doesn't matter
newtype ID a = ID a
deriving Alt'
via Identity
-- • Couldn't match type ‘Identity’ with ‘ID’
-- arising from the coercion of the method ‘some’
-- from type ‘forall a.
-- Applicative Identity =>
-- Identity a -> Identity [a]’
-- to type ‘forall a. Applicative ID => ID a -> ID [a]’
-- • When deriving the instance for (Alt' ID)
```