h*       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                        !!!!!!!!!!!!!!!!!!""""#$$%&'((  )*+,,,,-((./////////////0111111122333334444444450.16.2.066 Safe-Inferred 7 Safe-Inferred"+fourmolu&Options controlling formatting output.-fourmolu%Number of spaces per indentation step.fourmolu+Max line length for automatic line breaking/fourmolu$Styling of arrows in type signatures0fourmolu6How to place commas in multi-line lists, records, etc.1fourmoluStyling of import/export lists2fourmolu&Whether to full-indent or half-indent 'where'! bindings past the preceding body3fourmolu7Whether to leave a space before an opening record brace4fourmolu/Number of spaces between top-level declarations5fourmoluHow to print Haddock comments6fourmoluHow to print module docstring7fourmoluStyling of let blocks8fourmoluHow to align the 'in' keyword with respect to the 'let' keyword9fourmolu5Whether to put parentheses around a single constraint:fourmolu9Whether to put parentheses around a single deriving class;fourmoluOutput Unicode syntax<fourmolu>Give the programmer more choice on where to insert blank lines>fourmoluFill the field values that are  in the first argument with the values of the corresponding fields of the second argument.+,-./0123456789:;<'()#$%&! "   =@>?* Safe-InferredAfourmolu 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.CfourmoluCreate A6 from a data structure containing "located" elements.CfourmoluData structure to inspect (AST)ABCABC Safe-Inferred"EfourmoluState of the CPP processor.fourmoluOutside of CPP directivesfourmolu:In a conditional expression, with a positive nesting countfourmoluIn a continuation (after \&), but not in a conditional expressionIfourmolu Return an 0 containing all lines which are affected by CPP.Jfourmolu3Replace all lines affected by CPP with blank lines.IJIJ Safe-Inferred"MfourmoluRelative positions in a list.RfourmoluAttach Mes to elements of a given list.Sfourmolu-Combine all source spans from the given list.Tfourmolu4Placeholder for things that are not yet implemented.UfourmoluPretty-print an 89 thing.VfourmoluSplit and normalize a doc string. The result is a list of lines that make up the comment.WfourmoluIncrement line number in a .Xfourmolu.Do two declarations have a blank between them?Yfourmolu4Do two declaration groups have a blank between them?ZfourmoluReturn 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.\fourmoluCheck whether the given " or its Unicode variant is in an , and return the  if so.]fourmoluConvert  to a  by making a copy.^fourmoluConvert GHC's  into the one used by Cabal.MNOPQRSTUVWXYZ[\]^MNOPQRSTUVWXYZ[\]^ Safe-Inferred" afourmolu;Whether to use colors and other features of ANSI terminals.ffourmoluRun e monad.hfourmoluMake the output bold text.ifourmoluMake the output cyan text.jfourmoluMake the output green text.kfourmoluMake the output red text.lfourmoluOutput .mfourmolu Output a  value.nfourmolu Output an  value.ofourmoluOutput a newline.ffourmolu Color modefourmoluHandle to print toeadbcfghijklmnoeadbcfghijklmno Safe-Inferredxx Safe-Inferred"%&fourmolu Diff hunk.fourmolu Similar to !, but with line numbers assigned.fourmoluList of lines tagged by , , or .yfourmoluResult of diffing two s.fourmolu%Path to the file that is being diffedfourmoluThe list of differencesfourmoluSelected lines. Only hunks that contain selected lines will be displayed, unless ; is empty, in which case the whole diff will be displayed.zfourmoluDiff two texts and produce a y.{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 y as a e4 action. This function tries to mimic the style of git diff.fourmoluAssign lines to a .fourmoluForm  s from a .fourmoluForm a .fourmolu4Trim empty @both@ lines from beginning and end of a .zfourmolu Text beforefourmolu Text afterfourmolu Path to usefourmoluThe resulting diff or  if the inputs are identicalyz{|yz{|  Safe-Inferred"" 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 filefourmolu Print an .fourmoluInside this wrapper & will be caught and displayed nicely.fourmolu Color modefourmolu"Action that may throw an exception    Safe-Inferred"% fourmolu#Ormolu's representation of pragmas.fourmoluLanguage pragmafourmoluGHC options pragmafourmoluHaddock options pragmafourmolu7Extract a pragma from a comment if possible, or return  otherwise.fourmoluAssuming the input consists of a series of tokens from a language pragma, return the set of enabled extensions.fourmolu)Tokenize a given input using GHC's lexer.fourmoluHaskell lexer.fourmoluComment to try to parse  Safe-Inferred"(+ 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 .fourmoluNormalize comment string. Sometimes one multi-line comment is turned into several lines for subsequent outputting with correct indentation for each line.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?fourmolu1Detect and extract stack header if it is present.fourmolu.Extract pragmas and their associated comments.fourmoluExtract   from .fourmoluRemove consecutive blank lines.fourmolu6Escape characters that can turn a line into a Haddock.fourmoluOriginal inputfourmolu$Module to use for comment extractionfourmolu)Stack header, pragmas, and comment streamfourmolu*Lines of original input with their indicesfourmoluRaw comment stringfourmolu6Remaining lines of original input and the constructed fourmoluComment stream to analyzefourmoluInputfourmoluComment stream to analyze    Safe-Inferred %&(0 fourmoluA wrapper for   that allows us to define an  instance for it.fourmolu does not have an  instance.fourmolu.The import is not qualified by a package name.fourmolu4The import is qualified by an external package name.fourmoluThe import is qualified by the current package being built, using the special this package name.fourmoluImport id, a collection of all things that justify having a separate import entry. This is used for merging of imports. If two imports have the same  they can be merged.fourmolu"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.fourmolu;Combine two import declarations. It should be assumed that  s are equal.fourmolu Obtain an  for a given import.fourmolu'Normalize a collection of import items.fourmoluProject   from  .fourmoluLike  for located wrapped names.fourmolu Compare two IEWrapppedName  things.  Safe-Inferred"%&(1>;fourmolu)Fixity qualification that determines how  matches a particular use of an operator, given whether it is qualified or unqualified and the module name used.fourmoluProvenance of fixity info.fourmolu7 of a built-in operator or provided by a user override.fourmolu$ to be inferred from module imports.fourmoluFixity map that takes into account imports in a particular module.fourmoluFixity information that is specific to a package being formatted. It requires module-specific imports in order to be usable.fourmoluModule re-exportsfourmolu"Map from the operator name to its .fourmoluThe map of operators declared by each package grouped by module name.fourmoluApproximation of fixity information 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 information about an infix operator. This type provides precise information as opposed to .fourmoluFixity directionfourmolu PrecedencefourmoluFixity direction.fourmoluAn operator name.fourmoluInvariant: UTF-8 encodedfourmolu Convert an  to .fourmoluConvert an 'OccName to an .fourmolu3Fixity info of the built-in colon data constructor.fourmoluFixity that is implicitly assumed if no fixity declaration is present.fourmolu>The lowest level of information we can have about an operator.fourmolu Convert from  to .fourmolu#Fixity overrides to use by default.fourmolu&Module re-exports to apply by default.fourmoluGet a  of an operator.fourmolu1Render a human-readable account of why a certain  was chosen for an operator.fourmoluGives the ability to merge two (maybe conflicting) definitions for an operator, keeping the higher level of compatible information from both.fourmolu6Whether to print debug info regarding fixity inferencefourmolu Operator namefourmoluModule fixity mapfourmolu"The resulting fixity approximationfourmolu Operator namefourmolu"Qualification of the operator namefourmoluModule fixity mapfourmoluThe chosen fixity approximation)) Safe-Inferred%&<fourmolu Simplified info about an import.fourmoluExtract s from the AST.fourmoluExtract an individual .fourmoluApply given module re-exports. Safe-Inferred"%&Afourmolu The built-in  used by Ormolu.fourmoluDefault set of packages to assume as dependencies e.g. when no Cabal file is found or taken into consideration.fourmoluCompute the fixity map that is specific to the package we are formatting.fourmolu The same as , except this specific version of the function allows the user to specify % used to build the final fixity map.fourmoluCompute the fixity map that is specific to the module we are formatting.fourmoluApply fixity overrides.fourmoluSet of packages to selectfourmoluPackage fixity mapfourmolu Hackage infofourmoluSet of packages to selectfourmoluPackage fixity mapfourmolu=Fixity information selected from dependencies of this packagefourmolu=A simplified representation of the import list in this modulefourmolu"Fixity map specific to this modulefourmoluUser overridesfourmoluModule fixity mapfourmolu(Module fixity map with overrides applied(( Safe-Inferred1SfourmoluWrapper for an operator, carrying information about its name and fixity.fourmoluThe actual operatorfourmoluIts name, if available. We use 'Maybe RdrName' 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.fourmolu/Compare the precedence level of two operators.  is required (and not just ;) because operator names are used in the case of equality.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.fourmolu%Wrap every operator of the tree with  to carry the information about its fixity (extracted from the specified fixity map).fourmoluGiven a  of any shape, produce a flat , where every node and operator is directly connected to the root.fourmoluStarting from a flat  (i.e. a n-ary tree of depth 1, without regard for operator fixities), build an  with proper sub-trees (according to the fixity info carried by the nodes).=We have two complementary ways to build the proper sub-trees:if we can find a set of operators "minOps" at the current level where forall (op1, op2) in minOps x minOps, op1 equal op2 forall (op1, op2) in minOps x (opsOfCurrentLevel minOps), op1 lessThan op2 then we can build a subtree with the exprs and ops located "between" each element of minOps. For example, if minOps = {op0, op2, op5}, and if [...] means "extract a subtree", then currentLevel = [ex0 op0 ex1 op1 ex2 op2 ex3 op3 ex4 op4 ex5 op5 ex6 op6 ex7] will become [ex0 op0 [ex1 op1 ex2] op2 [ex3 op3 ex4 op4 ex5] op5 [ex6 op6 ex7]]if we can find a set of operators "maxOps" at the current level where forall (op1, op2) in maxOps x maxOps, op1 equal op2 forall (op1, op2) in maxOps x (opsOfCurrentLevel maxOps), op1  greaterThan op2 then we can build a subtree with every contiguous range of elements from maxOps (and the exprs on their sides) For example, if maxOps = {op0, op1, op4}, and if [...] means "extract a subtree", then currentLevel = [ex0 op0 ex1 op1 ex2 op2 ex3 op3 ex4 op4 ex5 op5 ex6 op6 ex7] will become [[ex0 op0 ex1 op1 ex2] op2 ex3 op3 [ex4 op4 ex5] op5 ex6 op6 ex7]We will also recursively apply the same logic on every sub-tree built during the process. The two principles are not overlapping and thus are required, because we are comparing precedence level ranges. In the case where we can't find a non-empty set {min,max}Ops with one logic or the other, we finally try to split the tree on @hard splitters@ if there is any.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.fourmolu6Whether to print debug info regarding fixity inferencefourmoluHow to get name of an operatorfourmolu Fixity Mapfourmolu Original fourmoluRe-associated ., with added context and info around operatorsfourmolu6Whether to print debug info regarding fixity inferencefourmoluFixity map for operatorsfourmolu"How to get the name of an operatorfourmolufourmolu/, with fixity info wrapped around each operatorfourmoluFlat /, with fixity info wrapped around each operatorfourmoluRe-associated /, with fixity info wrapped around each operator   Safe-Inferred"%&T_fourmolu)Print out a textual representation of an .ormolu file. Safe-Inferred"%&Vfourmolu Parse textual representation of .fourmolu1Parse a single self-contained fixity declaration.fourmolu;Parse a single self-contained module re-export declaration.fourmolu*Parse a single fixity declaration, such as infixr 4 +++, >>>fourmoluSee https://www.haskell.org/onlinereport/haskell2010/haskellch2.htmlfourmolu;Location of the file we are parsing (only for parse errors)fourmoluFile contents to parsefourmolu Parse resultfourmolu Text to parsefourmolu Parse resultfourmolu Text to parsefourmolu Parse result   Safe-Inferred(XfourmoluFind the path to the closest file higher in the file hierarchy that satisfies a given predicate.fourmolu Execute an 7 action but only if the given key is not found in the  cache.fourmolu5The predicate that determines what we are looking forfourmolu)Path to the starting point for the searchfourmolu,Absolute path to the found file if available Safe-Inferred\fourmoluAttempt to locate and parse an .ormolu file. If it does not exist, default fixity map and module reexports are returned. This function maintains a cache of fixity overrides and module re-exports where cabal file paths act as keys.fourmolu Find the path to an appropriate .ormolu/ file for a Haskell source file, if available.fourmoluCache ref that maps names of .ormolu files to their contents.fourmoluA wrapper around , for parsing individual fixity definitions.fourmoluA wrapper around + for parsing a individual module reexport.fourmolu CabalInfo& already obtained for this source filefourmoluPath to a Haskell source filefourmoluAbsolute path to the closest .ormolu file, if availablefourmoluInput to parsefourmolu Parse resultfourmoluInput to parsefourmolu Parse result Safe-Inferred "%&)4=efourmolu 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 overridesfourmoluModule reexports to take into account when doing fixity resolutionfourmoluKnown 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  .fourmoluReturn all dependencies of the module. This includes both the declared dependencies of the component we are working with and all potential module re-export targets.fourmoluConvert  into .fourmoluConvert  to  .fourmoluApply the given configuration in order (later options override earlier).fourmolu#Find a fourmolu configuration file.Looks for a file named  fourmolu.yaml, first in the given path and its parents, and then in the XDG config directory.fourmolu#Expected file name for YAML config.fourmolu"Total number of lines in the inputfourmoluRegion indicesfourmolu Region deltasadbc+,-./0123456789:;<=@>'()#$%&! "   ?*adbc+,-./0123456789:;<=@>'()#$%&! "   ?* Safe-Inferred"%&(h\fourmolu 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 lines Safe-Inferred"%&mJ fourmolu Ormolu state.fourmoluEnabledfourmoluDisabledfourmoluPreprocess the specified region of the input into raw snippets and subregions to be formatted.fourmoluAll lines we are not supposed to format, and a set of replacements for specific lines.fourmoluAll lines which are disabled by Ormolu's magic comments, as well as normalizing replacements.fourmolu$All lines which satisfy a predicate.fourmoluLines which contain a shebang.fourmolu"Lines which contain a LINE pragma.fourmoluIf the given string is an enabling marker (Ormolu or Fourmolu style), then return < the enabling marker + rest of the string. Otherwise return .fourmoluIf the given string is a disabling marker (Ormolu or Fourmolu style), then return = the disabling marker + rest of the string. Otherwise return .fourmoluConstruct a function for whitespace-insensitive matching of string.fourmoluWhether CPP is enabledfourmoluWhether CPP is enabledfourmoluWhat to expectfourmoluString to testfourmolu9If the two strings match, we return the rest of the line. Safe-Inferred"1fourmoluHaddock 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 spanfourmoluType of the thing to output. Influences the primary low-level rendering function .fourmolu.Simple opaque text that breaks comment series.fourmoluLike , but assume that when this text is inserted it will separate an / and its pending comments, so insert an extra  in that case to force the pending comments and continue on a fresh line.fourmoluAn atom that typically have span information in the AST and can have comments attached to it.fourmolu!Used for rendering comment lines.fourmolu(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 linesfourmolu;Make sure next output is delimited by one of the following.fourmoluA spacefourmolu A newlinefourmoluNothingfourmoluWe just output a newlinefourmoluWe haven't printed anything yetfourmoluState context of .fourmolu"Index of the next column to renderfourmolu4Indentation level that was used for the current linefourmoluRendered source code so farfourmolu Span streamfourmoluSpans of atoms that have been printed on the current line so farfourmoluComment streamfourmoluPending comment lines (in reverse order) to be inserted before next newline,  is the indentation levelfourmolu0Whether to output a space before the next outputfourmoluIs the preceding comment and AST element are on the same line?fourmolu>Is the following comment and AST element are on the same line?fourmolu/Determine if given comment follows AST element.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 tofourmolu)Span of the element to attach comments tofourmolu#The comment that was output, if anyfourmolu!AST element to attach comments tofourmolu#The comment that was output, if anyfourmolu#The comment that was output, if anyfourmolu*Output and return the next comment, if anyfourmoluThe comments outputtedfourmoluComment predicatefourmoluPrinting functionfourmolu Are we done?fourmoluCurrent comment spanfourmoluLast printed comment spanfourmoluCurrent comment spanfourmoluAST element locationfourmoluCurrent comment spanfourmoluAST element locationfourmoluLocation of AST elementfourmoluLocation of next AST elementfourmolu!Location of enclosing AST elementfourmolu&Location of last comment in the seriesfourmoluComment to test Safe-Inferred")/fourmoluExpression 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 Similar to , but when the "payload" is an empty list, print virtual elements at the start and end of the source span to prevent comments from "floating out".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.fourmoluSame as %, except disregards the column limit.It should be used for the argument list in function definitions because the column limit can't be enforced there without changing the AST.fourmolu&Which layout combined spans result in?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 .fourmolu$A helper for defining wrappers like  and .fourmoluPrint ,.fourmoluDelimiting combination with . To be used with .fourmoluDelimiting combination with + for import-export lists. To be used with .fourmoluPrint = . Do not use  "=".fourmoluPrint R or -<< as appropriate.fourmoluPrint R or >>- as appropriate.fourmoluPrint C or => as appropriate.fourmoluPrint D or :: as appropriate.fourmoluPrint C or <- as appropriate.fourmoluPrint R or -< as appropriate.fourmoluPrint C or -> as appropriate.fourmoluPrint R or >- as appropriate.fourmoluPrint L or * as appropriate.fourmoluPrint D or forall as appropriate.fourmoluPrint S or (| as appropriate.fourmoluPrint S or |) as appropriate.fourmoluPrint O or [| as appropriate.fourmoluPrint O or |] as appropriate.fourmoluPrint E or %1 -> as appropriate.fourmoluWrite the one text or the other depending on whether Unicode is enabled.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 bodyfourmolu"Insert breakpoints around bracketsfourmoluOpening bracketfourmoluClosing bracketfourmolu Bracket stylefourmoluInner expression Safe-Inferred" fourmoluLanguage pragma classification.The order in which language pragmas are put in the input sometimes matters. This is because some language extensions can enable other extensions, yet the extensions coming later in the list have the ability to change it. So here we classify all extensions by assigning one of the four groups to them. Then we only sort inside of the groups.8 instance of this data type is what affects the sorting. See also: *https://github.com/tweag/ormolu/issues/404fourmoluA pack of extensions like GHC2021 or  Haskell2010fourmoluAll other extensionsfourmoluExtensions starting with Nofourmolu/Extensions that should go after everything elsefourmoluPragma classification.fourmoluPrint a collection of !s with their associated comments.fourmolu Classify a LanguagePragma.fourmoluExtension packs, like GHC2021 and  Haskell2010. Safe-Inferred"(1fourmoluData 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.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  to renderfourmolu$'haddock-style' configuration optionfourmolu Haddock stylefourmolu$Finish the doc string with a newlinefourmoluThe  to render  ! Safe-Inferred "%&fourmoluReturn  if at least one argument in " has a doc string attached to it.fourmoluRender several forall-ed variables.' Safe-Inferred" Safe-Inferred"%&, Safe-Inferred"%&"fourmoluAnnotate each element with a Bool indicating if all preceding elements are documentation elements.fourmolu%Surround given entity by parentheses ( and ).$ Safe-Inferred"%&U% Safe-Inferred"%&fourmoluType constructorfourmoluFixityfourmoluType variablesfourmoluRHS of type declaration" Safe-Inferred"%&3fourmolu(Should the tail of the names be indentedfourmoluNames (before ::)fourmoluTypefourmolu%Whether this is a "default" signaturefourmoluNames (before ::)fourmoluTypefourmoluNamefourmoluInline pragma specificationfourmoluNamefourmoluThe types to specialize tofourmoluFor specialize inlinefourmoluBoolean formulafourmoluBoolean formulafourmoluConstructors/patternsfourmoluType Safe-Inferred"p# Safe-Inferred"fourmoluPrinter for the last part of an import/export, which is function name and type signature.fourmolu Printer for .These have the form: 6foreign import callingConvention [safety] [identifier]We need to check whether the safety has a good source, span, as it defaults to * if you don't have anything in the source.(We also layout the identifier using the  SourceText1, because printing with the other two fields of  is very complicated. See the  Outputable instance of  for details.& Safe-Inferred "%&)-1fourmolu Whether to format as data familyfourmoluType constructorfourmoluType variablesfourmolu+Get location information for type variablesfourmoluHow to print type variablesfourmoluLexical fixityfourmoluData definition  Safe-Inferred "%&(1fourmoluAn applicand is the left-hand side in a function application, i.e. f in f a. We need to track this in order to add extra identation in cases like foo = do succ 1fourmolu+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.fourmoluStyle of equations in a group.fourmoluStyle of a group of equations.fourmolu1Function id obtained through pattern matching on  should not be used to print the actual equations because the different @RdrNames@ used in the equations may have different @decorations@ (such as backticks and paretheses) associated with them. It is necessary to use per-equation names obtained from  of 2. This function replaces function name inside of  accordingly.fourmoluRender an expression preserving blank lines between such consecutive expressions found in the original source code.fourmoluPrint a list comprehension.BracketStyle should be N except in a do-block, which must be S or else it's a parse error.fourmolu5Gather the set of statements in a list comprehension.For example, this code: [ a + b + c + d | a <- as, let b = a + a | c <- cs | d <- ds, then sort by f ] is parsed as roughly: [ ParStmt [ ParStmtBlock [ BindStmt [| a <- as |] , LetStmt [| let b = a + a |] ] , ParStmtBlock [ BindStmt [| c <- cs |] ] , ParStmtBlock [ TransStmt [ BindStmt [| d <- ds |] ] [| then sort by f |] ] ] , LastStmt [| a + b + c + d |] ] The final expression is parsed out in p_body, and the rest is passed to this function. This function takes the above tree as input and normalizes it into: [ [ BindStmt [| a <- as |] , LetStmt [| let b = a + a |] ] , [ BindStmt [| c <- cs |] ] , [ BindStmt [| d <- ds |] , TransStmt [] [| then sortWith by f |] ] ] Notes: * The number of elements in the outer list is the number of pipes in the comprehension; i.e. 1 unless -XParallelListComp is enabledfourmoluReturn the wrapping function controlling the use of braces according to the current layout.fourmolu%Determine placement of a given block.fourmolu'Determine placement of a given command.fourmoluReturn * if any of the RHS expressions has guards.fourmolu7For use before record braces. Collapse to empty if not 3.fourmoluFor nested lists/tuples, pad with whitespace so that we always indent correctly, rather than sometimes indenting by 2 regardless of -. fourmoluHow to get body placementfourmoluHow to print bodyfourmolu Style of this group of equationsfourmolu Match groupfourmoluStyle of the groupfourmoluIs this an infix match?fourmoluMultiplicity annotationfourmoluStrictness prefix (FunBind)fourmoluArgument patternsfourmolu EquationsfourmoluHow to get body placementfourmoluHow to print bodyfourmolu Style of this group of equationsfourmoluIs this an infix match?fourmoluMultiplicity annotationfourmoluStrictness prefix (FunBind)fourmoluArgument patternsfourmolu Equationsfourmolu%Placement of the parent RHS constructfourmoluHow to get body placementfourmoluHow to print bodyfourmoluRendering functionfourmoluEntity to renderfourmoluPlacerfourmoluRenderfourmoluStatement to renderfourmoluPlacerfourmoluRenderfourmoluStatements to renderfourmoluPlacerfourmoluRenderfourmolu Expressionfourmolu Match groupfourmolu Variant (\ or \case or \cases)fourmoluPlacerfourmoluRenderfourmolu ExpressionfourmoluPlacerfourmoluRenderfourmolu AnnotationsfourmoluIffourmoluThenfourmoluElsefourmoluTrue if in do-blockfourmoluRenderfourmoluAnnotation for the `let` blockfourmoluTrue if in do-blockfourmoluAnnotation for the `let` blockfourmolu Let bindingsfourmolu Optional 'in' bodyfourmolu Typed splice?fourmoluSplice expressionfourmoluSplice decoration  ) Safe-InferredY* Safe-Inferred"%&ψ Safe-Inferred- fourmoluConvert 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.fourmolu>Decide if the operands of an operator chain should be hanging.fourmoluDecide whether to use braces or not based on the layout and placement of an expression in an infix operator application.fourmoluCheck if given expression has a hanging form. Added for symmetry with exprPlacement and cmdTopPlacement, which are all used in p_xxxOpTree functions with opBranchPlacement.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 fixityfourmoluPlacer function for nodesfourmolufirst expression of the chainfourmolulast expression of the chain+ Safe-Inferred"), Safe-Inferred"%&V- Safe-Inferred"%&֑( Safe-Inferred%&(ٿfourmoluLike  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)fourmolu1Always put newlines where we think they should befourmolu+Respect user preferences regarding groupingfourmolu"Is a declaration group documented?fourmolu%Group relevant declarations together.fourmolu;Determine if these declarations should be grouped together.fourmoluDetect declaration series that should not have blanks between them.fourmoluIs the source a signature file?fourmoluList of declarations. Safe-Inferred"%&fourmoluRender a module-like entity (either a regular module or a backpack signature).fourmolu Stack headerfourmolu#Pragmas and the associated commentsfourmolu AST to print/ Safe-Inferred 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 map for operatorsfourmolu?Indentation level, can be non-zero in case of region formattingfourmolu Either a , or a raw snippet.  0 Safe-Inferred%&fourmoluRender several source snippets.fourmolu6Whether to print out debug information during printingfourmoluResult of parsingfourmoluResulting rendition+,-./0123456789:;<+,-./0123456789:;<1 Safe-Inferred%&(1PfourmoluResult of comparing two s.fourmoluTwo parse results are the samefourmoluTwo parse results differfourmoluReturn Diff of two s.fourmoluCompare two modules for equality disregarding the following aspects:sordering of import lists*style (ASCII vs Unicode) of arrows, colons,LayoutInfo (brace style) in extension fieldsEmpty contexts in type classes"Parens around derived type classes (in LHsToken/ LHsUniToken)2 Safe-Inferred "%&()xfourmoluParse a complete module from .fourmolu Normalize a < by sorting its export lists, dropping blank comments, etc.fourmoluEnable all language extensions that we think should be enabled by default for ease of use.fourmoluExtensions that are not enabled automatically and should be activated by user.fourmoluRun a  computation.fourmoluDetect pragmas in the given input and return them as a collection of .fourmolu9Detect the collection of imports used in the given input.fourmoluCatch and report GHC errors.fourmoluOrmolu configurationfourmoluPackage fixity mapfourmolu0File name (only for source location annotations)fourmoluInput for parserfourmoluComputation to runfourmolu Dynamic flagsfourmolu Module pathfourmoluModule contentsfourmolu Parse resultfourmoluPre-set fourmolu Extra options (provided by user)fourmolu0File name (only for source location annotations)fourmoluInput for parserfourmoluPre-set fourmoluImplicit Prelude?fourmolu0File name (only for source location annotations)fourmoluInput for the parser Safe-Inferred%&fourmoluParsed cabal file information to be shared across multiple source files.fourmolu#Parsed generic package description.fourmoluMap from Haskell source file paths (without any extensions) to the corresponding s and dependencies.fourmolu(Cabal information of interest to Ormolu.fourmolu Package namefourmolu/Extension and language settings in the form of sfourmoluDirect dependenciesfourmoluAbsolute path to the cabal filefourmoluThe result of searching for a .cabal file.fourmoluCabal file could not be foundfourmoluCabal file was found, but it did not mention the source file in questionfourmoluCabal file was found and it mentions the source file in questionfourmolu Locate a .cabal file corresponding to the given Haskell source file and obtain  from it.fourmolu Find the path to an appropriate .cabal/ file for a Haskell source file, if available.fourmoluCache ref that stores  per Cabal file.fourmoluParse  from a .cabal file at the given .fourmoluGet a map from Haskell source file paths (without any extensions) to the corresponding s and dependencies.fourmoluHaskell source filefourmoluExtracted cabal info, if anyfourmolu2Path to a Haskell source file in a project with a .cabal filefourmoluAbsolute path to the .cabal file, if availablefourmoluLocation of the .cabal filefourmolu-Location of the source file we are formattingfourmoluIndication if the source file was mentioned in the Cabal file and the extracted fourmoluPath to the cabal filefourmolu"Parsed generic package description3 Safe-Inferred%&kfourmolu Format a . The functionNeeds  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 .fourmolu Refine a  by incorporating given ,  CabalInfo, and fixity overrides  FixityMap. You can use  to deduce  based on the file extension,  to obtain  CabalInfo and getFixityOverridesForSourceFile for  FixityMap.fourmoluA wrapper around .fourmoluDetect  based on the file extension.fourmoluOrmolu configurationfourmoluLocation of source filefourmoluInput to formatfourmoluOrmolu configurationfourmoluLocation of source filefourmoluResulting renditionfourmoluOrmolu configurationfourmoluResulting renditionfourmoluSource type to usefourmolu%Cabal info for the file, if availablefourmoluFixity overrides, if availablefourmoluModule re-exports, if availablefourmolu to refinefourmoluRefined fourmoluOrmolu configurationfourmoluFixity Map for operatorsfourmoluHow to obtain  to throw when parsing failsfourmoluFile name to use in errorsfourmoluActual input for the parseradbc+,-./0123456789:;<=adbc+,-./0123456789:;<=4 Safe-Inferred:;<:;=:;>:;?7@7A7B7C7D7E7D7F7G7H7I7J7K7L7M7N7O7P7Q7R7S7T7U7V7W7X7Y7Z7[7\7]7^7_7`7a7b7c7d7e7f7f7g7h7i7j7k7l7m7n7o7p7q7r7s7t7u7v7w7x7y7z{{|}~                                                                                                                                        !!!!!!!!!!!!!!!!!!""""#$$%&'((  )*+,,,,-((./////////////011111112233333444444446777777:9                        """""""##                         ((((((12222223(fourmolu-0.16.2.0-Aizgb3pCi0G9aWlNkjYyvtOrmolu.Utils.Cabal Ormolu.ConfigOrmolu.Printer.SpanStreamOrmolu.Processing.Cpp Ormolu.UtilsOrmolu.TerminalOrmolu.Terminal.QualifiedDoOrmolu.Diff.TextOrmolu.ExceptionOrmolu.Parser.PragmaOrmolu.Parser.CommentStreamOrmolu.ImportsOrmolu.Fixity.InternalOrmolu.Fixity.Imports Ormolu.FixityOrmolu.Printer.OperatorsOrmolu.Fixity.PrinterOrmolu.Fixity.ParserOrmolu.Utils.IOOrmolu.Utils.FixityOrmolu.Processing.CommonOrmolu.Processing.PreprocessOrmolu.Printer.InternalOrmolu.Printer.CommentsOrmolu.Printer.CombinatorsOrmolu.Printer.Meat.PragmaOrmolu.Printer.Meat.Common'Ormolu.Printer.Meat.Declaration.Warning Ormolu.Printer.Meat.ImportExport.Ormolu.Printer.Meat.Declaration.RoleAnnotation&Ormolu.Printer.Meat.Declaration.OpTree%Ormolu.Printer.Meat.Declaration.ValueOrmolu.Printer.Meat.Type)Ormolu.Printer.Meat.Declaration.Signature'Ormolu.Printer.Meat.Declaration.Foreign*Ormolu.Printer.Meat.Declaration.TypeFamily$Ormolu.Printer.Meat.Declaration.Type$Ormolu.Printer.Meat.Declaration.Data'Ormolu.Printer.Meat.Declaration.DefaultOrmolu.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.Printer.Meat.ModuleOrmolu.Parser.ResultOrmolu.PrinterOrmolu.Diff.ParseResult Ormolu.ParserOrmoluPaths_fourmolufourmolu GHC.DynFlagsOrmolu.Config.GenGHC Outputable,Cabal-syntax-3.12.0.0-Dc3sBaMPwhr30wKLLBY6AaLanguage.Haskell.Extension ExtensionEnableExtensionDisableExtensionUnknownExtensionSingleDerivingParens DerivingAutoDerivingAlways DerivingNever ColumnLimitNoLimitUnicode UnicodeDetect UnicodeAlways UnicodeNeverInStyle InLeftAlign InRightAlign InNoSpaceLetStyleLetAuto LetInline LetNewlineLetMixedImportExportStyleImportExportLeadingImportExportTrailingImportExportDiffFriendlyHaddockPrintStyleModulePrintStyleInheritPrintStyleOverrideHaddockPrintStyleHaddockSingleLineHaddockMultiLineHaddockMultiLineCompactFunctionArrowsStyleTrailingArrows LeadingArrowsLeadingArgsArrows CommaStyleLeadingTrailingparsePrinterOptType PrinterOpts poIndentation poColumnLimitpoFunctionArrows poCommaStylepoImportExportStylepoIndentWherespoRecordBraceSpacepoNewlinesBetweenDeclspoHaddockStylepoHaddockStyleModule poLetStyle poInStylepoSingleConstraintParenspoSingleDerivingParens poUnicode poRespectfuldefaultPrinterOptsfillMissingPrinterOptsparsePrinterOptsCLIdefaultPrinterOptsYaml SpanStream mkSpanStream$fEqSpanStream$fShowSpanStream$fDataSpanStream$fSemigroupSpanStream$fMonoidSpanStreamcppLines eraseCppLines $fEqState $fShowState RelativePos SinglePosFirstPos MiddlePosLastPosattachRelativePoscombineSrcSpans'notImplementedshowOutputablesplitDocString incSpanLineseparatedByBlankseparatedByBlankNE onTheSameLinegroupBy' matchAddEpAnntextToStringBufferghcModuleNameToCabal$fEqRelativePos$fShowRelativePos ColorModeNeverAlwaysAutoTermrunTerm runTermPureboldcyangreenredputputShow putOutputablenewline $fEqColorMode$fShowColorMode$fEnumColorMode$fBoundedColorMode$fSemigroupTermOutput$fMonoidTermOutput$fFunctorTermOutput$fApplicativeTermOutput>>TextDiffdiffText selectSpans printTextDiff $fShowHunk $fEqTextDiff$fShowTextDiffOrmoluExceptionOrmoluParsingFailedOrmoluOutputParsingFailedOrmoluASTDiffersOrmoluNonIdempotentOutputOrmoluUnrecognizedOptsOrmoluCabalFileParsingFailedOrmoluMissingStdinInputFileOrmoluFixityOverridesParseErrorprintOrmoluExceptionwithPrettyOrmoluExceptions$fExceptionOrmoluException$fShowOrmoluExceptionPragmaPragmaLanguagePragmaOptionsGHCPragmaOptionsHaddock parsePragma $fShowPragma $fEqPragmaCommentLComment CommentStreammkCommentStream unCommenthasAtomsBeforeisMultilineComment$fEqCommentStream$fDataCommentStream$fSemigroupCommentStream$fMonoidCommentStream $fEqComment $fShowComment $fDataCommentnormalizeImports $fOrdImportListInterpretationOrd$fOrdIEWrappedNameOrd$fEqIEWrappedNameOrd $fEqImportId $fOrdImportId$fEqImportListInterpretationOrd$fEqImportPkgQual$fOrdImportPkgQualFixityQualificationUnqualifiedAndQualified OnlyQualifiedFixityProvenanceGivenFromModuleImportsModuleFixityMapPackageFixityMapModuleReexportsunModuleReexportsFixityOverridesunFixityOverrides HackageInfoFixityApproximation faDirectionfaMinPrecedencefaMaxPrecedence FixityInfo fiDirection fiPrecedenceFixityDirectionInfixLInfixRInfixNOpNameunOpName occOpNamecolonFixityInfodefaultFixityInfodefaultFixityApproximationdefaultFixityOverridesdefaultModuleReexports inferFixity$fIsStringOpName $fShowOpName$fSemigroupFixityApproximation$fEqModuleFixityMap$fShowModuleFixityMap$fEqFixityProvenance$fShowFixityProvenance$fEqFixityQualification$fShowFixityQualification$fEqPackageFixityMap$fShowPackageFixityMap$fEqModuleReexports$fShowModuleReexports$fEqFixityOverrides$fShowFixityOverrides$fGenericHackageInfo$fBinaryHackageInfo$fNFDataHackageInfo$fEqFixityApproximation$fOrdFixityApproximation$fShowFixityApproximation$fGenericFixityApproximation$fBinaryFixityApproximation$fNFDataFixityApproximation$fEqFixityInfo$fOrdFixityInfo$fShowFixityInfo$fGenericFixityInfo$fBinaryFixityInfo$fNFDataFixityInfo$fEqFixityDirection$fOrdFixityDirection$fShowFixityDirection$fGenericFixityDirection$fBinaryFixityDirection$fNFDataFixityDirection $fEqOpName $fOrdOpName$fBinaryOpName$fNFDataOpName FixityImportfimportPackage fimportModulefimportQualified fimportListextractFixityImportsapplyModuleReexports hackageInfodefaultDependenciespackageFixityMappackageFixityMap'moduleFixityMapapplyFixityOverridesOpInfoopiOpopiNameopiFixityApproximationOpTreeOpNode OpBranchesBinaryOpBranches opTreeLocreassociateOpTreeisHardSplitterOp $fEqOpInfo $fEqOpTree $fShowOpTreeprintDotOrmoluparseDotOrmoluparseFixityDeclarationparseModuleReexportDeclarationpFixity pOperator pModuleName pPackageNameisIdentifierFirstCharisIdentifierConstituentisOperatorConstituentisPackageNameConstituentisModuleSegmentFirstCharisModuleSegmentConstituentfindClosestFileSatisfyingwithIORefCachegetDotOrmoluForSourceFileparseFixityDeclarationStr!parseModuleReexportDeclarationStrConfigNotFound searchDirsFourmoluConfigcfgFilePrinterOptscfgFileFixitiescfgFileReexportsPrinterOptsTotalPrinterOptsPartial DynOption unDynOption RegionDeltasregionPrefixLengthregionSuffixLength RegionIndicesregionStartLine regionEndLineConfig cfgDynOptionscfgFixityOverridescfgModuleReexportscfgDependencies cfgUnsafecfgDebugcfgCheckIdempotence cfgSourceType cfgColorMode cfgRegioncfgPrinterOpts SourceType ModuleSourceSignatureSource defaultConfigoverapproximatedDependenciesregionIndicesToDeltasdynOptionToLocatedStrresolvePrinterOpts emptyConfigfindConfigFileconfigFileName$fFromJSONPrinterOpts$fMonoidPrinterOpts$fSemigroupPrinterOpts$fFromJSONFourmoluConfig$fShowConfigNotFound$fEqFourmoluConfig$fShowFourmoluConfig $fEqConfig $fShowConfig$fFunctorConfig$fGenericConfig $fEqDynOption$fOrdDynOption$fShowDynOption$fEqRegionDeltas$fShowRegionDeltas$fEqRegionIndices$fShowRegionIndices$fEqSourceType$fShowSourceType$fShowPrinterOpts$fEqPrinterOpts$fShowPrinterOpts0$fEqPrinterOpts0removeIndentationreindent linesInRegionintSetToRegions preprocess$fEqOrmoluState$fShowOrmoluState HaddockStylePipeCaretAsteriskNamedSpanMark HaddockSpan CommentSpan StatementSpanCommentPosition OnTheSameLine OnNextLineLayout SingleLine MultiLineRrunRtxtinterferingTxtatomspace declNewline askSourceTypeaskModuleFixityMapaskDebuginciBy inciByFracincisitccsitccIfTrailing enterLayoutvlayout getLayout getPrinterOptregisterPendingCommentLinetrimSpanStream nextEltSpan popCommentgetEnclosingCommentsgetEnclosingSpangetEnclosingSpanWherewithEnclosingSpan thisLineSpans spanMarkSpan setSpanMark getSpanMark useBraces dontUseBraces canUseBracesisExtensionEnabled $fFunctorR$fApplicativeR$fMonadR$fShowSpitType $fEqSpitType$fEqCommentPosition$fShowCommentPosition $fEqLayout $fShowLayout$fEqRequestedDelimiter$fShowRequestedDelimiterspitPrecedingCommentsspitFollowingCommentsspitRemainingCommentsspitCommentNowspitCommentPending PlacementNormalHanging BracketStyleNSinciIflocatedencloseLocatedlocated' switchLayoutswitchLayoutNoLimit spansLayout breakpoint breakpoint'sepsepSemi backticksbananabracesbracketsparens parensHash pragmaBracespragmacommacommaDelcommaDelImportExportequalstoken'Larrowtailtoken'Rarrowtail token'darrow token'dcolon token'larrowtoken'larrowtail token'rarrowtoken'rarrowtail token'star token'foralltoken'oparenbartoken'cparenbartoken'openExpQuotetoken'closeQuote token'lolly placeHanging $fEqPlacement$fShowPlacement$fEqBracketStyle$fShowBracketStyle p_pragmas $fEqPragmaTy $fOrdPragmaTy$fEqLanguagePragmaClass$fOrdLanguagePragmaClass FamilyStyle AssociatedFree p_hsmodNamep_ieWrappedName p_rdrName p_qualNamep_infixDefHelperp_hsDocp_hsDoc' p_sourceTextp_namespaceSpec p_warnDecls p_warningTxtp_hsmodExports p_hsmodImport p_roleAnnot getOpNameStr getOpName p_tyOpTreetyOpTree p_cmdOpTree cmdOpTree p_exprOpTree exprOpTree IsApplicandcmdTopPlacement exprPlacement p_hsCmdTop p_hsExpr' p_stringLitp_hsUntypedSplicep_hsExprp_pat p_valDeclForAllVisibility ForAllInvis ForAllVisp_hsTypestartTypeAnnotationstartTypeAnnotationDecl hasDocStrings p_hsContext p_hsTyVarBndr p_forallBndrsp_conDeclFields p_lhsTypeArg p_hsSigTypehsOuterTyVarBndrsToHsTypelhsTypeToSigType$fIsTyVarBndrFlagHsBndrVis$fIsTyVarBndrFlagSpecificity$fIsTyVarBndrFlag() p_sigDeclp_typeAscription p_activationp_standaloneKindSig p_foreignDecl p_famDeclp_tyFamInstEqn p_synDecl p_dataDecl p_defaultDeclp_hsDeclsRespectGrouping p_hsDecls Applicand NotApplicand p_spliceDecl p_ruleDecls p_annDeclp_standaloneDerivDecl p_clsInstDeclp_tyFamInstDeclp_dataFamInstDecl p_classDecl$fEqUserGrouping$fShowUserGrouping p_hsModule ParseResultprParsedSource prSourceType prStackHeader prPragmasprCommentStream prExtensionsprModuleFixityMapprIndent SourceSnippet RawSnippet ParsedSnippet printSnippetsParseResultDiffSame DifferentdiffParseResult$fMonoidParseResultDiff$fSemigroupParseResultDiff$fShowParseResultDiff parseModule manualExts CabalInfo ciPackageName ciDynOptsciDependenciesciCabalFilePathCabalSearchResult CabalNotFoundCabalDidNotMention CabalFoundgetCabalInfoForSourceFile findCabalFileparseCabalInfo$fShowCachedCabalFile$fEqCabalSearchResult$fShowCabalSearchResult $fEqCabalInfo$fShowCabalInfoormolu ormoluFile ormoluStdin refineConfigdetectSourceTypeversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDir baseDynFlagsbase GHC.MaybeNothingSingleConstraintParensConstraintAlwaysConstraintAutoConstraintNeveremptyPrinterOptsparsePrinterOptsJSON5ghc-lib-parser-9.10.1.20240511-DFZDVsjyMKLA0RUjp6BXQMGHC.Types.SrcLoc RealSrcSpanStateOutside InConditionalInContinuationcontainers-0.6.7Data.IntSet.InternalIntSetSrcSpanghc-prim GHC.TypesTrueGHC.Parser.Annotation AnnKeywordIdAddEpAnn EpaLocation!text-2.1.1-8U019Orr3j1Lv0iEdMelS6Data.Text.InternalTextGHC.Data.StringBuffer StringBufferDistribution.ModuleName ModuleNameGHC.ShowShowGHC.Utils.OutputableHunk DiffList'DiffListDiff-0.5-8lvooJgusBoJwapswPgNOgData.Algorithm.DiffBothFirstSecond textDiffPathtextDiffDiffListtextDiffSelectedLines assignLinestoHunksformHunk trimEmptyparseExtensionstokenizepLexerBoolGHC.BaseNonEmpty RealLocatedLanguage.Haskell.SyntaxHsModule mkCommentextractStackHeaderextractPragmasunAnnotationComment LEpaCommentremoveConseqBlanksescapeHaddockTriggersIEWrappedNameOrdLanguage.Haskell.Syntax.ImpExp IEWrappedNameGHC.Hs.ExtensionGhcPass GHC.ClassesOrdImportListInterpretationOrdImportListInterpretationNoImportPkgQual ImportPkgQualImportPkgQualThisImportIdcombineImportsimportId normalizeLiesgetIewnIE compareLIewn compareIewnfixityInfoToApproximationrenderFixityJustificationextractFixityImportGHC.Types.Name.ReaderRdrNameMaybe compareOp addFixityInfomakeFlatOpTreereassociateFlatOpTree$IO GHC.IORefIOReffindDotOrmoluFilecacheRefLocatedString OrmoluState OrmoluEnabledOrmoluDisabledlinesNotToFormatmagicDisabledLines linesFiltered shebangLineslinePragmaLinesenablingMagicCommentJustdisablingMagicCommentisMagicCommentSpitTypespit SimpleTextInterferingTextAtom CommentPartRequestedDelimiterRequestedSpaceRequestedNewlineRequestedNothing AfterNewline VeryBeginningSCscColumnscIndent scBuilder scSpanStreamscThisLineSpansscCommentStreamscPendingCommentsIntscRequestedDelimiter scSpanMarkRCrcIndentrcLayoutrcEnclosingSpansrcCanUseBraces rcExtensions rcSourceTypercModuleFixityMaprcDebug newlineRaw newlineRawNspitPrecedingCommentspitFollowingCommentspitRemainingCommenthandleCommentSerieswithPoppedCommentneedsNewlineBeforetheSameLinePretheSameLinePostcommentFollowsElt GenLocated brackets_whenUnicodeOtherwiseLanguagePragmaClass ExtensionPack DisablingFinalPragmaTyclassifyLanguagePragmaextensionPacksLocatedN GHC.Hs.DocLHsDocLanguage.Haskell.Syntax.TypeHsTypewithAllPrevDocparens' p_typeSig p_classOpSig p_inlineSig p_specSig p_minimalSigp_booleanFormula p_completeSigp_foreignTypeSigp_foreignImportLanguage.Haskell.Syntax.Decls ForeignDeclGHC.Types.ForeignCallPlaySafeCImport GroupStyleMatchGroupStyleadjustMatchGroupStyleLanguage.Haskell.Syntax.BindsFunBindLanguage.Haskell.Syntax.Exprm_ctxtMatchFunction withSpacing p_listComp gatherStmtslayoutToBracesblockPlacement cmdPlacement withGuardsbreakpointPreRecordBracep_hsExprListItem p_matchGroup'p_matchp_match'p_grhs'p_stmt'p_stmtsp_casep_lamp_ifp_letp_let' p_hsSpliceTHHsExpr LHsCmdTopLHsExpropBranchPlacementopBranchBraceStyle tyOpPlacement DisregardRespect isDocumented groupDecls groupedDecls declSeries diffHsModule TokenLocationnormalizeModulesetDefaultExts runParserGHC.Parser.LexerPparsePragmasIntoDynFlagsGHC.Driver.DynFlagsDynFlags parseImportscatchGhcErrorsCachedCabalFilegenericPackageDescriptionextensionsAndDepsGHC.IOFilePathgetExtensionAndDepsMap parseModule'