(      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~               !"#$%&'None$/9:;DIR[\CDifferent classes of definitions that have different kind of names..Normal value definitions: functions, variables Data constructors !"Functions with operator-like names"%Constructors with operator-like names#*UType definitions with operator-like names$+The refactoring monad for the whole project%(The refactoring monad for a given module&$A monad that can be used to refactor)%The information a refactoring can use.0Input and output information for the refactoring1;Change in the project, modification or removal of a module.:The type of a refactoring;*A refactoring that only affects one module<;Decides if a module is a .hs-boot file or a normal .hs file?oModule name and marker to separate .hs-boot module definitions. Specifies a source file in a working directory.C"The name of the module and the ASTEAPerforms the given refactoring, transforming it into a Ghc actionF\Wraps a refactoring that only affects one module. Performs the per-module finishing touches.G-Transform the result of the local refactoringHOAdds the imports that bring names into scope that are needed by the refactoringNhCreate a name that references the definition. Generates an import if the definition is not yet imported.O2Reference the name by the shortest suitable importP.Get which category does a given name belong toQ-Checks if a given name is a valid module nameR=Check if a given name is valid for a given kind of definitionG !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abrs9 !"#$%&(')*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTrsGDC?@AB<=>;:123456789bEFGHa`_^]\[ZY./0)*+,-X&'(WVU%$IJKLMNO !"#PQRSTsr- !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abrsNone$/5:DLRT[\t9The final version of our AST, with type infromation addedv>Adjust the source range to be applied to the refactored modulew'Set the given flags for the GHC sessionx?Initialize GHC flags to default values that support refactoring{ Use the given source directories}oTranslates module name and working directory into the name of the file where the given module should be defined~nTranslates module name and working directory into the name of the file where the boot module should be definedLLoad the summary of a module given by the working directory and module name.9Get the typed representation from a type-correct program.4Modifies the dynamic flags for performing a ghc task-Forces the code generation for a given module-Forces ASM code generation for a given module)Normalizes the flags for a module summary9Removes all flags that are unintelligable for refactoringtuvwxyz{|}~tuvwxyz{|}~uvwxyz{|}~ttuvwxyz{|}~NoneLFilters 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.Inserts the element in the places where the two positioning functions (one checks the element before, one the element after) allows the placement. NChecks where the element will be inserted given the two positioning functions.None#:L[2This data structure identifies a module collectionjThe modules of a library, executable, test or benchmark. A package contains one or more module collection.HSets up the ghc environment for compiling the modules of this collection!Gets all ModuleCollections from a list of source directories. It also orders the source directories that are package roots so that they can be loaded in the order they are defined (no backward imports). This matters in those cases because for them there can be special compilation flags.Sorts model collection in an order to remove all backward references. Works because module collections defined by directories cannot be recursive. Get modules of the project with the indicated root directory. If there is a cabal file, it uses that, otherwise it just scans the directory recursively for haskell sourcefiles. Only returns the non-boot haskell modules, the boot modules will be found during loading.C<G*NoneLPCheck which modules can be reached from the module, if it uses template haskell.None:DR ]A type class for handling definitions that can appear as both top-level and local definitionsGAccesses a type signature definition in a local or top-level definitionJAccesses a value or function definition in a local or top-level definitionGAccesses a type signature definition in a local or top-level definition.Creates a new definition from a type signature<Creates a new definition from a value or function definitionCreates a new fixity signature0Checks if a given definition is a type signature;Checks if a given definition is a function or value binding2Checks if a given definition is a fixity signature  None$()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&(')*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTrstuvwxyz{|}~   None None$*: None $*:DORTf Safely performs the transformation to introduce the local binding and replace the expression with the call. Checks if the introduction of the name causes a name conflict.]Decides if a new name defined to be the given string will conflict with the given AST elementAAdds a local binding to the where clause of the enclosing binding2Puts a value definition into a list of local bindsBAll expressions that are bound stronger than function application.UReplaces the expression with the call and stores the binding of the call in its stateBGets the values that have to be passed to the extracted definition5Generates the expression that calls the local binding7Generates the local binding for the selected expression     None*:DLR lCreates an export list that imports standalone top-level definitions with all of their contained definitionsGet all the top-level definitions with flags that mark if they can contain other top-level definitions (classes and data declarations)."Create the export for a give name.         None $*:DLORTf?Perform the refactoring on either local or top-level definition7Generates the source-level type for a GHC internal type9Check whether the definition already has a type signature   BAccess for a top-level definition if it is the selected definitionCAccess for a definition list if it contains the selected definitionISelector for either local or top-level declaration in the definition list       None$:OTNone *:DORT[\f /Performs the inline binding on a single module.ETrue if the given module contains the name of the inlined definition.LRemoves the inlined binding and the accompanying type and fixity signatures.As a top-down transformation, replaces the occurrences of the binding with generated expressions. This method passes the captured arguments of the function call to generate simpler results.LSplits an application into function and arguments. Works also for operators.8Rejoins the function and the arguments as an expression.BCreate an expression that is equivalent to calling the given bind.7Replaces names with expressions according to a mapping.sMatches a pattern list with an expression list and generates bindings. Matches until an argument cannot be matched.RMatches a pattern with an expression. Generates a mapping of names to expressions.>True for patterns that need to be parenthesized if in a lambdaETrue for expresssions that need to be parenthesized if in applicationNone *:DLRT['Sorts the imports in alphabetical order5Modify an import to only import names that are used.5Reduces the number of definitions used from an import*Check each import if it is actually needed@Narrows the import specification (explicitely imported elements)@Reduces the number of definitions imported from a sub-specifier.  None $*:DRT[\fNone$/5:DLRT[\A refactoring command$GExecutes a given command on the selected module and given other modules  !"#$0The module in which the refactoring is performed Other modules%& "#! $%& $ !"#%& !"#$%& !"#$%&'()'(*'(+'(,'(-'(.'(/'(0'(1'(2'(3456789:;<=>??@ABCCDEFGHIJKLMNOPQRSSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                    !"#$%&'()*+,-./012345464748494:4;4<4=4>4?4@4A4B4C4D4E4F4G4H4I4J4K4L4M4N4O4P4Q4R4S4T4U4V4WXYXZX[X\X]X^X_X`XaXbXcXdXeXfXgXhXiXjXklmlnlolplqlrlsltlulvlwlxlylzl{l|l}l~lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll l l l l lllllllllllllllllll l!l"l#l$l%l&l'l(l)l*l+l,l-l.l/l0l1l2l3l4l5l6l7l8l9l:l;l<l=l>l?l@lAlBlClDlElFlGlHlIlJlKlLlMlNlOlPlQlRlSlTlUlVlWlXlYlZl[l\l]l^l_l`lalblcldlelflglhliljlklllmlnlolplqlrlsltlulvlwlxlylzl{l|l}l~lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll'      !"#$%&'()*+,-./01232425262728292:2;2<2=2>2?2@ABACADAEAFAGAHAIAJAKALAMANAOAPAQARASATAUAVAWXYXZX[X\X]X^X_X`abacadaeafagahaiajakalamanaoapaqarastutvtwtxtytzt{t|t}t~                             ! " # $ % & ' ( ) * +,-,.,/,0,1,2,345464748494:4;4<4=4>4?4@ABACADAEAFAGAHAIAJAKALAMANAOAPAQARASATAUAVAWXYXZX[X\X]X^X_X`XaXbXcXdXeXfXgXhXiXjXkXlXmnonpnqnrnsntnunvnwnxnynzn{n|n}n~n      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQgQRQbQcQdQeQgQSQTQUQjQVQWQXQYQZQkQnQqQ[QQ\Q]Q^Q_QQ`QQQQQaQQbQQQcQQdQeQfQgQ#QQhQiQQjQkQlQQmQnQoQpQqQrQQQsQQtQuQQvQQwQxQyQzQQ{Q|Q}QQQQ~QQQQQQQQ:Q9QQQQQQQQQQ_Q`Q^QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ                             5haskell-tools-refactor-0.4.1.2-EtzzlgCdSDUF4DXXkFGIGvLanguage.Haskell.Tools.Refactor,Language.Haskell.Tools.Refactor.RefactorBase'Language.Haskell.Tools.Refactor.Prepare.Language.Haskell.Tools.Refactor.ListOperations*Language.Haskell.Tools.Refactor.GetModules'Language.Haskell.Tools.Refactor.Session+Language.Haskell.Tools.Refactor.BindingElem8Language.Haskell.Tools.Refactor.Predefined.DataToNewtype4Language.Haskell.Tools.Refactor.Predefined.DollarApp9Language.Haskell.Tools.Refactor.Predefined.ExtractBinding:Language.Haskell.Tools.Refactor.Predefined.GenerateExports@Language.Haskell.Tools.Refactor.Predefined.GenerateTypeSignature5Language.Haskell.Tools.Refactor.Predefined.IfToGuards8Language.Haskell.Tools.Refactor.Predefined.InlineBinding:Language.Haskell.Tools.Refactor.Predefined.OrganizeImports;Language.Haskell.Tools.Refactor.Predefined.RenameDefinition'Language.Haskell.Tools.Refactor.Perform0haskell-tools-ast-0.4.1.3-2En4RzqDfteBpDc0Rx2ZZ5Language.Haskell.Tools.AST.Ann isAnnNothingannJustannMaybesrcInfoSourceInfoType HasSourceInfosourceInfoTraversesourceInfoTraverseDownsourceInfoTraverseUpSourceInfoTraversalannList annListElems annListAnnot shortShowSpanSrcTemplateStageDomainsetRangegetRangeHasRange8haskell-tools-prettyprint-0.4.1.3-IGf3qXvqnkWLlhkMAcpauF/Language.Haskell.Tools.Transform.SourceTemplatesrcTmpOptAftersrcTmpOptBeforesourceTemplateOptRangesrcTmpSeparatorssrcTmpIndentedsrcTmpDefaultSeparatorsrcTmpListAftersrcTmpListBeforesourceTemplateListRangesourceTemplateNodeElemssourceTemplateNodeRange NameClassVariableCtor ValueOperatorDataCtorOperatorSynonymOperatorRefactor LocalRefactor RefactorMonad refactErrorliftGhc RefactorCtx refModuleName refCtxRoot refCtxImportsLocalRefactorT fromRefactorTRefactorChangeContentChanged ModuleRemoved ModuleCreatedfromContentChangedremovedModuleNamecreatedModuleNamecreatedModuleContent sameLocation RefactoringLocalRefactoringIsBootNormalHsIsHsBoot SourceFileKey _sfkIsBoot_sfkModuleName ModuleDom UnnamedModule runRefactorlocalRefactoringlocalRefactoringResaddGeneratedImportsregisteredNamesFromPreludeotherNamesFromPrelude qualifiedName referenceNamereferenceOperatorreferenceName' referenceBy classifyNamevalidModuleName nameValid isIdStartCharisOperatorChar$fRefactorMonadStateT$fRefactorMonadLocalRefactorT$fRefactorMonadExceptT$fMonadTransLocalRefactorT$fExceptionMonadExceptT$fGhcMonadExceptT$fExceptionMonadReaderT$fGhcMonadReaderT$fExceptionMonadStateT$fGhcMonadStateT$fHasDynFlagsStateT$fExceptionMonadWriterT$fGhcMonadWriterT$fShowRefactorChange $fEqIsBoot $fOrdIsBoot $fShowIsBoot$fEqSourceFileKey$fOrdSourceFileKey$fShowSourceFileKey$fFunctorLocalRefactorT$fApplicativeLocalRefactorT$fMonadLocalRefactorT$fMonadReaderLocalRefactorT$fMonadWriterLocalRefactorT$fMonadIOLocalRefactorT$fHasDynFlagsLocalRefactorT$fExceptionMonadLocalRefactorT$fGhcMonadLocalRefactorT sfkIsBoot sfkModuleName TypedModule tryRefactorcorrectRefactorSpanuseFlags initGhcFlagsinitGhcFlagsForTest initGhcFlags'useDirsderegisterDirs toFileNametoBootFileName getSourceDir getModSumOrig loadModule parseTypedwithAlteredDynFlags forceCodeGen forceAsmGenmodSumNormalizeFlagsnormalizeFlags readSrcSpan readSrcLoc filterListfilterListIndexed insertWhere insertIndexzipWithSeparatorsreplaceWithJustModuleCollectionId DirectoryMC LibraryMC ExecutableMC TestSuiteMC BenchmarkMC ModuleRecordModuleNotLoaded ModuleParsed ModuleRenamedModuleTypeCheckedModuleCodeGenerated_recModuleWillNeedCode_parsedRecModule _modRecMS_renamedRecModule_typedRecModuleModuleCollection_mcId_mcRoot _mcSourceDirs _mcModules _mcFlagSetup_mcDependenciesmoduleCollectionIdStringmoduleCollectionPkgId$fShowModuleCollection$fEqModuleCollection$fEqModuleCollectionId$fOrdModuleCollectionId$fShowModuleCollectionIdmcDependencies mcFlagSetupmcId mcModulesmcRoot mcSourceDirsToModuleCollectionmkModuleCollKey getBuildInfogetModuleNamesmodRecMSparsedRecModulerecModuleWillNeedCoderenamedRecModuletypedRecModulelookupModuleColllookupModInSCs removeModulehasGeneratedCodeneedsGeneratedCodecodeGeneratedForisAlreadyLoaded getAllModulesorderMCs getModulesmodulesFromDirectorysrcDirFromRootmodulesFromCabalFilecompileInContextapplyDependenciesdependencyToPkgFlagenableAllPackagesflagsFromBuildInfo$fToModuleCollectionBenchmark$fToModuleCollectionTestSuite$fToModuleCollectionExecutable$fToModuleCollectionLibrary$fShowModuleRecordRefactorSessionState __refSessMCs SummaryNodeNodeMapNodeKeyIsRefactSessionState refSessMCs initSession _refSessMCsloadPackagesFrom handleErrors keyFromMSgetMods getFileModsreloadChangedModulesgetReachableModules reloadModulecheckEvaluatedModscodeGenForModulegetEvaluatedMods modSumNamegetModFromNodemoduleGraphNodeshscSourceToIsBootsummaryNodeKey ms_home_impsms_home_srcimps home_imps*$fIsRefactSessionStateRefactorSessionState BindingElemsigBindvalBind fixitySig createTypeSig createBindingcreateFixitySig isTypeSig isBinding isFixitySiggetValBindInListvalBindsInList$fBindingElemULocalBind$fBindingElemUDecltryItOut dataToNewtype DollarDomain dollarAppExtractBindingDomainextractBinding'DomGenerateExportsgenerateExportsGenerateSignatureDomaingenerateTypeSignature'generateTypeSignature ifToGuardsInlineBindingDomain inlineBindingOrganizeImportsDomainprojectOrganizeImportsorganizeImportsDomainRenameDefinitionrenameDefinition'renameDefinitionRefactorCommand NoRefactorOrganizeImportsProjectOrganizeImportsGenerateExportsGenerateSignatureRenameDefinitionExtractBinding InlineBindingperformCommand readCommandanalyzeCommand$fShowRefactorCommand*Language.Haskell.Tools.AST.SemaInfoClasses HasNameInfo HasNameInfo' semanticsName HasIdInfo HasIdInfo' semanticsId HasFixityInfoHasFixityInfo'semanticsFixity HasScopeInfo HasScopeInfo'semanticsScopeHasDefiningInfoHasDefiningInfo'semanticsDefiningHasSourceInfoInSema'semanticsSourceInfo HasModuleInfoHasModuleInfo'semanticsModule isBootModulesemanticsImplicitImportssemanticsPrelOrphanInstssemanticsPrelFamInsts HasImportInfoHasImportInfo'semanticsImportedModulesemanticsAvailablesemanticsImportedsemanticsOrphanInstssemanticsFamInstsHasImplicitFieldsInfoHasImplicitFieldsInfo'semanticsImplicitFldsHasNoSemanticInfo"Language.Haskell.Tools.AST.HelpersinScopecompareRangeLengthgetNodeContainingnodesWithRange isContainednodesContainedisInsidenodesContaining semantics valBindPats typeParams declHeadNames bindingName importIsExactAnnList AnnNothingAnnJust NamedElement elementName%Language.Haskell.Tools.AST.References stringNodeStr simpleNameStrunqualifiedName qualifiers simpleName operatorNamepromotedStringValuepromotedIntValuepromotedElementspromotedConNamestringLitValue intLitValue fracLitValue floatLitValue charLitValue bracketTypebracketPattern bracketExpr bracketDeclqqString qqExprName qqExprBodyspliceId spliceExprfieldPatternWildcardfieldPatternName fieldPattern patternType patternSplice patternRhspatternOperator patternNamepatternLiteral patternLit patternLhs patternInner patternFields patternExpr patternElems patternArgspatQQ compStmts usingExprthenExprcompStmtbyExpr stmtPatternstmtExpr stmtBinds cmdStmtBindscaseGuardStmts caseGuardExpr rhsCaseGuards rhsCaseExpr pragmaStrpragmaSrcRange tupSecExpr fieldWildcard fieldValuefieldUpdateName fieldNamealtRhs altPatternaltBindstupleSectionElems tupleElems quotedName procPatternprocExpr listElems innerExprexprTypeexprThen exprStmts exprSpliceexprSigexprRhs exprRecName exprRecFieldsexprQQ exprPragma exprOperatorexprNameexprLitexprLhs exprInner exprIfAlts exprFunBindexprFunexprElseexprCondexprCase exprBracket exprBindingsexprArgexprAlts enumToFixenumToenumThenenumFromdoKindcompExprcompBody arrowAppl assertTypes assertRhsassertOp assertLhs assertImplVarassertImplType assertClsNamecontextAssertionscontextAssertionkindVar kindRight kindPromoted kindParenkindLeftkindElem kindAppFun kindAppArgtypeWildcardNametypeType typeRight typeResulttypeQQ typeParam typeOperatortypeNametypeLefttypeKind typeInner typeElements typeElementtypeCtxtypeCon typeBoundedtypeArgtsSplice tpPromoted tyVarName tyVarKind valBindRhs valBindPat valBindLocalsfunBindMatches kindConstr matchLhsRhsmatchLhsOperator matchLhsName matchLhsLhs matchLhsArgstsTypetsNameprecedenceValuefixityPrecedencefixityOperators fixityAssoc localBindslocalVallocalSig localFixityguardRhsguardPat guardCheck guardBinds guardStmts guardExpr rhsGuardsrhsExprmatchRhsmatchLhs matchBinds numberIntegersrToLinesrToCol srFromLine srFromCol srFileName minimalOrs minimalName minimalInner minimalAnds annotateNamespecializeType specializeDef pragmaRule pragmaPhase pragmaObjects pragmaMessage pragmaLineNumpragmaFileName pragmaConlike noInlineDef inlineDef inlinableDefannotationSubject annotateExprphaseNum phaseUntil phaseNumberruleRhs rulePhaseruleNameruleLhs ruleBoundedteRhsteLhsihType ihOperatorihLeftOpihHeadihFun ihConNameirVarsirHeadirCtx oneDerived allDerived fieldType fieldNames conDeclRhs conDeclOp conDeclName conDeclLhs conDeclFields conDeclArgs funDepRhs funDepLhsfunDeps patSigType patSigName patOpposite patSynRhspatSynOp patSynLhspatNamepatArgspatRhsOpposite patRhsPatpatRhspatLhsgadtConResultTypegadtConRecordFieldsgadtConNormalType gadtConType gadtConNames injAnnRes injAnnDeps tfSpecKind tfInjectivitytfSpectfKindtfHeadspecializeInstanceTypeinstBodyTypeSiginstBodyTypeEqninstBodyLhsTypeinstBodyGadtConsinstBodyDerivingsinstBodyDeclFunbindinstBodyDataNewinstBodyDataKindinstBodyDataCons instBodyDeclsdhRight dhOperatordhNamedhLeftdhBody dhAppOperanddhAppFun pragmaFormula ceTypeSig ceTypeFamceTypeceNameceKindceHeadceBind cbElements declValBind declTypes declTypeSigdeclTypeFamilydeclType declSplice declSafety declRoles declRoleType declPragmadeclPatTypeSig declPatSyn declOverlap declNewtypedeclNamedeclKind declInstance declInstRule declInstDecldeclHeaddeclGadt declFunDeps declFixity declDerivingdeclDecldeclCtxdeclCons declCallConvdeclBodydeclAssignedTypelangExtmoduleNameString importRenameimportSpecListimportSpecHiding importSpec importSource importSafeimportQualified importPkg importModuleimportAsopStr lpPragmas modWarningStrmodDeprecatedPragmaessList ieSubspecieName ieModifierexportModuleName exportDecl espExportsmhPragmamhName mhExports modImportsmodHeadmodDecl filePragmas'Language.Haskell.Tools.IndentationUtilssetMinimalIndent3haskell-tools-rewrite-0.4.1.3-AMK2yimal3xxLIP0GjfF6&Language.Haskell.Tools.AST.Match.Types ForallTypeCtxType FunctionType TupleTypeUnboxedTupleTypeListType ParArrayTypeTypeApp InfixTypeApp ParenTypeVarType KindedTypeBangTypeLazyType UnpackType NoUnpackType WildcardTypeNamedWildcardType SpliceTypeQuasiQuoteTypePromotedIntTypePromotedStringTypePromotedConTypePromotedListTypePromotedTupleTypePromotedUnitType TyVarDeclKindedTyVarDecl ContextOne ContextMulti ClassAssert InfixAssertImplicitAssert#Language.Haskell.Tools.AST.Match.THIdSplice ParenSplice QuasiQuote ExprBracketPatternBracket TypeBracket DeclsBracket&Language.Haskell.Tools.AST.Match.ExprsVarLitInfixApp PrefixAppAppLambdaLetIfMultiIfCaseDo ParArrayCompTuple UnboxedTuple TupleSectionUnboxedTupleSectionListParArrayParen LeftSection RightSectionRecCon RecUpdateEnum ParArrayEnumListCompParArrayListCompTypeSigExplicitTypeAppVarQuote TypeQuote BracketExpr SpliceExprQuasiQuoteExpr ExprPragmaProcArrowApp LambdaCase StaticPointerNormalFieldUpdateFieldPun FieldWildcard TupSecPresent TupSecMissingAltCaseRhsGuardedCaseRhssGuardedCaseRhs CorePragma SccPragmaGeneratedPragma SourceRange ArrowAppCmd ArrowFormCmdAppCmdInfixCmd LambdaCmdParenCmdCaseCmdIfCmdLetCmdDoCmdLeftAppl RightAppl LeftHighApp RightHighApp&Language.Haskell.Tools.AST.Match.StmtsBindStmtExprStmtLetStmtRecStmt DoKeyword MDoKeyword ListCompBodyCompStmtThenStmt GroupStmt BindStmtCmd ExprStmtCmd LetStmtCmd RecStmtCmd)Language.Haskell.Tools.AST.Match.PatternsVarPatLitPat InfixAppPatAppPatTuplePat UnboxTuplePatListPat ParArrayPatParenPatRecPatAsPatWildPatIrrefutablePatBangPat TypeSigPatViewPat SplicePat QuasiQuotePat NPlusKPat FieldPatternFieldPunPatternFieldWildcardPattern&Language.Haskell.Tools.AST.Match.NamesNormalOp BacktickOp NormalName ParenName ImplicitName StringNode QualifiedNameNamePart(Language.Haskell.Tools.AST.Match.ModulesModule ModuleHead ExportSpecs ExportSpec ModuleExportIESpecSubAllSubList ImportDeclImportRenamingImportSpecListImportHidingList ModuleNameLanguagePragma OptionsPragmaLanguageExtensionModuleWarningPragmaModuleDeprecatedPragma)Language.Haskell.Tools.AST.Match.LiteralsCharLit StringLitIntLitFracLit PrimIntLit PrimWordLit PrimFloatLit PrimDoubleLit PrimCharLit PrimStringLit&Language.Haskell.Tools.AST.Match.KindsKindConstraintStarKind UnboxKindFunKind ParenKindVarKindAppKindListKindIntKind StringKindConKindListKindPromoted TupleKindUnitKind&Language.Haskell.Tools.AST.Match.DeclsTypeDeclStandaloneDeriving FixityDecl DefaultDecl TypeSigDecl ValueBinding SpliceDeclDataDecl GADTDataDecl GadtConDeclGadtRecordConDeclConDecl RecordConDecl InfixConDecl FieldDecl DerivingOne DerivingMulti 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.AST.Match.Binds SimpleBind FunctionBindMatchMatchLhsInfixLhs LocalBinds LocalValBind LocalTypeSig LocalFixity TypeSignatureInfixLInfixRInfix UnguardedRhs GuardedRhss GuardedRhs GuardBindGuardLet GuardCheck$Language.Haskell.Tools.AST.Gen.TypesmkImplicitAssert mkInfixAssert mkClassAssertmkContextMulti mkContextOnemkPromotedUnitTypemkPromotedTupleTypemkPromotedListTypemkPromotedConTypemkPromotedStringTypemkPromotedIntTypemkQuasiQuoteType mkSpliceTypemkNamedWildcardTypemkWildcardTypemkNoUnpackType mkUnpackType mkLazyType mkBangType mkKindedType mkVarTypemkKindedTypeVar mkTypeVar mkParenTypemkInfixTypeApp mkTypeAppmkParArrayType mkListTypemkUnboxedTupleType mkTupleTypemkFunctionType mkCtxType mkTypeVar' mkForallType!Language.Haskell.Tools.AST.Gen.THmkDeclsBracket mkTypeBracketmkPatternBracket mkExprBracket mkQuasiQuote mkParenSplice mkIdSplice$Language.Haskell.Tools.AST.Gen.StmtsmkRecCmd mkLetStmtCmd mkExprCmd mkBindCmd mkGroupStmt mkThenStmt mkCompStmtmkListCompBody mkRecStmt mkLetStmt mkExprStmt mkBindStmt$Language.Haskell.Tools.AST.Gen.Binds mkGuardCheck mkGuardLet mkGuardBind mkGuardedRhs mkGuardedRhssmkUnguardedRhsmkInfixmkInfixRmkInfixLmkTypeSignature mkLocalFixitymkLocalTypeSigmkLocalValBind mkLocalBinds' mkLocalBinds mkInfixLhs mkMatchLhsmkMatchmkFunctionBind'mkFunctionBind mkSimpleBind mkSimpleBind''Language.Haskell.Tools.AST.Gen.PatternsmkFieldWildcardPatternmkFieldPunPatternmkPatternFieldmkQuasiQuotePat mkSplicePat mkViewPat mkTypeSigPat mkBangPatmkIrrefutablePat mkWildPatmkAsPatmkRecPat mkParenPat mkParArrayPat mkListPatmkUnboxTuplePat mkTuplePatmkAppPat mkInfixAppPatmkLitPatmkVarPat&Language.Haskell.Tools.AST.Gen.ModulesmkModuleDeprecatedPragmamkModuleWarningPragma mkOptionsGHCmkLanguagePragma mkModuleNamemkImportHidingListmkImportSpecList mkImportDeclmkSubAll mkSubListmkPatternIESpecmkIESpecmkModuleExport mkExportSpec mkExportSpecs mkModuleHeadmkModule$Language.Haskell.Tools.AST.Gen.Names mkStringNode mkSimpleName mkSimpleName' mkNamePartmkQualifiedNamemkQualifiedName'mkImplicitName mkParenName mkNormalName mkUnqualName' mkQualName' mkUnqualOp mkUnqualOp' mkQualOp' mkBacktickOpmkQualOpmkName'Language.Haskell.Tools.AST.Gen.LiteralsmkPrimStringLit mkPrimCharLitmkPrimDoubleLitmkPrimFloatLit mkPrimWordLit mkPrimIntLit mkFracLitmkIntLit mkStringLit mkCharLit$Language.Haskell.Tools.AST.Gen.Kinds mkUnitKind mkTupleKind mkListKind mkConKind mkStringKind mkIntKind mkKindList mkKindApp mkKindVar mkKindParen mkKindFun mkKindUnbox mkKindStarmkKindConstraint$Language.Haskell.Tools.AST.Gen.ExprsmkRightHighApplmkLeftHighAppl 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 mkDoBlockmkCase mkMultiIfmkIfmkLetmkLambdamkApp mkPrefixApp mkInfixAppmkLitmkVar$Language.Haskell.Tools.AST.Gen.DeclsmkConlikeAnnotationmkModuleAnnotationmkTypeAnnotationmkNameAnnotation 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.AST.ElementTypesAnnMaybeSubSpec ModulePragma FilePragma ImportSpecImportQualified ImportSource ImportSafe TypeNamespaceDecl ClassElementDeclHeadInstBody InstBodyDecl GadtConTypeDataOrNewtypeKeywordDeriving OverlapPragmaTopLevelPragmaRuleAnnotationSubjectMinimalFormulaTypeFamilySpecInjectivityAnn PatSynRhs PatSynLhs PatSynWhereRoleCallConvSafety ConlikeAnnot PhaseControl ValueBindRhsRhsGuard LocalBindFixitySignatureTypeTyVarContext AssertionKind PromotedKindExpr FieldUpdate TupSecElemCmdCmdAltStmtDoKindCmdStmtPattern PatternFieldSpliceBracketLiteralOperatorName MaybeContext MaybeDerivingMaybeLocalBindsMaybeTypeFamilySpecMaybeKindConstraintMaybeClassBody MaybeInstBody MaybeExprMaybeExportSpecsMaybeImportQualifiedMaybeImportSourceMaybeImportSafeMaybeImportSpecMaybeModuleHeadMaybeModulePragma MaybeSubSpecMaybeStringNodeMaybeImportRenaming MaybeSafetyMaybePhaseControlMaybeConlikeAnnot MaybeFunDeps MatchListDeclList PatternList OperatorListNameList LocalBindList IESpecList RhsGuardListGuardedRhsListGuardedCaseRhsList ConDeclList TypeEqnListTypeList FieldDeclListExprListFieldUpdateListGadtConDeclListClassElementListInstBodyDeclListInstanceHeadListAltListStmtListKindList TyVarListListCompBodyListExportSpecListFilePragmaListImportDeclListPatternFieldList AssertionList CompStmtListRuleListRoleListMinimalFormulaList FunDepListTupSecElemListCmdList CmdAltList CmdStmtListLanguageExtensionListStringNodeList NamePartListchangeDeclaration DollarMonad replaceExpr parenExpr parenDollar dollarNameextractBinding isConflictingaddLocalBindinginsertLocalBindisParenLikeExpr doExtractgetExternalBinds generateCall generateBindextractThatBindactualContainingExprisValidBindingName getTopLevels createExportsgenerateTypeFortypeSignatureAlreadyExisthasScopedTypeSignatures genTypeSig generateTSForgetBindingNamegetExternalTVs isForalledTSchangeBindingscreateSimpleIfRhssinlineBinding'containInlinedremoveBindingAndSigreplaceInvocations splitAppsjoinAppscreateReplacement replaceExprsmatchArgumentsstaticPatternMatch compositePatcompositeExprsremoveBindingAndSig' replaceMatch wrapLocals parenIfNeeded createLambda sortImports narrowImports narrowImport neededImportsnarrowImportSpecsnarrowImportSubspecs groupThings getTopDefcreateImportSpec renameModule conflicts sameNamespace