h*'%      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             !!!!""""############$$$$$$$$$$%%%%%%%%%&''''''''())))))))))))))***********++++++++++++++++++++++,,,,,,,,,,,,-------------.........../////////00000000000111111111111122222222233344444445555555555555677777777788889999999999999999999:::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<=========>>>>>>>>>>>>>>>>>>>>>>>>>????????????????????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAABBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDEEEEEEEEEFFFFFFFFFFFFFGGGGGHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIJJJKKKKKLLLLLLMMMMMMMMMMMNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUVVVVVVVVVVVWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZ[[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]^____```````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccdddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffghhhhhhiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnoooooooooooooooooopppppqrrrrrrrrrrrrrrrssttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuvvvwwwwwwwxxxxxxxx x x x x x x x x x x x x x x x x y y y y y z z z z z z z { { { { { { { { { { | | | | | | | | | | | | | | | | | } } } } } } } } } } } } } } } } } } } } } ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~                              !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""################################################################################################################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%2.15.3 Safe-Inferred_   Safe-Inferredh4 stackNative - of the file or directory within the archive.Assumes that the % of an   is UTF8 encoded.%stack Convert a % to a native . The native  will use the native directory separator but it is not otherwise checked for validity or sanity. In particular:?The tar path may be invalid as a native path, eg the file name "nul" is not valid on Windows.4The tar path may be an absolute path or may contain ".." components. For security reasons this should not usually be allowed, but it is your responsibility to check for these conditions (eg using %).Assumes that the % is UTF8 encoded. stackCreate local files and directories based on the entries of a tar archive.This is a portable implementation of unpacking suitable for portable archives. It handles   and  ( entries and has simulated support for   and   entries. Links are implemented by copying the target file. This therefore works on Windows as well as Unix. All other entry types are ignored, that is they are not unpacked and no exception is raised.If the   ends in an error then it is raised an an exception. Any files or directories that have been unpacked before the error was encountered will not be deleted. For this reason you may want to unpack into an empty directory so that you can easily clean up if unpacking fails part-way.:On its own, this function only checks for security (using %). You can do other checks by applying checking functions to the  . that you pass to this function. For example: -unpack dir (checkTarbomb expectedDir entries)If you care about the priority of the reported errors then you may want to use % before  checkTarbomb or other checks.Assumes that the % of an   is UTF8 encoded.%stack If the given ; can be interpreted as a string of bytes that encodes a string using UTF8, then yields the string decoded, otherwise yields the given ;.% %  Safe-Inferred"n stack!Set the user-agent request header stackDownload the given URL to the given location. If the file already exists, no download is performed. Otherwise, creates the parent directory, downloads to a temporary file, and on file download completion moves to the appropriate destination.&Throws an exception if things go wrong stackSame as  , but will download a file a second time if it is already present.Returns V if the file was downloaded, S otherwise stack>Copied and extended version of Network.HTTP.Download.download.Has the following additional features: * Verifies that response content-length header (if present) matches expected length * Limits the download to (close to) the expected # of bytes * Verifies that the expected # bytes were downloaded (not too few) * Verifies md5 if response includes content-md5 header * Verifies the expected hashesThrows VerifiedDownloadException. Throws IOExceptions related to file system operations. Throws HttpException.%stackGiven a printf format string for the decimal part and a number of bytes, formats the bytes using an appropriate unit and returns the formatted string.bytesfmt "%.2" 512368"500.359375 KiB" stack destinationstackWas a downloaded performed (True) or did the file already exist (False)? stack destination stack destinationstackcustom hook to observe progressstack Whether a download was performed       Safe-Inferredp   Safe-Inferred(z stack3Convert to FilePath but don't add a trailing slash. stackCollapse intermediate "." and ".." directories from path, then parse it with %0. (probably should be moved to the Path module) stackCollapse intermediate "." and ".." directories from path, then parse it with %0. (probably should be moved to the Path module) stackAdd a relative FilePath to the end of a Path We can't parse the FilePath first because we need to account for ".." in the FilePath (#2895)%stack;Collapse intermediate "." and ".." directories from a path. collapseFilePath "./foo" == "foo" collapseFilePath "/bar/../baz" == "/baz" collapseFilePath "/../baz" == "/../baz" collapseFilePath "parent/foo/baz/../bar" == "parent/foo/bar" collapseFilePath "parent/foo/baz/../../bar" == "parent/bar" collapseFilePath "parent/foo/.." == "parent" collapseFilePath "/parent/foo/../../bar" == "/bar"(adapted from Text.Pandoc.Shared) stackIf given file in F does not exist, ensure we have T*. This is to be used in conjunction with forgivingAbsence and  resolveFile.Previously the idiom  forgivingAbsence (resolveFile @)" alone was used, which relied on canonicalizePath throwing % when path does not exist. As it turns out, this behavior is actually not intentional and unreliable, see  .https://github.com/haskell/directory/issues/44. This was @fixed@ in version 1.2.3.0 of  directory package (now it never throws). To make it work with all versions, we need to use the following idiom: 6forgivingAbsence (resolveFile @) >>= rejectMissingFile stackSee  . stack7Convert to a lazy ByteString using toFilePath and UTF8. stack2Convert to a ByteString using toFilePath and UTF8. stack (path-io package) throws % (path package) if the directory does not exist; this function yields T. stack (path-io package) throws % (path< package) if the file does not exist; this function yields T. stack (path-io package) throws % (path< package) if the file does not exist; this function yields T. stackBase directorystackPath to resolve stackBase directorystackPath to resolve stackPath to resolve  Safe-Inferred1t stack9Find the location of a file matching the given predicate. stack>Find the location of a directory matching the given predicate.%stack9Find the location of a path matching the given predicate. stack5Find files matching predicate below a root directory.NOTE: this skips symbolic directory links, to avoid loops. This may not make sense for all uses of file finding.TODO: write one of these that traverses symbolic links but efficiently ignores loops. stackfindInParents f path applies f to path and its %s until it finds a U or reaches the root directory. stack Start here.stackPredicate to match the file.stack#Do not ascend above this directory.stackAbsolute file path. stack Start here.stack!Predicate to match the directory.stack#Do not ascend above this directory.stackAbsolute directory path.%stackChoose path type from pair.stack Start here.stackPredicate to match the path.stack#Do not ascend above this directory.stackAbsolute path. stackRoot directory to begin with.stackPredicate to match files.stack,Predicate for which directories to traverse.stackList of matching files.   Safe-Inferred   Safe-Inferred" stackLike  First Bool, but the default is False. stackLike  First Bool, but the default is True. stack Path version stackLike  -, but the temporary directory is not deleted. stack:Consume the stdout and stderr of a process feeding strict s to the consumers. Throws a ReadProcessException# if unsuccessful in launching, or ExitCodeException if the process itself fails. stack/Consume the stdout of a process feeding strict s to a consumer. If the process fails, spits out stdout and stderr as error log level. Should not be used for long-running processes or ones with lots of output; for that use  . Throws a ReadProcessException if unsuccessful. stack+Read from the process, ignoring any output. Throws a ReadProcessException exception if the process fails. stack Use the new %, but retain the working directory from the parent environment. stack*Remove a trailing carriage pure if present stackPrompt the user by sending text to stdout, and taking a line of input from stdin. stackPrompt the user by sending text to stdout, and collecting a line of input from stdin. While taking input from stdin, input echoing is disabled, to hide passwords.Convert a package identifier to a value of a string-like type. stack8Convert a package name to a value of a string-like type. stackCommandstackCommand line argumentsstackSink for stderrstackSink for stdout stackCommandstackCommand line argumentsstackSink for stdout stackCommandstackCommand line arguments ^_`R]bcd1(7)e6fg5lhijkmnop!qr"s# t$uvwxyz{|}~% &'* + ,-./0234 89:SV;<=>?@ABCDFTUGYZ[HIJKLMNOWXPQE\                               ^_`R]bcd1(7)e6fg5lhijkmnop!qr"s# t$uvwxyz{|}~% &'* + ,-./0234 89:SV;<=>?@ABCDFTUGYZ[HIJKLMNOWXPQE\                                 Safe-Inferred stackAllows adjust global options depending on their context Note: This was being used to remove ambiguity between the local and global implementation of stack init --resolver option. Now that stack init has no local --resolver this is not being used anymore but the code is kept for any similar future use cases. stack%Global options before subcommand name stack-Global options following any other subcommand stack9If argument is True, hides the option from usage and help   Safe-Inferred"? stackParser for a logging level.   Safe-Inferred"%stackMake sure that a filename with spaces in it gets the proper quotes. a  a  Safe-Inferred"%stack(Run an action, watching for file changesThe action provided takes a callback that is used to set the files to be watched. When any of those files are changed, we rerun the action again.   Safe-Inferred stackUsed in Stack.Setup for detecting libc.musl-x86_64.so.1, see comments at use site stackUsed in Stack.Setup for detecting libtinfo, see comments at use site  Safe-Inferred stackName of the Stack program.   Safe-InferredG%stackType representing exceptions thrown by functions exported by the !Options.Applicative.Builder.Extra module. stackEnable/disable flags for a :. stackEnable/disable flags for a :2, without a default case (to allow chaining with ). stack%Flag with no default of True or False stack4Flag with a Semigroup instance and a default of True stack5Flag with a Semigroup instance and a default of False stack"Enable/disable flags for any type. stackEnable/disable flags for any type, without a default (to allow chaining with ) stack Show an extra help option (e.g.  --docker-help shows help for all  --docker* args).'To actually have that help appear, use  # before executing the main parser. stack x.   Safe-Inferred" stack4An argument which accepts a list of arguments e.g. --ghc-options="-X P.hs "this"". stack2An option which accepts a list of arguments e.g. --ghc-options="-X P.hs "this"". stackAn option which accepts a command and a list of arguments e.g. --exec "echo hello world"   Safe-Inferred% stack$Does not include the current action. stack+Actions which depend on the current action. stack8Whether this action may be run concurrently with others. stackType representing permissions for actions to be run concurrently with others. stack&Type representing Stack build actions. stackThe action's unique id. stack%Actions on which this action depends. stack The action's I action, given a context. stack8Whether this action may be run concurrently with others. stack9Types representing the unique ids of Stack build actions. stack/Type representing types of Stack build actions. stack=Action for building a package's library and executables. If  taskAllInOne is V9, then this will also build benchmarks and tests. It is S when the library's benchmarks or test-suites have cyclic dependencies. stackTask for building the package's benchmarks and test-suites. Requires that the library was already built. stack+Task for running the package's test-suites. stack*Task for running the package's benchmarks.%stackType representing exceptions thrown by functions exported by the Control.Concurrent.Execute module.%stackSort actions such that those that can't be run concurrently are at the end. stackthreadsstack$keep going after one task has failedstackprogress updated   Safe-Inferred   Safe-Inferred" stack;Which packages do ghc-options on the command line apply to? stackall local targets stack$all local packages, even non-targets stack every package   Safe-Inferred"$ stackWhich packages do all and any --PROG-option options on the command line apply to? stack$All local packages that are targets. stack*All local packages (targets or otherwise). stack"All packages (local or otherwise).   Safe-Inferred" stack+Command sum type for conditional arguments. stack!Which subset of packages to build stackOnly install packages in the snapshot database, skipping packages intended for the local database. stack8Refuse to build anything in the snapshot database, see 6https://github.com/commercialhaskell/stack/issues/5272 stackHow to apply a CLI flag stackApply to all project packages which have such a flag name available. stack$Apply to the specified package only. stack5Build options that may only be specified from the CLI stack"Generate a list of --PROG-option=" argument" arguments for all PROGs. stackOnly flags set via  # #  Safe-Inferred stackParser for package:[-]flag   Safe-Inferred"% stackBuild options that may be specified in the stack.yaml or from the CLIstack&Parse ProgressBarFormat from a String.=     =      Safe-Inferred%$stackOptions for the  FinalAction  DoBenchmarksstack)Arguments passed to the benchmark programstackDisable running of benchmarksstackOptions for the  FinalAction DoTestsstack)Whether successful tests will be run gainstack$Arguments passed to the test programstackGenerate a code coverage reportstackDisable running of testsstacktest suite timeout in secondsstackWhether to allow standard inputstackHaddock Optionsstack#Arguments passed to haddock programstackBuild options that is interpreted by the build command. This is built up from BuildOptsCLI and BuildOptsMonoidstackBuild Haddock documentation?stackOptions to pass to haddockstackOpen haddocks in the browser?stack Build haddocks for dependencies?stack3Build haddocks for all symbols and packages, like cabal haddock --internalstack1Build hyperlinked source. Disable for no sources.stackBuild with flags to generate Haddock documentation suitable to upload to Hackage.stack0Install executables to user path after building?stack:Install executables to compiler tools path after building?stackFetch all packages immediately ^ Watch files for changes and automatically rebuildstack#Keep building/running after failurestack-Keep intermediate files and build directoriesstack7Force treating all local packages as having dirty filesstackTurn on tests for local targetsstackAdditional test argumentsstack$Turn on benchmarks for local targetsstackAdditional test arguments ^ Commands (with arguments) to run after a successful build ^ Only perform the configure step when buildingstack5Perform the configure step even if already configuredstack%Ask Cabal to be verbose in its buildsstackWhether to enable split-objs.stack&Which components to skip when buildingstackShould we use the interleaved GHC output when building multiple packages?stackFormat of the progress bar// Safe-Inferred/stack+Parser for test arguments. FIXME hide args Safe-InferredȃstackParser for haddock arguments.  Safe-Inferred"stack1Parser for bench arguments. FIXME hiding options! Safe-Inferred%" Safe-Inferred%stack#Interprets BuildOptsMonoid options.stack%Interprets HaddockOptsMonoid options.stack"Interprets TestOptsMonoid options.stack'Interprets BenchmarkOptsMonoid options.# Safe-Inferred"stack*Which packages do configure opts apply to?stackSee AGOTargetsstack See AGOLocalsstackSee AGOEverythingstackA specific package$ Safe-Inferred"AstackAn uninterpreted representation of Casa configuration options. Configurations may be "cascaded" using mappend (left-biased).%stack'Casa configuration enable setting name.%stack2Casa configuration repository prefix setting name.%stack9Casa configuration maximum keys per request setting name.stack/Left-biased combine Casa configurations optionsstack.Left-biased combine Casa configuration optionsstack?Decode uninterpreted Casa configuration options from JSON/YAML.% Safe-Inferred"|& Safe-Inferredtstack,The default adopts the standard proposed at  http://no-color.org/,3 that color should not be added by default if the NO_COLOR" environment variable is present.' Safe-InferredSstack#Descriptive name for compiler buildstackSuffix to use for filenames/directories constructed with compiler buildstack#Parse compiler build from a String.( Safe-InferredϮstackGHC build parser) Safe-Inferred%1stackType representing the name of an 'unqualified' component (that is, the component can be any sort - a (unnamed) main library or sub-library, an executable, etc. ).,The corresponding The Cabal-syntax type is .* Safe-Inferred"vstackType representing configuration options which support the needs of the  ,https://github.com/commercialhaskell/curatorcurator tool.stack3Packages for which Stack should ignore test suites.stackPackages for which Stack should expect building test suites to fail.stack2Packages for which Stack should ignore benchmarks.stackPackages for which Stack should expect building benchmarks to fail.stackPackages for which Stack should ignore creating Haddock documentation.stackPackages for which Stack should expect creating Haddock documentation to fail.+ Safe-InferredstackIs this package being used as a library, or just as a build tool? If the former, we need to ensure that a library actually exists. See 6https://github.com/commercialhaskell/stack/issues/2195stackThe value for a map from dependency name. This contains both the version range and the type of dependency., Safe-Inferred"IstackInformation about a package in the dependency graph, when available.stackThe package version.stack+The license the package was released under.stackThe location of the package.  - Safe-InferredstackDocker host user infostackuidstackgidstackSupplemental groupsstackFile creation mask }stackData passed into Docker container for the Docker entrypoint's usestackUIDGIDetc of host user, if we wish to perform UID/GID switch in container  . Safe-Inferredڭ stackOptions record for  stack dot and stack ls dependenciesstackInclude external dependenciesstackInclude dependencies on basestackLimit the depth of dependency resolution to (Just n) or continue until fixpointstack%Package names to prune from the graphstack'Stack TARGETs to trace dependencies forstack,Flags to apply when calculating dependenciesstack9Like the "--test" flag for build, affects the meaning of  dotTargets.stack:Like the "--bench" flag for build, affects the meaning of  dotTargets.stackUse global hints instead of relying on an actual GHC installation.  / Safe-Inferred"stackBuild of the compiler distribution (e.g. standard, gmp4, tinfo6) | Information for a file to download.stackURL or absolute file pathstack"Parse JSON in existing object for 0 Safe-Inferred"ܮstackWhich build log files to dumpstackdon't dump any logfilesstack!dump logfiles containing warningsstackdump all logfiles1 Safe-Inferredstack1Controls which version of the environment is usedstack:include local project bin directory, GHC_PACKAGE_PATH, etcstack%include the GHC_PACKAGE_PATH variablestack9set the STACK_EXE variable to the current executable namestackset the locale to C.UTF-8stack,if True, keep GHCRTS variable in environmentstackDefault  EnvSettings, which includes locals and GHC_PACKAGE_PATH.Note that this also passes through the GHCRTS environment variable. See 6https://github.com/commercialhaskell/stack/issues/3444stack;Environment settings which do not embellish the environmentNote that this also passes through the GHCRTS environment variable. See 6https://github.com/commercialhaskell/stack/issues/3444  2 Safe-Inferred93 Safe-Inferredstack5Type synonym representing caches of digests of files.4 Safe-Inferred"5 Safe-Inferred stack4Class for environment values which have a GHCVariantstack;Specialized variant of GHC (e.g. libgmp4 or integer-simple)stackStandard bindiststack Bindist that uses integer-simplestack8Bindist that uses the Haskell-native big-integer backendstackOther bindistsstack!Render a GHC variant to a String.stack(Render a GHC variant to a String suffix.stack Parse GHC variant from a String.  6 Safe-InferredRstackGHC variant parser7 Safe-Inferred"}8 Safe-Inferred9 Safe-Inferred_stackA ghc-pkg package identifier.%stack A parse fail.stack.Convenient way to parse a package name from a .stack)A parser for a package-version-hash pair.%stack4Parse an alphanumerical character, as recognised by %.stack.Get a string representation of GHC package id.stack"Get a text value of GHC package id: Safe-Inferred"stackType of config cache; Safe-Inferredlstack6Type representing information about what is installed.stackA library, including its installed package id and, optionally, its license.stackAn executable.stackType synonym representing dictionaries of package names, and a pair of in which package database the package is installed (write-only or mutable) and information about what is installed.stackType synonym representing dictionaries of package names for a project's packages and dependencies, and pairs of their relevant database (write-only or mutable) and package versions.stackType representing varieties of package databases that can provide installed packages.stackGHC's global package database.stack*An 'extra' package database, specified by extra-package-dbs.stack8The write-only package database, for immutable packages.stackThe mutable package database.stackType representing package databases that can provide installed packages.stackGHC's global package database.stackA user package database.stackType representing user (non-global) package databases that can provide installed packages.stack8A package database that a package can be installed into.stack*An 'extra' package database, specified by extra-package-dbs.stackType representing user package databases that packages can be installed into.stackThe write-only package database, formerly known as the snapshot database.stackThe mutable package database, formerly known as the local database.stackA function to yield the variety of package database for a given package database that can provide installed packages.stackA strict fold over the  of the given installed package. This will iterate on both sub and main libraries, if any.stackGet the installed Version.< Safe-Inferred= Safe-InferredstackHow to interact with lock filesstackRead and write lock filesstack&Read lock files, but do not write themstackEntirely ignore lock filesstackError out on trying to write a lock file. This can be used to ensure that lock files in a repository already ensure reproducible builds.stack Parser for > Safe-Inferred"%stack?Type representing components of a fully-resolved Cabal package.stack'Render a component to anything with an IsString instance. For  prefer .stackA function to split the given list of components into sets of the names of the named components by the type of component (sub-libraries, executables, test-suites, benchmarks), ignoring any main unnamed library component or foreign library component. This function should be used very sparingly; more often than not, you can keep/parse the components split from the start.? Safe-Inferred%1stackType synonym for a %6 constraint for all the common component fields i.e. name,  buildInfo and  qualifiedName.%stackType synonym for a % constraint which represent a virtual field, computed from the type, the NamedComponent constructor and the name.stackType synonym for a % constraint.stackType synonym for a % constraint.stackType representing information needed to build. The file gathering-related fields are lazy because they are not always needed.(The corresponding Cabal-syntax type is .stack!Corresponding to Cabal-syntax's #. The component is buildable here.stack!Corresponding to Cabal-syntax's ;. Dependencies specific to a library or executable target.stackFrom Cabal-syntax's . We only keep the legacy build tool depends that we know (from a hardcoded list). We only use the deduplication aspect of the Set here, as this field is only used for error reporting in the end. This is lazy because it's an error reporting field only.stack*Only used in file gathering. See usage in Stack.ComponentFile module.stack*Only used in file gathering. See usage in Stack.ComponentFile module.stack1Only used in file & opts gathering. See usage in Stack.ComponentFile module for fle gathering.stack*Only used in file gathering. See usage in Stack.ComponentFile module.stack*Only used in opts gathering. See usage in  Stack.Package module.stackOnly used in opts gathering.stackOnly used in opts gathering.stackOnly used in opts gathering.stackOnly used in opts gathering.stackOnly used in opts gathering.stackOnly used in opts gathering.stackOnly used in opts gathering.stackOnly used in opts gathering.%stack,Type representing the name of an executable.stack6A type representing benchmark components of a package.(The corresponding Cabal-syntax type is .stackThis is only used for gathering the files related to this component.stack7A type representing test suite components of a package.(The corresponding Cabal-syntax type is .stack7A type representing executable components of a package.(The corresponding Cabal-syntax type is .stack= 1.2.3.4, bar ^>= 1  C Safe-Inferred"%GstackAn uninterpreted representation of nix options. Configurations may be "cascaded" using mappend (left-biased).stackIs using nix-shell enabled?stackShould the nix-shell be purestack+System packages to use (given to nix-shell)stackThe path of a file containing preconfiguration of the environment (e.g shell.nix)stack1Options to be given to the nix-shell command linestack$Override parts of NIX_PATH (notably nixpkgs)stackShould we register gc roots so running nix-collect-garbage doesn't remove nix dependenciesstackNix configuration. Parameterize by resolver type to avoid cyclic dependency.stackThe system packages to be installed in the environment before it runsstackThe path of a file containing preconfiguration of the environment (e.g shell.nix)stack1Options to be given to the nix-shell command linestackShould we register gc roots so running nix-collect-garbage doesn't remove nix dependenciesstackNix enable argument name.stack$Nix run in pure shell argument name.stack*Nix packages (build inputs) argument name.stack"shell.nix file path argument name.stack6Extra options for the nix-shell command argument name.stackNIX_PATH override argument namestackAdd GC roots arg namestackLeft-biased combine Nix optionsstackLeft-biased combine Nix optionsstack0Decode uninterpreted nix options from JSON/YAML.D Safe-Inferred&stack9An argument which accepts a template name of the format  foo.hsfiles.E Safe-InferredZstack2Class for environment values which have a PlatformstackA variant of the platform, used to differentiate Docker builds from hoststack-Render a platform variant to a String suffix.stack.Relative directory for the platform identifierF Safe-Inferred" stackA project is a collection of packages. We can have multiple stack.yaml files, but only one of them may contain project information.stackA warning message to display to the user when the auto generated config may have issues.stackPackages which are actually part of the project (as opposed to dependencies).stackDependencies defined within the stack.yaml file, to be applied on top of the snapshot.stack1Flags to be applied on top of the snapshot flags.stackHow we resolve which Snapshot to usestackOverride the compiler in projectResolverstackExtra configuration intended exclusively for usage by the curator tool. In other words, this is not part of the documented and exposed Stack API. SUBJECT TO CHANGE.stackPackages to drop from the projectResolver.  G Safe-Inferred estackProject configuration information. Not every run of Stack has a true local project; see constructors below.stackNormal run: we want a project, and have one. This comes from either  SYLDefault or  SYLOverride.stack No project was found when using  SYLDefault$. Instead, use the implicit global.stack&Use a no project run. This comes from  SYLNoProject.stackYields V only if the project configuration information is for the implicit global project.H Safe-Inferred" stack.How PVP bounds should be added to .cabal files  I Safe-Inferred")1"[stack=Most recent Nightly and newest LTS version per major release.stackEither an actual resolver value, or an abstract description of one (e.g., latest nightly).%stackType representing exceptions thrown by functions exported by the Stack.Types.Resolver module.  J Safe-Inferred1"stackParser for the snapshotK Safe-Inferred"#,stackA software control system.L Safe-Inferred$stack+Location for the project's stack.yaml file.stack0Use the standard parent-directory-checking logicstack'Use a specific stack.yaml file providedstackDo not load up a project, just user configuration. Include the given extra dependencies with the resolver.stackDo not look for a project configuration, and use the implicit global.M Safe-Inferred"&(stackA bit of type safety to ensure we're talking to the right database.stackA bit of type safety to ensure we're talking to the right database.stackType representing 'pretty' exceptions thrown by functions exported by modules beginning  Stack.Storage.N Safe-Inferred)' stack=Efficiently update a set of values stored in a database tablestack?Efficiently update a list of values stored in a database table.O Safe-Inferred", stackServices from which templates can be retrieved from a repository.stack8Details for how to access a template from a remote repo.stack"an absolute path on the filesystemstacka relative path on the filesystem, or relative to the template repository. To avoid path separator conversion on Windows, the raw command-line parameter passed is also given as the first field (possibly with .hsfiles appended).stack a full URLstackA template name.%stackType representing exceptions thrown by functions exported by the Stack.Types.TemplateName module.stack8An argument which accepts a template name of the format  foo.hsfiles or foo, ultimately normalized to foo.stackAn argument which accepts a  key:value pair for specifying parameters.stack$Parse a template name from a string.stackstack.A unique hash for the immutable portions of a .stack The final source map, taking an 6 and applying all command line flags and GHC options.stackDoesn't need to be included in the hash, does not affect the source map.stackNeed to hash the compiler version _and_ its installation path. Ideally there would be some kind of output from GHC telling us some unique ID for the compiler itself.stackDoesn't need to be included in hash, doesn't affect any of the packages that get stored in the snapshot database.stackNeed to hash all of the immutable dependencies, can ignore the mutable dependencies.stackDoesn't actually need to be hashed, implicitly captured by smCompiler. Can be broken if someone installs new global packages. We can document that as not supported, _or_ we could actually include all of this in the hash and make Stack more resilient.stack Builds on an  by resolving the targets specified on the command line, potentially adding in new dependency packages in the process.stack%How a package is intended to be builtstack$Build all of the default components.stackOnly build specific componentsstack'Adds in actual compiler information to =, in particular the contents of the global package database. Invariant: a  PackageName appears in only one of the Maps.stackA source map with information on the wanted (but not actual) compiler. This is derived by parsing the  stack.yaml file for packages,  extra-deps, their configuration (e.g., flags and options), and parsing the snapshot it refers to. It does not include global packages or any information from the command line. Invariant: a  PackageName appears in either  smwProject or smwDeps, but not both.stack#Where this snapshot is loaded from.stackA view of a package installed in the global package database also could include marker for a replaced global package (could be replaced because of a replaced dependency)stack;A view of a project package needed for resolving componentsstack7A view of a dependency package, specified in stack.yamlstackShould the package be hidden after registering? Affects the script interpreter's module name import parser.stack7Needed to ignore bounds between snapshot packages See 9https://github.com/commercialhaskell/stackage/issues/3185stackFlag showing if package comes from a snapshot needed to ignore dependency bounds between such packagesstack(Settings common to dependency packages () and project packages ().stackoverrides default flagsstack7Should Haddock documentation be built for this package?stack6Returns relative directory name with source map's hashstackRoot directory for the given stack&All components available in the given stack%Version for the given 'ProjectPackageT Safe-InferredC stack"Location of the ghc-pkg executablestackAn environment which ensures that the given compiler is available on the PATHstack4Paths on the filesystem for the compiler we're usingstackghc-pkg or equivalentstackrunghcstack haddock, in I to allow deferring the lookupstack'Is this a Stack-sandboxed installation?stackThis is the version of Cabal that Stack will use to compile Setup.hs files in the build process.Note that this is not necessarily the same version as the one that Stack depends on as a library and which is displayed when running "stack ls dependencies | grep Cabal in the Stack project.stackGlobal package databasestack Output of  ghc --infostackGet the path for the given compiler ignoring any local binaries. 6https://github.com/commercialhaskell/stack/issues/1052stackGet the  from a  environmentU Safe-Inferred"DZV Safe-Inferred"(EstackFor the siGHCs field maps are deeply merged. For all fields the values from the first  SetupInfo win. Safe-InferredEWW Safe-InferredEstackFalse if using Windows.stackTrue if using Windows. Safe-Inferred"Y1%stackType representing exceptions thrown by functions exported by the Stack.Constants module.stackName of the Stack program.stack'Name of the Nix package manager commandstackExtensions used for Haskell modules. Excludes preprocessor ones.stackExtensions for modules that are preprocessed by common preprocessors.stack Name of the stack program, uppercasedstackThe filename used for the Stack project-level configuration file.stackEnvironment variable used to override the '.stack-work' relative dir.stack>Environment variable used to override the '~/.stack' location.stackEnvironment variable used to indicate XDG directories should be used.stack&Option name for the global Stack root.stack4Option name for the global Stack configuration file.stackEnvironment variable used to override the location of the Pantry storestackEnvironment variable used to indicate Stack is running in container.stackEnvironment variable used to indicate Stack is running in container. although we already have STACK_IN_NIX_EXTRA_ARGS that is set in the same conditions, it can happen that STACK_IN_NIX_EXTRA_ARGS is set to empty.stackThe comment to 'see  https://downloads.haskell.org/~ghc/7.10.1/docs/html/libraries/ghc/src/Module.html#integerPackageKey\' appears to be out of date.2See 'Note [About units]' and 'Wired-in units' at  https://gitlab.haskell.org/ghc/ghc/-/blob/master/compiler/GHC/Unit.hs.The 'wired-in packages' appear to have been replaced by those that have (e.g) #ghc-options: -this-unit-id ghc-prim-in their Cabal file because they are 'magic'.stack+Just to avoid repetition and magic strings.stackDeprecated implicit global project directory used when outside of a project.stackImplicit global project directory used when outside of a project. Normally, getImplicitGlobalProjectDir should be used instead.stack&Deprecated default global config path.stack'Default global config path. Normally, getDefaultUserConfigPath should be used instead.stack?Deprecated default global config path. Note that this will be Nothing on Windows, which is by design.stack'Default global config path. Normally, getDefaultGlobalConfigPath1 should be used instead. Note that this will be Nothing on Windows, which is by design.stack"Path where build plans are stored.stack7Path where binary caches of the build plans are stored.stackEnvironment variable that stores a variant to append to platform-specific directory names. Used to ensure incompatible binaries aren't shared between Docker builds and hoststackProvides --ghc-options for stackThe flag to pass to GHC when we want to force its output to be colorized.stack=The minimum allowed terminal width. Used for pretty-printing.stack=The maximum allowed terminal width. Used for pretty-printing.stackThe default terminal width. Used for pretty-printing when we can't automatically detect it and when the user doesn't supply one.stack9Suffix applied to an installation root to get the bin dirstack9Suffix applied to an installation root to get the doc dirstack$Suffix applied to a path to get the html directory.stack4Relative paths inside a GHC repo to the boot script.stack9Relative paths inside a GHC repo to the configure script.stack?Command applicable to GHC's configure script on Windows. See: https://gitlab.haskell.org/ghc/ghc/-/blob/master/hadrian/README.mdstack=Command applicable to GHC's configure script on macOS. See: https://gitlab.haskell.org/ghc/ghc/-/blob/master/hadrian/README.mdstackCommand applicable to GHC's configure script on non-Windows, non-macOS. See: https://gitlab.haskell.org/ghc/ghc/-/blob/master/hadrian/README.mdstackRelative paths inside a GHC repo to the Hadrian build batch script. The second path is maintained for compatibility with older GHC versions.stackRelative paths inside a GHC repo to the Hadrian build shell script The second path is maintained for compatibility with older GHC versions.stackRelative file path for a temporary GHC environment file for testsstack/File inside a dist directory to use for lockingstack3What should the default be for stack-developer-modestack3What should the default be for stack-developer-modestack.The footer to the help for Stack's subcommandsstack9The type for GitHub REST API HTTP 'Basic' authentication.stackEnvironment variable to hold credentials for GitHub REST API HTTP 'Basic' authentication.stackAlternate environment variable to hold credentials for GitHub REST API HTTP 'Basic' authentication.stack Stack root.stack Stack root.stack Stack rootstack Stack root    X Safe-Inferred"%qOstack)Newtype for non-orphan FromJSON instance.stack'Options for Docker repository or image.stackDocker volume mount.stackWhere to get the stack' executable to run in Docker containersstackDownload from official bindiststackHost's stack (linux-x86_64 only)stackDocker image's stack (versions must match)stackExecutable at given pathstackAn uninterpreted representation of docker options. Configurations may be "cascaded" using mappend (left-biased).stack,Should Docker be defaulted to enabled (does docker: section exist in the config)?stackIs using Docker enabled?stackDocker repository name (e.g. fpco/stack-build or fpco/stack-full:lts-2.8)stack&Does registry require login for pulls?stack&Optional username for Docker registry.stack&Optional password for Docker registry.stackAutomatically pull new images.stack#Whether to run a detached containerstackCreate a persistent container (don't remove it when finished). Implied by --  dockerDetach.stackContainer name to use, only makes sense from command-line with  dockerPersist or  dockerDetach.stackSee:  dockerNetworkstackArguments to pass directly to  docker runstack!Volumes to mount in the containerstackVolume mount modestack-Environment variables to set in the containerstack1Location of container-compatible Stack executablestack%Set in-container user to match host'sstackSee: dockerRequireDockerVersionstackDocker configuration.stackIs using Docker enabled?stack;Exact Docker image tag or ID. Overrides docker-repo-*/tag.stack&Does registry require login for pulls?stack&Optional username for Docker registry.stack&Optional password for Docker registry.stackAutomatically pull new images.stack#Whether to run a detached containerstackCreate a persistent container (don't remove it when finished). Implied by  dockerDetach.stackContainer name to use, only makes sense from command-line with  dockerPersist or  dockerDetach.stackThe network docker uses.stackArguments to pass directly to  docker run.stack"Volumes to mount in the container.stackVolume mount modestack.Environment variables to set in the container.stack1Location of container-compatible Stack executablestack%Set in-container user to match host'sstack.Require a version of Docker within this range.stackType representing exceptions thrown by functions exported by the  Stack.Docker module.stack*Docker must be enabled to use the command.stack4Command must be run on host OS (not in a container).stackdocker inspect failed.stackImage does not exist.stackInvalid output from  docker images.stackInvalid output from  docker ps.stackInvalid output from docker inspect.stackCould not pull a Docker image.stackInstalled version of docker below minimum version.stackInstalled version of docker is prohibited.stackInstalled version of docker* is out of range specified in config file.stackInvalid output from docker --version.stack Version of stack) on host is too old for version in image.stack Version of stack3 in container/image is too old for version on host.stack?Can't determine the project root (where to put docker sandbox).stackdocker --version failed.stack-Using host stack-exe on unsupported platform.stack stack-exe option fails to parse.stackParse .stackDocker enable argument name.stackDocker repo arg argument name.stackDocker image argument name.stack$Docker registry login argument name.stack'Docker registry username argument name.stack'Docker registry password argument name.stackDocker auto-pull argument name.stackDocker detach argument name.stackDocker run args argument name.stackDocker mount argument name.stack Docker mount mode argument name.stack*Docker environment variable argument name.stack$Docker container name argument name.stack$Docker container name argument name.stackDocker persist argument name.stack&Docker Stack executable argument name.stack Value for --docker-stack-exe=downloadstack Value for --docker-stack-exe=hoststack Value for --docker-stack-exe=imagestackDocker set-user argument namestackDocker require-version argument namestackArgument name used to pass docker entrypoint data (only used internally)stack"Command-line argument for "docker"stackCommand-line argument for  docker pull.stackCommand-line option for --internal-re-exec-version.stack#Platform that Docker containers runstack For YAML.stackShow instance.stackFor optparse-applicative.stack"Left-biased combine Docker optionsstack"Left-biased combine Docker optionsstackParse VersionRange.stack3Decode uninterpreted docker options from JSON/YAML.Y Safe-Inferred"%}stackAn uninterpreted representation of configuration options. Configurations may be "cascaded" using mappend (left-biased).stackSee:  clStackRootstackSee:  configWorkDir.stackbuild options.stackDocker options.stack>Options for the execution environment (nix-shell or container)stackSee: configConnectionCountstackSee: configHideTHLoadingstackSee: configPrefixTimestampsstackSee: configLatestSnapshotstackSee: stack%Deprecated in favour of package-indexstackSee: configSystemGHCstackSee: configInstallGHCstackSee: configSkipGHCCheckstackSee: configSkipMsysstackSee: configCompilerCheckstackSee: configCompilerRepositorystackSee: configRequireStackVersionstack Used for overriding the platformstack Used for overriding the platformstack!Used for overriding the GHC buildstackSee:  configJobsstackSee: configExtraIncludeDirsstackSee: configExtraLibDirsstackSee: configCustomPreprocessorExtsstack'Allow users to override the path to gccstack.Use Hpack executable (overrides bundled Hpack)stackSee: configConcurrentTestsstack,Used to override the binary installation dirstackTemplate parameters.stack8Initialize SCM (e.g. git init) when making new projects?stackSee configGhcOptionsByName. Uses % so that options from the configs on the right come first, so that they can be overridden.stackSee configGhcOptionsAll. Uses % so that options from the configs on the right come first, so that they can be overridden.stackSee configCabalConfigOpts.stack-Additional paths to search for executables instackSee configSetupInfoLocationsstackSee configSetupInfoInlinestackOverride the default local programs dir, where e.g. GHC is installed.stackSee configPvpBoundsstackSee configModifyCodePagestackSee configMonoidRebuildGhcOptionsstackSee configApplyGhcOptionsstackSee configApplyProgOptionsstackSee configMonoidAllowNewerstackSee configMonoidAllowNewerDepsstackThe default template to use when none is specified. (If Nothing, the  'default' default template is used.)stackAllow users other than the Stack root owner to use the Stack installation.stackSee configDumpLogsstackSee configSaveHackageCredsstackSee configHackageBaseUrlstack When to use ANSI colorsstackSee configHideSourcePathsstackSee configRecommendUpgradestackSee configNotifyIfNixOnPathstackSee configNotifyIfGhcUntestedstackSee configNotifyIfCabalUntestedstackSee configNotifyIfArchUnknownstackCasa configuration options.stack$Casa repository prefix (deprecated).stack(Custom location of LTS/Nightly snapshotsstackSee: configNoRunCompilestackSee configStackDeveloperModestackParse a partial configuration. Used both to parse both a standalone config file and a project file, so that a sub-parser is not required, which would interfere with warnings for missing fields.Z Safe-Inferred"[ Safe-Inferredstack*Parsed global command-line options monoid.stack%Expected re-exec in container versionstackData used when Stack is acting as a Docker entrypoint (internal use only)stack Log levelstack#Whether to include timings in logs.stack4Whether to include raw snapshot layer (RSL) in logs.stackWhether to include debug information about the construction of the build plan in logs.stack Config monoid, for passing into  loadConfigstackResolver overridestack)root directory for resolver relative pathstackCompiler overridestackWe're in a terminal?stackStack's output stylesstackTerminal width overridestackOverride project stack.yamlstackSee globalLockFileBehavior\ Safe-Inferred&stack#Parsed global command-line options.stack%Expected re-exec in container versionstackData used when Stack is acting as a Docker entrypoint (internal use only)stack Log levelstack#Whether to include timings in logs.stack4Whether to include raw snapshot layer (RSL) in logs.stackWhether to include debug information about the construction of the build plan in logs.stack Config monoid, for passing into  loadConfigstackResolver overridestackCompiler overridestackWe're in a terminal?stackSGR (Ansi) codes for stylesstackTerminal width overridestackOverride project stack.yaml] Safe-Inferred%nstackGet the URL to request the information on the latest snapshots%stack STACK_ROOT/hooks/stack STACK_ROOT/hooks/ghc-install.shstack  ".stack-work"stack3In dev mode, print as a warning, otherwise as debugb Safe-Inferred)1#stackA superset of  adding information on how to build code. The reason for this breakdown is because we will need some of the information from ' in order to determine the values here.These are the components which know nothing about local configuration.stackExtra package databasesstack Location of the stack.yaml file.Note: if the STACK_YAML environment variable is used, this may be different from projectRootL  /0 "stack.yaml" if a different file name is used.stack3Database connection pool for project Stack databasestack2Directory containing the project's stack.yaml filestackPer-project work dirstackThe compiler specified by the  SnapshotDef7. This may be different from the actual compiler used!c Safe-Inferred1stackFiles that the package depends on, relative to package directory.stackThis is the information from Cabal we need at the package level to track files.stack(Warning generated when reading a packagestackModules found that are not listed in Cabal file TODO: bring this back - see 6https://github.com/commercialhaskell/stack/issues/2649stack?A descriptor from a Cabal file indicating one of the following:=exposed-modules: Foo other-modules: Foo or main-is: Foo.hsstackA path resolved from the Cabal file, which is either main-is or an exposedinternalreferenced module.d Safe-Inferredestack3Configuration after the environment has been setup.stackDirectory containing snapshotsstack"Installation root for dependenciesstackInstallation root for localsstackGet the hoogle database path.stackPath for platform followed by snapshot name followed by compiler name.stack6Relative directory for the platform and GHC identifierstack$Installation root for compiler toolsstackHoogle directory.stack1Package database for installing dependencies intostack3Package database for installing local packages intostackExtra package databasesstack+Where HPC reports and tix files get stored.stackGet the extra bin directories (for the PATH). Puts more local first3Bool indicates whether or not to include the localsstackThe version of the compiler which will actually be used. May be different than that specified in the  SnapshotDef and returned by wantedCompilerVersionL.stackRelative directory for the platform and GHC identifier without GHC bindist build%stackRelative directory for the platform and GHC identifier without GHC bindist build (before parsing into a Path)stackThis is an attempt to shorten Stack paths on Windows to decrease our chances of hitting 260 symbol path limit. The idea is to calculate SHA1 hash of the path used on other architectures, encode with base 16 and take first 8 symbols of it.  e Safe-Inferred"%19stackType representing inputs to t.stack:Information on a locally available package of source code.stackThe Package info itself, after resolution with package flags, with tests and benchmarks disabledstack9Components to build, not including the library component.stackComponents explicitly requested for build, that are marked "buildable: false".stack+Whether this package is wanted as a target.stackThis stores the  with tests and benchmarks enabled, if either is asked for by the user.stack Absolute path to the Cabal file.stack6Is Haddock documentation being built for this package?stackNothing == not dirty, Just == dirty. Note that the Set may be empty if we forced the build to treat packages as dirty. Also, the Set may not include all modified files.stackcurrent state of the filesstackall files used by this packagestackWhere the package's source is located: local directory or package indexstack%Package which exist on the filesystemstack%Package which is downloaded remotely.stackPackage build configurationstackAre tests enabled?stackAre benchmarks enabled?stackConfigured flags.stackConfigured ghc options.stack./Setup.hs configure optionsstack GHC versionstack host platformstack7GHC options based on cabal information and ghc-options.stackThese options can safely have < applied to them, as there are no multi-word options (see 7https://github.com/commercialhaskell/stack/issues/1255)stackSome package info.stackName of the package.stackVersion of the packagestack+The license the package was released under.stackGhc options used on package.stack1Additional options passed to ./Setup.hs configurestackFlags used on package.stackDefaults for unspecified flags.stack6Does the package have a buildable main library stanza?stack!The sub-libraries of the package.stack%The foreign libraries of the package.stackThe test suites of the package.stackThe benchmarks of the package.stackThe executables of the package.stackPackage build-type.stack%If present: custom-setup dependenciesstackCabal spec rangestackThe Cabal sourced files related to the package at the package level The components may have file information in their own typesstackThis is a requirement because when tests are not enabled, Stack's package dependencies should ignore test dependencies. Directly set from packageConfigEnableTests.stackThis is a requirement because when benchmark are not enabled, Stack's package dependencies should ignore benchmark dependencies. Directly set from packageConfigEnableBenchmarks.stackName of an executable.stackType representing exceptions thrown by functions exported by the  Stack.Package module.stack5Maybe get the module name from the .cabal descriptor.stack3Maybe get the main name from the .cabal descriptor.stackGet the module path.stackGet the main path.stackGet the c file path.stack Get the path.stack9Gathers all the GhcPkgId provided by a library into a map%stack Creates a  identifier.stackCompares the package name.stackCompares the package name.f Safe-Inferred%g Safe-Inferred"stackChecks if the installed executable will be available on the user's PATH. This doesn't use envSearchPath menv because it includes paths only visible when running in the Stack environment. Safe-Inferred%%h Safe-Inferred"%istackType representing exceptions thrown by functions exported by the Stack.Config.Docker module.stack7Only LTS resolvers are supported for default image tag.stack4Add a default Docker tag name to a given base image.stack$Interprets DockerOptsMonoid options.stackbasei Safe-Inferred"Dstack3Configure options to be sent to Setup.hs configure.stackOptions related to various paths. We separate these out since they do not have an effect on the contents of the compiled binary for checking if we can use an existing precompiled cache.stack(Options other than path-related options.stackBasic information used to calculate what the configure options arestack Render a BaseConfigOpts to an actual list of optionsstackSame as -, but does not include directory path optionsstack dependenciesstacklocal non-extra-dep?stack Dependencies.stackIs this a local, non-extra-dep?j Safe-Inferred"%1#stackspecial marker for expected failures in curator builds, using those we need to keep log handle open as build continues further even after a failurestackInformation on a compiled package: the library .conf file (if relevant), the sub-libraries (if present) and all of the executable paths.stack&.conf file inside the package databasestack.conf file inside the package database, for each of the sub-librariesstackFull paths to executablesstack:A complete plan of what needs to be built and how to do itstack0Final actions to be taken (test, benchmark, etc)stack4Text is reason we're unregistering, for display onlystack>Executables that should be installed after successful buildingstackType representing different types of task, depending on what is to be built.stackBuilding local source code.stack5Building something from the package index (upstream).stackGiven the IDs of any missing packages, produce the configure optionsstack4Dependencies for which we don't yet have an GhcPkgIdstack.Produce the list of options given the missing GhcPkgIdsstack3A type representing tasks to perform when building.stack+The task type, telling us how to build thisstack;A set of the package identifiers of dependencies for which  are missing and a function which yields configure options, given a dictionary of those identifiers and their .stackA dictionary of the package identifiers of already-installed dependencies, and their .stack3indicates that the package can be built in one stepstackIs the build type of this package Configure. Check out ensureConfigureScript in Stack.Build.Execute for the motivationstack6Stored on disk to know whether the flags have changed.stack2All Cabal configure options used for this package.stackThe GhcPkgIds of all of the dependencies. Since Cabal doesn't take the complete GhcPkgId (only a PackageIdentifier) in the configure options, just using the previous value is insufficient to know if dependencies have changed.stackThe components to be built. It's a bit of a hack to include this in here, as it's not a configure option (just a build option), but this is a convenient way to force compilation when the components change.stackAre haddocks to be built?stack Value of the PATH env var, see 6https://github.com/commercialhaskell/stack/issues/3138stack6Stored on disk to know whether the files have changed.stackModification times of files.%stackPackage dependency oracle.stack%Were any of the dependencies missing?stackRecommend adding to extra-deps, give a helpful version number?stackType representing exceptions thrown by functions exported by modules with names beginning  Stack.Build.stackHelper function to pretty print an error message for target parse errors.&stackGet the shortest reason for the package to be in the build plan. In other words, trace the parent dependencies back to a wanted package.,,n Safe-Inferred"(1{stacke.g. ghc-7.8.4, msys2-20150512stacke.g. ghc-git-COMMIT_ID-FLAVOURstack2Binary directories for the given installed packagestack# values are ordered by name (being ghc-git, for ToolGhcGit _ _) alphabetically and then by version (later versions are ordered before earlier versions, where applicable).stackpackage to findstackwhich versions are acceptablestacktools to filterstack executableo Safe-Inferred"stackOutput .o/.hi directory.stackGHCi files directory.stackThe directory containing the files used for dirtiness check of source files.stack4The filename used to mark tests as having succeeded.stack0The filename used to mark tests as having built.stack9The filename used for modification check of a Cabal file.stack9The filename used for modification check of setup-config.stackThe filename used for the project root from the last build of a package.stackDirectory for HPC work.stack,Relative location of directory for HPC work.stack3Package's setup-config storing Cabal configuration.stack$Package's build artifacts directory.stackThe directory containing all dist directories, including all different platform/compiler combinations.&stackRelative directory to the top dist directory, containing individual platform/compiler combinations as subdirs.stackPackage's working directory.stack Directory for project templates.stack%Relative location of build artifacts.stack!Docker sandbox from project root.stack$Image staging dir from project root. stackPackage directory.stackPackage directorystackPackage directorystackPackage directory.stackPackage directory.stackPackage directory.stackPackage directory.stack Project rootstackDocker sandboxstack Project rootstackIndex of imagestackDocker sandboxp Safe-Inferred"%I&stackType representing exceptions thrown by functions exported by the Stack.Config.Nix module.&stack=Nix can't be given packages and a shell file at the same timestack!Interprets NixOptsMonoid options.q Safe-Inferred"|r Safe-Inferred"1stack*Get all files referenced by the benchmark.stack%Get all files referenced by the test.stack+Get all files referenced by the executable.stackGet all files referenced by the library. Handle all libraries (CLib and SubLib), based on empty name or not.&stack*Get all files referenced by the component.&stackTry to resolve the list of base names in the given directory by looking for unique instances of base names applied with the given extensions, plus find any of their module and TemplateHaskell dependencies.&stack.Get the dependencies of a Haskell module file.&stackParse a .hi file into a set of modules and files (a map from a given path to a file to the resolved absolute path to the file).stackThe directory where generated files are put like .o or .hs (from .x files).&stackTry to resolve the list of base names in the given directory by looking for unique instances of base names applied with the given extensions.&stackFind a candidate for the given module-or-filename from the list of directories and given extensions.&stackLog that we couldn't find a candidate, but there are possibilities for custom preprocessor extensions.For example: .erb for a Ruby file might exist in one of the directories.&stack4Get all C sources and extra source files in a build.&stackResolve file as a child of a specified directory, symlinks don't get followed.&stackWarn the user that multiple candidates are available for an entry, but that we picked one anyway and continued.&stack&Parse a package name from a file path.&stackResolve the directory, if it can't be resolved, warn for the user (purely to be helpful).stack;Make the global autogen dir if Cabal version is new enough.stackMake the autogen dir.stack5Make the build dir. Note that Cabal >= 2.0 uses the  above for some things.stackSee &stackPackage component namestackDirectories to look in.stack Base names.&stackKnown file usages, where the file path has already been resolved.&stackKnown file usages, where the file path has already been resolved.stack&The path to the *.hi file to be parsed&stackDirectories to look in.stack Base names.s Safe-Inferred"&stackResolve the file, if it can't be resolved, warn for the user (purely to be helpful).&stack(Get all files referenced by the package.&stack>Resolve globbing of files (e.g. data files) to absolute paths.stackGets all of the modules, files, build files, and data files that constitute the package. This is primarily used for dirtiness checking during build, as well as use by "stack ghci"&stackCabal file versiont Safe-Inferred"%1 stackRead  package .buildinfo ancillary files produced by some Setup.hs hooks. The file includes Cabal file syntax to be merged into the package description derived from the package's Cabal file.NOTE: not to be confused with BuildInfo, an Stack-internal datatype.stack#Resolve a parsed Cabal file into a , which contains all of the info needed for Stack to build the ! given the current configuration.stackThis is an action used to collect info needed for "stack ghci". This info isn't usually needed, so computation of it is deferred.&stackGenerate GHC options for the package's components, and a list of options which apply generally to the package, not one specific component.&stackGenerate GHC options for the target. Since Cabal also figures out these options, currently this is only used for invoking GHCI (via stack ghci).&stackMake the .o path from the .c file path for a component. Example: 7executable FOO c-sources: cbits/text_search.c Produces dist-dirbuildFOOFOO-tmpcbits/text_search.oExample:,> makeObjectFilePathFromC $(mkAbsDir "UserschrisRepos$hoogle") CLib $(mkAbsDir "UserschrisReposhoogle .stack-work%Cabal-x.x.x/dist") $(mkAbsFile "UserschrisReposhooglecbitstext_search.c") Just "UserschrisReposhoogle .stack-work Cabal-x.x.xdistbuildcbits makeObjectFilePathFromC $(mkAbsDir "UserschrisRepos/hoogle") (CExe "hoogle") $(mkAbsDir "UserschrisReposhoogle .stack-work%Cabal-x.x.x/dist") $(mkAbsFile "UserschrisReposhooglecbitstext_search.c") Just "UserschrisReposhoogle .stack-work Cabal-x.x.xdistbuildhoogle hoogle-tmpcbitstext_search.o" >stack=Get all dependencies of the package (buildable targets only).&stack Variant of  allBuildInfo from Cabal that, like versions before Cabal 2.2 only includes buildable components.stackEvaluates the conditions of a &, yielding a resolved &.&stack.Make a map from a list of flag specifications.What is  flagManual for?&stack Generic a ResolveConditions using sensible defaults.&stack+Resolve the condition tree for the library.stack!Path for the package's build log.stack;Force a package to be treated as a custom build type, see 6https://github.com/commercialhaskell/stack/issues/4488stack:Check if the package has a main library that is buildable.stack2Check if the main library has any exposed modules.This should become irrelevant at some point since there's nothing inherently wrong or different with packages exposing only modules in internal libraries (for instance).stackAggregate all unknown tools from all components. Mostly meant for build tools specified in the legacy manner (build-tools:) that failed the hard-coded lookup. See ? for more information.&stackApply a generic processing function in a Monad over all of the Package's components.&stackThis is a function to iterate in a monad over all of a package's dependencies, and yield a collection of results (used with list and set).&stackThis is a function to iterate in a monad over all of a package component's dependencies, and yield a collection of results.stackIterate/fold on all the package dependencies, components, setup deps and all.stackList all package's dependencies in a "free" context through the identity monad.stack"The set of package's dependencies.stackThis implements a topological sort on all targeted components for the build and their dependencies. It's only targeting internal dependencies, so it's doing a topological sort on a subset of a package's components.Note that in Cabal they use the Data.Graph struct to pursue the same goal. But dong this here would require a large number intermediate data structure. This is needed because we need to get the right GhcPkgId of the relevant internal dependencies of a component before building it as a component.&stack:Packages to omit from the "-package" / "-package-id" flagsstack'Packages to add to the "-package" flags&stackThe cabal directory.stackThe name of the component.stackDist directory.stackThe path to the .c file.stack*The path to the .o file for the component.&stackCompiler versionstackinstallation target platformstack enabled flagsstackglobal Cabal version&stack2Processing function with all the component's info.stackInitial value.stackInclude directTarget or not. False here means we won't include the actual targets in the result, only their deps. Using it with False here only in GHCi88u Safe-Inferred+stackWarn about tools in the snapshot definition. States the tool name expected and the package name using it.stackState to be maintained during the calculation of local packages to unregister.stackType representing values used as the environment to be read from during the construction of a build plan (the 'context').stack5Basic information used to determine configure optionsstackA dictionary of package names, and combined information about the package in respect of whether or not it is already installed and, unless the package is not to be built (global packages), where its source code is located.stack3Configuration after the environment has been setup.stackType representing results of addDep.stack5A task must be performed to provide the package name.stack3An existing installation provides the package name.stackType representing values used as the output to be collected during the construction of a build plan.stackA dictionary of package names, and either a final task to perform when building the package or an exception.stackA dictionary of executables to be installed, and location where the executable's binary is placed.stackA dictionary of local packages, and the reason why the local package is considered dirty.stack Warnings.stackA dictionary of package names, and a list of pairs of the identifier of a package depending on the package and the version range specified for the dependency by that package. Used in the reporting of failure to construct a build plan.stackType synonym representing values used during the construction of a build plan. The type is an instance of ', hence its name.stackA type synonym representing dictionaries of package names, and combined information about the package in respect of whether or not it is already installed and, unless the package is not to be built (global packages), where its source code is located.stackType representing information about packages, namely information about whether or not a package is already installed and, unless the package is not to be built (global packages), where its source code is located.stackThis indicates that the package is already installed, and that we shouldn't build it from source. This is only the case for global packages.stackThis indicates that the package isn't installed, and we know where to find its source.stackThis indicates that the package is installed and we know where to find its source. We may want to reinstall from source.%%v Safe-Inferred"qstack$Hpack version we're compiled againststackIf 1 is enabled, the Git hash in the build directory, otherwise Nothing.w Safe-Inferred" stack2Determine whether we should haddock for a package.stack5Determine whether to build haddocks for dependencies.stack7Generate Haddock index and contents for local packages.stackGenerate Haddock index and contents for local packages and their dependencies.stack>Generate Haddock index and contents for all snapshot packages.&stack;Generate Haddock index and contents for specified packages.&stack,Find first DumpPackage matching the GhcPkgId&stackPath of haddock index file.&stack/Path of local packages documentation directory.&stackPath of documentation directory for the dependencies of local packages&stack2Path of snapshot packages documentation directory.&stackGenerate an archive file containing local Haddock documentation for Hackage, in a form accepted by Hackage.stack>Available packages and their locations for the current projectstackBuild targets as determined by stackPackages that we want to generate haddocks for in any case (whether or not we are going to generate haddocks for dependencies)stackLocal package dumpstackGlobal dump informationstackSnapshot dump informationstackLocal dump informationstackGlobal package dumpstackSnapshot package dump&stackThe package directory.stackThe package name and version.&stackFull path to archive filestackBase directorystack0Directory to archive, relative to base directoryx Safe-Inferred"1&stackStatus of a test suite&stack=Directory containing files to mark an executable as installedstack$Get all of the installed executablesstack&Mark the given executable as installedstack*Mark the given executable as not installedstackTry to read the dirtiness cache for the given package directory. stackTry to read the dirtiness cache for the given package directory. stack>Try to read the mod time of the Cabal file from the last build stackTry to read the mod time of setup-config file from the last build stack=Try to read the project root from the last build of a package stack3Write the dirtiness cache for this package's files. stack;Write the dirtiness cache for this package's configuration. stackSee  stackSee  stackSee  stack"Delete the caches for the project. stack7Loads the flag cache for the given installed extra-deps stackMark test suite status stack&Check if the test suite already passed&stackThe key containing information on the given package/configuration combination. The key contains a hash of the non-directory configure options for quick lookup if there's a match.We only pay attention to non-directory options. We don't want to avoid a cache hit just because it was installed in a different directory. stack1Write out information about a newly built package stackCheck the cache for a precompiled package matching the given configuration.&stackbuild haddocks stackbuild haddocksstacklibrarystack executables stacktarget packagestackbuild haddocks        y Safe-Inferred")1, &stack7Selector for picking the right package DB to modify as modify> changes the first database that contains a specific package.&stackA stack of package databases. Convention: head is the topmost in the stack.&stackEither an exact ', or a glob for all packages matching b.&stackRepresents how a package may be specified by a user on the command line.&stack-A package identifier foo-0.1, or a glob foo-*&stackAn installed package ID foo-0.1-HASH. This is guaranteed to uniquely match a single entry in the package database.&stackA glob against the package name. The first string is the literal glob, the second is a function which returns True if the argument matches.&stack$Enum flag representing argument type&stackType representing 'pretty' exceptions thrown by functions exported by the GHC.Utils.GhcPkg.Main.Compat module. stackFunction equivalent to: ghc-pkg --no-user-package-db --package-db= unregister [--ipid]

 stack#Path to the global package databasestackPath to the package databasestack'Apply ghc-pkg's --ipid, --unit-id flag?stackPackages to unregister&stack$Path to the global package database.stackPath to the package database.&stack$Path to the global package database.stackPath to the package database.  z Safe-Inferred"12F stackGet the global package database stackRun the ghc-pkg executable stackCreate a package database in the given directory, if it doesn't exist. stack=Get the environment variable to use for the package DB paths.&stackGet the necessary ghc-pkg flags for setting up the given package database stack(Get the value of a field of the package. stackunregister list of package ghcids, batching available from GHC 8.2.1, see  https://github.com/commercialhaskell/stack/issues/2662#issuecomment-4603424025 using GHC package id where available (from GHC 7.9)The version of the ghc-pkg executable supplied with GHCs published before 28 August 2023 does not efficiently bulk unregister. Until an  efficient5 ghc-pkg is available, this function no longer uses:  eres <- ghcPkg pkgexe [pkgDb] args where args = "unregister" : "--user" : "--force" : map packageIdentifierString idents ++ if null gids then [] else "--ipid" : map ghcPkgIdString gids but uses:  globalDb <- view $ compilerPathsL.to cpGlobalDB eres <- tryAny $ liftIO $ ghcPkgUnregisterUserForce globalDb pkgDb hasIpid pkgarg_strs stack"Get the value for GHC_PACKAGE_PATH stackpackage databasesstackpackage identifier, or GhcPkgId stack%Report pretty exceptions as warnings?stackpackage database  { Safe-Inferred"9 stack2A single line of input, not including line endings&stackType representing exceptions thrown by functions exported by the Stack.PackageDump module. stackCall  ghc-pkg dump with appropriate flags and stream to the given sink, using either the global package database or the given package databases. stackCall ghc-pkg describe with appropriate flags and stream to the given sink, using either the global package database or the given package databases.&stackCall ghc-pkg and stream to the given sink, using the either the global package database or the given package databases. stackPrune a list of possible packages down to those whose dependencies are met.id uniquely identifies an item$There can be multiple items per name stackFind the package IDs matching the given constraints with all dependencies installed. Packages not mentioned in the provided Map are allowed to be present too. stack+Convert a stream of bytes into a stream of  DumpPackages stackApply the given Sink to each section of output, broken by a single line containing --- stackGrab each key/value pair&stackGeneral purpose utility stackA list of package databases. If empty, use the global package database.stackSink. stackA list of package databases. If empty, use the global package database.stackSink.&stackA list of commands.stackA list of package databases. If empty, use the global package database.stackSink. stackextract the name from an idstackthe id of an itemstackget the dependencies of an itemstack(choose the desired of two possible itemsstack input items stackallowed versions    | Safe-Inferred"%<< stack Create a ' from a directory containing a package. stack Create a  from a , from some additional to a snapshot setting (extra-deps or command line) stack=Simple cond check for boot packages - checks only OS and Arch stack6Should Haddock documentation be built for the package? stack6Should Haddock documentation be built for the package? stack6Should Haddock documentation be built for the package? stack6Should Haddock documentation be build for the package?    } Safe-Inferred"=&stackType representing 'pretty' exceptions thrown by functions exported by the  Stack.Lock module. ~ Safe-Inferred"%)1C stackType representing exceptions thrown by functions exported by the Stack.BuildPlan module.&stackFind the set of FlagNames necessary to get the given GenericPackageDescription to compile against the given  BuildPlan. Will only modify non-manual flags, and will prefer default values for flags. Returns the plan which produces least number of dep errors&stackCheck whether with the given set of flags a package's dependency constraints can be satisfied against a given build plan or pool of packages.&stackChecks if the given package dependencies can be satisfied by the given set of packages. Will fail if a package is either missing or has a version outside of the version range.&stack Combine two  s for the same ].&stack&Given a bundle of packages (a list of GenericPackageDescriptions's) to build and an available package pool (snapshot) check whether the bundle's dependencies can be satisfied. If flags is passed as Nothing flag settings will be chosen automatically.&stackCompare  , where GT means a better plan. stackCheck a set of &s and a set of flags against a given snapshot. Returns how well the snapshot satisfies the dependencies of the packages. stackFind a snapshot and set of flags that is compatible with and matches as best as possible with the given &s.&stack6package using dependencies, for constructing DepErrorsstackdependency constraintsstackAvailable package pool or index   Safe-Inferred "%()1G &stack#Was a concrete component specified?&stack)Only if we're adding this as a dependency stackRaw command line input, without checking against any databases or list of locals. Does not deal with directories stackEither a fully resolved component, or a component name that could be either an executable, test, or benchmark&stackThe name of a component, which applies to executables, test suites, and benchmarks&stack2Raw target information passed on the command line. stackDo we need any targets? For example, `stack build` will fail if no targets are provided.&stackSame as parseRawTarget*, but also takes directories into account. stackIf this function returns Nothing., the input should be treated as a directory.&stack Convert a   into a &" (see description on the module).&stackcurrent directorystack+raw target information from the commandline       Safe-Inferred"%P% stack"loads and returns project packages stackloads all local dependencies - project packages and local extra-deps stackGiven the parsed targets and build command line options constructs a source map stackGet a  for a given  Basic rules:If someone modifies a GHC installation in any way after Stack looks at it, they voided the warranty. This includes installing a brand new build to the same directory, or registering new packages to the global database.We should include everything in the hash that would relate to immutable packages and identifying the compiler itself. Mutable packages (both project packages and dependencies) will never make it into the snapshot database, and can be ignored.Target information is only relevant insofar as it effects the dependency map. The actual current targets for this build are irrelevant to the cache mechanism, and can be ignored.Make sure things like profiling and haddocks are included in the hash stackAll flags for a local package.&stackGet the options to pass to ./Setup.hs configure&stackGet the configured options to pass from GHC, based on the build configuration and commandline. stack9Upgrade the initial project package info to a full-blown  LocalPackage" based on the selected components&stackCompare the current filesystem state to the cached information, and determine (1) if the files are dirty, and (2) the new cache values. stackReturns entries to add to the build cache for any newly found unlisted modules&stackGets list of Paths for files relevant to a set of components in a package. Note that the library component, if any, is always automatically added to the set of components.&stackGet file digest, if it exists&stackGet  for package given its name.&stack old cachestackfiles in package&stack GHC optionsstackcabal config opts   Safe-Inferred"%(h stack;Computes a build plan. This means figuring out which build 6s to take, and the interdependencies among the build s. In particular:1) It determines which packages need to be built, based on the transitive deps of the current targets. For local packages, this is indicated by the lpWanted< boolean. For extra packages to build, this comes from the  extraToBuild0 argument of type Set PackageName. These are usually packages that have been specified on the command line.2) It will only rebuild an upstream package if it isn't present in the ., or if some of its dependencies have changed.3) It will only rebuild a local package if its files are dirty or some of its dependencies have changed.&stackDetermine which packages to unregister based on the given tasks and already registered local packages.&stackGiven a  and its  lpTestBench , adds a ' for running its tests and benchmarks.If  isAllInOne is V, then this means that the build step will also build the tests. Otherwise, this indicates that there's a cyclic dependency and an additional build step needs to be done.This will also add all the deps needed to build the tests / benchmarks. If  isAllInOne is V (the common case), then all of these should have already been taken care of as part of the build step.&stackGiven a b, adds all of the build tasks to build the package, if needed. First checks if the package name is in the library map. 3 invokes this on all the target packages, setting  treatAsDep'= to False, because those packages are direct build targets. & invokes this while recursing into the dependencies of a package. As such, it sets  treatAsDep' to True, forcing this package to be marked as a dependency, even if it is directly wanted. This makes sense - if we left out packages that are deps, it would break the --only-dependencies build plan.&stackGiven a b, known not to be in the library map, adds all of the build tasks to build the package. First checks that the package name is not already in the call stack.&stackGiven a b and its  from the combined map, adds all of the build tasks to build the package. Assumes that the head of the call stack is the current package name.&stack For given b and < values, adds relevant executables to the collected output.&stack For a given b value, known to be immutable, adds relevant executables to the collected output.&stack For given  and  values, adds relevant executables to the collected output. In most cases, the relevant executables are all the executables of the package. If the package is a wanted local one, the executables are those executables that are wanted executables.&stackGiven a  and perhaps an  value, adds build 's for the package and its dependencies.&stack'Checks if we need to install the given , given the results of &. If dependencies are missing, the package is dirty, or it's not installed, then it needs to be installed.&stack*Is the build type of the package Configure&stackGiven a package, recurses into all of its dependencies. The resulting triple indicates: (1) which packages are missing. This means that their s will be figured out during the build, after they've been built; (2) the packages that are already installed and which will be used; and (3) whether the package itself is mutable or immutable.&stackGiven a dependency, yields either information for an error message or a triple indicating: (1) if the dependency is to be installed, its package identifier; (2) if the dependency is installed and a library, its package identifier and ; and (3) if the dependency is, or will be when installed, mutable or immutable.&stack,Function to determine whether the result of & is within range, given the version range of the dependency and taking into account Stack's  allow-newer configuration.&stackGiven a result of &, yields a triple indicating: (1) if the dependency is to be installed, its package identifier; (2) if the dependency is installed and a library, its package identifier and ; and (3) if the dependency is, or will be when installed, mutable or immutable.&stackFor the given package, warn about any unknown tools that are not on the PATH and not one of the executables of the package.&stackIs the given package/version combo defined in the snapshot or in the global database?&stackA function to yield a  value from: (1) a  value; and (2) a pair of an  value and an ( value. Checks that the version of the  value and the version of the  value are the same.&stackA function to yield a  value from: (1) a dictionary of package names, and where the source code of the named package is located; and (2) an  value. stacklocally registeredstackload upstream packagestack3Only include initial build steps required for GHCi?&stackTasksstack2Reasons why packages are dirty and must be rebuiltstackLocal package database dumpstackIf true, we're doing a special initialBuildSteps build - don't unregister target packages.&stack)Will the build step also build the tests?stack&Should Haddock documentation be built?&stack)will the build step also build any tests?stack&Should Haddock documentation be built?&stack)will the build step also build any tests?stack&Should Haddock documentation be built?&stack5The package which has the dependency being processed.stackThe name of the dependency.stack8The version range and dependency type of the dependency.&stack%The package which has the dependency.stackThe name of the dependency.stack$The version range of the dependency.stackThe result of &.&stack%Is Haddock documentation being built?   Safe-Inferred"%p &stackType representing certain information about an installed package.&stackThe package's id.&stackUnless the package's name is that of a 'wired-in' package, a list of the ids of the installed packages that are the package's dependencies.&stackA pair of (a) the package's name and (b) a pair of the relevant database (write-only or mutable) and information about the library installed.&stackType representing results of &.&stackThe installed package can be included in the set of relevant installed packages.&stackThe installed package cannot be included in the set of relevant installed packages because the package is unknown.&stackThe installed package cannot be included in the set of relevant installed packages because the package is in the wrong package database.&stackThe installed package cannot be included in the set of relevant installed packages because the package has the wrong version. stackReturns the new InstalledMap and all of the locally registered packages.&stackOutputs both the modified InstalledMap and the Set of all installed packages in this databaseThe goal is to ascertain that the dependencies for a package are present, that it has profiling if necessary, and that it matches the version and location needed by the SourceMap.&stackCheck if an installed package can be included in the set of relevant installed packages or not, based on the package selections made by the user. This does not perform any dirtiness or flag change checks.&stackThis is where sublibraries and main libraries are assembled into a single entity Installed package, where all ghcPkgId live. stack*does not contain any installed information&stack5to determine which installed things we should includestackpackage database.stackfrom parent databases&stack5The package database providing the installed package.stackThe installed package to check.   Safe-Inferred"r1!stackParser to extract the Stack command line embedded inside a comment after validating the placement and formatting rules for a valid interpreter specification.!stackExtract Stack arguments from a correctly placed and correctly formatted comment when it is being used as an interpreter!!!! Safe-Inferredrb&&&&&&& Safe-Inferred "%1W&stackIf deprecated path exists, use it and print a warning. Otherwise, return the new path.!stackGet the location of the implicit global project directory. If the directory already exists at the deprecated location, its location is returned. Otherwise, the new location is returned.!stack Download the  value from stackage.org.!stackTurn an  into a Resolver.&stack+Get the latest snapshot resolver available.&stack(Runs the provided action with the given  in the environment!stack$Runs the provided action with a new  , given a  .&stack9Get the default location of the local programs directory.!stackLoad the configuration, using current directory, environment variables, and defaults as necessary.!stackLoad the build configuration, adds build-specific values to config loaded by  loadConfig . values.&stackCheck if there are any duplicate package names and, if so, throw an exception.!stackGet the Stack root, e.g. ~/.stack), and determine whether the user owns it.'On Windows, the second value is always V.!stack! dir throws  if dir" isn't owned by the current user.If dir doesn't exist, its parent directory is checked instead. If the parent directory doesn't exist either,  (% dir) is thrown.&stack& dir returns U (dir, V) when dir6 exists and the current user owns it in the sense of &.&stack0Check whether the current user (determined with getEffectiveUserId#) is the owner for the given path.Will always pure V on Windows.!stackV7 if we are currently running inside a Docker container.!stackV* if we are currently running inside a Nix.'stack6Determine the extra config file locations which exist.Returns most local first!stack8Load and parse YAML from the given config file. Throws  when there's a decoding error.'stack(Load and parse YAML from the given file.!stack:Get the location of the project config file, if it exists.'stackFind the project config file location, respecting environment variables and otherwise traversing parents. If no config is found, we supply a default based on current directory.'stackGet the location of the default Stack configuration file. If a file already exists at the deprecated location, its location is returned. Otherwise, the new location is returned.'stackGet the location of the default user configuration file. If a file already exists at the deprecated location, its location is returned. Otherwise, the new location is returned.&stackDescription of file for warning (if Nothing, no deprecation warning is displayed)stackTest for existencestackNew pathstackDeprecated pathstack((Path to use, whether it already exists)'stackStack root, e.g. ~/.stackstackuser config file path, e.g. ~.stack config.yaml!stack Use color!stackParsed command-line arguments'stackuse config path!stackOverride stack.yaml'stackOverride stack.yaml!!!!!!!!!!!!!!!!!!!!!!!!!!!! Safe-Inferred"1'stackType representing exceptions thrown by functions exported by the  Stack.Nix module.'stackCan't determine the project root (location of the shell file if any).'stack?Shell-escape quotes inside the string and enclose it in quotes.!stackCommand-line argument for "nix"!!!!!! Safe-Inferred"!! Safe-Inferred"#)w'stackType representing types of representations of keys in YAML files.'stackFor example: install-ghc'stackFor example: 'install-ghc''stackFor example: "install-ghc"'stack;Apply changes to the global configuration, typically at ~.stack config.yaml.'stackApply changes to the project  stack.yaml.'stackType repesenting exceptions thrown by functions exported by the Stack.ConfigCmd module.'stackroot directory of project'stackroot directory of project !!!!!!!!!!!!! !!!!!!!!!!!!! Safe-Inferred"%15'stack,Whether to prefix log lines with timestamps.!stackHow we deal with output from GHC, either dumping to a log file or the console (with some prefix).!stack$Temporary Setup.hs for simple builds!stackTemporary SetupShim.hs, to provide access to initial-build-steps!stackCompiled version of eeSetupHs!stackStores which packages with custom-setup have already had their Setup.hs built.!stackFor nicer interleaved output: track the largest package name size!stack&Value of the PATH environment variable!stack$Has an executable been built or not?'stackGet a compiled Setup exe!stack!Execute a function that takes an !.'stack%Make a padded prefix for log messages'stack8Ensure we're the only action using the directory. See 6https://github.com/commercialhaskell/stack/issues/2730!stackThis sets up a context for executing build steps which need to run Cabal (via a compiled Setup.hs). In particular it does the following:Ensures the package exists in the file system, downloading if necessary.Provides the user a function with which run the Cabal process.'stackStrip Template Haskell "Loading package" lines and making paths absolute.'stack7Write stream of lines to handle, but adding timestamps.'stackFormat a time in ISO8601 format. We choose ZonedTime over UTCTime because a user expects to see logs in their local time, and would be confused to see UTC time. Stack's debug logs also use the local time zone.'stackFind the Setup.hs or Setup.lhs in the given directory. If none exists, throw an exception.'stackSetup.hs input filestackSetupShim.hs input filestacktemporary directory!stackglobal packagesstacksnapshot packagesstacklocal packagesstack2largest package name, for nicer interleaved output'stackA pretty announce functionstackroot directory for package!stack5All dependencies' package ids to provide to Setup.hs.'stackexclude TH loading?stackconvert paths to absolute?stackpackage's root directorystackcompiler we're building with'stackproject directory$!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!$!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Safe-Inferred!stackType representing exceptions thrown by functions exported by the System.Process.Pager module.!stackRun pager, providing a function that writes to the pager's input.!stackRun pager to display a !!!!!!!! Safe-Inferred"Y!stackSet the code page for this process as necessary. Only applies to Windows. See: 5https://github.com/commercialhaskell/stack/issues/738!stackhIsTerminaDevice does not recognise handles to mintty terminals as terminal devices, but isMinTTYHandle does.!stackmodify code page?stack GHC version!!!!!! Safe-Inferred' Safe-Inferred "%(1)!stack(Information on a binary release of Stack'stackMetadata downloaded from GitHub releases about available binaries.'stackInformation on the latest available binary for the current platforms.'stack;A modified environment which we know has MSYS2 on the PATH.'stackA modified env which we know has an installed compiler on the PATH.!stack;Should we use a system compiler installation, if available?!stack0If we got the desired GHC version from that file!stack&Run a sanity check on the selected GHC!stack5Don't check for a compatible GHC version/architecture!stack0Do not use a custom msys installation on Windows!stack8Message shown to user for how to resolve the missing GHC!stack>Alternate GHC binary distribution (requires custom GHCVariant)'stack'Type representing exceptions thrown by ''stackType representing 'pretty' exceptions thrown by functions exported by the  Stack.Setup module'stackType representing exceptions thrown by functions exported by the  Stack.Setup module!stack-Default location of the stack-setup.yaml file!stackModify the environment variables (like PATH) appropriately, possibly doing installation too'stackSet up a modified environment which includes the modified PATH that GHC can be found on. This is needed for looking up global package information and ghc fingerprint (result from 'ghc --info').'stackSet up a modified environment which includes the modified PATH that MSYS2 can be found on.'stackspecial helper for GHCJS which needs an updated source map only project dependencies should get included otherwise source map hash will get changed and EnvConfig will become inconsistent!stackSome commands (script, ghci and exec) set targets dynamically see also the note about only local targets for rebuildEnv'stack1Add the include and lib paths to the given Config!stackEnsure both the compiler and the msys toolchain are installed and provide the PATHs to add if necessary'stackSee 6https://github.com/commercialhaskell/stack/issues/4246'stackSee 6https://github.com/commercialhaskell/stack/issues/4246'stackEnsure that the msys toolchain is installed if necessary and provide the PATHs to add if necessary'stackEnsure compiler is installed.'stackRuns STACK_ROOT/hooks/ghc-install.sh.Reads and possibly validates the output of the process as the GHC binary and returns it.'stackDetermine which GHC builds to use depending on which shared libraries are available on the system.'stackEncode an OpenBSD version (like "6.1") into a valid argument for CompilerBuildSpecialized, so "maj6-min1". Later version numbers are prefixed with "r". The result r must be such that "ghc-" ++ r is a valid package name, as recognized by parsePackageNameFromString.!stack#Ensure Docker container-compatible stack executable is downloaded'stackGet all executables on the path that might match the wanted compiler'stack"Download the most recent SetupInfo'stack8Download and install the first available compiler build.'stackCheck if given processes appear to be present, throwing an exception if missing.'stackUnpack a compressed tarball using 7zip. Expects a single directory in the unpacked results, which is renamed to the destination directory.'stackDownload 7z as necessary, and get a function for unpacking things.8Returned function takes an unpack directory and archive.'stack#Perform a basic sanity check of GHC'stackGet map of environment variables to set to change the GHC's encoding to UTF-8.'stack%Same as above, but always uses GitHub'stackEnsure that the Stack executable download is in the same location as the currently running executable. See: 6https://github.com/commercialhaskell/stack/issues/3232 !stack9Message to give user when necessary GHC is not available.'stackalready warned about GHC?'stackexecutable filepath'stack Commit ID.stackHadrain flavour.'stackalready installedstackpackage to findstackwhich versions are acceptable'stack-Description of the tool that is being set up.stack.Description of the root directory of the tool.'stack$Name of tool, used in error messagesstackPath to archive filestackDestination directory.'stacklabelstack%URL, content-length, sha1, and sha256stack destination!stackoptional version'stackoptional version!stackacceptable platformsstackdestination directorystack&perform PATH-aware checking, see #3232stack!test the temp exe before renaming'stack(Path to the currently running executablestack+Path to the executable file to be relocatedstack/Path to the new location for the excutable file'stack!Path to the newly downloaded filestack(Path to the currently running executable!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Safe-Inferred"'stackParsed Config section of docker inspect output.'stackParsed result of docker inspect.'stackFunction to get command and arguments to run in Docker container"stack Error if running in a container."stack?Run a command in a new Docker container, then exit the process.'stack"Inspect Docker image or container.'stack1Inspect multiple Docker images and/or containers."stack=Pull latest version of configured Docker image from registry.'stack Pull Docker image from registry.'stack4Check docker version (throws exception if incorrect)"stack$Remove the project's Docker sandbox."stackThe Docker container "entrypoint": special actions performed when first entering a container, such as switching the UID/GID to the "outside-Docker" user's.'stackRemove the contents of a directory, without removing the directory itself. This is used instead of  to clear bind-mounted directories, since removing the root of the bind-mount won't work.'stackProduce a strict ) from the stdout of a process. Throws a ReadProcessException exception if the process fails.The stderr output is passed straight through, which is desirable for some cases e.g. docker pull, in which docker uses stderr for progress output.Use ' directly to customize this.'stack-Name of home directory within docker sandbox.'stackDirectory where stack executable is bind-mounted in Docker container This refers to a path in the Linux *container*, and so should remain a  (not 'Path Abs Dir') so that it works when the host runs Windows.'stack4Convenience function to decode ByteString to String."stack1Fail with friendly error if project root not set.'stackEnvironment variable that contained the old sandbox ID. | Use of this variable is deprecated, and only used to detect old images."stackParse Config section of docker inspect output."stackParse docker inspect output.'stackDirectory to remove contents ofstack1Top-level directory names to exclude from removalstack,Top-level file names to exclude from removal"""""""""""" Safe-Inferred"%1" "stackIf the settings justify it, should we reexec inside Docker or Nix?'stackType representing exceptions thrown by functions exported by the  Stack.Runners module."stack6Ensure that no project settings are used when running "."stack Helper for "( which passes in some default arguments:No targets are requested.Default command line build options are assumed"stack Upgrade a  environment to an  environment by performing further parsing of project-specific configuration (like !) and then setting up a build environment toolchain. This is intended to be run inside a call to "."stackLoad the configuration. Convenience function used throughout this module.'stackPerform a Docker or Nix reexec, if warranted. Otherwise run the inner action."stackUse the  to create a  and run the provided action.'stackCheck if we should recommend upgrading Stack and, if so, recommend it."stackAction that uses the build config. If Docker is enabled for builds, this will be run in a Docker container. !"""""""" !"""""""" Safe-Inferred"stackFunction underlying the  stack update# command. Update the package index."" Safe-Inferred""stack"Type representing options for the  stack unpack command."stack2The packages or package candidates to be unpacked."stack3Whether the targets are Hackage package candidates."stackThe optional directory into which a target will be unpacked into a subdirectory."stack:Type synonymn representing packages to be unpacked by the  stack unpack command, identified either by name only or by an identifier (including Hackage revision).'stackType representing 'pretty' exceptions thrown by functions exported by the  Stack.Unpack module."stackFunction underlying the  stack unpack command. Unpack packages or package candidates to the filesystem."stack.Intended to work for the command line command."stack3When looking up by name, take from this build plan.stack Destination.stack+Whether the targets are package candidates."""""""""""""""" Safe-Inferred%"stack)Parse command line arguments for Stack's unpack command."" Safe-Inferred""stackFunction underlying the stack uninstall( command. Display help for the command."" Safe-Inferred"G'stackType representing 'pretty' exceptions thrown by functions exported by the Stack.Templates module."stackFunction underlying the stack templates9 command. Display instructions for how to use templates."stack'Display help for the templates command.'stack9Default web URL to get the `stack templates` help output."""" Safe-Inferred"%1"stack/Type representing command line options for the  stack setup command."stackFunction underlying the  stack setup command. """"""""" """"""""" Safe-Inferred"1"stack)Parse command line arguments for Stack's setup command."" Safe-Inferred"'stackType representing exceptions thrown by functions exported by the  Stack.Querymodule.'stackHelper function for ' instance of 0"stackFunction underlying the  stack query command."stackQuery information about the build and print the result to stdout in YAML format.'stack$Get the raw build information object"stack Selectors."stack Selectors."""" Safe-Inferred"%"stackPrint out useful path information in a human-readable format (and support others later)."stack3The paths of interest to a user which do require a  or . The first tuple string is used for a description that the optparse flag uses, and the second string as a machine-readable key and also for --foo: flags. The user can choose a specific path to list like  --stack-root7. But really it's mainly for the documentation aspect."stack4The paths of interest to a user which do require an . The first tuple string is used for a description that the optparse flag uses, and the second string as a machine-readable key and also for --foo: flags. The user can choose a specific path to list like  --stack-root7. But really it's mainly for the documentation aspect.!When printing output we generate Config and pass it to the function to generate an appropriate string. Trailing slashes are removed, see #506."stack0The paths of interest to a user which require a . The first tuple string is used for a description that the optparse flag uses, and the second string as a machine-readable key and also for --foo: flags. The user can choose a specific path to list like --project-root7. But really it's mainly for the documentation aspect.!When printing output we generate EnvConfigPathInfo and pass it to the function to generate an appropriate string. Trailing slashes are removed, see #506.'stack equivalent of ."""""""""" Safe-InferredP"stack)Parse command line arguments for Stack's path command."" Safe-Inferred"'stackType representing exceptions thrown by functions exported by the  Stack.List module."stackFunction underlying the  stack list command. List packages."stack.Intended to work for the command line command."stack3When looking up by name, take from this build plan.stackNames or identifiers."""" Safe-Inferred"%P "stack/Type representing command line options for the  stack init command."stack2List of sub directories to search for .cabal files"stack1Exclude conflicting or incompatible user packages"stackOverwrite existing stack.yaml"stack>If True, include all .cabal files found in any sub directories'stackType representing 'pretty' exceptions thrown by functions exported by the  Stack.Init module.'stackType representing exceptions thrown by functions exported by the  Stack.Init module."stackFunction underlying the  stack init! command. Project initialization."stack Generate a  stack.yaml file.'stack.Render a stack.yaml file with comments, see: 5https://github.com/commercialhaskell/stack/issues/226'stackGet the default resolver value'stack*Yields the minimum LTS supported by Stack.'stackSpecial directories that we don't want to traverse for .cabal files'stackSrc package name: cabal dirstack( Resolver , Flags for src packages and extra deps , Extra dependencies , Src packages actually considered)'stackSrc packages: cabal dirstack( SnapshotDef , Flags for src packages and extra deps , Extra dependencies , Src packages actually considered)'stackSrc package dirs"""""""""""""""" Safe-Inferred"stack)Parse command line arguments for Stack's init and new commands."" Safe-Inferred"b'stackType representing settings for the download of Stack project templates.'stackOptional HTTP Basic# authentication (type, credentials)"stack/Type representing command line options for the  stack new3 command (other than those applicable also to the  stack init command)."stackName of the project to create."stack2Whether to create the project without a directory."stack5Whether to initialise the project for use with Stack."stackName of the template to use."stack4Nonce parameters specified just for this invocation.'stackType representing 'pretty' exceptions thrown by functions exported by the  Stack.New module."stackFunction underlying the  stack new command. Create a project directory structure and initialize the Stack config."stack,Create a new project with the given options.'stack/Download and read in a template's text content.'stackConstruct settings for downloading a Stack project template from a repository.'stack-Apply and unpack a template into a directory.'stack5Check if we're going to overwrite any existing files.'stack)Write files to the new project directory.'stack.Run any initialization functions, such as Git.'stack1The default service to use to download templates. """"""""" """"""""" Safe-Inferred"stack Parser for  stack new."" Safe-Inferred""stackPackage names."stackPaths to Cabal files."stack3To the same output stream as other log information."stackTo the standard output stream."stackFunction underlying the stack ide packages( command. List packages in the project."stackFunction underlying the stack ide targets' command. List targets in the project."stack-List the packages inside the current project."stack(List the targets in the current project. """""""""" """""""""" Safe-Inferred"% "stack/Type representing command line options for the stack hpc report command.'stackType representing 'pretty' exceptions thrown by functions exported by the Stack.Coverage module.#stackFunction underlying the stack hpc report command.#stack5Invoked at the beginning of running with "--coverage"#stackMove a tix file into a sub-directory of the hpc report directory. Deletes the old one if one is present.'stack;Get the directory used for hpc reports for the given pkgId.'stackGet the tix file location, given the name of the file (without extension), and the package identifier string.#stackGenerates the HTML coverage report and shows a textual coverage summary for a package.'stackModule names which contain  have a package name, and so they weren't built into the executable.'stack/Escape HTML symbols (copied from Text.Hastache)'stackThe pretty name for the reportstack2The plain name for the report, used in HTML output'stack!Pretty description of the report.stack8Plain description of the report, used in HTML reporting. """#""####### """#""####### Safe-Inferred"%1 'stackGenerate the ConfigCache'stackEnsure that the configuration for the package matches what is given'stack%Make a padded prefix for log messages'stack=Action in the case that the task relates to a remote package.'stackOnce all the Cabal-related tasks have run for a package, we should be able to gather the information needed to create an  package value. For now, either there's a main library (in which case we consider the  values of the package's libraries) or we just consider it's an executable (and mark all the executables as installed, if any).Note that this also modifies the installedDumpPkgsTVar which is used for generating Haddocks.'stackCopy ddump-* files, if we are building finals and a non-empty ddump-dir has been specified.'stackGet the build status of all the package executables. Do so by testing whether their expected output file exists, e.g. .stack-workdist x86_64-osxCabal-1.22.4.0buildalphaalpha .stack-workdist x86_64-osxCabal-1.22.4.0buildalphaalpha.exe .stack-workdist x86_64-osxCabal-1.22.4.0buildalphaalpha.jsexe/ (NOTE: a dir)'stackCheck whether the given executable is defined in the given dist directory.'stackCheck if any unlisted files have been found, and add them to the build cache.#stackImplements running a package's tests. Also handles producing coverage reports if coverage is enabled.#stack*Implements running a package's benchmarks.'stackHistory of this function:Normally it would do either all executables or if the user specified requested components, just build them. Afterwards, due to this Cabal bug  ,https://github.com/haskell/cabal/issues/2780;, we had to make Stack build all executables every time.In  6https://github.com/commercialhaskell/stack/issues/3229 this was flagged up as very undesirable behavior on a large project, hence the behavior below that we build all executables once (modulo success), and thereafter pay attention to user-wanted components.The Cabal bug was fixed, in that the copy command of later Cabal versions allowed components to be specified. Consequently, Cabal may be satisified, even if all of a package's executables have not yet been built.'stack8Do the current executables satisfy Cabal's requirements?'stacknewConfigCachestackpackage directorystackannouncestackcabalstack Cabal file#stackIs this a final build?'stack7Is Cabal copy limited to all libraries and executables?'stack7Is Cabal copy limited to all libraries and executables?'stack7Is Cabal copy limited to all libraries and executables?###### Safe-Inferred"1P#stackFetch the packages necessary for a build, for example in combination with a dry run.#stack8Print a description of build plan for human consumption.'stack For a dry run#stackPerform the actual plan'stackWindows can't write over the current executable. Instead, we rename the current executable to something else and then do the copy.'stack"Perform the actual plan (internal)#stackglobal packagesstacksnapshot packagesstacklocal packages ### ### Safe-Inferred"#stack,Type representing Stack's cleaning commands.#stack/Type representing command line options for the  stack clean command.#stack-Delete the "dist directories" as defined in o for the given local packages. If no packages are given, all project packages should be cleaned.#stack+Delete all work directories in the project.'stackType representing exceptions thrown by functions exported by the  Stack.Clean module.#stackFunction underlying the  stack clean command.#stack/Deletes build artifacts in the current project.################ Safe-Inferredp#stack*Command-line parser for the clean command.## Safe-Inferred#stack(Options parser configuration for Docker.## Safe-Inferred#stackFunction underlying the stack docker pull) command. Pull the current Docker image.#stackFunction underlying the stack docker reset$ command. Reset the Docker sandbox.#stack$Delete the sandbox's home directory?#### Safe-Inferred"%#stack%Helper for build and install commands#stackBuild.If a buildLock is passed there is an important contract here. That lock must protect the snapshot, and it must be safe to unlock it if there are no further modifications to the snapshot to be performed by this build.'stackSee  6https://github.com/commercialhaskell/stack/issues/1198.#stackGet the BaseConfigOpts- necessary for constructing configure options#stackProvide a function for loading package information from the package index#stack*callback after discovering all local files#stack GHC optionsstackCabal configure options############ Safe-Inferred"%#stack/Type representing command line options for the  stack upgrade command.#stack?Type representing options for upgrading Stack from source code.#stackType representing options for upgrading Stack with a binary executable file.#stackForce a download, even if the downloaded version is older than what we are.#stack0Only download to Stack's local binary directory.#stackSpecific version to download(stackType representing 'pretty' exceptions thrown by functions in the  Stack.Upgrade module.#stackFunction underlying the  stack upgrade command.#stack&git hash at time of building, if known################################ Safe-Inferred#stack)Parse command line arguments for Stack's upgrade command.#stack%The default for --[no]-only-local-bin## Safe-Inferred"%r #stack/Type representing command line options for the  stack script command.#stack3Type representing choices of whether to run or not.#stackRun.#stack Do not run.#stackType representing choices of interpreting, compiling (without optimisation) and compiling (with optimisation).#stackWithout optimisation.#stackCompile with optimisation.(stackType representing exceptions thrown by functions exported by the  Stack.Script module.#stackRun a Stack Script(stackThe Stackage project introduced the concept of hidden packages, to deal with conflicting module names. However, this is a relatively recent addition (at time of writing). See:  Note that we temporarily decompress the archive to analyze it.#stack Version of # that first saves lazy bytestring to temporary directory and then calls # on it.#stackOverride Config valuestackPath to local packagestackFilename, tarball contents, and option Cabal file revision to upload(stackoptional revisionstack Cabal file#stack"The configuration of what to checkstackAbsolute path to tarball(stackAbsolute path to tarball#stack Tarball namestack!Tarball contents as a byte string(stackLocation of tarballstack/Perform actions given dir with tarball contents(stack,Full path to find the file on the local diskstack,Path to use for the tar Entry in the archive ############ ############ Safe-Inferred"%$#stack*Username and password to log into Hackage. Since 0.1.0.0#stack/Type representing command line options for the  stack upload command.#stackThe items to work with.#stack%Uploading documentation for packages?#stack4Type representing variants for uploading to Hackage.#stack(Publish the package/a published package.#stack/Create a package candidate/a package candidate.#stack9Type representing forms of content for upload to Hackage.#stack(Content in the form of an sdist tarball.#stackContent in the form of an archive file of package documentation.(stackType representing 'pretty' exceptions thrown by functions exported by the  Stack.Upload module.#stackFunction underlying the  stack upload command. Upload to Hackage.(stackLoad Hackage credentials, either from a save file or the command line. Since 0.1.0.0#stack1Write contents to a file which is always private."For history of this function, see: https://github.com/commercialhaskell/stack/issues/2159#issuecomment-477948928 4https://github.com/commercialhaskell/stack/pull/4665#stack'Upload a single tarball with the given Uploader". Instead of sending a file like $, this sends a lazy bytestring. Since 0.1.2.1$stack'Upload a single tarball with the given Uploader. Since 0.1.0.0#stackHackage base URLstack#Form of the content to be uploaded.stackOptional package identifier name, applies only to the upload of documentation.stack tar file namestacktar file contents$stackHackage base URLstackOptional package identifier name, applies only to the upload of documentation.stackPath to archive file.$stackHackage base URL########################$#$#################################$#$######### Safe-Inferred#$stack)Parse command line arguments for Stack's upload command.$$ Safe-Inferred$stack"Parser for Cabal verbosity options$stack!Parser for Cabal verbosity option$stackParser for the Cabal verbose flag, retained for backward compatibility$$$$$$$$ Safe-Inferred%v$stack0Command-line arguments parser for configuration.$$ Safe-Inferred%[$stack'Parser for global command-line options.$stack(Create GlobalOpts from GlobalOptsMonoid.(stack?Default logging level should be something useful but not crazy.$$$$ Safe-Inferred"$$$$$$$$ Safe-Inferred $stack)Parse command line arguments for Stack's script command.$$ Safe-Inferred k$stack Parser for stack hpc report.$$$$ Safe-Inferred $stack)Parse command line arguments for Stack's sdist and upload commands.$$ Safe-Inferred" T$stack#Parser for CLI-only build arguments$$$$$$ Safe-Inferred" $stack#Parser for arguments to `stack dot`$$ Safe-Inferred"% (stack%Helper type to duplicate log messages(stackType representing 'pretty' exceptions thrown by functions exported by the  Stack.Hoogle module.(stackType representing exceptions thrown by functions exported by the  Stack.Hoogle module.$stackHoogle command.$$ Safe-Inferred"%c (stackType representing loaded package description and related information.$stackType representing information required to load a package or its components.NOTE: GhciPkgInfo has paths as list instead of a Set to preserve files order as a workaround for bug -https://ghc.haskell.org/trac/ghc/ticket/13786$stackC files.$stack1Typre respresenting command line options for the  stack ghci and  stack repl commands.$stackType representing 'pretty' exceptions thrown by functions exported by the  Stack.Ghci module.$stackType representing exceptions thrown by functions exported by the  Stack.Ghci module.$stackFunction underlying the  stack ghci and  stack repl1 commands. Run GHCi in the context of a project.$stackLaunch a GHCi session for the given local package targets with the given options and configure it with the load paths and extensions of those targets.(stack$Display PackageName + NamedComponent(stackFigure out the main-is file to load based on the targets. Asks the user for input if there is more than one candidate main-is file.(stack7Load package description information for a ghci target.(stack=Make information necessary to load the given package in GHCi.$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ Safe-Inferred"?$stackParser for GHCI options$$ Safe-Inferred"(stackType representing 'pretty' exceptions thrown by functions in the  Stack.Exec module.(stack8Type representing exceptions thrown by functions in the  Stack.Exec module.$stack The function underlying Stack's exec, ghc, run, runghc and  runhaskell commands. Execute a command.$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ Safe-Inferred$stack)Parse command line arguments for Stack's exec, ghc, run, runghc and  runhaskell commands.$stack(Parser for extra options to exec command$$$$ Safe-Inferred%$stackFunction underlying the  stack eval- command. Evaluate some Haskell code inline.$$$$$$$$$$ Safe-Inferred#$stack)Parse command line arguments for Stack's eval command.$stackmetavar$$ Safe-Inferred"%(stackType representing exceptions thrown by functions exported by the Stack.DependencyGraph module.$stackCreate the dependency graph and also prune it as specified in the dot options. Returns a set of local names and a map from package names to dependencies.(stackCreate the dependency graph, the result is a map from a package name to a tuple of dependencies and payload if available. This function mainly gathers the required arguments for resolveDependencies.(stackResolve the direct (depth 0) external dependencies of the given local packages (assumed to come from project packages)(stackGiven a SourceMap and a dependency loader, load the set of dependencies for a package$stackResolve the dependency graph up to (Just depth) or until fixpoint is reached$stack"pruneGraph dontPrune toPrune graph prunes all packages in graph with a name in toPrune3 and removes resulting orphans unless they are in  dontPrune(stack9Make sure that all unreachable nodes (orphans) are pruned$$$$$$ Safe-Inferred"$stack/Type representing command line options for the stack ls tools command.$stack/Type representing command line options for the stack ls stack-colors and stack ls stack-colours commands.%stack1Type representing items to filter the results of stack ls dependencies.%stackItem is a package name.%stack#Item represents all local packages.%stack/Separator between the package name and details.%stack.Print dependency licenses instead of versions.%stackFormat of printing dependencies%stackThe normal dot options.(stack*Type representing Stackage snapshot types.(stackStackage LTS Haskell(stackStackage Nightly%stack&Type representing subcommands for the stack ls snapshots command.%stack/Type representing command line options for the stack ls snapshots command.%stack&Type representing subcommands for the stack ls command.%stack/Type representing command line options for the stack ls command.(stackType representing exceptions thrown by functions exported by the Stack.Ls module.(stackList Stack's output styles(stack6List Stack's installed tools, sorted (see instance of + for ).)%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%$$%%%$$$%)%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%$$%%%$$$% Safe-Inferred"!%stack)Parse command line arguments for Stack's ls command.(stack0Parser for arguments to `stack ls dependencies`.%% Safe-Inferred"# %stack8Visualize the project's dependencies as a graphviz graph%stackPrint a graphviz graph of the edges in the Map and highlight the given local packages(stackPrint the local nodes with a different style depending on options(stack Print nodes without dependencies(stackprintDedges p ps" prints an edge from p to every ps(stack+Print an edge between the two package names(stack,Convert a package name to a graph node name.(stack!Print a node with no dependencies(stack3Check if the package is wired in (shipped with) ghc%stack all locals%%%% Safe-Inferred%-(stackType representing 'pretty' exceptions thrown by functions in the  Stack.CLI module.%stackStack's command line handler.(stack(fall-through to external executables in git style if they exist (i.e. `stack something` looks for `stack-something` before failing with "Invalid argument  something")%% Safe-Inferred")'w(stack8Type representing exceptions thrown by functions in the Stack module.(stackChange the character encoding of the given Handle to transliterate on unsupported characters instead of throwing an exception(stackHandle ExitCode exceptions.(stack"Handle PrettyException exceptions.(stack+Handle (pretty) PantryException exceptions.(stackHandle any pretty exception.(stackHandle SomeException exceptions. This special handler stops "stack: " from being printed before the exception.%%(                                                                                                                                                                                                        !!!!""""############$$$$$$$$$$%%%%%%%%%&''''''''())))))))))))))***********++++++++++++++++++++++,,,,,,,,,,,,-------------.........../////////00000000000111111111111122222222233344444445555555555555677777777788889999999999999999999:::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<=========>>>>>>>>>>>>>>>>>>>>>>>>>????????????????????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAABBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDEEEEEEEEEFFFFFFFFFFFFFGGGGGHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIJJJKKKKKLLLLLLMMMMMMMMMMMNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSS SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUVVVVVVVVVVVWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZ[[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]^____```````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccdddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffghhhhhhiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllmmmmmmmmmmmmmm m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m n n n n n n n n n n n n n n n n o o o o o o o o o o o o o o o oo o p p p p p q r r r r r r r r r r r r r rr s s t t t t t t t t t t t t t t t t t t t t u u u u u u u u u u u u u u u u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!u!v!v!v!w!w!w!w!w!w!w!x!x!x!x!x!x!x!x!x!x!x!x!x!x!x!x!x!x!x!x!x!x!x!x!y!y!y!y!y!z!z!z!z!z!z!z!{!{!{!{!{!{!{!{!{!{!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!}!}!}!}!}!}!}!}!}!}}!}}}!}!}!}!}!}!}!}"~"~"~"~"~"~"~"~"~"~"~"~"~"~"~"~"~"~"~"~"~"~""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""###################################################################################################################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$#$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& & & &&& & & & & &&&&&&&&&&&&&&&&&&&&&$&$&$&9&9&&&&&?&?A'A'A'B'B'B'I'O'O'''''_'_'&''a'd'e'''j'k'k'k!k'k'l'l'm'm'm'm'o'p'p'r'r'r'r'r'r'r'r'r'r'r'r's's's't'tt't'''''t't't't't't'w'w'w'w'w'w'w'w'x'x'y'y'y'y'y'y'y'y'y'y'y'z'{'{'{'}'~'~'~'~'~'~'''''''''''''''''''''''''''''''''((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))"stack-2.15.3-IiMra1A9vP4fPzeIsQ44c Stack.PreludeStack.Ghci.ScriptStack.Types.VersionSystem.Info.ShortPathNameStack.FileWatchNetwork.HTTP.StackClientCodec.Archive.Tar.Utf8 Build_stack Path.Extended Path.Extra Path.Find Paths_stackStack.Options.UtilsStack.Options.LogLevelParserStack.ConstantsStack.Constants.StackProgName!Options.Applicative.Builder.ExtraData.Monoid.MapData.Attoparsec.CombinatorsData.Attoparsec.ArgsOptions.Applicative.ArgsControl.Concurrent.ExecuteStack.Types.AllowNewerDepsStack.Types.ApplyGhcOptionsStack.Types.ApplyProgOptionsStack.Types.BuildOptsCLIStack.Options.PackageParserStack.Types.BuildOptsMonoidStack.Types.BuildOptsStack.Options.TestParserStack.Options.HaddockParserStack.Options.BenchParserStack.BuildOptsStack.Config.BuildStack.Types.CabalConfigKeyStack.Types.CasaStack.Types.ColorWhenStack.DefaultColorWhenStack.Types.CompilerBuildStack.Options.GhcBuildParserStack.Types.ComponentUtilsStack.Types.CuratorStack.Types.DependencyStack.Types.DependencyTreeStack.Types.DockerEntrypointStack.Types.DotOptsStack.Types.DownloadInfoStack.Types.DumpLogsStack.Types.EnvSettingsStack.Types.ExtraDirsStack.Types.FileDigestCacheStack.Types.GHCDownloadInfoStack.Types.GHCVariantStack.Options.GhcVariantParserStack.Types.GhcOptionKeyStack.Types.GhcOptionsStack.Types.GhcPkgIdStack.Types.CacheStack.Types.InstalledStack.Types.IsMutableStack.Types.LockFileBehaviorStack.Types.NamedComponentStack.Types.ComponentStack.Types.DumpPackageStack.Types.CompCollectionStack.ComponentStack.Types.NixStack.Types.PackageNameStack.Types.PlatformStack.Types.ProjectStack.Types.ProjectConfigStack.Types.PvpBoundsStack.Types.ResolverStack.Options.ResolverParserStack.Types.SCMStack.Types.StackYamlLocStack.Types.StorageStack.Storage.UtilStack.Types.TemplateNameStack.Types.UnusedFlagsStack.Types.ParentMapStack.Types.CompilerStack.Types.SourceMapStack.Types.CompilerPaths!Stack.Types.VersionedDownloadInfoStack.Types.SetupInfoSystem.PermissionsStack.Types.DockerStack.Types.ConfigMonoid"Stack.Types.ProjectAndConfigMonoidStack.Types.GlobalOptsMonoidStack.Types.GlobalOptsStack.Types.RunnerStack.Types.AddCommandOptions.Applicative.ComplicatedStack.Types.Config.ExceptionStack.Types.ConfigStack.Types.BuildConfigStack.Types.PackageFileStack.Types.EnvConfigStack.Types.PackageStack.Types.DotConfigPath.CheckInstallStack.Config.DockerStack.Types.ConfigureOptsStack.Types.BuildStack.Storage.UserStack.Storage.ProjectStack.Types.Build.ExceptionStack.Setup.InstalledStack.Constants.ConfigStack.Config.NixStack.Config.ConfigureScriptStack.ComponentFileStack.PackageFile Stack.PackageStack.Types.Build.ConstructPlanStack.BuildInfoStack.Build.HaddockStack.Build.CacheGHC.Utils.GhcPkg.Main.Compat Stack.GhcPkgStack.PackageDumpStack.SourceMap Stack.LockStack.BuildPlanStack.Build.TargetStack.Build.SourceStack.Build.ConstructPlanStack.Build.InstalledData.Attoparsec.Interpreter Stack.Config Stack.NixStack.Options.NixParserStack.ConfigCmdStack.Build.ExecuteEnvSystem.Process.PagerSystem.Terminal Stack.Setup Stack.Docker Stack.Runners Stack.Update Stack.UnpackStack.Options.UnpackParserStack.UninstallStack.TemplatesStack.SetupCmdStack.Options.SetupParser Stack.Query Stack.PathStack.Options.PathParser Stack.List Stack.InitStack.Options.InitParser Stack.NewStack.Options.NewParser Stack.IDEStack.CoverageStack.Build.ExecutePackageStack.Build.Execute Stack.CleanStack.Options.CleanParserStack.Options.DockerParserStack.DockerCmd Stack.Build Stack.UpgradeStack.Options.UpgradeParser Stack.Script Stack.SDist Stack.UploadStack.Options.UploadParserStack.Options.BuildMonoidParserStack.Options.ConfigParserStack.Options.GlobalParserStack.Options.CompletionStack.Options.ScriptParserStack.Options.HpcReportParserStack.Options.SDistParserStack.Options.BuildParserStack.Options.DotParser Stack.Hoogle Stack.GhciStack.Options.GhciParser Stack.ExecStack.Options.ExecParser Stack.EvalStack.Options.EvalParserStack.DependencyGraphStack.LsStack.Options.LsParser Stack.Dot Stack.CLIStackstackPath.IO resolveDir resolveFile resolveFile'Stack.Constants.UsrLibDirs&Distribution.Types.UnqualComponentNameUnqualComponentNameDistribution.Types.BuildInfo BuildInfo buildabletargetBuildDepends buildToolsDistribution.Types.Benchmark BenchmarkDistribution.Types.TestSuite TestSuiteDistribution.Types.Executable Executable$Distribution.Types.Foreign.Libraries ForeignLibDistribution.Types.LibraryName LMainLibName LSubLibNameDistribution.Types.LibraryLibraryData.HashMap.StrictHashMap Data.TextText$Distribution.Simple.BuildToolDependsdesugarBuildToolbuildToolDependsgenerateBuildInfoOptsStack.Docker.Handlers"Distribution.Simple.LocalBuildInfocomponentBuildDir unknownTools loadSourceMapSystem.Posix.User System.UnameFS removeTreeS ByteStringdistRelativeDirbaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip otherwiseassertmap$GHC.Num fromInteger-GHC.Real fromRational GHC.Classes==>=negate>>=>>fmapreturnControl.Monad.Failfail Data.String fromString fromIntegral realToFrac toInteger toRational Control.Monadguard<>memptymappendmconcatjoin<*>pure*>GHC.EnumBoundedEnumEq GHC.FloatFloating FractionalIntegralMonad Data.DataDataFunctorNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShowData.Typeable.InternalTypeable MonadFailIsString Applicative Data.FoldableFoldableData.Traversable Traversable GHC.GenericsGeneric SemigroupMonoid GHC.TypesBoolStringCharDoubleFloatIntGHC.IntInt8Int16Int32Int64 ghc-bignumGHC.Num.IntegerIntegerGHC.Num.NaturalNatural GHC.MaybeMaybeOrderingRationalIOWordGHC.WordWord8Word16Word32Word64 Data.EitherEitherVoidNonEmptyGHC.Stack.Types CallStackFalseNothingJustTrueLeftRightLTEQGTData.Ord comparingCabal-syntax-3.10.1.0Distribution.Types.VersionVersion LibraryNameDistribution.ModuleName ModuleNameDistribution.Types.PackageName PackageNameGHC.MVarMVar GHC.Conc.SyncThreadId<$traverse sequenceAtoListfoldMapfoldrfoldl'nulllengthelemsumproductminBoundmaxBoundfromEnum/=piexplogsqrt**logBasesincostanasinacosatansinhcoshtanhasinhacoshatanh/recipquotremdivmodquotRemdivMod+*abssignumcompare<<=>maxmin floatRadix floatDigits floatRange decodeFloat encodeFloatexponent significand scaleFloatisNaN isInfiniteisDenormalizedisNegativeZeroisIEEEatan2properFractiontruncateroundceilingfloorshowliftA2<*:|GHC.Exception.Type SomeException MonadPlusmzeromplus Alternative<|>somemany Data.ProxyProxyData.Functor.ConstConstgetConst Exception toException fromExceptiondisplayExceptionGHC.IO.Exception IOExceptionGHC.IOFilePathExitCode ExitSuccess ExitFailureData.Functor.IdentityIdentity runIdentitycontainers-0.6.7Data.Set.InternalSetData.Map.InternalMapdeepseq-1.4.8.1Control.DeepSeqNFDatarnfdeepseq&&||notGHC.Errerror undefinedabsurd=<<whenliftMliftM2idconst.flip$!asTypeOfsubtract Data.MaybemaybeisJust isNothing fromMaybe maybeToList listToMaybe catMaybesmapMaybe replicate takeWhile dropWhiletakedropspanbreakreverselookupzipWithevenodd^^^gcdlcm Data.Tuplefstsndcurryuncurry Data.Functor<$>void Data.FunctiononeitherpartitionEithers Text.Read readMaybe traverse_for_ sequence_concat concatMapandoranyallnotElem Data.OldListlinesunlineswordsunwordsforfilterMfoldMunlessforceGHC.STSTforM_GHC.IO.StdHandlesstderrstdoutDistribution.Types.PackageIdPackageIdentifierpkgName pkgVersion"Distribution.Types.MungedPackageIdMungedPackageId(Distribution.Types.VersionRange.Internal VersionRangeDistribution.Types.VersionRange withinRangeData.Semigroup.InternalAnygetAnyControl.Applicativeoptional$Distribution.Types.MungedPackageNameMungedPackageNameDistribution.Types.FlagFlagName mungedName mungedVersion byteSwap16 byteSwap32 byteSwap64bytestring-0.11.5.3Data.ByteString.Short.InternalShortByteStringData.ByteString.Internal.TypeWin32-2.13.3.0System.Win32.InfogetShortPathNameGHC.IO.Handle.TypesHandle2unordered-containers-0.2.20-KS9Z7VmQbqLIjGcy5HyY73Data.HashMap.Internal text-2.0.2Data.Text.Internal'hashable-1.4.3.0-6LukcPsaWSn5ctNZbuwjolData.Hashable.ClassHashable Data.ByteString.Builder.InternalBuilderstdinData.Bifunctor Bifunctorbimap"async-2.2.5-FFYJVKMyFXGGQbZpyMJaaI!Control.Concurrent.Async.InternalAsyncCancelledAsync asyncThreadIdwaitSTM waitCatchSTMpollSTMwaitAnyCatchSTM waitAnySTMwaitEitherCatchSTM waitEitherSTMwaitEitherSTM_ waitBothSTMmapM_ HasCallStackliftAliftA3runST Data.Boolbool<&>$>fix&TVarleftsrightsisLeftisRightfromLeft fromRightForeign.StorableStorableDowngetDownControl.CategoryCategory>>> GHC.IO.IOModeIOModeReadMode WriteMode AppendMode ReadWriteModeSumgetSumEndoappEndo Data.MonoidFirstgetFirstfoldfoldr' sequenceA_asummsum GHC.IORefIORef GHC.IO.DeviceSeekMode AbsoluteSeek RelativeSeek SeekFromEnd BufferMode NoBuffering LineBufferingBlockBufferingSomeAsyncExceptionasyncExceptionToExceptionasyncExceptionFromExceptionSTMorElsenewTVarreadTVar writeTVar Control.ArrowArrow***&&&mapMsequenceforM>=><=<foreverzipWithM zipWithM_foldM_ replicateM_<$!>mfilterControl.Concurrent.QSemNQSemNControl.Concurrent.QSemQSemControl.Concurrent.ChanChanControl.Monad.IO.ClassMonadIOliftIOfirstsecondData.Bifoldable Bifoldablebifold bifoldMapbifoldrbifoldlbifoldr'bifoldr1bifoldrMbifoldl'bifoldl1bifoldlM bitraverse_bifor_ bisequence_biasumbiListbinullbilengthbielembiconcat bimaximum biminimumbisum biproduct biconcatMapbiandbiorbianybiall bimaximumBy biminimumBy binotElembifindData.Bitraversable Bitraversable bitraverse bisequencebifor bimapAccumL bimapAccumRgfoldlgunfoldtoConstr dataTypeOf dataCast1 dataCast2gmapTgmapQlgmapQrgmapQgmapQigmapMgmapMpgmapMo fromShorttoShortexceptions-0.10.7Control.Monad.Catch MonadThrowthrowMtransformers-0.6.1.0Control.Monad.Trans.Class MonadTranslift(primitive-0.8.0.0-BcoUEAnXhk925AP6fFV7UeControl.Monad.Primitive PrimMonad PrimState primitive+unliftio-core-0.2.1.0-jCMAjQfJQAFcRO0d4vNHTControl.Monad.IO.Unlift MonadUnliftIO withRunInIO$conduit-1.3.5-8bZ6WjGXFHR3XkWLyBmJ7MData.Conduit.Internal.ConduitConduitM.| runConduitControl.Monad.Trans.ReaderReaderTData.Sequence.InternalSeqData.IntSet.InternalIntSetData.IntMap.InternalIntMap$!!Handler'fsnotify-0.4.1.0-BQxN46f5rsDJuSycFrBCcfSystem.FSNotify.Types WatchMode WatchModePoll)http-client-0.7.16-9dnmoiz94mO6vidn6nh9UDNetwork.HTTP.Client.TypesResponseresponseStatusresponseVersionresponseHeaders responseBodyresponseCookieJarresponseEarlyHintsRequestmethodpathrequestHeaders requestBody checkResponse RequestBodyRequestBodyLBS RequestBodyBSHttpExceptionContentStatusCodeExceptionTooManyRedirectsOverlongHeadersResponseTimeoutConnectionTimeoutConnectionFailureInvalidStatusLine InvalidHeaderInvalidRequestHeaderInternalExceptionProxyConnectExceptionNoResponseDataReceivedTlsNotSupportedWrongRequestBodyStreamSizeResponseBodyTooShortInvalidChunkHeadersIncompleteHeadersInvalidDestinationHostHttpZlibExceptionInvalidProxyEnvironmentVariableConnectionClosedInvalidProxySettings HttpExceptionHttpExceptionRequestInvalidUrlExceptionNetwork.HTTP.Client.Request parseUrlThrow parseRequestgetUrisetRequestCheckStatus%Network.HTTP.Client.MultipartFormDatapartBSpartLBSpartFileRequestBody formDataBody.http-client-tls-0.3.6.3-K701dxqH871CFbjJX2mFagNetwork.HTTP.Client.TLSgetGlobalManagerdisplayDigestAuthExceptionapplyDigestAuth+http-conduit-2.3.8.3-IAfPVzUSVwL5YIfwg516VONetwork.HTTP.SimplesetRequestMethodaddRequestHeadersetRequestHeadersetRequestHeaderssetRequestBodygetResponseStatusCodegetResponseHeadersgetResponseBody,http-download-0.2.1.0-JMHdBsIyVKaIlHTjBjSwMRNetwork.HTTP.Download.VerifiedVerifiedDownloadExceptionWrongContentLengthWrongStreamLength WrongDigestDownloadHttpErrorCheckHexDigestCheckHexDigestStringCheckHexDigestByteStringCheckHexDigestHeader HashCheckhashCheckAlgorithmhashCheckHexDigestDownloadRequestmkDownloadRequest setHashCheckssetLengthChecksetRetryPolicysetForceDownloaddrRetryPolicyDefault(http-types-0.12.4-ANCAYszdM2i8kwZCo4KFzUNetwork.HTTP.Types.HeaderhAccepthContentLength hContentMD5Network.HTTP.Types.Method methodPost methodPutNetwork.HTTP.Types.Status notFound404(microlens-0.4.13.1-Ke4m5S0ig5NfuZJJcuPpwLens.Micro.TypeLens'LensGetting SimpleGetterASetter'ASetterLens.Micro.Internalsets Lens.Micro%~over.~set^.to^..^?lens,microlens-mtl-0.2.0.3-Ckh9msSQt7FJJCEfAq0N91Lens.Micro.Mtlviewpreview mtl-2.3.1Control.Monad.Reader.ClasslocalReader MonadReaderasks runReaderT runReaderask.pantry-0.9.3.2-IdFfQInao7y3yiRDshhLmH-internal Pantry.SHA256SHA256 Pantry.TypesSnapshotCacheHashunSnapshotCacheHash SnapshotLayerslParent slCompiler slLocationsslDropPackagesslFlagsslHidden slGhcOptions slPublishTimeRawSnapshotLayer rslParent rslCompiler rslLocationsrslDropPackagesrslFlags rslHidden rslGhcOptionsrslPublishTimeSnapshotPackage spLocationspFlagsspHidden spGhcOptionsRawSnapshotPackage rspLocationrspFlags rspHidden rspGhcOptionsSnapshotsnapshotCompilersnapshotPackages snapshotDrop RawSnapshot rsCompiler rsPackagesrsDropSnapshotLocation SLCompilerSLUrl SLFilePathRawSnapshotLocation RSLCompilerRSLUrl RSLFilePath RSLSynonymSnapNameLTSNightlyWantedCompilerWCGhcWCGhcGitWCGhcjsHpackExecutable HpackBundled HpackCommand CabalString unCabalStringArchiveLocationALUrl ALFilePath RelFilePathPackageMetadatapmIdent pmTreeKeyRawPackageMetadatarpmName rpmVersion rpmTreeKeyTreeKey SafeFilePath FuzzyResultsFRNameNotFoundFRVersionNotFoundFRRevisionNotFoundPantryException"PackageIdentifierRevisionParseFailInvalidCabalFileTreeWithoutCabalFileTreeWithMultipleCabalFilesMismatchedCabalNameNoLocalPackageDirFoundNoCabalFileFoundMultipleCabalFilesFoundInvalidWantedCompilerInvalidSnapshotLocationInvalidOverrideCompilerInvalidFilePathSnapshotInvalidSnapshotMismatchedPackageMetadataNon200ResponseStatusInvalidBlobKeyCouldn'tParseSnapshotWrongCabalFileNameDownloadInvalidSHA256DownloadInvalidSizeDownloadTooLargeLocalNoArchiveFileFoundLocalInvalidSHA256LocalInvalidSizeUnknownArchiveTypeInvalidTarFileTypeUnsupportedTarballNoHackageCryptographicHashFailedToCloneRepoTreeReferencesMissingBlobCompletePackageMetadataMismatch CRC32MismatchUnknownHackagePackageCannotCompleteRepoNonSHA1MutablePackageLocationFromUrlMismatchedCabalFileForHackagePackageNameParseFailPackageVersionParseFailInvalidCabalFilePathDuplicatePackageNamesMigrationFailure NoCasaConfigInvalidTreeFromCasaParseSnapNameExceptionHpackLibraryExceptionHpackExeExceptionMismatchmismatchExpectedmismatchActualPackageIdentifierRevision CabalFileInfo CFILatestCFIHash CFIRevisionBlobKeyFileSizeHasPantryConfig pantryConfigLHackageSecurityConfig hscKeyIdshscKeyThresholdhscIgnoreExpiryPackageIndexConfigpicDownloadPrefixpicHackageSecurityConfig SimpleReposRepoUrl sRepoCommit sRepoTypeReporepoUrl repoCommitrepoType repoSubdirRepoTypeRepoGitRepoHgArchivearchiveLocation archiveHash archiveSize archiveSubdir RawArchive raLocationraHashraSizeraSubdirPackageLocationImmutable PLIHackage PLIArchivePLIRepoRawPackageLocationImmutable RPLIHackage RPLIArchiveRPLIRepoPackageLocation PLImmutable PLMutableRawPackageLocation RPLImmutable RPLMutable ResolvedPathresolvedRelativeresolvedAbsolute Unresolved PrintWarningsYesPrintWarningsNoPrintWarnings PantryConfigRevisionsnapshotLocation resolvePathstoRawPLdefaultHackageSecurityConfigparseHackageTextparsePackageIdentifierRevisionmkSafeFilePathparsePackageIdentifierparsePackageNameparsePackageNameThrowing parseVersionparseVersionThrowing parseFlagNamepackageNameStringpackageIdentifierString versionStringflagNameStringmoduleNameStringtoCabalStringMapunCabalStringMapparseWantedCompilerparseRawSnapshotLocationdefaultSnapshotLocation parseSnapNametoRawSLtoRawSnapshotLayerwarnMissingCabalFile%pantry-0.9.3.2-21RHHYSqBCE1zoeMATZmgsPantry.HackageRequireHackageIndexYesRequireHackageIndexNoRequireHackageIndexUsePreferredVersionsIgnorePreferredVersionsDidUpdateOccurUpdateOccurredNoUpdateOccurredhackageIndexTarballLupdateHackageIndexgetHackageTypoCorrectionsgetHackagePackageVersions Pantry.Repo fetchReposRaw fetchReposwithRepoPantry PantryAppAddPackagesConfigapcDropapcFlags apcHiddens apcGhcOptions CompletedSL CompletedPLICompletePackageLocation cplCompletecplHasCabalFilewithPantryConfigwithPantryConfig'defaultCasaRepoPrefixdefaultCasaMaxPerRequestdefaultPackageIndexConfigdefaultDownloadPrefixgetLatestHackageVersiongetLatestHackageLocationgetLatestHackageRevision fetchPackagesunpackPackageLocationRawunpackPackageLocationloadCabalFileImmutableloadCabalFileRawImmutableloadCabalFileRaw loadCabalFileloadCabalFilePathfindOrGenerateCabalFilegpdPackageIdentifiergpdPackageName gpdVersion loadPackageloadPackageRawtryLoadPackageRawViaCasacompletePackageLocationcompleteSnapshotLocationloadAndCompleteSnapshotloadAndCompleteSnapshot'loadAndCompleteSnapshotRawloadAndCompleteSnapshotRaw'addPackagesToSnapshotloadRawSnapshotLayerloadSnapshotLayergetPackageLocationNamepackageLocationIdentpackageLocationVersiongetRawPackageLocationIdentgetRawPackageLocationTreeKeygetPackageLocationTreeKeyhpackExecutableL runPantryApprunPantryAppWithrunPantryAppCleanloadGlobalHintspartitionReplacedDependencieswithSnapshotCache!path-0.9.5-EhT35eCI9pALS6aQvyvDKjPath.Internal.WindowsPath toFilePath Path.WindowsDirFileRelAbsData.Text.Encoding.ErrorUnicodeException DecodeError EncodeError lenientDecodeData.Text.EncodingdecodeUtf8With decodeUtf8'encodeUtf8Builder encodeUtf8(unliftio-0.2.25.0-3Hrj22fHDvO9TZYWQ2Ubta UnliftIO.IOwithBinaryFileUnliftIO.IO.FileensureFileDurablewriteBinaryFileDurablewriteBinaryFileDurableAtomicwithBinaryFileDurablewithBinaryFileDurableAtomicwithBinaryFileAtomicwriteBinaryFileUnliftIO.Concurrent myThreadId threadDelaythreadWaitReadthreadWaitWriteisCurrentThreadBoundData.HashSet.InternalHashSet&vector-0.13.1.0-FOiRjj23qtPGmaTT8dsGRq Data.VectorVectorData.Vector.Unboxed.BaseUnbox#rio-0.1.22.0-HmBqm37y9EwCCFt31YeJJNRIO.Prelude.DisplayDisplaydisplay textDisplay Utf8BuildergetUtf8Builder displayShowdisplayBytesUtf8utf8BuilderToTextutf8BuilderToLazyTextwriteFileUtf8BuilderRIO.Prelude.Exit exitFailure exitSuccessexitWithRIO.Prelude.ExtramapLeft fromFirst mapMaybeA forMaybeA mapMaybeM forMaybeMfoldMapMnubOrdwhenMunlessMasIORIO.Prelude.RenamesLText LByteStringGVectorSVectorUVectorsappend toStrictBytesfromStrictBytes yieldThreadRIO.Prelude.TexttshowdecodeUtf8LenientRIO.Prelude.Logger HasLogSource getLogSource HasLogLevel getLogLevelGLogFunc HasGLogFuncGMsg gLogFuncL LogOptionsLogFunc HasLogFunclogFuncL LogSourceLogLevel LevelDebug LevelInfo LevelWarn LevelError LevelOther mkLogFunc logGenericlogDebuglogInfologWarnlogErrorlogOther logDebugSlogInfoSlogWarnS logErrorS logOtherS logSticky logStickyDonelogOptionsMemorylogOptionsHandle newLogFunc withLogFuncsetLogMinLevelsetLogMinLevelIOsetLogVerboseFormatsetLogVerboseFormatIOsetLogTerminal setLogUseTimesetLogUseColorsetLogLevelColorssetLogSecondaryColorsetLogAccentColors setLogUseLoc setLogFormatdisplayCallStacklogFuncUseColorLlogFuncLogLevelColorsLlogFuncSecondaryColorLlogFuncAccentColorsL noLoggingcontramapMaybeGLogFunccontramapGLogFunc mkGLogFuncgloggLogFuncClassicRIO.Prelude.IO withLazyFilewithLazyFileUtf8 writeFileUtf8 hPutBuilderreadFileBinarywriteFileBinary readFileUtf8 RIO.DequeBDequeSDequeUDequeDequeasUDequeasSDequeasBDequenewDeque getDequeSize popFrontDeque popBackDequepushFrontDeque pushBackDeque foldlDeque foldrDeque dequeToList dequeToVector freezeDequeRIO.Prelude.URefIOURefURefnewURefreadURef writeURef modifyURefRIO.Prelude.RIO HasWriteRef writeRefL HasStateRef stateRefLSomeRefRIOunRIOrunRIOliftRIOmapRIO readSomeRef writeSomeRef modifySomeRef newSomeRefnewUnboxedSomeRefRIO.Prelude.Simple SimpleApp mkSimpleApp runSimpleAppRIO.Prelude.TracetracetraceIdtraceIOtraceM traceEvent traceEventIO traceMarker traceMarkerIO traceStack traceShow traceShowId traceShowIO traceShowMtraceShowEventtraceShowEventIOtraceShowMarkertraceShowMarkerIOtraceShowStack traceDisplaytraceDisplayIdtraceDisplayIO traceDisplayMtraceDisplayEventtraceDisplayEventIOtraceDisplayMarkertraceDisplayMarkerIOtraceDisplayStackUnliftIOunliftIOUnliftIO.Internals.Async ConcurrentlyrunConcurrently.safe-exceptions-0.1.7.4-3nSgnRDkUlC4nQNQLXkPtQControl.Exception.SafeAsyncExceptionWrapperSyncExceptionWrapperUnliftIO.ExceptionStringException stm-2.5.1.0Control.Concurrent.STM.TBQueueTBQueueControl.Concurrent.STM.TChanTChanControl.Concurrent.STM.TMVarTMVarControl.Concurrent.STM.TQueueTQueue ConcExceptionEmptyWithNoAlternativeConcUnliftIO.MemoizeMemoizedasynctry asyncBoundasyncOnasyncWithUnmaskasyncOnWithUnmask withAsyncwithAsyncBound withAsyncOnwithAsyncWithUnmaskwithAsyncOnWithUnmaskwait waitCatchpollcanceluninterruptibleCancel cancelWith waitAnyCatchwaitAnyCatchCancelwaitAny waitAnyCancelwaitEitherCatchwaitEitherCatchCancel waitEither waitEither_waitEitherCancelwaitBothlinklink2racerace_ concurrently concurrently_mapConcurrentlyforConcurrentlymapConcurrently_forConcurrently_replicateConcurrentlyreplicateConcurrently_ UnliftIO.STM atomicallybracketopenFilethrowToUnliftIO.IORefatomicWriteIORefatomicModifyIORefhSeekhFlushmaskthrowIO newTChanIOnewBroadcastTChanIO newTQueueIO newTBQueueIO newTMVarIOcatchhClose hWaitForInput UnliftIO.MVar newEmptyMVarnewMVartakeMVarreadMVarputMVar tryTakeMVar tryPutMVar tryReadMVar isEmptyMVarcatchAny onExceptionmask_uninterruptibleMask_uninterruptibleMaskfinallyevaluatenewIORef readIORef writeIORefatomicModifyIORef' mkWeakIORef modifyIORef modifyIORef' newTVarIO readTVarIOwithMVar modifyMVar_ catchJusthandle handleJusttryJustbracket_bracketOnErrorcatchesswapMVarwithMVarMasked modifyMVarmodifyMVarMasked_modifyMVarMasked mkWeakMVar withException registerDelaywithFile hFileSize hSetFileSizehIsEOF hSetBufferinghTellhIsOpen hIsClosed hIsReadable hIsWritable hGetBuffering hIsSeekablehSetEchohGetEchohIsTerminalDevicehReadyUnliftIO.QSemNnewQSemN waitQSemN signalQSemN UnliftIO.QSemnewQSemwaitQSem signalQSem UnliftIO.ChannewChan writeChanreadChandupChangetChanContentswriteList2ChangetMonotonicTimeUnliftIO.Timeouttimeout throwString impureThrowcatchIO catchDeep catchAnyDeephandleIO handleAny handleDeep handleAnyDeeptryIOtryAnytryDeep tryAnyDeepbracketOnError_toSyncExceptiontoAsyncExceptionisSyncExceptionisAsyncException catchesDeep evaluateDeep newTBQueue writeTBQueue readTBQueuetryReadTBQueue flushTBQueue peekTBQueuetryPeekTBQueue unGetTBQueue lengthTBQueueisEmptyTBQueue isFullTBQueuenewTChannewBroadcastTChan writeTChan readTChan tryReadTChan peekTChan tryPeekTChandupTChan unGetTChan isEmptyTChan cloneTChannewTMVar newEmptyTMVarnewEmptyTMVarIO takeTMVar tryTakeTMVarputTMVar tryPutTMVar readTMVar tryReadTMVar swapTMVar writeTMVar isEmptyTMVar mkWeakTMVar newTQueue writeTQueue readTQueue tryReadTQueue peekTQueue tryPeekTQueue unGetTQueue isEmptyTQueueControl.Concurrent.STM.TVar modifyTVar modifyTVar' stateTVarswapTVar mkWeakTVarcatchSyncOrAsynchandleSyncOrAsynctrySyncOrAsyncpureTry pureTryDeepfromExceptionUnwrapstringException fromEither fromEitherIO fromEitherM mapExceptionMconcrunConcpooledMapConcurrentlyNpooledMapConcurrentlypooledForConcurrentlyNpooledForConcurrentlypooledMapConcurrentlyN_pooledMapConcurrently_pooledForConcurrently_pooledForConcurrentlyN_pooledReplicateConcurrentlyNpooledReplicateConcurrentlypooledReplicateConcurrentlyN_pooledReplicateConcurrently_ runMemoized memoizeRef memoizeMVarwithQSem withQSemNretrySTMcheckSTMUnliftIO.TemporarywithSystemTempFilewithSystemTempDirectory withTempFilewithTempDirectory askUnliftIO askRunInIO withUnliftIOtoIOwrappedWithRunInIOliftIOOp.rio-prettyprint-0.1.8.0-5osp3ntKjSU2PNZbZIqDM4RIO.PrettyPrint.Types StyleSpecStyleErrorWarningInfoDebug OtherLevelGoodShellUrlRecommendationCurrentTargetModule PkgComponent Secondary HighlightRIO.PrettyPrint.DefaultStyles defaultStylesRIO.PrettyPrint.StylesUpdateHasStylesUpdate stylesUpdateL StylesUpdate stylesUpdateparseStylesUpdateFromString Text.PrettyPrint.Leijen.ExtendedStyleDocPrettypretty<+>alignparensstringlinefill punctuatehcatsepvsephsepfillSep encloseSepindenthang softbreaksoftlineRIO.PrettyPrint.PrettyExceptionPrettyException ppException prettyThrowIO prettyThrowMRIO.PrettyPrintHasTerm useColorL termWidthLdisplayWithColor prettyGeneric prettyDebug prettyInfo prettyNote prettyWarn prettyErrorprettyWarnNoIndent prettyDebugL prettyInfoL prettyNoteL prettyWarnL prettyErrorL prettyInfoS prettyNoteS prettyWarnSflow blankLine debugBracketstyle bulletedListmkNarrativeListspacedBulletedListlogLevelToStyle"tar-0.5.1.1-Al01P9Dof2O7kspgWq1vuxCodec.Archive.Tar.TypesEntriesNextDoneFail EntryContent NormalFile Directory SymbolicLinkHardLinkCharacterDevice BlockDevice NamedPipeOtherEntryTypeEntry entryContent unfoldEntries foldEntries foldlEntries mapEntriesmapEntriesNoFailCodec.Archive.Tar.Read FormatErrorTruncatedArchive ShortTrailer BadTrailer TrailingJunkChecksumIncorrect NotTarFormatUnrecognisedTarFormatHeaderBadNumericEncodingreadCodec.Archive.Tar.PackpackCodec.Archive.Tar.WritewriteCodec.Archive.Tarcreateextractappenddeps entryPathunpackhttpJSONhttpLbs httpNoBodyhttpSink withResponsesetGitHubHeadersdownload redownloadverifiedDownloadverifiedDownloadWithProgress fileExtension addExtensionreplaceExtensiontoFilePathNoTrailingSepparseCollapsedAbsDirparseCollapsedAbsFileconcatAndCollapseAbsDirrejectMissingFilerejectMissingDirpathToLazyByteStringpathToByteString pathToTexttryGetModificationTimeforgivingResolveDirforgivingResolveFileforgivingResolveFile' findFileUp findDirUp findFiles findInParentsversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirPrettyRawSnapshotLocation FirstFalse$sel:firstFalse:FirstFalse FirstTrue$sel:firstTrue:FirstTruewithSystemTempDirwithKeepSystemTempDirsinkProcessStderrStdoutsinkProcessStdoutlogProcessStderrStdoutreadProcessNullwithProcessContextstripCRpromptpromptPassword promptBool fromFirstTruedefaultFirstTruefromFirstFalsedefaultFirstFalsewriteBinaryFileAtomic bugReportbugPrettyReportmconsputUtf8Builder putBuilder fromPackageIdfromPackageName$fMonoidFirstTrue$fSemigroupFirstTrue$fMonoidFirstFalse$fSemigroupFirstFalse!$fPrettyPrettyRawSnapshotLocation$fEqFirstFalse$fOrdFirstFalse$fShowFirstFalse $fEqFirstTrue$fOrdFirstTrue$fShowFirstTrueGlobalOptsContextOuterGlobalOptsOtherCmdGlobalOptsBuildCmdGlobalOptsGhciCmdGlobalOptshideMods$fEqGlobalOptsContext$fShowGlobalOptsContextlogLevelOptsParser GhciScriptcmdAdd cmdModulescriptToLazyByteStringscriptToBuilder scriptToFile$fMonoidGhciScript$fSemigroupGhciScript$fShowGhciCommand fileWatch fileWatchPolllibDirs usrLibDirs stackProgNamePathCompleterOpts$sel:absolute:PathCompleterOpts$sel:relative:PathCompleterOpts$sel:rootDir:PathCompleterOpts!$sel:fileFilter:PathCompleterOpts $sel:dirFilter:PathCompleterOpts boolFlagsboolFlagsNoDefaultfirstBoolFlagsNoDefaultfirstBoolFlagsTruefirstBoolFlagsFalseenableDisableFlagsenableDisableFlagsNoDefaultextraHelpOption execExtraHelp textOption textArgument optionalFirstoptionalFirstTrueoptionalFirstFalse absFileOption relFileOption absDirOption relDirOption eitherReader'defaultPathCompleterOpts fileCompleterfileExtCompleter dirCompleterpathCompleterWithunescapeBashArg showHelpText+$fExceptionOptionsApplicativeExtraException&$fShowOptionsApplicativeExtraException MonoidMap$fMonoidMonoidMap$fSemigroupMonoidMap $fEqMonoidMap$fFunctorMonoidMap$fGenericMonoidMap$fOrdMonoidMap$fReadMonoidMap$fShowMonoidMap appending alternatingpured concating EscapingModeEscaping NoEscaping parseArgsparseArgsFromString argsParser$fEnumEscapingMode$fEqEscapingMode$fShowEscapingMode argsArgument argsOption cmdOption ActionContext$sel:remaining:ActionContext$sel:downstream:ActionContext$sel:concurrency:ActionContext ConcurrencyConcurrencyAllowedConcurrencyDisallowedAction$sel:actionId:Action$sel:actionDeps:Action$sel:action:Action$sel:concurrency:ActionActionId ActionTypeATBuild ATBuildFinal ATRunTestsATRunBenchmarks runActions$fExceptionExecuteException$fEqConcurrency $fEqActionId $fOrdActionId$fShowActionId$fShowActionType$fEqActionType$fOrdActionType$fShowExecuteExceptionAllowNewerDeps$fFromJSONAllowNewerDeps$fMonoidAllowNewerDeps$fSemigroupAllowNewerDeps$fEqAllowNewerDeps$fGenericAllowNewerDeps$fOrdAllowNewerDeps$fReadAllowNewerDeps$fShowAllowNewerDepsApplyGhcOptions AGOTargets AGOLocals AGOEverything$fFromJSONApplyGhcOptions$fBoundedApplyGhcOptions$fEnumApplyGhcOptions$fEqApplyGhcOptions$fOrdApplyGhcOptions$fReadApplyGhcOptions$fShowApplyGhcOptionsApplyProgOptions APOTargets APOLocals APOEverything$fFromJSONApplyProgOptions$fBoundedApplyProgOptions$fEnumApplyProgOptions$fEqApplyProgOptions$fOrdApplyProgOptions$fReadApplyProgOptions$fShowApplyProgOptions BuildCommandBuildTestHaddockBenchInstall FileWatchOpts NoFileWatch FileWatch FileWatchPoll BuildSubsetBSAllBSOnlySnapshotBSOnlyDependencies BSOnlyLocals ApplyCLIFlagACFAllProjectPackages ACFByName BuildOptsCLI$sel:targetsCLI:BuildOptsCLI$sel:dryrun:BuildOptsCLI$sel:ghcOptions:BuildOptsCLI$sel:progsOptions:BuildOptsCLI$sel:flags:BuildOptsCLI$sel:buildSubset:BuildOptsCLI$sel:fileWatch:BuildOptsCLI$sel:watchAll:BuildOptsCLI$sel:exec:BuildOptsCLI$sel:onlyConfigure:BuildOptsCLI$sel:command:BuildOptsCLI#$sel:initialBuildSteps:BuildOptsCLIdefaultBuildOptsCLIboptsCLIAllProgOptionsboptsCLIFlagsByName$fShowBuildOptsCLI$fEqBuildCommand$fShowBuildCommand$fShowFileWatchOpts$fEqFileWatchOpts$fShowBuildSubset$fEqBuildSubset$fEqApplyCLIFlag$fOrdApplyCLIFlag$fShowApplyCLIFlagreadFlagProgressBarFormatNoBar CountOnlyBar CappedBarFullBarCabalVerbosityBenchmarkOptsMonoid'$sel:additionalArgs:BenchmarkOptsMonoid#$sel:disableRun:BenchmarkOptsMonoidHaddockOptsMonoid%$sel:additionalArgs:HaddockOptsMonoidTestOptsMonoid$sel:rerunTests:TestOptsMonoid"$sel:additionalArgs:TestOptsMonoid$sel:coverage:TestOptsMonoid$sel:disableRun:TestOptsMonoid&$sel:maximumTimeSeconds:TestOptsMonoid$sel:allowStdin:TestOptsMonoidBuildOptsMonoid$sel:trace:BuildOptsMonoid$sel:profile:BuildOptsMonoid$sel:noStrip:BuildOptsMonoid$sel:libProfile:BuildOptsMonoid$sel:exeProfile:BuildOptsMonoid$sel:libStrip:BuildOptsMonoid$sel:exeStrip:BuildOptsMonoid"$sel:buildHaddocks:BuildOptsMonoid $sel:haddockOpts:BuildOptsMonoid!$sel:openHaddocks:BuildOptsMonoid $sel:haddockDeps:BuildOptsMonoid$$sel:haddockInternal:BuildOptsMonoid+$sel:haddockHyperlinkSource:BuildOptsMonoid&$sel:haddockForHackage:BuildOptsMonoid $sel:installExes:BuildOptsMonoid($sel:installCompilerTool:BuildOptsMonoid$sel:preFetch:BuildOptsMonoid$sel:keepGoing:BuildOptsMonoid!$sel:keepTmpFiles:BuildOptsMonoid$sel:forceDirty:BuildOptsMonoid$sel:tests:BuildOptsMonoid$sel:testOpts:BuildOptsMonoid$sel:benchmarks:BuildOptsMonoid"$sel:benchmarkOpts:BuildOptsMonoid $sel:reconfigure:BuildOptsMonoid!$sel:cabalVerbose:BuildOptsMonoid$sel:splitObjs:BuildOptsMonoid#$sel:skipComponents:BuildOptsMonoid&$sel:interleavedOutput:BuildOptsMonoid $sel:progressBar:BuildOptsMonoid$sel:ddumpDir:BuildOptsMonoidtoFirstCabalVerbositybuildOptsMonoidHaddockLbuildOptsMonoidTestsLbuildOptsMonoidBenchmarksLbuildOptsMonoidInstallExesLreadProgressBarFormat$fMonoidTestOptsMonoid$fSemigroupTestOptsMonoid$fFromJSONWithJSONWarnings$fMonoidHaddockOptsMonoid$fSemigroupHaddockOptsMonoid$fFromJSONWithJSONWarnings0$fMonoidBenchmarkOptsMonoid$fSemigroupBenchmarkOptsMonoid$fFromJSONWithJSONWarnings1$fParsecCabalVerbosity$fFromJSONCabalVerbosity$fFromJSONProgressBarFormat$fMonoidBuildOptsMonoid$fSemigroupBuildOptsMonoid$fFromJSONWithJSONWarnings2$fGenericBuildOptsMonoid$fShowBuildOptsMonoid$fEqProgressBarFormat$fShowProgressBarFormat$fEqCabalVerbosity$fShowCabalVerbosity$fGenericBenchmarkOptsMonoid$fShowBenchmarkOptsMonoid$fGenericHaddockOptsMonoid$fShowHaddockOptsMonoid$fShowTestOptsMonoid$fGenericTestOptsMonoid BenchmarkOpts!$sel:additionalArgs:BenchmarkOpts$sel:disableRun:BenchmarkOptsTestOpts$sel:rerunTests:TestOpts$sel:additionalArgs:TestOpts$sel:coverage:TestOpts$sel:disableRun:TestOpts $sel:maximumTimeSeconds:TestOpts$sel:allowStdin:TestOpts HaddockOpts$sel:additionalArgs:HaddockOpts BuildOpts$sel:libProfile:BuildOpts$sel:exeProfile:BuildOpts$sel:libStrip:BuildOpts$sel:exeStrip:BuildOpts$sel:buildHaddocks:BuildOpts$sel:haddockOpts:BuildOpts$sel:openHaddocks:BuildOpts$sel:haddockDeps:BuildOpts$sel:haddockInternal:BuildOpts%$sel:haddockHyperlinkSource:BuildOpts $sel:haddockForHackage:BuildOpts$sel:installExes:BuildOpts"$sel:installCompilerTool:BuildOpts$sel:preFetch:BuildOpts$sel:keepGoing:BuildOpts$sel:keepTmpFiles:BuildOpts$sel:forceDirty:BuildOpts$sel:tests:BuildOpts$sel:testOpts:BuildOpts$sel:benchmarks:BuildOpts$sel:benchmarkOpts:BuildOpts$sel:reconfigure:BuildOpts$sel:cabalVerbose:BuildOpts$sel:splitObjs:BuildOpts$sel:skipComponents:BuildOpts $sel:interleavedOutput:BuildOpts$sel:progressBar:BuildOpts$sel:ddumpDir:BuildOptsbuildOptsInstallExesLbuildOptsHaddockL$fShowBuildOpts$fEqBenchmarkOpts$fShowBenchmarkOpts $fEqTestOpts$fShowTestOpts$fEqHaddockOpts$fShowHaddockOptstestOptsParserhaddockOptsParserbenchOptsParserdefaultBuildOptsdefaultTestOptsdefaultHaddockOptsdefaultBenchmarkOptsbuildOptsFromMonoidhaddockOptsFromMonoidtestOptsFromMonoidbenchmarkOptsFromMonoidCabalConfigKey CCKTargets CCKLocals CCKEverything CCKPackageparseCabalConfigKey$fFromJSONKeyCabalConfigKey$fFromJSONCabalConfigKey$fShowCabalConfigKey$fReadCabalConfigKey$fEqCabalConfigKey$fOrdCabalConfigKeyCasaOptsMonoid$sel:enable:CasaOptsMonoid$sel:repoPrefix:CasaOptsMonoid%$sel:maxKeysPerRequest:CasaOptsMonoid$fMonoidCasaOptsMonoid$fSemigroupCasaOptsMonoid$fGenericCasaOptsMonoid$fShowCasaOptsMonoid ColorWhen ColorNever ColorAlways ColorAuto readColorWhen$fFromJSONColorWhen $fEqColorWhen$fGenericColorWhen$fShowColorWhendefaultColorWhen CompilerBuildCompilerBuildStandardCompilerBuildSpecializedcompilerBuildNamecompilerBuildSuffixparseCompilerBuild$fFromJSONCompilerBuild$fShowCompilerBuildghcBuildParserStackUnqualCompName)$sel:unqualCompToText:StackUnqualCompName fromCabalName toCabalName$fDataStackUnqualCompName$fEqStackUnqualCompName$fGenericStackUnqualCompName$fHashableStackUnqualCompName$fIsStringStackUnqualCompName$fNFDataStackUnqualCompName$fOrdStackUnqualCompName$fReadStackUnqualCompName$fShowStackUnqualCompNameCurator$sel:skipTest:Curator$sel:expectTestFailure:Curator$sel:skipBenchmark:Curator#$sel:expectBenchmarkFailure:Curator$sel:skipHaddock:Curator!$sel:expectHaddockFailure:Curator$fToJSONCurator $fShowCurator DepLibrary$sel:main:DepLibrary$sel:subLib:DepLibraryDepType AsLibrary AsBuildToolDepValue$sel:versionRange:DepValue$sel:depType:DepValue getDepSublibisDepTypeLibrarycabalToStackDepcabalExeToStackDepcabalSetupDepsToStackDeplibraryDepFromVersionRange$fShowDepValue $fEqDepType $fShowDepType$fEqDepLibrary$fShowDepLibraryDependencyTree DotPayload$sel:version:DotPayload$sel:license:DotPayload$sel:location:DotPayload licenseText versionText$fToJSONDependencyTree$fEqDotPayload$fShowDotPayload DockerUser$sel:uid:DockerUser$sel:gid:DockerUser$sel:groups:DockerUser$sel:umask:DockerUserDockerEntrypoint$sel:user:DockerEntrypoint$fReadDockerEntrypoint$fShowDockerEntrypoint$fReadDockerUser$fShowDockerUserDotOpts$sel:includeExternal:DotOpts$sel:includeBase:DotOpts$sel:dependencyDepth:DotOpts$sel:prune:DotOpts$sel:dotTargets:DotOpts$sel:flags:DotOpts$sel:testTargets:DotOpts$sel:benchTargets:DotOpts$sel:globalHints:DotOpts DownloadInfo$sel:url:DownloadInfo$sel:contentLength:DownloadInfo$sel:sha1:DownloadInfo$sel:sha256:DownloadInfoparseDownloadInfoFromObject$fShowDownloadInfoDumpLogs DumpNoLogsDumpWarningLogs DumpAllLogs$fFromJSONDumpLogs$fBoundedDumpLogs$fEnumDumpLogs $fEqDumpLogs $fOrdDumpLogs$fReadDumpLogs$fShowDumpLogs EnvSettings$sel:includeLocals:EnvSettings&$sel:includeGhcPackagePath:EnvSettings$sel:stackExe:EnvSettings$sel:localeUtf8:EnvSettings$sel:keepGhcRts:EnvSettingsminimalEnvSettingsdefaultEnvSettingsplainEnvSettings$fEqEnvSettings$fOrdEnvSettings$fShowEnvSettings ExtraDirs$sel:bins:ExtraDirs$sel:includes:ExtraDirs$sel:libs:ExtraDirs$fMonoidExtraDirs$fSemigroupExtraDirs$fShowExtraDirs$fGenericExtraDirsFileDigestCachenewFileDigestCachereadFileDigestGHCDownloadInfo"$sel:configureOpts:GHCDownloadInfo!$sel:configureEnv:GHCDownloadInfo!$sel:downloadInfo:GHCDownloadInfo$fShowGHCDownloadInfo HasGHCVariant ghcVariantL GHCVariant GHCStandardGHCIntegerSimpleGHCNativeBignum GHCCustomghcVariantNameghcVariantSuffixparseGHCVariant$fFromJSONGHCVariant$fHasGHCVariantGHCVariant$fShowGHCVariantghcVariantParser GhcOptionKeyGOKOldEverything GOKEverything GOKLocals GOKTargets GOKPackage$fFromJSONKeyGhcOptionKey$fEqGhcOptionKey$fOrdGhcOptionKey GhcOptions$sel:ghcOptions:GhcOptions$fFromJSONGhcOptionsGhcPkgId parseGhcPkgIdghcPkgIdParserghcPkgIdString unGhcPkgId$fExceptionGhcPkgIdParseFail$fToJSONGhcPkgId$fFromJSONGhcPkgId$fReadGhcPkgId$fShowGhcPkgId$fNFDataGhcPkgId$fHashableGhcPkgId$fDataGhcPkgId $fEqGhcPkgId$fGenericGhcPkgId $fOrdGhcPkgId$fPersistFieldGhcPkgId$fPersistFieldSqlGhcPkgId$fShowGhcPkgIdParseFail UpgradeCheckConfigCacheTypeConfigCacheTypeConfigConfigCacheTypeFlagLibraryConfigCacheTypeFlagExecutable $fPersistFieldSqlConfigCacheType$fPersistFieldConfigCacheType$fPersistFieldSqlAction$fPersistFieldAction $fEqAction $fOrdAction $fShowAction$fEqConfigCacheType$fShowConfigCacheType InstalledInstalledLibraryInfoghcPkgIdlicensesubLib InstalledMap InstallMapPackageDbVarietyGlobalDbExtraDb WriteOnlyDb MutableDbPackageDatabase GlobalPkgDb UserPkgDbInstalledPackageLocation InstalledTo ExtraPkgDbInstallLocationSnapLocaltoPackageDbVariety installedLibraryInfoFromGhcPkgIdsimpleInstalledLibinstalledToPackageIdOptinstalledPackageIdentifierfoldOnGhcPkgId'installedVersion$fMonoidInstallLocation$fSemigroupInstallLocation $fEqInstalled$fShowInstalled$fEqInstalledLibraryInfo$fShowInstalledLibraryInfo$fEqPackageDbVariety$fShowPackageDbVariety$fEqPackageDatabase$fShowPackageDatabase$fEqInstalledPackageLocation$fShowInstalledPackageLocation$fEqInstallLocation$fShowInstallLocation IsMutableMutable Immutable$fMonoidIsMutable$fSemigroupIsMutable $fEqIsMutable$fShowIsMutableLockFileBehavior LFBReadWrite LFBReadOnly LFBIgnoreLFBErrorOnWritereadLockFileBehavior$fBoundedLockFileBehavior$fEnumLockFileBehavior$fShowLockFileBehaviorNamedComponentCLibCSubLibCFlibCExeCTestCBenchrenderComponentTorenderComponentrenderPkgComponentsrenderPkgComponent exeComponentstestComponentsbenchComponentssubLibComponentsisCLib isCSubLibisCExeisCTestisCBenchisPotentialDependencysplitComponents$fEqNamedComponent$fOrdNamedComponent$fShowNamedComponentHasComponentInfo HasBuildInfoHasNameStackBuildInfo$sel:buildable:StackBuildInfo$sel:dependency:StackBuildInfo $sel:unknownTools:StackBuildInfo $sel:otherModules:StackBuildInfo$sel:jsSources:StackBuildInfo $sel:hsSourceDirs:StackBuildInfo$sel:cSources:StackBuildInfo$sel:cppOptions:StackBuildInfo&$sel:targetBuildDepends:StackBuildInfo$sel:options:StackBuildInfo $sel:allLanguages:StackBuildInfo"$sel:usedExtensions:StackBuildInfo$sel:includeDirs:StackBuildInfo$sel:extraLibs:StackBuildInfo $sel:extraLibDirs:StackBuildInfo$sel:frameworks:StackBuildInfoStackBenchmark$sel:name:StackBenchmark$sel:buildInfo:StackBenchmark$sel:interface:StackBenchmarkStackTestSuite$sel:name:StackTestSuite$sel:buildInfo:StackTestSuite$sel:interface:StackTestSuiteStackExecutable$sel:name:StackExecutable$sel:buildInfo:StackExecutable$sel:modulePath:StackExecutableStackForeignLibrary$sel:name:StackForeignLibrary"$sel:buildInfo:StackForeignLibrary StackLibrary$sel:name:StackLibrary$sel:buildInfo:StackLibrary $sel:exposedModules:StackLibrary;$fHasFieldSymbol"qualifiedName"StackBenchmarkNamedComponent;$fHasFieldSymbol"qualifiedName"StackTestSuiteNamedComponent<$fHasFieldSymbol"qualifiedName"StackExecutableNamedComponent$fHasFieldSymbol"qualifiedName"StackForeignLibraryNamedComponent9$fHasFieldSymbol"qualifiedName"StackLibraryNamedComponent$fShowStackLibrary$fShowStackForeignLibrary$fShowStackExecutable$fShowStackTestSuite$fShowStackBenchmark$fShowStackBuildInfo $fDataExeName $fEqExeName$fHashableExeName$fIsStringExeName$fGenericExeName$fNFDataExeName $fOrdExeName $fShowExeName SublibDump$sel:packageName:SublibDump$sel:libraryName:SublibDump DumpPackage$sel:ghcPkgId:DumpPackage$sel:packageIdent:DumpPackage$sel:sublib:DumpPackage$sel:license:DumpPackage$sel:libDirs:DumpPackage$sel:libraries:DumpPackage"$sel:hasExposedModules:DumpPackage$sel:exposedModules:DumpPackage$sel:depends:DumpPackage"$sel:haddockInterfaces:DumpPackage$sel:haddockHtml:DumpPackage$sel:isExposed:DumpPackagedpParentLibIdent$fEqDumpPackage$fReadDumpPackage$fShowDumpPackage$fEqSublibDump$fReadSublibDump$fShowSublibDumpCompCollectionfoldAndMakeCollectiongetBuildableSetgetBuildableSetTextgetBuildableListTextgetBuildableListAshasBuildableComponentcollectionLookupcollectionKeyValueListcollectionMember foldComponentToAnotherCollection$fFoldableCompCollection$fMonoidCompCollection$fSemigroupCompCollection$fShowCompCollectionstackUnqualToQualfoldOnNameAndBuildInfostackLibraryFromCabalstackExecutableFromCabalstackForeignLibraryFromCabalstackBenchmarkFromCabalstackTestFromCabalisComponentBuildablecomponentDependencyMap NixOptsMonoid$sel:enable:NixOptsMonoid$sel:pureShell:NixOptsMonoid$sel:packages:NixOptsMonoid$sel:initFile:NixOptsMonoid$sel:shellOptions:NixOptsMonoid$sel:path:NixOptsMonoid$sel:addGCRoots:NixOptsMonoidNixOpts$sel:enable:NixOpts$sel:pureShell:NixOpts$sel:packages:NixOpts$sel:initFile:NixOpts$sel:shellOptions:NixOpts$sel:addGCRoots:NixOptsnixEnableArgNamenixPureShellArgNamenixPackagesArgNamenixInitFileArgNamenixShellOptsArgNamenixPathArgNamenixAddGCRootsArgName$fMonoidNixOptsMonoid$fSemigroupNixOptsMonoid$fEqNixOptsMonoid$fGenericNixOptsMonoid$fShowNixOptsMonoid $fShowNixOptspackageNameArgument HasPlatform platformLplatformVariantLPlatformVariantPlatformVariantNoneplatformVariantSuffixplatformOnlyRelDir$fHasPlatform(,)Project$sel:userMsg:Project$sel:packages:Project$sel:extraDeps:Project$sel:flagsByPkg:Project$sel:resolver:Project$sel:compiler:Project$sel:extraPackageDBs:Project$sel:curator:Project$sel:dropPackages:Project$fToJSONProject $fShowProject ProjectConfig PCProjectPCGlobalProject PCNoProjectisPCGlobalProject PvpBoundspbType pbAsRevision PvpBoundsType PvpBoundsNonePvpBoundsUpperPvpBoundsLower PvpBoundsBoth pvpBoundsTextparsePvpBounds$fFromJSONPvpBounds$fToJSONPvpBounds $fEqPvpBounds$fOrdPvpBounds$fReadPvpBounds$fShowPvpBounds$fBoundedPvpBoundsType$fEnumPvpBoundsType$fEqPvpBoundsType$fOrdPvpBoundsType$fReadPvpBoundsType$fShowPvpBoundsType Snapshots$sel:nightly:Snapshots$sel:lts:SnapshotsAbstractResolverARLatestNightly ARLatestLTSARLatestLTSMajor ARResolverARGlobalreadAbstractResolver!$fExceptionTypesResolverException$fDisplayAbstractResolver$fShowAbstractResolver$fFromJSONSnapshots$fShowSnapshots$fShowTypesResolverExceptionabstractResolverOptsParsercompilerOptsParserreadCompilerVersionSCMGit $fToJSONSCM $fFromJSONSCM $fShowSCM StackYamlLoc SYLDefault SYLOverride SYLNoProjectSYLGlobalProject$fShowStackYamlLocProjectStorageprojectStorage UserStorage userStorageStoragePrettyExceptionStorageMigrationFailure!$fExceptionStoragePrettyException$fPrettyStoragePrettyException$fShowStoragePrettyException updateSet updateListhandleMigrationException RepoServiceGitHubGitLab BitbucketRepoTemplatePathserviceusertemplate TemplatePathAbsPathRelPathUrlPathRepoPath TemplateNametemplateNameArgumenttemplateParamArgumentparseTemplateNameFromStringdefaultTemplateName templateName templatePathparseRepoPathWithService$$fExceptionTypeTemplateNameException$fFromJSONTemplateName$fEqTemplateName$fOrdTemplateName$fShowTemplateName$fEqTemplatePath$fOrdTemplatePath$fShowTemplatePath$fEqRepoTemplatePath$fOrdRepoTemplatePath$fShowRepoTemplatePath$fEqRepoService$fOrdRepoService$fShowRepoService$fShowTypeTemplateNameException UnusedFlags UFNoPackageUFFlagsNotDefined UFSnapshot FlagSource FSCommandLine FSStackYaml$fEqUnusedFlags$fOrdUnusedFlags$fShowUnusedFlags$fEqFlagSource$fOrdFlagSource$fShowFlagSource VersionCheck MatchMinor MatchExact NewerMinorIntersectingVersionRange6$sel:intersectingVersionRange:IntersectingVersionRangeversionRangeTextintersectVersionRangestoMajorVersionlatestApplicableVersionnextMajorVersion checkVersion minorVersion stackVersionshowStackVersionstackMinorVersionstackMajorVersion $fMonoidIntersectingVersionRange#$fSemigroupIntersectingVersionRange$fFromJSONVersionCheck$fToJSONVersionCheck$fEqVersionCheck$fOrdVersionCheck$fShowVersionCheck$fShowIntersectingVersionRange ParentMapCompilerRepositoryActualCompilerACGhcACGhcGit WhichCompilerGhcCompilerExceptionGhcjsNotSupportedwantedToActualactualToWantedparseActualCompilercompilerVersionTextcompilerVersionString whichCompilerisWantedCompiler getGhcVersiondefaultCompilerRepositorywhichCompilerL$fExceptionCompilerException$fPersistFieldSqlActualCompiler$fPersistFieldActualCompiler$fFromJSONKeyActualCompiler$fFromJSONActualCompiler$fToJSONActualCompiler$fDisplayActualCompiler$fNFDataActualCompiler$fFromJSONCompilerRepository$fShowCompilerRepository$fDataActualCompiler$fEqActualCompiler$fGenericActualCompiler$fOrdActualCompiler$fShowActualCompiler$fEqWhichCompiler$fOrdWhichCompiler$fShowWhichCompiler$fShowCompilerException SourceMapHash SourceMap$sel:targets:SourceMap$sel:compiler:SourceMap$sel:project:SourceMap$sel:deps:SourceMap$sel:globalPkgs:SourceMap SMTargets$sel:targets:SMTargets$sel:deps:SMTargets PackageType PTProject PTDependency TargetAll TargetCompsGlobalPackageVersionSMActual$sel:compiler:SMActual$sel:project:SMActual$sel:deps:SMActual$sel:globals:SMActualSMWanted$sel:compiler:SMWanted$sel:project:SMWanted$sel:deps:SMWanted$sel:snapshotLocation:SMWanted GlobalPackageReplacedGlobalPackageProjectPackage!$sel:projectCommon:ProjectPackage$sel:cabalFP:ProjectPackage$sel:resolvedDir:ProjectPackage DepPackage$sel:depCommon:DepPackage$sel:location:DepPackage$sel:hidden:DepPackage$sel:fromSnapshot:DepPackage FromSnapshotNotFromSnapshot CommonPackage$sel:gpd:CommonPackage$sel:name:CommonPackage$sel:flags:CommonPackage$sel:ghcOptions:CommonPackage"$sel:cabalConfigOpts:CommonPackage $sel:buildHaddocks:CommonPackageisReplacedGlobalsmRelDirppGPDppRoot ppComponentsppComponentsMaybe ppVersion$fEqPackageType$fShowPackageType$fEqGlobalPackage$fShowFromSnapshot GhcPkgExe HasCompilercompilerPathsL CompilerPaths"$sel:compilerVersion:CompilerPaths$sel:arch:CompilerPaths$sel:build:CompilerPaths$sel:compiler:CompilerPaths$sel:pkg:CompilerPaths$sel:interpreter:CompilerPaths$sel:haddock:CompilerPaths$sel:sandboxed:CompilerPaths$sel:cabalVersion:CompilerPaths$sel:globalDB:CompilerPaths$sel:ghcInfo:CompilerPaths$sel:globalDump:CompilerPaths cabalVersionLcompilerVersionLcpWhichgetCompilerPath getGhcPkgExe$fHasCompilerCompilerPaths$fShowCompilerPaths$fShowGhcPkgExeVersionedDownloadInfo"$sel:version:VersionedDownloadInfo'$sel:downloadInfo:VersionedDownloadInfo$fShowVersionedDownloadInfo SetupInfo$sel:sevenzExe:SetupInfo$sel:sevenzDll:SetupInfo$sel:msys2:SetupInfo$sel:ghcByVersion:SetupInfo$sel:stackByVersion:SetupInfo$fMonoidSetupInfo$fSemigroupSetupInfo$fShowSetupInfo osIsMacOS osIsWindowssetFileExecutablesetScriptPermsstackProgName' nixProgNamehaskellFileExtshaskellDefaultPreprocessorExtsstackProgNameUpper stackDotYamlstackWorkEnvVarstackRootEnvVarstackXdgEnvVarstackRootOptionNamestackGlobalConfigOptionNamepantryRootEnvVarinContainerEnvVarinNixShellEnvVarwiredInPackagescabalPackageName"implicitGlobalProjectDirDeprecatedimplicitGlobalProjectDirdefaultUserConfigPathDeprecateddefaultUserConfigPath!defaultGlobalConfigPathDeprecateddefaultGlobalConfigPath buildPlanDirbuildPlanCacheDirplatformVariantEnvVarcompilerOptionsCabalFlagghcColorForceFlagminTerminalWidthmaxTerminalWidthdefaultTerminalWidthrelFileSetupHsrelFileSetupLhsrelFileHpackPackageConfigrelDirGlobalAutogen relDirAutogen relDirLogsrelFileCabalMacrosH relDirBuild relDirBin relDirGhcirelDirGhciScript relDirPantryrelDirPrograms relDirRootrelDirUpperProgramsrelDirStackProgNamerelDirStackWorkrelFileReadmeTxt relDirScript relDirScriptsrelFileConfigYamlrelDirSnapshotsrelDirGlobalHintsrelFileGlobalHintsYaml relDirInstallrelDirCompilerTools relDirHooglerelFileDatabaseHoo relDirPkgdbrelFileStoragerelDirLoadedSnapshotCache bindirSuffix docDirSuffix htmlDirSuffix relDirHpc relDirLib relDirShare relDirLibexec relDirEtcsetupGhciShimCoderelDirSetupExeCacherelDirSetupExeSrcrelFileConfigure relDirDistrelFileSetupMacrosH relDirSetuprelFileSetupLower relDirMingw relDirMingw32 relDirMingw64 relDirLocal relDirUsr relDirIncluderelFileIndexHtml relDirAllrelFilePackageCacherelFileDockerfilerelFileGhciScriptrelDirCombinedrelFileHpcIndexHtml relDirCustomrelDirPackageConfInplacerelDirExtraTixFilesrelDirInstalledPackagesbackupUrlRelPathrelDirDotLocal relDirDotSshrelDirDotStackProgNamerelDirUnderHome relDirSrcrelFileLibcMuslx86_64So1relFileLibtinfoSo5relFileLibtinfoSo6relFileLibncurseswSo6relFileLibgmpSo10relFileLibgmpSo3relDirNewCabalrelFileSetupExerelFileSetupUpper relFile7zexe relFile7zdll relFileMainHsrelFileStackDotExerelFileStackDotTmpDotExerelFileStackDotTmp relFileStackghcShowOptionsOutput ghcBootScriptghcConfigureScriptghcConfigureWindowsghcConfigureMacOSghcConfigurePosix relDirHadrianrelFileHadrianStackDotYamlhadrianScriptsWindowshadrianScriptsPosixtestGhcEnvRelFilerelFileBuildLockstackDeveloperModeDefaultisStackUploadDisabled globalFootergitHubBasicAuthTypegitHubTokenEnvVaraltGitHubTokenEnvVarhackageBaseUrl$fExceptionConstantsException$fShowConstantsExceptionVersionRangeJSON&$sel:versionRangeJSON:VersionRangeJSONDockerMonoidRepoOrImageDockerMonoidRepoDockerMonoidImageMountDockerStackExeDockerStackExeDownloadDockerStackExeHostDockerStackExeImageDockerStackExePathDockerOptsMonoid#$sel:defaultEnable:DockerOptsMonoid$sel:enable:DockerOptsMonoid!$sel:repoOrImage:DockerOptsMonoid#$sel:registryLogin:DockerOptsMonoid&$sel:registryUsername:DockerOptsMonoid&$sel:registryPassword:DockerOptsMonoid$sel:autoPull:DockerOptsMonoid$sel:detach:DockerOptsMonoid$sel:persist:DockerOptsMonoid#$sel:containerName:DockerOptsMonoid$sel:network:DockerOptsMonoid$sel:runArgs:DockerOptsMonoid$sel:mount:DockerOptsMonoid$sel:mountMode:DockerOptsMonoid$sel:env:DockerOptsMonoid$sel:stackExe:DockerOptsMonoid$sel:setUser:DockerOptsMonoid*$sel:requireDockerVersion:DockerOptsMonoid DockerOpts$sel:enable:DockerOpts$sel:image:DockerOpts$sel:registryLogin:DockerOpts $sel:registryUsername:DockerOpts $sel:registryPassword:DockerOpts$sel:autoPull:DockerOpts$sel:detach:DockerOpts$sel:persist:DockerOpts$sel:containerName:DockerOpts$sel:network:DockerOpts$sel:runArgs:DockerOpts$sel:mount:DockerOpts$sel:mountMode:DockerOpts$sel:env:DockerOpts$sel:stackExe:DockerOpts$sel:setUser:DockerOpts$$sel:requireDockerVersion:DockerOptsDockerExceptionDockerMustBeEnabledExceptionOnlyOnHostExceptionInspectFailedExceptionNotPulledExceptionInvalidImagesOutputExceptionInvalidPSOutputExceptionInvalidInspectOutputExceptionPullFailedExceptionDockerTooOldException DockerVersionProhibitedExceptionBadDockerVersionExceptionInvalidVersionOutputExceptionHostStackTooOldExceptionContainerStackTooOldException#CannotDetermineProjectRootExceptionDockerNotInstalledException(UnsupportedStackExeHostPlatformExceptionDockerStackExeParseExceptionparseDockerStackExedockerEnableArgNamedockerRepoArgNamedockerImageArgNamedockerRegistryLoginArgNamedockerRegistryUsernameArgNamedockerRegistryPasswordArgNamedockerAutoPullArgNamedockerDetachArgNamedockerRunArgsArgNamedockerMountArgNamedockerMountModeArgNamedockerEnvArgNamedockerContainerNameArgNamedockerNetworkArgNamedockerPersistArgNamedockerStackExeArgNamedockerStackExeDownloadValdockerStackExeHostValdockerStackExeImageValdockerSetUserArgName!dockerRequireDockerVersionArgNamedockerEntrypointArgName dockerCmdNamedockerHelpOptNamedockerPullCmdName reExecArgNamedockerContainerPlatform$fExceptionDockerException$fFromJSONDockerStackExe$fFromJSONMount $fShowMount $fReadMount$fMonoidDockerOptsMonoid$fSemigroupDockerOptsMonoid$fFromJSONVersionRangeJSON$fShowDockerOptsMonoid$fGenericDockerOptsMonoid$fShowDockerMonoidRepoOrImage$fShowDockerOpts$fShowDockerStackExe$fShowDockerException ConfigMonoid$sel:stackRoot:ConfigMonoid$sel:workDir:ConfigMonoid$sel:buildOpts:ConfigMonoid$sel:dockerOpts:ConfigMonoid$sel:nixOpts:ConfigMonoid!$sel:connectionCount:ConfigMonoid$sel:hideTHLoading:ConfigMonoid"$sel:prefixTimestamps:ConfigMonoid $sel:latestSnapshot:ConfigMonoid$sel:packageIndex:ConfigMonoid $sel:packageIndices:ConfigMonoid$sel:systemGHC:ConfigMonoid$sel:installGHC:ConfigMonoid$sel:skipGHCCheck:ConfigMonoid$sel:skipMsys:ConfigMonoid$sel:compilerCheck:ConfigMonoid$$sel:compilerRepository:ConfigMonoid%$sel:requireStackVersion:ConfigMonoid$sel:arch:ConfigMonoid$sel:ghcVariant:ConfigMonoid$sel:ghcBuild:ConfigMonoid$sel:jobs:ConfigMonoid"$sel:extraIncludeDirs:ConfigMonoid$sel:extraLibDirs:ConfigMonoid($sel:customPreprocessorExts:ConfigMonoid!$sel:overrideGccPath:ConfigMonoid$sel:overrideHpack:ConfigMonoid!$sel:concurrentTests:ConfigMonoid$sel:localBinPath:ConfigMonoid$$sel:templateParameters:ConfigMonoid$sel:scmInit:ConfigMonoid"$sel:ghcOptionsByName:ConfigMonoid!$sel:ghcOptionsByCat:ConfigMonoid!$sel:cabalConfigOpts:ConfigMonoid$sel:extraPath:ConfigMonoid$$sel:setupInfoLocations:ConfigMonoid!$sel:setupInfoInline:ConfigMonoid#$sel:localProgramsBase:ConfigMonoid$sel:pvpBounds:ConfigMonoid $sel:modifyCodePage:ConfigMonoid#$sel:rebuildGhcOptions:ConfigMonoid!$sel:applyGhcOptions:ConfigMonoid"$sel:applyProgOptions:ConfigMonoid$sel:allowNewer:ConfigMonoid $sel:allowNewerDeps:ConfigMonoid!$sel:defaultTemplate:ConfigMonoid$$sel:allowDifferentUser:ConfigMonoid$sel:dumpLogs:ConfigMonoid"$sel:saveHackageCreds:ConfigMonoid $sel:hackageBaseUrl:ConfigMonoid$sel:colorWhen:ConfigMonoid$sel:styles:ConfigMonoid!$sel:hideSourcePaths:ConfigMonoid"$sel:recommendUpgrade:ConfigMonoid#$sel:notifyIfNixOnPath:ConfigMonoid%$sel:notifyIfGhcUntested:ConfigMonoid'$sel:notifyIfCabalUntested:ConfigMonoid%$sel:notifyIfArchUnknown:ConfigMonoid$sel:casaOpts:ConfigMonoid $sel:casaRepoPrefix:ConfigMonoid"$sel:snapshotLocation:ConfigMonoid$sel:noRunCompile:ConfigMonoid$$sel:stackDeveloperMode:ConfigMonoidparseConfigMonoidparseConfigMonoidObjectconfigMonoidSystemGHCNameconfigMonoidInstallGHCNameconfigMonoidGHCVariantName"configMonoidAllowDifferentUserName$fMonoidConfigMonoid$fSemigroupConfigMonoid$fGenericConfigMonoid$fShowConfigMonoidProjectAndConfigMonoidparseProjectAndConfigMonoidGlobalOptsMonoid#$sel:reExecVersion:GlobalOptsMonoid&$sel:dockerEntrypoint:GlobalOptsMonoid$sel:logLevel:GlobalOptsMonoid$sel:timeInLog:GlobalOptsMonoid$sel:rslInLog:GlobalOptsMonoid$sel:planInLog:GlobalOptsMonoid"$sel:configMonoid:GlobalOptsMonoid$sel:resolver:GlobalOptsMonoid"$sel:resolverRoot:GlobalOptsMonoid$sel:compiler:GlobalOptsMonoid$sel:terminal:GlobalOptsMonoid$sel:styles:GlobalOptsMonoid"$sel:termWidthOpt:GlobalOptsMonoid$sel:stackYaml:GlobalOptsMonoid&$sel:lockFileBehavior:GlobalOptsMonoid$fMonoidGlobalOptsMonoid$fSemigroupGlobalOptsMonoid$fGenericGlobalOptsMonoid GlobalOpts$sel:reExecVersion:GlobalOpts $sel:dockerEntrypoint:GlobalOpts$sel:logLevel:GlobalOpts$sel:timeInLog:GlobalOpts$sel:rslInLog:GlobalOpts$sel:planInLog:GlobalOpts$sel:configMonoid:GlobalOpts$sel:resolver:GlobalOpts$sel:compiler:GlobalOpts$sel:terminal:GlobalOpts$sel:stylesUpdate:GlobalOpts$sel:termWidthOpt:GlobalOpts$sel:stackYaml:GlobalOpts $sel:lockFileBehavior:GlobalOptsglobalOptsBuildOptsMonoidL$fShowGlobalOptsHasDockerEntrypointMVardockerEntrypointMVarL HasRunnerrunnerLRunner$sel:globalOpts:Runner$sel:useColor:Runner$sel:logFunc:Runner$sel:termWidth:Runner$sel:processContext:Runner $sel:dockerEntrypointMVar:Runner stackYamlLocLlockFileBehaviorL globalOptsL terminalLreExecL rslInLogL$fHasTermRunner$fHasStylesUpdateRunner$fHasProcessContextRunner$fHasLogFuncRunner$fHasRunnerRunner$fHasDockerEntrypointMVarRunner AddCommandcomplicatedOptions addCommandaddSubCommandscomplicatedParserParseAbsolutePathExceptionConfigPrettyExceptionParseConfigFileExceptionStackWorkEnvNotRelativeDirMultiplePackageIndicesDuplicateLocalPackageNamesConfigExceptionParseCustomSnapshotExceptionNoProjectConfigFoundUnexpectedArchiveContentsUnableToExtractArchiveBadStackVersionExceptionNoSuchDirectoryParseGHCVariantException BadStackRoot3Won'tCreateStackRootInDirectoryOwnedByDifferentUserUserDoesn'tOwnDirectory4ManualGHCVariantSettingsAreIncompatibleWithSystemGHCNixRequiresSystemGhcNoResolverWhenUsingNoProjectNoLTSWithMajorVersion NoLTSFoundpackageIndicesWarning$fExceptionConfigException $fExceptionConfigPrettyException$fPrettyConfigPrettyException%$fExceptionParseAbsolutePathException $fShowParseAbsolutePathException$fShowConfigPrettyException$fShowConfigException HasConfigconfigLConfig$sel:workDir:Config$sel:userConfigPath:Config$sel:build:Config$sel:docker:Config$sel:nix:Config"$sel:processContextSettings:Config$sel:localProgramsBase:Config$sel:localPrograms:Config$sel:hideTHLoading:Config$sel:prefixTimestamps:Config$sel:platform:Config$sel:platformVariant:Config$sel:ghcVariant:Config$sel:ghcBuild:Config$sel:latestSnapshot:Config$sel:systemGHC:Config$sel:installGHC:Config$sel:skipGHCCheck:Config$sel:skipMsys:Config$sel:compilerCheck:Config$sel:compilerRepository:Config$sel:localBin:Config$sel:requireStackVersion:Config$sel:jobs:Config$sel:overrideGccPath:Config$sel:extraIncludeDirs:Config$sel:extraLibDirs:Config"$sel:customPreprocessorExts:Config$sel:concurrentTests:Config$sel:templateParams:Config$sel:scmInit:Config$sel:ghcOptionsByName:Config$sel:ghcOptionsByCat:Config$sel:cabalConfigOpts:Config$sel:setupInfoLocations:Config$sel:setupInfoInline:Config$sel:pvpBounds:Config$sel:modifyCodePage:Config$sel:rebuildGhcOptions:Config$sel:applyGhcOptions:Config$sel:applyProgOptions:Config$sel:allowNewer:Config$sel:allowNewerDeps:Config$sel:defaultTemplate:Config$sel:allowDifferentUser:Config$sel:dumpLogs:Config$sel:project:Config$sel:allowLocals:Config$sel:saveHackageCreds:Config$sel:hackageBaseUrl:Config$sel:runner:Config$sel:pantryConfig:Config$sel:stackRoot:Config$sel:resolver:Config$sel:userStorage:Config$sel:hideSourcePaths:Config$sel:recommendUpgrade:Config$sel:notifyIfNixOnPath:Config$sel:notifyIfGhcUntested:Config!$sel:notifyIfCabalUntested:Config$sel:notifyIfArchUnknown:Config$sel:noRunCompile:Config$sel:stackDeveloperMode:Config$sel:casa:ConfigconfigProjectRootaskLatestSnapshotUrlghcInstallHook stackRootLstackGlobalConfigL buildOptsLenvOverrideSettingsLworkDirLprettyStackDevL$fHasTermConfig$fHasStylesUpdateConfig$fHasLogFuncConfig$fHasRunnerConfig$fHasPantryConfigConfig$fHasProcessContextConfig$fHasGHCVariantConfig$fHasPlatformConfig$fHasConfigConfigHasBuildConfig buildConfigL BuildConfig$sel:config:BuildConfig$sel:smWanted:BuildConfig $sel:extraPackageDBs:BuildConfig$sel:stackYaml:BuildConfig$sel:projectStorage:BuildConfig$sel:curator:BuildConfig stackYamlL projectRootLgetProjectWorkDirwantedCompilerVersionL$fHasTermBuildConfig$fHasStylesUpdateBuildConfig$fHasLogFuncBuildConfig$fHasRunnerBuildConfig$fHasConfigBuildConfig$fHasPantryConfigBuildConfig$fHasProcessContextBuildConfig$fHasGHCVariantBuildConfig$fHasPlatformBuildConfig$fHasBuildConfigBuildConfigPackageComponentFile'$sel:modulePathMap:PackageComponentFile&$sel:cabalFileMap:PackageComponentFile*$sel:packageExtraFile:PackageComponentFile"$sel:warnings:PackageComponentFileStackPackageFile#$sel:extraSrcFiles:StackPackageFile$sel:dataDir:StackPackageFile$sel:dataFiles:StackPackageFilePackageWarningUnlistedModulesWarningDotCabalDescriptorDotCabalModule DotCabalMain DotCabalFile DotCabalCFile DotCabalPathDotCabalModulePathDotCabalMainPathDotCabalFilePathDotCabalCFilePathGetPackageFileContext$sel:file:GetPackageFileContext"$sel:distDir:GetPackageFileContext&$sel:buildConfig:GetPackageFileContext#$sel:cabalVer:GetPackageFileContext($fHasProcessContextGetPackageFileContext&$fHasPantryConfigGetPackageFileContext%$fHasBuildConfigGetPackageFileContext $fHasConfigGetPackageFileContext$fHasTermGetPackageFileContext&$fHasStylesUpdateGetPackageFileContext $fHasRunnerGetPackageFileContext!$fHasLogFuncGetPackageFileContext$$fHasGHCVariantGetPackageFileContext"$fHasPlatformGetPackageFileContext$fMonoidPackageComponentFile$fSemigroupPackageComponentFile$fShowStackPackageFile$fEqDotCabalDescriptor$fOrdDotCabalDescriptor$fShowDotCabalDescriptor$fEqDotCabalPath$fOrdDotCabalPath$fShowDotCabalPath HasSourceMap sourceMapL HasEnvConfig envConfigL EnvConfig$sel:buildConfig:EnvConfig$sel:buildOptsCLI:EnvConfig$sel:fileDigestCache:EnvConfig$sel:sourceMap:EnvConfig$sel:sourceMapHash:EnvConfig$sel:compilerPaths:EnvConfigshouldForceGhcColorFlagappropriateGhcColorFlag snapshotsDirinstallationRootDepsinstallationRootLocalhoogleDatabasePathplatformSnapAndCompilerRelplatformGhcRelDirbindirCompilerTools hoogleRootcompilerVersionDirpackageDatabaseDepspackageDatabaseLocalpackageDatabaseExtra hpcReportDir extraBinDirsactualCompilerVersionLplatformGhcVerOnlyRelDiruseShaPathOnWindowsshaPathForBytes$fHasTermEnvConfig$fHasStylesUpdateEnvConfig$fHasLogFuncEnvConfig$fHasRunnerEnvConfig$fHasCompilerEnvConfig$fHasPantryConfigEnvConfig$fHasProcessContextEnvConfig$fHasGHCVariantEnvConfig$fHasPlatformEnvConfig$fHasConfigEnvConfig$fHasSourceMapEnvConfig$fHasEnvConfigEnvConfig$fHasBuildConfigEnvConfig$fIsPathRelFile$fIsPathAbsFile$fIsPathRelDir$fIsPathAbsDirBioInput$sel:installMap:BioInput$sel:installedMap:BioInput$sel:cabalDir:BioInput$sel:distDir:BioInput$sel:omitPackages:BioInput$sel:addPackages:BioInput$sel:buildInfo:BioInput$sel:dotCabalPaths:BioInput$sel:configLibDirs:BioInput$sel:configIncludeDirs:BioInput$sel:componentName:BioInput$sel:cabalVersion:BioInput FileCacheInfo$sel:hash:FileCacheInfo MemoizedWith$sel:memoizedWith:MemoizedWith LocalPackage$sel:package:LocalPackage$sel:components:LocalPackage$sel:unbuildable:LocalPackage$sel:wanted:LocalPackage$sel:testBench:LocalPackage$sel:cabalFP:LocalPackage$sel:buildHaddocks:LocalPackage$sel:forceDirty:LocalPackage$sel:dirtyFiles:LocalPackage $sel:newBuildCaches:LocalPackage $sel:componentFiles:LocalPackage PackageSource PSFilePathPSRemote PackageConfig$sel:enableTests:PackageConfig#$sel:enableBenchmarks:PackageConfig$sel:flags:PackageConfig$sel:ghcOptions:PackageConfig"$sel:cabalConfigOpts:PackageConfig"$sel:compilerVersion:PackageConfig$sel:platform:PackageConfig BuildInfoOpts$sel:opts:BuildInfoOpts$sel:oneWordOpts:BuildInfoOpts$sel:packageFlags:BuildInfoOpts$sel:cabalMacros:BuildInfoOptsPackage$sel:name:Package$sel:version:Package$sel:license:Package$sel:ghcOptions:Package$sel:cabalConfigOpts:Package$sel:flags:Package$sel:defaultFlags:Package$sel:library:Package$sel:subLibraries:Package$sel:foreignLibraries:Package$sel:testSuites:Package$sel:benchmarks:Package$sel:executables:Package$sel:buildType:Package$sel:setupDeps:Package$sel:cabalSpec:Package$sel:file:Package$sel:testEnabled:Package$sel:benchmarkEnabled:PackageExeName$sel:exeName:ExeNamePackageExceptionPackageInvalidCabalFileMismatchedCabalIdentifierCabalFileNameParseFailCabalFileNameInvalidPackageNameComponentNotParsedBugpackageIdentifierpackageDefinedFlags psVersionmemoizeRefWithrunMemoizedWithlpFileslpFilesForComponentsdotCabalModule dotCabalMaindotCabalModulePathdotCabalMainPathdotCabalCFilePathdotCabalGetPathinstalledMapGhcPkgIdtoCabalMungedPackageName$fExceptionPackageException $fEqPackage $fOrdPackage$fShowMemoizedWith$fFromJSONFileCacheInfo$fToJSONFileCacheInfo$fNFDataFileCacheInfo$fShowPackageSource$fShowLocalPackage$fEqFileCacheInfo$fGenericFileCacheInfo$fShowFileCacheInfo$fApplicativeMemoizedWith$fFunctorMemoizedWith$fMonadMemoizedWith$fShowPackageConfig$fShowBuildInfoOpts $fShowPackage$fShowPackageException DotConfig$sel:buildConfig:DotConfig$sel:sourceMap:DotConfig$sel:globalDump:DotConfig$fHasSourceMapDotConfig$fHasBuildConfigDotConfig$fHasConfigDotConfig$fHasProcessContextDotConfig$fHasRunnerDotConfig$fHasPlatformDotConfig$fHasGHCVariantDotConfig$fHasStylesUpdateDotConfig$fHasTermDotConfig$fHasPantryConfigDotConfig$fHasLogFuncDotConfigwarnInstallSearchPathIssuesConfigDockerExceptionResolverNotSupportedException addDefaultTagdockerOptsFromMonoid $fExceptionConfigDockerException$fShowConfigDockerException ConfigureOpts$sel:pathRelated:ConfigureOpts!$sel:nonPathRelated:ConfigureOptsBaseConfigOpts$sel:snapDB:BaseConfigOpts$sel:localDB:BaseConfigOpts#$sel:snapInstallRoot:BaseConfigOpts$$sel:localInstallRoot:BaseConfigOpts$sel:buildOpts:BaseConfigOpts $sel:buildOptsCLI:BaseConfigOpts$sel:extraDBs:BaseConfigOpts configureOptsconfigureOptsPathRelatedconfigureOptsNonPathRelated$fNFDataConfigureOpts$fDataConfigureOpts$fEqConfigureOpts$fGenericConfigureOpts$fShowConfigureOpts$fShowBaseConfigOptsKeepOutputOpenKeepOpenCloseOnExceptionConvertPathsToAbsolute KeepPathsAsIsExcludeTHLoading KeepTHLoadingPrecompiledCache$sel:library:PrecompiledCache$sel:subLibs:PrecompiledCache$sel:exes:PrecompiledCachePlan$sel:tasks:Plan$sel:finals:Plan$sel:unregisterLocal:Plan$sel:installExes:PlanTaskTypeTTLocalMutableTTRemotePackageTaskConfigOpts$sel:missing:TaskConfigOpts$sel:opts:TaskConfigOptsTask$sel:taskType:Task$sel:configOpts:Task$sel:buildHaddocks:Task$sel:present:Task$sel:allInOne:Task$sel:cachePkgSrc:Task$sel:buildTypeConfig:Task CachePkgSrcCacheSrcUpstream CacheSrcLocal ConfigCache$sel:configureOpts:ConfigCache$sel:deps:ConfigCache$sel:components:ConfigCache$sel:buildHaddocks:ConfigCache$sel:pkgSrc:ConfigCache$sel:pathEnvVar:ConfigCache BuildCache$sel:times:BuildCache toCachePkgSrctaskAnyMissingtaskTypePackageIdentifier taskIsTargettaskTypeLocation taskLocation taskProvidestaskTargetIsMutableinstallLocationIsMutable$fNFDataBuildCache$fPersistFieldSqlCachePkgSrc$fPersistFieldCachePkgSrc$fNFDataCachePkgSrc$fNFDataConfigCache$fShowTaskConfigOpts$fNFDataPrecompiledCache$fNFDataPrecompiledCache0$fEqKeepOutputOpen$fEqPrecompiledCache$fGenericPrecompiledCache$fShowPrecompiledCache $fShowPlan $fShowTask$fShowTaskType$fDataConfigCache$fEqConfigCache$fGenericConfigCache$fShowConfigCache$fDataCachePkgSrc$fEqCachePkgSrc$fGenericCachePkgSrc$fReadCachePkgSrc$fShowCachePkgSrc$fEqBuildCache$fFromJSONBuildCache$fGenericBuildCache$fShowBuildCache$fToJSONBuildCache$fEqPkgDepsOracle$fNFDataPkgDepsOracle$fShowPkgDepsOracle$fExceptionStorageUserException$fShowStorageUserExceptionPrecompiledCacheKeyinitUserStorageprecompiledCacheKeyloadPrecompiledCachesavePrecompiledCacheloadDockerImageExeCachesaveDockerImageExeCacheloadCompilerPathssaveCompilerPathsupgradeChecksSincelogUpgradeCheck$$fSafeToInsertPrecompiledCacheParent3$fSymbolToField"library"PrecompiledCacheParentMaybe2$fSymbolToField"haddock"PrecompiledCacheParentBool<$fSymbolToField"optionsHash"PrecompiledCacheParentByteString5$fSymbolToField"packageKey"PrecompiledCacheParentText7$fSymbolToField"cabalVersion"PrecompiledCacheParentText3$fSymbolToField"compiler"PrecompiledCacheParentText9$fSymbolToField"platformGhcDir"PrecompiledCacheParentList,$fSymbolToField"id"PrecompiledCacheParentKey+$fAtLeastOneUniqueKeyPrecompiledCacheParent($fOnlyOneUniqueKeyPrecompiledCacheParent.$fToBackendKeySqlBackendPrecompiledCacheParent'$fPersistFieldSqlPrecompiledCacheParent$$fPersistFieldPrecompiledCacheParent%$fPersistEntityPrecompiledCacheParent$$fSafeToInsertPrecompiledCacheSubLib0$fSymbolToField"value"PrecompiledCacheSubLibList0$fSymbolToField"parent"PrecompiledCacheSubLibKey,$fSymbolToField"id"PrecompiledCacheSubLibKey+$fAtLeastOneUniqueKeyPrecompiledCacheSubLib($fOnlyOneUniqueKeyPrecompiledCacheSubLib.$fToBackendKeySqlBackendPrecompiledCacheSubLib'$fPersistFieldSqlPrecompiledCacheSubLib$$fPersistFieldPrecompiledCacheSubLib%$fPersistEntityPrecompiledCacheSubLib!$fSafeToInsertPrecompiledCacheExe-$fSymbolToField"value"PrecompiledCacheExeList-$fSymbolToField"parent"PrecompiledCacheExeKey)$fSymbolToField"id"PrecompiledCacheExeKey($fAtLeastOneUniqueKeyPrecompiledCacheExe%$fOnlyOneUniqueKeyPrecompiledCacheExe+$fToBackendKeySqlBackendPrecompiledCacheExe$$fPersistFieldSqlPrecompiledCacheExe!$fPersistFieldPrecompiledCacheExe"$fPersistEntityPrecompiledCacheExe!$fSafeToInsertDockerImageExeCache2$fSymbolToField"compatible"DockerImageExeCacheBool7$fSymbolToField"exeTimestamp"DockerImageExeCacheUTCTime/$fSymbolToField"exePath"DockerImageExeCacheList1$fSymbolToField"imageHash"DockerImageExeCacheText)$fSymbolToField"id"DockerImageExeCacheKey($fAtLeastOneUniqueKeyDockerImageExeCache%$fOnlyOneUniqueKeyDockerImageExeCache+$fToBackendKeySqlBackendDockerImageExeCache$$fPersistFieldSqlDockerImageExeCache!$fPersistFieldDockerImageExeCache"$fPersistEntityDockerImageExeCache$fSafeToInsertCompilerCache,$fSymbolToField"globalDump"CompilerCacheText,$fSymbolToField"info"CompilerCacheByteString8$fSymbolToField"globalDbCacheModified"CompilerCacheInt644$fSymbolToField"globalDbCacheSize"CompilerCacheInt64*$fSymbolToField"globalDb"CompilerCacheList.$fSymbolToField"cabalVersion"CompilerCacheText-$fSymbolToField"haddockPath"CompilerCacheList,$fSymbolToField"runghcPath"CompilerCacheList,$fSymbolToField"ghcPkgPath"CompilerCacheList.$fSymbolToField"ghcModified"CompilerCacheInt64*$fSymbolToField"ghcSize"CompilerCacheInt64)$fSymbolToField"ghcPath"CompilerCacheList&$fSymbolToField"arch"CompilerCacheText9$fSymbolToField"actualVersion"CompilerCacheActualCompiler#$fSymbolToField"id"CompilerCacheKey"$fAtLeastOneUniqueKeyCompilerCache$fOnlyOneUniqueKeyCompilerCache%$fToBackendKeySqlBackendCompilerCache$fPersistFieldSqlCompilerCache$fPersistFieldCompilerCache$fPersistEntityCompilerCache$fSafeToInsertLastPerformed.$fSymbolToField"timestamp"LastPerformedUTCTime*$fSymbolToField"action"LastPerformedAction#$fSymbolToField"id"LastPerformedKey"$fAtLeastOneUniqueKeyLastPerformed$fOnlyOneUniqueKeyLastPerformed%$fToBackendKeySqlBackendLastPerformed$fPersistFieldSqlLastPerformed$fPersistFieldLastPerformed$fPersistEntityLastPerformed $fShowKey $fReadKey$fEqKey$fOrdKey$fPathPieceKey$fToHttpApiDataKey$fFromHttpApiDataKey$fPersistFieldKey$fPersistFieldSqlKey $fToJSONKey $fFromJSONKey $fShowKey0 $fReadKey0$fEqKey0 $fOrdKey0$fPathPieceKey0$fToHttpApiDataKey0$fFromHttpApiDataKey0$fPersistFieldKey0$fPersistFieldSqlKey0 $fToJSONKey0$fFromJSONKey0 $fShowKey1 $fReadKey1$fEqKey1 $fOrdKey1$fPathPieceKey1$fToHttpApiDataKey1$fFromHttpApiDataKey1$fPersistFieldKey1$fPersistFieldSqlKey1 $fToJSONKey1$fFromJSONKey1$fShowDockerImageExeCache $fShowKey2 $fReadKey2$fEqKey2 $fOrdKey2$fPathPieceKey2$fToHttpApiDataKey2$fFromHttpApiDataKey2$fPersistFieldKey2$fPersistFieldSqlKey2 $fToJSONKey2$fFromJSONKey2$fShowPrecompiledCacheExe $fShowKey3 $fReadKey3$fEqKey3 $fOrdKey3$fPathPieceKey3$fToHttpApiDataKey3$fFromHttpApiDataKey3$fPersistFieldKey3$fPersistFieldSqlKey3 $fToJSONKey3$fFromJSONKey3$fShowPrecompiledCacheSubLib $fShowKey4 $fReadKey4$fEqKey4 $fOrdKey4$fPathPieceKey4$fToHttpApiDataKey4$fFromHttpApiDataKey4$fPersistFieldKey4$fPersistFieldSqlKey4 $fToJSONKey4$fFromJSONKey4$fShowPrecompiledCacheParentConfigCacheKeyinitProjectStorageconfigCacheKeyloadConfigCachesaveConfigCachedeactiveConfigCache$fSafeToInsertConfigCacheParent-$fSymbolToField"haddock"ConfigCacheParentBool0$fSymbolToField"pathEnvVar"ConfigCacheParentText,$fSymbolToField"active"ConfigCacheParentBool3$fSymbolToField"pkgSrc"ConfigCacheParentCachePkgSrc5$fSymbolToField"type"ConfigCacheParentConfigCacheType/$fSymbolToField"directory"ConfigCacheParentList'$fSymbolToField"id"ConfigCacheParentKey&$fAtLeastOneUniqueKeyConfigCacheParent#$fOnlyOneUniqueKeyConfigCacheParent)$fToBackendKeySqlBackendConfigCacheParent"$fPersistFieldSqlConfigCacheParent$fPersistFieldConfigCacheParent $fPersistEntityConfigCacheParent"$fSafeToInsertConfigCacheDirOption.$fSymbolToField"value"ConfigCacheDirOptionList-$fSymbolToField"index"ConfigCacheDirOptionInt.$fSymbolToField"parent"ConfigCacheDirOptionKey*$fSymbolToField"id"ConfigCacheDirOptionKey)$fAtLeastOneUniqueKeyConfigCacheDirOption&$fOnlyOneUniqueKeyConfigCacheDirOption,$fToBackendKeySqlBackendConfigCacheDirOption%$fPersistFieldSqlConfigCacheDirOption"$fPersistFieldConfigCacheDirOption#$fPersistEntityConfigCacheDirOption$$fSafeToInsertConfigCacheNoDirOption0$fSymbolToField"value"ConfigCacheNoDirOptionList/$fSymbolToField"index"ConfigCacheNoDirOptionInt0$fSymbolToField"parent"ConfigCacheNoDirOptionKey,$fSymbolToField"id"ConfigCacheNoDirOptionKey+$fAtLeastOneUniqueKeyConfigCacheNoDirOption($fOnlyOneUniqueKeyConfigCacheNoDirOption.$fToBackendKeySqlBackendConfigCacheNoDirOption'$fPersistFieldSqlConfigCacheNoDirOption$$fPersistFieldConfigCacheNoDirOption%$fPersistEntityConfigCacheNoDirOption$fSafeToInsertConfigCacheDep,$fSymbolToField"value"ConfigCacheDepGhcPkgId($fSymbolToField"parent"ConfigCacheDepKey$$fSymbolToField"id"ConfigCacheDepKey#$fAtLeastOneUniqueKeyConfigCacheDep $fOnlyOneUniqueKeyConfigCacheDep&$fToBackendKeySqlBackendConfigCacheDep$fPersistFieldSqlConfigCacheDep$fPersistFieldConfigCacheDep$fPersistEntityConfigCacheDep"$fSafeToInsertConfigCacheComponent4$fSymbolToField"value"ConfigCacheComponentByteString.$fSymbolToField"parent"ConfigCacheComponentKey*$fSymbolToField"id"ConfigCacheComponentKey)$fAtLeastOneUniqueKeyConfigCacheComponent&$fOnlyOneUniqueKeyConfigCacheComponent,$fToBackendKeySqlBackendConfigCacheComponent%$fPersistFieldSqlConfigCacheComponent"$fPersistFieldConfigCacheComponent#$fPersistEntityConfigCacheComponent$fShowConfigCacheComponent$fShowConfigCacheDep$fShowConfigCacheNoDirOption$fShowConfigCacheDirOption$fShowConfigCacheParent BadDependencyNotInBuildPlanCouldn'tResolveItsDependenciesDependencyMismatch HasNoLibraryBDDependencyCycleDetectedLatestApplicableVersionConstructPlanExceptionDependencyCycleDetectedDependencyPlanFailuresUnknownPackageBuildPrettyExceptionConstructPlanFailedExecutionFailureCabalExitedUnsuccessfullySetupHsBuildFailureTargetParseExceptionSomeTargetsNotBuildableInvalidFlagSpecificationGHCProfOptionInvalid NotOnlyLocalCompilerVersionMismatchBuildExceptionCouldn'tFindPkgIdCouldn'tParseTargetsUnknownTargetsTestSuiteFailureTestSuiteTypeUnsupportedLocalPackageDoesn'tMatchTargetNoSetupHsFoundInvalidGhcOptionsSpecificationTestSuiteExeMissingCabalCopyFailedLocalPackagesPresentCouldNotLockDistDir TaskCycleBugPackageIdMissingBugAllInOneBuildBugMultipleResultsBugTemplateHaskellNotFoundBugHaddockIndexNotFoundShowBuildErrorBugCallStackEmptyBugpprintTargetParseErrors$fExceptionBuildException$fExceptionBuildPrettyException$fPrettyBuildPrettyException $fEqDepsPath $fOrdDepsPath$fShowDepsPath$fShowBuildPrettyException$fEqConstructPlanException$fShowConstructPlanException$fEqBadDependency$fOrdBadDependency$fShowBadDependency$fShowBuildExceptionTool ToolGhcGit toolStringtoolNameString parseToolText markInstalledunmarkInstalled listInstalled filterToolsgetCompilerVersion toolExtraDirs installDirtempInstallDir $fOrdTool$fEqToolobjectInterfaceDirLghciDirLbuildCachesDirtestSuccessFile testBuiltFileconfigCabalModconfigSetupConfigModconfigPackageProjectRoot hpcDirFromDirhpcRelativeDirsetupConfigFromDirdistDirFromDirrootDistDirFromDirworkDirFromDir templatesDirprojectDockerSandboxDirimageStagingDirnixOptsFromMonoid nixCompilernixCompilerVersion$fExceptionConfigNixException$fShowConfigNixExceptionensureConfigureScript ComponentFile moduleFileMap otherFilepackageWarningstackBenchmarkFilesstackTestSuiteFilesstackExecutableFilesstackLibraryFilescomponentOutputDirpackageAutogenDircomponentAutogenDirbuildDir resolveOrWarngetPackageFilestackPackageFileFromCabalreadDotBuildinforesolvePackagepackageFromPackageDescriptiongetPackageOptspackageDependenciesresolvePackageDescription buildLogPathapplyForceCustomBuildhasBuildableMainLibrarymainLibraryHasExposedModulespackageUnknownToolsbuildableForeignLibsbuildableSubLibs buildableExesbuildableTestSuitesbuildableBenchmarksprocessPackageDepsToListlistOfPackageDepssetOfPackageDepstopSortPackageComponent ToolWarningUnregisterState toUnregistertoKeepanyAddedCtxbaseConfigOpts combinedMap ctxEnvConfig callStackwanted localNamescurator pathEnvVar AddDepRes ADRToInstallADRFoundWwFinalswInstallwDirty wWarningswParentsM CombinedMap PackageInfoPIOnlyInstalled PIOnlySourcePIBothtoTask adrVersion adrHasLibrary $fMonoidW $fSemigroupW$fHasEnvConfigCtx$fHasCompilerCtx$fHasSourceMapCtx$fHasBuildConfigCtx$fHasProcessContextCtx$fHasPantryConfigCtx$fHasConfigCtx $fHasTermCtx$fHasStylesUpdateCtx$fHasRunnerCtx$fHasLogFuncCtx$fHasGHCVariantCtx$fHasPlatformCtx$fShowToolWarning$fShowAddDepRes $fGenericW$fShowPackageInfoversionString' hpackVersion maybeGitHashopenHaddocksInBrowsershouldHaddockPackageshouldHaddockDepsgenerateLocalHaddockIndexgenerateDepsHaddockIndexgenerateSnapHaddockIndex&generateLocalHaddockForHackageArchives TestStatus TSSuccess TSFailure TSUnknowngetInstalledExesmarkExeInstalledmarkExeNotInstalledtryGetBuildCachetryGetConfigCachetryGetCabalModtryGetSetupConfigModtryGetPackageProjectRootwriteBuildCachewriteConfigCache writeCabalModwriteSetupConfigModwritePackageProjectRoot deleteCachestryGetFlagCachewriteFlagCache setTestStatus getTestStatuswritePrecompiledCachereadPrecompiledCacheghcPkgUnregisterForce$fShowPackageArg $fExceptionGhcPkgPrettyException$fPrettyGhcPkgPrettyException$fShowGhcPkgPrettyException getGlobalDBghcPkgcreateDatabaseghcPkgPathEnvVarfindGhcPkgFieldunregisterGhcPkgIdsmkGhcPackagePathLine ghcPkgDumpghcPkgDescribe pruneDeps sinkMatchingconduitDumpPackage eachSectioneachPair$fExceptionPackageDumpException$fShowPackageDumpExceptionSnapshotCandidateDumpedGlobalPackagemkProjectPackageadditionalDepPackagesnapToDepPackage loadVersion getPLIVersionglobalsFromDumpglobalsFromHints actualFromGhcactualFromHintsglobalCondCheckcheckFlagsUsedThrowing pruneGlobalsgetCompilerInfoimmutableLocShaloadProjectSnapshotCandidateLocked$sel:snapshotLocations:Locked!$sel:pkgImmutableLocations:LockedLockedLocation$sel:original:LockedLocation$sel:completed:LockedLocationlockCachedWanted$fToJSONLockedLocation$fToJSONLocked$fExceptionLockPrettyException$fPrettyLockPrettyException$fShowLockPrettyException $fEqLocked $fShowLocked$fEqLockedLocation$fShowLockedLocationBuildPlanCheckBuildPlanCheckOkBuildPlanCheckPartialBuildPlanCheckFailDepError$sel:version:DepError$sel:neededBy:DepError DepErrorsBuildPlanExceptionUnknownPackagesSnapshotNotFound"NeitherCompilerOrResolverSpecifiedDuplicatePackagesBugremoveSrcPkgDefaultFlagscheckSnapBuildPlanselectBestSnapshot showItems$fExceptionBuildPlanException$fShowBuildPlanCheck$fShowDepError$fShowBuildPlanException RawTargetRTPackageComponent RTComponent RTPackageRTPackageIdentifierUnresolvedComponentResolvedComponent NeedTargetsAllowNoTargetsparseRawTarget parseTargets $fEqRawTarget$fShowRawTarget$fEqUnresolvedComponent$fOrdUnresolvedComponent$fShowUnresolvedComponentprojectLocalPackageslocalDependencieshashSourceMapData getLocalFlagsloadCommonPackageloadLocalPackageaddUnlistedToBuildCache constructPlan toInstallMap getInstalled$fShowLoadHelper $fEqAllowed $fShowAllowedinterpreterArgsParsergetInterpreterArgsgetImplicitGlobalProjectDir getSnapshotsmakeConcreteResolverwithNewLogFunc loadConfigwithBuildConfigdetermineStackRootAndOwnershipcheckOwnershipgetInContainer getInNixShellloadConfigYamlgetProjectConfigpackagesParserdefaultConfigYamlrunShellAndExit nixCmdNamenixHelpOptName$fExceptionNixException$fShowNixException nixOptsParser ConfigCmdSetConfigCmdSetSnapshotConfigCmdSetResolverConfigCmdSetSystemGhcConfigCmdSetInstallGhcConfigCmdSetDownloadPrefix cfgCmdSet cfgCmdName cfgCmdSetName cfgCmdEnvNameconfigCmdSetParserconfigCmdEnvParser cfgCmdEnv$fExceptionConfigCmdException$fShowEnvVarAction $fEqKeyType $fShowKeyType$fShowConfigCmdException OutputType OTLogFile OTConsole ExecuteEnv$sel:installLock:ExecuteEnv$sel:buildOpts:ExecuteEnv$sel:buildOptsCLI:ExecuteEnv$sel:baseConfigOpts:ExecuteEnv$sel:ghcPkgIds:ExecuteEnv$sel:tempDir:ExecuteEnv$sel:setupHs:ExecuteEnv$sel:setupShimHs:ExecuteEnv$sel:setupExe:ExecuteEnv$sel:cabalPkgVer:ExecuteEnv$sel:totalWanted:ExecuteEnv$sel:locals:ExecuteEnv$sel:globalDB:ExecuteEnv$sel:globalDumpPkgs:ExecuteEnv $sel:snapshotDumpPkgs:ExecuteEnv$sel:localDumpPkgs:ExecuteEnv$sel:logFiles:ExecuteEnv$sel:customBuilt:ExecuteEnv"$sel:largestPackageName:ExecuteEnv$sel:pathEnvVar:ExecuteEnvExecutableBuildStatusExecutableBuiltExecutableNotBuiltwithExecuteEnvwithSingleContext$fEqExecutableBuildStatus$fOrdExecutableBuildStatus$fShowExecutableBuildStatusPagerExceptionPagerExitFailure pageWriterpageText$fExceptionPagerException$fShowPagerExceptiongetTerminalWidth fixCodePagehIsTerminalDeviceOrMinTTYStackReleaseInfo SetupOpts$sel:installIfMissing:SetupOpts$sel:useSystem:SetupOpts$sel:wantedCompiler:SetupOpts$sel:compilerCheck:SetupOpts$sel:stackYaml:SetupOpts$sel:forceReinstall:SetupOpts$sel:sanityCheck:SetupOpts$sel:skipGhcCheck:SetupOpts$sel:skipMsys:SetupOpts $sel:resolveMissingGHC:SetupOpts$sel:ghcBindistURL:SetupOptsdefaultSetupInfoYamlsetupEnvwithNewLocalBuildTargetsensureCompilerAndMsysensureDockerStackExedownloadStackReleaseInfopreferredPlatformsdownloadStackExegetDownloadVersion$fExceptionSetupException$fExceptionSetupPrettyException$fPrettySetupPrettyException'$fExceptionPerformPathCheckingException$fHasCompilerWithGHC$fHasBuildConfigWithGHC$fHasConfigWithGHC$fHasGHCVariantWithGHC$fHasPlatformWithGHC$fHasPantryConfigWithGHC$fHasTermWithGHC$fHasStylesUpdateWithGHC$fHasProcessContextWithGHC$fHasRunnerWithGHC$fHasLogFuncWithGHC$fHasBuildConfigWithMSYS$fHasConfigWithMSYS$fHasGHCVariantWithMSYS$fHasPlatformWithMSYS$fHasPantryConfigWithMSYS$fHasTermWithMSYS$fHasStylesUpdateWithMSYS$fHasProcessContextWithMSYS$fHasRunnerWithMSYS$fHasLogFuncWithMSYS$fAlternativeCheckDependency$fApplicativeCheckDependency$fShowHaskellStackOrg$fFunctorCheckDependency$fShowSetupOpts"$fShowPerformPathCheckingException$fShowSetupPrettyException$fShowSetupExceptionpreventInContainerrunContainerAndExitpullreset entrypointgetProjectRoot$fFromJSONImageConfig$fFromJSONInspect $fShowInspect$fShowImageConfig ShouldReexec YesReexecNoReexecwithGlobalProjectwithDefaultEnvConfig withEnvConfig withConfigwithRunnerGlobal$fExceptionRunnersException$fShowRunnersException updateCmd UnpackOpts$sel:targets:UnpackOpts$sel:areCandidates:UnpackOpts$sel:dest:UnpackOpts UnpackTarget unpackCmdunpackPackages $fExceptionUnpackPrettyException$fPrettyUnpackPrettyException$fShowUnpackPrettyExceptionunpackOptsParser uninstallCmd templatesCmd templatesHelp#$fExceptionTemplatesPrettyException $fPrettyTemplatesPrettyException$fShowTemplatesPrettyException SetupCmdOpts!$sel:compilerVersion:SetupCmdOpts $sel:forceReinstall:SetupCmdOpts$sel:ghcBindistUrl:SetupCmdOpts$sel:ghcjsBootOpts:SetupCmdOpts $sel:ghcjsBootClean:SetupCmdOptssetupCmdsetupsetupOptsParserqueryCmdqueryBuildInfo$fExceptionQueryException$fShowQueryExceptionEnvConfigPathInfopathsFromRunnerpathsFromConfigpathsFromEnvConfig!$fHasBuildConfigEnvConfigPathInfo$$fHasProcessContextEnvConfigPathInfo"$fHasPantryConfigEnvConfigPathInfo$fHasConfigEnvConfigPathInfo $fHasGHCVariantEnvConfigPathInfo$fHasTermEnvConfigPathInfo"$fHasStylesUpdateEnvConfigPathInfo$fHasRunnerEnvConfigPathInfo$fHasLogFuncEnvConfigPathInfo$fHasPlatformEnvConfigPathInfo pathParserlistCmd listPackages$fExceptionListPrettyException$fPrettyListPrettyException$fShowListPrettyExceptionInitOpts$sel:searchDirs:InitOpts$sel:omitPackages:InitOpts$sel:forceOverwrite:InitOpts$sel:includeSubDirs:InitOptsinitCmd initProject$fExceptionInitException$fExceptionInitPrettyException$fPrettyInitPrettyException$fShowInitPrettyException$fShowInitExceptioninitOptsParserNewOpts$sel:projectName:NewOpts$sel:createBare:NewOpts$sel:init:NewOpts$sel:template:NewOpts$sel:nonceParams:NewOptsnewCmdnew$fExceptionNewPrettyException$fPrettyNewPrettyException$fShowNewPrettyException newOptsParserListPackagesCmdListPackageNamesListPackageCabalFiles OutputStream OutputLogInfo OutputStdoutidePackagesCmd ideTargetsCmd listTargets HpcReportOpts$sel:inputs:HpcReportOpts$sel:all:HpcReportOpts$sel:destDir:HpcReportOpts$sel:openBrowser:HpcReportOpts hpcReportCmddeleteHpcReports updateTixFilegenerateHpcReportgenerateHpcReportForTargetsgenerateHpcUnifiedReportgenerateHpcMarkupIndex"$fExceptionCoveragePrettyException$fPrettyCoveragePrettyException$fShowHpcReportOpts$fShowCoveragePrettyException singleBuild singleTest singleBenchpreFetch printPlan executePlan CleanCommandCleanPurge CleanOpts CleanShallow CleanFullcleanCmdclean$fExceptionCleanException$fShowCleanExceptioncleanOptsParserdockerOptsParser dockerPullCmddockerResetCmdbuildCmdbuildbuildLocalTargetssplitObjsWarningmkBaseConfigOpts&$fExceptionCabalVersionPrettyException#$fPrettyCabalVersionPrettyException!$fShowCabalVersionPrettyException UpgradeOpts$sel:binary:UpgradeOpts$sel:source:UpgradeOpts SourceOpts BinaryOpts$sel:platform:BinaryOpts$sel:force:BinaryOpts$sel:onlyLocalBin:BinaryOpts$sel:version:BinaryOpts$sel:gitHubOrg:BinaryOpts$sel:gitHubRepo:BinaryOpts upgradeCmdupgrade!$fExceptionUpgradePrettyException$fPrettyUpgradePrettyException$fShowUpgradeOpts$fShowSourceOpts$fShowBinaryOpts$fShowUpgradePrettyExceptionupgradeOptsParser ScriptOpts$sel:packages:ScriptOpts$sel:file:ScriptOpts$sel:args:ScriptOpts$sel:compile:ScriptOpts$sel:useRoot:ScriptOpts$sel:ghcOptions:ScriptOpts$sel:scriptExtraDeps:ScriptOpts$sel:shouldRun:ScriptOpts ShouldRunYesRunNoRun ScriptExecute SEInterpret SECompile SEOptimize scriptCmd$fExceptionScriptException$fShowScriptOpts$fShowShouldRun$fShowScriptExecute$fShowScriptException SDistOpts$sel:dirsToWorkWith:SDistOpts$sel:pvpBounds:SDistOpts$sel:ignoreCheck:SDistOpts$sel:buildTarball:SDistOpts$sel:tarPath:SDistOptssdistCmdgetSDistTarballreadLocalPackagecheckSDistTarballcheckSDistTarball'$fExceptionSDistPrettyException$fPrettySDistPrettyException$fShowSDistPrettyException HackageAuthHAKeyHACreds HackageCreds HackageKey UploadOpts$sel:itemsToWorkWith:UploadOpts$sel:documentation:UploadOpts$sel:pvpBounds:UploadOpts$sel:check:UploadOpts$sel:buildPackage:UploadOpts$sel:tarPath:UploadOpts$sel:uploadVariant:UploadOpts UploadVariant Publishing Candidate UploadContentSDist DocArchive uploadCmdmaybeGetHackageKeyloadAuthwriteFilePrivate uploadBytesuploaduploadRevision $fExceptionUploadPrettyException$fPrettyUploadPrettyException $fFromJSONFUN$fToJSONHackageCreds$fEqHackageAuth$fShowHackageAuth$fEqHackageCreds$fShowHackageCreds$fEqHackageKey$fShowHackageKey$fShowUploadPrettyExceptionuploadOptsParserbuildOptsMonoidParsercabalVerbosityOptsParsercabalVerbosityParsercabalVerboseParserconfigOptsParserglobalOptsParserglobalOptsFromMonoidghcOptsCompletertargetCompleter flagCompleterprojectExeCompleterscriptOptsParserhpcReportOptsParserpvpBoundsOptionsdistOptsParserbuildOptsParser targetsParser flagsParser dotOptsParser hoogleCmd$fExceptionHoogleException $fExceptionHooglePrettyException$fPrettyHooglePrettyException$fShowHooglePrettyException$fShowHoogleException GhciPkgInfo$sel:name:GhciPkgInfo$sel:opts:GhciPkgInfo$sel:dir:GhciPkgInfo$sel:modules:GhciPkgInfo$sel:cFiles:GhciPkgInfo$sel:mainIs:GhciPkgInfo$sel:targetFiles:GhciPkgInfo$sel:package:GhciPkgInfoGhciOpts$sel:targets:GhciOpts$sel:args:GhciOpts$sel:ghcOptions:GhciOpts$sel:flags:GhciOpts$sel:ghcCommand:GhciOpts$sel:noLoadModules:GhciOpts $sel:additionalPackages:GhciOpts$sel:mainIs:GhciOpts$sel:loadLocalDeps:GhciOpts$sel:skipIntermediate:GhciOpts$sel:hidePackages:GhciOpts$sel:noBuild:GhciOpts$sel:onlyMain:GhciOptsGhciPrettyExceptionGhciTargetParseExceptionCandidatesIndexOutOfRangeBug GhciExceptionInvalidPackageOptionLoadingDuplicateModulesMissingFileTargetCan'tSpecifyFilesAndTargetsCan'tSpecifyFilesAndMainIsghciCmdghci$fExceptionGhciException$fExceptionGhciPrettyException$fPrettyGhciPrettyException$fShowGhciPkgInfo$fShowGhciOpts$fShowGhciPrettyException$fShowGhciExceptionghciOptsParserExecOptscmdargsextra ExecOptsExtra envSettingspackages rtsOptionscwdSpecialExecCmdExecCmdExecRunExecGhc ExecRunGhcexecCmd$fExceptionExecException$fExceptionExecPrettyException$fPrettyExecPrettyException$fShowExecOpts$fShowExecOptsExtra$fEqSpecialExecCmd$fShowSpecialExecCmd$fShowExecPrettyException$fShowExecExceptionexecOptsParserexecOptsExtraParserEvalOpts$sel:arg:EvalOpts$sel:extra:EvalOptsevalCmd$fShowEvalOptsevalOptsParsercreatePrunedDependencyGraphresolveDependencies pruneGraph#$fExceptionDependencyGraphException$fShowDependencyGraphException ListToolsOpts$sel:filter:ListToolsOptsListStylesOpts$sel:basic:ListStylesOpts$sel:sgr:ListStylesOpts$sel:example:ListStylesOptsListDepsTextFilter FilterPackage FilterLocalsListDepsFormatOpts$sel:sep:ListDepsFormatOpts$sel:license:ListDepsFormatOptsListDepsFormat ListDepsText ListDepsTree ListDepsJSONListDepsConstraints ListDepsOpts$sel:format:ListDepsOpts$sel:dotOpts:ListDepsOptsLsViewRemote SnapshotOpts$sel:viewType:SnapshotOpts$sel:ltsSnapView:SnapshotOpts!$sel:nightlySnapView:SnapshotOptsLsCmds LsSnapshotLsDependenciesLsStylesLsTools LsCmdOpts$sel:lsCmds:LsCmdOptslsCmd$fExceptionLsException$fFromJSONSnapshot$fFromJSONSnapshotData$fEqSnapshotData$fOrdSnapshotData$fShowSnapshotData $fEqSnapshot $fOrdSnapshot$fShowSnapshot$fEqListStylesOpts$fOrdListStylesOpts$fShowListStylesOpts$fEqSnapshotType$fOrdSnapshotType$fShowSnapshotType$fEqSnapshotOpts$fOrdSnapshotOpts$fShowSnapshotOpts $fEqLsView $fOrdLsView $fShowLsView$fShowLsException lsOptsParserdotCmd printGraphcommandLineHandler$fExceptionCliPrettyException$fPrettyCliPrettyException$fShowCliPrettyExceptionmain$fExceptionStackException$fShowStackExceptionTarPath fromTarPathCodec.Archive.Tar.Check checkSecuritydecodeIfUtf8Encodedbytesfmt parseAbsDir parseAbsFilecollapseFilePathSystem.IO.ErrorisDoesNotExistError InvalidAbsDirInvalidAbsFile findPathUpparent RIO.ProcessProcessContextbugDeclaration bugRequest quoteFileName fileWatchConf OptionsApplicativeExtraException4optparse-applicative-0.18.1.0-6MdvsNKMpCsIalxqyfKTx1Options.Applicative.Builder abortOptionoptionargument eitherReaderExecuteException sortActionscasaEnableNamecasaRepoPrefixNamecasaMaxKeysPerRequestNameGhcPkgIdParseFailalphaNum GHC.Unicode isAlphaNum GHC.RecordsHasField HasQualiNameInnerCollectionunbuildableOnes addComponent$gatherComponentToolsAndDepsFromCabalisKnownLegacyExeisPreInstalledPackagesTypesResolverExceptionTypeTemplateNameException parseRepoPath Data.Version showVersionConstantsExceptionDual addCommand' helpOptionOptions.Applicative.ExtrahandleParseResulthooksDirplatformGhcVerOnlyRelDirStrtoCabalMungedPackageIdentifierhandleSetGroups handleSignals PkgDepsOracleStorageUserExceptionwithUserStorage sizeToInt64 timeToInt64withProjectStoragereadConfigCachedpLength dpNameLengthdpPathgetShortestDepsPathrootDistRelativeDirConfigNixException)NixCannotUseShellFileAndPackagesExceptionresolveComponentFilesresolveFilesAndDepsgetDependenciesparseHI resolveFiles findCandidatelogPossibilitiesbuildOtherSourcesresolveDirFile warnMultipleparsePackageNameFromFilePathresolveDirOrWarnresolveFileOrWarnpackageDescModulesAndFilesresolveGlobFilesgeneratePkgDescOptsmakeObjectFilePathFromC allBuildInfo',Distribution.Types.GenericPackageDescriptionGenericPackageDescription%Distribution.Types.PackageDescriptionPackageDescriptionflagMapmkResolveConditionsresolveConditionsprocessPackageComponentprocessPackageMapDepsprocessPackageDepsgenerateHaddockIndexlookupDumpPackagehaddockIndexFile localDocDirlocalDepsDocDir snapDocDir%generateLocalHaddockForHackageArchivecreateTarGzFileexeInstalledDirgetPrecompiledCacheKeyDbModifySelectorPackageDBStackGlobPackageIdentifier PackageArgIdIUId Substring AsPackageArgGhcPkgPrettyExceptiongetPkgDatabasesunregisterPackagespackageDbFlagsPackageDumpException ghcPkgCmdArgs takeWhileCLockPrettyExceptionselectPackageBuildPlancheckPackageBuildPlancheckPackageDepscombineDepErrorcheckBundleBuildPlancompareBuildPlanCheck$sel:component:ResolveResult$sel:addedDep:ResolveResult ComponentNameRawInputparseRawTargetDirsresolveRawTarget ResolveResultgeneralCabalConfigOptsgeneralGhcOptionscheckBuildCachegetPackageFilesForTargetsgetFileDigestMaybegetPackageConfigmkUnregisterLocaladdFinalgetCachedDepOrAddDepaddPackageDepscheckCallStackAndAddDepaddDeptellExecutablestellExecutablesUpstreamtellExecutablesPackageinstallPackageinstallPackageGivenDepspackageBuildTypeConfig processDep adrInRange processAdrcheckAndWarnForUnknownTools inSnapshotcombineSourceInstalled combineMapresolveDepsAndInstallcheckDirtiness LoadHelper$sel:ghcPkgId:LoadHelper$sel:depsGhcPkgId:LoadHelper$sel:pair:LoadHelperAllowed isAllowed UnknownPkg WrongLocation WrongVersion loadDatabasegatherAndTransformSubLoadHelpergetEffectiveUserIDgetEffectiveGroupID getGroupsgetUserEntryForName homeDirectory setGroupID setUserIDtryDeprecatedPathgetLatestResolverwithLocalLogFuncgetDefaultLocalProgramsBasecheckDuplicateNamesgetDirAndOwnership isOwnedByUsergetExtraConfigsloadYamlloadProjectConfiggetDefaultGlobalConfigPathgetDefaultUserConfigPathconfigFromConfigMonoid NixExceptionCannotDetermineProjectRootescapeKeyTypePlainKeySingleQuotedKeyDoubleQuotedKeyCommandScopeGlobalCommandScopeProjectConfigCmdExceptioncfgCmdSetValue snapshotValuePrefixWithTimestamps getSetupExepackageNamePrefixwithLockedDistDirmungeBuildOutputsinkWithTimestampsformatZonedTimeForLog getSetupHs getRelease SRIGitHubSRIHaskellStackOrgWithMSYSWithGHCPerformPathCheckingExceptionperformPathCheckingSetupPrettyExceptionSetupException runWithGHC runWithMSYS rebuildEnv addIncludeLibwarnUnsupportedCompilerwarnUnsupportedCompilerCabal ensureMsysensureCompilerrunGHCInstallHook getGhcBuilds mungeReleasesourceSystemCompilers getSetupInfo#downloadAndInstallPossibleCompilerscheckDependencieswithUnpackedTarball7zsetup7z sanityCheckgetUtf8EnvVarsdownloadStackReleaseInfoGitHubpathsFromCompilerbuildGhcFromSourcegetInstalledToolgetOSKeychattyDownloadrelocateStackExeFile ImageConfigInspect getCmdArgsinspectinspects pullImagecheckDockerVersionremoveDirectoryContentsreadDockerProcess-typed-process-0.2.11.1-JmmqmmRqQL4DC1BwopY7z9System.Process.Typed readProcess_ homeDirName hostBinDir decodeUtf8oldSandboxIdEnvVarRunnersExceptionreexecshouldUpgradeCheckUnpackPrettyExceptionTemplatesPrettyExceptiondefaultTemplatesHelpUrlQueryExceptionerr rawBuildInfostackRootOptionName'ListPrettyExceptionInitPrettyException InitExceptionrenderStackYamlgetDefaultResolverminSupportedLts ignoredDirsgetWorkingResolverPlancheckBundleResolverTemplateDownloadSettings'$sel:basicAuth:TemplateDownloadSettingsNewPrettyException loadTemplatesettingsFromRepoTemplatePath applyTemplatecheckForOverwritewriteTemplateFilesrunTemplateInitsdefaultRepoServiceCoveragePrettyException hpcPkgPath tixFilePathremoveExeModules htmlEscapegenerateHpcReportInternalgenerateUnionReportgetConfigCache ensureConfigpostProcessRemotePackagefetchAndMarkInstalledPackagecopyDdumpFilesIfNeededgetExecutableBuildStatusescheckExeStatuscheckForUnlistedFiles exesToBuildcabalIsSatisfiedprimaryComponentOptions displayTaskwindowsRenameCopy executePlan'CleanException/warnIfExecutablesWithSameNameCouldBeOverwrittenUpgradePrettyExceptionScriptException blacklistgetPackagesFromImportsSDistPrettyException getCabalLbs gtraverseTgetSDistFileListcheckPackageInExtractedTarballwithTempTarGzContents packFileEntryUploadPrettyExceptionloadUserAndPassworddefaultLogLevelMutedHooglePrettyExceptionHoogleException GhciPkgDescdisplayPkgComponentfigureOutMainFileloadGhciPkgDescmakeGhciPkgInfoExecPrettyException ExecExceptionDependencyGraphExceptioncreateDependencyGraphprojectPackageDependenciescreateDepLoaderpruneUnreachable SnapshotTypeLts LsException listStylesCmd listToolsCmdlistDepsOptsParserprintLocalNodes printLeaves printEdges printEdgenodeName printLeaf isWiredInCliPrettyExceptionsecondaryCommandHandlerStackException hSetTranslithandleExitCodehandlePrettyExceptionhandlePantryExceptionhandleAnyPrettyExceptionhandleSomeException