EA      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv w x y z { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @  Safe ABCDEFGHIJKLMBHIJKLM ABCDEFGHIJKLM#(c) 2008--2009 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableNone*NIndicates whether Generic(1) is being derived for a plain data type (DataPlain) or a data family instance (DataFamily). DataFamily bundles the Name of the data family instance's first constructor (for Name-generation purposes) and the types used to instantiate the instance.OLike  GenericArity!, but bundling two things in the P case: The Q of the last type parameter.XIf that last type parameter had kind k (where k is some kind variable), then it has R the kind variable Q. Otherwise, it has S.T7Indicates whether Generic or Generic1 is being derived.UEWhether a type is not of kind *, is of kind *, or is a kind variable.VBExpands all type synonyms in a type. Written by Dan Rosn in the  genifunctors package (licensed under BSD3).W8Does a Type have kind * or k (for some kind variable k)?XReturns R the kind variable Q of a U# if it exists. Otherwise, returns S.YjConcat together all of the StarKindStatuses that are IsKindVar and extract the kind variables' Names out.Z"Returns True if a Type has kind *.[GGets all of the type/kind variable names mentioned somewhere in a Type.\BGets all of the kind variable names mentioned somewhere in a Kind.]XGets all of the specified type/kind variable names mentioned in a Type. In contrast to [, ] does not go into kinds of ^s._PIs the given type a type family constructor (and not a data family constructor)?`*True if the type does not mention the Namea)Construct a type via curried application.b7Apply a type constructor name to type variable binders.cHSplit an applied type into its individual components. For example, this: Either Int Char would split to this: [Either, Int, Char] dESplit a type signature by the arrows on its spine. For example, this: #forall a b. (a -> b) -> Char -> () would split to this: ([a, b], [a -> b, Char, ()]) e)Like uncurryType, except on a kind level.fKIf a VarT is missing an explicit kind signature, steal it from a TyVarBndr.gKGenerate a list of fresh names with a common prefix, and numbered suffixes.hChecks to see if the last types in a data family instance can be safely eta- reduced (i.e., dropped), given the other types. This checks for three conditions: +All of the dropped types are type variables%All of the dropped types are distinct<None of the remaining types mention any of the dropped typesidExtract the Name from a type variable. If the argument Type is not a type variable, throw an error.jIs the given type a variable?kIs the given kind a variable?lReturns m is a n contains no type variables.oReturns m is a p contains no kind variables.q6Peel off a kind signature from a Type (if it has one).r;Peel off a kind signature from a TyVarBndr (if it has one).s9Does the given type mention any of the Names in the list?tAAre all of the items in a list (which have an ordering) distinct?HThis uses Set (as opposed to nub) for better asymptotic time complexity.uAVariant of foldr1 which returns a special element for empty listsv#Extracts the name of a constructor.w;Extracts the constructors of a data or newtype declaration.x*Credit to Vctor Lpez Juan for this tricky}One of the last type variables cannot be eta-reduced (see the canEtaReduce function for the criteria it would have to meet).zEither the given data type doesn't have enough type variables, or one of the type variables to be eta-reduced cannot realize kind *.{HDeriving Generic(1) doesn't work with ExistentialQuantification or GADTs|>Cannot have a constructor argument of form (forall a1 ... an.  type) when deriving Generic(1)}Cannot have a Generic(1) instance where the instance head's type is instantiated to be a more "saturated" type than the original data declaration. That means something like this would be rejected: {- LANGUAGE TypeInType (-} data Hm k (a :: k) deriving Generic1 Since having a Generic1 instance would force k to be instantiated with *, resulting in an instance Generic1 (Hm *) instead of instance Generic1 (Hm k).~"Boilerplate for top level splices.-The given Name must meet one of two criteria: JIt must be the name of a type constructor of a plain data type or newtype.NIt must be the name of a data family instance or newtype instance constructor.,Any other value will result in an exception.One cannot derive Generic(1) instance for anything that uses DatatypeContexts, so check to make sure the Cxt field of a datatype is null.NOPTUVWXYZ[\]_`abcdefghijkloqrstuvwxyz{|}~  NOPTUVWXYZ[\]_`abcdefghijkloqrstuvwxyz{|}~  NOPTUVWXYZ[\]_`abcdefghijkloqrstuvwxyz{|}~  #(c) 2008--2009 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableNoneNGiven the type and the name (as string) for the type to derive, generate the Data instance, the  Constructor instances, and the Selector instances.vOn GHC 7.11 and up, this functionality is no longer used in GHC generics, so this function generates no declarations.?Given a datatype name, derive a datatype and instance of class Datatype.vOn GHC 7.11 and up, this functionality is no longer used in GHC generics, so this function generates no declarations.@Given a datatype name, derive datatypes and instances of class  Constructor.vOn GHC 7.11 and up, this functionality is no longer used in GHC generics, so this function generates no declarations.?Given a datatype name, derive datatypes and instances of class Selector.vOn GHC 7.11 and up, this functionality is no longer used in GHC generics, so this function generates no declarations.          #(c) 2008--2009 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableNoneGiven the names of a generic class, a type to instantiate, a function in the class and the default implementation, generates the code for a basic generic instance.#A backwards-compatible synonym for .NGiven the type and the name (as string) for the type to derive, generate the Data instance, the  Constructor instances, the Selector instances, and the Representable0 instance.Like 0, except that the type variable binders in the Rep1 type synonym will have explicit kind signatures.NGiven the type and the name (as string) for the type to derive, generate the Data instance, the  Constructor instances, the Selector instances, and the Representable1 instance. Like 0, except that the type variable binders in the Rep11 type synonym will have explicit kind signatures. NGiven the type and the name (as string) for the type to derive, generate the Data instance, the  Constructor instances, the Selector instances, the Representable0 instance, and the Representable1 instance. Like  0, except that the type variable binders in the Rep and Rep12 type synonyms will have explicit kind signatures. eGiven the type and the name (as string) for the Representable0 type synonym to derive, generate the Representable0 instance. Like  0, except that the type variable binders in the Rep1 type synonym will have explicit kind signatures.eGiven the type and the name (as string) for the Representable1 type synonym to derive, generate the Representable1 instance.Like 0, except that the type variable binders in the Rep11 type synonym will have explicit kind signatures.Derive only the Rep0 type synonym. Not needed if   is used.Like /, except that the type variable binders in the Rep2 type synonym will have explicit kind signatures.Derive only the Rep1 type synonym. Not needed if  is used.Like /, except that the type variable binders in the Rep12 type synonym will have explicit kind signatures.Generates the Rep) type synonym constructor (as opposed to , which generates the type synonym declaration). After splicing it into Haskell source, it expects types as arguments. For example: type Rep (Foo a b) = $( ''Foo) a b Generates the Rep1) type synonym constructor (as opposed to , which generates the type synonym declaration). After splicing it into Haskell source, it expects types as arguments. For example: type Rep1 (Foo a b) = $( ''Foo) a b Generates the Rep) type synonym constructor (as opposed to X, which generates the type synonym declaration) applied to its type arguments. Unlike , this also takes a quoted n as an argument, e.g., type Rep (Foo a b) = $( ''Foo [t| Foo a b |]) Generates the Rep1) type synonym constructor (as opposed to X, which generates the type synonym declaration) applied to its type arguments. Unlike , this also takes a quoted n as an argument, e.g., type Rep1 (Foo a b) = $( ''Foo [t| Foo a b |]) #A backwards-compatible synonym for .1Generates a lambda expression which behaves like from.#A backwards-compatible synonym for .1Generates a lambda expression which behaves like to.1Generates a lambda expression which behaves like from1.1Generates a lambda expression which behaves like to1.;Deduces the instance type to use for a Generic(1) instance.A   !"#$%&'()*+,-./0123456789:;<Generic or Generic1(The type constructor or data family name=The type variables from the data type/data family declarationUIf using a data family instance, provides the types used to instantiate the instance=Generic or Generic1(The type constructor or data family name*The types to instantiate the instance with+True if it's a data family, False otherwise>   A   !"#$%&'()*+,-./0123456789:;<=>Safe +9;<=CDQRSafe/02349;<=BCDQRc?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safec?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safe +69:;DQR !"#$%&'()*+,-./0123456789:;< !"" ! !"#$%&'()*+,-./0123456789:;<(c) 2012 University of OxfordBSD3generics@haskell.org experimental non-portableSafe +9:;DQRT@FReturn the name of all the constructors of the type of the given term.A4Return the name of the constructor of the given term=>?@ABCD=>?@A=>?@A=>?@ABCD Trustworthy +69:;BDQREFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~EFGHIEFFIGHEFFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Trustworthy +69:;DQR>The list of values in the subrange defined by a bounding pair.,The position of a subscript in the subrange.Returns mB the given subscript lies in the range defined the bounding pair.wInterleave elements from two lists. Similar to (++), but swap left and right arguments on every recursive application. From Mark Jones' talk at AFP2008{Diagonalization of nested lists. Ensure that some elements from every sublist will be included. Handles infinite sublists. From Mark Jones' talk at AFP2008      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~5Safe +69:;DQR., Trustworthy 69:;BQRT      !"#$%&'()*+,-./0123456789:;<=>? |      !"#$%&'()*+,-./0123456789:;<=>?42011-2012 Universiteit Utrecht, University of OxfordBSD3generics@haskell.org experimental non-portable Trustworthy +69:;<=DQR8@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstu@EFABCDGHIJKLMNOPQRSTUVWXY @AABBCCDDEEFFSTUVWXYMNOPQRGHIJKL,@ AABBCCDDEEFFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstu Safe +69:;DQRBvwxyz{|}~v{wxyz|}~vwwxyz{|}~9v wwxyz{|}~ Safe+6:DQRGeneric Generic Generic /.( Safe+6:DQROnly available with base-4.9 or later,     (     666 Safe +69:;DQR. !"#$%&'()*+,-./0123456789:;<=>?@ ) !"#$%&'()*+,-./0123456789:;<=>?@Safe?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"=>?@AEFGHI@EFABCDGHIJKLMNOPQRSTUVWXY !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                        ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` abcdefghijhiklmnopqrstuefvwxyz{|}~efef      !"#$%%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWhXhXYhXZhX[hXhX\hX]hX^hX_hX`hXahXbhXchXdhXehXfhXghXhhXihXjhXkhXlhXmhXnhXnhXohXohXphXqhXqhXrhXshXshXthXuhXuhXvhXwhXxhXyhXzhXzhX{hX|hX}hX~hXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhXhihihihihhhhhhhhhhhhhhhhhhhhhhhhhhhh.generic-deriving-1.10.7-97cry435kPFExVapHSVN7cGenerics.Deriving.THGenerics.Deriving.CopointGenerics.Deriving.ConNamesGenerics.Deriving.EqGenerics.Deriving.EnumGenerics.Deriving.FunctorGenerics.Deriving.ShowGenerics.Deriving.UniplateGenerics.Deriving.FoldableGenerics.Deriving.MonoidGenerics.Deriving.SemigroupGenerics.Deriving.TraversablePaths_generic_derivingGenerics.Deriving.TH.InternalGenerics.Deriving.TH.Post4_9Generics.Deriving.InstancesGenerics.Deriving.Base.InternalGenerics.Deriving.BaseGenerics.Deriving deriveMeta deriveDataderiveConstructorsderiveSelectors simplInstance deriveAll deriveAll0deriveAll0WithKindSigs deriveAll1deriveAll1WithKindSigsderiveAll0And1deriveAll0And1WithKindSigsderiveRepresentable0 deriveRepresentable0WithKindSigsderiveRepresentable1 deriveRepresentable1WithKindSigs deriveRep0deriveRep0WithKindSigs deriveRep1deriveRep1WithKindSigsmakeRep0makeRep1makeRep0FromTypemakeRep1FromTypemakeFrom makeFrom0makeTomakeTo0 makeFrom1makeTo1GCopointgcopoint GCopoint' gcopoint'gcopointdefault$fGCopointWrappedMonoid$fGCopointWrappedMonad $fGCopointSum$fGCopointSum0 $fGCopointMin $fGCopointMax$fGCopointLast$fGCopointIdentity$fGCopointFirst$fGCopointDual $fGCopointArg $fGCopointAlt$fGCopoint(,,,,,,)$fGCopoint(,,,,,)$fGCopoint(,,,,)$fGCopoint(,,,)$fGCopoint(,,) $fGCopoint(,)$fGCopoint':.:$fGCopoint'Rec1$fGCopoint':*:$fGCopoint':+: $fGCopoint'M1 $fGCopoint'K1$fGCopoint'Par1 $fGCopoint'U1ConNames gconNames gconNameOfconNames conNameOf$fConNamesTYPEM1$fConNamesTYPEM10$fConNamesTYPE:+:GEqgeqGEq'geq' geqdefault $fGEqZipList$fGEqWrappedMonoid $fGEqWordPtr $fGEqWord64 $fGEqWord32 $fGEqWord16 $fGEqWord8 $fGEqWord $fGEqVoid $fGEqVersion $fGEqURec $fGEqURec0 $fGEqURec1 $fGEqURec2 $fGEqURec3 $fGEqURec4$fGEqU1$fGEqSum$fGEqSourceUnpackedness$fGEqSourceStrictness$fGEqStablePtr $fGEqSeekMode $fGEqRec1$fGEqPtr $fGEqProxy $fGEqProduct $fGEqPar1 $fGEqOrdering $fGEqOption $fGEqNonEmpty $fGEqNatural$fGEqMin$fGEqMax $fGEqMaybe$fGEqM1 $fGEqLast $fGEqLast0$fGEqK1 $fGEqIOMode$fGEqIOErrorType$fGEqIOException $fGEqIntPtr $fGEqInteger $fGEqInt64 $fGEqInt32 $fGEqInt16 $fGEqInt8$fGEqInt $fGEqIdentity$fGEqHandlePosn $fGEqHandle$fGEqGeneralCategory $fGEqFunPtr$fGEqForeignPtr $fGEqFloat $fGEqFixity $fGEqFirst $fGEqFirst0$fGEqFd $fGEqExitCode $fGEqErrno $fGEqEither $fGEqDual $fGEqDouble$fGEqDecidedStrictness $fGEqCWchar $fGEqCUShort$fGEqCUSeconds $fGEqCULong $fGEqCULLong $fGEqCUIntPtr $fGEqCUIntMax $fGEqCUInt $fGEqCUid $fGEqCUChar $fGEqCTime $fGEqCTcflag $fGEqCSsize $fGEqCSize$fGEqCSigAtomic $fGEqCShort$fGEqCSUSeconds $fGEqCSpeed $fGEqCSChar $fGEqCRLim $fGEqCPtrdiff $fGEqCPid $fGEqConst $fGEqComplex $fGEqCOff $fGEqCNlink $fGEqCMode $fGEqCLong $fGEqCLLong $fGEqCIntPtr $fGEqCIntMax $fGEqCInt $fGEqCIno $fGEqChar $fGEqCGid $fGEqCFloat $fGEqCDouble $fGEqCDev $fGEqCClock $fGEqCChar$fGEqCCc$fGEqBufferMode $fGEqBool$fGEqAssociativity$fGEqArg$fGEqAny$fGEqAlt$fGEqAll$fGEq:.:$fGEq:*:$fGEq:+:$fGEq[] $fGEq(,,,,,,) $fGEq(,,,,,) $fGEq(,,,,) $fGEq(,,,) $fGEq(,,)$fGEq(,)$fGEq()$fGEq'TYPEURec$fGEq'TYPEURec0$fGEq'TYPEURec1$fGEq'TYPEURec2$fGEq'TYPEURec3$fGEq'TYPEURec4 $fGEq'TYPE:*: $fGEq'TYPE:+: $fGEq'TYPEM1 $fGEq'TYPEK1 $fGEq'TYPEU1GIxrangeindexinRangeGEnumgenumEnum'enum' genumDefault toEnumDefaultfromEnumDefault rangeDefault indexDefaultinRangeDefault$fGIxWrappedMonoid $fGIxWordPtr $fGIxWord64 $fGIxWord32 $fGIxWord16 $fGIxWord8 $fGIxWord$fGIxSum $fGIxProxy $fGIxProduct $fGIxOrdering $fGIxOption $fGIxNonEmpty $fGIxNatural$fGIxMin $fGIxMaybe$fGIxMax $fGIxLast $fGIxLast0 $fGIxIntPtr $fGIxInteger $fGIxInt64 $fGIxInt32 $fGIxInt16 $fGIxInt8$fGIxInt $fGIxIdentity $fGIxFixity $fGIxFirst $fGIxFirst0$fGIxFd $fGIxExitCode $fGIxEither $fGIxDual $fGIxCWchar $fGIxCUShort $fGIxCULong $fGIxCULLong $fGIxCUIntPtr $fGIxCUIntMax $fGIxCUInt $fGIxCUid $fGIxCUChar $fGIxCTcflag $fGIxCSsize $fGIxCSize$fGIxCSigAtomic $fGIxCShort $fGIxCSChar $fGIxCRLim $fGIxCPtrdiff $fGIxCPid $fGIxCOff $fGIxCNlink $fGIxCMode $fGIxCLong $fGIxCLLong $fGIxCIntPtr $fGIxCIntMax $fGIxCInt $fGIxCIno $fGIxCGid $fGIxCChar $fGIxBool$fGIxAssociativity$fGIxArg$fGIxAny$fGIxAlt$fGIxAll$fGIx[] $fGIx(,,,,,,) $fGIx(,,,,,) $fGIx(,,,,) $fGIx(,,,) $fGIx(,,)$fGIx(,)$fGIx()$fGEnumZipList$fGEnumWrappedMonoid$fGEnumWordPtr $fGEnumWord64 $fGEnumWord32 $fGEnumWord16 $fGEnumWord8 $fGEnumWord $fGEnumU1 $fGEnumSum $fGEnumRec1 $fGEnumProxy$fGEnumProduct $fGEnumPar1$fGEnumOrdering $fGEnumOption$fGEnumNonEmpty$fGEnumNatural $fGEnumMin $fGEnumMaybe $fGEnumMax $fGEnumM1 $fGEnumLast $fGEnumLast0 $fGEnumK1 $fGEnumIntPtr$fGEnumInteger $fGEnumInt64 $fGEnumInt32 $fGEnumInt16 $fGEnumInt8 $fGEnumInt$fGEnumIdentity $fGEnumFloat $fGEnumFixity $fGEnumFirst $fGEnumFirst0 $fGEnumFd$fGEnumExitCode $fGEnumEither $fGEnumDual $fGEnumDouble $fGEnumCWchar$fGEnumCUShort$fGEnumCUSeconds $fGEnumCULong$fGEnumCULLong$fGEnumCUIntPtr$fGEnumCUIntMax $fGEnumCUInt $fGEnumCUid $fGEnumCUChar $fGEnumCTime$fGEnumCTcflag $fGEnumCSsize $fGEnumCSize$fGEnumCSigAtomic $fGEnumCShort$fGEnumCSUSeconds $fGEnumCSpeed $fGEnumCSChar $fGEnumCRLim$fGEnumCPtrdiff $fGEnumCPid $fGEnumConst$fGEnumComplex $fGEnumCOff $fGEnumCNlink $fGEnumCMode $fGEnumCLong $fGEnumCLLong$fGEnumCIntPtr$fGEnumCIntMax $fGEnumCInt $fGEnumCIno $fGEnumCGid $fGEnumCFloat$fGEnumCDouble $fGEnumCDev $fGEnumCClock $fGEnumCChar $fGEnumCCc $fGEnumBool$fGEnumAssociativity $fGEnumArg $fGEnumAny $fGEnumAlt $fGEnumAll $fGEnum:.: $fGEnum:*: $fGEnum:+: $fGEnum[]$fGEnum(,,,,,,)$fGEnum(,,,,,) $fGEnum(,,,,) $fGEnum(,,,) $fGEnum(,,) $fGEnum(,) $fGEnum()$fEnum'TYPE:*:$fEnum'TYPE:+: $fEnum'TYPEM1 $fEnum'TYPEK1 $fEnum'TYPEU1GFunctorgmap GFunctor'gmap' gmapdefault$fGFunctorZipList$fGFunctorWrappedMonoid $fGFunctorSum$fGFunctorSum0$fGFunctorProxy$fGFunctorProduct$fGFunctorProduct0$fGFunctorOption$fGFunctorNonEmpty $fGFunctorMin$fGFunctorMaybe $fGFunctorMax$fGFunctorLast$fGFunctorLast0 $fGFunctorIO$fGFunctorIdentity$fGFunctorFirst$fGFunctorFirst0$fGFunctorEither$fGFunctorDual$fGFunctorConst$fGFunctorComplex $fGFunctorArg $fGFunctorAlt $fGFunctor[] $fGFunctor(,)$fGFunctor(->)$fGFunctor'URec$fGFunctor'URec0$fGFunctor'URec1$fGFunctor'URec2$fGFunctor'URec3$fGFunctor'URec4$fGFunctor':.:$fGFunctor':*:$fGFunctor':+: $fGFunctor'M1$fGFunctor'Rec1 $fGFunctor'K1$fGFunctor'Par1 $fGFunctor'U1GShow gshowsPrecgshowsgshowGShow' gshowsPrec' isNullarygshowsPrecdefault$fGShowZipList$fGShowWrappedMonoid$fGShowWordPtr $fGShowWord64 $fGShowWord32 $fGShowWord16 $fGShowWord8 $fGShowWord $fGShowVoid$fGShowVersion $fGShowURec $fGShowURec0 $fGShowURec1 $fGShowURec2 $fGShowURec3 $fGShowU1 $fGShowSum $fGShow[]$fGShowSeekMode $fGShowRec1 $fGShowPtr $fGShowProxy$fGShowProduct $fGShowPar1$fGShowOrdering $fGShowOption$fGShowNonEmpty$fGShowNatural $fGShowMin $fGShowMaybe $fGShowMax $fGShowM1 $fGShowLast $fGShowLast0 $fGShowK1 $fGShowIOMode$fGShowIOErrorType$fGShowIOException $fGShowIntPtr$fGShowInteger $fGShowInt64 $fGShowInt32 $fGShowInt16 $fGShowInt8 $fGShowInt$fGShowIdentity$fGShowHandlePosn $fGShowHandle$fGShowGeneralCategory $fGShowFunPtr$fGShowForeignPtr $fGShowFloat $fGShowFixity $fGShowFirst $fGShowFirst0 $fGShowFd$fGShowExitCode $fGShowEither $fGShowDual $fGShowDouble $fGShowCWchar$fGShowCUShort$fGShowCUSeconds $fGShowCULong$fGShowCULLong$fGShowCUIntPtr$fGShowCUIntMax $fGShowCUInt $fGShowCUChar $fGShowCTime $fGShowCSize$fGShowCSigAtomic $fGShowCShort$fGShowCSUSeconds $fGShowCSChar$fGShowCPtrdiff $fGShowConst$fGShowComplex $fGShowCLong $fGShowCLLong$fGShowCIntPtr$fGShowCIntMax $fGShowCInt $fGShowChar $fGShowCFloat$fGShowCDouble $fGShowCClock $fGShowCChar$fGShowBufferMode $fGShowBool$fGShowAssociativity $fGShowArg $fGShowAny $fGShowAlt $fGShowAll $fGShow:.: $fGShow:*: $fGShow:+: $fGShow[]0$fGShow(,,,,,,)$fGShow(,,,,,) $fGShow(,,,,) $fGShow(,,,) $fGShow(,,) $fGShow(,) $fGShow() $fGShow'URec $fGShow'URec0 $fGShow'URec1 $fGShow'URec2 $fGShow'URec3 $fGShow':*: $fGShow':+: $fGShow'M1 $fGShow'M10 $fGShow'M11 $fGShow'K1 $fGShow'U1UniplatechildrencontextdescenddescendM transform transformM Uniplate' children'descend' descendM' transform' transformM'childrendefaultcontextdefaultdescenddefaultdescendMdefaulttransformdefaulttransformMdefaultuniplateuniverserewriterewriteMcontextsholespara $fUniplate[]$fUniplateEither$fUniplateMaybe$fUniplate(,,,,,,)$fUniplate(,,,,,)$fUniplate(,,,,)$fUniplate(,,,)$fUniplate(,,) $fUniplate(,) $fUniplate() $fUniplateInt$fUniplateFloat$fUniplateDouble$fUniplateChar$fUniplateBool$fContext'TYPE:*:b$fContext'TYPE:*:a$fContext'TYPE:+:b$fContext'TYPEM1b$fContext'TYPEK1b$fContext'TYPEK1a$fContext'TYPEU1b$fUniplate'TYPE:*:b$fUniplate'TYPE:+:b$fUniplate'TYPEM1b$fUniplate'TYPEK1b$fUniplate'TYPEK1a$fUniplate'TYPEU1a GFoldablegfoldMapgfoldgfoldrgfoldr'gfoldlgfoldl'gfoldr1gfoldl1 GFoldable' gfoldMap'gfoldMapdefaultgtoListgconcat gconcatMapgandgorganygallgsumgproductgmaximum gmaximumBygminimum gminimumBygelemgnotElemgfind$fGFoldableZipList$fGFoldableWrappedMonoid$fGFoldableSum$fGFoldableSum0$fGFoldableProxy$fGFoldableProduct$fGFoldableProduct0$fGFoldableOption$fGFoldableNonEmpty$fGFoldableMin$fGFoldableMaybe$fGFoldableMax$fGFoldableLast$fGFoldableLast0$fGFoldableIdentity$fGFoldableFirst$fGFoldableFirst0$fGFoldableEither$fGFoldableDual$fGFoldableConst$fGFoldableComplex$fGFoldableArg $fGFoldable[]$fGFoldable(,)$fGFoldable'URec$fGFoldable'URec0$fGFoldable'URec1$fGFoldable'URec2$fGFoldable'URec3$fGFoldable'URec4$fGFoldable':.:$fGFoldable':*:$fGFoldable':+:$fGFoldable'M1$fGFoldable'Rec1$fGFoldable'K1$fGFoldable'Par1$fGFoldable'U1GMonoidgmemptygmappendgmconcatMonoid'mempty'mappend'GMonoid'gmempty' gmappend'gmemptydefaultgmappenddefault memptydefaultmappenddefault$fGMonoid(,,,,,,,)$fGMonoid(,,,,,,)$fGMonoid(,,,,,)$fGMonoid(,,,,)$fGMonoid(,,,) $fGMonoid(,,) $fGMonoid(,)$fGMonoidWrappedMonoid$fGMonoidIdentity$fGMonoidProxy$fGMonoidConst $fGMonoid(->)$fGMonoidMaybe $fGMonoidDual $fGMonoidAlt $fGMonoidEndo $fGMonoid[]$fGMonoidProduct $fGMonoidSum $fGMonoidLast$fGMonoidFirst $fGMonoidAll $fGMonoidAny $fGMonoid()$fGMonoidOrdering$fMonoid'TYPE:*:$fMonoid'TYPEM1$fMonoid'TYPEK1$fMonoid'TYPEU1$fGMonoid'TYPE:*:$fGMonoid'TYPEM1$fGMonoid'TYPEK1$fGMonoid'TYPEU1 GSemigroupgsappendgstimesgsconcat GSemigroup' gsappend'gsappenddefault$fGSemigroup(,,,,,,,)$fGSemigroup(,,,,,,)$fGSemigroup(,,,,,)$fGSemigroup(,,,,)$fGSemigroup(,,,)$fGSemigroup(,,)$fGSemigroup(,)$fGSemigroupWrappedMonoid$fGSemigroupOption$fGSemigroupNonEmpty$fGSemigroupMin$fGSemigroupMax$fGSemigroupLast$fGSemigroupFirst$fGSemigroupVoid$fGSemigroupIdentity$fGSemigroupProxy$fGSemigroupEither$fGSemigroupConst$fGSemigroup(->)$fGSemigroupMaybe$fGSemigroupDual$fGSemigroupAlt$fGSemigroupEndo$fGSemigroup[]$fGSemigroupProduct$fGSemigroupSum$fGSemigroupLast0$fGSemigroupFirst0$fGSemigroupAll$fGSemigroupAny$fGSemigroup()$fGSemigroupOrdering$fGSemigroup'TYPE:*:$fGSemigroup'TYPEM1$fGSemigroup'TYPEK1$fGSemigroup'TYPEU1 GTraversable gtraverse gsequenceAgmapM gsequence GTraversable' gtraverse'gtraversedefault$fGTraversableZipList$fGTraversableWrappedMonoid$fGTraversableSum$fGTraversableSum0$fGTraversableProxy$fGTraversableProduct$fGTraversableProduct0$fGTraversableOption$fGTraversableNonEmpty$fGTraversableMin$fGTraversableMaybe$fGTraversableMax$fGTraversableLast$fGTraversableLast0$fGTraversableIdentity$fGTraversableFirst$fGTraversableFirst0$fGTraversableEither$fGTraversableDual$fGTraversableConst$fGTraversableComplex$fGTraversableArg$fGTraversable[]$fGTraversable(,)$fGTraversable'URec$fGTraversable'URec0$fGTraversable'URec1$fGTraversable'URec2$fGTraversable'URec3$fGTraversable'URec4$fGTraversable':.:$fGTraversable':*:$fGTraversable':+:$fGTraversable'M1$fGTraversable'Rec1$fGTraversable'K1$fGTraversable'Par1$fGTraversable'U1catchIOversionbindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName DataVariety GenericKindGen1template-haskellLanguage.Haskell.TH.SyntaxNamebaseGHC.BaseJustNothing GenericClassStarKindStatus expandSyncanRealizeKindStarstarKindStatusToNamecatKindVarNames hasKindStartyVarNamesOfTypekindVarNamesOfKindvisibleTyVarsOfTypeSigT isTyFamilyground applyTyToTys applyTyToTvbs unapplyTy uncurryTy uncurryKindstealKindForType newNameList canEtaReduce varTToNameisTyVar isKindVarisTypeMonomorphicghc-prim GHC.TypesTrueTypeisKindMonomorphicKindunSigT unKindedTV mentionsName allDistinctfoldr1'constructorName dataDecCons sanitizeNameetaReductionErrorderivingKindError gadtError rankNErrorinstantiationError reifyDataInfocheckDataContext DataPlain DataFamilyGen0GenericGeneric1 NotKindStarKindStar IsKindVar KindSubst TypeSubst expandSynKind expandSynAppmkSubst substType substKindsubstNameWithKindsubstNamesWithKindStarsubstTyVarBndrKind substNameWithKindStarInTyVarBndrtyVarNamesOfTyVarBndrtyVarBndrToType tyVarBndrName tyVarBndrKindfst3snd3trd3shrink reifyConTysshowsDataVariety showNameQualoutOfPlaceTyVarError gdPackageKey mkGD4'4_d mkGD4'9_d mkGD4'4_tc mkGD4'9_tc mkGD4'4_v mkGD4'9_v mkBaseName_dmkGHCPrimName_dmkGHCPrimName_tc comp1DataName infixDataName k1DataName l1DataNameleftAssociativeDataName m1DataNamenotAssociativeDataName par1DataNameprefixDataNameproductDataName r1DataName rec1DataNamerightAssociativeDataName u1DataName uAddrDataName uCharDataNameuDoubleDataNameuFloatDataName uIntDataName uWordDataName c1TypeNamecomposeTypeNameconstructorTypeName d1TypeNamegenericTypeNamegeneric1TypeNamedatatypeTypeNamenoSelectorTypeName par1TypeNameproductTypeName rec0TypeName rec1TypeName repTypeName rep1TypeName s1TypeNameselectorTypeName sumTypeName u1TypeName uAddrTypeName uCharTypeNameuDoubleTypeNameuFloatTypeName uIntTypeName uWordTypeName v1TypeNameconFixityValNameconIsRecordValNameconNameValNamedatatypeNameValNameisNewtypeValName fromValName from1ValNamemoduleNameValNameselNameValName toValName to1ValNameuAddrHashValNameuCharHashValNameuDoubleHashValNameuFloatHashValNameuIntHashValNameuWordHashValNameunComp1ValName unK1ValName unPar1ValName unRec1ValName trueDataName falseDataNamenothingDataName justDataName mkGHCPrim_tcaddrHashTypeNamecharHashTypeNamedoubleHashTypeNamefloatHashTypeNameintHashTypeNamewordHashTypeNamecomposeValName errorValName fmapValNameundefinedValName starKindNamedecidedLazyDataNamedecidedStrictDataNamedecidedUnpackDataNameinfixIDataNamemetaConsDataNamemetaDataDataNamemetaNoSelDataNamemetaSelDataNamenoSourceStrictnessDataNamenoSourceUnpackednessDataNameprefixIDataNamesourceLazyDataNamesourceNoUnpackDataNamesourceStrictDataNamesourceUnpackDataNamepackageNameValName SelStrictInfomkMetaDataTypemkMetaConsType promoteBoolfixityIPromotedTypepromoteAssociativity mkMetaSelTypepromoteSourceUnpackednesspromoteSourceStrictnesspromoteDecidedStrictnessreifySelStrictInfo splitBangbuildTypeInstancederiveAllCommonderiveRepresentableCommonderiveRepCommon deriveInstderiveInstCommon makeRepCommonmakeRepTySynApp makeFunCommon genRepNamerepTyperepCon repConWithprodTrepField repFieldArgboxT mkCaseExpmkFrom errorFromerrorTomkTofromConprodE fromField fromFieldWrapwC boxRepNametoCon toConUnwCtoField toFieldWrapunwC unboxRepNamelrPlrEunboxedRepNamesbuildTypeInstanceFromTysgrabTyVarBndrsFromCons GHC.GenericsRepfromtoRep1from1to1Datatype moduleName datatypeName packageName isNewtype ConstructorconName conFixity conIsRecordSelectorselNameselSourceUnpackednessselSourceStrictnessselDecidedStrictnessV1U1Par1unPar1Rec1unRec1K1unK1M1unM1:+:L1R1:*::.:Comp1unComp1RDCSRec0D1C1S1URecUAddrUCharUDoubleUFloatUIntUWorduWord#uInt#uFloat#uDouble#uChar#uAddr#precFixityPrefixInfixFixityIPrefixIInfixI AssociativityLeftAssociativeRightAssociativeNotAssociativeSourceUnpackedness SourceUnpackSourceNoUnpackNoSourceUnpackednessSourceStrictness SourceLazy SourceStrictNoSourceStrictnessDecidedStrictness DecidedLazy DecidedStrict DecidedUnpackMetaMetaDataMetaConsMetaSel|||diagskewcombine findIndexgenumNumUnboundedgenumNumSignedgenumNumUnsigned rangeEnum indexIntegral inRangeOrdRecTupPrefInf intersperseappPrecContext'context'memptymappendmconcatMonoid Data.Monoid<>DualgetDualEndoappEndoAllgetAllAnygetAnySumgetSumProduct getProductFirstgetFirstLastgetLastAltgetAlt