h*6      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                           !!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""""""""""""""""""""""############$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%&'((())))*0.2.0.07+ Safe-Inferred"%&(/36< (c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36< {stanOpen a given file in a browser. The function has the following algorithm: Check the BROWSER environment variable5If it's not set, try to guess browser depending on OS!If unsuccsessful, print a messagestan!Execute a command with arguments.{{(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<& |stanA type of the inspection.stanShow | in a human-friendly format.stanList category of Stan inspections.stanPartial category of Stan inspections.stanInfinite category of Stan inspections.stan AntiPattern category of Stan inspections.stan SpaceLeak category of Stan inspections.stanSyntax/ category of Stan inspections. Usually used in , inspections.stanUnsafe category of Stan inspections.stanThe list of all available Stan |s. |}~ |}~(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/136<OstanA type alias for the situations when we don't care about the parameter of , but don't want to deal with type variables.stanA wrapper around the textual value to safely represent IDs for different structures by using a phantom parameter.stanUnsafe cast of ?. Implementation uses smart trick to enforce usage always with TypeApplications.(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<^stanChecks that two lists have the same length and that a given binary predicate returns ( on each corresponding pair of elements.checkWith (==) [] []TruecheckWith (==) [1, 2] [1, 2]TruecheckWith (==) [1, 2] [2, 1]FalsecheckWith (==) [1, 2] [1]FalsestanReturns list all element pairs without the following properties:No element with itself: (x, x) Only one of (x, y) and (y, x) will be in the resultIn other words, it's like taking the cross product of the list with itself and then keeping only the half of that without the diagonal. foo [1..3][(1, 2), (1, 3), (2, 3)](c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<-(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<h.(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36</(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<W0 Safe-Inferred"%&(/36<1 Safe-Inferred"%&(/36<   &%' ($-./ *)+,9:;012345678<=> !"# Safe-Inferred"%&(/36<`  <=>9:; *)+, !"#-./012345678  $%&'(   &%' ($-./ *)+,+,9:;012345678<=> !"#(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<stan#Wrapper around Haskell module name.stanConvert 23 to .stanExtract  from 24.5(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<t6 Safe-Inferred"%&(/36<7 Safe-Inferred"%&(/36<8 Safe-Inferred"%&(/36<1DEFGHIJKLMNOPcd[\]^_`abqrstuvwxfghijklmnoe?@ABCUQRSTVWXYZpyz Safe-Inferred"%&(/36<?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzDEFGHIJKLMNOPcd[\]^_`abqrstuvwxfghijklmnoe?@ABCUQRSTVWXYZpyz (c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<stanGets the list of .cabal* file paths that were used in the project.stan%From a given path to cabal files and qs create the map from modules (that are in .cabal file) to the resulting parsed extensions for each.stanRecursively find all .cabal files in the current directory and its subdirectories. It returns maximum 1 .cabal file from each directory.stanFind a .cabal file in the given directory. TODO: better error handling in stan.stanDo print into terminal?stan.cabal files9(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<:(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36< ;(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<  (c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<"stan*Data from different environment resources:Environment variablesUsed TOML configuration filesCommand Line argumentsstan Contains all stan System informationstanstan version information.stanCurrent stan version information.stanColourful pretty  representation used in the CLI.stanAll system info for the project (c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<( stan%Meta information about function/type.stan Pretty show  in the following format: package/module/name.stan Check if  is identical to  .stanCheck whether HIE U with details is a given .stanCheck if the given [' node is identifier equal to the given .stanCreate  for a function from the base package and a given  . module.stanCreate  for a function from the base package and the GHC.List module.stanCreate  for a function from the base package and the  Data.OldList module.stanCreate  for a function from the base package and the  Data.Foldable module.stanCreate  for a function from the unordered-containers package and a given  module.stanCreate  for a function from the text package and a given  module.stanCreate  for a function from the ghc-prim package and a given  module.stan for primitive types.stanName meta infostanHIE identifier88888<(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<(  Safe-Inferred"%&(/36<)7 (c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<+stanCommon interface for -like parts of patterns. Allows to write composable and reusable complex pattern definitions from smaller pieces.1Laws (in terms of matching functions that return ):  D    D    x D x   D    x D x   D xstan(Anything. Matching should always return .stan Negation. Inverses the argument.stanOr-pattern. Choice.stanAnd-pattern. Both.23(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<1stan.Query pattern used to search types in HIE AST.stanArgument, type or constructor:a!PatternName (NameMeta ... "a") [][a] ,PatternName (NameMeta ... "List") [aPattern] (after GHC 9.6) *PatternName (NameMeta ... "[]") [aPattern] (before GHC 9.6)Either Int String?PatternName (NameMeta ... "Either") [intPattern, stringPattern]stanFunction pattern.stan Type wildcard, matches anything.stan5Choice between patterns. Should match either of them.stan-Union of patterns. Should match both of them.stanNegation of pattern. Should match everything except this pattern.stanShort operator alias for  PatternFun.stanShort operator alias for .stan for list [a] or .stan for .stan for [a] -> _ or  String -> _.stan for .stan for .stan for .stan for .stanList of types for  STAN-0207.stan for stan for stan for pair (,).stanType patterns for the = typeclass methods. Represented as a non-empty list of pairs: Method name1Function from type to pattern (where things like ,  should be)45(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<?G"stanQuery pattern used to search AST nodes in HIE AST. This data type tries to mirror HIE AST to each future matching, so it's quite low-level, but helper functions are provided.stanInteger constant in code.stan3Name of a specific function, variable or data type.stanVariable name.stan5AST node with tags for current node and any children.stan5Choice between patterns. Should match either of them.stan-Union of patterns. Should match both of them.stanNegation of pattern. Should match everything except this pattern.stan5AST node with the specified Identifier details (only )stanFunction that creates ( from the given non-empty list of pairs  and .If the list contains only one  then it is simple  . Else it is  of all such s.stanLike  but doesn't care about types.stanapp f x' is a pattern for function application f x.stan opApp x op y' is a pattern for operator application x op y.stan range a b is a pattern for [a .. b]stan is a pattern for case' expression (not considering branches).stan is a pattern for  case EXP of' expression (not considering branches).stan1Pattern to represent one pattern matching branch.stan Pattern for _ in pattern matching.Note: presents on GHC >=8.10 only.stan)Pattern for literals in pattern matching.Note: presents on GHC >=8.10 only.stan4Pattern to represent one pattern matching branch on _.stan>Pattern to represent right side of the pattern matching, e.g. -> "foo".stan-Pattern for the top-level fixity declaration: infixr 7 ***, +++, ??? stan4Pattern for the function type signature declaration: foo :: Some -> Type stan$Pattern for the function definition: foo x y = ... standata or newtype declaration.stanConstructor of a plain data type or newtype. Children of node that matches this pattern are constructor fields.stan Constructor name Identifier infostan*Lazy data type field. Comes in two shapes: Record field, like:  foo :: Text Simple type: IntstanPattern for any occurrence of a plain type. Covers the following cases:Simple type: Int, Bool, a.Higher-kinded type: Maybe Int, Either String aType in parenthesis: (Int)Tuples: (Int, Bool)List type: [Int]Function type: Int -> Boolstan8Pattern for the field without the explicit bang pattern: someField :: Int stanPattern for tuples:,Type signatures: foo :: (Int, Int, Int, Int) Literals: (True, 0, [], Nothing)stanPattern for a single guard branch:  | x < y = ... stan:Pattern for the right-hand-side. Usually an equality sign.  foo = baz stan)Annotations for constants: 0, "foo", etc.stanSet of context info (pairs of tags) | AST node with tags for current node and children patterns. This pattern should match the node exactly.stan#Set of context info (pairs of tags)stan0Node children | AST wildcard, matches anything.(((c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<CPstanReturns contents of all .hie files recursively in the given hie directory.stan9Get the number of lines of code in the file by analising q.stan.Take sub-bytestring according to a given span.'When the given source is empty returns .1TODO: currently works only with single-line spansstanCompare two AST nodes on equality. This is a more relaxed version of the  instance for [ because it doesn't compare source locations. This function is useful if you want to check whether two AST nodes represent the same AST.)This function needs to take the original q% because constants are not stored in [ and to compare constants we need to compare parts of source code.(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<Dstan?Matching function that searches the array of types recursively.stanArray of all types in HIE filestanOur search querystan$Index of the current expression typestanIf matched type is found(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<FstanMatching function that matches current AST node with a given pattern.stanHIE filestanCurrent AST node to matchstanPattern to match againststan if pattern matches AST node(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<F(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<GstanBoolean for showing/hiding solution information of observations.stanSettings for produced report.stanIs the toggle option set to ?  (c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<K stan!Severity level of the inspection.SeverityExampleMissing infix, or type signature in where Usage of =>, =?Some common user errors: [0 .. length xs]Partial functions, like @A Usage of  in codestan$Code style issues. Usually harmless.stan Safe-Inferred"%&(/36<O stan0Data type that represents all possible types of stan inspections in a uniformed way.stanFind the specific part of the Haskell AST (including specific functions).stan$Find all operators without matching  infix[r|l]stan&Check if the data type has lazy fieldsstanUsage of tuples with size >= 4stanPattern matching on _ for sum types.stan,Replace multiple comparison operations with stanType alias for the $ that contains pairs of inspections s and corresponding s.stan:Data type that represents a check/test, or how we call it  inspection# that is provided by the Stan tool.stanSort  by stanShow  in a human-friendly format.stanShow the short view of a given .stanCreate the MarkDown text for all inspections. The generated MD has a ToC and separate sections for each inspection.=This is used to keep the Wiki page of the project up to date.(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<Q/stanAll anti-pattern  s map from s.stan @ missing fixity declaration  STAN-0301.stan @ to big tuples  STAN-0302.(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<Ystan All partial s.stan,Smart constructor to create generic partial  with a given Pattern.stan,Smart constructor to create generic partial  with PatternAnything.stan$Smart constructor to create partial $ for functions that work with lists.stan$Smart constructor to create partial / for functions that work with enumerable types.stan @ partial @A  STAN-0001.stan @ partial @B  STAN-0002.stan @ partial @C  STAN-0003.stan @ partial @D  STAN-0004.stan @ partial @E  STAN-0005.stan @ partial @F  STAN-0006.stan @ partial GH  STAN-0007.stan @ partial IJ  STAN-0008.stan @ partial KL  STAN-0009.stan @ partial MN  STAN-0010.stan @ partial MO  STAN-0011.stan @ partial MP  STAN-0012.stan @ partial =Q  STAN-0013.stan @ partial =R  STAN-0014.stan @ partial =S  STAN-0015.stan @ partial =T  STAN-0016.stan @ partial =U  STAN-0017.stan# @ partial 'Data.Foldable.foldl1''  STAN-0018.stan @ partial =V  STAN-0019.stan @ partial WX  STAN-0020.stan @ partial YZ  STAN-0021.stan @ partial [\  STAN-0022.stan @ partial []  STAN-0023.stan - partial [^  STAN-0024stan - partial 'GHC.Real.(/)'  STAN-0025stan Type namestan Type name(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<[stan All infinite  s map from s.stan%Smart constructor to create infinite .stan for  @ infinite   STAN-0101.stan for  @ infinite G_  STAN-0102.stan for  @ infinite =` | G`  STAN-0103.stan for  @ infinite Ga  STAN-0104.stan for  @ infinite =>  STAN-0105.stan for  @ infinite =b  STAN-0106.(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<`stanAll anti-pattern  s map from s.stan)Smart constructor to create anti-pattern .stan @ [0 .. length xs]  STAN-0201.stan @ foldl  STAN-0202.stan @ cd  STAN-0203.stan @ slow ef and   STAN-0204.stan @ slow gf  STAN-0205.stan" @ missing strictness declaration  STAN-0206.stan @ , methods on possibly error-prone structures  STAN-0207.stan @ slow  for hi  STAN-0208.stan @ slow nub for lists  STAN-0209.stan @ slow  and  for ranges  STAN-0210.stan @  / on URLs  STAN-0211.stan @ usage of unsafe* functions  STAN-0212.stan @ Pattent matching on _ for sum types @  STAN-0213.stan @ use   STAN-0214.stan @ Slashes in paths  STAN-0215.(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<bstanAll  s map from s.stanList of all inspections.stanSet of all inspection s.stanLook up  by the given inspection .stanGet the  by the given known inspection .(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<gstan!Type alias for the sized list of s.stan6Data type to represent discovered by Stan suggestions.stanSmart constructor for s from qs.stanShow  in a human-friendly format.stanShow  in the following format: filename.ext(11:12-13:14) stanCheckes the predicate on colourfulness and returns an empty text when the colouroing is disabled.stanCreate a stable   in a such way that: 2 doesn't depend on other inspections in this file. uniquely identifies  location.s are guaranteed to be the same if the module content didn't change between different stan runs.The   should look like this: OBS-STAN-XXXX- module-name-hash-10:42 stan-Hash module name to a short string of length 6%. Hashing algorithm is the following: First, run SHA-1.Then, encode with base64.Last, take first 6 characters.stanCorresponding s .stan Position.stan Use colouringstanIgnored ^ Unknown(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<hstanFile specific information.stan-Return the list of pretty-printed extensions.stan-Check whether the given extension is disabled  (c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<l stanObject that implements the Visitor pattern.stanState for the  object that stores all values during a single HIE AST traversal.stanInitial empty state.stan Transform 1 to the final list of observations for the given q.  stores not only ready  but also additional metadata collected during tree traversal, so this metadata is converted to  for the corresponding  Inspections.stanGet sized list of all , from the given HIE file using the created .stan Add single  to the existing .stanAdd  to the existing .stan&Add single operator infix declaration.stan:Add single operator top-level defintion with its position.stan2Traverse HIE AST starting from a given node using .(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<t0 stan2Analyses the whole AST starting from the very top.stanCreate a sinble  value from a list of )s and additional read-only context. This 2 can be used to traverse HIE AST in a single pass.stan9Check for big tuples (size >= 4) in the following places:,Type signatures: foo :: (Int, Int, Int, Int) Literals: (True, 0, [], Nothing)stan?Find usages of multiple comparison operators and suggest using ). Currently, handles the following cases:GuardsThe algorithm is to find all guards, filter them by usage of comparison operators and find matches.stan?Check for occurrences lazy fields in all constructors. Ignores newtypes. Currently HIE Ast doesn't have information whether the data type is newtype or not. So the algorithm ignores all data types with a single constructor and single field inside that constructor.stan-Check for occurrences of pattern matching on _! for sum types (except literals).stanAnalyse HIE AST to find all operators which lack explicit fixity declaration.The algorithm is the following: 6Traverse AST and discover all top-level operators and infix declarations in a single pass.9Compare two resulting sets to find out operators without infix declaration.stan*Returns source spans of matched AST nodes.stanSpecialized version of ' where custom predicate always returns .stanAdd observation to the state if the given node matches the given  exactly (non-recursively) and if the given custom predicate returns ..stan Current nodestanCustom node checkstan Current node (c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<wPstanThis data type stores all information collected during static analysis.stanIncrease the total loc (0) by the given number of analised lines of code.stan Add set of  s to the existing set.stan Add list of 's to the beginning of the existing liststan Add list of 's to the beginning of the existing liststan#Collect all unique used extensions.stanUpdate  for the given .stan!Perform static analysis of given q.stan#List of to-be-ignored Observations.stan#List of to-be-ignored Observations.stan#List of to-be-ignored Observations.  !(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<ystan:Enum to describe project health depending on the value of .stan:Shows analysed output of Stan work. This functions groups s by  they are found in.stan;Show project health as pretty text with 2 digits after dot.stan Calculate ."(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/1346<f stan7Where to apply the rule for controlling inspection set.stan$Criterion for inspections filtering.stan1Rule to control the set of inspections per scope.stanType of :  or  s.stan3Main configuration type for the following purposes:Filtering inspections (including or ignoring) per scope (file, directory, all)stanConvert TOML configuration to the equivalent CLI command that can be copy-pasted to get the same results as using the TOML config.  I Reading Configurations from /home/vrom911/Kowainik/stan/.stan.toml ... stan check --exclude --directory=test/ \ check --include \ check --exclude --inspectionId=STAN-0002 \ check --exclude --inspectionId=STAN-0001 --file=src/MyFile.hs remove --file=src/Secret.hs ignore --id="STAN0001-asdfgh42:42" stanApply configuration to the given list of files to get the set of inspections for each file.The algorithm: "Remove all files specified by the remove option.Run  on the remaining files.stanConvert the list of s from , to data structure that allows filtering of s for given files.stanModify existing (s for each file using the given list of s.stanPaths to project filesstanStan runtime configurationstan*Resulting set of inspections for each filestanPaths to project filesstan List of rulesstan*Resulting set of inspections for each filestan(Initial set of inspections for each filestan List of rulesstan*Resulting set of inspections for each file#(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<X  $(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/346<stanOptions used for the stan cli-to-toml command.stanOptions used for the stan toml-to-cli command.stanOptions used for the stan inspection command.stanOpen HTML report in a browserstanOptions used for the main stan command.stanDirectory with HIE filesstanPath to .cabal files.stan#Settings for output terminal reportstanHTML report settingsstan Use default  .stan.toml filestan%Path to a custom configurations file.stan:Output the machine-readable output in JSON format instead.stanCommands used in Stan CLI.stanJust stan with its options.stanstan inspection.stan stan toml-to-clistan stan cli-to-tomlstan stan inspections-to-mdstanRun main parser of the stan command line tool.stan To turn on some special options.stanStan tool parser. It either uses the named commands or the main stan command.stanstan command parser.stanstan inspection command parser.stanThe solution is shown by default and gets hidden when option is specified.stanThe  is shown juicy by default and gets shortened when option is specified.stan Parser of an ?. Receives a string to specify in Help what kind of ID is this.stanShow the version of the tool.  %(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36< stanCount of each inspectionstanCount of each categorystan Count of observations per modulestanHighest severitystanShort info about analysis.stanThe most popular stanThe most popular |stan.Module with the biggest number of observationsstan The highest stan Assemble  after analysis. Returns  when there's no  Observations. Otherwise, there's at least one observation, which means that we can find the most popular , | and the highest .stanFast, strict maximum&(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<p'(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<gstan'Warnings during Trial config selectionsstanEnvironment informationstanProject related Information((c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/346<stanBased on the incoming settings returns the TOML configuration files that were used to get the final config.stanHelper  for the hardcoded string "all".)(c) 2020 KowainikMPL-2.0Kowainik  Safe-Inferred"%&(/36<jkljkmjnojnojnpjq3jqrjstjsujv4jvwjxyjxzj{|j}~j}j}j}j}j}j}j}jjjjjjjjjjjjjjjjjxjxjxj{j{j{j{jjjjsjsjsjsjsjsjsjsjsjsujsjsjsjsjsjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj111338888888888                                                         <     ,            !!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""""""""""""""""""""""############$$$$$$$$$$$$$$$$$$$$$$$$$)$$$$$$$%%%%%%%&'((())))++++++++  i=@=`==        $*$$$$$$%%%%%(#stan-0.2.0.0-KLKSPLq0Zn5JNjawrl8XhEStan.Ghc.CompatStan.Hie.Compat Stan.Browse Stan.Category Stan.Core.IdStan.Core.List Stan.EnvVarsStan.Core.ModuleName Stan.Cabal Stan.Info Stan.NameMetaStan.Hie.DebugStan.Pattern.EdslStan.Pattern.TypeStan.Pattern.AstStan.HieStan.Hie.MatchTypeStan.Hie.MatchAstStan.Report.CssStan.Report.Settings Stan.SeverityStan.InspectionStan.Inspection.StyleStan.Inspection.PartialStan.Inspection.InfiniteStan.Inspection.AntiPatternStan.Inspection.AllStan.Observation Stan.FileInfoStan.Analysis.VisitorStan.Analysis.Analyser Stan.AnalysisStan.Analysis.Pretty Stan.ConfigStan.Config.PrettyStan.CliStan.Analysis.SummaryStan.Report.Html Stan.Report Stan.TomlStanstan Paths_stanStyle Stan.ExampleStan.Ghc.Compat810Stan.Ghc.Compat900Stan.Ghc.Compat902Stan.Ghc.Compat906GHC ModuleNameModuleStan.Hie.Compat810Stan.Hie.Compat900Stan.Hie.Compat902Stan.Hie.Compat904Stan.Hie.Debug810Stan.Hie.Debug900Stan.Hie.Debug908Stan.Hie.Debug902 Data.FoldablesumfoldlGHC.Listheadtailinitlast!!cycle Data.OldList genericIndex Data.MaybefromJust Text.ReadreadGHC.EnumsuccpredtoEnummaximumminimum maximumBy minimumByfoldl1foldr1GHC.ExtsfromListGHC.Num fromIntegerGHC.Real fromRational realToFracrecip isSuffixOflength genericLengthproductData.ByteString.Char8packData.HashMap.Strictsize Data.HashSetDataTextghcGHC.Data.FastString FastString mkFastStringLanguage.Haskell.Syntax.BasicFieldLabelString field_label#Language.Haskell.Syntax.Module.NamemoduleNameStringGHC.Iface.Type IfaceTyLit IfaceTyConGHC.Unit.Types moduleNameGHC.Types.NameName nameOccName GHC.Types.Var ForAllTyFlagGHC.Types.SrcLoc RealSrcSpan srcSpanFile mkRealSrcLoc mkRealSrcSpansrcSpanStartLinesrcSpanEndLinesrcSpanStartCol srcSpanEndColGHC.Types.FieldLabel FieldLabelflLabelflHasDuplicateRecordFieldsflHasFieldSelector flSelectorGHC.Unit.ModulemoduleStableStringLanguage.Haskell.Syntax.Type PromotionFlag NotPromoted IsPromotedGHC.Types.Basic TupleSort BoxedTuple UnboxedTupleConstraintTupleGHC.Types.Name.Occurrence occNameStringisSymOccisExternalName nameModulenameStableString InvisibleRequired SpecifiedInferredGHC.Types.Avail AvailInfoAvailAvailTCIfaceTyConInfoifaceTyConIsPromotedifaceTyConSortIfaceTyConSortIfaceNormalTyConIfaceTupleTyCon IfaceSumTyConIfaceEqualityTyConifaceTyConNameifaceTyConInfo IfaceNumTyLit IfaceStrTyLitIfaceCharTyLitGHC.Iface.Ext.TypesIETypeImportImportAs ImportHidingExport ContextInfoUse MatchBindIEThingTyDeclValBind PatternBind ClassTyDeclDecl TyVarBindRecFieldEvidenceVarBindEvidenceVarUseIdentifierDetails identType identInfo IdentifierNodeInfonodeAnnotationsnodeTypenodeIdentifiersHieASTNodesourcedNodeInfonodeSpan nodeChildrenHieASTsgetAstsHieArgs HieTypeFlatHieTypeHTyVarTyHAppTy HTyConApp HForAllTyHFunTyHQualTyHLitTyHCastTy HCoercionTy TypeIndexHieFile hie_hs_file hie_module hie_typeshie_asts hie_exports hie_hs_srcGHC.Iface.Ext.Binary HieFileResulthie_file_result openBrowserCategory unCategoryprettyShowCategorylistpartialinfinite antiPattern spaceLeaksyntaxunsafestanCategories$fShowCategory $fEqCategory$fHashableCategory$fToJSONCategoryAnyIdIdunIdcastId$fShowId$fEqId$fOrdId $fHashableId $fToJSONId checkWithnonRepeatingPairsEnvVarsenvVarsUseDefaultConfigFile getEnvVars envVarsToTextFieldLbl moduleUnitId showTUnitId unModuleNamefromGhcModuleName fromGhcModule$fShowModuleName$fEqModuleName$fHashableModuleName$fIsStringModuleName$fToJSONModuleNameDeclTypeNodeAnnotationnodeInfomkNodeAnnotationtoNodeAnnotationhFunTy2readHieFileWithNameCacheconDec eqDeclTypeusedCabalFilescreateCabalExtensionsMapmergeParsedExtensions ProjectInfopiName piCabalFilespiHieDir piFileNumberStanEnv seEnvVars seTomlFiles seCliArgs StanSystemssOsssArch ssCompilerssCompilerVersion StanVersion svVersion svGitRevision svCommitDate stanVersionprettyStanVersion stanSystem$fShowProjectInfo$fEqProjectInfo $fShowStanEnv $fEqStanEnv$fShowStanSystem$fEqStanSystem$fShowStanVersion$fEqStanVersionNameMetanameMetaPackagenameMetaModuleName nameMetaNameprettyShowNameMeta compareNameshieMatchNameMetahieFindIdentifier baseNameFromghcInternalNameFrom _nameFrommkBaseListMetamkBaseOldListMetamkBaseFoldableMetaunorderedNameFrom textNameFromghcPrimNameFrom primTypeMeta$fShowNameMeta $fEqNameMeta debugHieFile PatternBool?neg|||&&& PatternTypePatternTypeNamePatternTypeFunPatternTypeAnything PatternTypeOrPatternTypeAndPatternTypeNeg|->|:: listPatternnonEmptyPatternlistFunPatternintegerPatternnaturalPatternrationalPatternscientificPattern charPattern stringPattern textPatternfoldableTypesPatternsfoldableMethodsPatterns$fPatternBoolPatternType$fShowPatternType$fEqPatternTypeLiteralExactNumExactStr PrefixStr ContainStr AnyLiteral PatternAstPatternAstConstantPatternAstNamePatternAstVarNamePatternAstNodePatternAstNodeExactPatternAstAnything PatternAstOr PatternAstAnd PatternAstNegPatternAstIdentifierDetailsDeclnamesToPatternAstanyNamesToPatternAstappopApprange lambdaCasecase'patternMatchBranchwildPat literalPat patternMatch_patternMatchArrowfixitytypeSigfundataDecl constructorconstructorNameIdentifier lazyFieldtuple guardBranchrhs literalAnns$fPatternBoolPatternAst$fShowPatternAst$fEqPatternAst $fShowLiteral $fEqLiteral readHieFilescountLinesOfCodesliceeqAsthieMatchPatternTypehieMatchPatternAststanCssToggleSolution HideSolution ShowSolution VerbosityVerbose NonVerboseOutputSettingsoutputSettingsVerbosityoutputSettingsSolutionVerbosity isVerboseisHidden$fShowToggleSolution$fShowVerbositySeverity Performance PotentialBugWarningErrorseverityDescriptionseverityColourprettyShowSeverity$fToJSONSeverity$fShowSeverity$fReadSeverity $fEqSeverity $fOrdSeverity$fEnumSeverity$fBoundedSeverityInspectionAnalysisFindAstInfix LazyField BigTuplesPatternMatchOn_ UseCompareInspectionsMap Inspection inspectionIdinspectionNameinspectionDescriptioninspectionSolutioninspectionCategoryinspectionSeverityinspectionAnalysis descriptionL solutionL categoryL severityL analysisLsortByIdprettyShowInspectionprettyShowInspectionShort inspectionsMd$fToJSONInspection$fShowInspection$fEqInspection$fShowInspectionAnalysis$fEqInspectionAnalysisstyleInspectionsMapstan0301stan0302partialInspectionsMapstan0001stan0002stan0003stan0004stan0005stan0006stan0007stan0008stan0009stan0010stan0011stan0012stan0013stan0014stan0015stan0016stan0017stan0018stan0019stan0020stan0021stan0022stan0023stan0024stan0025infiniteInspectionsMapstan0101stan0102stan0103stan0104stan0105stan0106antiPatternInspectionsMapstan0201stan0202stan0203stan0204stan0205stan0206stan0207stan0208stan0209stan0210stan0211stan0212stan0213stan0214stan0215inspectionsMap inspectionsinspectionsIdslookupInspectionByIdgetInspectionById Observations Observation observationIdobservationInspectionIdobservationSrcSpanobservationFileobservationModuleNameobservationFileContent mkObservationprettyShowObservationprettyObservationSourceignoredObservationsprettyShowIgnoredObservationsmkObservationId$fToJSONObservation$fShowObservation$fEqObservationFileMapFileInfo fileInfoPathfileInfoModuleName fileInfoLocfileInfoCabalExtensionsfileInfoExtensionsfileInfoMergedExtensionsfileInfoObservationsextensionsToTextisExtensionDisabled$fToJSONFileInfo$fShowFileInfo $fEqFileInfoVisitor unVisitor VisitorStatevisitorStateObservationsvisitorStateFixitiesvisitorStateOpDeclsgetFinalObservationsaddObservationaddObservations addFixity addOpDeclvisitAst analyseAstAnalysisanalysisModulesNumanalysisLinesOfCodeanalysisUsedExtensionsanalysisInspectionsanalysisObservationsanalysisIgnoredObservationsanalysisFileMap runAnalysis$fToJSONAnalysis$fShowAnalysis ProjectHealth Unhealthy LowHealth MediumHealthHealthyAnalysisNumbers anModulesanLocanExts anSafeExtsanIns anFoundObs anIgnoredObsanHealthprettyShowAnalysisanalysisToNumbers prettyHealthtoProjectHealthScope ScopeFileScopeDirectoryScopeAll CheckFilterCheckInspection CheckSeverity CheckCategoryCheckAllCheck checkType checkFilter checkScope CheckTypeIncludeExclude PartialConfigConfigConfigP configChecks configRemoved configIgnored defaultConfigfinaliseConfigconfigToCliCommandmkDefaultChecks applyConfig applyChecksapplyChecksFor$fSemigroupConfigP $fShowCheck $fEqCheck $fShowScope $fEqScope$fShowCheckFilter$fEqCheckFilter$fShowCheckType $fEqCheckType$fEnumCheckType$fBoundedCheckType $fEqConfigP $fShowConfigP ConfigAction RemoveAction IncludeAction ExcludeAction IgnoreActionprettyConfigActionconfigActionClassconfigActionColourconfigToTriplesprettyConfigCli$fShowConfigAction$fEqConfigAction CliToTomlArgscliToTomlArgsFilePathcliToTomlArgsConfig TomlToCliArgstomlToCliArgsFilePathInspectionArgsinspectionArgsId ReportArgsreportArgsBrowseStanArgsstanArgsHiedirstanArgsCabalFilePathstanArgsOutputSettingsstanArgsReportstanArgsUseDefaultConfigFilestanArgsConfigFilestanArgsConfigstanArgsJsonOut StanCommandStanInspection StanTomlToCli StanCliToTomlStanInspectionsToMd runStanClistanParserPrefs stanCliParserSummarysummaryInspectionIdsummaryCategory summaryModulesummarySeverity createSummarystanHtmlgenerateReport usedTomlFiles getTomlConfig configCodecrun getStanConfig getAnalysisrunStanversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDirgetDataFileName getSysconfDir runCommandghc-prim GHC.TypesTruefindCabalFilesfindCabalFileDirBoolFalsebaseGHC.BaseStringNonEmpty ghc-bignumGHC.Num.IntegerIntegerGHC.Num.NaturalNatural text-2.0.2Data.Text.Internal maybePattern GHC.MaybeMaybe eitherPattern Data.EitherEither pairPatternFoldabletype_lazyRecordFieldNothing GHC.ClassesEq%relude-1.2.2.0-3GOZgXfYpCkLxDQTZIJ3Rv Relude.Debug undefinedcompare2unordered-containers-0.2.20-IjGhMC3VxQdI8jjxoJi472Data.HashMap.InternalHashMapmkPartialInspectionPatternmkPartialInspectionmkPartialInspectionListmkPartialInspectionEnummkInfiniteInspectionreversemkAntiPatternInspectionfor_forM_showSpan whenColourhashModuleNameinitialVisitorState finaliseState createVisitoranalyseBigTuplesanalyseCompareanalyseLazyFieldsanalysePatternMatch_ analyseInfix createMatchmatchAst matchAstWithincLinesOfCodeaddInspectionsaddIgnoredObservations addExtensions updateFileMapGHC.IOFilePathanalyseanalyseHieFilestanPstanInspectionPtoggleSolutionP verbosityPidPversionP sdInspections sdCategories sdModules sdSeverity maximumOn1_All&tomland-1.3.3.3-9NbbuU7are8C7PZZ4s0FrJToml.Codec.BiMapBiMap