diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,9 @@ +# 1.14.1 [2021.08.30] +* Backport the `Generic(1)` instances introduced for tuples (8 through 15) in + `base-4.16`. +* Make the test suite compile on GHC 9.2 or later. +* Always import `Data.List` qualified to fix the build with recent GHCs. + # 1.14 [2020.09.30] * Remove instances for `Data.Semigroup.Option`, which is deprecated as of `base-4.15.0.0`. diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -3,7 +3,7 @@ [![Hackage Dependencies](https://img.shields.io/hackage-deps/v/generic-deriving.svg)](http://packdeps.haskellers.com/reverse/generic-deriving) [![Haskell Programming Language](https://img.shields.io/badge/language-Haskell-blue.svg)][Haskell.org] [![BSD3 License](http://img.shields.io/badge/license-BSD3-brightgreen.svg)][tl;dr Legal: BSD3] -[![Build](https://img.shields.io/travis/dreixel/generic-deriving.svg)](https://travis-ci.org/dreixel/generic-deriving) +[![Build Status](https://github.com/dreixel/generic-deriving/workflows/Haskell-CI/badge.svg)](https://github.com/dreixel/generic-deriving/actions?query=workflow%3AHaskell-CI) [Hackage: generic-deriving]: http://hackage.haskell.org/package/generic-deriving diff --git a/generic-deriving.cabal b/generic-deriving.cabal --- a/generic-deriving.cabal +++ b/generic-deriving.cabal @@ -1,5 +1,5 @@ name: generic-deriving -version: 1.14 +version: 1.14.1 synopsis: Generic programming library for generalised deriving. description: @@ -36,7 +36,7 @@ "Generics.Deriving.Monoid", "Generics.Deriving.Semigroup", "Generics.Deriving.Show", "Generics.Deriving.Traversable", and "Generics.Deriving.Uniplate". - . + . It is worth emphasizing that these modules are primarly intended for educational purposes. Many of the classes in these modules resemble other commonly used classes—for example, @GShow@ from "Generics.Deriving.Show" @@ -79,8 +79,10 @@ , GHC == 8.2.2 , GHC == 8.4.4 , GHC == 8.6.5 - , GHC == 8.8.3 - , GHC == 8.10.1 + , GHC == 8.8.4 + , GHC == 8.10.7 + , GHC == 9.0.1 + , GHC == 9.2.* extra-source-files: CHANGELOG.md , README.md @@ -127,7 +129,7 @@ build-depends: containers >= 0.1 && < 0.7 , ghc-prim < 1 - , template-haskell >= 2.4 && < 2.18 + , template-haskell >= 2.4 && < 2.19 , th-abstraction >= 0.4 && < 0.5 default-language: Haskell2010 @@ -144,7 +146,7 @@ build-depends: base >= 4.3 && < 5 , generic-deriving , hspec >= 2 && < 3 - , template-haskell >= 2.4 && < 2.18 + , template-haskell >= 2.4 && < 2.19 build-tool-depends: hspec-discover:hspec-discover hs-source-dirs: tests default-language: Haskell2010 diff --git a/src/Generics/Deriving/Instances.hs b/src/Generics/Deriving/Instances.hs --- a/src/Generics/Deriving/Instances.hs +++ b/src/Generics/Deriving/Instances.hs @@ -27,144 +27,1842 @@ module Generics.Deriving.Instances ( -- Only instances from Generics.Deriving.Base -- and the Generic1 instances -#if !(MIN_VERSION_base(4,14,0)) - Rep0Kleisli - , Rep1Kleisli -#endif -#if !(MIN_VERSION_base(4,12,0)) - , Rep0Down - , Rep1Down -#endif -#if !(MIN_VERSION_base(4,9,0)) - , Rep0ExitCode - , Rep0Version - , Rep1ConSum - , Rep1ConProduct - , Rep1ConCompose - , Rep1K1 - , Rep1M1 - , Rep1Par1 - , Rep1Rec1 - , Rep1U1 - , Rep0V1 - , Rep1V1 - , Rep0UAddr - , Rep1UAddr - , Rep0UChar - , Rep1UChar - , Rep0UDouble - , Rep1UDouble - , Rep0UFloat - , Rep1UFloat - , Rep0UInt - , Rep1UInt - , Rep0UWord - , Rep1UWord -# if MIN_VERSION_base(4,4,0) - , Rep0Complex - , Rep1Complex -# endif -# if MIN_VERSION_base(4,7,0) - , Rep1Proxy -# endif -#endif -#if !(MIN_VERSION_base(4,7,0)) - , Rep0All - , Rep0Any - , Rep0Arity - , Rep0Associativity - , Rep0Const - , Rep1Const - , Rep0Dual - , Rep1Dual - , Rep0Endo - , Rep0First - , Rep1First - , Rep0Fixity - , Rep0Last - , Rep1Last - , Rep0Product - , Rep1Product - , Rep0Sum - , Rep1Sum - , Rep0WrappedArrow - , Rep1WrappedArrow - , Rep0WrappedMonad - , Rep1WrappedMonad - , Rep0ZipList - , Rep1ZipList - , Rep0U1 - , Rep0Par1 - , Rep0Rec1 - , Rep0K1 - , Rep0M1 - , Rep0ConSum - , Rep0ConProduct - , Rep0ConCompose -#endif -#if !(MIN_VERSION_base(4,6,0)) - , Rep1Either - , Rep1List - , Rep1Maybe - , Rep1Tuple2 - , Rep1Tuple3 - , Rep1Tuple4 - , Rep1Tuple5 - , Rep1Tuple6 - , Rep1Tuple7 -#endif -#if !(MIN_VERSION_base(4,4,0)) - , Rep0Bool - , Rep0Char - , Rep0Double - , Rep0Either - , Rep0Int - , Rep0Float - , Rep0List - , Rep0Maybe - , Rep0Ordering - , Rep0Tuple2 - , Rep0Tuple3 - , Rep0Tuple4 - , Rep0Tuple5 - , Rep0Tuple6 - , Rep0Tuple7 - , Rep0Unit -#endif - ) where - -#if !(MIN_VERSION_base(4,7,0)) -import Control.Applicative -import Data.Monoid -#endif - -#if MIN_VERSION_base(4,4,0) && !(MIN_VERSION_base(4,9,0)) -import Data.Complex (Complex(..)) -#endif - -#if MIN_VERSION_base(4,7,0) && !(MIN_VERSION_base(4,9,0)) -import Data.Proxy (Proxy(..)) -#endif - -#if !(MIN_VERSION_base(4,9,0)) -import Data.Version (Version(..)) -import System.Exit (ExitCode(..)) -#endif - -#if !(MIN_VERSION_base(4,12,0)) -# if MIN_VERSION_base(4,6,0) -import Data.Ord (Down(..)) -# else -import GHC.Exts (Down(..)) -# endif -#endif - -#if !(MIN_VERSION_base(4,14,0)) -import Control.Arrow (Kleisli(..)) -#endif - -#if !(MIN_VERSION_base(4,14,0)) -import Generics.Deriving.Base.Internal +#if !(MIN_VERSION_base(4,16,0)) + Rep0Tuple8 + , Rep0Tuple9 + , Rep0Tuple10 + , Rep0Tuple11 + , Rep0Tuple12 + , Rep0Tuple13 + , Rep0Tuple14 + , Rep0Tuple15 + , Rep1Tuple8 + , Rep1Tuple9 + , Rep1Tuple10 + , Rep1Tuple11 + , Rep1Tuple12 + , Rep1Tuple13 + , Rep1Tuple14 + , Rep1Tuple15 +#endif +#if !(MIN_VERSION_base(4,14,0)) + , Rep0Kleisli + , Rep1Kleisli +#endif +#if !(MIN_VERSION_base(4,12,0)) + , Rep0Down + , Rep1Down +#endif +#if !(MIN_VERSION_base(4,9,0)) + , Rep0ExitCode + , Rep0Version + , Rep1ConSum + , Rep1ConProduct + , Rep1ConCompose + , Rep1K1 + , Rep1M1 + , Rep1Par1 + , Rep1Rec1 + , Rep1U1 + , Rep0V1 + , Rep1V1 + , Rep0UAddr + , Rep1UAddr + , Rep0UChar + , Rep1UChar + , Rep0UDouble + , Rep1UDouble + , Rep0UFloat + , Rep1UFloat + , Rep0UInt + , Rep1UInt + , Rep0UWord + , Rep1UWord +# if MIN_VERSION_base(4,4,0) + , Rep0Complex + , Rep1Complex +# endif +# if MIN_VERSION_base(4,7,0) + , Rep1Proxy +# endif +#endif +#if !(MIN_VERSION_base(4,7,0)) + , Rep0All + , Rep0Any + , Rep0Arity + , Rep0Associativity + , Rep0Const + , Rep1Const + , Rep0Dual + , Rep1Dual + , Rep0Endo + , Rep0First + , Rep1First + , Rep0Fixity + , Rep0Last + , Rep1Last + , Rep0Product + , Rep1Product + , Rep0Sum + , Rep1Sum + , Rep0WrappedArrow + , Rep1WrappedArrow + , Rep0WrappedMonad + , Rep1WrappedMonad + , Rep0ZipList + , Rep1ZipList + , Rep0U1 + , Rep0Par1 + , Rep0Rec1 + , Rep0K1 + , Rep0M1 + , Rep0ConSum + , Rep0ConProduct + , Rep0ConCompose +#endif +#if !(MIN_VERSION_base(4,6,0)) + , Rep1Either + , Rep1List + , Rep1Maybe + , Rep1Tuple2 + , Rep1Tuple3 + , Rep1Tuple4 + , Rep1Tuple5 + , Rep1Tuple6 + , Rep1Tuple7 +#endif +#if !(MIN_VERSION_base(4,4,0)) + , Rep0Bool + , Rep0Char + , Rep0Double + , Rep0Either + , Rep0Int + , Rep0Float + , Rep0List + , Rep0Maybe + , Rep0Ordering + , Rep0Tuple2 + , Rep0Tuple3 + , Rep0Tuple4 + , Rep0Tuple5 + , Rep0Tuple6 + , Rep0Tuple7 + , Rep0Unit +#endif + ) where + +#if !(MIN_VERSION_base(4,7,0)) +import Control.Applicative +import Data.Monoid +#endif + +#if MIN_VERSION_base(4,4,0) && !(MIN_VERSION_base(4,9,0)) +import Data.Complex (Complex(..)) +#endif + +#if MIN_VERSION_base(4,7,0) && !(MIN_VERSION_base(4,9,0)) +import Data.Proxy (Proxy(..)) +#endif + +#if !(MIN_VERSION_base(4,9,0)) +import Data.Version (Version(..)) +import System.Exit (ExitCode(..)) +#endif + +#if !(MIN_VERSION_base(4,12,0)) +# if MIN_VERSION_base(4,6,0) +import Data.Ord (Down(..)) +# else +import GHC.Exts (Down(..)) +# endif +#endif + +#if !(MIN_VERSION_base(4,14,0)) +import Control.Arrow (Kleisli(..)) +#endif + +#if !(MIN_VERSION_base(4,16,0)) +import Generics.Deriving.Base.Internal +#endif + +#if !(MIN_VERSION_base(4,16,0)) +# if MIN_VERSION_base(4,6,0) +type Rep0Tuple8 a b c d e f g h = Rep (a, b, c, d, e, f, g, h) +type Rep0Tuple9 a b c d e f g h i = Rep (a, b, c, d, e, f, g, h, i) +type Rep0Tuple10 a b c d e f g h i j = Rep (a, b, c, d, e, f, g, h, i, j) +type Rep0Tuple11 a b c d e f g h i j k = Rep (a, b, c, d, e, f, g, h, i, j, k) +type Rep0Tuple12 a b c d e f g h i j k l = Rep (a, b, c, d, e, f, g, h, i, j, k, l) +type Rep0Tuple13 a b c d e f g h i j k l m = Rep (a, b, c, d, e, f, g, h, i, j, k, l, m) +type Rep0Tuple14 a b c d e f g h i j k l m n = Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n) +type Rep0Tuple15 a b c d e f g h i j k l m n o = Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) +type Rep1Tuple8 a b c d e f g = Rep1 ((,,,,,,,) a b c d e f g) +type Rep1Tuple9 a b c d e f g h = Rep1 ((,,,,,,,,) a b c d e f g h) +type Rep1Tuple10 a b c d e f g h i = Rep1 ((,,,,,,,,,) a b c d e f g h i) +type Rep1Tuple11 a b c d e f g h i j = Rep1 ((,,,,,,,,,,) a b c d e f g h i j) +type Rep1Tuple12 a b c d e f g h i j k = Rep1 ((,,,,,,,,,,,) a b c d e f g h i j k) +type Rep1Tuple13 a b c d e f g h i j k l = Rep1 ((,,,,,,,,,,,,) a b c d e f g h i j k l) +type Rep1Tuple14 a b c d e f g h i j k l m = Rep1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m) +type Rep1Tuple15 a b c d e f g h i j k l m n = Rep1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n) +deriving instance Generic (a, b, c, d, e, f, g, h) +deriving instance Generic (a, b, c, d, e, f, g, h, i) +deriving instance Generic (a, b, c, d, e, f, g, h, i, j) +deriving instance Generic (a, b, c, d, e, f, g, h, i, j, k) +deriving instance Generic (a, b, c, d, e, f, g, h, i, j, k, l) +deriving instance Generic (a, b, c, d, e, f, g, h, i, j, k, l, m) +deriving instance Generic (a, b, c, d, e, f, g, h, i, j, k, l, m, n) +deriving instance Generic (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) +deriving instance Generic1 ((,,,,,,,) a b c d e f g) +deriving instance Generic1 ((,,,,,,,,) a b c d e f g h) +deriving instance Generic1 ((,,,,,,,,,) a b c d e f g h i) +deriving instance Generic1 ((,,,,,,,,,,) a b c d e f g h i j) +deriving instance Generic1 ((,,,,,,,,,,,) a b c d e f g h i j k) +deriving instance Generic1 ((,,,,,,,,,,,,) a b c d e f g h i j k l) +deriving instance Generic1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m) +deriving instance Generic1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n) +# else +type Rep0Tuple8 a b c d e f g h = D1 + D1Tuple8 + (C1 + C1_0Tuple8 + (((S1 + NoSelector + (Rec0 a) + :*: S1 + NoSelector + (Rec0 + b)) + :*: (S1 + NoSelector + (Rec0 + c) + :*: S1 + NoSelector + (Rec0 + d))) + :*: ((S1 + NoSelector + (Rec0 + e) + :*: S1 + NoSelector + (Rec0 + f)) + :*: (S1 + NoSelector + (Rec0 + g) + :*: S1 + NoSelector + (Rec0 + h))))) +type Rep1Tuple8 a b c d e f g = D1 + D1Tuple8 + (C1 + C1_0Tuple8 + (((S1 + NoSelector + (Rec0 a) + :*: S1 + NoSelector + (Rec0 + b)) + :*: (S1 + NoSelector + (Rec0 + c) + :*: S1 + NoSelector + (Rec0 + d))) + :*: ((S1 + NoSelector + (Rec0 + e) + :*: S1 + NoSelector + (Rec0 + f)) + :*: (S1 + NoSelector + (Rec0 + g) + :*: S1 + NoSelector + Par1)))) + +instance Generic (a, b, c, d, e, f, g, h) where + type Rep (a, b, c, d, e, f, g, h) = Rep0Tuple8 a b c d e f g h + + from x + = M1 + (case x of { + (,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 + -> M1 + ((:*:) + ((:*:) + ((:*:) + (M1 (K1 g1)) + (M1 (K1 g2))) + ((:*:) + (M1 (K1 g3)) + (M1 (K1 g4)))) + ((:*:) + ((:*:) + (M1 (K1 g5)) + (M1 (K1 g6))) + ((:*:) + (M1 (K1 g7)) + (M1 (K1 g8))))) }) + to (M1 x) + = case x of { + (M1 ((:*:) ((:*:) ((:*:) (M1 (K1 g1)) + (M1 (K1 g2))) + ((:*:) (M1 (K1 g3)) + (M1 (K1 g4)))) + ((:*:) ((:*:) (M1 (K1 g5)) + (M1 (K1 g6))) + ((:*:) (M1 (K1 g7)) + (M1 (K1 g8)))))) + -> (,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 } + +instance Generic1 ((,,,,,,,) a b c d e f g) where + type Rep1 ((,,,,,,,) a b c d e f g) = Rep1Tuple8 a b c d e f g + + from1 x + = M1 + (case x of { + (,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 + -> M1 + ((:*:) + ((:*:) + ((:*:) + (M1 (K1 g1)) + (M1 (K1 g2))) + ((:*:) + (M1 (K1 g3)) + (M1 (K1 g4)))) + ((:*:) + ((:*:) + (M1 (K1 g5)) + (M1 (K1 g6))) + ((:*:) + (M1 (K1 g7)) + (M1 (Par1 g8))))) }) + to1 (M1 x) + = case x of { + (M1 ((:*:) ((:*:) ((:*:) (M1 g1) + (M1 g2)) + ((:*:) (M1 g3) + (M1 g4))) + ((:*:) ((:*:) (M1 g5) + (M1 g6)) + ((:*:) (M1 g7) + (M1 g8))))) + -> (,,,,,,,) + (unK1 g1) (unK1 g2) + (unK1 g3) (unK1 g4) + (unK1 g5) (unK1 g6) + (unK1 g7) (unPar1 g8) } + +data D1Tuple8 +data C1_0Tuple8 + +instance Datatype D1Tuple8 where + datatypeName _ = "(,,,,,,,)" + moduleName _ = "GHC.Tuple" + +instance Constructor C1_0Tuple8 where + conName _ = "(,,,,,,,)" + +----- + +type Rep0Tuple9 a b c d e f g h i = D1 + D1Tuple9 + (C1 + C1_0Tuple9 + (((S1 + NoSelector + (Rec0 a) + :*: S1 + NoSelector + (Rec0 + b)) + :*: (S1 + NoSelector + (Rec0 + c) + :*: S1 + NoSelector + (Rec0 + d))) + :*: ((S1 + NoSelector + (Rec0 + e) + :*: S1 + NoSelector + (Rec0 + f)) + :*: (S1 + NoSelector + (Rec0 + g) + :*: (S1 + NoSelector + (Rec0 + h) + :*: S1 + NoSelector + (Rec0 + i)))))) +type Rep1Tuple9 a b c d e f g h = D1 + D1Tuple9 + (C1 + C1_0Tuple9 + (((S1 + NoSelector (Rec0 a) + :*: S1 + NoSelector + (Rec0 b)) + :*: (S1 + NoSelector + (Rec0 c) + :*: S1 + NoSelector + (Rec0 + d))) + :*: ((S1 + NoSelector + (Rec0 e) + :*: S1 + NoSelector + (Rec0 + f)) + :*: (S1 + NoSelector + (Rec0 + g) + :*: (S1 + NoSelector + (Rec0 + h) + :*: S1 + NoSelector + Par1))))) + +instance Generic (a, b, c, d, e, f, g, h, i) where + type Rep (a, b, c, d, e, f, g, h, i) = Rep0Tuple9 a b c d e f g h i + + from x + = M1 + (case x of { + (,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 + -> M1 + ((:*:) + ((:*:) + ((:*:) + (M1 (K1 g1)) + (M1 (K1 g2))) + ((:*:) + (M1 (K1 g3)) + (M1 (K1 g4)))) + ((:*:) + ((:*:) + (M1 (K1 g5)) + (M1 (K1 g6))) + ((:*:) + (M1 (K1 g7)) + ((:*:) + (M1 (K1 g8)) + (M1 (K1 g9)))))) }) + to (M1 x) + = case x of { + (M1 ((:*:) ((:*:) ((:*:) (M1 (K1 g1)) + (M1 (K1 g2))) + ((:*:) (M1 (K1 g3)) + (M1 (K1 g4)))) + ((:*:) ((:*:) (M1 (K1 g5)) + (M1 (K1 g6))) + ((:*:) (M1 (K1 g7)) + ((:*:) (M1 (K1 g8)) + (M1 (K1 g9))))))) + -> (,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 } + +instance Generic1 ((,,,,,,,,) a b c d e f g h) where + type Rep1 ((,,,,,,,,) a b c d e f g h) = Rep1Tuple9 a b c d e f g h + + from1 x + = M1 + (case x of { + (,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 + -> M1 + ((:*:) + ((:*:) + ((:*:) + (M1 (K1 g1)) + (M1 (K1 g2))) + ((:*:) + (M1 (K1 g3)) + (M1 (K1 g4)))) + ((:*:) + ((:*:) + (M1 (K1 g5)) + (M1 (K1 g6))) + ((:*:) + (M1 (K1 g7)) + ((:*:) + (M1 (K1 g8)) + (M1 (Par1 g9)))))) }) + to1 (M1 x) + = case x of { + (M1 ((:*:) ((:*:) ((:*:) (M1 g1) + (M1 g2)) + ((:*:) (M1 g3) + (M1 g4))) + ((:*:) ((:*:) (M1 g5) + (M1 g6)) + ((:*:) (M1 g7) + ((:*:) (M1 g8) + (M1 g9)))))) + -> (,,,,,,,,) + (unK1 g1) (unK1 g2) + (unK1 g3) (unK1 g4) + (unK1 g5) (unK1 g6) + (unK1 g7) (unK1 g8) + (unPar1 g9) } + +data D1Tuple9 +data C1_0Tuple9 + +instance Datatype D1Tuple9 where + datatypeName _ = "(,,,,,,,,)" + moduleName _ = "GHC.Tuple" + +instance Constructor C1_0Tuple9 where + conName _ = "(,,,,,,,,)" + +----- + +type Rep0Tuple10 a b c d e f g h i j = D1 + D1Tuple10 + (C1 + C1_0Tuple10 + (((S1 + NoSelector (Rec0 a) + :*: S1 + NoSelector + (Rec0 b)) + :*: (S1 + NoSelector + (Rec0 c) + :*: (S1 + NoSelector + (Rec0 + d) + :*: S1 + NoSelector + (Rec0 + e)))) + :*: ((S1 + NoSelector + (Rec0 f) + :*: S1 + NoSelector + (Rec0 + g)) + :*: (S1 + NoSelector + (Rec0 + h) + :*: (S1 + NoSelector + (Rec0 + i) + :*: S1 + NoSelector + (Rec0 + j)))))) +type Rep1Tuple10 a b c d e f g h i = D1 + D1Tuple10 + (C1 + C1_0Tuple10 + (((S1 + NoSelector (Rec0 a) + :*: S1 + NoSelector + (Rec0 b)) + :*: (S1 + NoSelector + (Rec0 c) + :*: (S1 + NoSelector + (Rec0 + d) + :*: S1 + NoSelector + (Rec0 + e)))) + :*: ((S1 + NoSelector + (Rec0 f) + :*: S1 + NoSelector + (Rec0 + g)) + :*: (S1 + NoSelector + (Rec0 + h) + :*: (S1 + NoSelector + (Rec0 + i) + :*: S1 + NoSelector + Par1))))) + +instance Generic (a, b, c, d, e, f, g, h, i, j) where + type Rep (a, b, c, d, e, f, g, h, i, j) = Rep0Tuple10 a b c d e f g h i j + + from x + = M1 + (case x of { + (,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 + -> M1 + ((:*:) + ((:*:) + ((:*:) + (M1 (K1 g1)) + (M1 (K1 g2))) + ((:*:) + (M1 (K1 g3)) + ((:*:) + (M1 (K1 g4)) + (M1 (K1 g5))))) + ((:*:) + ((:*:) + (M1 (K1 g6)) + (M1 (K1 g7))) + ((:*:) + (M1 (K1 g8)) + ((:*:) + (M1 (K1 g9)) + (M1 (K1 g10)))))) }) + to (M1 x) + = case x of { + (M1 ((:*:) ((:*:) ((:*:) (M1 (K1 g1)) + (M1 (K1 g2))) + ((:*:) (M1 (K1 g3)) + ((:*:) (M1 (K1 g4)) + (M1 (K1 g5))))) + ((:*:) ((:*:) (M1 (K1 g6)) + (M1 (K1 g7))) + ((:*:) (M1 (K1 g8)) + ((:*:) (M1 (K1 g9)) + (M1 (K1 g10))))))) + -> (,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 } + +instance Generic1 + ((,,,,,,,,,) a b c d e f g h i) where + type Rep1 ((,,,,,,,,,) a b c d e f g h i) = Rep1Tuple10 a b c d e f g h i + + from1 x + = M1 + (case x of { + (,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 + -> M1 + ((:*:) + ((:*:) + ((:*:) + (M1 (K1 g1)) + (M1 (K1 g2))) + ((:*:) + (M1 (K1 g3)) + ((:*:) + (M1 (K1 g4)) + (M1 (K1 g5))))) + ((:*:) + ((:*:) + (M1 (K1 g6)) + (M1 (K1 g7))) + ((:*:) + (M1 (K1 g8)) + ((:*:) + (M1 (K1 g9)) + (M1 (Par1 g10)))))) }) + to1 (M1 x) + = case x of { + (M1 ((:*:) ((:*:) ((:*:) (M1 g1) + (M1 g2)) + ((:*:) (M1 g3) + ((:*:) (M1 g4) + (M1 g5)))) + ((:*:) ((:*:) (M1 g6) + (M1 g7)) + ((:*:) (M1 g8) + ((:*:) (M1 g9) + (M1 g10)))))) + -> (,,,,,,,,,) + (unK1 g1) (unK1 g2) + (unK1 g3) (unK1 g4) + (unK1 g5) (unK1 g6) + (unK1 g7) (unK1 g8) + (unK1 g9) (unPar1 g10) } + +data D1Tuple10 +data C1_0Tuple10 + +instance Datatype D1Tuple10 where + datatypeName _ = "(,,,,,,,,,)" + moduleName _ = "GHC.Tuple" + +instance Constructor C1_0Tuple10 where + conName _ = "(,,,,,,,,,)" + +----- + +type Rep0Tuple11 a b c d e f g h i j k = D1 + D1Tuple11 + (C1 + C1_0Tuple11 + (((S1 + NoSelector + (Rec0 a) + :*: S1 + NoSelector + (Rec0 b)) + :*: (S1 + NoSelector + (Rec0 c) + :*: (S1 + NoSelector + (Rec0 + d) + :*: S1 + NoSelector + (Rec0 + e)))) + :*: ((S1 + NoSelector + (Rec0 f) + :*: (S1 + NoSelector + (Rec0 + g) + :*: S1 + NoSelector + (Rec0 + h))) + :*: (S1 + NoSelector + (Rec0 + i) + :*: (S1 + NoSelector + (Rec0 + j) + :*: S1 + NoSelector + (Rec0 + k)))))) +type Rep1Tuple11 a b c d e f g h i j = D1 + D1Tuple11 + (C1 + C1_0Tuple11 + (((S1 + NoSelector + (Rec0 a) + :*: S1 + NoSelector + (Rec0 b)) + :*: (S1 + NoSelector + (Rec0 c) + :*: (S1 + NoSelector + (Rec0 + d) + :*: S1 + NoSelector + (Rec0 + e)))) + :*: ((S1 + NoSelector + (Rec0 f) + :*: (S1 + NoSelector + (Rec0 + g) + :*: S1 + NoSelector + (Rec0 + h))) + :*: (S1 + NoSelector + (Rec0 + i) + :*: (S1 + NoSelector + (Rec0 + j) + :*: S1 + NoSelector + Par1))))) + +instance Generic + (a, b, c, d, e, f, g, h, i, j, k) where + type Rep (a, b, c, d, e, f, g, h, i, j, k) = Rep0Tuple11 a b c d e f g h i j k + + from x + = M1 + (case x of { + (,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 + -> M1 + ((:*:) + ((:*:) + ((:*:) + (M1 (K1 g1)) + (M1 (K1 g2))) + ((:*:) + (M1 (K1 g3)) + ((:*:) + (M1 (K1 g4)) + (M1 (K1 g5))))) + ((:*:) + ((:*:) + (M1 (K1 g6)) + ((:*:) + (M1 (K1 g7)) + (M1 (K1 g8)))) + ((:*:) + (M1 (K1 g9)) + ((:*:) + (M1 (K1 g10)) + (M1 (K1 g11)))))) }) + to (M1 x) + = case x of { + (M1 ((:*:) ((:*:) ((:*:) (M1 (K1 g1)) + (M1 (K1 g2))) + ((:*:) (M1 (K1 g3)) + ((:*:) (M1 (K1 g4)) + (M1 (K1 g5))))) + ((:*:) ((:*:) (M1 (K1 g6)) + ((:*:) (M1 (K1 g7)) + (M1 (K1 g8)))) + ((:*:) (M1 (K1 g9)) + ((:*:) (M1 (K1 g10)) + (M1 (K1 g11))))))) + -> (,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 } + +instance Generic1 + ((,,,,,,,,,,) a b c d e f g h i j) where + type Rep1 ((,,,,,,,,,,) a b c d e f g h i j) = Rep1Tuple11 a b c d e f g h i j + + from1 x + = M1 + (case x of { + (,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 + -> M1 + ((:*:) + ((:*:) + ((:*:) + (M1 (K1 g1)) + (M1 (K1 g2))) + ((:*:) + (M1 (K1 g3)) + ((:*:) + (M1 (K1 g4)) + (M1 (K1 g5))))) + ((:*:) + ((:*:) + (M1 (K1 g6)) + ((:*:) + (M1 (K1 g7)) + (M1 (K1 g8)))) + ((:*:) + (M1 (K1 g9)) + ((:*:) + (M1 (K1 g10)) + (M1 (Par1 g11)))))) }) + to1 (M1 x) + = case x of { + (M1 ((:*:) ((:*:) ((:*:) (M1 g1) + (M1 g2)) + ((:*:) (M1 g3) + ((:*:) (M1 g4) + (M1 g5)))) + ((:*:) ((:*:) (M1 g6) + ((:*:) (M1 g7) + (M1 g8))) + ((:*:) (M1 g9) + ((:*:) (M1 g10) + (M1 g11)))))) + -> (,,,,,,,,,,) + (unK1 g1) (unK1 g2) + (unK1 g3) (unK1 g4) + (unK1 g5) (unK1 g6) + (unK1 g7) (unK1 g8) + (unK1 g9) (unK1 g10) + (unPar1 g11) } + +data D1Tuple11 +data C1_0Tuple11 + +instance Datatype D1Tuple11 where + datatypeName _ = "(,,,,,,,,,,)" + moduleName _ = "GHC.Tuple" + +instance Constructor C1_0Tuple11 where + conName _ = "(,,,,,,,,,,)" + +----- + +type Rep0Tuple12 a b c d e f g h i j k l = D1 + D1Tuple12 + (C1 + C1_0Tuple12 + (((S1 + NoSelector + (Rec0 a) + :*: (S1 + NoSelector + (Rec0 b) + :*: S1 + NoSelector + (Rec0 + c))) + :*: (S1 + NoSelector + (Rec0 d) + :*: (S1 + NoSelector + (Rec0 + e) + :*: S1 + NoSelector + (Rec0 + f)))) + :*: ((S1 + NoSelector + (Rec0 g) + :*: (S1 + NoSelector + (Rec0 + h) + :*: S1 + NoSelector + (Rec0 + i))) + :*: (S1 + NoSelector + (Rec0 + j) + :*: (S1 + NoSelector + (Rec0 + k) + :*: S1 + NoSelector + (Rec0 + l)))))) +type Rep1Tuple12 a b c d e f g h i j k = D1 + D1Tuple12 + (C1 + C1_0Tuple12 + (((S1 + NoSelector + (Rec0 a) + :*: (S1 + NoSelector + (Rec0 b) + :*: S1 + NoSelector + (Rec0 + c))) + :*: (S1 + NoSelector + (Rec0 d) + :*: (S1 + NoSelector + (Rec0 + e) + :*: S1 + NoSelector + (Rec0 + f)))) + :*: ((S1 + NoSelector + (Rec0 g) + :*: (S1 + NoSelector + (Rec0 + h) + :*: S1 + NoSelector + (Rec0 + i))) + :*: (S1 + NoSelector + (Rec0 + j) + :*: (S1 + NoSelector + (Rec0 + k) + :*: S1 + NoSelector + Par1))))) + +instance Generic + (a, b, c, d, e, f, g, h, i, j, k, l) where + type Rep (a, b, c, d, e, f, g, h, i, j, k, l) = Rep0Tuple12 a b c d e f g h i j k l + + from x + = M1 + (case x of { + (,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 + -> M1 + ((:*:) + ((:*:) + ((:*:) + (M1 (K1 g1)) + ((:*:) + (M1 (K1 g2)) + (M1 (K1 g3)))) + ((:*:) + (M1 (K1 g4)) + ((:*:) + (M1 (K1 g5)) + (M1 (K1 g6))))) + ((:*:) + ((:*:) + (M1 (K1 g7)) + ((:*:) + (M1 (K1 g8)) + (M1 (K1 g9)))) + ((:*:) + (M1 (K1 g10)) + ((:*:) + (M1 (K1 g11)) + (M1 (K1 g12)))))) }) + to (M1 x) + = case x of { + (M1 ((:*:) ((:*:) ((:*:) (M1 (K1 g1)) + ((:*:) (M1 (K1 g2)) + (M1 (K1 g3)))) + ((:*:) (M1 (K1 g4)) + ((:*:) (M1 (K1 g5)) + (M1 (K1 g6))))) + ((:*:) ((:*:) (M1 (K1 g7)) + ((:*:) (M1 (K1 g8)) + (M1 (K1 g9)))) + ((:*:) (M1 (K1 g10)) + ((:*:) (M1 (K1 g11)) + (M1 (K1 g12))))))) + -> (,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 } + +instance Generic1 + ((,,,,,,,,,,,) a b c d e f g h i j k) where + type Rep1 ((,,,,,,,,,,,) a b c d e f g h i j k) = Rep1Tuple12 a b c d e f g h i j k + + from1 x + = M1 + (case x of { + (,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 + -> M1 + ((:*:) + ((:*:) + ((:*:) + (M1 (K1 g1)) + ((:*:) + (M1 (K1 g2)) + (M1 (K1 g3)))) + ((:*:) + (M1 (K1 g4)) + ((:*:) + (M1 (K1 g5)) + (M1 (K1 g6))))) + ((:*:) + ((:*:) + (M1 (K1 g7)) + ((:*:) + (M1 (K1 g8)) + (M1 (K1 g9)))) + ((:*:) + (M1 (K1 g10)) + ((:*:) + (M1 (K1 g11)) + (M1 (Par1 g12)))))) }) + to1 (M1 x) + = case x of { + (M1 ((:*:) ((:*:) ((:*:) (M1 g1) + ((:*:) (M1 g2) + (M1 g3))) + ((:*:) (M1 g4) + ((:*:) (M1 g5) + (M1 g6)))) + ((:*:) ((:*:) (M1 g7) + ((:*:) (M1 g8) + (M1 g9))) + ((:*:) (M1 g10) + ((:*:) (M1 g11) + (M1 g12)))))) + -> (,,,,,,,,,,,) + (unK1 g1) (unK1 g2) + (unK1 g3) (unK1 g4) + (unK1 g5) (unK1 g6) + (unK1 g7) (unK1 g8) + (unK1 g9) (unK1 g10) + (unK1 g11) (unPar1 g12) } + +data D1Tuple12 +data C1_0Tuple12 + +instance Datatype D1Tuple12 where + datatypeName _ = "(,,,,,,,,,,,)" + moduleName _ = "GHC.Tuple" + +instance Constructor C1_0Tuple12 where + conName _ = "(,,,,,,,,,,,)" + +----- + +type Rep0Tuple13 a b c d e f g h i j k l m = D1 + D1Tuple13 + (C1 + C1_0Tuple13 + (((S1 + NoSelector + (Rec0 a) + :*: (S1 + NoSelector + (Rec0 + b) + :*: S1 + NoSelector + (Rec0 + c))) + :*: (S1 + NoSelector + (Rec0 + d) + :*: (S1 + NoSelector + (Rec0 + e) + :*: S1 + NoSelector + (Rec0 + f)))) + :*: ((S1 + NoSelector + (Rec0 + g) + :*: (S1 + NoSelector + (Rec0 + h) + :*: S1 + NoSelector + (Rec0 + i))) + :*: ((S1 + NoSelector + (Rec0 + j) + :*: S1 + NoSelector + (Rec0 + k)) + :*: (S1 + NoSelector + (Rec0 + l) + :*: S1 + NoSelector + (Rec0 + m)))))) +type Rep1Tuple13 a b c d e f g h i j k l = D1 + D1Tuple13 + (C1 + C1_0Tuple13 + (((S1 + NoSelector + (Rec0 a) + :*: (S1 + NoSelector + (Rec0 + b) + :*: S1 + NoSelector + (Rec0 + c))) + :*: (S1 + NoSelector + (Rec0 + d) + :*: (S1 + NoSelector + (Rec0 + e) + :*: S1 + NoSelector + (Rec0 + f)))) + :*: ((S1 + NoSelector + (Rec0 + g) + :*: (S1 + NoSelector + (Rec0 + h) + :*: S1 + NoSelector + (Rec0 + i))) + :*: ((S1 + NoSelector + (Rec0 + j) + :*: S1 + NoSelector + (Rec0 + k)) + :*: (S1 + NoSelector + (Rec0 + l) + :*: S1 + NoSelector + Par1))))) + +data D1Tuple13 +data C1_0Tuple13 + +instance Generic + (a, b, c, d, e, f, g, h, i, j, k, l, m) where + type Rep (a, b, c, d, e, f, g, h, i, j, k, l, m) = Rep0Tuple13 a b c d e f g h i j k l m + + from x + = M1 + (case x of { + (,,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 g13 + -> M1 + ((:*:) + ((:*:) + ((:*:) + (M1 (K1 g1)) + ((:*:) + (M1 (K1 g2)) + (M1 (K1 g3)))) + ((:*:) + (M1 (K1 g4)) + ((:*:) + (M1 (K1 g5)) + (M1 (K1 g6))))) + ((:*:) + ((:*:) + (M1 (K1 g7)) + ((:*:) + (M1 (K1 g8)) + (M1 (K1 g9)))) + ((:*:) + ((:*:) + (M1 (K1 g10)) + (M1 (K1 g11))) + ((:*:) + (M1 (K1 g12)) + (M1 (K1 g13)))))) }) + to (M1 x) + = case x of { + (M1 ((:*:) ((:*:) ((:*:) (M1 (K1 g1)) + ((:*:) (M1 (K1 g2)) + (M1 (K1 g3)))) + ((:*:) (M1 (K1 g4)) + ((:*:) (M1 (K1 g5)) + (M1 (K1 g6))))) + ((:*:) ((:*:) (M1 (K1 g7)) + ((:*:) (M1 (K1 g8)) + (M1 (K1 g9)))) + ((:*:) ((:*:) (M1 (K1 g10)) + (M1 (K1 g11))) + ((:*:) (M1 (K1 g12)) + (M1 (K1 g13))))))) + -> (,,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 g13 } + +instance Generic1 + ((,,,,,,,,,,,,) a b c d e f g h i j k l) where + type Rep1 ((,,,,,,,,,,,,) a b c d e f g h i j k l) = Rep1Tuple13 a b c d e f g h i j k l + + from1 x + = M1 + (case x of { + (,,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 g13 + -> M1 + ((:*:) + ((:*:) + ((:*:) + (M1 (K1 g1)) + ((:*:) + (M1 (K1 g2)) + (M1 (K1 g3)))) + ((:*:) + (M1 (K1 g4)) + ((:*:) + (M1 (K1 g5)) + (M1 (K1 g6))))) + ((:*:) + ((:*:) + (M1 (K1 g7)) + ((:*:) + (M1 (K1 g8)) + (M1 (K1 g9)))) + ((:*:) + ((:*:) + (M1 (K1 g10)) + (M1 (K1 g11))) + ((:*:) + (M1 (K1 g12)) + (M1 (Par1 g13)))))) }) + to1 (M1 x) + = case x of { + (M1 ((:*:) ((:*:) ((:*:) (M1 g1) + ((:*:) (M1 g2) + (M1 g3))) + ((:*:) (M1 g4) + ((:*:) (M1 g5) + (M1 g6)))) + ((:*:) ((:*:) (M1 g7) + ((:*:) (M1 g8) + (M1 g9))) + ((:*:) ((:*:) (M1 g10) + (M1 g11)) + ((:*:) (M1 g12) + (M1 g13)))))) + -> (,,,,,,,,,,,,) + (unK1 g1) (unK1 g2) + (unK1 g3) (unK1 g4) + (unK1 g5) (unK1 g6) + (unK1 g7) (unK1 g8) + (unK1 g9) (unK1 g10) + (unK1 g11) (unK1 g12) + (unPar1 g13) } + +instance Datatype D1Tuple13 where + datatypeName _ = "(,,,,,,,,,,,,)" + moduleName _ = "GHC.Tuple" + +instance Constructor C1_0Tuple13 where + conName _ = "(,,,,,,,,,,,,)" + +----- + +type Rep0Tuple14 a b c d e f g h i j k l m n = D1 + D1Tuple14 + (C1 + C1_0Tuple14 + (((S1 + NoSelector + (Rec0 a) + :*: (S1 + NoSelector + (Rec0 + b) + :*: S1 + NoSelector + (Rec0 + c))) + :*: ((S1 + NoSelector + (Rec0 + d) + :*: S1 + NoSelector + (Rec0 + e)) + :*: (S1 + NoSelector + (Rec0 + f) + :*: S1 + NoSelector + (Rec0 + g)))) + :*: ((S1 + NoSelector + (Rec0 + h) + :*: (S1 + NoSelector + (Rec0 + i) + :*: S1 + NoSelector + (Rec0 + j))) + :*: ((S1 + NoSelector + (Rec0 + k) + :*: S1 + NoSelector + (Rec0 + l)) + :*: (S1 + NoSelector + (Rec0 + m) + :*: S1 + NoSelector + (Rec0 + n)))))) +type Rep1Tuple14 a b c d e f g h i j k l m = D1 + D1Tuple14 + (C1 + C1_0Tuple14 + (((S1 + NoSelector + (Rec0 a) + :*: (S1 + NoSelector + (Rec0 + b) + :*: S1 + NoSelector + (Rec0 + c))) + :*: ((S1 + NoSelector + (Rec0 + d) + :*: S1 + NoSelector + (Rec0 + e)) + :*: (S1 + NoSelector + (Rec0 + f) + :*: S1 + NoSelector + (Rec0 + g)))) + :*: ((S1 + NoSelector + (Rec0 + h) + :*: (S1 + NoSelector + (Rec0 + i) + :*: S1 + NoSelector + (Rec0 + j))) + :*: ((S1 + NoSelector + (Rec0 + k) + :*: S1 + NoSelector + (Rec0 + l)) + :*: (S1 + NoSelector + (Rec0 + m) + :*: S1 + NoSelector + Par1))))) + +instance Generic + (a, b, c, d, e, f, g, h, i, j, k, l, m, n) where + type Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n) = Rep0Tuple14 a b c d e f g h i j k l m n + + from x + = M1 + (case x of { + (,,,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 g13 g14 + -> M1 + ((:*:) + ((:*:) + ((:*:) + (M1 (K1 g1)) + ((:*:) + (M1 (K1 g2)) + (M1 (K1 g3)))) + ((:*:) + ((:*:) + (M1 (K1 g4)) + (M1 (K1 g5))) + ((:*:) + (M1 (K1 g6)) + (M1 (K1 g7))))) + ((:*:) + ((:*:) + (M1 (K1 g8)) + ((:*:) + (M1 (K1 g9)) + (M1 (K1 g10)))) + ((:*:) + ((:*:) + (M1 (K1 g11)) + (M1 (K1 g12))) + ((:*:) + (M1 (K1 g13)) + (M1 (K1 g14)))))) }) + to (M1 x) + = case x of { + (M1 ((:*:) ((:*:) ((:*:) (M1 (K1 g1)) + ((:*:) (M1 (K1 g2)) + (M1 (K1 g3)))) + ((:*:) ((:*:) (M1 (K1 g4)) + (M1 (K1 g5))) + ((:*:) (M1 (K1 g6)) + (M1 (K1 g7))))) + ((:*:) ((:*:) (M1 (K1 g8)) + ((:*:) (M1 (K1 g9)) + (M1 (K1 g10)))) + ((:*:) ((:*:) (M1 (K1 g11)) + (M1 (K1 g12))) + ((:*:) (M1 (K1 g13)) + (M1 (K1 g14))))))) + -> (,,,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 g13 g14 } + +instance Generic1 + ((,,,,,,,,,,,,,) a b c d e f g h i j k l m) where + type Rep1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m) = Rep1Tuple14 a b c d e f g h i j k l m + + from1 x + = M1 + (case x of { + (,,,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 g13 g14 + -> M1 + ((:*:) + ((:*:) + ((:*:) + (M1 (K1 g1)) + ((:*:) + (M1 (K1 g2)) + (M1 (K1 g3)))) + ((:*:) + ((:*:) + (M1 (K1 g4)) + (M1 (K1 g5))) + ((:*:) + (M1 (K1 g6)) + (M1 (K1 g7))))) + ((:*:) + ((:*:) + (M1 (K1 g8)) + ((:*:) + (M1 (K1 g9)) + (M1 (K1 g10)))) + ((:*:) + ((:*:) + (M1 (K1 g11)) + (M1 (K1 g12))) + ((:*:) + (M1 (K1 g13)) + (M1 (Par1 g14)))))) }) + to1 (M1 x) + = case x of { + (M1 ((:*:) ((:*:) ((:*:) (M1 g1) + ((:*:) (M1 g2) + (M1 g3))) + ((:*:) ((:*:) (M1 g4) + (M1 g5)) + ((:*:) (M1 g6) + (M1 g7)))) + ((:*:) ((:*:) (M1 g8) + ((:*:) (M1 g9) + (M1 g10))) + ((:*:) ((:*:) (M1 g11) + (M1 g12)) + ((:*:) (M1 g13) + (M1 g14)))))) + -> (,,,,,,,,,,,,,) + (unK1 g1) (unK1 g2) + (unK1 g3) (unK1 g4) + (unK1 g5) (unK1 g6) + (unK1 g7) (unK1 g8) + (unK1 g9) (unK1 g10) + (unK1 g11) (unK1 g12) + (unK1 g13) (unPar1 g14) } + +data D1Tuple14 +data C1_0Tuple14 + +instance Datatype D1Tuple14 where + datatypeName _ = "(,,,,,,,,,,,,,)" + moduleName _ = "GHC.Tuple" + +instance Constructor C1_0Tuple14 where + conName _ = "(,,,,,,,,,,,,,)" + +----- + +type Rep0Tuple15 a b c d e f g h i j k l m n o = D1 + D1Tuple15 + (C1 + C1_0Tuple15 + (((S1 + NoSelector + (Rec0 a) + :*: (S1 + NoSelector + (Rec0 + b) + :*: S1 + NoSelector + (Rec0 + c))) + :*: ((S1 + NoSelector + (Rec0 + d) + :*: S1 + NoSelector + (Rec0 + e)) + :*: (S1 + NoSelector + (Rec0 + f) + :*: S1 + NoSelector + (Rec0 + g)))) + :*: (((S1 + NoSelector + (Rec0 + h) + :*: S1 + NoSelector + (Rec0 + i)) + :*: (S1 + NoSelector + (Rec0 + j) + :*: S1 + NoSelector + (Rec0 + k))) + :*: ((S1 + NoSelector + (Rec0 + l) + :*: S1 + NoSelector + (Rec0 + m)) + :*: (S1 + NoSelector + (Rec0 + n) + :*: S1 + NoSelector + (Rec0 + o)))))) +type Rep1Tuple15 a b c d e f g h i j k l m n = D1 + D1Tuple15 + (C1 + C1_0Tuple15 + (((S1 + NoSelector + (Rec0 a) + :*: (S1 + NoSelector + (Rec0 + b) + :*: S1 + NoSelector + (Rec0 + c))) + :*: ((S1 + NoSelector + (Rec0 + d) + :*: S1 + NoSelector + (Rec0 + e)) + :*: (S1 + NoSelector + (Rec0 + f) + :*: S1 + NoSelector + (Rec0 + g)))) + :*: (((S1 + NoSelector + (Rec0 + h) + :*: S1 + NoSelector + (Rec0 + i)) + :*: (S1 + NoSelector + (Rec0 + j) + :*: S1 + NoSelector + (Rec0 + k))) + :*: ((S1 + NoSelector + (Rec0 + l) + :*: S1 + NoSelector + (Rec0 + m)) + :*: (S1 + NoSelector + (Rec0 + n) + :*: S1 + NoSelector + Par1))))) + +instance Generic + (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) where + type Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) = Rep0Tuple15 a b c d e f g h i j k l m n o + + from x + = M1 + (case x of { + (,,,,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 g13 g14 g15 + -> M1 + ((:*:) + ((:*:) + ((:*:) + (M1 (K1 g1)) + ((:*:) + (M1 (K1 g2)) + (M1 (K1 g3)))) + ((:*:) + ((:*:) + (M1 (K1 g4)) + (M1 (K1 g5))) + ((:*:) + (M1 (K1 g6)) + (M1 (K1 g7))))) + ((:*:) + ((:*:) + ((:*:) + (M1 (K1 g8)) + (M1 (K1 g9))) + ((:*:) + (M1 (K1 g10)) + (M1 (K1 g11)))) + ((:*:) + ((:*:) + (M1 (K1 g12)) + (M1 (K1 g13))) + ((:*:) + (M1 (K1 g14)) + (M1 (K1 g15)))))) }) + to (M1 x) + = case x of { + (M1 ((:*:) ((:*:) ((:*:) (M1 (K1 g1)) + ((:*:) (M1 (K1 g2)) + (M1 (K1 g3)))) + ((:*:) ((:*:) (M1 (K1 g4)) + (M1 (K1 g5))) + ((:*:) (M1 (K1 g6)) + (M1 (K1 g7))))) + ((:*:) ((:*:) ((:*:) (M1 (K1 g8)) + (M1 (K1 g9))) + ((:*:) (M1 (K1 g10)) + (M1 (K1 g11)))) + ((:*:) ((:*:) (M1 (K1 g12)) + (M1 (K1 g13))) + ((:*:) (M1 (K1 g14)) + (M1 (K1 g15))))))) + -> (,,,,,,,,,,,,,,) + g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 g13 g14 g15 } + +instance Generic1 + ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n) where + type Rep1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n) = Rep1Tuple15 a b c d e f g h i j k l m n + + from1 x + = M1 + (case x of { + (,,,,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 g13 g14 g15 + -> M1 + ((:*:) + ((:*:) + ((:*:) + (M1 (K1 g1)) + ((:*:) + (M1 (K1 g2)) + (M1 (K1 g3)))) + ((:*:) + ((:*:) + (M1 (K1 g4)) + (M1 (K1 g5))) + ((:*:) + (M1 (K1 g6)) + (M1 (K1 g7))))) + ((:*:) + ((:*:) + ((:*:) + (M1 (K1 g8)) + (M1 (K1 g9))) + ((:*:) + (M1 (K1 g10)) + (M1 (K1 g11)))) + ((:*:) + ((:*:) + (M1 (K1 g12)) + (M1 (K1 g13))) + ((:*:) + (M1 (K1 g14)) + (M1 (Par1 g15)))))) }) + to1 (M1 x) + = case x of { + (M1 ((:*:) ((:*:) ((:*:) (M1 g1) + ((:*:) (M1 g2) + (M1 g3))) + ((:*:) ((:*:) (M1 g4) + (M1 g5)) + ((:*:) (M1 g6) + (M1 g7)))) + ((:*:) ((:*:) ((:*:) (M1 g8) + (M1 g9)) + ((:*:) (M1 g10) + (M1 g11))) + ((:*:) ((:*:) (M1 g12) + (M1 g13)) + ((:*:) (M1 g14) + (M1 g15)))))) + -> (,,,,,,,,,,,,,,) + (unK1 g1) (unK1 g2) + (unK1 g3) (unK1 g4) + (unK1 g5) (unK1 g6) + (unK1 g7) (unK1 g8) + (unK1 g9) (unK1 g10) + (unK1 g11) (unK1 g12) + (unK1 g13) (unK1 g14) + (unPar1 g15) } + +data D1Tuple15 +data C1_0Tuple15 + +instance Datatype D1Tuple15 where + datatypeName _ = "(,,,,,,,,,,,,,,)" + moduleName _ = "GHC.Tuple" + +instance Constructor C1_0Tuple15 where + conName _ = "(,,,,,,,,,,,,,,)" + +# endif #endif #if !(MIN_VERSION_base(4,14,0)) diff --git a/src/Generics/Deriving/TH/Internal.hs b/src/Generics/Deriving/TH/Internal.hs --- a/src/Generics/Deriving/TH/Internal.hs +++ b/src/Generics/Deriving/TH/Internal.hs @@ -1,3 +1,4 @@ +{-# LANGUAGE BangPatterns #-} {-# LANGUAGE CPP #-} {- | @@ -18,7 +19,7 @@ import Data.Char (isAlphaNum, ord) import Data.Foldable (foldr') -import Data.List +import qualified Data.List as List import qualified Data.Map as Map import Data.Map as Map (Map) import Data.Maybe (mapMaybe) @@ -197,11 +198,11 @@ -- | Construct a type via curried application. applyTyToTys :: Type -> [Type] -> Type -applyTyToTys = foldl' AppT +applyTyToTys = List.foldl' AppT -- | Apply a type constructor name to type variable binders. applyTyToTvbs :: Name -> [TyVarBndr_ flag] -> Type -applyTyToTvbs = foldl' (\a -> AppT a . tyVarBndrToType) . ConT +applyTyToTvbs = List.foldl' (\a -> AppT a . tyVarBndrToType) . ConT -- | Split an applied type into its individual components. For example, this: -- @@ -363,10 +364,17 @@ shrink (_, b, c) = (b, c) foldBal :: (a -> a -> a) -> a -> [a] -> a -foldBal _ x [] = x -foldBal _ _ [y] = y -foldBal op x l = let (a,b) = splitAt (length l `div` 2) l - in foldBal op x a `op` foldBal op x b +{-# INLINE foldBal #-} -- inlined to produce specialised code for each op +foldBal op0 x0 xs0 = fold_bal op0 x0 (length xs0) xs0 + where + fold_bal op x !n xs = case xs of + [] -> x + [a] -> a + _ -> let !nl = n `div` 2 + !nr = n - nl + (l,r) = splitAt nl xs + in fold_bal op x nl l + `op` fold_bal op x nr r isNewtypeVariant :: DatatypeVariant_ -> Bool isNewtypeVariant Datatype_ = False diff --git a/tests/ExampleSpec.hs b/tests/ExampleSpec.hs --- a/tests/ExampleSpec.hs +++ b/tests/ExampleSpec.hs @@ -241,9 +241,9 @@ # else (a :: *) (b :: *) (c :: * -> *) (d :: *) (e :: *) # endif -newtype instance MyType3 (f p) (f p) f p q = MyType3Newtype q -data instance MyType3 Bool () f p q = MyType3True | MyType3False -data instance MyType3 Int () f p q = MyType3Hash q Addr# Char# Double# Float# Int# Word# +newtype instance MyType3 (f p) (f p) f p (q :: *) = MyType3Newtype q +data instance MyType3 Bool () f p q = MyType3True | MyType3False +data instance MyType3 Int () f p (q :: *) = MyType3Hash q Addr# Char# Double# Float# Int# Word# #endif $(deriveAll0And1 ''Empty)