h$      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ 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 { | } ~                       !"##$%&''''(##))))))))))))))****+++++,-.......///00111142None ^3None fourmolu5Generate a `BijectiveMap a` value with the given map.Checks the following: * all Names in given list refer to a constructor of type a * all Names in given list refer to a 0-arity constructor * all constructors in type a are accounted for.4 Safe-Inferred8  fourmolu&Options controlling formatting output.fourmolu'Number of spaces to use for indentationfourmolu0Whether to place commas at start or end of linesfourmolu>Whether to place commas at start or end of import-export linesfourmoluWhether to indent `where` blocksfourmolu'Leave space before opening record bracefourmolu2Trailing commas with parentheses on separate linesfourmolu.Be less opinionated about spaces/newlines etc.fourmoluHow to print doc commentsfourmolu*Number of newlines between top-level decls None #$;q fourmoluThe map of operators declared by each package and the popularity of each package, if available.fourmolu A variant of *, represented as a lazy union of several s.fourmolu"Map from the operator name to its .fourmoluFixity information about an infix operator that takes the uncertainty that can arise from conflicting definitions into account.fourmoluFixity direction if it is knownfourmoluMinimum precedence level found in the (maybe conflicting) definitions for the operator (inclusive) fourmoluMaximum precedence level found in the (maybe conflicting) definitions for the operator (inclusive)!fourmoluFixity direction.%fourmolu>The lowest level of information we can have about an operator.&fourmolu3Fixity info of the built-in colon data constructor.'fourmolu Lookup a  of an operator. This might have drastically different performance depending on whether this is an "unusal" operator.*fourmoluGives the ability to merge two (maybe conflicting) definitions for an operator, keeping the higher level of compatible information from both.fourmolu?Map from package name to a map from operator name to its fixityfourmoluMap from package name to its 30-days download count from Hackage !"#$%&'!"#$ %&'NoneE;fourmoluList of packages shipped with GHC, for which the download count from Hackage does not reflect their high popularity. See  ?https://github.com/tweag/ormolu/pull/830#issuecomment-986609572. "base" is not is this list, because it is already whitelisted by buildFixityMap'.<fourmoluThe default value for the popularity ratio threshold, after which a very popular definition from packageToOps will completely rule out conflicting definitions instead of being merged with them.=fourmoluBuild a fixity map using the given popularity threshold and a list of cabal dependencies. Dependencies from the list have higher priority than other packages.>fourmoluBuild a fixity map using the given popularity threshold and a list of cabal dependencies. Dependencies from the list have higher priority than other packages. This specific version of the function allows the user to specify the package databases used to build the final fixity map.=fourmoluPopularity ratio threshold, after which a very popular package will completely rule out conflicting definitions coming from other packages instead of being merged with themfourmoluExplicitly known dependenciesfourmolu Resulting map>fourmoluMap from package to fixity map for operators defined in this packagefourmoluMap from package to popularityfourmoluHigher priority packagesfourmoluPopularity ratio threshold, after which a very popular package will completely rule out conflicting definitions coming from other packages instead of being merged with themfourmoluExplicitly known dependenciesfourmolu Resulting map !"#$%'9:;<=>!"#$ '<%=>;9:None #$?fourmolu"Parse textual representation of a .@fourmolu1Parse a single self-contained fixity declaration.?fourmolu;Location of the file we are parsing (only for parse errors)fourmoluFile contents to parsefourmolu Parse result@fourmoluExpression to parsefourmolu Parse result?@?@None #$8Afourmolu(Print out a textual representation of a .AANone rBfourmolu#Ormolu's representation of pragmas.CfourmoluLanguage pragmaDfourmoluGHC options pragmaEfourmoluHaddock options pragmaFfourmolu7Extract a pragma from a comment if possible, or return  otherwise.FfourmoluComment to try to parseBCDEFBCDEFNone3Ifourmolu 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.KfourmoluCreate I6 from a data structure containing "located" elements.KfourmoluData structure to inspect (AST)IJKIJK  Safe-Inferred jQfourmolu Return an 0 containing all lines which are affected by CPP.QQ None &! VfourmoluRelative positions in a list.\fourmoluAttach Ves 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 56 thing.`fourmoluSplit and normalize a doc string. The result is a list of lines that make up the comment.afourmoluIncrement line number in a .bfourmolu.Do two declarations have a blank between them?cfourmolu4Do two declaration groups have a blank between them?dfourmoluReturn 9 if one span ends on the same line the second one starts.efourmoluA 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.TUVWXYZ[\]^_`abcdefVWXYZ[\]^_`abcdeTUf None #$$ kfourmolu;Whether to use colors and other features of ANSI terminals.ofourmoluTerminal monad.pfourmoluRun o monad.qfourmolu,Make the inner computation output bold text.rfourmolu,Make the inner computation output cyan text.sfourmolu-Make the inner computation output green text.tfourmolu+Make the inner computation output red text.ufourmoluOutput .vfourmoluOutput .wfourmolu Output a 57.xfourmolu Output a 58.yfourmoluOutput a newline.pfourmolu Monad to runfourmolu Color modefourmoluHandle to print toklmnopqrstuvwxyoklmnpqrstuvwxy None #$&fourmoluResult of diffing two s.fourmoluDiff two texts and produce a .fourmoluSelect certain spans in the diff (line numbers are interpreted as belonging to the @before@ state). Only selected spans will be printed.fourmoluPrint the given  as a o4 action. This function tries to mimic the style of git diff.fourmolu Text beforefourmolu Text afterfourmolu Path to usefourmoluThe resulting diff or  if the inputs are identical None ) fourmolu=Ormolu exception representing all cases when Ormolu can fail.fourmolu&Parsing of original source code failedfourmolu'Parsing of formatted source code failedfourmolu"Original and resulting ASTs differfourmolu'Formatted source code is not idempotentfourmolu$Some GHC options were not recognizedfourmoluCabal file parsing failedfourmoluMissing input file path when using stdin input and accounting for .cabal filesfourmolu(A parse error in a fixity overrides filefourmoluInside this wrapper & will be caught and displayed nicely.fourmolu Color modefourmolu"Action that may throw an exception  None #$%'(12589>2[fourmoluThe result of calling .fourmoluSource of truth for how PrinterOpts is parsed from configuration sources.fourmolu A version of   without empty fields.fourmolu A version of   where any field can be empty. This corresponds to the information in a config file or in CLI options.fourmoluA wrapper for dynamic options.fourmoluRegion selection as the length of the literal prefix and the literal suffix.fourmolu Prefix length in number of linesfourmolu Suffix length in number of linesfourmoluRegion selection as the combination of start and end line numbers.fourmolu"Start line of the region to formatfourmolu End line of the region to formatfourmoluOrmolu configuration.fourmolu%Dynamic options to pass to GHC parserfourmoluFixity overridesfourmoluKnown dependencies, if anyfourmolu?Do formatting faster but without automatic detection of defectsfourmolu'Output information useful for debuggingfourmolu0Checks if re-formatting the result is idempotentfourmoluHow to parse the input (regular haskell module or Backpack file)fourmolu:Whether to use colors and other features of ANSI terminalsfourmoluRegion selectionfourmolu0Type of sources that can be formatted by Ormolu.fourmolu.Consider the input as a regular Haskell modulefourmolu1Consider the input as a Backpack module signaturefourmoluDefault  .fourmoluConvert  into .fourmoluConvert  to  .fourmoluFill the field values that are  in the first argument with the values of the corresponding fields of the second argument.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 deltas klmnklmn  None #$&4fourmolu 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 .fourmolu,Convert a set of line indices into disjoint  RegionDeltasfourmoluTotal number of linesNone #$5fourmoluPreprocess the specified region of the input into raw snippets and subregions to be formatted.fourmoluWhether CPP is enabledNone= fourmoluWrapper for an operator, carrying information about its name and fixity.fourmoluThe actual operatorfourmolu?Its name, if available. We use 'Maybe String' here instead of 1 because the name-fetching function received by  returns a fourmoluInformation about the fixity direction and precedence level of the operatorfourmoluIntermediate representation of operator trees, where a branching is not just a binary branching (with a left node, right node, and operator like in the GHC's AST), but rather a n-ary branching, with n + 1 nodes and n operators (n >= 1).This representation allows us to put all the operators with the same precedence level as direct siblings in this tree, to better represent the idea of a chain of operators.fourmolu+A node which is not an operator applicationfourmolu8A subtree of operator application(s); the invariant is: length exprs == length ops + 1. OpBranches [x, y, z] [op1, op2] represents the expression  x op1 y op2 z.fourmoluReturn combined s of all elements in this .fourmoluRe-associate an  taking into account precedence of operators. Users are expected to first construct an initial <, then re-associate it using this function before printing.fourmoluIndicate if an operator has # 0 fixity. We special-case this class of operators because they often have, like (), a specific @separator@ use-case, and we sometimes format them differently than other operators.fourmoluHow to get name of an operatorfourmoluFixity overridesfourmolu Fixity Mapfourmolu Original fourmoluRe-associated ., with added context and info around operators  None3@fourmolu$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$Module to use for comment extractionfourmolu)Stack header, pragmas, and comment stream  None U0fourmoluHaddock 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 the source type.fourmoluRetrieve fixity overrides map.fourmoluRetrieve the lazy fixity map.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.fourmolu$When using trailing commas, same as ?; when using leading commas, runs the input action unmodified.fourmoluSet  for internal computation.fourmolu-Do one or another thing depending on current .fourmolu Get current .fourmoluGet a particular   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.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 streamfourmolu5Whether the source is a signature or a regular modulefourmoluEnabled extensionsfourmoluFixity overridesfourmolu Fixity mapfourmoluResulting renditionfourmolu to outputfourmolu to outputfourmolu Single linefourmolu Multi linefourmoluComment positionfourmolu to outputfourmoluReference spanfourmoluPredicate to usefourmoluSpan mark to set22None YPfourmolu?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 '(?gzfourmoluExpression placement. This marks the places where expressions that implement handing forms may use them.fourmoluMulti-line layout should cause insertion of a newline and indentation bumpfourmoluExpressions that have hanging form should use it and avoid bumping one level of indentationfourmolu- 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.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 }.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 .fourmoluDelimiting combination with + for import-export lists. To be used with .fourmoluPrint = . Do not use  "=".fourmoluPlace a thing that may have a hanging form. This function handles how to separate it from preceding expressions and whether to bump indentation depending on what sort of expression we have.fourmoluWhether to indentfourmoluThe expression to indentfourmoluThing 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 bodyNone hfourmoluPrint a collection of B!s with their associated comments.None %kfourmoluData and type family style.fourmoluDeclarations in type classesfourmoluTop-level declarationsfourmoluOutputs the name of the module-like entity, preceeded by the correct prefix ("module" or "signature").fourmolu Render a  .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  #$lfourmoluReturn  if at least one argument in " has a doc string attached to it.fourmoluRender several forall-ed variables.None m/None #$mUNone mNone #$mNone #$nMfourmoluType constructorfourmoluFixityfourmoluType variablesfourmoluRHS of type declarationNone #$ns None n!None %n"None #$'(+ofourmolu Whether to format as data familyfourmoluType constructorfourmolu Type patternsfourmoluLexical fixityfourmoluData definitionNone  #$%&pfourmolu+Determine placement of a top level command.fourmolu-Check if given expression has a hanging form.fourmoluPrint a top-level command.fourmoluPrint the source text of a string literal while indenting gaps correctly.  $Noneq%None #$q5None+umfourmoluConvert an operator name to a .fourmolu+Extract the operator name of the specified 0 if this expression corresponds to an operator.fourmolu.Print an operator tree where leaves are types.fourmolu5Convert a LHsType containing an operator tree to the  intermediate representation.fourmolu1Print an operator tree where leaves are commands.fourmolu Convert a $ containing an operator tree to the  intermediate representation.fourmolu/Print an operator tree where leaves are values.fourmolu Convert a $ containing an operator tree to the  intermediate representation.fourmoluN-ary  to render, enhanced with information regarding operator fixityfourmoluBracket style to usefourmoluN-ary OpTree to render, enhanced with information regarding operator fixityfourmoluBracket style to usefourmoluN-ary  to render, enhanced with information regarding operator fixity&None u'None #$u(None #$v#None #$&wSfourmoluLike  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.fourmoluParsed module or signaturefourmolu'Either regular module or signature filefourmolu Stack headerfourmolu#Pragmas and the associated commentsfourmoluComment streamfourmoluEnabled extensionsfourmoluFixity overridesfourmoluFixity map for operatorsfourmolu?Indentation level, can be non-zero in case of region formattingfourmolu Either a , or a raw snippet.*None #$&{9fourmolu$Parse a complete module from string.fourmoluExtensions that are not enabled automatically and should be activated by user.fourmoluOrmolu configurationfourmolu'Fixity map to include in the resulting sfourmolu0File name (only for source location annotations)fourmoluInput for parser+None #$|Ufourmolu"Sort, group and normalize imports.Assumes input list is sorted by source location. Output list is not necessarily sorted by source location, so this function should be called at most once on a given input list.,None #$}FfourmoluRender a module-like entity (either a regular module or a backpack signature).fourmolu Stack headerfourmolu#Pragmas and the associated commentsfourmolu AST to print-None #$}fourmoluRender several source snippets.fourmoluResult of parsingfourmoluResulting rendition   .None#$&~fourmoluResult of comparing two s.fourmoluTwo parse results are the samefourmoluTwo parse results differfourmoluReturn Diff of two s.None#$& fourmolu(Cabal information of interest to Ormolu.fourmolu Package namefourmolu/Extension and language settings in the form of sfourmoluDirect dependenciesfourmolu0Absolute path to the cabal file, if it was foundfourmoluCabal info that is used by default when no .cabal file can be found.fourmoluLocate .cabal file corresponding to the given Haskell source file and obtain  from it.fourmoluFind the path to an appropriate .cabal file for a Haskell source file, if available.fourmoluParse ! from a .cabal file at the given .fourmoluHaskell source filefourmoluExtracted cabal infofourmolu=Path to a Haskell source file in a project with a .cabal filefourmolu-Absolute path to the .cabal file if availablefourmoluLocation of the .cabal filefourmolu-Location of the source file we are formattingfourmoluExtracted cabal info/ Safe-InferredPfourmoluWrite 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.fourmoluRead stdin as UTF8-encoded  value.0None#$fourmoluAttempt to locate and parse a .ormolu file. If it does not exist, empty fixity map is returned. This function maintains a cache of fixity overrides where cabal file paths act as keys.fourmoluA wrapper around @, for parsing individual fixity definitions.fourmolu& already obtained for this source filefourmoluInput to parsefourmolu Parse result1Nonefourmolu 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 .NOTE: The caller is responsible for setting the appropriate value in the = field. Autodetection of source type won't happen here, see .fourmoluLoad a file and format it. The file stays intact and the rendered version is returned as .NOTE: The caller is responsible for setting the appropriate value in the = field. Autodetection of source type won't happen here, see .fourmolu$Read input from stdin and format it.NOTE: The caller is responsible for setting the appropriate value in the = field. Autodetection of source type won't happen here, see .fourmoluDetect  based on the file extension.fourmoluOrmolu configurationfourmoluLocation of source filefourmoluInput to formatfourmoluOrmolu configurationfourmoluLocation of source filefourmoluResulting renditionfourmoluOrmolu configurationfourmoluResulting rendition> klmn>klmn 9:;9:<9:=9:>9?@9?A4B4C4D4E4F4G4H4H4I4J4K4L4M4N4O4P4QRRSSTUUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                    !"##$%&''''(##))))))))))))))****+++++,-.......///00111123333333876'fourmolu-0.7.0.0-5XfjyxWOfXPGxk6UjLW41xOrmolu.Utils.Cabal Ormolu.ConfigOrmolu.Fixity.Internal Ormolu.FixityOrmolu.Fixity.ParserOrmolu.Fixity.PrinterOrmolu.Parser.PragmaOrmolu.Printer.SpanStreamOrmolu.Processing.Cpp Ormolu.UtilsOrmolu.TerminalOrmolu.Diff.TextOrmolu.ExceptionOrmolu.Processing.CommonOrmolu.Processing.PreprocessOrmolu.Printer.OperatorsOrmolu.Parser.CommentStreamOrmolu.Printer.InternalOrmolu.Printer.CommentsOrmolu.Printer.CombinatorsOrmolu.Printer.Meat.Pragma%Ormolu.Printer.Meat.Declaration.Value&Ormolu.Printer.Meat.Declaration.OpTreeOrmolu.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.Utils.FixityOrmolu GHC.DynFlagsOrmolu.Config.THOrmolu.Config.TypesGHC OutputableSrcSpan RealSrcSpan$Cabal-3.6.3.0-I4Ii3Qpj1svLmdsaKaNlunLanguage.Haskell.ExtensionUnknownExtensionDisableExtensionEnableExtension ExtensionDistribution.Types.PackageName unPackageName PackageNameHaddockPrintStyleHaddockSingleLineHaddockMultiLine CommaStyleLeadingTrailing PrinterOpts poIndentation poCommaStylepoImportExportCommaStylepoIndentWherespoRecordBraceSpacepoDiffFriendlyImportExport poRespectfulpoHaddockStylepoNewlinesBetweenDecls HackageInfo LazyFixityMap FixityMap FixityInfo fiDirectionfiMinPrecedencefiMaxPrecedenceFixityDirectionInfixLInfixRInfixNdefaultFixityInfocolonFixityInfo lookupFixity$fToJSONFixityDirection$fFromJSONFixityDirection$fSemigroupFixityInfo$fToJSONFixityInfo$fFromJSONFixityInfo$fToJSONHackageInfo$fFromJSONHackageInfo$fLiftLiftedRepHackageInfo$fShowLazyFixityMap$fEqFixityInfo$fOrdFixityInfo$fShowFixityInfo$fLiftLiftedRepFixityInfo$fEqFixityDirection$fOrdFixityDirection$fShowFixityDirection$fLiftLiftedRepFixityDirection packageToOpspackageToPopularity bootPackagesdefaultStrategyThresholdbuildFixityMapbuildFixityMap'parseFixityMapparseFixityDeclarationprintFixityMapPragmaPragmaLanguagePragmaOptionsGHCPragmaOptionsHaddock parsePragma $fShowPragma $fEqPragma SpanStream mkSpanStream$fEqSpanStream$fShowSpanStream$fDataSpanStream$fSemigroupSpanStream$fMonoidSpanStreamcppLines $fEqState $fShowState HasSrcSpanloc' RelativePos SinglePosFirstPos MiddlePosLastPosFirstAfterDocPosattachRelativePoscombineSrcSpans'notImplementedshowOutputablesplitDocString incSpanLineseparatedByBlankseparatedByBlankNE onTheSameLinegroupBy'getLoc'$fHasSrcSpanSrcSpanAnn'$fHasSrcSpanSrcSpan$fEqRelativePos$fShowRelativePos ColorModeNeverAlwaysAutoTermrunTermboldcyangreenredputputS putSrcSpanputRealSrcSpannewline $fEqColorMode$fShowColorMode$fEnumColorMode$fBoundedColorMode $fFunctorTerm$fApplicativeTerm $fMonadTermTextDiffdiffText selectSpans printTextDiff$fShowTextDiff $fEqTextDiffOrmoluExceptionOrmoluParsingFailedOrmoluOutputParsingFailedOrmoluASTDiffersOrmoluNonIdempotentOutputOrmoluUnrecognizedOptsOrmoluCabalFileParsingFailedOrmoluMissingStdinInputFileOrmoluFixityOverridesParseErrorwithPrettyOrmoluExceptions$fExceptionOrmoluException$fEqOrmoluException$fShowOrmoluExceptionConfigFileLoadResult ConfigLoadedConfigParseErrorConfigNotFoundFourmoluConfigcfgFilePrinterOptscfgFileFixitiesPrinterOptsFieldType parseJSON parseTextshowTextPrinterOptsFieldMetametaName metaGetFieldmetaPlaceholdermetaHelp metaDefaultPrinterOptsTotalPrinterOptsPartial DynOption unDynOption RegionDeltasregionPrefixLengthregionSuffixLength RegionIndicesregionStartLine regionEndLineConfig cfgDynOptionscfgFixityOverridescfgDependencies cfgUnsafecfgDebugcfgCheckIdempotence cfgSourceType cfgColorMode cfgRegioncfgPrinterOpts SourceType ModuleSourceSignatureSource defaultConfigregionIndicesToDeltasdynOptionToLocatedStr overFields overFieldsMdefaultPrinterOptsfillMissingPrinterOptsprinterOptsMetaloadConfigFileconfigFileName$fMonoidPrinterOpts$fSemigroupPrinterOpts'$fPrinterOptsFieldTypeHaddockPrintStyle $fPrinterOptsFieldTypeCommaStyle$fPrinterOptsFieldTypeBool$fPrinterOptsFieldTypeInt$fFromJSONPrinterOpts$fFromJSONFourmoluConfig$fShowConfigFileLoadResult$fEqFourmoluConfig$fShowFourmoluConfig $fEqConfig $fShowConfig$fFunctorConfig$fGenericConfig $fEqDynOption$fOrdDynOption$fShowDynOption$fEqRegionDeltas$fShowRegionDeltas$fEqRegionIndices$fShowRegionIndices$fEqSourceType$fShowSourceType$fShowPrinterOpts$fEqPrinterOpts$fShowPrinterOpts0$fEqPrinterOpts0removeIndentationreindent linesInRegionintSetToRegions preprocess$fEqOrmoluState$fShowOrmoluStateOpInfoopiOpopiNameopiFixOpTreeOpNode OpBranches opTreeLocreassociateOpTreeisHardSplitterOp $fEqOpInfo $fEqOpTree $fShowOpTreeComment CommentStreammkCommentStreamshowCommentStream unCommenthasAtomsBeforeisMultilineComment$fEqCommentStream$fDataCommentStream$fSemigroupCommentStream$fMonoidCommentStream $fEqComment $fShowComment $fDataComment HaddockStylePipeCaretAsteriskNamedSpanMark HaddockSpan CommentSpan StatementSpanCommentPosition OnTheSameLine OnNextLineLayout SingleLine MultiLineRrunRtxtinterferingTxtatomspace declNewline askSourceTypeaskFixityOverrides askFixityMapinciBy inciByFracinciinciHalfsitccsitccIfTrailing enterLayoutvlayout getLayout getPrinterOptregisterPendingCommentLinetrimSpanStream nextEltSpan popCommentgetEnclosingSpanwithEnclosingSpan thisLineSpans spanMarkSpan setSpanMark getSpanMark useBraces dontUseBraces canUseBracesisExtensionEnabled $fFunctorR$fApplicativeR$fMonadR$fShowSpitType $fEqSpitType$fEqCommentPosition$fShowCommentPosition $fEqLayout $fShowLayout$fEqRequestedDelimiter$fShowRequestedDelimiterspitPrecedingCommentsspitFollowingCommentsspitRemainingCommentsspitCommentNowspitCommentPending PlacementNormalHanging BracketStyleNSinciIflocatedlocated' switchLayout breakpoint breakpoint'sepsepSemi backticksbananabracesbracketsparens parensHash pragmaBracespragmacommacommaDelcommaDelImportExportequals placeHanging $fEqPlacement$fShowPlacement$fEqBracketStyle$fShowBracketStyle p_pragmas $fEqPragmaTy $fOrdPragmaTy$fEqLanguagePragmaClass$fOrdLanguagePragmaClasscmdTopPlacement exprPlacement p_hsCmdTop p_hsExpr' p_stringLit p_hsSplicep_hsExprp_pat p_valDecl getOpNameStr getOpName p_tyOpTreetyOpTree p_cmdOpTree cmdOpTree p_exprOpTree exprOpTree FamilyStyle AssociatedFree p_hsmodNamep_ieWrappedName p_rdrName p_qualNamep_infixDefHelper p_hsDocString p_sourceTextForAllVisibility ForAllInvis ForAllVisp_hsTypep_hsTypePostDoc hasDocStrings p_hsContext p_hsTyVarBndr p_forallBndrsp_conDeclFields p_lhsTypeArg p_hsSigTypetyVarsToTyPatshsOuterTyVarBndrsToHsTypelhsTypeToSigType $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 p_spliceDecl p_ruleDecls p_annDeclp_standaloneDerivDecl p_clsInstDeclp_tyFamInstDeclp_dataFamInstDecl p_classDecl$fEqUserGrouping$fShowUserGrouping ParseResultprParsedSource prSourceType prStackHeader prPragmasprCommentStream prExtensionsprFixityOverrides prFixityMapprIndent SourceSnippet RawSnippet ParsedSnippet parseModule manualExts$fOrdSeverityOrd$fEqSeverityOrdnormalizeImports$fOrdIEWrappedNameOrd$fEqIEWrappedNameOrd $fEqImportId $fOrdImportId p_hsModule printSnippetsParseResultDiffSame DifferentdiffParseResult$fMonoidParseResultDiff$fSemigroupParseResultDiff$fShowParseResultDiff CabalInfo ciPackageName ciDynOptsciDependenciesciCabalFilePathdefaultCabalInfogetCabalInfoForSourceFile findCabalFileparseCabalInfo $fEqCabalInfo$fShowCabalInfo writeFileUtf8 readFileUtf8getContentsUtf8getFixityOverridesForSourceFileparseFixityDeclarationStrormolu ormoluFile ormoluStdindetectSourceType baseDynFlagsmkBijectiveMap BijectiveMap parseTextWith showTextWith allNothingunpackFieldsWithSuffix showAllValuesbase GHC.MaybeNothing4ghc-lib-parser-9.2.3.20220527-IGGNPhWczlt7FtIiDaU4xQGHC.Types.SrcLoccontainers-0.6.2.1Data.IntSet.InternalIntSetghc-prim GHC.TypesTrue text-1.2.3.2Data.Text.InternalTextGHC.BaseStringLocateddirectory-1.3.6.0 System.Directory.Internal.Common XdgConfigMaybe$BoolNonEmpty RealLocatedGHC.HsHsModuleGHC.Utils.Outputable GenLocatedGHC.Parser.AnnotationLocatedNGHC.Types.Name.ReaderRdrNameLanguage.Haskell.Syntax.TypeHsTypeLanguage.Haskell.Syntax.ExprHsExpr LHsCmdTopLHsExprGHC.IOFilePathIO