h$of       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH 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 { | } ~                                                         !"####$%%%%%%%%%%%%%&&&&'''''()******++,,,--NoneQNonefourmolu2Ormolu-specific representation of GHC annotations.fourmoluEmpty .fourmoluCreate  from .fourmoluLookup s corresponding to a given .fourmoluSpan to lookup withfourmoluCollection of annotationsNone  fourmolu#Ormolu's representation of pragmas. fourmoluLanguage pragma fourmoluGHC options pragma fourmoluHaddock options pragmafourmolu7Extract a pragma from a comment if possible, or return  otherwise.fourmoluComment to try to parse  None3 Efourmolu A stream of s in ascending order. This allows us to tell e.g. whether there is another "located" element of AST between current element and comment we're considering for printing.fourmoluCreate 6 from a data structure containing "located" elements.fourmoluData structure to inspect (AST) Safe-Inferred fourmolu Return an 0 containing all lines which are affected by CPP.None &t fourmoluRelative positions in a list.!fourmoluAttach es to elements of a given list."fourmolu-Combine all source spans from the given list.#fourmolu4Placeholder for things that are not yet implemented.$fourmoluPretty-print an  thing.%fourmoluSplit and normalize a doc string. The result is a list of lines that make up the comment.&fourmoluGet  out of  if the span is @helpful@.'fourmoluIncrement line number in a .(fourmolu.Do two declarations have a blank between them?)fourmolu4Do two declaration groups have a blank between them?*fourmoluReturn 9 if one span ends on the same line the second one starts.+fourmoluA generalisation of groupBy to functions which aren't equivalences - a group ends when comparison fails with the previous element, rather than the first of the group. !"#$%&'()*+ !"#$%&'()*+None #$ .fourmolu;Whether to use colors and other features of ANSI terminals.2fourmoluTerminal monad.3fourmoluRun 2 monad.4fourmolu,Make the inner computation output bold text.5fourmolu,Make the inner computation output cyan text.6fourmolu-Make the inner computation output green text.7fourmolu+Make the inner computation output red text.8fourmoluOutput .9fourmoluOutput .:fourmolu Output a ./.;fourmoluOutput a newline.3fourmolu Monad to runfourmolu Color modefourmoluHandle to print to./0123456789:;2./013456789:;None #$CfourmoluResult of diffing two s.DfourmoluDiff two texts and produce a C.EfourmoluPrint the given C as a 24 action. This function tries to mimic the style of git diff.Dfourmolu Text beforefourmolu Text afterfourmolu Path to usefourmoluThe resulting diff or  if the inputs are identicalCDECDE None S Hfourmolu=Ormolu exception representing all cases when Ormolu can fail.Ifourmolu&Parsing of original source code failedJfourmolu'Parsing of formatted source code failedKfourmolu"Original and resulting ASTs differLfourmolu'Formatted source code is not idempotentMfourmolu$Some GHC options were not recognizedNfourmoluCabal file parsing failedOfourmoluMissing input file path when using stdin input and accounting for .cabal filesPfourmoluInside this wrapper H& will be caught and displayed nicely.Pfourmolu Color modefourmolu"Action that may throw an exception HIJKLMNOP HIJKLMNOP None #$258> TfourmoluThe result of calling .XfourmoluA wrapper for dynamic options.afourmolu A version of c without empty fields.bfourmolu A version of c where any field can be empty. This corresponds to the information in a config file or in CLI options.cfourmolu&Options controlling formatting output.efourmolu'Number of spaces to use for indentationffourmolu0Whether to place commas at start or end of linesgfourmoluWhether to indent `where` blockshfourmolu'Leave space before opening record braceifourmolu2Trailing commas with parentheses on separate linesjfourmolu.Be less opinionated about spaces/newlines etc.kfourmoluHow to print doc commentslfourmolu*Number of newlines between top-level declsmfourmoluRegion selection as the length of the literal prefix and the literal suffix.ofourmolu Prefix length in number of linespfourmolu Suffix length in number of linesqfourmoluRegion selection as the combination of start and end line numbers.sfourmolu"Start line of the region to formattfourmolu End line of the region to formatufourmoluOrmolu configuration.wfourmolu%Dynamic options to pass to GHC parserxfourmolu?Do formatting faster but without automatic detection of defectsyfourmolu'Output information useful for debuggingzfourmolu0Checks if re-formatting the result is idempotent{fourmolu:Whether to use colors and other features of ANSI terminals|fourmoluRegion selection~fourmoluDefault u q.fourmoluFill the field values that are  in the first argument with the values of the corresponding fields of the second argument.fourmoluConvert q into m.fourmoluConvert X to  .fourmoluRead options from a config file, if found. Looks recursively in parent folders, then in , for a file named  fourmolu.yaml.fourmolu#Expected file name for YAML config.fourmolu"Total number of lines in the inputfourmoluRegion indicesfourmolu Region deltas5./01TWVUXYZ[]\^_`abcdiefghjklmnopqrstuvwxyz{|}~5uvwxyz{|}./01qrstmnop~cdiefghjklbaTWVU^_`[]\XYZ None #$&!ufourmolu Remove indentation from a given . Return the input with indentation removed and the detected indentation level.fourmoluAdd indentation to a .fourmolu%All lines in the region specified by m.fourmoluGet the region after the end of the first and till the end of the second region.fourmolu,Convert a set of line indices into disjoint  RegionDeltasfourmoluTotal number of linesfourmoluTotal number of lines None #$"DfourmoluPreprocess the specified region of the input into raw snippets and subregions to be formatted.fourmoluWhether CPP is enabled None$fourmoluIntermediate representation of operator trees. It has two type parameters: ty' is the type of sub-expressions, while op is the type of operators.fourmoluReturn combined s of all elements in this .fourmoluRe-associate an  taking into account automagically inferred relative precedence of operators. Users are expected to first construct an initial <, then re-associate it using this function before printing.fourmoluHow to get name of an operatorfourmolu Original fourmoluRe-associated None3(ffourmolu$A wrapper for a single comment. The  indicates whether there were atoms before beginning of the comment in the original input. The 1 list inside contains lines of multiline comment {- @ -}% or just single item/line otherwise.fourmolu A stream of  s in ascending order with respect to beginning of corresponding spans.fourmoluCreate  from $. The pragmas are removed from the .fourmoluPretty-print a .fourmolu!Get a collection of lines from a .fourmoluCheck whether the  had some non-whitespace atoms in front of it in the original input.fourmolu Is this comment multiline-style?fourmoluOriginal inputfourmolu*Parser state to use for comment extractionfourmolu)Stack header, pragmas, and comment stream  None <.fourmoluHaddock string style.fourmolu -- |fourmolu -- ^fourmolu -- *fourmolu -- $fourmolu=An auxiliary marker for keeping track of last output element.fourmoluHaddock commentfourmoluNon-haddock commentfourmolu'A statement in a do-block and such spanfourmolu(Modes for rendering of pending comments.fourmolu Put the comment on the same linefourmoluPut the comment on next linefourmolu options.fourmoluPut everything on single linefourmoluUse multiple linesfourmoluThe  monad hosts combinators that allow us to describe how to render AST.fourmoluRun  monad.fourmoluOutput a fixed : fragment. The argument may not contain any line breaks.  is used to output all sorts of @fixed@ bits of syntax like keywords and pipes | in functional dependencies.8To separate various bits of syntax with white space use  instead of  " " . To output $ Haskell entities like numbers use .fourmolu Similar to  but the text inserted this way is assumed to break the @link@ between the preceding atom and its pending comments.fourmoluOutput  fragment of AST. This can be used to output numeric literals and similar. Everything that doesn't have inner structure but does have an  instance.fourmoluThis primitive does not necessarily output a space. It just ensures that the next thing that will be printed on the same line will be separated by a single space from the previous output. Using this combinator twice results in at most one space.In practice this design prevents trailing white space and makes it hard to output more than one delimiting space in a row, which is what we usually want.fourmoluOutput a newline. First time  is used after some non-5 output it gets inserted immediately. Second use of  does not output anything but makes sure that the next non-white space output will be prefixed by a newline. Using 6 more than twice in a row has no effect. Also, using  at the very beginning has no effect, this is to avoid leading whitespace. Similarly to , this design prevents trailing newlines and makes it hard to output more than one blank newline in a row.fourmoluReturn & if we should print record dot syntax.fourmoluLike 3, but indents by exactly the given number of steps.fourmoluLike 3, but indents by the given fraction of a full step.fourmoluIncrease indentation level by one indentation step for the inner computation.  should be used when a part of code must be more indented relative to the parts outside of  in order for the output to be valid Haskell. When layout is single-line there is no obvious effect, but with multi-line layout correct indentation levels matter.fourmoluIn rare cases, we have to indent by a positive amount smaller than  indentStep.fourmoluSet indentation level for the inner computation equal to current column. This makes sure that the entire inner block is uniformly "shifted" to the right.fourmoluSet  for internal computation.fourmolu-Do one or another thing depending on current .fourmolu Get current .fourmoluGet a particular c field from the environment.fourmoluRegister a comment line for outputting. It will be inserted right before next newline. When the comment goes after something else on the same line, a space will be inserted between preceding text and the comment when necessary.fourmolu?Drop elements that begin before or at the same place as given .fourmolu$Get location of next element in AST.fourmoluPop a  from the  if given predicate is satisfied and there are comments in the stream.fourmoluGet the first enclosing  that satisfies given predicate.fourmoluSet - of enclosing span for the given computation.fourmoluGet spans on this line so far.fourmoluProject  from .fourmolu Set span of last output comment.fourmolu Get span of last output comment.fourmoluFor a given span return s associated with it.fourmoluMake the inner computation use braces around single-line layouts.fourmoluMake the inner computation omit braces around single-line layouts.fourmoluReturn & if we can use braces in this context.fourmolu Monad to runfourmolu Span streamfourmoluComment streamfourmolu AnnotationsfourmoluUse Record Dot SyntaxfourmoluEnabled extensionsfourmoluResulting renditionfourmolu to outputfourmolu to outputfourmolu Single linefourmolu Multi linefourmoluComment positionfourmolu to outputfourmoluReference spanfourmoluPredicate to usefourmoluSpan mark to set00None @Bfourmolu?Output all preceding comments for an element at given location.fourmolu;Output all comments following an element at given location.fourmolu4Output all remaining comments in the comment stream.fourmolu Output a 4 immediately. This is a low-level printing function.fourmolu Output a 6 at the end of correct line or after it depending on . Used for comments that may potentially follow on the same line as something we just rendered, but not immediately after it.fourmolu)Span of the element to attach comments tofourmolu)Span of the element to attach comments toNone '(?Lfourmolu- controlling how closing bracket is rendered.fourmoluNormalfourmoluShifted one levelfourmolu5Indent the inner expression if the first argument is .fourmoluEnter a  entity. This combinator handles outputting comments and sets layout (single-line vs multi-line) for the inner computation. Roughly, the rule for using  is that every time there is a : wrapper, it should be @discharged@ with a corresponding  invocation.fourmoluSee fourmolu A version of  with arguments flipped.fourmolu-Set layout according to combination of given s for a given. Use this only when you need to set layout based on e.g. combined span of several elements when there is no corresponding  wrapper provided by GHC AST. It is relatively rare that this one is needed.>Given empty list this function will set layout to single line.fourmoluInsert a space if enclosing layout is single-line, or newline if it's multiline. "breakpoint = vlayout space newlinefourmolu Similar to 4 but outputs nothing in case of single-line layout. )breakpoint' = vlayout (return ()) newlinefourmoluRender a collection of elements inserting a separator between them.fourmoluRender a collection of elements layout-sensitively using given printer, inserting semicolons if necessary and respecting  and  combinators. useBraces $ sepSemi txt ["foo", "bar"] == vlayout (txt "{ foo; bar }") (txt "foo\nbar") dontUseBraces $ sepSemi txt ["foo", "bar"] == vlayout (txt "foo; bar") (txt "foo\nbar")fourmolu#Surround given entity by backticks.fourmoluSurround given entity by banana brackets (i.e., from arrow notation.)fourmolu&Surround given entity by curly braces { and }.fourmoluSurround record update fields which use RecordDot plugin entity by curly braces { and }.fourmolu)Surround given entity by square brackets [ and ].fourmolu%Surround given entity by parentheses ( and ).fourmoluSurround given entity by (#  and  #).fourmoluBraces as used for pragmas: {-# and #-}.fourmolu)Surround the body with a pragma name and .fourmoluPrint ,.fourmoluDelimiting combination with . To be used with .fourmoluPrint = . Do not use  "=".fourmoluWhether to indentfourmoluThe expression to indentfourmoluThing to enterfourmoluHow to render inner valuefourmoluThing to enterfourmoluHow to render inner valuefourmoluHow to render inner valuefourmoluThing to enterfourmoluSpan that controls layoutfourmolu&Computation to run with changed layoutfourmolu SeparatorfourmoluHow to render an elementfourmoluElements to renderfourmoluHow to render an elementfourmoluElements to renderfourmolu Pragma textfourmolu Pragma body;;None N)fourmoluPrint a collection of  !s with their associated comments.None QfourmoluData and type family style.fourmoluDeclarations in type classesfourmoluTop-level declarationsfourmolu Render a  .fourmoluWhether given name should not have parentheses around it. This is used to detect e.g. tuples for which annotations will indicate parentheses, but the parentheses are already part of the symbol, so no extra layer of parentheses should be added. It also detects the [] literal.fourmoluA helper for formatting infix constructions in lhs of definitions.fourmoluPrint a Haddock.fourmolu Whether to format in infix stylefourmolu)Whether to bump indentation for argumentsfourmoluHow to print the operator/namefourmoluHow to print the argumentsfourmolu Haddock stylefourmolu$Finish the doc string with a newlinefourmoluThe doc string to render  None #$RfourmoluReturn  if at least one argument in " has a doc string attached to it.fourmoluRender several forall-ed variables.  None SNone #$S5None SaNone #$SNone #$T-fourmoluType constructorfourmoluFixityfourmoluType variablesfourmoluRHS of type declarationNone #$TSNone TNone %TNone #$'(Ufourmolu Whether to format as data familyfourmoluType constructorfourmolu Type patternsfourmoluLexical fixityfourmoluData definitionNone #$&U NoneU!None #$V"None V)#None #$VO$None #$VNone #$&WfourmoluLike  but respects user choices regarding grouping. If the user omits newlines between declarations, we also omit them in most cases, except when said declarations have associated Haddocks.Does some normalization (compress subsequent newlines into a single one)%None#$Y fourmolu?A collection of data that represents a parsed module in Ormolu.fourmolu ParsedSource from GHCfourmolu,Ormolu-specfic representation of annotationsfourmolu Stack headerfourmolu#Pragmas and the associated commentsfourmoluComment streamfourmolu+Whether or not record dot syntax is enabledfourmoluEnabled extensionsfourmolu?Indentation level, can be non-zero in case of region formattingfourmolu Either a , or a raw snippet.  &None #$[efourmolu$Parse a complete module from string.fourmoluExtensions that are not enabled automatically and should be activated by user.fourmoluOrmolu configurationfourmolu0File name (only for source location annotations)fourmoluInput for parser'None#$[fourmoluSort, group and normalize imports. Assumes input list is sorted by source location.(None #$\fourmoluRender a module.fourmolu Stack headerfourmolu#Pragmas and the associated commentsfourmolu AST to print)None #$]2fourmoluRender a module.fourmoluResult of parsingfourmoluResulting rendition cdiefghjkl cdiefghjkl*None #$%&^1fourmoluResult of comparing two s.fourmoluTwo parse results are the samefourmoluTwo parse results differfourmoluReturn Diff of two s.None#$&`nfourmoluGet a map from Haskell source file paths (without any extensions) to its default language extensionsfourmoluFind the path to an appropriate .cabal file for a Haskell source file, if availablefourmoluGet the default language extensions of a Haskell source file. The .cabal file can be provided explicitly or auto-detected.fourmoluPath to cabal filefourmoluAbsolute path to a Haskell source file in a project with a .cabal filefourmoluHaskell source file+ Safe-InferredafourmoluWrite a  to a file using UTF8 and ignoring native line ending conventions.fourmolu$Read an entire file strictly into a 9 using UTF8 and ignoring native line ending conventions.,Noneefourmolu Format a , return formatted version as . The functionTakes ( because that's what GHC parser accepts.Needs  because some functions from GHC that are necessary to setup parsing context require 8. There should be no visible side-effects though.7Takes file name just to use it in parse error messages.Throws H.fourmoluLoad a file and format it. The file stays intact and the rendered version is returned as . ormoluFile cfg path = liftIO (readFile path) >>= ormolu cfg pathfourmolu$Read input from stdin and format it. ormoluStdin cfg = liftIO (hGetContents stdin) >>= ormolu cfg ""fourmoluOrmolu configurationfourmoluLocation of source filefourmoluInput to formatfourmoluOrmolu configurationfourmoluLocation of source filefourmoluResulting renditionfourmoluOrmolu configurationfourmoluResulting rendition5./01HIJKLMNOPTWVUXYZabcdiefghjklqrstuvwxyz{|}~5uvwxyz{|}./01qrst~XYZcdiefghjklbaTWVUHIJKLMNOP01201301401566789:;<=>?@ABBCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvw x y z { | } ~                                                                                                       k !"####$%%%%%%%%%%%%%&&&&'''''()******++,,,-/'fourmolu-0.4.0.0-LeiclRjONUdFWKAZR6QEVUOrmolu.Utils.ExtensionsOrmolu.Parser.AnnsOrmolu.Parser.PragmaOrmolu.Printer.SpanStreamOrmolu.Processing.Cpp Ormolu.UtilsOrmolu.TerminalOrmolu.Diff.TextOrmolu.Exception Ormolu.ConfigOrmolu.Processing.CommonOrmolu.Processing.PreprocessOrmolu.Printer.OperatorsOrmolu.Parser.CommentStreamOrmolu.Printer.InternalOrmolu.Printer.CommentsOrmolu.Printer.CombinatorsOrmolu.Printer.Meat.Pragma%Ormolu.Printer.Meat.Declaration.ValueOrmolu.Printer.Meat.CommonOrmolu.Printer.Meat.Type'Ormolu.Printer.Meat.Declaration.Default Ormolu.Printer.Meat.ImportExport'Ormolu.Printer.Meat.Declaration.Warning*Ormolu.Printer.Meat.Declaration.TypeFamily$Ormolu.Printer.Meat.Declaration.Type)Ormolu.Printer.Meat.Declaration.Signature.Ormolu.Printer.Meat.Declaration.RoleAnnotation'Ormolu.Printer.Meat.Declaration.Foreign$Ormolu.Printer.Meat.Declaration.DataOrmolu.Printer.Meat.Declaration&Ormolu.Printer.Meat.Declaration.Splice$Ormolu.Printer.Meat.Declaration.Rule*Ormolu.Printer.Meat.Declaration.Annotation(Ormolu.Printer.Meat.Declaration.Instance%Ormolu.Printer.Meat.Declaration.ClassOrmolu.Parser.Result Ormolu.ParserOrmolu.ImportsOrmolu.Printer.Meat.ModuleOrmolu.PrinterOrmolu.Diff.ParseResultOrmolu.Utils.IOOrmolu GHC.DynFlagsGHCSrcSpan$Cabal-3.4.0.0-87V2bvTScjS3xdojmsQSEWLanguage.Haskell.ExtensionUnknownExtensionDisableExtensionEnableExtension ExtensionAnns emptyAnnsmkAnns lookupAnns$fEqAnnsPragmaPragmaLanguagePragmaOptionsGHCPragmaOptionsHaddock parsePragma $fShowPragma $fEqPragma SpanStream mkSpanStream$fEqSpanStream$fShowSpanStream$fDataSpanStream$fSemigroupSpanStream$fMonoidSpanStreamcppLines $fEqState $fShowState RelativePos SinglePosFirstPos MiddlePosLastPosattachRelativePoscombineSrcSpans'notImplementedshowOutputablesplitDocString unSrcSpan incSpanLineseparatedByBlankseparatedByBlankNE onTheSameLinegroupBy'$fEqRelativePos$fShowRelativePos ColorModeNeverAlwaysAutoTermrunTermboldcyangreenredputputS putSrcSpannewline $fEqColorMode$fShowColorMode$fEnumColorMode$fBoundedColorMode $fFunctorTerm$fApplicativeTerm $fMonadTermTextDiffdiffText printTextDiff$fShowTextDiff $fEqTextDiffOrmoluExceptionOrmoluParsingFailedOrmoluOutputParsingFailedOrmoluASTDiffersOrmoluNonIdempotentOutputOrmoluUnrecognizedOptsOrmoluCabalFileParsingFailedOrmoluMissingStdinInputFilewithPrettyOrmoluExceptions$fExceptionOrmoluException$fEqOrmoluException$fShowOrmoluExceptionConfigFileLoadResult ConfigLoadedConfigParseErrorConfigNotFound DynOption unDynOptionHaddockPrintStyleHaddockSingleLineHaddockMultiLine CommaStyleLeadingTrailingPrinterOptsTotalPrinterOptsPartial PrinterOpts poIndentation poCommaStylepoIndentWherespoRecordBraceSpacepoDiffFriendlyImportExport poRespectfulpoHaddockStylepoNewlinesBetweenDecls RegionDeltasregionPrefixLengthregionSuffixLength RegionIndicesregionStartLine regionEndLineConfig cfgDynOptions cfgUnsafecfgDebugcfgCheckIdempotence cfgColorMode cfgRegioncfgPrinterOpts defaultConfigdefaultPrinterOptsfillMissingPrinterOptsregionIndicesToDeltasdynOptionToLocatedStrloadConfigFileconfigFileName$fFromJSONCommaStyle$fFromJSONHaddockPrintStyle$fFromJSONPrinterOpts$fMonoidPrinterOpts$fSemigroupPrinterOpts$fEqConfigFileLoadResult$fShowConfigFileLoadResult $fEqConfig $fShowConfig$fFunctorConfig $fEqDynOption$fOrdDynOption$fShowDynOption$fGenericPrinterOpts$fEqHaddockPrintStyle$fOrdHaddockPrintStyle$fShowHaddockPrintStyle$fGenericHaddockPrintStyle$fBoundedHaddockPrintStyle$fEnumHaddockPrintStyle$fEqCommaStyle$fOrdCommaStyle$fShowCommaStyle$fGenericCommaStyle$fBoundedCommaStyle$fEnumCommaStyle$fEqRegionDeltas$fShowRegionDeltas$fEqRegionIndices$fShowRegionIndices$fShowPrinterOpts$fEqPrinterOpts$fShowPrinterOpts0$fEqPrinterOpts0removeIndentationreindent linesInRegionregionInbetweenintSetToRegions preprocess$fEqOrmoluState$fShowOrmoluStateOpTreeOpNodeOpBranch opTreeLocreassociateOpTree $fEqScore $fOrdScoreComment CommentStreammkCommentStreamshowCommentStream unCommenthasAtomsBeforeisMultilineComment$fEqCommentStream$fDataCommentStream$fSemigroupCommentStream$fMonoidCommentStream $fEqComment $fShowComment $fDataComment HaddockStylePipeCaretAsteriskNamedSpanMark HaddockSpan CommentSpan StatementSpanCommentPosition OnTheSameLine OnNextLineLayout SingleLine MultiLineRrunRtxtinterferingTxtatomspace declNewline useRecordDotinciBy inciByFracinciinciHalfsitcc enterLayoutvlayout getLayout getPrinterOptregisterPendingCommentLinetrimSpanStream nextEltSpan popCommentgetEnclosingSpanwithEnclosingSpan thisLineSpans spanMarkSpan setSpanMark getSpanMarkgetAnns useBraces dontUseBraces canUseBracesisExtensionEnabled $fFunctorR$fApplicativeR$fMonadR$fShowSpitType $fEqSpitType$fEqCommentPosition$fShowCommentPosition $fEqLayout $fShowLayout$fEqRequestedDelimiter$fShowRequestedDelimiterspitPrecedingCommentsspitFollowingCommentsspitRemainingCommentsspitCommentNowspitCommentPending BracketStyleNSinciIflocated realLocatedlocated' switchLayout breakpoint breakpoint'sepsepSemi backticksbananabracesrecordDotBracesbracketsparens parensHash pragmaBracespragmacommacommaDelequals$fEqBracketStyle$fShowBracketStyle p_pragmas $fEqPragmaTy $fOrdPragmaTy$fEqLanguagePragmaClass$fOrdLanguagePragmaClass p_stringLit p_hsSplicep_hsExprp_pat p_valDecl FamilyStyle AssociatedFree p_hsmodNamep_ieWrappedName p_rdrNamedoesNotNeedExtraParens p_qualNamep_infixDefHelper p_hsDocString p_sourceTextForAllVisibility ForAllInvis ForAllVisp_hsTypep_hsTypePostDoc hasDocStrings p_hsContext p_hsTyVarBndr p_forallBndrsp_conDeclFields p_lhsTypeArg tyVarsToTypestyVarsToTyPats $fIsInferredTyVarBndrSpecificity$fIsInferredTyVarBndr() p_defaultDeclp_hsmodExports p_hsmodImportbreakIfNotDiffFriendly p_warnDeclsp_moduleWarning p_famDeclp_tyFamInstEqn p_synDecl p_sigDeclp_typeAscription p_activationp_standaloneKindSig p_roleAnnot p_foreignDecl p_dataDeclp_hsDeclsRespectGrouping p_hsDecls $fEqPlacement$fShowPlacement p_spliceDecl p_ruleDecls p_annDeclp_standaloneDerivDecl p_clsInstDeclp_tyFamInstDeclp_dataFamInstDecl p_classDecl$fEqUserGrouping$fShowUserGrouping ParseResultprParsedSourceprAnns prStackHeader prPragmasprCommentStreamprUseRecordDot prExtensionsprIndent SourceSnippet RawSnippet ParsedSnippet parseModule manualExts$fOrdSeverityOrd$fEqSeverityOrdnormalizeImports$fOrdIEWrappedNameOrd$fEqIEWrappedNameOrd $fEqImportId $fOrdImportId p_hsModule printModuleParseResultDiffSame DifferentdiffParseResult$fMonoidParseResultDiff$fSemigroupParseResultDiffgetExtensionsFromCabalFile findCabalFilegetCabalExtensionDynOptions writeFileUtf8 readFileUtf8ormolu ormoluFile ormoluStdin baseDynFlags4ghc-lib-parser-9.0.1.20210324-KhT8gCGlMUXDIBlo6O2TR9GHC.Parser.LexerPStateGHC.Parser.Annotation AnnKeywordIdGHC.Types.SrcLocbase GHC.MaybeNothing RealSrcSpancontainers-0.6.2.1Data.IntSet.InternalIntSetGHC.Utils.Outputable Outputableghc-prim GHC.TypesTrue text-1.2.3.2Data.Text.InternalTextGHC.BaseStringLocateddirectory-1.3.6.0 System.Directory.Internal.Common XdgConfigBoolNonEmpty RealLocatedGHC.Types.Name.ReaderRdrName GHC.Hs.TypeHsTypeIO