h$(|      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                (C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone'(%/deriving-compatA mapping of type variable Names to their auxiliary function Names. deriving-compatWhether a type is not of kind *, is of kind *, or is a kind variable.deriving-compat>A type-level modifier intended to be used in conjunction with  deriveVia". Refer to the documentation for  deriveVia for more details./deriving-compat8Does a Type have kind * or k (for some kind variable k)?0deriving-compatReturns  the kind variable  of a  # if it exists. Otherwise, returns .1deriving-compatConcat together all of the StarKindStatuses that are IsKindVar and extract the kind variables' Names out.3deriving-compatAttempt 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.See Note [Type inference in derived instances] for the heuristics used to come up with constraints.5deriving-compatThe given datatype has no constructors, and we don't know what to do with it.6deriving-compatEither the given data type doesn't have enough type variables, or one of the type variables to be eta-reduced cannot realize kind *.7deriving-compatThe last type variable appeared in a contravariant position when deriving Functor.8deriving-compatA constructor has a function argument in a derived Foldable or Traversable instance.9deriving-compatOne of the last type variables cannot be eta-reduced (see the canEtaReduce function for the criteria it would have to meet).:deriving-compatThe data type has a DatatypeContext which mentions one of the eta-reduced type variables.;deriving-compatThe data type has an existential constraint which mentions one of the eta-reduced type variables.<deriving-compatThe 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.Bderiving-compatB 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.Cderiving-compatC 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" This function does not check whether the lists have equal length.Dderiving-compatD 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]) This function does not check whether the lists have equal length.Fderiving-compat"Returns True if a Type has kind *.Hderiving-compathasKindVarChain n kind Checks if kind is of the form k_0 -> k_1 -> ... -> k_(n-1), where k0, k1, ..., and k_(n-1) can be * or kind variables.Ideriving-compatIf a Type is a SigT, returns its kind signature. Otherwise, return *.Oderiving-compat1Returns the number of fields for the constructor.Pderiving-compatReturns  if it's a datatype with exactly one, non-existential constructor.Qderiving-compatReturns  if it's a datatype with one or more nullary, non-GADT constructors.Rderiving-compatReturns ; if we're dealing with existential quantification or GADTs.Sderiving-compatGenerate a list of fresh names with a common prefix, and numbered suffixes.Tderiving-compat#Extracts the kind from a TyVarBndr.Uderiving-compatConvert a TyVarBndr to a Type.Vderiving-compat)Applies a typeclass constraint to a type.Xderiving-compatChecks 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 Type Then in the type F a b, we would consider a to be an argument to F , but not b._deriving-compatAre all of the items in a list (which have an ordering) distinct?This uses Set (as opposed to nub) for better asymptotic time complexity.`deriving-compat9Does the given type mention any of the Names in the list?aderiving-compatDoes an instance predicate mention any of the Names in the list?bderiving-compat)Construct a type via curried application.cderiving-compat7Fully applies a type constructor to its type variables.dderiving-compatSplit an applied type into its individual components. For example, this: Either Int Char would split to this: [Either, Int, Char] ederiving-compatSplit 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, ()]) fderiving-compat)Like uncurryType, except on a kind level.oderiving-compat Checks if a 1 represents a tuple type constructor (other than ())pderiving-compat Checks if a  represents a tuple (other than ())qderiving-compat Checks if a  names a valid Haskell infix data constructor (i.e., does it begin with a colon?).2deriving-compat5The typeclass for which an instance should be derivedderiving-compat(The type constructor or data family namederiving-compatThe datatype contextderiving-compat*The types to instantiate the instance withderiving-compat1Are we dealing with a data family instance or not  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-. /01 23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~0(C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone+|deriving-compat Generates a  instance declaration for the given data type or data family instance.deriving-compat1Generates a lambda expression which behaves like  (without requiring a  instance).deriving-compat1Generates a lambda expression which behaves like  (without requiring a  instance). (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 HaskellNone0deriving-compatGenerates an instance for a type class at a newtype by emulating the behavior of the GeneralizedNewtypeDeriving extension. For example: newtype Foo a = MkFoo a $( [t| forall a.  a =>  (Foo a) |]) deriving-compatGenerates an instance for a type class by emulating the behavior of the  DerivingVia extension. For example: newtype Foo a = MkFoo a $( [t| forall a.  a =>  (Foo a)  Down a |]) As shown in the example above, the syntax is a tad strange. One must specify the type by which to derive the instance using the  type. This requirement is in place to ensure that the type variables are scoped correctly across all the types being used (e.g., to make sure that the same a is used in  a,  (Foo a), and Down a).deriving-compat8Replace the last element of a list with another element.deriving-compatThe instance head (e.g.,  Eq (Foo a))deriving-compat If using  , this is 'Nothing. If using  , this is  the via type.   (C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone1(C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone5`deriving-compat Generates an  instance declaration for the given data type or data family instance.deriving-compat1Generates a lambda expression which behaves like  (without requiring an  instance).deriving-compat1Generates a lambda expression which behaves like  (without requiring an  instance).deriving-compat1Generates a lambda expression which behaves like  (without requiring an  instance).deriving-compat1Generates a lambda expression which behaves like  (without requiring an  instance).deriving-compat1Generates a lambda expression which behaves like  (without requiring an  instance).deriving-compat1Generates a lambda expression which behaves like  (without requiring an  instance). (C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone5(C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone'(; deriving-compat Generates an  instance declaration for the given data type or data family instance.deriving-compat1Generates a lambda expression which behaves like  (without requiring an  instance).deriving-compat1Generates a lambda expression which behaves like  (without requiring an  instance).deriving-compat Generates an  instance declaration for the given data type or data family instance.deriving-compat1Generates a lambda expression which behaves like liftEq (without requiring an  instance).$This function is not available with transformers-0.4.deriving-compat1Generates a lambda expression which behaves like eq1 (without requiring an  instance).deriving-compat Generates an  instance declaration for the given data type or data family instance.$This function is not available with transformers-0.4.deriving-compat1Generates a lambda expression which behaves like liftEq2 (without requiring an  instance).$This function is not available with transformers-0.4.deriving-compat1Generates a lambda expression which behaves like eq2 (without requiring an  instance).$This function is not available with transformers-0.4.  (C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone parser datatype while the latter use the slower, list-based  type.deriving-compat that favor readPrec over .deriving-compat Generates a  instance declaration for the given data type or data family instance.deriving-compatLike , but takes a  argument.deriving-compat1Generates a lambda expression which behaves like  (without requiring a  instance).deriving-compat1Generates a lambda expression which behaves like readPrec (without requiring a  instance).deriving-compat Generates a  instance declaration for the given data type or data family instance.deriving-compatLike , but takes a  argument.deriving-compat1Generates a lambda expression which behaves like  liftReadsPrec (without requiring a  instance).$This function is not available with transformers-0.4.deriving-compat1Generates a lambda expression which behaves like  liftReadPrec (without requiring a  instance).%This function is only available with  base-4.10 or later.deriving-compat1Generates a lambda expression which behaves like  readPrec1 (without requiring a  instance).%This function is only available with  base-4.10 or later.deriving-compat1Generates a lambda expression which behaves like  readsPrec1 (without requiring a  instance).deriving-compat Generates a  instance declaration for the given data type or data family instance.$This function is not available with transformers-0.4.deriving-compatLike , but takes a  argument.$This function is not available with transformers-0.4.deriving-compat1Generates a lambda expression which behaves like liftReadsPrec2 (without requiring a  instance).$This function is not available with transformers-0.4.deriving-compat1Generates a lambda expression which behaves like  liftReadPrec2 (without requiring a  instance).%This function is only available with  base-4.10 or later.deriving-compat1Generates a lambda expression which behaves like  readPrec2 (without requiring a  instance).%This function is only available with  base-4.10 or later.deriving-compat1Generates a lambda expression which behaves like  readsPrec2 (without requiring a  instance).$This function is not available with transformers-0.4.(C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNonei (C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone%'(yderiving-compat4Options that further configure how the functions in Text.Show.Deriving should behave.deriving-compatIf , the derived , , or  instance will not surround the output of showing fields of unlifted types with parentheses, and the output will be suffixed with hash signs (#).deriving-compatIf , 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.)deriving-compat8 that match the behavior of the most recent GHC release.deriving-compat9 that match the behavior of the installed version of GHC.deriving-compat Generates a  instance declaration for the given data type or data family instance.deriving-compatLike , but takes a  argument.deriving-compat1Generates a lambda expression which behaves like  (without requiring a  instance).deriving-compatLike , but takes a  argument.deriving-compat1Generates a lambda expression which behaves like  (without requiring a  instance).deriving-compatLike , but takes a  argument.deriving-compat1Generates a lambda expression which behaves like  (without requiring a  instance).deriving-compatLike , but takes a  argument.deriving-compat Generates a  instance declaration for the given data type or data family instance.deriving-compatLike , but takes a  argument.deriving-compat1Generates a lambda expression which behaves like  showsPrec1 (without requiring a  instance).deriving-compat1Generates a lambda expression which behaves like  liftShowsPrec (without requiring a  instance).$This function is not available with transformers-0.4.deriving-compatLike , but takes a  argument.$This function is not available with transformers-0.4.deriving-compat1Generates a lambda expression which behaves like  liftShowList (without requiring a  instance).$This function is not available with transformers-0.4.deriving-compatLike , but takes a  argument.$This function is not available with transformers-0.4.deriving-compatLike , but takes a  argument.deriving-compat Generates a  instance declaration for the given data type or data family instance.$This function is not available with transformers-0.4.deriving-compatLike , but takes a  argument.$This function is not available with transformers-0.4.deriving-compat1Generates a lambda expression which behaves like liftShowsPrec2 (without requiring a  instance).$This function is not available with transformers-0.4.deriving-compatLike , but takes a  argument.$This function is not available with transformers-0.4.deriving-compat1Generates a lambda expression which behaves like  liftShowList2 (without requiring a  instance).$This function is not available with transformers-0.4.deriving-compatLike , but takes a  argument.$This function is not available with transformers-0.4.deriving-compat1Generates a lambda expression which behaves like  showsPrec2 (without requiring a  instance).$This function is not available with transformers-0.4.deriving-compatLike , but takes a  argument.$This function is not available with transformers-0.4.(C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNonez(C) 2015-2017 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone{ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                      )deriving-compat-0.6-JNGpJ5Y9bknD8TUmYLXFCData.Deriving.InternalData.Bounded.Deriving.InternalData.Deriving.Via.InternalData.Enum.Deriving.InternalData.Eq.Deriving.InternalData.Functor.Deriving.InternalData.Ix.Deriving.InternalData.Ord.Deriving.InternalText.Read.Deriving.InternalText.Show.Deriving.InternalData.Bounded.DerivingData.Deriving.ViaData.Enum.DerivingData.Eq.DerivingData.Functor.DerivingData.Foldable.DerivingData.Ix.DerivingData.Ord.DerivingData.Traversable.DerivingPaths_deriving_compatText.Read.DerivingText.Show.Deriving Data.DerivingTwoOne OneOrTwoNamesOneNameTwoNames TyVarMap2 TyVarMap1TyVarMapClassReparity allowExQuant fullClassNameclassConstraintStarKindStatus NotKindStarKindStar IsKindVarViaapplySubstitutionKindsubstNameWithKindsubstNamesWithKindStar fmapConst replaceConst foldrConst foldMapConst nullConst traverseConsteqConsteq1Const liftEqConst liftEq2Const compareConstltConst compare1ConstliftCompareConstliftCompare2ConstreadsPrecConst readPrecConstreadsPrec1ConstliftReadsPrecConstliftReadPrecConstliftReadsPrec2ConstliftReadPrec2ConstshowsPrecConstshowsPrec1ConstliftShowsPrecConstliftShowsPrec2ConstcanRealizeKindStarstarKindStatusToNamecatKindVarNamesbuildTypeInstancederiveConstraintcheckExistentialContextnoConstructorsErrorderivingKindErrorcontravarianceErrornoFunctionsErroretaReductionErrordatatypeContextErrorexistentialContextErroroutOfPlaceTyVarErrorenumerationErrorenumerationOrProductErrorenumerationErrorStr interleaveisTrue# filterByList filterByListspartitionByListintegerE hasKindStar isStarOrVarhasKindVarChaintyKindzipWithAndUnzipMzipWith3AndUnzipMthd3unsnoc isNullaryConconArity isProductTypeisEnumerationType isVanillaCon newNameListtvbKind tvbToType applyClasscreateKindChain canEtaReduce conTToNamevarTToName_maybe varTToNameunSigTisTyVarisInTypeFamilyApp allDistinct mentionsNamepredMentionsNameapplyTy applyTyCon unapplyTy uncurryTy uncurryKind untagExpr tag2ConExpr primOrdFunTblremoveClassAppfreshen freshenTypeenumFromToExpr primOpAppExprisNonUnitTupleisNonUnitTupleStringisInfixDataConisSym ghc7'8OrLaterderivingCompatPackageKeygHC_IXmkDerivingCompatName_vmkDerivingCompatName_tcisTrueHashValNamefmapConstValNamereplaceConstValNamefoldrConstValNamefoldMapConstValNamenullConstValNametraverseConstValNameeqConstValNameeq1ConstValNameliftEqConstValNameliftEq2ConstValNamecompareConstValNameltConstValNamecompare1ConstValNameliftCompareConstValNameliftCompare2ConstValNamereadsPrecConstValNamereadPrecConstValNamereadsPrec1ConstValNameliftReadsPrecConstValNameliftReadPrecConstValNameliftReadsPrec2ConstValNameliftReadPrec2ConstValNameshowsPrecConstValNameshowsPrec1ConstValNameliftShowsPrecConstValNameliftShowsPrec2ConstValName viaTypeName cHashDataName dHashDataName fHashDataName identDataName iHashDataName puncDataNamesymbolDataNamewrapMonadDataNameaddrHashTypeNameboundedTypeNamecharHashTypeNamedoubleHashTypeName enumTypeNamefloatHashTypeNamefoldableTypeNamefunctorTypeName intTypeNameintHashTypeName ixTypeName readTypeName showTypeNametraversableTypeNamewordHashTypeName altValName appendValName chooseValName coerceValNamecomposeValName constValNameenumFromValNameenumFromThenValNameenumFromThenToValNameenumFromToValNameeqAddrHashValNameeqCharHashValNameeqDoubleHashValNameeqFloatHashValNameeqIntHashValNameeqWordHashValName errorValName flipValName fmapValName foldrValNamefoldMapValNamefromEnumValNamegeAddrHashValNamegeCharHashValNamegeDoubleHashValNamegeFloatHashValNamegeIntHashValName getTagValNamegeWordHashValNamegtAddrHashValNamegtCharHashValNamegtDoubleHashValNamegtFloatHashValNamegtIntHashValNamegtWordHashValName idValName indexValNameinRangeValNameleAddrHashValNameleCharHashValNameleDoubleHashValNameleFloatHashValNameleIntHashValNameleWordHashValNameliftReadListPrecDefaultValNameliftReadListPrec2DefaultValNameliftReadListPrecValNameliftReadListPrec2ValNameliftReadPrecValNameliftReadPrec2ValName listValNameltAddrHashValNameltCharHashValNameltDoubleHashValNameltFloatHashValNameltIntHashValNameltWordHashValNameminBoundValName mapValNamemaxBoundValNameminusIntHashValName parenValName parensValName pfailValName plusValName precValName predValNamerangeSizeValName rangeValName readFieldHashreadFieldHashValNamereadListValNamereadListPrecDefaultValNamereadListPrecValNamereadPrec_to_SValNamereadPrecValNamereadS_to_PrecValNamereadsPrecValNamereplaceValName resetValName returnValName seqValNameshowCharValNameshowListValNameshowListWithValNameshowParenValNameshowsPrecValNameshowSpaceValNameshowStringValName stepValName succValNametagToEnumHashValName timesValName toEnumValNametraverseValNameunsafeIndexValNameunsafeRangeSizeValNameunwrapMonadValName boolTypeName falseDataName trueDataName eqDataName gtDataName ltDataName eqTypeName ordTypeName andValNamecompareValName eqValName geValName gtValName leValName ltValName notValName wHashDataNameexpectPValName allValName apValName pureValName liftA2ValNamemappendValName memptyValName nullValName eq1TypeName eq2TypeName liftEqValNameliftEq2ValName ord1TypeName ord2TypeNameliftCompareValNameliftCompare2ValName read1TypeName read2TypeNameliftReadsPrecValNameliftReadListValNameliftReadsPrec2ValNameliftReadList2ValName show1TypeName show2TypeNameliftShowListValNameliftShowsPrecValNameliftShowList2ValNameliftShowsPrec2ValNameshowCommaSpaceValNameappEndoValName dualDataName endoDataNamegetDualValNamereadFieldValNamereadSymFieldValNameeqInt8HashValNameeqInt16HashValNameeqWord8HashValNameeqWord16HashValNamegeInt8HashValNamegeInt16HashValNamegeWord8HashValNamegeWord16HashValNamegtInt8HashValNamegtInt16HashValNamegtWord8HashValNamegtWord16HashValNameint8HashTypeNameint8ToIntHashValNameint16HashTypeNameint16ToIntHashValNameintToInt8HashValNameintToInt16HashValNameleInt8HashValNameleInt16HashValNameleWord8HashValNameleWord16HashValNameltInt8HashValNameltInt16HashValNameltWord8HashValNameltWord16HashValNameword8HashTypeNameword8ToWordHashValNameword16HashTypeNameword16ToWordHashValNamewordToWord8HashValNamewordToWord16HashValName$fEqStarKindStatus deriveBounded makeMinBound makeMaxBound$fClassRepBoundedClass deriveGND deriveVia deriveViaDecsderiveViaDecs'mkCoerceClassMethEqn zipTvbSubst changeLaststripOuterForallT decomposeTypenewtypeRepType etaReduce deriveEnummakeSuccmakePred makeToEnum makeFromEnum makeEnumFrommakeEnumFromThen$fClassRepEnumClass $fShowEnumFunderiveEqmakeEq makeNotEq deriveEq1 makeLiftEqmakeEq1 deriveEq2 makeLiftEq2makeEq2$fClassRepEqClass$fBoundedEqClass $fEnumEqClass FFTOptionsfftEmptyCaseBehaviordefaultFFTOptionsderiveFoldablederiveFoldableOptions makeFoldMapmakeFoldMapOptionsmakeNullmakeNullOptions makeFoldrmakeFoldrOptionsmakeFoldmakeFoldOptions makeFoldlmakeFoldlOptions deriveFunctorderiveFunctorOptionsmakeFmapmakeFmapOptions makeReplacemakeReplaceOptionsderiveTraversablederiveTraversableOptions makeTraversemakeTraverseOptions makeSequenceAmakeSequenceAOptionsmakeMapMmakeMapMOptions makeSequencemakeSequenceOptions$fClassRepFunctorClass$fShowFunctorFun$fEqFunctorFun$fEqFFTOptions$fOrdFFTOptions$fReadFFTOptions$fShowFFTOptionsderiveIx makeRangemakeUnsafeIndex makeInRange$fClassRepIxClass $fShowIxFun deriveOrd makeComparemakeLTmakeLEmakeGTmakeGEmakeMaxmakeMin deriveOrd1makeLiftCompare makeCompare1 deriveOrd2makeLiftCompare2 makeCompare2$fClassRepOrdClass $fEqOrdFun$fBoundedOrdClass$fEnumOrdClass ReadOptions useReadPrecdefaultReadOptions deriveReadderiveReadOptions makeReadsPrec makeReadPrec deriveRead1deriveRead1OptionsmakeLiftReadsPrecmakeLiftReadPrec makeReadPrec1makeReadsPrec1 deriveRead2deriveRead2OptionsmakeLiftReadsPrec2makeLiftReadPrec2 makeReadPrec2makeReadsPrec2$fClassRepReadClass$fBoundedReadClass$fEnumReadClass$fEqReadOptions$fOrdReadOptions$fReadReadOptions$fShowReadOptions ShowOptionsghc8ShowBehaviorshowEmptyCaseBehaviordefaultShowOptionslegacyShowOptions deriveShowderiveShowOptionsmakeShowmakeShowOptions makeShowsPrecmakeShowsPrecOptions makeShowListmakeShowListOptions deriveShow1deriveShow1OptionsmakeShowsPrec1makeLiftShowsPrecmakeLiftShowsPrecOptionsmakeLiftShowListmakeLiftShowListOptionsmakeShowsPrec1Options deriveShow2deriveShow2OptionsmakeLiftShowsPrec2makeLiftShowsPrec2OptionsmakeLiftShowList2makeLiftShowList2OptionsmakeShowsPrec2makeShowsPrec2Options$fClassRepShowClass$fBoundedShowClass$fEnumShowClass$fEqShowOptions$fOrdShowOptions$fReadShowOptions$fShowShowOptionsbase GHC.MaybeJusttemplate-haskellLanguage.Haskell.TH.SyntaxNameNothingghc-prim GHC.TypesTrueFalseGHC.BaseStringGHC.EnumBoundedminBoundmaxBound GHC.ClassesEqOrdEnumsuccpredtoEnumfromEnumenumFrom enumFromThen==/=Eq1Eq2FunctorFoldable TraversableGHC.Primseq Data.FoldablefoldMapnullfoldrfoldlfmap<$Data.Traversabletraverse sequenceAmapMsequencecompare<<=>>=maxminOrd1Ord2version getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameReadGHC.Read readsPrecRead1Read2Text.ParserCombinators.ReadPReadSShowShow1Show2GHC.Showshow showsPrecshowList