ao      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n  Safe opqrstuvwxyz{pvwxyz{ opqrstuvwxyz{ (C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone%&B2|CA mapping of type variable Names to their auxiliary function Names.}EWhether a type is not of kind *, is of kind *, or is a kind variable.~8Does a Type have kind * or k (for some kind variable k)?Returns  the kind variable  of a }# if it exists. Otherwise, returns .jConcat together all of the StarKindStatuses that are IsKindVar and extract the kind variables' Names out.Attempt to derive a constraint on a Type. If successful, return Just the constraint and any kind variable names constrained to *. Otherwise, return Nothing and the empty list.dSee Note [Type inference in derived instances] for the heuristics used to come up with constraints.MThe given datatype has no constructors, and we don't know what to do with it.Either the given data type doesn't have enough type variables, or one of the type variables to be eta-reduced cannot realize kind *.SThe last type variable appeared in a contravariant position when deriving Functor.UA constructor has a function argument in a derived Foldable or Traversable instance.}One of the last type variables cannot be eta-reduced (see the canEtaReduce function for the criteria it would have to meet).ZThe data type has a DatatypeContext which mentions one of the eta-reduced type variables.bThe data type has an existential constraint which mentions one of the eta-reduced type variables.The data type mentions one of the n eta-reduced type variables in a place other than the last nth positions of a data type in a constructor's field. Test if an  value is the = constructor. Provided as standard with GHC 7.8 and above.Pull the value out of an / where both alternatives have the same type. ?\x -> fromEither (Left x ) == x \x -> fromEither (Right x) == x takes a list of Bools and a list of some elements and filters out these elements for which the corresponding value in the list of Bools is False. This function does not check whether the lists have equal length. takes a list of Bools and two lists as input, and outputs a new list consisting of elements from the last two input lists. For each Bool in the list, if it is ;, then it takes an element from the former list. If it is ~, it takes an element from the latter list. The elements taken correspond to the index of the Bool in its list. For example: @filterByLists [True, False, True, False] "abcd" "wxyz" = "axcz" AThis function does not check whether the lists have equal length. takes a list of Bools and a list of some elements and partitions the list according to the list of Bools. Elements corresponding to + go to the left; elements corresponding to  go to the right. For example, ;partitionByList [True, False, True] [1,2,3] == ([1,3], [2])D This function does not check whether the lists have equal length. Apply an Either Exp Exp expression to an  expression, preserving the -ness."Returns True if a Type has kind *.hasKindVarChain n kind Checks if kindj is of the form k_0 -> k_1 -> ... -> k_(n-1), where k0, k1, ..., and k_(n-1) can be * or kind variables.EIf a Type is a SigT, returns its kind signature. Otherwise, return *.1Returns the number of fields for the constructor.Returns B if it's a datatype with exactly one, non-existential constructor.Returns E if it's a datatype with one or more nullary, non-GADT constructors.Returns ; if we're dealing with existential quantification or GADTs.KGenerate a list of fresh names with a common prefix, and numbered suffixes.#Extracts the kind from a TyVarBndr.Convert a TyVarBndr to a Type.)Applies a typeclass constraint to a type.Checks 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 typesgExtract the Name from a type constructor. If the argument Type is not a type variable, throw an error.iExtract Just the Name from a type variable. If the argument Type is not a type variable, return Nothing.dExtract the Name from a type variable. If the argument Type is not a type variable, throw an error.6Peel off a kind signature from a Type (if it has one).Is the given type a variable?PIs the given type a type family constructor (and not a data family constructor)?AAre all of the items in a list (which have an ordering) distinct?HThis uses Set (as opposed to nub) for better asymptotic time complexity.9Does the given type mention any of the Names in the list?@Does an instance predicate mention any of the Names in the list?)Construct a type via curried application.7Fully applies a type constructor to its type variables.HSplit an applied type into its individual components. For example, this: Either Int Char would split to this: [Either, Int, Char] ESplit a type signature by the arrows on its spine. For example, this: .forall a b. (a ~ b) => (a -> b) -> Char -> () would split to this: (a ~ b, [a -> b, Char, ()]) )Like uncurryType, except on a kind level.CGets all of the required type variable binders mentioned in a Type. Checks if a 6 represents a tuple type constructor (other than '()') Checks if a % represents a tuple (other than '()') Checks if a S names a valid Haskell infix data constructor (i.e., does it begin with a colon?).6|}~5The typeclass for which an instance should be derived(The type constructor or data family nameThe datatype context*The types to instantiate the instance with1Are we dealing with a data family instance or not      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~6|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~-|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ (C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone 6A representation of which function is being generated. Generates an G instance declaration for the given data type or data family instance.1Generates a lambda expression which behaves like  (without requiring an  instance).1Generates a lambda expression which behaves like  (without requiring an  instance).1Generates a lambda expression which behaves like  (without requiring an  instance).1Generates a lambda expression which behaves like  (without requiring an  instance).1Generates a lambda expression which behaves like  (without requiring an  instance).1Generates a lambda expression which behaves like  (without requiring an  instance).%Generates method declarations for an  instance.FGenerates a lambda expression which behaves like the EnumFun argument.*Generates a lambda expression for fromEnumtoEnumNetc. for the given constructors. All constructors must be from the same type.(C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone(C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone%&A representation of which Eq variant is being derived. Generates an G instance declaration for the given data type or data family instance.OGenerates a lambda expression which behaves like '(==)' (without requiring an  instance). OGenerates a lambda expression which behaves like '(/=)' (without requiring an  instance).  Generates an G instance declaration for the given data type or data family instance. 1Generates a lambda expression which behaves like liftEq (without requiring an  instance).$This function is not available with transformers-0.4. 1Generates a lambda expression which behaves like eq1 (without requiring an  instance).  Generates an G instance declaration for the given data type or data family instance.$This function is not available with transformers-0.4.1Generates a lambda expression which behaves like liftEq2 (without requiring an  instance).$This function is not available with transformers-0.4.1Generates a lambda expression which behaves like eq2 (without requiring an  instance).$This function is not available with transformers-0.4.UDerive an Eq(1)(2) instance declaration (depending on the EqClass argument's value).Generates a declaration defining the primary function corresponding to a particular class ((==) for Eq, liftEq for Eq1, and liftEq2 for Eq2).hGenerates a lambda expression which behaves like (==) (for Eq), liftEq (for Eq1), or liftEq2 (for Eq2).&Generates a lambda expression for (==)liftEqNetc. for the given constructors. All constructors must be from the same type.    (C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone    (C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone%&%6A representation of which function is being generated.1A representation of which class is being derived.4Options that further configure how the functions in Data.Functor.Deriving should behave. (FFT stands for "'Functor'/'Foldable'/'Traversable'.)If `, derived instances for empty data types (i.e., ones with no data constructors) will use the  EmptyCase language extension. If $, derived instances will simply use ; instead. (This has no effect on GHCs before 7.8, since  EmptyCase' is only available in 7.8 or later.) Conservative  that doesn't attempt to use  EmptyCaseG (to prevent users from having to enable that extension at use sites.) Generates a G instance declaration for the given data type or data family instance.Like , but takes an  argument.1Generates a lambda expression which behaves like  (without requiring a  instance).Like , but takes an  argument.1Generates a lambda expression which behaves like  (without requiring a  instance).Like , but takes an  argument.1Generates a lambda expression which behaves like fold (without requiring a  instance).Like , but takes an  argument.1Generates a lambda expression which behaves like  (without requiring a  instance).Like , but takes an  argument. Generates a G instance declaration for the given data type or data family instance.Like , but takes an  argument. 1Generates a lambda expression which behaves like  (without requiring a  instance).!Like  , but takes an  argument." Generates a G instance declaration for the given data type or data family instance.#Like deriveTraverse, but takes an  argument.$1Generates a lambda expression which behaves like  (without requiring a  instance).%Like $, but takes an  argument.&1Generates a lambda expression which behaves like  (without requiring a  instance).'Like &, but takes an  argument.(1Generates a lambda expression which behaves like  (without requiring a  instance).)Like (, but takes an  argument.*1Generates a lambda expression which behaves like  (without requiring a  instance).+Like *, but takes an  argument.UDerive a class instance declaration (depending on the FunctorClass argument's value).Generates a declaration defining the primary function(s) corresponding to a particular class (fmap for Functor, foldr and foldMap for Foldable, and traverse for Traversable).HFor why both foldr and foldMap are derived for Foldable, see Trac #7436.IGenerates a lambda expression which behaves like the FunctorFun argument.gGenerates a lambda expression for the given constructors. All constructors must be from the same type.7Generates a lambda expression for a single constructor.CGenerates a lambda expression for a single constructor's arguments.^Generates a lambda expression for a single argument of a constructor. The returned value is A if its type mentions the last type parameter. Otherwise, it is .JGenerates a lambda expression for a specific type. The returned value is A if its type mentions the last type parameter. Otherwise, it is .> !"#$%&'()*+      !"#$%&'()*+5 !"#$%&'()*+     (C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone(C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone ! !(C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone"#$%&'()*+"#$%&'()*+(C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone6A representation of which function is being generated., Generates a IxG instance declaration for the given data type or data family instance.-1Generates a lambda expression which behaves like range (without requiring an Ix instance)..1Generates a lambda expression which behaves like  unsafeIndex (without requiring an Ix instance)./1Generates a lambda expression which behaves like inRange (without requiring an Ix instance).%Generates method declarations for an Ix instance.DGenerates a lambda expression which behaves like the IxFun argument.%Generates a lambda expression for an IxQ method for the given constructors. All constructors must be from the same type.,-./ ,-./ ,-./ (C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone,-./,-./(C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone%&!A representation of which Ord variant is being derived.0 Generates an "G instance declaration for the given data type or data family instance.11Generates a lambda expression which behaves like # (without requiring an " instance).2NGenerates a lambda expression which behaves like '(<)' (without requiring an " instance).3OGenerates a lambda expression which behaves like '(<=)' (without requiring an " instance).4NGenerates a lambda expression which behaves like '(>)' (without requiring an " instance).5OGenerates a lambda expression which behaves like '(>=)' (without requiring an " instance).61Generates a lambda expression which behaves like $ (without requiring an " instance).71Generates a lambda expression which behaves like % (without requiring an " instance).8 Generates an &G instance declaration for the given data type or data family instance.91Generates a lambda expression which behaves like  liftCompare (without requiring an & instance).$This function is not available with transformers-0.4.:1Generates a lambda expression which behaves like compare1 (without requiring an & instance).; Generates an 'G instance declaration for the given data type or data family instance.$This function is not available with transformers-0.4.<1Generates a lambda expression which behaves like  liftCompare2 (without requiring an ' instance).$This function is not available with transformers-0.4.=1Generates a lambda expression which behaves like compare2 (without requiring an ' instance).$This function is not available with transformers-0.4.(WDerive an Ord(1)(2) instance declaration (depending on the OrdClass argument's value).)Generates a declaration defining the primary function(s) corresponding to a particular class (compare for Ord, liftCompare for Ord1, and liftCompare2 for Ord2).*Generates a lambda expression which behaves like the OrdFun value. This function uses heuristics to determine whether to implement the OrdFun from scratch or define it in terms of compare.+gGenerates a lambda expression for the given constructors. All constructors must be from the same type.,Like -(, only it reverses the sense of the test7./012345!6&'01234567789:;<=()*+89:;<=>?@ABCDEFGHIJKLM,N0123456789:;<=-./012345!6&'01234567789:;<=()*+89:;<=>?@ABCDEFGHIJKLM,N(C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone0123456789:;<=0123456789:;<=(C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone%&OA representation of which Read variant is being derived.>4Options that further configure how the functions in Text.Read.Deriving should behave.@If :Derived P instances will implement readPrec, not Q2, and will provide a default implementation of  readListPrec in terms of readPrec.If built against  base-4.10 or later, derived 'Read1'/'Read2' instances will implement 'liftReadPrec'/'liftReadPrec2' , not  'liftReadsPrec'/'liftReadsPrec2'1, and will provide default implementations of &'liftReadListPrec'/'liftReadListPrec2' in terms of 'liftReadPrec'/'liftReadPrec2',. If built against an earlier version of base , derived 'Read1'/'Read2'F instances are not affected, so they will act as if this flag were .If :Derived P instances will implement Q.Derived R instances will implement  readsPrec1 (if built against transformers-0.4) or  liftReadsPrec& (otherwise). If not built against transformers-0.4 , derived S instances will implement liftReadsPrec2.8It's generally a good idea to enable this option, since readPrec& and friends are more efficient than Q2 and friends, since the former use the efficient ReadPrec> parser datatype while the latter use the slower, list-based T type.A> that favor readPrec over Q.B Generates a PG instance declaration for the given data type or data family instance.CLike B, but takes a > argument.D1Generates a lambda expression which behaves like Q (without requiring a P instance).E1Generates a lambda expression which behaves like readPrec (without requiring a P instance).F Generates a RG instance declaration for the given data type or data family instance.GLike F, but takes a > argument.H1Generates a lambda expression which behaves like  liftReadsPrec (without requiring a R instance).$This function is not available with transformers-0.4.I1Generates a lambda expression which behaves like  readsPrec1 (without requiring a R instance).J Generates a SG instance declaration for the given data type or data family instance.$This function is not available with transformers-0.4.KLike J, but takes a > argument.$This function is not available with transformers-0.4.L1Generates a lambda expression which behaves like liftReadsPrec2 (without requiring a S instance).$This function is not available with transformers-0.4.M1Generates a lambda expression which behaves like  readsPrec2 (without requiring a S instance).$This function is not available with transformers-0.4.UXDerive a Read(1)(2) instance declaration (depending on the ReadClass argument's value).VGenerates a declaration defining the primary function corresponding to a particular class (read(s)Prec for Read, liftRead(s)Prec for Read1, and liftRead(s)Prec2 for Read2).WGenerates a lambda expression which behaves like read(s)Prec (for Read), liftRead(s)Prec (for Read1), or liftRead(s)Prec2 (for Read2).X-Generates a lambda expression for read(s)PrecliftRead(s)PrecNetc. for the given constructors. All constructors must be from the same type.4OYRS>?@ABCDEFGHIJKLMUVWXZ[\]^_`abcde-readsListName if True, readsPrecName if Falsef/readListPrecName if True, readPrecName if Falseg8readPrecOrListName if True, readsPrecOrListName if False7read(s)List(Prec)Name if True, read(s)PrecName if Falsehijklmnopqrstu>?@ABCDEFGHIJKLM/OYRS>?@ABCDEFGHIJKLMUVWXZ[\]^_`abcdefghijklmnopqrstu(C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone>?@ABCDEFGHIJKLMBCDEFGHIJKLM>?@A(C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone%&&vA representation of which Show variant is being derived.N4Options that further configure how the functions in Text.Show.Deriving should behave.PIf , the derived w, x, or y instance will not surround the output of showing fields of unlifted types with parentheses, and the output will be suffixed with hash signs (#).QIf `, derived instances for empty data types (i.e., ones with no data constructors) will use the  EmptyCase language extension. If $, derived instances will simply use ; instead. (This has no effect on GHCs before 7.8, since  EmptyCase' is only available in 7.8 or later.)RN8 that match the behavior of the most recent GHC release.SN9 that match the behavior of the installed version of GHC.T Generates a wG instance declaration for the given data type or data family instance.ULike T, but takes a N argument.V1Generates a lambda expression which behaves like z (without requiring a w instance).WLike V, but takes a N argument.X1Generates a lambda expression which behaves like { (without requiring a w instance).YLike X, but takes a N argument.Z1Generates a lambda expression which behaves like | (without requiring a w instance).[Like Z, but takes a N argument.\ Generates a xG instance declaration for the given data type or data family instance.]Like \, but takes a N argument.^1Generates a lambda expression which behaves like  showsPrec1 (without requiring a x instance)._1Generates a lambda expression which behaves like  liftShowsPrec (without requiring a x instance).$This function is not available with transformers-0.4.`Like _, but takes a N argument.$This function is not available with transformers-0.4.a1Generates a lambda expression which behaves like  liftShowList (without requiring a w instance).$This function is not available with transformers-0.4.bLike a, but takes a N argument.$This function is not available with transformers-0.4.cLike ^, but takes a N argument.d Generates a yG instance declaration for the given data type or data family instance.$This function is not available with transformers-0.4.eLike d, but takes a N argument.$This function is not available with transformers-0.4.f1Generates a lambda expression which behaves like liftShowsPrec2 (without requiring a y instance).$This function is not available with transformers-0.4.gLike f, but takes a N argument.$This function is not available with transformers-0.4.h1Generates a lambda expression which behaves like  liftShowList2 (without requiring a w instance).$This function is not available with transformers-0.4.iLike h, but takes a N argument.$This function is not available with transformers-0.4.j1Generates a lambda expression which behaves like  showsPrec2 (without requiring a y instance).$This function is not available with transformers-0.4.kLike j, but takes a N argument.$This function is not available with transformers-0.4.}XDerive a Show(1)(2) instance declaration (depending on the ShowClass argument's value).~Generates a declaration defining the primary function corresponding to a particular class (showsPrec for Show, liftShowsPrec for Show1, and liftShowsPrec2 for Show2).Generates a lambda expression which behaves like showsPrec (for Show), liftShowsPrec (for Show1), or liftShowsPrec2 (for Show2).+Generates a lambda expression for showsPrec liftShowsPrecNetc. for the given constructors. All constructors must be from the same type.+Generates a lambda expression for showsPrec liftShowsPrecetc. for a single constructor.+Generates a lambda expression for showsPrec liftShowsPrec'etc. for an argument of a constructor.+Generates a lambda expression for showsPrec liftShowsPrec\etc. for a specific type. The generated expression depends on the number of type variables. .If the type is of kind * (T), apply showsPrec.MIf the type is of kind * -> * (T a), apply liftShowsPrec $(makeShowForType a)nIf the type is of kind * -> * -> * (T a b), apply liftShowsPrec2 $(makeShowForType a) $(makeShowForType b)qParenthesize an infix constructor name if it is being applied as a prefix function (e.g., data Amp a = (:&) a a)0vxyNOPQRSTUVWXYZ[\]^_`abcdefghijk}~|True if we are using the function of type ([a] -> ShowS), False if we are using the function of type (Int -> a -> ShowS).,showListName if True, showsPrecName if FalseNOPQRSTUVWXYZ[\]^_`abcdefghijk*vxyNOPQRSTUVWXYZ[\]^_`abcdefghijk}~ (C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNoneNOPQRSTUVWXYZ[\]^_`abcdefghijkTUXYVWZ[\]_`ab^cdefghijkNOPQRS(C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone6A representation of which function is being generated.l Generates a G instance declaration for the given data type or data family instance.m1Generates a lambda expression which behaves like  (without requiring a  instance).n1Generates a lambda expression which behaves like  (without requiring a  instance). Generates  and  method declarations.IGenerates a lambda expression which behaves like the BoundedFun argument.~Generates a lambda expression for minBound/maxBound. for the given constructors. All constructors must be from the same type. lmnlmn lmn (C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNonelmnlmn(C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNoneo  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn        !"#$%&&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSSTUVWXYZ[\]^_`abbcdefghijklmnopqrstuvwxyz{|}~                                                    ! " # $ % & ' ( ) * + , - . / 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 [ \ ] ^ _ ` 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 { | } ~                                                                                                                   !"#$%&'()*+,-./01234567789:;<=>?@ABCDEFGHIJKLMNO;PQRSTUVWXYZ[\]^_`abcdefghijiklmnopqrsjtuvwxyz{|}~*deriving-compat-0.4-64ZV78vJfFX1z5QeJlsw0kData.Enum.DerivingData.Eq.DerivingData.Foldable.DerivingData.Functor.DerivingData.Traversable.DerivingData.Ix.DerivingData.Ord.DerivingText.Read.DerivingText.Show.DerivingData.Bounded.DerivingPaths_deriving_compatData.Deriving.InternalData.Enum.Deriving.InternalData.Eq.Deriving.InternalData.Functor.Deriving.InternalData.Ix.Deriving.InternalData.Ord.Deriving.InternalText.Read.Deriving.InternalText.Show.Deriving.InternalData.Bounded.Deriving.Internal Data.Deriving deriveEnummakeSuccmakePred makeToEnum makeFromEnum makeEnumFrommakeEnumFromThenderiveEqmakeEq makeNotEq deriveEq1 makeLiftEqmakeEq1 deriveEq2 makeLiftEq2makeEq2 FFTOptionsfftEmptyCaseBehaviordefaultFFTOptionsderiveFoldablederiveFoldableOptions makeFoldMapmakeFoldMapOptions makeFoldrmakeFoldrOptionsmakeFoldmakeFoldOptions makeFoldlmakeFoldlOptions deriveFunctorderiveFunctorOptionsmakeFmapmakeFmapOptionsderiveTraversablederiveTraversableOptions makeTraversemakeTraverseOptions makeSequenceAmakeSequenceAOptionsmakeMapMmakeMapMOptions makeSequencemakeSequenceOptionsderiveIx makeRangemakeUnsafeIndex makeInRange deriveOrd makeComparemakeLTmakeLEmakeGTmakeGEmakeMaxmakeMin deriveOrd1makeLiftCompare makeCompare1 deriveOrd2makeLiftCompare2 makeCompare2 ReadOptions useReadPrecdefaultReadOptions deriveReadderiveReadOptions makeReadsPrec makeReadPrec deriveRead1deriveRead1OptionsmakeLiftReadsPrecmakeReadsPrec1 deriveRead2deriveRead2OptionsmakeLiftReadsPrec2makeReadsPrec2 ShowOptionsghc8ShowBehaviorshowEmptyCaseBehaviordefaultShowOptionslegacyShowOptions deriveShowderiveShowOptionsmakeShowmakeShowOptions makeShowsPrecmakeShowsPrecOptions makeShowListmakeShowListOptions deriveShow1deriveShow1OptionsmakeShowsPrec1makeLiftShowsPrecmakeLiftShowsPrecOptionsmakeLiftShowListmakeLiftShowListOptionsmakeShowsPrec1Options deriveShow2deriveShow2OptionsmakeLiftShowsPrec2makeLiftShowsPrec2OptionsmakeLiftShowList2makeLiftShowList2OptionsmakeShowsPrec2makeShowsPrec2Options deriveBounded makeMinBound makeMaxBoundcatchIOversionbindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameTyVarMapStarKindStatuscanRealizeKindStarstarKindStatusToNamebaseGHC.BaseJusttemplate-haskellLanguage.Haskell.TH.SyntaxNameNothingcatKindVarNamesderiveConstraintnoConstructorsErrorderivingKindErrorcontravarianceErrornoFunctionsErroretaReductionErrordatatypeContextErrorexistentialContextErroroutOfPlaceTyVarErrorisRight Data.EitherEitherRight fromEither filterByList filterByListsghc-prim GHC.TypesTrueFalsepartitionByList appEitherEExp hasKindStarhasKindVarChaintyKindconArity isProductTypeisEnumerationType isVanillaCon newNameListtvbKind tvbToType applyClass canEtaReduce conTToNamevarTToName_maybe varTToNameunSigTisTyVar isTyFamily allDistinct mentionsNamepredMentionsNameapplyTy applyTyCon unapplyTy uncurryTy uncurryKindrequiredTyVarsOfTypeisNonUnitTupleisNonUnitTupleStringStringisInfixDataConTwoOne OneOrTwoNamesOneNameTwoNames TyVarMap2 TyVarMap1ClassReparity allowExQuant fullClassNameclassConstraint NotKindStarKindStar IsKindVarapplySubstitutionKindsubstNameWithKindsubstNamesWithKindStar fmapConst foldrConst foldMapConst traverseConsteqConsteq1Const liftEqConst liftEq2Const compareConstltConst compare1ConstliftCompareConstliftCompare2ConstreadsPrecConst readPrecConstreadsPrec1ConstliftReadsPrecConstliftReadPrecConstliftReadsPrec2ConstliftReadPrec2ConstshowsPrecConstshowsPrec1ConstliftShowsPrecConstliftShowsPrec2ConstbuildTypeInstancecheckExistentialContextenumerationErrorenumerationOrProductErrorenumerationErrorStr interleaveisTrue#integerE isStarOrVarzipWithAndUnzipMzipWith3AndUnzipMthd3unsnoc isNullaryConcreateKindChain untagExpr tag2ConExprremoveClassAppfreshen freshenTypeenumFromToExpr primOpAppExprisSym ghc7'8OrLaterderivingCompatPackageKeymkDerivingCompatName_visTrueHashValNamefmapConstValNamefoldrConstValNamefoldMapConstValNametraverseConstValNameeqConstValNameeq1ConstValNameliftEqConstValNameliftEq2ConstValNamecompareConstValNameltConstValNamecompare1ConstValNameliftCompareConstValNameliftCompare2ConstValNamereadsPrecConstValNamereadPrecConstValNamereadsPrec1ConstValNameliftReadsPrecConstValNameliftReadPrecConstValNameliftReadsPrec2ConstValNameliftReadPrec2ConstValNameshowsPrecConstValNameshowsPrec1ConstValNameliftShowsPrecConstValNameliftShowsPrec2ConstValName cHashDataName dHashDataName dualDataName endoDataName fHashDataName identDataName iHashDataName puncDataNamesymbolDataNamewrapMonadDataNameaddrHashTypeNameboundedTypeNamecharHashTypeNamedoubleHashTypeName enumTypeNamefloatHashTypeNamefoldableTypeNamefunctorTypeName intTypeNameintHashTypeName ixTypeName readTypeName showTypeNametraversableTypeNamewordHashTypeName altValNameappEndoValName appendValName chooseValName coerceValNamecomposeValName constValNameenumFromValNameenumFromThenValNameenumFromThenToValNameenumFromToValNameeqAddrHashValNameeqCharHashValNameeqDoubleHashValNameeqFloatHashValNameeqIntHashValNameeqWordHashValName errorValName flipValName fmapValName foldrValNamefoldMapValNamefromEnumValNamegeAddrHashValNamegeCharHashValNamegeDoubleHashValNamegeFloatHashValNamegeIntHashValNamegetDualValName getTagValNamegeWordHashValNamegtAddrHashValNamegtCharHashValNamegtDoubleHashValNamegtFloatHashValNamegtIntHashValNamegtWordHashValName idValName indexValNameinRangeValNameleAddrHashValNameleCharHashValNameleDoubleHashValNameleFloatHashValNameleIntHashValNameleWordHashValNameliftReadListPrecDefaultValNameliftReadListPrec2DefaultValNameliftReadListPrecValNameliftReadListPrec2ValNameliftReadPrecValNameliftReadPrec2ValName listValNameltAddrHashValNameltCharHashValNameltDoubleHashValNameltFloatHashValNameltIntHashValNameltWordHashValNameminBoundValName mapValNamemaxBoundValNameminusIntHashValName parenValName parensValName pfailValName plusValName precValName predValNamerangeSizeValName rangeValNamereadListValNamereadListPrecDefaultValNamereadListPrecValNamereadPrec_to_SValNamereadPrecValNamereadS_to_PrecValNamereadsPrecValName resetValName returnValName seqValNameshowCharValNameshowListValNameshowListWithValNameshowParenValNameshowsPrecValNameshowSpaceValNameshowStringValName stepValName succValNametagToEnumHashValName timesValName toEnumValNametraverseValNameunsafeIndexValNameunsafeRangeSizeValNameunwrapMonadValName boolTypeName falseDataName trueDataName eqDataName gtDataName ltDataName eqTypeName ordTypeName andValNamecompareValName eqValName geValName gtValName leValName ltValName notValName wHashDataNameexpectPValName pureValName apValName liftA2ValNamemappendValName memptyValName eq1TypeName eq2TypeName liftEqValNameliftEq2ValName ord1TypeName ord2TypeNameliftCompareValNameliftCompare2ValName read1TypeName read2TypeNameliftReadsPrecValNameliftReadListValNameliftReadsPrec2ValNameliftReadList2ValName show1TypeName show2TypeNameliftShowListValNameliftShowsPrecValNameliftShowList2ValNameliftShowsPrec2ValNameshowCommaSpaceshowCommaSpaceValNameEnumFunGHC.EnumEnumsuccpredtoEnumfromEnumenumFrom enumFromThen enumFunDecs makeEnumFunmakeEnumFunForConsSuccPredToEnumFromEnumEnumFrom EnumFromThen EnumClass enumFunNameenumFromThenToExpr illegalExprillegalToEnumTag$fClassRepEnumClassEqClass GHC.ClassesEqEq1Eq2 deriveEqClasseqDecs makeEqClass makeEqForCons makeTagCasemakeFallThroughCaseFalsemakeFallThroughCaseTruemakeFallThroughCasemakeCaseForConmakeCaseForArgsmakeCaseForArgmakeCaseForType eqConstNameeqName$fClassRepEqClass FunctorFun FunctorClassGHC.Primseq Data.FoldableFoldablefoldMapfoldrfoldlFunctorfmapData.Traversable Traversabletraverse sequenceAmapMsequencederiveFunctorClassfunctorFunDecsmakeFunctorFunmakeFunctorFunForConsmakeFunctorFunForConmakeFunctorFunForArgsmakeFunctorFunForArgLeftmakeFunctorFunForTypeFmapFoldrFoldMapTraversefunctorFunConstNamefunctorFunNamefunctorClassToFunsfunctorFunToClass allowFunTysfunctorFunTriv functorFunAppfunctorFunCombine fmapCombine foldrCombinefoldMapCombinetraverseCombinefunctorFunEmptyCasefunctorFunNoConsfunctorFunTrivial$fShowFunctorFun$fClassRepFunctorClassIxFun ixFunDecs makeIxFunmakeIxFunForConsRange UnsafeIndexInRangeIxClass ixFunName$fClassRepIxClassOrdClassOrdcomparemaxminOrd1Ord2deriveOrdClass ordFunDecs makeOrdFunmakeOrdFunForCons filterOutGHC.ListfilterOrdFun OrdCompareOrdLTOrdLEOrdGEOrdGTOrd1LiftCompareOrd2LiftCompare2 makeMinMaxmakeOrdFunForConmakeOrdFunForFieldsmakeOrdFunForTypecompareConstNameordClassToCompare ordFunName ordFunToClasseqResultgtResultltResult ltTagExpr eqTagExpr gtTagExpr falseExprtrueExpr otherFunsunliftedOrdFununliftedCompare primOrdFuns primOrdFunTblisSupportedUnliftedType isSingleton$fClassRepOrdClass ReadClassGHC.ReadRead readsPrecRead1Read2Text.ParserCombinators.ReadPReadSderiveReadClass readPrecDecsmakeReadPrecClassmakeReadForConsmakeReadForConmakeReadForArgmakeReadForFieldmakeReadForTypereadsPrecConstNamereadPrecConstName readsPrecName readPrecNamereadListPrecDefaultNamereadListPrecName readListNamereadsPrecOrListNamereadPrecOrListNamereadsOrReadNamemkParser mkDoStmts resultExpr identHPatbindLexidentPat symbolPatreadPuncsnocView dataConStr readPrefixCon wrapReadSshouldDefineReadPrec$fClassRepReadClass ShowClassGHC.ShowShowShow1Show2show showsPrecshowListderiveShowClass showsPrecDecsmakeShowsPrecClassmakeShowForConsmakeShowForConmakeShowForArgmakeShowForTypeparenInfixConNameshowsPrecConstName showsPrecName showListNameshowsPrecOrListNamecharE$fClassRepShowClass BoundedFunBoundedminBoundmaxBoundboundedFunDecsmakeBoundedFunmakeBoundedFunForConsMinBoundMaxBound BoundedClassboundedFunName$fClassRepBoundedClass