Auto derive from top to bottom

It is very good to see that Template Haskell types are now Generic and DeriveAnyClass have been implemented. I suppose that this auto-deriving thing can go even further. The problem is like the following:

When we manipulate a complex composite JSON object, we need to define a dozen of data types for each of the dozen we may need to derive Eq, Show, Generic etc.

Another situaition can be manipulating the AST of a language, there may be dozens of data type definitions, also, for each of them, we need to derive Show, Eq, Generic.

Take the old Template Haskell types without Generic as an example, I want to make them instances of Generic type class, I wrote:

deriving instance Generic FixityDirection
deriving instance Generic Inline
deriving instance Generic RuleBndr
deriving instance Generic Match
deriving instance Generic Name
deriving instance Generic RuleMatch
deriving instance Generic Pred
deriving instance Generic Phases
deriving instance Generic Con
deriving instance Generic Module
deriving instance Generic AnnTarget
deriving instance Generic Type
deriving instance Generic TyVarBndr
deriving instance Generic TyLit
deriving instance Generic Exp
deriving instance Generic Lit
deriving instance Generic Pat
deriving instance Generic Dec
deriving instance Generic Clause
deriving instance Generic FunDep
deriving instance Generic Foreign
deriving instance Generic Fixity
deriving instance Generic Pragma
deriving instance Generic FamFlavour
...

How can we use Generic? Say we want to serialize Template Haskell data type with Binary type class, Of course, by writing Binary empty instances or just derive it with DeriveAnyClass extension. However, the problem is that we still need to write deriving Binary dozens of times, as many as the trivial Generic deriving declaration above.

What if GHC can attemp to derive the instance from the top of the tree down to the leaf in the data type declarations? For example:

data Person = Person Names Address
            | Student Names Address
data Names  = Names String
data Address = Address Gate
type Gate = (String,Int)

deriving topdown Generic Person
deriving topdown Eq Person

It will generate Eq instances of Person, Names and Address since Name and Address are in the Person data declaration tree.

I tried to implement a prototype see https://github.com/HaskellZhangSong/derive-topdown

It is rather an experiment tryout than a formal implementation. If you think this feature is attractive, I would like to discuss it.