!p     None&'2 None>Qlambdabot-haskell-plugins,We can accumulate an interesting environmentlambdabot-haskell-pluginsExtract the default environmentlambdabot-haskell-pluginsCall the binary: Noneg NoneY Safe< !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXSafeIYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safe Safe Safe 4 Safe  None V  None wlambdabot-haskell-pluginsActually run the hoogle binary None lambdabot-haskell-pluginsNice little combinator used to throw away error messages from an Either and just keep a Maybe indicating the success of the computation.lambdabot-haskell-plugins-Parse an instance declaration. Sample inputs: Linstance Monad [] instance (Monoid w) => Monad (Writer w) instance (State s)lambdabot-haskell-plugins Wrapper for the instance parser.lambdabot-haskell-pluginsnSplit the input into a list of the instances, then run each instance through the parser. Collect successes.lambdabot-haskell-plugins)The standard modules we ask GHCi to load.lambdabot-haskell-pluginsMain processing function for @instances. Takes a class name and return a list of lines to output (which will actually only be one).lambdabot-haskell-pluginsMain processing function for @instances-importing. Takes the args, which are words'd. The all but the last argument are taken to be the modules to import, and the last is the typeclass whose instances we want to print.lambdabot-haskell-pluginsXInterface with GHCi to get the input for the parser, then send it through the parser.NoneEc      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefNone#glambdabot-haskell-pluginsExpressions with holes No MLambda here because we only consider closed Terms (no alpha-renaming!). Has to be in this module, otherwise we get recursionhlambdabot-haskell-plugins Applicationilambdabot-haskell-plugins/Hole/argument where another expression could go<gjhiklmnopqrstuvwxyz{|}~9 8NoneQ$NoneQ& lambdabot-haskell-pluginsExpression with syntactic sugarHNone=?QXLlambdabot-haskell-plugins,An expression with holes to match or replacelambdabot-haskell-pluginsExpression with holeslambdabot-haskell-pluginsNumber of holeslambdabot-haskell-pluginsA * rule, rewrite the first to the second s can contain islambdabot-haskell-plugins5Haskell function as a rule, applied to subexpressionslambdabot-haskell-plugins&Like Up, but applied to subexpressionslambdabot-haskell-pluginswApply the first rule, then try the second rule on the first result if it fails, returns the result of the first rulelambdabot-haskell-plugins Use all ruleslambdabot-haskell-plugins3Try the first rule, if it fails use the second rulelambdabot-haskell-plugins9Apply the first rule, apply the second rule to the resultlambdabot-haskell-plugins;Optionally apply the rewrite rule, Opt x == Or [identity,x]lambdabot-haskell-plugins=Apply the second rule only if the first rule has some resultslambdabot-haskell-plugins%Apply the rule only in the first passlambdabot-haskell-pluginsFill in the holes in a glambdabot-haskell-plugins%Create an array, only if the keys in lst+ are unique and all keys [0..n-1] are givenlambdabot-haskell-pluginseTry to match a Rewrite to an expression, if there is a match, returns the expressions in the holeslambdabot-haskell-pluginsFill in the holes in a lambdabot-haskell-pluginsFMatch an Expr to a MExpr template, return the values used in the holeslambdabot-haskell-pluginsYet another pointless transformation: Bring an MExpr to (more pointless) form by seeing it as a function hole_n -> ... and writing that in pointless formlambdabot-haskell-plugins%Is there a (Hole n) in an expression?lambdabot-haskell-plugins7Variants of a rewrite rule: fill in (some of) the holes2haddock doesn't like n+k patterns, so rewrite themlambdabot-haskell-plugins7Variants of a rewrite rule: fill in (some of) the holes2haddock doesn't like n+k patterns, so rewrite themlambdabot-haskell-plugins_Use this rewrite rule and rewrite rules derived from it by iterated pointless transformationlambdabot-haskell-plugins Construct a  rewrite rulelambdabot-haskell-plugins Construct a  rewrite rulelambdabot-haskell-plugins Construct a  rewrite rulelambdabot-haskell-plugins Construct a  rewrite rulelambdabot-haskell-pluginsApply Down/Up repeatedlylambdabot-haskell-pluginsApply Down/Up repeatedlyNoneEQSXL NoneT}lambdabot-haskell-pluginsThe size" of an expression, lower is bettervThis seems to be a better size for our purposes, despite being "a little" slower because of the wasteful uglyprintinglambdabot-haskell-pluginsOptimize an expressionlambdabot-haskell-pluginsApply all rewrite rules oncelambdabot-haskell-pluginsApply a single rewrite rulelambdabot-haskell-plugins.Apply a rewrite rule to an expression in a deep, position, i.e. from inside a RR,CRR or DownNone>Qblambdabot-haskell-pluginsDoes a name occur in a pattern?lambdabot-haskell-plugins:How often does the given name occur free in an expression?lambdabot-haskell-plugins(Does a name occur free in an expression?lambdabot-haskell-plugins"The subset of ds that d depends onlambdabot-haskell-pluginsCConvert recursive lets to lambdas with tuple patterns and fix callslambdabot-haskell-plugins3Rename all variables to (locally) unique fresh ones^It's a pity we still need that for the pointless transformation. Otherwise a newly created idconst\... could be bound by a lambda e.g. transform' (id x -> x) ==> transform' (id -> id) ==> idlambdabot-haskell-pluginsMake an expression points freelambdabot-haskell-plugins_Transform patterns to: fst/snd for tuple patterns head/tail for cons patterns idconstflip/. for variable paternsNonecOlambdabot-haskell-plugins"Convert a string to pointfree formNoneggHlambdabot-haskell-pluginscalculates "desired" indentation and return pretty-printed declarations the indentation calculations are still pretty much rough guesswork. i'll have to figure out a way to do some _reliable_ pretty-printing!NonegNoneQgNonehNoneSXklambdabot-haskell-pluginsParse a string as an  or a O, apply the given generic transformation to it, and re-render it back to text.lambdabot-haskell-plugins'Render haskell code in a compact formatNonegmlambdabot-haskell-plugins] is a smart constructor that inserts parens when the first argument is an infix application.;Don Stewart, Lennart Kolmodin 2007, Twan van Laarhoven 2008GPL-style (see LICENSE)Nonego>56None%XgoNoneo    !"#$%&'()*+ , -./0123456789:;<==>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzxy{xy|x}~x}x}x}x}x}x}x}x}x}x}xyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyx}x}x}x}                                                        !"#$"%&"#'"#("#)"#*"#+"#,"#-"#."/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"WX"WY"W"WZ"W["W\"@]":^_`a_`b_`c_`defghijklmnopqrstuvwxyz{|}~uh4lambdabot-haskell-plugins-5.3-Fpvcu9w0vD7LBAJkvJgy0tLambdabot.Plugin.HaskellLambdabot.Config.HaskellLambdabot.Plugin.Haskell.DjinnLambdabot.Plugin.Haskell.EvalLambdabot.Plugin.Haskell.Check#Lambdabot.Plugin.Haskell.Free.Parse"Lambdabot.Plugin.Haskell.Free.Util"Lambdabot.Plugin.Haskell.Free.Type"Lambdabot.Plugin.Haskell.Free.Expr%Lambdabot.Plugin.Haskell.Free.Theorem)Lambdabot.Plugin.Haskell.Free.FreeTheorem Lambdabot.Plugin.Haskell.HaddockLambdabot.Plugin.Haskell.Hoogle"Lambdabot.Plugin.Haskell.Instances"Lambdabot.Plugin.Haskell.Pl.Common!Lambdabot.Plugin.Haskell.Pl.Names"Lambdabot.Plugin.Haskell.Pl.Parser)Lambdabot.Plugin.Haskell.Pl.PrettyPrinter#Lambdabot.Plugin.Haskell.Pl.RuleLib!Lambdabot.Plugin.Haskell.Pl.Rules$Lambdabot.Plugin.Haskell.Pl.Optimize%Lambdabot.Plugin.Haskell.Pl.TransformLambdabot.Plugin.Haskell.PlLambdabot.Plugin.Haskell.PrettyLambdabot.Plugin.Haskell.SourceLambdabot.Plugin.Haskell.TypeLambdabot.Plugin.Haskell.FreeLambdabot.Util.ParserLambdabot.Plugin.Haskell.UndoLambdabot.Plugin.Haskell.UnMtl!Lambdabot.Plugin.Haskell.Pointful evalPrefixestrustedPackages languageExts djinnBinary ghcBinary ghciBinary hoogleBinary muevalBinarymaxPasteLength djinnPlugin evalPlugin checkPlugin haddockPlugin hooglePlugininstancesPluginplPlugin prettyPlugin sourcePlugin typePlugin freePlugin undoPlugin unmtlPluginpointfulPluginhaskellPluginsDjinnEnv getDjinnEnvdjinnrunGHCfindL_hsParseSparse ParseResult ParseSuccess ParseErrorTokenTokErrorIdUscoreIdWhereIdTypeIdThenIdOf IdNewtypeIdModuleIdLet IdInstanceIdInfixrIdInfixlIdInfixIdInIdImportIdIfIdForallIdElseIdDo IdDeriving IdDefaultIdDataIdClassIdCase OpImpliesOpTildeOpAtOpArrow OpBackArrowOpPipe OpBackslashOpEquals OpColonColonOpColonOpDotDot CloseBracket OpenBracket Semicolon CloseParen OpenParen BackQuoteCommaQConSymQVarSymQConIdQVarId CloseBrace OpenBrace peekTokengetTokenmatch ascSymbollexerpretty-1.1.3.6Text.PrettyPrint.HughesPJDocvcatfsep#Text.PrettyPrint.Annotated.HughesPJModePageMode ZigZagModeLeftMode OneLineModeStylemode lineLengthribbonsPerLinestyle fullRender renderStylerenderfirstfcatcatsep<+><>$+$$$ punctuatehangnesthsephcat reduceDocmaybeDoubleQuotes maybeQuotes maybeBraces maybeBrackets maybeParensbracesbracketsparens doubleQuotesquotesrationaldoublefloatintegerintrbracelbracerbracklbrackrparenlparenequalsspacecoloncommasemiisEmptyempty zeroWidthText sizedTextptexttextchar TextDetailsStrChrPStrPrettyprettyprettyP prettyParenprettyParenIndentTypeTyConsTyArrTyTupleTyForallTyVarTyName precTYAPP precARROWprettyTs parseType parseType' normaliseTypereadTypeExprCtxECTyAppECAppRECAppLECDotBuiltinBArr BMapTupleBProjBIdBMapExprETyAppEAppEVarOpEBuiltinEVarFixityFNFRFLVar varInExpr leftVarOfExpr exprSubstapplySimplifierExpr unzipExprvarInCtxprecAPPTheoremThAndThEqual ThImpliesThForall precIMPLIESprecAND prettyTheorem prettyForall varInTheoremapplySimplifierTheorempeepholeSimplifyTheorempeepholeSimplifyTheorem'peepholeSimplifyExprpeepholeSimplifyExpr' foldEquality tryCurryingtheoremSimplify theoremSubstRNRnStuniquefn uniquelistuniquegammaTyEnvMyMonMyState myVSupplymakeVar extractTypesfreeTheoremStr freeTheoreminitRnSt freshNamefreshFunctionName freshListNameinsertRnlookupRnrenamernExprnTy freeTheorem'hoogle eitherToMaybe instanceP parseInstance getInstancesstdMdlsfetchInstancesfetchInstancesImportingfetchInstances'baseGHC.Baseassert Control.MonadguardjoinMonad>>=>>returnfailFunctorfmapData.TraversablesequencemapM MonadPlusmplusmzero=<<whenliftMliftM2ap Data.MaybeisJust Data.Functorvoid Data.OldList intersperse Data.Foldable sequence_filterMfoldMunlessliftM3liftM4liftM5mapM_forM_msumforM>=><=<forever mapAndUnzipMzipWithM zipWithM_foldM_ replicateM replicateM_<$!>mfilter Control.Arrow|||+++***second&&& minimumByfromJustparsec-3.1.13.0Text.Parsec.ExprAssoc AssocNone AssocLeft AssocRightTopLevelTLDTLEDeclDefinedeclNamedeclExprPatternPVarPTuplePConsAppLetLambdaPrefInf mapTopLevelgetExprsizeExprcompflip'id'const'scombconsnilfix'if'makeListgetListbtmaxPrecminPrec operatorsopchars reservedOpslookupOp lookupFixreadMMExprMAppHoleQuoteidEflipEconstEcompEsEfixEbindEextEreturnEconsEnilEappendEfoldrEfoldlEfstEsndEdollarEuncurryEcurryEheadEtailEcommaEfoldl1EequalsEnequalsEnotEplusEmultEzeroEoneElengthEsumEproductEconcatE concatMapEjoinEmapEfmapEfmapIE subtractEminusEliftMEliftM2EapEseqMEzipEzipWithEcrossEfirstEsecondEandEorEallEanyEacparsePFSExprRewriteholesridRRCRRDownUpOrOrElseThenOptIfHardmyFire uniqueArrayfire' matchWith transformMhasHole getVariants' getVariantsrrListrrrr1rr2rr0downup RewriteRulefirerules sizeExpr'optimizesteprewriterewoccursPfreeInisFreeIn dependsOnunLet alphaRename transform transform'pfdoPretty query_ghci withParsed7haskell-src-exts-simple-1.23.0.0-LUdM10yRLbxCKpN5drNPhG#Language.Haskell.Exts.Simple.SyntaxExpprettyPrintInLineapp-->