h&8      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUV 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 { | } ~                             !"##$%&''''(##))))))))))))))****+++++,-.......///00111142 Safe-Inferred 3 Safe-Inferred afourmolu5Generate 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 a2 are accounted for. * each constructor in type a must be provided only once.4 Safe-Inferred; fourmolu&Options controlling formatting output.fourmolu'Number of spaces to use for indentationfourmolu&How to style arrows in type signaturesfourmolu0Whether to place commas at start or end of linesfourmoluStyling of import/export listsfourmoluWhether to indent `where` blocksfourmolu'Leave space before opening record bracefourmolu*Number of newlines between top-level declsfourmoluHow to print doc commentsfourmolu.Be less opinionated about spaces/newlines etc.  Safe-Inferred"%&> 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 known$fourmoluMinimum 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 !"#$%&'()*+,&'()!"#$%*+ , Safe-Inferred@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'.AfourmoluThe 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.BfourmoluBuild a fixity map using the given popularity threshold and a list of cabal dependencies. Dependencies from the list have higher priority than other packages.CfourmoluBuild 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.fourmoluMerge a list of individual fixity maps, coming from different packages. Package popularities and the given threshold are used to choose between the "keep best only" (>= threshold) and "merge all" (< threshold) strategies when conflicting definitions are encountered for an operator.BfourmoluPopularity 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 mapCfourmoluMap 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 mapfourmolu/Map from package name to 30-days download countfourmoluPopularity ratio thresholdfourmolu3List of (package name, package fixity map) to mergefourmoluResulting fixity map !"#$%&'()*,>?@ABC&'()!"#$% ,A*BC@>? Safe-Inferred"%&Dfourmolu"Parse textual representation of a  .Efourmolu1Parse a single self-contained fixity declaration.fourmoluSee https://www.haskell.org/onlinereport/haskell2010/haskellch2.htmlDfourmolu;Location of the file we are parsing (only for parse errors)fourmoluFile contents to parsefourmolu Parse resultEfourmoluExpression to parsefourmolu Parse resultDEDE Safe-Inferred"%&TFfourmolu(Print out a textual representation of a  .FF Safe-Inferred" oGfourmolu#Ormolu's representation of pragmas.HfourmoluLanguage pragmaIfourmoluGHC options pragmaJfourmoluHaddock options pragmaKfourmolu7Extract 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.KfourmoluComment to try to parseGHIJKGHIJK Safe-Inferred6!Nfourmolu 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.PfourmoluCreate N6 from a data structure containing "located" elements.PfourmoluData structure to inspect (AST)NOPNOP  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 expressionVfourmolu Return an 0 containing all lines which are affected by CPP.VV  Safe-Inferred"(& [fourmoluRelative positions in a list.afourmoluAttach [es to elements of a given list.bfourmolu-Combine all source spans from the given list.cfourmolu4Placeholder for things that are not yet implemented.dfourmoluPretty-print an 56 thing.efourmoluSplit and normalize a doc string. The result is a list of lines that make up the comment.ffourmoluIncrement line number in a .gfourmolu.Do two declarations have a blank between them?hfourmolu4Do two declaration groups have a blank between them?ifourmoluReturn 9 if one span ends on the same line the second one starts.jfourmoluA 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.YZ[\]^_`abcdefghijk[\]^_`abcdefghijYZk  Safe-Inferred"%&*>pfourmolu;Whether to use colors and other features of ANSI terminals.fourmoluReader context of t.fourmoluWhether to use colorsfourmoluHandle to print totfourmoluTerminal monad.ufourmoluRun t monad.vfourmolu,Make the inner computation output bold text.wfourmolu,Make the inner computation output cyan text.xfourmolu-Make the inner computation output green text.yfourmolu+Make the inner computation output red text.fourmoluAlter  for inner computation.zfourmoluOutput .{fourmoluOutput .|fourmolu Output a 57.}fourmolu Output a 58.~fourmoluOutput a newline.ufourmolu Monad to runfourmolu Color modefourmoluHandle to print toprqstuvwxyz{|}~tprqsuvwxyz{|}~  Safe-Inferred"%&/fourmolu Diff hunk.fourmolu Similar to !, but with line numbers assigned.fourmoluList of lines tagged by , , or .fourmoluResult 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.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 t4 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 .fourmolu Text beforefourmolu Text afterfourmolu Path to usefourmoluThe resulting diff or  if the inputs are identical  Safe-Inferred"2# 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"%&')*358;<: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 prqsprqs   Safe-Inferred"%&(=pfourmolu 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"%&B_ 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-InferredT(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.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.fourmoluHow to get name of an operatorfourmoluFixity overridesfourmolu Fixity Mapfourmolu Original fourmoluRe-associated ., with added context and info around operatorsfourmoluFixity overridesfourmoluFixity 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-Inferred6Z 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 .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"zfourmoluWhat (if anything) precedes the current type on the same line Only used for the `function-arrows` settingfourmoluHaddock 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 Are we done?fourmolu!AST element to attach comments tofourmolu Are we done?fourmolu Are we done?fourmoluGiven location of previous comment, output the next comment returning  if we're donefourmoluWhether we printed any commentsfourmoluComment 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 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.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  "=".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.fourmoluOutput space >> txt "::"* when we are printing with trailing arrowsfourmoluOutput txt "::" >> space) when we are printing with leading arrowsfourmoluWhether 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"8fourmoluLanguage 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/404fourmoluAll other extensionsfourmoluExtensions starting with Nofourmolu/Extensions that should go after everything elsefourmoluPragma classification.fourmoluPrint a collection of G!s with their associated comments.fourmolu Classify a LanguagePragma. Safe-Inferred"'2fourmoluData 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   Safe-Inferred"%&=fourmoluUnlike the version in 1:>, this version handles explicitly leading export documentationfourmolu%Surround given entity by parentheses ( and ). Safe-Inferred"r  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 "%&gfourmolu.How to render Haddocks associated with a type.fourmolu Render an  PrevTypeCtx infixfourmoluLike ' but indent properly following a forallfourmoluReturn  if at least one argument in " has a doc string attached to it.fourmoluRender several forall-ed variables. Safe-Inferred "%&'()fourmolu+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.fourmoluReturn the wrapping function controlling the use of braces according to the current layout.fourmoluAppend each element in both lists with semigroups. If one list is shorter than the other, return the rest of the longer list unchanged.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 .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?fourmoluStrictness prefix (FunBind)fourmoluArgument patternsfourmolu EquationsfourmoluHow to get body placementfourmoluHow to print bodyfourmolu Style of this group of equationsfourmoluIs this an infix match?fourmoluStrictness 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 groupfourmoluPlacerfourmoluRenderfourmolu ExpressionfourmoluPlacerfourmoluRenderfourmoluIffourmoluThenfourmoluElsefourmoluRenderfourmolu Typed splice?fourmoluSplice expressionfourmoluSplice decoration   Safe-Inferred"%&|fourmolu(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- 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"%&fourmoluType constructorfourmoluFixityfourmoluType variablesfourmoluRHS of type declaration$ Safe-Inferred% Safe-Inferred"%&3' Safe-Inferred"%&b" Safe-Inferred"%&)*-Ifourmolu Whether to format as data familyfourmoluType constructorfourmolu Type patternsfourmoluLexical fixityfourmoluData definition! 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"( Safe-Inferred"%&& Safe-Inferred"1) Safe-Inferred%&g 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.* Safe-Inferred"%&(˜fourmolu Wrap GHC's  to add  instance.fourmolu$Parse a complete module from string.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.fourmoluOrmolu configurationfourmolu'Fixity map to include in the resulting sfourmolu0File 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 parser+ Safe-Inferred %&z fourmoluA wrapper for   that allows us to define an  instance for it.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/export items.fourmoluProject   from  .fourmoluLike  for located wrapped names.fourmolu Compare two IEWrapppedName  things., Safe-Inferred"%&tfourmoluRender 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"%&fourmoluRender several source snippets.fourmoluResult of parsingfourmoluResulting rendition  . Safe-Inferred%&(3fourmoluResult of comparing two s.fourmoluTwo parse results are the samefourmoluTwo parse results differfourmoluReturn Diff of two s.fourmoluCompare two values for equality disregarding the following aspects:sordering of import lists"style (ASCII vs Unicode) of arrows,LayoutInfo (brace style) in extension fieldsEmpty contexts in type classes"Parens around derived type classes Safe-Inferred%&(ffourmoluParsed 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 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.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 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 infofourmoluPath to the cabal filefourmolu"Parsed generic package description/ Safe-InferredifourmoluWrite 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.fourmolu(A helper function for decoding a strict  into . It is strict and fails immediately if decoding encounters a problem.0 Safe-Inferred%&Ԁfourmolu6Cache ref that stores fixity overrides per cabal file.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 E, for parsing individual fixity definitions.fourmolu& already obtained for this source filefourmoluInput to parsefourmolu Parse result1 Safe-InferredZfourmolu 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 .fourmoluA wrapper around .fourmoluPretty-print a .fourmoluDetect  based on the file extension.fourmoluOrmolu configurationfourmoluLocation of source filefourmoluInput to formatfourmoluOrmolu configurationfourmoluLocation of source filefourmoluResulting renditionfourmoluOrmolu configurationfourmoluResulting renditionfourmoluOrmolu configurationfourmoluFixity Map for operatorsfourmoluHow to obtain  to throw when parsing failsfourmoluFile name to use in errorsfourmoluActual input for the parser>prqs>prqs;<=;<>;<?;<@;AB;AC4D4E4F4G4H4I4J4K4L4M4N4O4O4P4Q4R4S4T4U4V4W4XYYZZ[\\]^_`abcdefghijklmnopqrstuvwxyz{9|}~                                                                     !"##$%&''''(##))))))))))))))****+++++,-.......///001111233333334447                   6######!!*****++++++++./011'fourmolu-0.8.2.0-GosLlu5LFzMIPkpkOEf81JOrmolu.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 RealSrcSpanbuildFixityMapUtils Cabal-3.6.3.0Language.Haskell.ExtensionUnknownExtensionEnableExtensionDisableExtension ExtensionDistribution.Types.PackageName PackageName unPackageNameImportExportStyleImportExportLeadingImportExportTrailingImportExportDiffFriendlyHaddockPrintStyleHaddockSingleLineHaddockMultiLineHaddockMultiLineCompact CommaStyleLeadingTrailing PrinterOpts poIndentationpoFunctionArrows poCommaStylepoImportExportStylepoIndentWherespoRecordBraceSpacepoNewlinesBetweenDeclspoHaddockStyle poRespectful HackageInfo LazyFixityMap FixityMap FixityInfo fiDirectionfiMinPrecedencefiMaxPrecedenceFixityDirectionInfixLInfixRInfixNdefaultFixityInfocolonFixityInfo lookupFixity$fToJSONFixityDirection$fFromJSONFixityDirection$fSemigroupFixityInfo$fToJSONFixityInfo$fFromJSONFixityInfo$fToJSONHackageInfo$fFromJSONHackageInfo$fLiftBoxedRepHackageInfo$fShowLazyFixityMap$fEqFixityInfo$fOrdFixityInfo$fShowFixityInfo$fLiftBoxedRepFixityInfo$fEqFixityDirection$fOrdFixityDirection$fShowFixityDirection$fLiftBoxedRepFixityDirection packageToOpspackageToPopularity bootPackagesdefaultStrategyThresholdbuildFixityMap'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 $fShowHunk $fEqTextDiff$fShowTextDiffOrmoluExceptionOrmoluParsingFailedOrmoluOutputParsingFailedOrmoluASTDiffersOrmoluNonIdempotentOutputOrmoluUnrecognizedOptsOrmoluCabalFileParsingFailedOrmoluMissingStdinInputFileOrmoluFixityOverridesParseErrorwithPrettyOrmoluExceptions$fExceptionOrmoluException$fEqOrmoluException$fShowOrmoluExceptionConfigFileLoadResult ConfigLoadedConfigParseErrorConfigNotFoundFourmoluConfigcfgFilePrinterOptscfgFileFixitiesPrinterOptsFieldType parseJSON parseTextshowTextPrinterOptsFieldMetametaName metaGetFieldmetaPlaceholdermetaHelp metaDefaultPrinterOptsTotalPrinterOptsPartial DynOption unDynOption RegionDeltasregionPrefixLengthregionSuffixLength RegionIndicesregionStartLine regionEndLineConfig cfgDynOptionscfgFixityOverridescfgDependencies cfgUnsafecfgDebugcfgCheckIdempotence cfgSourceType cfgColorMode cfgRegioncfgPrinterOpts SourceType ModuleSourceSignatureSource defaultConfigregionIndicesToDeltasdynOptionToLocatedStr overFields overFieldsMdefaultPrinterOptsfillMissingPrinterOptsprinterOptsMeta emptyConfigloadConfigFileconfigFileName$fMonoidPrinterOpts$fSemigroupPrinterOpts'$fPrinterOptsFieldTypeImportExportStyle'$fPrinterOptsFieldTypeHaddockPrintStyle)$fPrinterOptsFieldTypeFunctionArrowsStyle $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 PrevTypeCtx TypeCtxStart TypeCtxForallTypeCtxContextTypeCtxArgument HaddockStylePipeCaretAsteriskNamedSpanMark HaddockSpan CommentSpan StatementSpanCommentPosition OnTheSameLine OnNextLineLayout SingleLine MultiLineRrunRtxtinterferingTxtatomspace declNewline askSourceTypeaskFixityOverrides askFixityMapinciBy inciByFracinciinciHalf inciByExactsitccsitccIfTrailing enterLayoutvlayout getLayout getPrinterOptregisterPendingCommentLinetrimSpanStream nextEltSpan popCommentgetEnclosingSpanwithEnclosingSpan thisLineSpans spanMarkSpan setSpanMark getSpanMark useBraces dontUseBraces canUseBracesisExtensionEnabledgetPrevTypeCtxsetPrevTypeCtx $fFunctorR$fApplicativeR$fMonadR$fEqPrevTypeCtx$fShowPrevTypeCtx$fShowSpitType $fEqSpitType$fEqCommentPosition$fShowCommentPosition $fEqLayout $fShowLayout$fEqRequestedDelimiter$fShowRequestedDelimiterspitPrecedingCommentsspitFollowingCommentsspitRemainingCommentsspitCommentNowspitCommentPending PlacementNormalHanging BracketStyleNSinciIflocatedlocated' switchLayout breakpoint breakpoint'sepsepSemi backticksbananabracesbracketsparens parensHash pragmaBracespragmacommacommaDelcommaDelImportExportequals placeHangingtrailingArrowTypeleadingArrowType $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$fShowCachedCabalFile $fEqCabalInfo$fShowCabalInfo writeFileUtf8 readFileUtf8getContentsUtf8getFixityOverridesForSourceFileparseFixityDeclarationStrormolu ormoluFile ormoluStdindetectSourceType baseDynFlagsmkBijectiveMap BijectiveMap parseTextWith showTextWith allNothingunpackFieldsWithSuffix showAllValuesFunctionArrowsStyleTrailingArrows LeadingArrowsmergeFixityMaps pOperatorbase GHC.MaybeNothingparseExtensionstokenizepLexer4ghc-lib-parser-9.2.4.20220729-IKxrswr4gmOD9vG8LKIAKFGHC.Types.SrcLocStateOutside InConditionalInContinuationcontainers-0.6.5.1Data.IntSet.InternalIntSetghc-prim GHC.TypesTrueRC rcUseColorrcHandlewithSGR+ansi-terminal-0.11.3-D6bL3e3spkLAvtkpG8VRUeSystem.Console.ANSI.TypesSGR text-1.2.5.0Data.Text.InternalTextGHC.BaseStringHunk DiffList'DiffList Diff-0.4.1-HkfsxrzDHbyEEDIwt4L5bData.Algorithm.DiffBothFirstSecond textDiffPathtextDiffDiffListtextDiffSelectedLines assignLinestoHunksformHunk trimEmptyprintOrmoluExceptionLocateddirectory-1.3.6.2 System.Directory.Internal.Common XdgConfig OrmoluState OrmoluEnabledOrmoluDisabledlinesNotToFormatmagicDisabledLines linesFiltered shebangLineslinePragmaLinesenablingMagicCommentJustdisablingMagicCommentisMagicCommentMaybe compareOp addFixityInfomakeFlatOpTreereassociateFlatOpTree$BoolNonEmpty RealLocatedGHC.HsHsModule mkCommentextractStackHeaderextractPragmasunAnnotationCommentGHC.Parser.Annotation LEpaCommentremoveConseqBlanksescapeHaddockTriggersSpitTypespit SimpleTextInterferingTextAtom CommentPartRequestedDelimiterRequestedSpaceRequestedNewlineRequestedNothing AfterNewline VeryBeginningSCscColumnscIndent scBuilder scSpanStreamscThisLineSpansscCommentStreamscPendingCommentsIntscRequestedDelimiter scSpanMark scPrevTypeCtxrcIndentrcLayoutrcEnclosingSpansrcCanUseBraces rcExtensions rcSourceTypercFixityOverrides rcFixityMapGHC.Utils.Outputable newlineRaw newlineRawNspitPrecedingCommentspitFollowingCommentspitRemainingCommenthandleCommentSerieswithPoppedCommentneedsNewlineBeforetheSameLinePretheSameLinePostcommentFollowsElt GenLocated spansLayout brackets_LanguagePragmaClass GHC.ClassesOrd DisablingFinalPragmaTyclassifyLanguagePragmaLocatedNGHC.Types.Name.ReaderRdrNameattachRelativePos'parens' DisregardRespect isDocumented groupDecls groupedDecls declSeries TypeDocStylep_afterLanguage.Haskell.Syntax.TypeHsType GroupStyleMatchGroupStyleadjustMatchGroupStyleLanguage.Haskell.Syntax.BindsFunBindLanguage.Haskell.Syntax.Exprm_ctxtMatchFunction withSpacinglayoutToBraces liftAppendblockPlacement cmdPlacement withGuardsbreakpointPreRecordBracep_hsExprListItem p_matchGroup'p_matchp_match'p_grhs'p_stmt'p_stmtsp_case p_lamcasep_ifp_let p_hsSpliceTH p_typeSig p_classOpSig p_inlineSig p_specSig p_minimalSigp_booleanFormula p_completeSigHsExpr LHsCmdTopLHsExpropBranchPlacementopBranchBraceStyle tyOpPlacementp_foreignTypeSigp_foreignImportLanguage.Haskell.Syntax.Decls ForeignImportGHC.Types.ForeignCallPlaySafeCImport SeverityOrdGHC.Types.ErrorSeveritynormalizeModulesetDefaultExts runParserGHC.Parser.LexerPparsePragmasIntoDynFlagsGHC.Driver.SessionDynFlagsIEWrappedNameOrd GHC.Hs.ImpExp IEWrappedNameImportIdcombineImportsimportId normalizeLiesgetIewnIEGHC.Hs.ExtensionGhcPs compareLIewn compareIewnmatchIgnoringSrcSpansCachedCabalFilegenericPackageDescriptionextensionsAndDeps cabalCacheRefGHC.IOFilePathgetExtensionAndDepsMap decodeUtf8bytestring-0.11.3.1Data.ByteString.Internal ByteStringcacheRefIO parseModule'showWarnGHC.Driver.CmdLineWarn