!T      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123 4 5 6 7 8 9 : ; < = > ? @ A B C DEFGHIJK 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{|}~None;=dfhaskell-tools-refactorsExceptions that can occur while loading modules or during internal operations (not during performing the refactor).haskell-tools-refactor;Change in the project, modification or removal of a module.haskell-tools-refactoroModule name and marker to separate .hs-boot module definitions. Specifies a source file in a working directory.haskell-tools-refactor"The name of the module and the ASThaskell-tools-refactor7A type for the input and result of refactoring a modulehaskell-tools-refactorPTransforms module name to a .hs file name relative to the source root directory.haskell-tools-refactor=Transforms a source root relative file name into module name.None;=Ko haskell-tools-refactor%The information a refactoring can usehaskell-tools-refactorMThe name of the module being refactored. Used for accessing implicit imports.haskell-tools-refactor]Input and output information for the refactoring TODO: use multiple states instead of Eitherhaskell-tools-refactor+The refactoring monad for the whole projecthaskell-tools-refactor(The refactoring monad for a given modulehaskell-tools-refactor9The type of a refactoring that affects the whole project.haskell-tools-refactorThe type of a refactoringhaskell-tools-refactor*A refactoring that only affects one modulehaskell-tools-refactor$A monad that can be used to refactorNone]x,haskell-tools-refactor}Remove a separator from the AST while keeping the textual parts of it that should not be removed (like preprocessor pragmas).haskell-tools-refactor|Remove an element from the AST while keeping the textual parts of it that should not be removed (like preprocessor pragmas).haskell-tools-refactor.Extracts all text elements that should be kepthaskell-tools-refactorWWrites the elements to be kept into a writer monad with ranges and default line ending.None< haskell-tools-refactor]A type class for handling definitions that can appear as both top-level and local definitionshaskell-tools-refactorGAccesses a type signature definition in a local or top-level definitionhaskell-tools-refactorJAccesses a value or function definition in a local or top-level definitionhaskell-tools-refactorGAccesses a type signature definition in a local or top-level definitionhaskell-tools-refactor.Creates a new definition from a type signaturehaskell-tools-refactor<Creates a new definition from a value or function definitionhaskell-tools-refactorCreates a new fixity signaturehaskell-tools-refactor0Checks if a given definition is a type signaturehaskell-tools-refactor;Checks if a given definition is a function or value bindinghaskell-tools-refactor2Checks if a given definition is a fixity signature  !  !Nonej&haskell-tools-refactor-Displays True iff the wrapped value is a Just $%&'()$%&'()None~*haskell-tools-refactorPExpands an extension into all the extensions it implies (keeps original as well)+haskell-tools-refactor9Replaces deprecated extensions with their new counterpart/haskell-tools-refactorHThese extensions' GHC representation name differs from their actual name0haskell-tools-refactor`Canonicalize extensions. This is a helper function for parsing extensions This way we can say read . canonExt to parse any extension string1haskell-tools-refactortSerializes the extension's GHC name into its LANGUAGE pragma name. Should be always used in composition with show (seriealizeExt . showj) when refactoring extensions. This function also replaces depracted extensions with their new versions.2haskell-tools-refactor8Map the cabal extensions to the ones that GHC recognizesx >BKI9GsuNMEDoOxyt;?FnZH~}:7gfh.kdcqYTS\L58=vA@e<|ba,-`41WVU0_^]zCj&X*+iJ6r{%$#RQ"[(!lw'mPp)32/*+,-./012x*+,-./012 >BKI9GsuNMEDoOxyt;?FnZH~}:7gfh.kdcqYTS\L58=vA@e<|ba,-`41WVU0_^]zCj&X*+iJ6r{%$#RQ"[(!lw'mPp)32/ None3haskell-tools-refactor=Set the minimal indentation recursively for a part of the AST33 NoneiX4haskell-tools-refactorFilters the elements of the list. By default it removes the separator before the element. Of course, if the first element is removed, the following separator is removed as well.6haskell-tools-refactorhA version of filterList that cares about keeping non-removable code elements (like preprocessor pragmas)7haskell-tools-refactoroA version of filterListIndexed that cares about keeping non-removable code elements (like preprocessor pragmas)8haskell-tools-refactor%Selects the given indices from a list9haskell-tools-refactor-Selects all but the given indices from a list:haskell-tools-refactorInserts the element in the places where the two positioning functions (one checks the element before, one the element after) allows the placement.;haskell-tools-refactorNChecks where the element will be inserted given the two positioning functions.<haskell-tools-refactorGets the elements and separators from a list. The first separator is zipped to the second element. To the first element, the "" string is zipped. 456789:;< 456789:;< None<QV]?haskell-tools-refactorERemove the container (where or let) when the last binding is removed.@haskell-tools-refactorbPuts the elements in the orginal order and remove duplicates (elements with the same source range)Ahaskell-tools-refactor1Groups elements together into equivalence groups.Bhaskell-tools-refactorlChooses a representative element for each equivalence group, and pairs them with their corresponding group.Chaskell-tools-refactorSorts the elements of a list into equivalence groups based on a function, then chooses a representative element for each group, and pairs them with their corresponding group.=>?@ABC=>?@ABCSafe DEFGHIJ DEFGHIJ None<^iKhaskell-tools-refactorAPerforms the given refactoring, transforming it into a Ghc actionLhaskell-tools-refactor\Wraps a refactoring that only affects one module. Performs the per-module finishing touches.Mhaskell-tools-refactor-Transform the result of the local refactoringNhaskell-tools-refactorfRe-inserts the elements removed from the AST that should be kept (for example preprocessor directives)Ohaskell-tools-refactorOAdds the imports that bring names into scope that are needed by the refactoringUhaskell-tools-refactorhCreate a name that references the definition. Generates an import if the definition is not yet imported.Vhaskell-tools-refactor2Reference the name by the shortest suitable import KLMNOPQRSTUV KLMNOPQRSTUV NoneV]Yhaskell-tools-refactor9The final version of our AST, with type infromation addedZhaskell-tools-refactorType synonym for module names.[haskell-tools-refactor(A quick function to try the refactorings\haskell-tools-refactor>Adjust the source range to be applied to the refactored module]haskell-tools-refactorSet the given flags for the GHC session. Also gives back a change function that you can use to apply the settings to any flags. Prints out errors and warnings`haskell-tools-refactor7Reloads the package database based on the session flagsahaskell-tools-refactor?Initialize GHC flags to default values that support refactoringchaskell-tools-refactor(Sets up basic flags and settings for GHCdhaskell-tools-refactorDUse the given source directories when searching for imported modulesehaskell-tools-refactorJDon't use the given source directories when searching for imported modulesfhaskell-tools-refactoroTranslates module name and working directory into the name of the file where the given module should be definedghaskell-tools-refactornTranslates module name and working directory into the name of the file where the boot module should be definedhhaskell-tools-refactor5Get the source directory where the module is located.ihaskell-tools-refactor/Gets the path to the source file of the module.khaskell-tools-refactorGets the module namelhaskell-tools-refactorHLoad the AST of a module given by the working directory and module name.mhaskell-tools-refactorLLoad the summary of a module given by the working directory and module name.nhaskell-tools-refactor1Get the typed representation of a Haskell module.phaskell-tools-refactor4Modifies the dynamic flags for performing a ghc taskqhaskell-tools-refactor-Forces the code generation for a given moduleshaskell-tools-refactor-Forces ASM code generation for a given modulethaskell-tools-refactor)Normalizes the flags for a module summaryuhaskell-tools-refactor9Removes all flags that are unintelligable for refactoringvhaskell-tools-refactor-Read a source range from our textual format: line:col-line:col or line:colwhaskell-tools-refactor(Read a source location from our format: line:col!WXYZ[\]^_`abcdefghijklmnopqrstuvw!Z[\]^_`abcdefghijklmYnWXopqrstuvwNonezhaskell-tools-refactorCThe signature and behavior of one refactoring that can be executed.haskell-tools-refactorzExecutes a given command (choosen from the set of available refactorings) on the selected module and given other modules.haskell-tools-refactor'Gets the name of possible refactorings.haskell-tools-refactor!The set of available refactoringshaskell-tools-refactorThe refactoring commandhaskell-tools-refactor0The module in which the refactoring is performedhaskell-tools-refactor Other modules z}|{~ z}|{~None6haskell-tools-refactorThe set of available querieshaskell-tools-refactorThe query commandhaskell-tools-refactor0The module in which the refactoring is performedhaskell-tools-refactor Other modulesNone]u haskell-tools-refactorCDifferent classes of definitions that have different kind of names.haskell-tools-refactor.Normal value definitions: functions, variableshaskell-tools-refactorData constructorshaskell-tools-refactor"Functions with operator-like nameshaskell-tools-refactor%Constructors with operator-like nameshaskell-tools-refactor*UType definitions with operator-like nameshaskell-tools-refactor.Get which category does a given name belong tohaskell-tools-refactor-Checks if a given name is a valid module namehaskell-tools-refactor=Check if a given name is valid for a given kind of definition  None;=haskell-tools-refactor@Collects the qualified names of the class heads in an assertion.haskell-tools-refactor?Collects the semantic names of the class heads in an assertion.haskell-tools-refactorExtracts the name of a type. In case of a type application, it finds the type being applied. It works only for unambiguous types, so it won't work for tuples.None<QViSNoneV!haskell-tools-refactoryLooks up the Type of an entity with an Id of any locality. If the entity being scrutinised is a type variable, it fails.haskell-tools-refactorLooks up the Type or the Kind of an entity that has an Id. Note: In some cases we only get the Kind of the Id (e.g. for type constructors)haskell-tools-refactor-Extracts a Type from a TyThing when possible.haskell-tools-refactor1Looks up a GHC Type from a Haskell Tools Name (given the name is global) For an identifier, it returns its type. For a data constructor, it returns its type. For a pattern synonym, it returns its builder's type. For a type synonym constructor, it returns its right-hand side. For a coaxiom, it fails.haskell-tools-refactorjLooks up the right-hand side (GHC representation) of a Haskell Tools Name corresponding to a type synonymhaskell-tools-refactorLooks up a GHC.Class from something that has a type class constructor in it Fails if the argument does not contain a class type constructorhaskell-tools-refactorjLooks up the right-hand side (GHC representation) of a Haskell Tools Type corresponding to a type synonymhaskell-tools-refactor2Converts a global Haskell Tools type to a GHC typehaskell-tools-refactor Looks up the given name, extracts something out of it. If the extraction is not succesful, it returns False, if it is successful, then checks the result against the predicate. The reasoning behind this, is that the predicate can only be satisfied by a proper name.haskell-tools-refactorbDecides whether a given name is a type family constructor. Fails if the lookup is not successful.haskell-tools-refactornDecides whether a given name is a standard Haskell98 data constructor. Fails if the lookup is not successful.haskell-tools-refactor*Looks up a closed type family from a name.haskell-tools-refactorFExtract the CoAxioms from a TyThing representing a closed type family.haskell-tools-refactor:Determines whether a Type itself has a type variable head.None"+       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     ! "$#%'&(*)+-,.0/213987654:?>=<;@BACDEFIHGMLKJNOPQRSTUVWZYX[`_^]\cbaedqprsgfhijklmnotuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !$%&'()3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY[\]^_`abcdefghijklmnopqrstuvwz~{|}E       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     ! "$#%'&(*)+-,.0/213987654:?>=<;@BAC[`_^]\qprshijklmnotuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !$%&'()3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY[\]^_`abcdefghijklmnopqrstuvwz~{|}QIHGZYXOPNEFDWUVSRTMLKJ~yWXedcbagf !"#$%&'()*+,-./012345645645712812912:12;12<12=12>12?12@12A12B12C12D12E12F12G12H12I12J12K12L12M12N12O12P12Q12R12S12T12U12V12W12X12Y12Z12[12\12]12^12_12`12a12b12c12d12e12f12g12h12i12j12k12l12m12n12o12p12q12r12s12t12u12v12w12x12y12z12{12|12}12~121212121212121212121212121212121212121212121212121212121212121212121212121212      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=<><?<@<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<bcdcecfcgchcicjckclcmcncocpcqcrcsctcucvcwcxcycz{|{}{~{{{     H !"#$%&'()*+,-./01234567898:8;8<8=8>8?8@8A8B8C8D8E8FGHGIGJGKGLGMGNGOGPGQGRGSGTGUGVGWGXGYGZG[G\G]^_^`^a^b^c^d^e^fghgigjgkglgmgngogpgqgrgsgtgugvgwgxgyz{z|z}z~zzzzzzu      !"#$%&'(')'*'+','-'.'/'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'{'|'}'~''''''''''''''                       !"#$%&'()*+,-./012131415161718191:1;1<1=1>1?1@1A1B1C1D1E1FGHGIGJGKGLGMGNGOGPGQGRGSTUTVTWTXTYTZT[\\]\h\i\j\k\m\^\_\`\a\p\b\c\d\e\f\q\t\w\g\\h\i\j\k\\l\\\\\m\\n\o\\\\p\\q\r\s\t\u\(\\v\w\\x\y\z\\{\|\}\~\\\\\\ \\\\\\\\\\\\\\!\"\$\\\\\\\\\@\?\\\\\\\\\\e\f\d\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\      !"#$%&'()*+,-./0123456789:;<=>?@A B C D E F G H I J K L M N O P Q RSTUVWXY Z [ \ ] ^ _ ` a b c d e f f g t h i j k l m n o p q r s t u v w x y z { | } ~        5haskell-tools-refactor-1.1.0.2-Gow74qwhN9O8QI7dzZUXUMLanguage.Haskell.Tools.Refactor0Language.Haskell.Tools.Refactor.Utils.Extensions+Language.Haskell.Tools.Refactor.Utils.Maybe.Language.Haskell.Tools.Refactor.Representation%Language.Haskell.Tools.Refactor.Monad)Language.Haskell.Tools.Refactor.Utils.AST1Language.Haskell.Tools.Refactor.Utils.BindingElem+Language.Haskell.Tools.Refactor.Utils.Debug1Language.Haskell.Tools.Refactor.Utils.Indentation+Language.Haskell.Tools.Refactor.Utils.Lists-Language.Haskell.Tools.Refactor.Utils.Helpers-Language.Haskell.Tools.Refactor.Utils.Monadic'Language.Haskell.Tools.Refactor.Prepare+Language.Haskell.Tools.Refactor.Refactoring(Language.Haskell.Tools.Refactor.Querying*Language.Haskell.Tools.Refactor.Utils.Name0Language.Haskell.Tools.Refactor.Utils.NameLookup*Language.Haskell.Tools.Refactor.Utils.Type0Language.Haskell.Tools.Refactor.Utils.TypeLookupbase Debug.TracetraceGHC.BaseMaybeNothingJust Data.MaybemaybeisJust isNothing fromMaybe maybeToList listToMaybe catMaybesmapMaybe traceMarkerIO traceMarker traceEventIO traceEvent traceStack traceShowMtraceM traceShowId traceShowtraceId putTraceMsgtraceIOfromJustghc-boot-th-8.4.3GHC.LanguageExtensions.Type Extensiontransformers-0.5.5.0Control.Monad.Trans.MaybeMaybeT runMaybeTEmptyDataDerivingMonadFailDesugaring StrictDataStrictTypeApplicationsStaticPointersNamedWildCardsPartialTypeSignaturesPatternSynonyms EmptyCaseOverloadedLabelsDuplicateRecordFieldsHexFloatLiteralsNegativeLiteralsBinaryLiterals MultiWayIf LambdaCaseTraditionalRecordSyntax RelaxedLayoutNondecreasingIndentationDatatypeContexts!AlternativeLayoutRuleTransitionalAlternativeLayoutRuleExplicitForAllPackageImportsExplicitNamespaces TypeOperatorsImpredicativeTypes RankNTypesLiberalTypeSynonyms PatternGuards TupleSectionsPostfixOperators RecursiveDoGeneralizedNewtypeDerivingMonadComprehensionsTransformListCompParallelListCompRoleAnnotationsKindSignaturesEmptyDataDecls MagicHashExistentialQuantification UnicodeSyntaxFunctionalDependenciesNullaryTypeClassesMultiParamTypeClassesConstrainedClassMethodsFlexibleInstancesFlexibleContextsTypeSynonymInstancesDerivingStrategies DeriveLiftDeriveAnyClassDefaultSignatures DeriveGenericDeriveFoldableDeriveTraversable DeriveFunctorAutoDeriveTypeableDeriveDataTypeableStandaloneDeriving ApplicativeDo InstanceSigs DataKinds PolyKindsConstraintKindsRebindableSyntaxDoAndIfThenElseNPlusKPatterns GADTSyntaxGADTs ViewPatterns RecordPunsRecordWildCardsDisambiguateRecordFields NumDecimalsOverloadedListsOverloadedStrings TypeInTypeTypeFamilyDependencies TypeFamilies BangPatterns UnboxedSums UnboxedTuplesAllowAmbiguousTypesScopedTypeVariablesImplicitPreludeImplicitParams QuasiQuotesTemplateHaskellQuotesTemplateHaskellArrowsParallelArrays JavaScriptFFIGHCForeignImportPrimCApiFFIInterruptibleFFIUnliftedFFITypesForeignFunctionInterfaceExtendedDefaultRulesRelaxedPolyRecMonoLocalBinds MonoPatBindsMonomorphismRestrictionUndecidableSuperClassesIncoherentInstancesUndecidableInstancesOverlappingInstancesCpp0haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3"Language.Haskell.Tools.AST.HelpersinScopecompareRangeLengthgetNodeContainingnodesWithRange isContainednodesContainedisInsidenodesContaining semantics valBindPats typeParams declHeadNames bindingNameimportIsHiding importIsExactAnnList AnnNothingAnnJust elementName NamedElement%Language.Haskell.Tools.AST.References stringNodeStr simpleNameStrunqualifiedName qualifiers simpleName operatorNamepromotedStringValuepromotedIntValuepromotedElementspromotedConNamestringLitValue intLitValue fracLitValue floatLitValue charLitValue bracketTypebracketPattern bracketExpr bracketDeclqqString qqExprName qqExprBodyspliceId spliceExprfieldPatternWildcardfieldPatternName fieldPattern patternTypepatternSumPlaceholdersBeforepatternSumPlaceholdersAfter patternSplice patternRhspatternOperator patternNamepatternLiteral patternLit patternLhs patternInner patternFields patternExpr patternElems patternArgspatQQcmdThencmdStmts cmdRightCmdcmdRhs cmdOperatorcmdLhs cmdLeftCmd cmdInnerCmds cmdInnerCmdcmdInnercmdExprcmdElsecmdBinds cmdBindings cmdArrowOp cmdAppliedcmdAlts compStmts usingExprthenExprcompStmtbyExpr stmtPatternstmtExpr stmtBinds cmdStmtBindscaseGuardStmts caseGuardExpr rhsCaseGuards rhsCaseExpr pragmaStrpragmaSrcRange tupSecExpr fieldWildcard fieldValuefieldUpdateName fieldNamealtRhs altPatternaltBindstupleSectionElems tupleElems quotedName procPatternprocExpr listElems innerExprexprTypeexprThenexprSumPlaceholdersBeforeexprSumPlaceholdersAfter exprStmts exprSpliceexprSigexprRhs exprRecName exprRecFieldsexprQQ exprPragma exprOperatorexprNameexprLitexprLhs exprInner exprIfAlts exprFunBindexprFunexprElseexprCondexprCase exprBracket exprBindingsexprArgexprAlts enumToFixenumToenumThenenumFromdoKindcompExprcompBody arrowAppl innerAsserts assertTypes assertRhsassertOp assertLhs assertImplVarassertImplType assertClsNamecontextAssertionkindVarkindType kindRightkindRhs kindPromoted kindParenkindLhskindLeft kindElemskindElem kindAppOp kindAppFun kindAppArgtypeWildcardNametypeType typeRight typeResulttypeQQ typeParam typeOperatortypeNametypeLefttypeKind typeInner typeElements typeElementtypeCtxtypeCon typeBoundedtypeArgtsSplice tpPromoted tyVarName tyVarKind valBindRhs valBindPat valBindLocalsfunBindMatches kindConstr matchLhsRhsmatchLhsOperator matchLhsName matchLhsLhs matchLhsArgstsTypetsNameprecedenceValuefixityPrecedencefixityOperators fixityAssoc localBindslocalVallocalSig localInline localFixityguardRhsguardPat guardCheck guardBinds guardStmts guardExpr rhsGuardsrhsExprmatchRhsmatchLhs matchBindsspecializeType specializeDef pragmaPhase numberIntegersrToLinesrToCol srFromLine srFromCol srFileName minimalOrs minimalName minimalInner minimalAnds annotateName warnMessagespecializePragmapragmaSignature pragmaRule pragmaObjects pragmaLineNum pragmaInlinepragmaFileName deprMessageannotationSubject annotateExprphaseNum phaseUntil phaseNumber ruleVarType ruleVarNameruleRhs rulePhaseruleNameruleLhs ruleBoundedteRhsteLhsihType ihOperatorihLeftOpihHeadihFun ihConNameirVarsirHeadirCtx oneDerived allDerivedderiveStrategy fieldType fieldNames conDeclRhs conDeclOp conDeclName conDeclLhs conDeclFields conDeclArgs conTypeCtx conTypeArgs funDepRhs funDepLhsfunDeps patSigType patSigName patOpposite patSynRhspatSynOp patSynLhspatNamepatArgspatRhsOpposite patRhsPatpatRhspatLhsgadtConResultTypegadtConRecordFieldsgadtConNormalTypegadtConTypeCtxgadtConTypeArgs gadtConType gadtConNames injAnnRes injAnnDeps tfTypeVar tfSpecKind tfInjectivitytfSpectfKindtfHeadspecializeInstanceTypespecializeInstanceinstanceInlineinstBodyTypeSiginstBodyTypeEqninstBodyLhsTypeinstBodyGadtConsinstBodyDerivingsinstBodyDeclFunbindinstBodyDataNewinstBodyDataKindinstBodyDataCons instBodyDeclsdhRight dhOperatordhNamedhLeftdhBody dhAppOperanddhAppFun pragmaFormula clsInline clsFixity ceTypeSig ceTypeFamceTypeceNameceKindceHeadceBind cbElements declValBind declTypes declTypeSigdeclTypeFamilydeclType declSplicedeclSpec declSafety declRoles declRoleType declPragmadeclPatTypeSig declPatSyn declOverlap declNewtypedeclNamedeclKind declInstance declInstRule declInstDecldeclHeaddeclGadt declFunDepsdeclForeignType declFixity declDerivingdeclDerivStratdeclDecldeclCtxdeclCons declCallConvdeclBodydeclAssignedTypelangExtmoduleNameString importRenameimportSpecListimportSpecHiding importSpec importSource importSafeimportQualified importPkg importModuleimportAsopStr lpPragmas modWarningStrmodDeprecatedPragmaessList ieSubspecieName ieModifierexportModuleName exportDecl espExportsmhPragmamhName mhExports modImportsmodHeadmodDecl filePragmas*Language.Haskell.Tools.AST.SemaInfoClassessemanticsLitType HasNameInfo semanticsName HasNameInfo'HasLiteralInfosemanticsLiteralTypeHasLiteralInfo' HasIdInfo semanticsId HasIdInfo' HasFixityInfosemanticsFixityHasFixityInfo' HasScopeInfosemanticsScope HasScopeInfo'HasDefiningInfosemanticsDefiningHasDefiningInfo'semanticsSourceInfoHasSourceInfoInSema' HasModuleInfosemanticsPrelTransModssemanticsImplicitImports isBootModulesemanticsDynFlagssemanticsModuleHasModuleInfo' HasImportInfosemanticsTransModssemanticsImportedsemanticsAvailablesemanticsImportedModuleHasImportInfo'HasImplicitFieldsInfosemanticsImplicitFldsHasImplicitFieldsInfo'HasNoSemanticInfoLanguage.Haskell.Tools.AST.Ann isAnnNothingannJustannMaybesrcInfoSourceInfoType HasSourceInfosourceInfoTraversesourceInfoTraverseDownsourceInfoTraverseUpSourceInfoTraversalannList annListElems annListAnnotAnnshortShowSpanWithFile shortShowSpanSrcTemplateStageDomIdDomDomainsetRangegetRangeHasRange(Language.Haskell.Tools.AST.SemaInfoTypes getInstancesusageAsusageQualifierusageQualified UsageSpec8haskell-tools-backend-ghc-1.1.0.2-8bCnWhUdJzW3ufERIRf6qN'Language.Haskell.Tools.BackendGHC.UtilsUnrootedConvertionProblemConvertionProblem'Language.Haskell.Tools.BackendGHC.MonadSpliceInsertionProblem8haskell-tools-prettyprint-1.1.0.2-IglSkv32X2j1D7Yl2LxtWO+Language.Haskell.Tools.PrettyPrint.RoseTreePrettyPrintProblem*Language.Haskell.Tools.PrettyPrint.Prepare fixMainRange prepareASTCpp prepareAST@Language.Haskell.Tools.PrettyPrint.Prepare.SourceTemplateHelpersindented separatedBylistoptchild followedByafterrelativeIndentedminimumIndentedHLanguage.Haskell.Tools.PrettyPrint.Prepare.RangeTemplateToSourceTemplateextractStayingElems mapLocIndices getLocIndices rangeToSource9Language.Haskell.Tools.PrettyPrint.Prepare.SourceTemplate lineEndingssourceTemplateTextsourceTemplateTextRangesourceTemplateTextElem isStayingTextsrcTmpOptMinimalIndentsrcTmpOptAftersrcTmpOptBeforesourceTemplateOptRangesrcTmpListMinimalIndentsrcTmpSeparatorssrcTmpIndentedsrcTmpDefaultSeparatorsrcTmpListAftersrcTmpListBeforesourceTemplateListRangesourceTemplateMinimalIndentsourceTemplateNodeElemssourceTemplateNodeRange_sourceTemplateTextRange_sourceTemplateTextElem ChildElemTextElemSourceTemplateElem _lineEndings_sourceTemplateText StayingText NormalTextSourceTemplateTextElem?Language.Haskell.Tools.PrettyPrint.Prepare.RangeToRangeTemplate fixRanges cutUpRanges bupSiblingsbupInnerbupOuterBreakUpProblem8Language.Haskell.Tools.PrettyPrint.Prepare.RangeTemplateTransformationProblem8Language.Haskell.Tools.PrettyPrint.Prepare.PlaceComments placeCommentsgetPragmaCommentsgetNormalComments4haskell-tools-rewrite-1.1.0.2-92ZNANwYG8rBHafaqkxRKO*Language.Haskell.Tools.Rewrite.Match.Types ForallTypeCtxType FunctionType TupleTypeUnboxedTupleTypeListType ParArrayTypeTypeApp InfixTypeApp ParenTypeVarType KindedTypeBangTypeLazyType UnpackType NoUnpackType WildcardTypeNamedWildcardType SpliceTypeQuasiQuoteTypePromotedIntTypePromotedStringTypePromotedConTypePromotedListTypePromotedTupleTypePromotedUnitTypeUnboxedSumType TyVarDeclKindedTyVarDeclContext ClassAssert InfixAssertImplicitAssert TupleAssert'Language.Haskell.Tools.Rewrite.Match.THIdSplice ParenSplice QuasiQuote ExprBracketPatternBracket TypeBracket DeclsBracket*Language.Haskell.Tools.Rewrite.Match.ExprsVarLitInfixApp PrefixAppAppLambdaLetIfMultiIfCaseDoMDo ParArrayCompTuple UnboxedTuple TupleSectionUnboxedTupleSectionListParArrayParen LeftSection RightSectionRecCon RecUpdateEnum ParArrayEnumListCompParArrayListCompTypeSigExplicitTypeAppVarQuote TypeQuote BracketExpr SpliceExprQuasiQuoteExpr ExprPragmaProcArrowApp StaticPointerNormalFieldUpdateFieldPun FieldWildcard TupSecPresent TupSecMissingAltCaseRhsGuardedCaseRhssGuardedCaseRhs CorePragma SccPragmaGeneratedPragma SourceRange ArrowAppCmd ArrowFormCmdAppCmdInfixCmd LambdaCmdParenCmdCaseCmdIfCmdLetCmdDoCmdLeftAppl RightAppl LeftHighApp RightHighAppHole*Language.Haskell.Tools.Rewrite.Match.StmtsBindStmtExprStmtLetStmtRecStmt DoKeyword MDoKeyword ListCompBodyCompStmtThenStmt GroupStmt BindStmtCmd ExprStmtCmd LetStmtCmd RecStmtCmd-Language.Haskell.Tools.Rewrite.Match.PatternsVarPatLitPat InfixAppPatAppPatTuplePat UnboxTuplePatListPat ParArrayPatParenPatRecPatAsPatWildPatIrrefutablePatBangPat TypeSigPatViewPat SplicePat QuasiQuotePat NPlusKPat FieldPatternFieldPunPatternFieldWildcardPattern*Language.Haskell.Tools.Rewrite.Match.NamesNormalOp BacktickOp NormalName ParenName ImplicitName StringNode QualifiedNameNamePart,Language.Haskell.Tools.Rewrite.Match.ModulesModule ModuleHead ExportSpecs ExportSpec ModuleExportIESpecSubAllSubList ImportDeclImportRenamingImportSpecListImportHidingList ModuleNameLanguagePragma OptionsPragmaLanguageExtensionModuleWarningPragmaModuleDeprecatedPragma-Language.Haskell.Tools.Rewrite.Match.LiteralsCharLit StringLitIntLitFracLit PrimIntLit PrimWordLit PrimFloatLit PrimDoubleLit PrimCharLit PrimStringLit*Language.Haskell.Tools.Rewrite.Match.KindsKindConstraintStarKind UnboxKindFunKind ParenKindVarKindAppKindListKindIntKind StringKindConKindListKindPromoted TupleKindUnitKind*Language.Haskell.Tools.Rewrite.Match.DeclsTypeDecl FixityDecl DefaultDecl TypeSigDecl ValueBinding SpliceDeclDataDecl GADTDataDecl GadtConDeclGadtRecordConDeclConDecl RecordConDecl InfixConDecl FieldDecl DerivingOne DerivingOne' DerivingMultiDerivingMulti' DataKeywordNewtypeKeywordFunDepsFunDep ClassDecl ClassBody ClassElemSig ClassElemDefClassElemTypeFamClassElemDataFamClsDefaultType ClsDefaultSig ClsMinimal MinimalName MinimalParen MinimalOr MinimalAnd NameDeclHead ParenDeclHead DeclHeadApp InfixDeclHead InstanceDecl InstanceBody InstanceBindInstanceTypeSigInstanceTypeFamilyDefInstanceDataFamilyDefInstanceDataFamilyGADTDefInstanceSpecializePragma InstanceRule InstanceHeadInfixInstanceHeadParenInstanceHeadAppInstanceHead EnableOverlapDisableOverlap Overlappable OverlappingOverlapsIncoherentOverlapRoleDecl NominalRoleRepresentationalRole PhantomRole ForeignImport ForeignExportStdCallCCallCApiUnsafePatternSynonym ConPatSyn InfixPatSyn RecordPatSynSymmetricPatSyn OneWayPatSyn TwoWayPatSynPatternSignatureDeclPatternSignature TypeFamily DataFamily TypeInstance DataInstanceGadtDataInstanceClosedTypeFamilyTypeFamilyKindSpecTypeFamilyInjectivitySpecTypeEqn PragmaDecl RulePragma DeprPragma WarningPragma AnnPragma InlinePragmaNoInlinePragmaInlinablePragma LinePragmaSpecializePragmaPhaseControlFromPhaseControlUntil RewriteRuleNameAnnotationTypeAnnotationModuleAnnotationConlikeAnnotation*Language.Haskell.Tools.Rewrite.Match.Binds SimpleBind FunctionBindMatchMatchLhsInfixLhs LocalBinds LocalValBind LocalTypeSig LocalFixity TypeSignatureInfixLInfixRInfix UnguardedRhs GuardedRhss GuardedRhs GuardBindGuardLet GuardCheck+Language.Haskell.Tools.Rewrite.Create.Binds mkGuardCheck mkGuardLet mkGuardBind mkGuardedRhs mkGuardedRhssmkUnguardedRhsmkInfixmkInfixRmkInfixLmkTypeSignature mkLocalFixitymkLocalTypeSigmkLocalValBind mkLocalBinds' mkLocalBinds mkInfixLhs mkMatchLhsmkMatchmkFunctionBind'mkFunctionBind mkSimpleBind mkSimpleBind'+Language.Haskell.Tools.Rewrite.Create.DeclsmkConlikeAnnotationmkModuleAnnotationmkTypeAnnotationmkNameAnnotation mkRuleVar mkRewriteRulemkPhaseControlUntilmkPhaseControlFrommkSpecializePragma mkLinePragmamkInlinablePragmamkNoInlinePragmamkInlinePragma mkAnnPragmamkWarningPragma mkDeprPragma mkRulePragma mkPragmaDeclmkPatternSignaturemkPatternSignatureDeclmkTwoWayPatSynmkOneWayPatSynmkSymmetricPatSynmkRecordPatSyn mkInfixPatSyn mkConPatSynmkPatternSynonymmkGadtDataInstancemkDataInstancemkTypeInstance mkTypeEqnmkTypeFamilyInjectivitySpecmkTypeFamilyKindSpec mkDataFamilymkClosedTypeFamily mkTypeFamilymkUnsafemkCApimkCCall mkStdCallmkForeignExportmkForeignImport mkPhantomRolemkRepresentationalRole mkNominalRole mkRoleDeclmkIncoherentOverlap mkOverlaps mkOverlappingmkOverlappablemkDisableOverlapmkEnableOverlapmkInstanceSpecializePragmamkInstanceDataFamilyGADTDefmkInstanceDataFamilyDefmkInstanceTypeFamilyDefmkInstanceTypeSigmkInstanceBindmkInstanceBodymkAppInstanceHeadmkParenInstanceHeadmkInfixInstanceHeadmkInstanceHeadmkInstanceRulemkInstanceDeclmkInfixDeclHead mkDeclHeadAppmkParenDeclHeadmkNameDeclHead mkMinimalAnd mkMinimalOrmkMinimalParen mkMinimalName mkClsMinimalmkFunDepmkClsDefaultSigmkClsDefaultTypemkClassElemDataFammkClassElemTypeFammkClassElemDefmkClassElemSig mkClassBody mkClassDeclmkNewtypeKeyword mkDataKeyword mkDeriving mkFieldDeclmkInfixConDeclmkRecordConDecl mkConDeclmkGadtRecordConDecl mkGadtConDeclmkGADTDataDecl mkDataDecl mkSpliceDeclmkValueBinding mkTypeSigDecl mkDefaultDecl mkFixityDeclmkStandaloneDeriving mkTypeDecl+Language.Haskell.Tools.Rewrite.Create.ExprsmkHolemkRightHighApplmkLeftHighAppl mkRightAppl mkLeftApplmkDoCmdmkLetCmdmkIfCmd mkCaseCmd mkParenCmd mkLambdaCmd mkInfixCmdmkAppCmdmkArrowFromCmd mkArrowAppCmd mkSourceRangemkGeneratedPragma mkSccPragma mkCorePragmamkGuardedCaseRhsmkGuardedCaseRhss mkCaseRhsmkAltmkFieldWildcard mkFieldPun mkFieldUpdatemkStaticPointer mkLambdaCase mkArrowApp mkProcExpr mkExprPragmamkQuasiQuoteExpr mkSpliceExpr mkBracketExpr mkTypeQuote mkVarQuotemkExplicitTypeApp mkExprTypeSigmkParArrayComp mkListCompmkParArrayEnummkEnum mkRecUpdatemkRecConmkRightSection mkLeftSectionmkParen mkParArraymkListmkTupleUnboxedSectionmkTupleSectionmkUnboxedTuplemkTuple mkMDoBlock mkDoBlockmkCase mkMultiIfmkIfmkLetmkLambdamkApp mkPrefixApp mkInfixAppmkLitmkVar+Language.Haskell.Tools.Rewrite.Create.TypesmkTupleAssertionmkImplicitAssert mkInfixAssert mkClassAssert mkContextmkPromotedUnitTypemkPromotedTupleTypemkPromotedListTypemkPromotedConTypemkPromotedStringTypemkPromotedIntTypemkQuasiQuoteType mkSpliceTypemkNamedWildcardTypemkWildcardTypemkNoUnpackType mkUnpackType mkLazyType mkBangType mkKindedType mkVarTypemkKindedTypeVar mkTypeVar mkParenTypemkInfixTypeApp mkTypeAppmkParArrayType mkListTypemkUnboxedTupleType mkTupleTypemkFunctionType mkCtxType mkTypeVar' mkForallType+Language.Haskell.Tools.Rewrite.Create.Kinds mkUnitKind mkTupleKind mkListKind mkConKind mkStringKind mkIntKind mkKindList mkKindApp mkKindVar mkKindParen mkKindFun mkKindUnbox mkKindStarmkKindConstraint.Language.Haskell.Tools.Rewrite.Create.LiteralsmkPrimStringLit mkPrimCharLitmkPrimDoubleLitmkPrimFloatLit mkPrimWordLit mkPrimIntLit mkFracLitmkIntLit mkStringLit mkCharLit-Language.Haskell.Tools.Rewrite.Create.ModulesmkModuleDeprecatedPragmamkModuleWarningPragma mkOptionsGHCmkLanguagePragma mkFilePragmas mkModuleNamemkImportHidingListmkImportSpecList mkImportDeclmkSubAll mkSubListmkPatternIESpecmkIESpecmkModuleExport mkExportSpec mkExportSpecs mkModuleHeadmkModule+Language.Haskell.Tools.Rewrite.Create.Names mkStringNode mkSimpleName mkSimpleName' mkNamePartmkQualifiedNamemkQualifiedName'mkImplicitName mkParenName mkNormalName mkUnqualName' mkQualName' mkUnqualOp mkUnqualOp' mkQualOp' mkBacktickOpmkQualOpmkName.Language.Haskell.Tools.Rewrite.Create.PatternsmkFieldWildcardPatternmkFieldPunPatternmkPatternFieldmkQuasiQuotePat mkSplicePat mkViewPat mkTypeSigPat mkBangPatmkIrrefutablePat mkWildPatmkAsPatmkRecPat mkParenPat mkParArrayPat mkListPatmkUnboxTuplePat mkTuplePatmkAppPat mkInfixAppPatmkLitPatmkVarPat+Language.Haskell.Tools.Rewrite.Create.StmtsmkRecCmd mkLetStmtCmd mkExprCmd mkBindCmd mkGroupStmt mkThenStmt mkCompStmtmkListCompBody mkRecStmt mkLetStmt mkExprStmt mkBindStmt(Language.Haskell.Tools.Rewrite.Create.THmkDeclsBracket mkTypeBracketmkPatternBracket mkExprBracket mkQuasiQuote mkParenSplice mkIdSplice+Language.Haskell.Tools.Rewrite.ElementTypesAnnMaybeImportModifierSubSpec ModulePragma FilePragma ImportSpecImportQualified ImportSource ImportSafe TypeNamespaceDecl ClassElementDeclHeadInstBody InstBodyDecl GadtConTypeDataOrNewtypeKeywordDerivingDeriveStrategy OverlapPragmaTopLevelPragmaRuleRuleVarAnnotationSubjectMinimalFormulaTypeFamilySpecInjectivityAnn PatSynRhs PatSynLhs PatSynWhereRoleCallConvSafety ConlikeAnnot PhaseControl ValueBindRhsRhsGuard LocalBindFixitySignatureTypeTyVar AssertionKind PromotedKindExpr FieldUpdate TupSecElemCmdCmdAltStmtDoKindCmdStmtPattern PatternFieldSpliceBracketLiteralOperatorName MaybeContext MaybeDerivingMaybeDeriveStrategyMaybeLocalBindsMaybeTypeFamilySpecMaybeKindConstraintMaybeClassBody MaybeInstBody MaybeExprMaybeExportSpecsMaybeImportQualifiedMaybeImportSourceMaybeImportSafeMaybeImportSpecMaybeModuleHeadMaybeImportModifierMaybeModulePragma MaybeSubSpecMaybeStringNodeMaybeImportRenaming MaybeSafetyMaybePhaseControlMaybeConlikeAnnot MaybeFunDeps MatchListDeclList PatternList OperatorListNameList LocalBindList IESpecList RhsGuardListGuardedRhsListGuardedCaseRhsList ConDeclList TypeEqnListTypeList FieldDeclListExprListFieldUpdateListGadtConDeclListClassElementListInstBodyDeclListInstanceHeadListAltListStmtListKindList TyVarListListCompBodyListExportSpecListFilePragmaListImportDeclListPatternFieldList AssertionList CompStmtListRuleList RuleVarListRoleListMinimalFormulaList FunDepListTupSecElemListCmdList CmdAltList CmdStmtListLanguageExtensionListStringNodeList NamePartList DerivingListRefactorExceptionIllegalExtensionsSourceCodeProblemUnknownExceptionRefactorChangeContentChanged ModuleRemoved ModuleCreatedfromContentChangedremovedModuleNamecreatedModuleNamecreatedModuleContent sameLocation SourceFileKey _sfkFileName_sfkModuleName ModuleDom UnnamedModulemoduleSourceFilesourceFileModule $fShowBag$fShowRefactorChange$fExceptionRefactorException$fEqSourceFileKey$fOrdSourceFileKey$fShowSourceFileKey$fShowRefactorException sfkFileName sfkModuleName RefactorCtx refModuleName refCtxRoot refCtxImportsLocalRefactorT fromRefactorTRefactor LocalRefactorProjectRefactoring RefactoringLocalRefactoring RefactorMonad refactErrorliftGhc$fExceptionMonadMaybeT$fExceptionMonadExceptT$fGhcMonadExceptT$fExceptionMonadReaderT$fGhcMonadReaderT$fExceptionMonadStateT$fGhcMonadStateT$fHasDynFlagsStateT$fExceptionMonadStateT0$fGhcMonadStateT0$fHasDynFlagsStateT0$fExceptionMonadWriterT$fGhcMonadWriterT$fRefactorMonadStateT$fRefactorMonadStateT0$fRefactorMonadExceptT$fMonadTransLocalRefactorT$fRefactorMonadLocalRefactorT$fFunctorLocalRefactorT$fApplicativeLocalRefactorT$fMonadLocalRefactorT$fMonadReaderLocalRefactorT$fMonadWriterLocalRefactorT$fMonadIOLocalRefactorT$fHasDynFlagsLocalRefactorT$fExceptionMonadLocalRefactorT$fGhcMonadLocalRefactorTremoveSeparator removeChild BindingElemsigBindvalBind fixitySig createTypeSig createBindingcreateFixitySig isTypeSig isBinding isFixitySiggetValBindInListvalBindsInList$fBindingElemULocalBind$fBindingElemUDecldebugMdebug debugMaybeTshowOutputableshowNameshowOpexpandExtensionreplaceDeprecatedturnOnturnOff impliedXFlagsirregularExtensionscanonExt serializeExttranslateExtensionsetMinimalIndent filterListfilterListIndexed filterListStfilterListIndexedStsublist notSublist insertWhere insertIndexzipWithSeparatorsreplaceWithJustreplaceWithNothingremoveEmptyBndsnormalizeElements groupElemsBy reprElemsequivalenceGroupsByisJustT isNothingT liftMaybe fromMaybeT fromMaybeTMmaybeTmaybeTM runRefactorlocalRefactoringlocalRefactoringRes insertTextaddGeneratedImportsregisteredNamesFromPreludeotherNamesFromPrelude qualifiedName referenceNamereferenceOperatorreferenceName' referenceByUnsupportedExtension TypedModule tryRefactorcorrectRefactorSpanuseFlags pprWarningpprErr reloadPkgDb initGhcFlagsinitGhcFlagsForTest initGhcFlags'useDirsderegisterDirs toFileNametoBootFileName getSourceDir getModSumOrig keyFromMS getModSumName loadModuleAST loadModule parseTyped trfProblemwithAlteredDynFlags forceCodeGen codeGenDfs forceAsmGenmodSumNormalizeFlagsnormalizeFlags readSrcSpan readSrcLoc$fExceptionUnsupportedExtension$fShowUnsupportedExtensionRefactoringChoiceNamingRefactoringSelectionRefactoringModuleRefactoringrefactoringNamenamingRefactoringselectionRefactoringmoduleRefactoringprojectRefactoringperformCommandrefactorCommandsSeverityErrorWarningInfoMarkerlocationseveritymessage QueryChoice LocationQuery GlobalQuery queryName locationQuery globalQuery QueryValue GeneralQuery MarkerQuery QueryMonad QueryType decompQuery queryCommands queryError performQuery$fToJSONSrcSpan$fToJSONSeverity $fShowMarker$fToJSONMarker$fToJSONQueryValue$fShowSeverity$fGenericSeverity $fEqSeverity$fGenericMarker $fEqMarker$fGenericQueryValue$fShowQueryValue$fEqQueryValue NameClassVariableCtor ValueOperatorDataCtorOperatorSynonymOperator classifyNamevalidModuleName nameValidisIdCharisOperatorChar opSemName declHeadQNamedeclHeadSemNameinstHeadSemNameassertionQNamesassertionSemNames nameFromType$fHasNameInfo'Ann$fHasNameInfo'Ann0$fHasNameInfo'Ann1$fHasNameInfo'NametypeExpr literalTypeappTypeMatches ClosedTyFamhasConstraintKindlookupTypeFromIdtypeOrKindFromIdtypeFromTyThinglookupTypeFromGlobalNamelookupTypeSynRhs lookupSynDeftyconFromTyThingtyconFromGHCType isNewtype lookupTypelookupClassWith lookupClasslookupClassFromInstancelookupClassFromDeclHeadsemanticsTypeSynRhs semanticsTypeisNewtypeTyCon satisfiesisClassTyConNameMisVanillaDataConNameMlookupClosedTyFamcoAxiomFromTyThing hasTyVarHead$fEqTypekeptText writeStaying