[GHC] #15310: Derive Generic1 instances for types of kind (k -> *) -> * that include applications of the parameter

[GHC]

#15310: Derive Generic1 instances for types of kind (k -> *) -> * that include
applications of the parameter
-------------------------------------+-------------------------------------
        Reporter:  cedricshock       |                Owner:  (none)
            Type:  feature request   |               Status:  new
        Priority:  low               |            Milestone:
       Component:  Compiler (Type    |              Version:
  checker)                           |             Keywords:  DeriveGeneric
      Resolution:                    |  Generic1
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:                    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by cedricshock):

 These types can represent applications of the parameter in `Generic1`
 instances

 {{{#!hs
 newtype ParAp0 c p = ParAp0 { unParAp0 :: p c }     -- applications of the
 parameter
 newtype ParAp1 f p = ParAp1 { unParAp1 :: p (f p) } -- recursive
 applications of the parameter
 }}}


 For example the `f (Fix f)` in `Fix` can be represented by `ParAp1 Fix`

 {{{#!hs
 type Rep1 Fix = D1
                   ('MetaData
                      "Fix"
                      "CanDoRep1Model_0"
                      "main"
                      'GHC.Types.False)
                   (C1
                      ('MetaCons
                         "In" 'PrefixI 'GHC.Types.False)
                      (S1
                         ('MetaSel
                            'GHC.Maybe.Nothing
                            'NoSourceUnpackedness
                            'NoSourceStrictness
                            'DecidedLazy)
                         (ParAp1 Fix)))
 }}}

 and the `f String` in `Child` can be represented by `ParAp0 String`

 {{{#!hs
 type Rep1 Child = D1
                     ('MetaData
                        "Child"
                        "CanDoRep1Model_0"
                        "main"
                        'GHC.Types.False)
                     (C1
                        ('MetaCons
                           "Child"
                           'PrefixI
                           'GHC.Types.True)
                        (S1
                           ('MetaSel
                              ('Just "ordinal")
                              'NoSourceUnpackedness
                              'NoSourceStrictness
                              'DecidedLazy)
                           (Rec0 GHC.Types.Int)
                         :*: S1
                               ('MetaSel
                                   ('Just "nickname")
                                   'NoSourceUnpackedness
                                   'NoSourceStrictness
                                   'DecidedLazy)
                               (ParAp0
                                   GHC.Base.String)))
 }}}


 Problems arise when attempting to represent a type that contains the
 parameter applied to the composition of other types. This type contains an
 application of the parameter to the composition of `[]` and `D`

 {{{#!hs
 data Compose2 f = Comp2 (f (Maybe (D f)))              deriving Generic1

 data D f = D                                           deriving Generic1
 }}}

 `ParAp1 (Maybe :*: D)` can represent `f (Maybe (D f))`, but the resulting
 `ParAp1` holds an `f ((Maybe :*: D) f))`, which, while representationally
 equivalent to `f (Maybe (D f))`, isn't nominally equivalent to `f (Maybe
 (D f))`. This prevents the `to1` and `from1` methods from being written,
 even with the help of `coerce`.

 Multiple compositions can be refactored to have `Generic1` instances.

 {{{#!hs
 data Compose2 f = Comp2 (f (MaybeD f))                 deriving Generic1

 newtype MaybeD f = MaybeD (Maybe (D f))                deriving Generic1

 data D f = D                                           deriving Generic1
 }}}

-- 
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/15310#comment:1>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler