h&!      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   !!!!!!!!!!!!!"""""""""###########$$$$$$$$$$$$$%%%%%%%%%&&&&&&&'''''''''''''()))))))))****+++++++++++++++++++,,,,,,,,,,,,,,,,,-------........./////////////////////0000000000000000000000000000000122222222233333333333334444555555555555555555555556666666666666666677788888999999:::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<=>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>????????????????????????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAABBBBBBBBBBBCDDD                                                                                                                            EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJKLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRSSSSSSTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYZZZZZZ[[[[[[[[[[\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^__________________`````aaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbccccccdddddddddddddeeeeefggggggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiijjjjjkkkkkkkkkkkkkkkkkkkkkkllmmmmmmnnnnnnnooooooooooooooooooooooooooooooooooooooooooooooppppppppppqqqqqqqqqqrssssstuuuuuvvvvvvvvvwxxxxyyyyyyyyyyyyyz{{{{|||||||||||||}~~~~~~~~~~~                                                                                                                                !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Safe-Inferred"[ 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 W if the file was downloaded, T 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-Inferred\!!! Safe-Inferred(f 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) stackDrop the root (either / on POSIX or C:\, D:\, etc. on Windows). stackIf given file in H does not exist, ensure we have U*. 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 U. stack (path-io package) throws ! (path< package) if the file does not exist; this function yields U. stack (path-io package) throws ! (path< package) if the file does not exist; this function yields U. stackBase directorystackPath to resolve stackBase directorystackPath to resolve stackPath to resolve   Safe-Inferred1k 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 V 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-Inferredl4   Safe-Inferred"v 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.?@ABCDEFGHUVI\][JKLMNOPQYZRXS`dabcefghijklmnqpotsruvzwyx}|{~ ` #$% &' ()*+, -./0123456! "789:;?@ABCDEFGHUVI\][JKLMNOPQYZRXSdabcefghijklmnqpotsruvzwyx}|{~  Safe-InferredC 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-Inferred8!stackIf USE_GIT_INFO is enabled, the Git hash in the build directory, otherwise Nothing.! Safe-Inferred"!stackMake sure that a filename with spaces in it gets the proper quotes.    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-InferredQ stackUsed in Stack.Setup for detecting libtinfo, see comments at use site  Safe-Inferred stackName of the Stack program.   Safe-Inferred%&!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%&I stack#Does not include the current action stack*Actions which depend on the current action stack7Whether this action may be run concurrently with others stack=Action for building a package's library and executables. If  taskAllInOne is W9, then this will also build benchmarks and tests. It is T when then 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"%&- stackOptions for the  FinalAction  DoBenchmarks stack)Arguments passed to the benchmark program stackDisable running of benchmarks stackHaddock Options stack#Arguments passed to haddock program stackOptions for the  FinalAction DoTests stack)Whether successful tests will be run gain stack$Arguments passed to the test program stackGenerate a code coverage report stackDisable running of tests stacktest suite timeout in seconds stackWhether to allow standard input 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 stackBuild options that may be specified in the stack.yaml or from the CLI stack+Command sum type for conditional arguments. stack5Build options that may only be specified from the CLI 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. stackBuild options that is interpreted by the build command. This is built up from BuildOptsCLI and BuildOptsMonoid stackBuild haddocks? stackOptions to pass to haddock stackOpen haddocks in the browser? stack Build haddocks for dependencies? stack3Build haddocks for all symbols and packages, like cabal haddock --internal stack2Build hyperlinked source if possible. Fallback to hscolour. Disable for no sources. 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 rebuild stack#Keep building/running after failure stack-Keep intermediate files and build directories stack7Force treating all local packages as having dirty files stackTurn on tests for local targets stackAdditional test arguments stack$Turn on benchmarks for local targets stackAdditional test arguments ^ Commands (with arguments) to run after a successful build ^ Only perform the configure step when building stack5Perform the configure step even if already configured stack%Ask Cabal to be verbose in its builds stackWhether to enable split-objs. stack&Which components to skip when building stackShould we use the interleaved GHC output when building multiple packages? stackOnly flags set via  stack"Generate a list of --PROG-option=" argument" arguments for all PROGs.      Safe-Inferredstack+Parser for test arguments. FIXME hide args Safe-InferredstackParser for package:[-]flag Safe-Inferred*stackParser for haddock arguments. Safe-Inferred"stack1Parser for bench arguments. FIXME hiding options Safe-Inferred%&stack#Interprets BuildOptsMonoid options. Safe-Inferred"stack*Which packages do configure opts apply to?stackSee AGOTargetsstack See AGOLocalsstackSee AGOEverythingstackA specific package Safe-Inferred" Safe-Inferredstack,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-Inferredstack#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"'stackExtra 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.! 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"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 # Safe-Inferred"stackWhich build log files to dumpstackdon't dump any logfilesstack!dump logfiles containing warningsstackdump all logfiles$ 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  % Safe-Inferred"& Safe-Inferred"]' Safe-InferredZ 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.  ( Safe-InferredstackGHC variant parser) Safe-Inferred"* Safe-Inferred0+ 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.stack.Get a string representation of GHC package id.stack"Get a text value of GHC package id, Safe-InferredTstackType representing dump information for a single package, as output by the ghc-pkg describe command.stackThe id field.stackThe name and version fields. The name field is the munged package name. If the package is not for a sub library, its munged name is its name.stackThe  package-name and version fields, if  package-name is present. That field is present if the package is for a sub library.stackThe  library-dirs field.stackThe  hs-libraries field.stackThe depends0 field (packages on which this package depends). Safe-Inferred"!stackType of config cache!!!!!!- Safe-Inferred. Safe-InferredǛstackHow 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/A single, fully resolved component of a package0 Safe-Inferred"%&kstackAn 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.1 Safe-InferredJstack9An argument which accepts a template name of the format  foo.hsfiles.2 Safe-Inferred~stack2Class 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 identifier3 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 stackExtra 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 .  4 Safe-InferredstackProject 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.5 Safe-Inferred"nstack.How PVP bounds should be added to .cabal files  6 Safe-Inferred")1stack=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.  7 Safe-Inferred1estackParser for the resolver8 Safe-Inferred"ؿstackA software control system.9 Safe-Inferredbstack+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. 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.!!!!!!!!: 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.; 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.stack Safe-Inferred"1stack*Repository containing the compiler sourcesstack/Specifies a compiler and its version number(s).Note that despite having this datatype, Stack isn't in a hurry to support compilers other than GHC.stackVariety of compiler to use.stackType representing exceptions thrown by functions exported by the Stack.Types.Compiler module.? Safe-Inferredstack.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  or , 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 packagesstack8Common settings for both dependency and project package.stackoverrides default flagsstack6Returns relative directory name with source map's hashstackRoot directory for the given stack&All components available in the given stack%Version for the given 'ProjectPackage@ Safe-Inferred 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 K 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  environmentA Safe-Inferred")B Safe-Inferred"%&(stackFor the siGHCs field maps are deeply merged. For all fields the values from the first  SetupInfo win.C Safe-Inferred&D Safe-InferredvstackTrue if using Windows OS.  Safe-Inferred" J)"stackType representing exceptions thrown by functions exported by the Stack.Constants module.stackName of the Stack program.stackExtensions 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 dirstackRelative 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-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   E Safe-Inferred"%&#Cstack)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 .stack?Container name to use, only makes sense from command-line with  or .stackSee: stackArguments 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: stackDocker 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 .stack?Container name to use, only makes sense from command-line with  or .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.F Safe-Inferred"%&1: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 stackSee configApplyGhcOptionsstackSee configApplyProgOptionsstackSee stackSee stackThe 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 configRecommendUpgradestack(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.G Safe-Inferred"2CH Safe-Inferred5$stack*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.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 globalLockFileBehaviorI Safe-Inferred7 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.stack Config monoid, for passing into  loadConfigstackResolver overridestackCompiler overridestackWe're in a terminal?stackSGR (Ansi) codes for stylesstackTerminal width overridestackOverride project stack.yamlJ Safe-Inferred9Ustack*Class for environment values which have a .stackThe base environment that almost everything in Stack runs in, based off of parsing command line options in *. Provides logging and process execution.stackSee stackSee K Safe-Inferred9L Safe-Inferred?stack2Generate and execute a complicated options parser.stack(Add a command to the options dispatcher.stackAdd a command that takes sub-commands to the options dispatcher."stack(Add a command to the options dispatcher.stack&Generate a complicated options parser."stackSubparser with --help argument. Borrowed with slight modification from Options.Applicative.Extra."stackNon-hidden help option. stacknumeric versionstackversion stringstack Hpack numeric version, as stringstackheaderstackprogram description (displayed between usage and options listing in the help output)stackfooterstackcommon settingsstack%optional handler for parser failure; " is called by defaultstackcommands (use )stackcommand stringstacktitle of commandstackfooter of command helpstack2constructor to wrap up command in common data typestack*extend common settings from local settingsstack common parserstackcommand parserstackcommand stringstacktitle of commandstackfooter of command helpstack common parserstacksub-commands (use )"stackcommand stringstacktitle of commandstackfooter of command helpstack2constructor to wrap up command in common data typestack common parserstackcommand parserstackmetavar for the sub-commandstackcommon settingsstackcommands (use )M Safe-Inferred")1A2stackType representing 'pretty' exceptions thrown by functions exported by the  Stack.Config module.stackType representing exceptions thrown by functions exported by the  Stack.Config module.stack $STACK_ROOT , parent dirN Safe-Inferred "%&()1<Ristack0Class for environment values that can provide a .stack%The top-level Stackage configuration.stack-this allows to override .stack-work directorystack*Path to user configuration file (usually ~.stack config.yaml)stackBuild configurationstackDocker configurationstack3Execution environment (e.g nix-shell) configurationstack4Environment variables to be passed to external toolsstack9Non-platform-specific path containing local installationsstack0Path containing local installations (mainly GHC)stackHide the Template Haskell "Loading package ..." messages from the consolestack2Prefix build output with timestamps for each line.stack=The platform we're building for, used in many directory namesstack5Variant of the platform, also used in directory namesstack)The variant of GHC requested by the user.stackOverride build of the compiler distribution (e.g. standard, gmp4, tinfo6)stackURL of a JSON file providing the latest LTS and Nightly snapshots.stackShould we use the system-installed GHC (on the PATH) if available? Can be overridden by command line options.stackShould we automatically install GHC if missing or the wrong version is available? Can be overridden by command line options.stack6Don't bother checking the GHC version or architecture.stack&On Windows: don't use a sandboxed MSYSstack8Specifies which versions of the compiler are acceptable.stack8Specifies the repository containing the compiler sourcesstack,Directory we should install executables intostack-Require a version of Stack within this range.stackHow many concurrent jobs to run, defaults to number of capabilitiesstackOptional gcc override pathstack-extra-include-dirs argumentsstack-extra-lib-dirs argumentsstackGet 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 debugO Safe-Inferred)1VstackA 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!P Safe-Inferred\stack3Configuration 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. Safe-Inferred1_"stack(Warning generated when reading a package"stackModules found that are not listed in Cabal file TODO: bring this back - see 6https://github.com/commercialhaskell/stack/issues/2649"stackFiles that the package depends on, relative to package directory. Argument is the location of the Cabal file"stack?A descriptor from a Cabal file indicating one of the following:=exposed-modules: Foo other-modules: Foo or main-is: Foo.hs"stackA path resolved from the Cabal file, which is either main-is or an exposedinternalreferenced module."""""""""""""""""""""Q Safe-Inferred"1m=stack>A location to install a package into, either snapshot or localstack9Information on a locally available package of source codestackThe 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.stackThe Cabal filestackNothing == 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)stackFiles that the package depends on, relative to package directory. Argument is the location of the Cabal filestackSome package info.stackName of the package.stackVersion of the packagestack+The license the package was released under.stackGet all files of the package.stackPackages that the package depends on, both as libraries and build tools.stackBuild tools specified in the legacy manner (build-tools:) that failed the hard-coded lookup.stack#Original dependencies (not sieved).stack/Original sub-library dependencies (not sieved).stackGhc options used on package.stack1Additional options passed to ./Setup.hs configurestackFlags used on package.stackDefaults for unspecified flags.stack1does the package have a buildable library stanza?stacknames of internal librariesstack#names and interfaces of test suitesstacknames of benchmarksstacknames of executablesstackArgs to pass to GHC.stack&Does the package have exposed modules?stackPackage build-type.stack%If present: custom-setup dependenciesstackCabal spec rangestackName of an executable.stackLibraries in a package. Since Cabal 2.0, internal libraries are a thing.stackthe foreign library names, sub libraries get built automatically without explicit component name passingstackType 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.stackGet the installed Version.stackCompares the package name.stackCompares the package name.R Safe-Inferred"pstackChecks 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-Inferredp""S Safe-Inferred"%&rstackType 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.stackbaseT Safe-Inferred"tstack2Configure options to be sent to Setup.hs configurestackOptions related to various paths. We separate these out since they do not have an impact on the contents of the compiled binary for checking if we can use an existing precompiled cache.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?U Safe-Inferred"1stackInformation on a compiled package: the library conf file (if relevant), the sublibraries (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 sublibrariesstackFull 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 buildingstackThe type of a task, either building local code or 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 GhcPkgIdsstackA task to perform when buildingstackthe package/version to be builtstack+the task type, telling us how to build thisstack+GhcPkgIds of already-installed dependenciesstack3indicates that the package can be built in one stepstackWere any of the dependencies missing? The reason this is necessary is... hairy. And as you may expect, a bug in Cabal. See:  https://github.com/haskell/cabal/issues/4728#issuecomment-337937673. The problem is that Cabal may end up generating the same package ID for a dependency, even if the ABI has changed. As a result, without this field, Stack would think that a reconfigure is unnecessary, when in fact we _do_ need to reconfigure. The details here suck. We really need proper hashes for package identifiers.stackIs 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.stack"All 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.  V Safe-Inferred "%&)1?"stackType representing exceptions thrown by functions exported by the Stack.Storage.User module.stack*Key used to retrieve the precompiled cachestackInitialize the database."stack'Run an action in a database transactionstack0Build key used to retrieve the precompiled cache"stackInternal helper to read the  from the databasestackLoad  from the database.stackInsert or update  to the database.stackGet the record of whether an executable is compatible with a Docker imagestackSets the record of whether an executable is compatible with a Docker image"stackType-restricted version of 7 to ensure we're making the value bigger, not smaller."stackType-restricted version of 7 to ensure we're making the value bigger, not smaller.stackLoad compiler information, if available, and confirm that the referenced files are unchanged. May throw exceptions!stack0Save compiler information. May throw exceptions!stackHow many upgrade checks have occurred since the given timestamp?stackLog in the database that an upgrade check occurred at the given time.stack storage filestackcompiler executablestack sandboxed?  W Safe-Inferred "%&)1?stack0Key used to retrieve configuration or flag cachestackInitialize the database."stack'Run an action in a database transactionstack6Build key used to retrieve configuration or flag cache"stackInternal helper to read the stackLoad  from the database.stackInsert or update  to the database.stackMark  as inactive in the database. We use a flag instead of deleting the records since, in most cases, the same cache will be written again within in a few seconds (after `cabal configure`), so this avoids unnecessary database churn.stack storage fileX Safe-Inferred"1n "stackLength of dpPath"stack Length of package names combined"stackA path where the packages later in the list depend on those that come earlierstack$Reason why a dependency was not usedstackSee description of DepTypestackThe latest applicable version and it's latest Cabal file revision. For display purposes only, Nothing if package not foundstack>Recommend 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.**Y Safe-Inferred"(1stacke.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 executableZ Safe-Inferred"1wstackGet the global package database"stackRun the ghc-pkg executablestackCreate 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 databasestack(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)stack"Get the value for GHC_PACKAGE_PATHstackpackage databasesstackpackage identifier, or GhcPkgIdstackpackage database[ Safe-Inferred"6 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, for a single databasestackCall ghc-pkg describe with appropriate flags and stream to the given Sink, for a single database"stack%Call ghc-pkg and stream to the given Sink, for a single databasestackPrune a list of possible packages down to those whose dependencies are met.id uniquely identifies an item$There can be multiple items per namestackFind 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  DumpPackagesstackApply the given Sink to each section of output, broken by a single line containing ---stackGrab each key/value pair"stackGeneral purpose utilitystackif empty, use globalstackif empty, use global"stackif empty, use globalstackextract the name from an idstackthe id of an itemstackget the dependencies of an itemstack(choose the desired of two possible itemsstack input itemsstackallowed 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] Safe-Inferred"%&"stackType representing 'pretty' exceptions thrown by functions exported by the  Stack.Lock module.  ^ Safe-Inferred"()1 "stack#Was a concrete component specified?"stack)Only if we're adding this as a dependencystackRaw command line input, without checking against any databases or list of locals. Does not deal with directoriesstackEither 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"stackOutput .o/.hi directory.stackGHCi files directory.stackThe directory containing the files used for dirtiness check of source files.stack3The filename used to mark tests as having succeededstack/The filename used to mark tests as having builtstack2The filename used for modification check of .cabalstack8The filename used for modification check of setup-configstackThe filename used for the project root from the last build of a packagestackDirectory for HPC work.stack,Relative location of directory for HPC work.stack2Package's setup-config storing Cabal configurationstack$Package's build artifacts directory.stackThe directory containing all dist directories, including all different GHC/Cabal combos."stackRelative directory to the top dist directory, containing individual GHC/Cabal combo 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 sandbox` Safe-Inferred"%&r"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. Safe-Inferred"1"stack*Get all files referenced by the benchmark."stack%Get all files referenced by the test."stack+Get all files referenced by the executable."stack(Get all files referenced by the library."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."stack1Parse a .hi file into a set of modules and files."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."stackGet the target's JS sources."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."stackDirectories to look in.stack Base names. """""""""" 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 version""a Safe-Inferred"%&1stackA pair of package descriptions: one which modified the buildable values of test suites and benchmarks depending on whether they are enabled, and one which does not.Fields are intentionally lazy, we may only need one or the other value.Michael S Snoyman 2017-08-29: The very presence of this data type is terribly ugly, it represents the fact that the Cabal 2.0 upgrade did _not_ go well. Specifically, we used to have a field to indicate whether a component was enabled in addition to buildable, but that's gone now, and this is an ugly proxy. We should at some point clean up the mess of Package, LocalPackage, etc, and probably pull in the definition of PackageDescription from Cabal with our additionally needed metadata. But this is a good enough hack for the moment. Odds are, you're reading this in the year 2024 and thinking "wtf?""stack Input to "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."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).Note that for Cabal versions 1.22 and earlier, there is a bug where Cabal requires dependencies for non-buildable components to be present. We're going to use GHC version as a proxy for Cabal library version in this case for simplicity, so we'll check for GHC being 7.10 or earlier. This obviously makes our function a lot more fun to write..."stack=Get all dependencies of the package (buildable targets only).This uses both the new " and old " information."stack&A hard-coded map for tool dependencies"stackExecutable-only packages which come pre-installed with GHC and do not need to be built. Without this exception, we would either end up unnecessarily rebuilding these packages, or failing because the packages do not appear in the Stackage snapshot."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/4488"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 version55b Safe-Inferred")1 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 indexc 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.stack>Available packages and their locations for the current projectstackBuild targets as determined by istackPackages 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 dumpd Safe-Inferred"%&1"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 environmentstack$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 W.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 V (dir, W) 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 W on Windows.stackW7 if we are currently running inside a Docker container.stackW* if we are currently running inside a Nix."stack6Determine the extra config file locations which exist.Returns most local firststack8Load 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.yamlstack Use color"stackParsed command-line arguments"stackuse config pathstackOverride stack.yaml"stackOverride stack.yaml  e 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"f Safe-Inferredg Safe-Inferred"#) #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  h Safe-Inferred"1zstackStatus 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 buildstackTry to read the mod time of setup-config file from the last buildstack=Try to read the project root from the last build of a packagestack3Write 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-depsstackMark test suite statusstack&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 packagestackCheck the cache for a precompiled package matching the given configuration.#stackbuild haddocksstack dependenciesstackbuild haddocksstack dependenciesstacklibrarystack$sublibraries, in the GhcPkgId formatstack executablesstacktarget packagestackbuild haddocksstack dependenciesi Safe-Inferred"%& stack"loads and returns project packagesstackloads all local dependencies - project packages and local extra-depsstackGiven the parsed targets and build command line options constructs a source mapstackGet 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 hashstackAll 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 optsj Safe-Inferred"1stackReturns 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 a can be included in the set of installed packages or not, based on the package selections made by the user. This does not perform any dirtiness or flag change checks.stack*does not contain any installed information#stack5to determine which installed things we should includestack$package database, Nothing for globalstackfrom parent databasesk 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.#stackexecutable to be installed, and location where the binary is placed#stack'why a local package is considered dirty#stackWarnings#stackWhich packages a given package depends on, along with the package's version#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.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 < 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.#stackThrow an exception if there are any snapshot packages in the plan.#stackDetermine which packages to unregister based on the given tasks and already registered local packages.#stackGiven a  and its  , adds a ' for running its tests and benchmarks.If  isAllInOne is W, 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 W (the common case), then all of these should have already been taken care of as part of the build step.#stackGiven a , 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 , 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  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.#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 results indicate which packages are missing, meaning that their s will be figured out during the build, after they've been built. The 2nd part of the tuple result indicates the packages that are already installed which will be used. The 3rd part of the tuple is an  . If it is , then the parent package must be installed locally. Otherwise, if it is >, then it can either be installed locally or in the snapshot.#stackGet all of the dependencies for a given package, including build tool dependencies.#stackStrip out anything from the Plan intended for the local database#stackIs the given package/version combo defined in the snapshot or in the global database?stacklocally registeredstackload upstream package#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.l Safe-Inferred"bstackParser 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 interpreterm 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 n Safe-Inferred  .stackhIsTerminaDevice does not recognise handles to mintty terminals as terminal devices, but isMinTTYHandle does. Safe-Inferred #stack# name stores nul-terminated strings of information identifying the current system info to the structure referenced by name. import Foreign.C import Foreign.Marshal sysName :: IO String sysName = alloca $ \ ptr -> do throwErrnoIfMinus1_ "uname" $ uname ptr peekCString $ sysname ptr#o 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.#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 filestack&Run a sanity check on the selected GHCstack5Don't check for a compatible GHC version/architecturestack0Do not use a custom msys installation on Windowsstack8Message shown to user for how to resolve the missing GHCstack>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 modulestack-Default location of the stack-setup.yaml filestackModify 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').#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 inconsistentstackSome 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 ConfigstackEnsure 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#stack9Ensure compiler is installed, without worrying about msys#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 stack8Message to give user when necessary GHC is not available#stackalready warned about GHC?#stackexecutable filepath#stackalready installedstackpackage to findstackwhich versions are acceptable#stack$Name of tool, used in error messagesstackPath to archive filestackDestination directory.#stacklabelstack%URL, content-length, sha1, and sha256stack destinationstackoptional version#stackoptional versionstackacceptable 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 executablep Safe-Inferred"%&(5#stackParsed Config section of docker inspect output.#stackParsed result of docker inspect.#stackFunction to get command and arguments to run in Docker containerstack 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.#stackMVar used to ensure the Docker entrypoint is performed exactly once#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 u (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 removalq Safe-Inferred"1-J 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 assumedstack 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.  r Safe-Inferred-stackFunction underlying the  stack update# command. Update the package index.s Safe-Inferred"0#stackType representing 'pretty' exceptions thrown by functions exported by the  Stack.Unpack module.stackFunction underlying the  stack unpack- command. Unpack packages to the filesystem.stack.Intended to work for the command line command.stackA pair of a list of names or identifiers and an optional destination path.stack3When looking up by name, take from this build plan.stack Destination.stackNames or identifiers.t Safe-Inferred"0stackFunction underlying the stack uninstall( command. Display help for the command.u Safe-Inferred"2&#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.v Safe-Inferred"%&12stack/Type representing command line options for the  stack setup command.stackFunction underlying the  stack setup command.  w Safe-Inferred"13stack)Parse command line arguments for Stack's setup command.x Safe-Inferred"5V#stackType representing exceptions thrown by functions exported by the  Stack.Querymodule.#stackHelper function for # instance of 2stackFunction 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 objectstack Selectors.stack Selectors.y Safe-Inferred"%&8"stack>Type representing information passed to all the path printers.stackPrint out useful path information in a human-readable format (and support others later).stackThe paths of interest to a user. 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 PathInfo and pass it to the function to generate an appropriate string. Trailing slashes are removed, see #506.z Safe-Inferred8stack)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"? stack/Type representing command line options for the  stack init command.stack2List of sub directories to search for .cabal filesstack1Exclude conflicting or incompatible user packagesstackOverwrite existing stack.yamlstack>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@5stack)Parse command line arguments for Stack's init and new commands.~ Safe-Inferred"Ea#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.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-InferredEstack Parser for  stack new. Safe-Inferred"GstackPackage names.stackPaths to Cabal files.stack4To the same output channel as other log information.stackTo the standard output channel.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"L 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_"#stack,Whether to prefix log lines with timestamps.stackspecial marker for expected failures in curator builds, using those we need to keep log handle open as build continues further even after a failure#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?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$stackGet a compiled Setup exestack!Execute a function that takes an .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)$stackGenerate the ConfigCache$stackEnsure that the configuration for the package matches what is given$stack%Make a padded prefix for log messages$stack8Ensure we're the only action using the directory. See 6https://github.com/commercialhaskell/stack/issues/2730stackThis 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.$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.$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.$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.$stackDo the current executables satisfy Cabal's bugged out requirements? $stackSetup.hs input filestackSetupShim.hs input filestacktemporary directorystackglobal packagesstacksnapshot packagesstacklocal packagesstack2largest package name, for nicer interleaved outputstackglobal packagesstacksnapshot packagesstacklocal packages$stacknewConfigCachestackpackage directorystackannouncestackcabalstack Cabal file$stackA pretty announce functionstackroot directory for packagestack5All dependencies' package ids to provide to Setup.hs.$stackIs this a final build?$stackexclude TH loading?stackconvert paths to absolute?stackpackage's root directorystackcompiler we're building with$stackproject directory   Safe-Inferred"bNstack,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 _ 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-Inferredbstack*Command-line parser for the clean command. Safe-Inferredc,stack(Options parser configuration for Docker. Safe-InferreddRstackFunction 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"gstack%Helper for build and install commandsstackBuild.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 optionsstackProvide a function for loading package information from the package index$stackFind if any sublibrary dependency (other than internal libraries) exists in each project package.stack*callback after discovering all local filesstack GHC optionsstackCabal configure options Safe-Inferred"jsstack/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-Inferredk[stack)Parse command line arguments for Stack's upgrade command.stack%The default for --[no]-only-local-bin Safe-Inferred"%&o3 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 filestack"The configuration of what to checkstackAbsolute path to tarball$stackAbsolute path to tarballstack 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.0stack/Type representing command line options for the  stack upload command.stackSays whether to publish the package or upload as a release candidatestackPublish the packagestackCreate a package candidate$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.0stack1Write 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/4665stack'Upload a single tarball with the given Uploader#. Instead of sending a file like , this sends a lazy bytestring. Since 0.1.2.1stack'Upload a single tarball with the given Uploader. Since 0.1.0.0stackHackage base URLstack tar file namestacktar file contentsstackHackage base URLstackHackage base URL Safe-Inferred}stack"Parser for Cabal verbosity optionsstack!Parser for Cabal verbosity optionstackParser for the Cabal verbose flag, retained for backward compatibility Safe-Inferred~-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 stack Parser for stack hpc report.   Safe-Inferred stack)Parse command line arguments for Stack's sdist and upload commands.   Safe-Inferred! stack)Parse command line arguments for Stack's upload command.   Safe-Inferred"} stack#Parser for CLI-only build arguments   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"%& $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.$stackRun a command and grab the first line of stdout, dropping stderr's contexts completely.# #  Safe-Inferred"f 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-InferredG stack)Parse command line arguments for Stack's eval command. stackmetavar   Safe-Inferred"# stackInformation 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. stackFormat of printing dependencies stackThe normal dot options. stack/Separator between the package name and details. stack.Print dependency licenses instead of versions. stackOptions record for  stack dot stackInclude external dependencies stackInclude dependencies on base stackLimit the depth of dependency resolution to (Just n) or continue until fixpoint stack%Package names to prune from the graph stack'Stack TARGETs to trace dependencies for stack,Flags to apply when calculating dependencies stack9Like the "--test" flag for build, affects the meaning of  . stack:Like the "--bench" flag for build, affects the meaning of  . stackUse global hints instead of relying on an actual GHC installation.$stackType representing exceptions thrown by functions exported by the  Stack.Dot module. stack8Visualize the project's dependencies as a graphviz graph$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.!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!stackResolve the dependency graph up to (Just depth) or until fixpoint is reached$stackGiven a SourceMap and a dependency loader, load the set of dependencies for a package$stackResolve the direct (depth 0) external dependencies of the given local packages (assumed to come from project packages)!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"%!stack#Parser for arguments to `stack dot`!stack0Parser for arguments to `stack ls dependencies`. !!!!!!!!!!! !!!!!!!!!!! Safe-Inferred"%& !stack/Type representing command line options for the stack ls command.!stack&Type representing subcommands for the stack ls command.!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.!stack/Type representing command line options for the stack ls snapshots command.$stack*Type representing Stackage snapshot types.$stackStackage LTS Haskell$stackStackage Nightly!stack&Type representing subcommands for the stack ls snapshots 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.!!$                                                                                                                                                                                                                                                      !!!!!!!!!!!!!"""""""""###########$$$$$$$$$$$$$%%%%%%%%%&&&&&&&'''''''''''''()))))))))****+++++++++++++++++++,,,,,,,,,,,,,,,,,-------........./////////////////////0000000000000000000000000000000122222222233333333333334444555555555555555555555556666666666666666677788888999999:::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<=>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>????????????????? ???????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAABBBBBBBBBBBCDDD                                                                                                                            EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJKLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRSSSSSSTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYZZZZZZ[[[[[[[[[[\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^__________________`````aaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbccccccdddddddddddddeeeeefggggggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiijjjjjkkkkkkkkkkkkkkkkkkkkkkllmmmmmmnnnnnnnooooooooooooooooooooooooooooooooooooooooooooooppppppppppqqqqqqqqqqrssssstuuuuuvvvvvvvvvwxxxxyyyyyyyyyyyyyz{{{{|||||||||||||}~~~~~~~~~~~                                                                                                                                         !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" " """" " "" " """"""" """""""""""""""+""""""6""""""""";";"""""##"## ##L#L#L#"##N#P########################U#V#V#VV#V#W#W#X#X#X#X#Z#Z#[#[#[#]#^#^#^#^#^#^#^#_#`#`###########################a#a#a#a#a#####a#a#a#####a#a#a#b#b#b#b#b#b#c#c#c#c#c#c#d#d#d#d#d#d#d#d#d#d#d#d$d$d$e$e$e$g$g$g$g$g$g$g$g$h$h$i$i$i$i$i$i$j$j$k$k$k$k$k$k$k$k$k$k$k$k$k$k$k$k$k$k$k$k$k$k$k$$$o$o$o$o$o$o$o$o$o$o$o$o$o$o$o$o$o$o$o$o$o$o$o$o$o$o$o$o$o$o$p$p$p$p$p$p$p$p$p$p$$$$p$p$p$p$q$q$q$s$u$u$x$x$x${$|$|$|$|$|$|$|$|$~$~$~$~$~$~$~$~$~$~$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"stack-2.11.1-jiSZNE6WsTHzVOblXTwji Stack.PreludeStack.Types.VersionStack.Ghci.ScriptStack.FileWatchNetwork.HTTP.StackClient Path.Extra Path.Find Paths_stackStack.Options.UtilsStack.Options.LogLevelParserStack.Constants!Options.Applicative.Builder.ExtraData.Monoid.MapData.Attoparsec.CombinatorsData.Attoparsec.ArgsOptions.Applicative.ArgsControl.Concurrent.ExecuteStack.Types.AllowNewerDepsStack.Types.ApplyGhcOptionsStack.Types.ApplyProgOptionsStack.Types.BuildOptsStack.Options.TestParserStack.Options.PackageParserStack.Options.HaddockParserStack.Options.BenchParserStack.Config.BuildStack.Types.CabalConfigKeyStack.Types.ColorWhenStack.DefaultColorWhenStack.Types.CompilerBuildStack.Options.GhcBuildParserStack.Types.CuratorStack.Types.DockerEntrypointStack.Types.DownloadInfoStack.Types.DumpLogsStack.Types.EnvSettingsStack.Types.ExtraDirsStack.Types.GHCDownloadInfoStack.Types.GHCVariantStack.Options.GhcVariantParserStack.Types.GhcOptionKeyStack.Types.GhcOptionsStack.Types.GhcPkgIdStack.Types.DumpPackageStack.Types.IsMutableStack.Types.LockFileBehaviorStack.Types.NamedComponentStack.Types.NixStack.Types.PackageNameStack.Types.PlatformStack.Types.ProjectStack.Types.ProjectConfigStack.Types.PvpBoundsStack.Types.ResolverStack.Options.ResolverParserStack.Types.SCMStack.Types.StackYamlLocStack.Storage.UtilStack.Types.TemplateNameStack.Types.UnusedFlagsStack.Types.ParentMapStack.Types.CompilerStack.Types.SourceMapStack.Types.CompilerPaths!Stack.Types.VersionedDownloadInfoStack.Types.SetupInfoSystem.Info.ShortPathNameSystem.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.EnvConfigStack.Types.PackagePath.CheckInstallStack.Config.DockerStack.Types.ConfigureOptsStack.Types.BuildStack.Storage.UserStack.Storage.ProjectStack.Types.Build.ExceptionStack.Setup.Installed Stack.GhcPkgStack.PackageDumpStack.SourceMap Stack.LockStack.Build.TargetStack.Constants.ConfigStack.Config.Nix Stack.PackageStack.BuildPlanStack.Build.Haddock Stack.Config Stack.NixStack.Options.NixParserStack.ConfigCmdStack.Build.CacheStack.Build.SourceStack.Build.InstalledStack.Build.ConstructPlanData.Attoparsec.InterpreterSystem.Process.PagerSystem.Terminal Stack.Setup Stack.Docker Stack.Runners Stack.Update Stack.UnpackStack.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.Execute Stack.CleanStack.Options.CleanParserStack.Options.DockerParserStack.DockerCmd Stack.Build Stack.UpgradeStack.Options.UpgradeParser Stack.Script Stack.SDist Stack.UploadStack.Options.BuildMonoidParserStack.Options.ConfigParserStack.Options.GlobalParserStack.Options.CompletionStack.Options.ScriptParserStack.Options.HpcReportParserStack.Options.SDistParserStack.Options.UploadParserStack.Options.BuildParser Stack.Hoogle Stack.GhciStack.Options.GhciParser Stack.ExecStack.Options.ExecParser Stack.EvalStack.Options.EvalParser Stack.DotStack.Options.DotParserStack.LsStack.Options.LsParser Path.ExtendedPath.IO resolveDir resolveFile resolveFile'Stack.Internal.BuildInfoStack.Constants.UsrLibDirsStack.Constants.StackProgNameStack.Types.CacheStack.Types.StorageStack.Types.DependencyStack.Types.PackageFileStack.Docker.HandlersStack.ComponentFile"Distribution.Simple.LocalBuildInfocomponentBuildDirStack.PackageFile loadSourceMap System.UnameFS removeTreeS ByteStringdistRelativeDirbaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip Data.Tuplefstsnd 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.EitherEitherNonEmptyGHC.Stack.Types CallStackFalseNothingJustTrue:|LeftRightLTEQGT,Cabal-syntax-3.10.1.0-CzFvy6Vr4NPEeFMO9pQqoE(Distribution.Types.VersionRange.Internal VersionRangeDistribution.Types.VersionRange withinRange"Distribution.Types.MungedPackageIdMungedPackageIdDistribution.Types.PackageIdpkgNamePackageIdentifier pkgVersionGHC.IO.StdHandlesstdoutstderrforM_GHC.STST Data.VoidVoidabsurdunlessfoldMfilterMforData.Functor.Identity runIdentityIdentityGHC.IO.Exception ExitFailure ExitSuccessExitCodeGHC.IOFilePath IOExceptionGHC.Exception.Type fromException toExceptiondisplayException ExceptionData.Functor.ConstgetConstConst traverse_ sequence_ornotElemfor_ concatMapconcatanyandall Data.OldListwordsunwordsunlineslines Text.Read readMaybepartitionEitherseither Data.ProxyProxyoddlcmgcdeven^^^zipWith takeWhiletakespanreverse replicatelookup dropWhiledropbreak Data.Maybe maybeToListmaybemapMaybe listToMaybe isNothingisJust fromMaybe catMaybes Data.Functionon Data.Functorvoid<$>uncurrycurrysubtractmplusmzero MonadPlusmanysome<|> AlternativewhenliftM2liftMidflipconstasTypeOf=<<.$!GHC.Err undefinederror SomeException&&not||containers-0.6.5.1Data.Map.InternalMapData.Set.InternalSetdeepseq-1.4.6.1Control.DeepSeqrnfNFDataforcedeepseq sequenceAtraversesumtoListproductnulllengthfoldrfoldl'foldMapelem<*showroundtruncateproperFractionfloorceiling scaleFloat significandisNegativeZeroisNaN isInfiniteisIEEEisDenormalized floatRange floatRadix floatDigitsexponent encodeFloat decodeFloatatan2<<=>comparemaxminsignumabs+*<$remquotRemquotmoddivModdivrecip/tantanhsqrtsinhsinpilogBaselogexpcoshcosatanhatanasinhasinacoshacos**/=fromEnummaxBoundminBound GHC.Conc.SyncThreadIdGHC.MVarMVarDistribution.Types.PackageName PackageNameDistribution.ModuleName ModuleNameData.Ord comparingDistribution.Types.VersionVersionDistribution.Types.LibraryName LibraryName LMainLibName LSubLibNamebytestring-0.11.3.1Data.ByteString.InternalData.ByteString.Short.InternalShortByteString byteSwap16 byteSwap32 byteSwap64 mungedVersion mungedNameDistribution.Types.FlagFlagName$Distribution.Types.MungedPackageNameMungedPackageNameData.Semigroup.InternalAnygetAnyControl.Applicativeoptional Data.ByteString.Builder.InternalBuilder'hashable-1.4.2.0-D6EOHOGayLdHLpjCLzeHpLData.Hashable.ClassHashable text-1.2.5.0Data.Text.InternalText3unordered-containers-0.2.19.1-IxllGDxiwx4nPRh3Oq5LRData.HashMap.InternalHashMapstdinGHC.IO.Handle.TypesHandleData.Bifunctorbimap BifunctormapM_!async-2.2.4-BynBTfyCgtT3jUuK6dAuwControl.Concurrent.Async waitBothSTMwaitEitherSTM_ waitEitherSTMwaitEitherCatchSTM waitAnySTMwaitAnyCatchSTMpollSTM waitCatchSTMwaitSTM asyncThreadIdAsyncAsyncCancelledtoConstrgunfoldgmapTgmapQrgmapQlgmapQigmapQgmapMpgmapMogmapMgfoldl dataTypeOf dataCast2 dataCast1Control.Concurrent.ChanChanControl.Concurrent.QSemQSemControl.Concurrent.QSemNQSemNData.Bitraversable bitraverse Bitraversable bisequence bimapAccumR bimapAccumLbiforData.Bifoldablebifoldrbifoldl bifoldMapbifold Bifoldable bitraverse_bisum bisequence_ biproductbiorbinull binotElem biminimumBy biminimum bimaximumBy bimaximumbilengthbifor_bifoldrMbifoldr1bifoldr'bifoldlMbifoldl1bifoldl'bifindbielem biconcatMapbiconcatbiasumbianybiandbiallbiListsecondfirstControl.Monad.IO.ClassliftIOMonadIO zipWithM_zipWithM replicateM_mfilterforeverfoldM_>=><=<<$!>sequencemapMforM Control.Arrow***&&&ArrowTVarSTM writeTVarreadTVarorElsenewTVarSomeAsyncExceptionasyncExceptionToExceptionasyncExceptionFromException NoBuffering LineBufferingBlockBuffering BufferMode GHC.IO.Device SeekFromEnd RelativeSeek AbsoluteSeekSeekMode GHC.IORefIOReffold sequenceA_msumasum Data.MonoidgetFirstFirstgetSumSumappEndoEndogetDownDownForeign.StorableStorablerightsleftsisRightisLeft fromRightfromLeftControl.CategoryCategory>>> GHC.IO.IOMode WriteMode ReadWriteModeReadMode AppendModeIOModerunST Data.Boolboolfix&<&>$>liftA2liftA3liftA HasCallStack fromShorttoShorttransformers-0.5.6.2Control.Monad.Trans.ReaderReaderT&conduit-1.3.4.3-BuAYhGgwY5ACYnc8L4tx87Data.Conduit.Internal.Conduit runConduit.|ConduitM,unliftio-core-0.2.1.0-LnlI9cWUdXt7RBg3vurrUqControl.Monad.IO.Unlift withRunInIO MonadUnliftIO(primitive-0.8.0.0-LlRUNeadwzL5iUsmiOkRZ1Control.Monad.Primitive PrimMonad PrimState primitiveControl.Monad.Trans.Class MonadTransliftexceptions-0.10.4Control.Monad.Catch MonadThrowthrowMData.IntMap.InternalIntMapData.IntSet.InternalIntSetData.Sequence.InternalSeq$!!Handler'fsnotify-0.4.1.0-CrQQNwL9LvD2L7DQC11onFSystem.FSNotify.Types WatchModePoll WatchMode+http-client-0.7.13.1-BEMx0YrR8MrCPaxNL0cTIr%Network.HTTP.Client.MultipartFormData formDataBodypartFileRequestBodypartLBSpartBSNetwork.HTTP.Client.RequestsetRequestCheckStatusgetUri parseRequest parseUrlThrowNetwork.HTTP.Client.TypesInvalidUrlExceptionHttpExceptionRequest HttpExceptionInvalidProxySettingsConnectionClosedInvalidProxyEnvironmentVariableHttpZlibExceptionInvalidDestinationHostIncompleteHeadersInvalidChunkHeadersResponseBodyTooShortWrongRequestBodyStreamSizeTlsNotSupportedNoResponseDataReceivedProxyConnectExceptionInternalExceptionInvalidRequestHeader InvalidHeaderInvalidStatusLineConnectionFailureConnectionTimeoutResponseTimeoutOverlongHeadersTooManyRedirectsStatusCodeExceptionHttpExceptionContent RequestBodyBSRequestBodyLBS RequestBody checkResponserequestHeaderspathRequestresponseCookieJar responseBodyresponseHeadersresponseVersionresponseStatusResponse.http-client-tls-0.3.6.1-6d4tyWlYIynCZBzrurYDlINetwork.HTTP.Client.TLSapplyDigestAuthdisplayDigestAuthExceptiongetGlobalManager(http-conduit-2.3.8-gyJtWpwz9QI7pnD4HkQWdNetwork.HTTP.SimplegetResponseBodygetResponseHeadersgetResponseStatusCodesetRequestBodysetRequestHeaderaddRequestHeadersetRequestMethod,http-download-0.2.0.0-Krikz3bjM8m8QZVBFjCFTbNetwork.HTTP.Download.VerifieddrRetryPolicyDefaultsetForceDownloadsetRetryPolicysetLengthCheck setHashChecksmkDownloadRequestDownloadRequesthashCheckHexDigesthashCheckAlgorithm HashCheckCheckHexDigestHeaderCheckHexDigestByteStringCheckHexDigestStringCheckHexDigestDownloadHttpError WrongDigestWrongStreamLengthWrongContentLengthVerifiedDownloadException(http-types-0.12.3-L3rcKlUfVN0BViQ440kXJlNetwork.HTTP.Types.Status notFound404Network.HTTP.Types.Method methodPutNetwork.HTTP.Types.Header hContentMD5hContentLengthhAccept)microlens-0.4.13.1-5Q580NbiDM6AM43K2os1L8 Lens.Microlens^?^..to^.set.~over%~Lens.Micro.InternalsetsLens.Micro.TypeASetterASetter' SimpleGetterGettingLensLens' mtl-2.2.2Control.Monad.Reader.Classasks MonadReaderReaderlocal,microlens-mtl-0.2.0.3-E048eF1HvNVB14JaafmtRuLens.Micro.Mtlpreviewview runReaderTask runReader%pantry-0.8.2.2-E26muiGbClT7ZjMNLB8evbPantrywithSnapshotCachepartitionReplacedDependenciesloadGlobalHintsrunPantryAppCleanrunPantryAppWith runPantryApphpackExecutableLgetPackageLocationTreeKeygetRawPackageLocationTreeKeygetRawPackageLocationIdentpackageLocationVersionpackageLocationIdentgetPackageLocationNameloadSnapshotLayerloadRawSnapshotLayeraddPackagesToSnapshotloadAndCompleteSnapshotRaw'loadAndCompleteSnapshotRawloadAndCompleteSnapshot'loadAndCompleteSnapshotcompleteSnapshotLocationcompletePackageLocationtryLoadPackageRawViaCasaloadPackageRaw loadPackage gpdVersiongpdPackageNamegpdPackageIdentifierfindOrGenerateCabalFileloadCabalFilePath loadCabalFileloadCabalFileRawloadCabalFileRawImmutableloadCabalFileImmutableunpackPackageLocationunpackPackageLocationRaw fetchPackagesgetLatestHackageRevisiongetLatestHackageLocationgetLatestHackageVersiondefaultDownloadPrefixdefaultPackageIndexConfigdefaultCasaMaxPerRequestdefaultCasaRepoPrefixwithPantryConfigcplHasCabalFile cplCompleteCompletePackageLocation CompletedPLI CompletedSL apcGhcOptions apcHiddensapcFlagsapcDropAddPackagesConfig PantryApp Pantry.RepowithRepo fetchRepos fetchReposRawPantry.HackagegetHackagePackageVersionsgetHackageTypoCorrectionsupdateHackageIndexhackageIndexTarballLNoUpdateOccurredUpdateOccurredDidUpdateOccurIgnorePreferredVersionsUsePreferredVersionsNoRequireHackageIndexYesRequireHackageIndexRequireHackageIndex Pantry.TypeswarnMissingCabalFiletoRawSnapshotLayertoRawSL parseSnapNamedefaultSnapshotLocationparseRawSnapshotLocationparseWantedCompilerunCabalStringMaptoCabalStringMapmoduleNameStringflagNameString versionStringpackageIdentifierStringpackageNameString parseFlagNameparseVersionThrowing parseVersionparsePackageNameThrowingparsePackageNameparsePackageIdentifiermkSafeFilePathparsePackageIdentifierRevisionparseHackageTextdefaultHackageSecurityConfigtoRawPL resolvePathssnapshotLocationRevision PantryConfigNoPrintWarningsYesPrintWarnings PrintWarnings UnresolvedresolvedAbsoluteresolvedRelative ResolvedPath RPLMutable RPLImmutableRawPackageLocation PLMutable PLImmutablePackageLocationRPLIRepo RPLIArchive RPLIHackageRawPackageLocationImmutablePLIRepo PLIArchive PLIHackagePackageLocationImmutableraSubdirraSizeraHash raLocation RawArchive archiveSubdir archiveSize archiveHasharchiveLocationArchiveRepoHgRepoGitRepoType repoSubdirrepoType repoCommitrepoUrlRepo sRepoType sRepoCommitsRepoUrl SimpleRepopicHackageSecurityConfigpicDownloadPrefixPackageIndexConfighscIgnoreExpiryhscKeyThreshold hscKeyIdsHackageSecurityConfig pantryConfigLHasPantryConfigFileSizeBlobKey CFIRevisionCFIHash CFILatest CabalFileInfoPackageIdentifierRevisionmismatchActualmismatchExpectedMismatchHpackExeExceptionHpackLibraryExceptionParseSnapNameExceptionInvalidTreeFromCasaMigrationFailureDuplicatePackageNamesInvalidCabalFilePathPackageVersionParseFailPackageNameParseFailMismatchedCabalFileForHackageMutablePackageLocationFromUrlCannotCompleteRepoNonSHA1UnknownHackagePackage CRC32MismatchCompletePackageMetadataMismatchTreeReferencesMissingBlobFailedToCloneRepoNoHackageCryptographicHashUnsupportedTarballInvalidTarFileTypeUnknownArchiveTypeLocalInvalidSizeLocalInvalidSHA256DownloadTooLargeDownloadInvalidSizeDownloadInvalidSHA256WrongCabalFileNameCouldn'tParseSnapshotInvalidBlobKeyNon200ResponseStatusMismatchedPackageMetadataInvalidSnapshotInvalidFilePathSnapshotInvalidOverrideCompilerInvalidSnapshotLocationInvalidWantedCompilerMultipleCabalFilesFoundNoCabalFileFoundNoLocalPackageDirFoundMismatchedCabalNameTreeWithMultipleCabalFilesTreeWithoutCabalFileInvalidCabalFile"PackageIdentifierRevisionParseFailPantryExceptionFRRevisionNotFoundFRVersionNotFoundFRNameNotFound FuzzyResults SafeFilePathTreeKey rpmTreeKey rpmVersionrpmNameRawPackageMetadata pmTreeKeypmIdentPackageMetadata RelFilePath ALFilePathALUrlArchiveLocation unCabalString CabalString HpackCommand HpackBundledHpackExecutableWCGhcjsWCGhcGitWCGhcWantedCompilerNightlyLTSSnapName RSLSynonym RSLFilePathRSLUrl RSLCompilerRawSnapshotLocation SLFilePathSLUrl SLCompilerSnapshotLocationrsDrop rsPackages rsCompiler RawSnapshot snapshotDropsnapshotPackagessnapshotCompilerSnapshot rspGhcOptions rspHiddenrspFlags rspLocationRawSnapshotPackage spGhcOptionsspHiddenspFlags spLocationSnapshotPackagerslPublishTime rslGhcOptions rslHiddenrslFlagsrslDropPackages rslLocations rslCompiler rslParentRawSnapshotLayer slPublishTime slGhcOptionsslHiddenslFlagsslDropPackages slLocations slCompilerslParent SnapshotLayerunSnapshotCacheHashSnapshotCacheHash Pantry.SHA256SHA256!path-0.9.2-FJCrfGsu6OO8pXhdlpLWUS Path.PosixAbsRelFileDirPath.Internal.Posix toFilePathPath'unliftio-0.2.24.0-LQ0PykdUzi0K9IfLZa7Vl UnliftIO.ChannewChan writeChanreadChandupChangetChanContentswriteList2ChanUnliftIO.ExceptionStringExceptioncatchcatchIOcatchAny catchDeep catchAnyDeep catchJustcatchSyncOrAsynchandlehandleIO handleAny handleDeep handleAnyDeep handleJusthandleSyncOrAsynctrytryIOtryAnytryDeep tryAnyDeeptryJusttrySyncOrAsyncpureTry pureTryDeepcatches catchesDeepevaluate evaluateDeepbracketbracket_bracketOnErrorbracketOnError_finally withException onExceptionthrowIOtoSyncExceptiontoAsyncExceptionfromExceptionUnwrapisSyncExceptionisAsyncExceptionmaskuninterruptibleMaskmask_uninterruptibleMask_ throwStringstringExceptionthrowTo impureThrow fromEither fromEitherIO fromEitherM mapExceptionM UnliftIO.IOwithFileopenFilehClosehFlush hFileSize hSetFileSizehIsEOF hSetBuffering hGetBufferinghSeekhTellhIsOpen hIsClosed hIsReadable hIsWritable hIsSeekablehIsTerminalDevicehSetEchohGetEcho hWaitForInputhReadygetMonotonicTimeUnliftIO.IORefnewIORef readIORef writeIORef modifyIORef modifyIORef'atomicModifyIORefatomicModifyIORef'atomicWriteIORef mkWeakIORefUnliftIO.Internals.AsyncEmptyWithNoAlternative ConcExceptionConcrunConcurrently Concurrentlyasync asyncBoundasyncOnasyncWithUnmaskasyncOnWithUnmask withAsyncwithAsyncBound withAsyncOnwithAsyncWithUnmaskwithAsyncOnWithUnmaskwaitpoll waitCatchcanceluninterruptibleCancel cancelWithwaitAny waitAnyCatch waitAnyCancelwaitAnyCatchCancel waitEitherwaitEitherCatchwaitEitherCancelwaitEitherCatchCancel waitEither_waitBothlinklink2racerace_ concurrently concurrently_forConcurrentlyforConcurrently_replicateConcurrentlyreplicateConcurrently_mapConcurrentlymapConcurrently_concrunConcpooledMapConcurrentlyNpooledMapConcurrentlypooledForConcurrentlyNpooledForConcurrentlypooledMapConcurrentlyN_pooledMapConcurrently_pooledForConcurrently_pooledForConcurrentlyN_pooledReplicateConcurrentlyNpooledReplicateConcurrentlypooledReplicateConcurrentlyN_pooledReplicateConcurrently_ UnliftIO.MVar newEmptyMVarnewMVartakeMVarputMVarreadMVarswapMVar tryTakeMVar tryPutMVar isEmptyMVar tryReadMVarwithMVarwithMVarMasked modifyMVar_ modifyMVarmodifyMVarMasked_modifyMVarMasked mkWeakMVarUnliftIO.MemoizeMemoized runMemoized memoizeRef memoizeMVar UnliftIO.QSemnewQSemwaitQSem signalQSemwithQSemUnliftIO.QSemNnewQSemN waitQSemN signalQSemN withQSemN UnliftIO.STM atomicallyretrySTMcheckSTM newTVarIO readTVarIO registerDelay mkWeakTVar newTMVarIOnewEmptyTMVarIO mkWeakTMVar newTChanIOnewBroadcastTChanIO newTQueueIO newTBQueueIOUnliftIO.TemporarywithSystemTempFilewithSystemTempDirectory withTempFilewithTempDirectoryUnliftIO.TimeouttimeoutliftIOOpwrappedWithRunInIOtoIO withUnliftIO askRunInIO askUnliftIOunliftIOUnliftIO stm-2.5.0.2Control.Concurrent.STM.TBQueue flushTBQueueisEmptyTBQueue isFullTBQueue lengthTBQueue newTBQueue peekTBQueue readTBQueuetryPeekTBQueuetryReadTBQueue unGetTBQueue writeTBQueueTBQueueControl.Concurrent.STM.TChan cloneTChandupTChan isEmptyTChannewBroadcastTChannewTChan peekTChan readTChan tryPeekTChan tryReadTChan unGetTChan writeTChanTChanControl.Concurrent.STM.TMVar isEmptyTMVar newEmptyTMVarnewTMVarputTMVar readTMVar swapTMVar takeTMVar tryPutTMVar tryReadTMVar tryTakeTMVarTMVarControl.Concurrent.STM.TQueue isEmptyTQueue newTQueue peekTQueue readTQueue tryPeekTQueue tryReadTQueue unGetTQueue writeTQueueTQueueControl.Concurrent.STM.TVar modifyTVar modifyTVar' stateTVarswapTVar.safe-exceptions-0.1.7.3-F3pCGsFacJi7W8pk2HTFeyControl.Exception.SafeAsyncExceptionWrapperSyncExceptionWrapper#rio-0.1.22.0-9oqw0pJ5UBeLFlbWBT8f2RRIO.Prelude.TracetraceDisplayStacktraceDisplayMarkerIOtraceDisplayMarkertraceDisplayEventIOtraceDisplayEvent traceDisplayMtraceDisplayIOtraceDisplayId traceDisplaytraceShowStacktraceShowMarkerIOtraceShowMarkertraceShowEventIOtraceShowEvent traceShowM traceShowIO traceShowId traceShow traceStack traceMarkerIO traceMarker traceEventIO traceEventtraceMtraceIOtraceIdtraceRIO.Prelude.Simple runSimpleApp mkSimpleApp SimpleAppRIO.Prelude.RIOnewUnboxedSomeRef newSomeRef modifySomeRef writeSomeRef readSomeRefmapRIOliftRIOrunRIOunRIORIOSomeRef stateRefL HasStateRef writeRefL HasWriteRefRIO.Prelude.URef modifyURef writeURefreadURefnewURefURefIOURef RIO.Deque freezeDeque dequeToVector dequeToList foldrDeque foldlDeque pushBackDequepushFrontDeque popBackDeque popFrontDeque getDequeSizenewDequeasBDequeasSDequeasUDequeDequeUDequeSDequeBDequeRIO.Prelude.IO readFileUtf8writeFileBinaryreadFileBinary hPutBuilder writeFileUtf8withLazyFileUtf8 withLazyFileRIO.Prelude.LoggergLogFuncClassicglog mkGLogFunccontramapGLogFunccontramapMaybeGLogFunc noLogginglogFuncAccentColorsLlogFuncSecondaryColorLlogFuncLogLevelColorsLlogFuncUseColorLdisplayCallStack setLogFormat setLogUseLocsetLogAccentColorssetLogSecondaryColorsetLogLevelColorssetLogUseColor setLogUseTimesetLogTerminalsetLogVerboseFormatIOsetLogVerboseFormatsetLogMinLevelIOsetLogMinLevel withLogFunc newLogFunclogOptionsHandlelogOptionsMemory logStickyDone logSticky logOtherS logErrorSlogWarnSlogInfoS logDebugSlogOtherlogErrorlogWarnlogInfologDebug logGeneric mkLogFunc LevelOther LevelError LevelWarn LevelInfo LevelDebugLogLevel LogSourcelogFuncL HasLogFuncLogFunc LogOptions gLogFuncLGMsg HasGLogFuncGLogFunc getLogLevel HasLogLevel getLogSource HasLogSourceRIO.Prelude.TextdecodeUtf8LenienttshowRIO.Prelude.Renames yieldThreadfromStrictBytes toStrictBytessappendUVectorSVectorGVector LByteStringLTextRIO.Prelude.ExtraasIOunlessMwhenMnubOrdfoldMapM forMaybeM mapMaybeM forMaybeA mapMaybeA fromFirstmapLeftRIO.Prelude.ExitexitWith exitSuccess exitFailureRIO.Prelude.DisplaywriteFileUtf8Builderutf8BuilderToLazyTextutf8BuilderToTextdisplayBytesUtf8 displayShowgetUtf8Builder Utf8Builder textDisplaydisplayDisplay&vector-0.13.0.0-JKrBPPZBIK2JBM2KZEUb7Z Data.VectorVectorData.Vector.Unboxed.BaseUnboxData.HashSet.InternalHashSetwithBinaryFileUnliftIO.IO.FileensureFileDurablewriteBinaryFileDurablewriteBinaryFileDurableAtomicwithBinaryFileDurablewithBinaryFileDurableAtomicwithBinaryFileAtomicwriteBinaryFileUnliftIO.Concurrent myThreadId threadDelaythreadWaitReadthreadWaitWriteisCurrentThreadBoundData.Text.Encoding.Error lenientDecodeUnicodeException DecodeError EncodeErrorData.Text.Encoding decodeUtf8'decodeUtf8With encodeUtf8encodeUtf8Builder.rio-prettyprint-0.1.4.0-JtMW7fgSykMKw6qAdZOaceRIO.PrettyPrintlogLevelToStylemkNarrativeList bulletedListstyle debugBracketflow prettyWarnS prettyNoteS prettyInfoS prettyErrorL prettyWarnL prettyNoteL prettyInfoL prettyDebugLprettyWarnNoIndent prettyError prettyWarn prettyNote prettyInfo prettyDebug termWidthL useColorLHasTermRIO.PrettyPrint.PrettyExceptionPrettyException Text.PrettyPrint.Leijen.Extendedsoftline softbreakhangindent encloseSepfillSephsepvsepsephcat punctuatefilllinestringparensalign<+>prettyPrettyStyleDocRIO.PrettyPrint.StylesUpdateparseStylesUpdateFromString stylesUpdate StylesUpdate stylesUpdateLHasStylesUpdateRIO.PrettyPrint.DefaultStyles defaultStylesRIO.PrettyPrint.Types Highlight Secondary PkgComponentModuleTargetCurrentRecommendationUrlShellGood OtherLevelDebugInfoWarningErrorStyle StyleSpechttpJSONhttpLbs httpNoBodyhttpSink withResponsesetGitHubHeadersdownload redownloadverifiedDownloadverifiedDownloadWithProgresstoFilePathNoTrailingSepparseCollapsedAbsDirparseCollapsedAbsFileconcatAndCollapseAbsDirdropRootrejectMissingFilerejectMissingDirpathToLazyByteStringpathToByteString pathToTexttryGetModificationTimeforgivingResolveDirforgivingResolveFileforgivingResolveFile' findFileUp findDirUp findFiles findInParentsversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirPrettyRawSnapshotLocation FirstFalse getFirstFalse FirstTrue getFirstTruewithSystemTempDirwithKeepSystemTempDirsinkProcessStderrStdoutsinkProcessStdoutlogProcessStderrStdoutreadProcessNullwithProcessContextstripCRpromptpromptPassword promptBool fromFirstTruedefaultFirstTruefromFirstFalsedefaultFirstFalsewriteBinaryFileAtomic bugReportbugPrettyReport blankLine ppException prettyThrowIO prettyThrowMmcons prettyGeneric$fMonoidFirstTrue$fSemigroupFirstTrue$fMonoidFirstFalse$fSemigroupFirstFalse!$fPrettyPrettyRawSnapshotLocation$fEqFirstFalse$fOrdFirstFalse$fShowFirstFalse $fEqFirstTrue$fOrdFirstTrue$fShowFirstTrueGlobalOptsContextOuterGlobalOptsOtherCmdGlobalOptsBuildCmdGlobalOptsGhciCmdGlobalOptshideMods$fEqGlobalOptsContext$fShowGlobalOptsContextlogLevelOptsParser GhciScriptcmdAddcmdCdGhc cmdModulescriptToLazyByteStringscriptToBuilder scriptToFile$fMonoidGhciScript$fSemigroupGhciScript$fShowGhciCommand fileWatch fileWatchPoll usrLibDirs stackProgNamePathCompleterOpts pcoAbsolute pcoRelative pcoRootDir pcoFileFilter pcoDirFilter 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 acRemaining acDownstream acConcurrency ConcurrencyConcurrencyAllowedConcurrencyDisallowedActionactionId actionDepsactionDoactionConcurrencyActionId 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$fShowApplyProgOptionsCabalVerbosity FileWatchOpts NoFileWatch FileWatch FileWatchPollBenchmarkOptsMonoidbeoMonoidAdditionalArgsbeoMonoidDisableRun BenchmarkOptsbeoAdditionalArgs beoDisableRunHaddockOptsMonoidhoMonoidAdditionalArgs HaddockOptshoAdditionalArgsTestOptsMonoidtoMonoidRerunTeststoMonoidAdditionalArgstoMonoidCoveragetoMonoidDisableRuntoMonoidMaximumTimeSecondstoMonoidAllowStdinTestOpts toRerunTeststoAdditionalArgs toCoverage toDisableRuntoMaximumTimeSeconds toAllowStdin BuildSubsetBSAllBSOnlySnapshotBSOnlyDependencies BSOnlyLocalsBuildOptsMonoidbuildMonoidTracebuildMonoidProfilebuildMonoidNoStripbuildMonoidLibProfilebuildMonoidExeProfilebuildMonoidLibStripbuildMonoidExeStripbuildMonoidHaddockbuildMonoidHaddockOptsbuildMonoidOpenHaddocksbuildMonoidHaddockDepsbuildMonoidHaddockInternal!buildMonoidHaddockHyperlinkSourcebuildMonoidInstallExesbuildMonoidInstallCompilerToolbuildMonoidPreFetchbuildMonoidKeepGoingbuildMonoidKeepTmpFilesbuildMonoidForceDirtybuildMonoidTestsbuildMonoidTestOptsbuildMonoidBenchmarksbuildMonoidBenchmarkOptsbuildMonoidReconfigurebuildMonoidCabalVerbosebuildMonoidSplitObjsbuildMonoidSkipComponentsbuildMonoidInterleavedOutputbuildMonoidDdumpDir BuildCommandBuildTestHaddockBenchInstall BuildOptsCLIboptsCLITargetsboptsCLIDryrunboptsCLIGhcOptionsboptsCLIProgsOptions boptsCLIFlagsboptsCLIBuildSubsetboptsCLIFileWatchboptsCLIWatchAll boptsCLIExecboptsCLIOnlyConfigureboptsCLICommandboptsCLIInitialBuildSteps ApplyCLIFlagACFAllProjectPackages ACFByName BuildOptsboptsLibProfileboptsExeProfile boptsLibStrip boptsExeStrip boptsHaddockboptsHaddockOptsboptsOpenHaddocksboptsHaddockDepsboptsHaddockInternalboptsHaddockHyperlinkSourceboptsInstallExesboptsInstallCompilerTool boptsPreFetchboptsKeepGoingboptsKeepTmpFilesboptsForceDirty boptsTests boptsTestOptsboptsBenchmarksboptsBenchmarkOptsboptsReconfigureboptsCabalVerboseboptsSplitObjsboptsSkipComponentsboptsInterleavedOutput boptsDdumpDirdefaultBuildOptsdefaultBuildOptsCLIboptsCLIFlagsByNameboptsCLIAllProgOptionsdefaultTestOptsdefaultHaddockOptsdefaultBenchmarkOptstoFirstCabalVerbositybuildOptsMonoidHaddockLbuildOptsMonoidTestsLbuildOptsMonoidBenchmarksLbuildOptsMonoidInstallExesLbuildOptsInstallExesLbuildOptsHaddockL$fMonoidTestOptsMonoid$fSemigroupTestOptsMonoid$fFromJSONWithJSONWarnings$fMonoidHaddockOptsMonoid$fSemigroupHaddockOptsMonoid$fFromJSONWithJSONWarnings0$fMonoidBenchmarkOptsMonoid$fSemigroupBenchmarkOptsMonoid$fFromJSONWithJSONWarnings1$fParsecCabalVerbosity$fFromJSONCabalVerbosity$fMonoidBuildOptsMonoid$fSemigroupBuildOptsMonoid$fFromJSONWithJSONWarnings2$fShowBuildOpts$fGenericBuildOptsMonoid$fShowBuildOptsMonoid$fEqCabalVerbosity$fShowCabalVerbosity$fShowBuildOptsCLI$fShowFileWatchOpts$fEqFileWatchOpts$fGenericBenchmarkOptsMonoid$fShowBenchmarkOptsMonoid$fEqBenchmarkOpts$fShowBenchmarkOpts$fGenericHaddockOptsMonoid$fShowHaddockOptsMonoid$fEqHaddockOpts$fShowHaddockOpts$fShowTestOptsMonoid$fGenericTestOptsMonoid $fEqTestOpts$fShowTestOpts$fShowBuildSubset$fEqBuildSubset$fEqBuildCommand$fShowBuildCommand$fEqApplyCLIFlag$fOrdApplyCLIFlag$fShowApplyCLIFlagtestOptsParserreadFlaghaddockOptsParserbenchOptsParserbuildOptsFromMonoidhaddockOptsFromMonoidtestOptsFromMonoidbenchmarkOptsFromMonoidCabalConfigKey CCKTargets CCKLocals CCKEverything CCKPackageparseCabalConfigKey$fFromJSONKeyCabalConfigKey$fFromJSONCabalConfigKey$fShowCabalConfigKey$fReadCabalConfigKey$fEqCabalConfigKey$fOrdCabalConfigKey ColorWhen ColorNever ColorAlways ColorAuto readColorWhen$fFromJSONColorWhen $fEqColorWhen$fGenericColorWhen$fShowColorWhendefaultColorWhen CompilerBuildCompilerBuildStandardCompilerBuildSpecializedcompilerBuildNamecompilerBuildSuffixparseCompilerBuild$fFromJSONCompilerBuild$fShowCompilerBuildghcBuildParserCuratorcuratorSkipTestcuratorExpectTestFailurecuratorSkipBenchmarkcuratorExpectBenchmarkFailurecuratorSkipHaddockcuratorExpectHaddockFailure$fToJSONCurator $fShowCurator DockerUserduUidduGidduGroupsduUmaskDockerEntrypointdeUser$fReadDockerEntrypoint$fShowDockerEntrypoint$fReadDockerUser$fShowDockerUser DownloadInfodownloadInfoUrldownloadInfoContentLengthdownloadInfoSha1downloadInfoSha256parseDownloadInfoFromObject$fShowDownloadInfoDumpLogs DumpNoLogsDumpWarningLogs DumpAllLogs$fFromJSONDumpLogs$fBoundedDumpLogs$fEnumDumpLogs $fEqDumpLogs $fOrdDumpLogs$fReadDumpLogs$fShowDumpLogs EnvSettingsesIncludeLocalsesIncludeGhcPackagePath esStackExe esLocaleUtf8 esKeepGhcRtsminimalEnvSettingsdefaultEnvSettingsplainEnvSettings$fEqEnvSettings$fOrdEnvSettings$fShowEnvSettings ExtraDirsedBins edIncludeedLib$fMonoidExtraDirs$fSemigroupExtraDirs$fShowExtraDirs$fGenericExtraDirsGHCDownloadInfogdiConfigureOptsgdiConfigureEnvgdiDownloadInfo$fShowGHCDownloadInfo HasGHCVariant ghcVariantL GHCVariant GHCStandardGHCIntegerSimpleGHCNativeBignum GHCCustomghcVariantNameghcVariantSuffixparseGHCVariant$fFromJSONGHCVariant$fHasGHCVariantGHCVariant$fShowGHCVariantghcVariantParser GhcOptionKeyGOKOldEverything GOKEverything GOKLocals GOKTargets GOKPackage$fFromJSONKeyGhcOptionKey$fEqGhcOptionKey$fOrdGhcOptionKey GhcOptions unGhcOptions$fFromJSONGhcOptionsGhcPkgId parseGhcPkgIdghcPkgIdParserghcPkgIdString unGhcPkgId$fExceptionGhcPkgIdParseFail$fToJSONGhcPkgId$fFromJSONGhcPkgId$fReadGhcPkgId$fShowGhcPkgId$fNFDataGhcPkgId$fHashableGhcPkgId$fDataGhcPkgId $fEqGhcPkgId$fGenericGhcPkgId $fOrdGhcPkgId$fPersistFieldGhcPkgId$fPersistFieldSqlGhcPkgId$fShowGhcPkgIdParseFail DumpPackage dpGhcPkgIddpPackageIdentdpParentLibIdent dpLicense dpLibDirs dpLibrariesdpHasExposedModulesdpExposedModules dpDependsdpHaddockInterfaces dpHaddockHtml dpIsExposed$fEqDumpPackage$fReadDumpPackage$fShowDumpPackage IsMutableMutable Immutable$fMonoidIsMutable$fSemigroupIsMutable $fEqIsMutable$fShowIsMutableLockFileBehavior LFBReadWrite LFBReadOnly LFBIgnoreLFBErrorOnWritereadLockFileBehavior$fBoundedLockFileBehavior$fEnumLockFileBehavior$fShowLockFileBehaviorNamedComponentCLib CInternalLibCExeCTestCBenchrenderComponentrenderPkgComponentsrenderPkgComponent exeComponentstestComponentsbenchComponentsinternalLibComponentsisCLibisCInternalLibisCExeisCTestisCBench$fEqNamedComponent$fOrdNamedComponent$fShowNamedComponent NixOptsMonoidnixMonoidEnablenixMonoidPureShellnixMonoidPackagesnixMonoidInitFilenixMonoidShellOptions nixMonoidPathnixMonoidAddGCRootsNixOpts nixEnable nixPureShell nixPackages nixInitFilenixShellOptions nixAddGCRootsnixEnableArgNamenixPureShellArgNamenixPackagesArgNamenixInitFileArgNamenixShellOptsArgNamenixPathArgNamenixAddGCRootsArgName$fMonoidNixOptsMonoid$fSemigroupNixOptsMonoid$fEqNixOptsMonoid$fGenericNixOptsMonoid$fShowNixOptsMonoid $fShowNixOptspackageNameArgument HasPlatform platformLplatformVariantLPlatformVariantPlatformVariantNoneplatformVariantSuffixplatformOnlyRelDir$fHasPlatform(,)ProjectprojectUserMsgprojectPackagesprojectDependencies projectFlagsprojectResolverprojectCompilerprojectExtraPackageDBsprojectCuratorprojectDropPackages$fToJSONProject $fShowProject ProjectConfig PCProjectPCGlobalProject PCNoProject PvpBoundspbType pbAsRevision PvpBoundsType PvpBoundsNonePvpBoundsUpperPvpBoundsLower PvpBoundsBoth pvpBoundsTextparsePvpBounds$fFromJSONPvpBounds$fToJSONPvpBounds $fEqPvpBounds$fOrdPvpBounds$fReadPvpBounds$fShowPvpBounds$fBoundedPvpBoundsType$fEnumPvpBoundsType$fEqPvpBoundsType$fOrdPvpBoundsType$fReadPvpBoundsType$fShowPvpBoundsType SnapshotssnapshotsNightly snapshotsLtsAbstractResolverARLatestNightly ARLatestLTSARLatestLTSMajor ARResolverARGlobalreadAbstractResolver!$fExceptionTypesResolverException$fDisplayAbstractResolver$fShowAbstractResolver$fFromJSONSnapshots$fShowSnapshots$fShowTypesResolverExceptionabstractResolverOptsParsercompilerOptsParserreadCompilerVersionSCMGit $fToJSONSCM $fFromJSONSCM $fShowSCM StackYamlLoc SYLDefault SYLOverride SYLNoProjectSYLGlobalProject$fShowStackYamlLoc updateSet updateListhandleMigrationException RepoServiceGitHubGitLab BitbucketRepoTemplatePath rtpServicertpUser rtpTemplate 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 NewerMinorIntersectingVersionRangegetIntersectingVersionRangeversionRangeTextintersectVersionRangestoMajorVersionlatestApplicableVersionnextMajorVersion 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 smTargets smCompiler smProjectsmDepssmGlobal SMTargets smtTargetssmtDeps PackageType PTProject PTDependency TargetAll TargetCompsGlobalPackageVersionSMActual smaCompiler smaProjectsmaDeps smaGlobalSMWanted smwCompiler smwProjectsmwDepssmwSnapshotLocation GlobalPackageReplacedGlobalPackageProjectPackageppCommon ppCabalFP ppResolvedDir DepPackagedpCommon dpLocationdpHiddendpFromSnapshot FromSnapshotNotFromSnapshot CommonPackagecpGPDcpNamecpFlags cpGhcOptionscpCabalConfigOpts cpHaddocksisReplacedGlobalsmRelDirppGPDppRoot ppComponents ppVersion$fEqPackageType$fShowPackageType$fEqGlobalPackage$fShowFromSnapshot GhcPkgExe HasCompilercompilerPathsL CompilerPathscpCompilerVersioncpArchcpBuild cpCompilercpPkg cpInterpreter cpHaddock cpSandboxedcpCabalVersion cpGlobalDB cpGhcInfo cpGlobalDump cabalVersionLcpWhichgetCompilerPath getGhcPkgExe$fHasCompilerCompilerPaths$fShowCompilerPaths$fShowGhcPkgExeVersionedDownloadInfo vdiVersionvdiDownloadInfo$fShowVersionedDownloadInfo SetupInfo siSevenzExe siSevenzDllsiMsys2siGHCssiStack$fMonoidSetupInfo$fSemigroupSetupInfo$fShowSetupInfogetShortPathName osIsWindowssetScriptPermssetFileExecutablestackProgName'haskellFileExtshaskellDefaultPreprocessorExtsstackProgNameUpper stackDotYamlstackWorkEnvVarstackRootEnvVarstackXdgEnvVarstackRootOptionNamestackGlobalConfigOptionNamepantryRootEnvVarinContainerEnvVarinNixShellEnvVarwiredInPackagescabalPackageName"implicitGlobalProjectDirDeprecatedimplicitGlobalProjectDirdefaultUserConfigPathDeprecateddefaultUserConfigPath!defaultGlobalConfigPathDeprecateddefaultGlobalConfigPath buildPlanDirbuildPlanCacheDirplatformVariantEnvVarcompilerOptionsCabalFlagghcColorForceFlagminTerminalWidthmaxTerminalWidthdefaultTerminalWidthrelFileSetupHsrelFileSetupLhsrelFileHpackPackageConfigrelDirGlobalAutogen relDirAutogen relDirLogsrelFileCabalMacrosH relDirBuild relDirBin relDirGhcirelDirGhciScript relDirPantryrelDirProgramsrelDirUpperProgramsrelDirStackProgNamerelDirStackWorkrelFileReadmeTxt relDirScript relDirScriptsrelFileConfigYamlrelDirSnapshotsrelDirGlobalHintsrelFileGlobalHintsYaml relDirInstallrelDirCompilerTools relDirHooglerelFileDatabaseHoo relDirPkgdbrelFileStoragerelDirLoadedSnapshotCache bindirSuffix docDirSuffix relDirHpc relDirLib relDirShare relDirLibexec relDirEtcsetupGhciShimCoderelDirSetupExeCacherelDirSetupExeSrcrelFileConfigure relDirDistrelFileSetupMacrosH relDirSetuprelFileSetupLower relDirMingw relDirMingw32 relDirMingw64 relDirLocal relDirUsr relDirIncluderelFileIndexHtml relDirAllrelFilePackageCacherelFileDockerfilerelFileGhciScriptrelDirCombinedrelFileHpcIndexHtml relDirCustomrelDirPackageConfInplacerelDirExtraTixFilesrelDirInstalledPackagesbackupUrlRelPathrelDirDotLocal relDirDotSshrelDirDotStackProgNamerelDirUnderHome relDirSrcrelFileLibtinfoSo5relFileLibtinfoSo6relFileLibncurseswSo6relFileLibgmpSo10relFileLibgmpSo3relDirNewCabalrelFileSetupExerelFileSetupUpper relFile7zexe relFile7zdll relFileMainHsrelFileStackDotExerelFileStackDotTmpDotExerelFileStackDotTmp relFileStackghcShowOptionsOutputhadrianScriptsWindowshadrianScriptsPosixtestGhcEnvRelFilerelFileBuildLockstackDeveloperModeDefault globalFootergitHubBasicAuthTypegitHubTokenEnvVaraltGitHubTokenEnvVar$fExceptionConstantsException$fShowConstantsExceptionVersionRangeJSONunVersionRangeJSONDockerMonoidRepoOrImageDockerMonoidRepoDockerMonoidImageMountDockerStackExeDockerStackExeDownloadDockerStackExeHostDockerStackExeImageDockerStackExePathDockerOptsMonoiddockerMonoidDefaultEnabledockerMonoidEnabledockerMonoidRepoOrImagedockerMonoidRegistryLogindockerMonoidRegistryUsernamedockerMonoidRegistryPassworddockerMonoidAutoPulldockerMonoidDetachdockerMonoidPersistdockerMonoidContainerNamedockerMonoidNetworkdockerMonoidRunArgsdockerMonoidMountdockerMonoidMountModedockerMonoidEnvdockerMonoidStackExedockerMonoidSetUser dockerMonoidRequireDockerVersion DockerOpts dockerEnable dockerImagedockerRegistryLogindockerRegistryUsernamedockerRegistryPassworddockerAutoPull dockerDetach dockerPersistdockerContainerName dockerNetwork dockerRunArgs dockerMountdockerMountMode dockerEnvdockerStackExe dockerSetUserdockerRequireDockerVersionDockerExceptionDockerMustBeEnabledExceptionOnlyOnHostExceptionInspectFailedExceptionNotPulledExceptionInvalidImagesOutputExceptionInvalidPSOutputExceptionInvalidInspectOutputExceptionPullFailedExceptionDockerTooOldException DockerVersionProhibitedExceptionBadDockerVersionExceptionInvalidVersionOutputExceptionHostStackTooOldExceptionContainerStackTooOldException#CannotDetermineProjectRootExceptionDockerNotInstalledException(UnsupportedStackExeHostPlatformExceptionDockerStackExeParseExceptionparseDockerStackExedockerEnableArgNamedockerRepoArgNamedockerImageArgNamedockerRegistryLoginArgNamedockerRegistryUsernameArgNamedockerRegistryPasswordArgNamedockerAutoPullArgNamedockerDetachArgNamedockerRunArgsArgNamedockerMountArgNamedockerMountModeArgNamedockerEnvArgNamedockerContainerNameArgNamedockerNetworkArgNamedockerPersistArgNamedockerStackExeArgNamedockerStackExeDownloadValdockerStackExeHostValdockerStackExeImageValdockerSetUserArgName!dockerRequireDockerVersionArgNamedockerEntrypointArgName dockerCmdNamedockerHelpOptNamedockerPullCmdName reExecArgNamedockerContainerPlatform$fExceptionDockerException$fFromJSONDockerStackExe$fFromJSONMount $fShowMount $fReadMount$fMonoidDockerOptsMonoid$fSemigroupDockerOptsMonoid$fFromJSONVersionRangeJSON$fShowDockerOptsMonoid$fGenericDockerOptsMonoid$fShowDockerMonoidRepoOrImage$fShowDockerOpts$fShowDockerStackExe$fShowDockerException ConfigMonoidconfigMonoidStackRootconfigMonoidWorkDirconfigMonoidBuildOptsconfigMonoidDockerOptsconfigMonoidNixOptsconfigMonoidConnectionCountconfigMonoidHideTHLoadingconfigMonoidPrefixTimestampsconfigMonoidLatestSnapshotconfigMonoidPackageIndexconfigMonoidPackageIndicesconfigMonoidSystemGHCconfigMonoidInstallGHCconfigMonoidSkipGHCCheckconfigMonoidSkipMsysconfigMonoidCompilerCheckconfigMonoidCompilerRepositoryconfigMonoidRequireStackVersionconfigMonoidArchconfigMonoidGHCVariantconfigMonoidGHCBuildconfigMonoidJobsconfigMonoidExtraIncludeDirsconfigMonoidExtraLibDirs"configMonoidCustomPreprocessorExtsconfigMonoidOverrideGccPathconfigMonoidOverrideHpackconfigMonoidConcurrentTestsconfigMonoidLocalBinPathconfigMonoidTemplateParametersconfigMonoidScmInitconfigMonoidGhcOptionsByNameconfigMonoidGhcOptionsByCatconfigMonoidCabalConfigOptsconfigMonoidExtraPathconfigMonoidSetupInfoLocationsconfigMonoidSetupInfoInlineconfigMonoidLocalProgramsBaseconfigMonoidPvpBoundsconfigMonoidModifyCodePageconfigMonoidRebuildGhcOptionsconfigMonoidApplyGhcOptionsconfigMonoidApplyProgOptionsconfigMonoidAllowNewerconfigMonoidAllowNewerDepsconfigMonoidDefaultTemplateconfigMonoidAllowDifferentUserconfigMonoidDumpLogsconfigMonoidSaveHackageCredsconfigMonoidHackageBaseUrlconfigMonoidColorWhenconfigMonoidStylesconfigMonoidHideSourcePathsconfigMonoidRecommendUpgradeconfigMonoidCasaRepoPrefixconfigMonoidSnapshotLocationconfigMonoidNoRunCompileconfigMonoidStackDeveloperModeparseConfigMonoidparseConfigMonoidObjectconfigMonoidSystemGHCNameconfigMonoidInstallGHCNameconfigMonoidGHCVariantName"configMonoidAllowDifferentUserName$fMonoidConfigMonoid$fSemigroupConfigMonoid$fGenericConfigMonoid$fShowConfigMonoidProjectAndConfigMonoidparseProjectAndConfigMonoidGlobalOptsMonoidglobalMonoidReExecVersionglobalMonoidDockerEntrypointglobalMonoidLogLevelglobalMonoidTimeInLogglobalMonoidRSLInLogglobalMonoidConfigMonoidglobalMonoidResolverglobalMonoidResolverRootglobalMonoidCompilerglobalMonoidTerminalglobalMonoidStylesglobalMonoidTermWidthglobalMonoidStackYamlglobalMonoidLockFileBehavior$fMonoidGlobalOptsMonoid$fSemigroupGlobalOptsMonoid$fGenericGlobalOptsMonoid GlobalOptsglobalReExecVersionglobalDockerEntrypointglobalLogLevelglobalTimeInLogglobalRSLInLogglobalConfigMonoidglobalResolverglobalCompilerglobalTerminalglobalStylesUpdateglobalTermWidthglobalStackYamlglobalLockFileBehaviorglobalOptsBuildOptsMonoidL$fShowGlobalOpts HasRunnerrunnerLRunnerrunnerGlobalOptsrunnerUseColor runnerLogFuncrunnerTermWidthrunnerProcessContext stackYamlLocLlockFileBehaviorL globalOptsL terminalLreExecL rslInLogL$fHasTermRunner$fHasStylesUpdateRunner$fHasProcessContextRunner$fHasLogFuncRunner$fHasRunnerRunner AddCommandcomplicatedOptions addCommandaddSubCommandscomplicatedParserParseAbsolutePathExceptionConfigPrettyExceptionParseConfigFileExceptionStackWorkEnvNotRelativeDirMultiplePackageIndicesDuplicateLocalPackageNamesConfigExceptionParseCustomSnapshotExceptionNoProjectConfigFoundUnexpectedArchiveContentsUnableToExtractArchiveBadStackVersionExceptionNoSuchDirectoryParseGHCVariantException BadStackRoot3Won'tCreateStackRootInDirectoryOwnedByDifferentUserUserDoesn'tOwnDirectory4ManualGHCVariantSettingsAreIncompatibleWithSystemGHCNixRequiresSystemGhcNoResolverWhenUsingNoProjectNoLTSWithMajorVersion NoLTSFoundpackageIndicesWarning$fExceptionConfigException $fExceptionConfigPrettyException$fPrettyConfigPrettyException%$fExceptionParseAbsolutePathException $fShowParseAbsolutePathException$fShowConfigPrettyException$fShowConfigException HasConfigconfigLConfig configWorkDirconfigUserConfigPath configBuild configDocker configNixconfigProcessContextSettingsconfigLocalProgramsBaseconfigLocalProgramsconfigHideTHLoadingconfigPrefixTimestampsconfigPlatformconfigPlatformVariantconfigGHCVariantconfigGHCBuildconfigLatestSnapshotconfigSystemGHCconfigInstallGHCconfigSkipGHCCheckconfigSkipMsysconfigCompilerCheckconfigCompilerRepositoryconfigLocalBinconfigRequireStackVersion configJobsconfigOverrideGccPathconfigExtraIncludeDirsconfigExtraLibDirsconfigCustomPreprocessorExtsconfigConcurrentTestsconfigTemplateParams configScmInitconfigGhcOptionsByNameconfigGhcOptionsByCatconfigCabalConfigOptsconfigSetupInfoLocationsconfigSetupInfoInlineconfigPvpBoundsconfigModifyCodePageconfigRebuildGhcOptionsconfigApplyGhcOptionsconfigApplyProgOptionsconfigAllowNewerconfigAllowNewerDepsconfigDefaultTemplateconfigAllowDifferentUserconfigDumpLogs configProjectconfigAllowLocalsconfigSaveHackageCredsconfigHackageBaseUrl configRunnerconfigPantryConfigconfigStackRootconfigResolverconfigUserStorageconfigHideSourcePathsconfigRecommendUpgradeconfigNoRunCompileconfigStackDeveloperModeconfigProjectRootaskLatestSnapshotUrlghcInstallHook stackRootLstackGlobalConfigL buildOptsLenvOverrideSettingsLworkDirLprettyStackDevL$fHasTermConfig$fHasStylesUpdateConfig$fHasLogFuncConfig$fHasRunnerConfig$fHasPantryConfigConfig$fHasProcessContextConfig$fHasGHCVariantConfig$fHasPlatformConfig$fHasConfigConfigHasBuildConfig buildConfigL BuildConfigbcConfig bcSMWantedbcExtraPackageDBs bcStackYamlbcProjectStorage bcCurator stackYamlL projectRootLgetProjectWorkDirwantedCompilerVersionL$fHasTermBuildConfig$fHasStylesUpdateBuildConfig$fHasLogFuncBuildConfig$fHasRunnerBuildConfig$fHasConfigBuildConfig$fHasPantryConfigBuildConfig$fHasProcessContextBuildConfig$fHasGHCVariantBuildConfig$fHasPlatformBuildConfig$fHasBuildConfigBuildConfig HasSourceMap sourceMapL HasEnvConfig envConfigL EnvConfigenvConfigBuildConfigenvConfigBuildOptsCLIenvConfigSourceMapenvConfigSourceMapHashenvConfigCompilerPathsshouldForceGhcColorFlagappropriateGhcColorFlag snapshotsDirinstallationRootDepsinstallationRootLocalhoogleDatabasePathplatformSnapAndCompilerRelplatformGhcRelDirbindirCompilerTools hoogleRootcompilerVersionDirpackageDatabaseDepspackageDatabaseLocalpackageDatabaseExtra hpcReportDir extraBinDirsactualCompilerVersionLplatformGhcVerOnlyRelDiruseShaPathOnWindowsshaPathForBytes$fHasTermEnvConfig$fHasStylesUpdateEnvConfig$fHasLogFuncEnvConfig$fHasRunnerEnvConfig$fHasCompilerEnvConfig$fHasPantryConfigEnvConfig$fHasProcessContextEnvConfig$fHasGHCVariantEnvConfig$fHasPlatformEnvConfig$fHasConfigEnvConfig$fHasSourceMapEnvConfig$fHasEnvConfigEnvConfig$fHasBuildConfigEnvConfig$fIsPathRelFile$fIsPathAbsFile$fIsPathRelDir$fIsPathAbsDir InstalledLibrary Executable InstalledMap FileCacheInfofciHashInstalledPackageLocation InstalledTo ExtraGlobalInstallLocationSnapLocal MemoizedWithunMemoizedWith LocalPackage lpPackage lpComponents lpUnbuildablelpWanted lpTestBench lpCabalFilelpBuildHaddocks lpForceDirty lpDirtyFileslpNewBuildCacheslpComponentFiles PackageSource PSFilePathPSRemote PackageConfigpackageConfigEnableTestspackageConfigEnableBenchmarkspackageConfigFlagspackageConfigGhcOptionspackageConfigCabalConfigOptspackageConfigCompilerVersionpackageConfigPlatform BuildInfoOptsbioOptsbioOneWordOptsbioPackageFlagsbioCabalMacrosGetPackageOptsgetPackageOpts InstallMapPackage packageNamepackageVersionpackageLicense packageFiles packageDepspackageUnknownToolspackageAllDepspackageSubLibDepspackageGhcOptionspackageCabalConfigOpts packageFlagspackageDefaultFlagspackageLibrariespackageInternalLibraries packageTestspackageBenchmarks packageExes packageOptspackageHasExposedModulespackageBuildTypepackageSetupDepspackageCabalSpecExeName unExeNamePackageLibraries NoLibraries HasLibrariesPackageExceptionPackageInvalidCabalFileMismatchedCabalIdentifierCabalFileNameParseFailCabalFileNameInvalidPackageNameComponentNotParsedBug packageIdentpackageIdentifierpackageDefinedFlags psVersionmemoizeRefWithrunMemoizedWithlpFileslpFilesForComponentsdotCabalModule dotCabalMaindotCabalModulePathdotCabalMainPathdotCabalCFilePathdotCabalGetPathinstalledPackageIdentifierinstalledVersion$fExceptionPackageException$fShowMemoizedWith$fMonoidInstallLocation$fSemigroupInstallLocation$fFromJSONFileCacheInfo$fToJSONFileCacheInfo$fNFDataFileCacheInfo$fShowGetPackageOpts $fEqPackage $fOrdPackage$fShowPackageSource$fShowLocalPackage $fShowPackage $fEqInstalled$fShowInstalled$fEqFileCacheInfo$fGenericFileCacheInfo$fShowFileCacheInfo$fEqInstalledPackageLocation$fShowInstalledPackageLocation$fEqInstallLocation$fShowInstallLocation$fApplicativeMemoizedWith$fFunctorMemoizedWith$fMonadMemoizedWith$fShowPackageConfig$fShowBuildInfoOpts $fDataExeName $fEqExeName$fGenericExeName$fHashableExeName$fIsStringExeName$fNFDataExeName $fOrdExeName $fShowExeName$fShowPackageLibraries$fShowPackageExceptionwarnInstallSearchPathIssuesConfigDockerExceptionResolverNotSupportedException addDefaultTagdockerOptsFromMonoid $fExceptionConfigDockerException$fShowConfigDockerException ConfigureOptscoDirscoNoDirsBaseConfigOpts bcoSnapDB bcoLocalDBbcoSnapInstallRootbcoLocalInstallRoot bcoBuildOptsbcoBuildOptsCLI bcoExtraDBs configureOptsconfigureOptsDirsconfigureOptsNoDir$fNFDataConfigureOpts$fDataConfigureOpts$fEqConfigureOpts$fGenericConfigureOpts$fShowConfigureOpts$fShowBaseConfigOptsPrecompiledCache pcLibrary pcSubLibspcExesPlan planTasks planFinalsplanUnregisterLocalplanInstallExesTaskTypeTTLocalMutableTTRemotePackageTaskConfigOpts tcoMissingtcoOptsTask taskProvidestaskTypetaskConfigOptstaskBuildHaddock taskPresent taskAllInOnetaskCachePkgSrctaskAnyMissingtaskBuildTypeConfig CachePkgSrcCacheSrcUpstream CacheSrcLocal ConfigCacheconfigCacheOptsconfigCacheDepsconfigCacheComponentsconfigCacheHaddockconfigCachePkgSrcconfigCachePathEnvVar BuildCachebuildCacheTimes toCachePkgSrc taskIsTarget taskLocationtaskTargetIsMutableinstallLocationIsMutable$fNFDataBuildCache$fPersistFieldSqlCachePkgSrc$fPersistFieldCachePkgSrc$fNFDataCachePkgSrc$fNFDataConfigCache$fShowTaskConfigOpts$fNFDataPrecompiledCache$fNFDataPrecompiledCache0$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"PrecompiledCacheParentText7$fSymbolToField"platformGhcDir"PrecompiledCacheParent[],$fSymbolToField"id"PrecompiledCacheParentKey+$fAtLeastOneUniqueKeyPrecompiledCacheParent($fOnlyOneUniqueKeyPrecompiledCacheParent.$fToBackendKeySqlBackendPrecompiledCacheParent'$fPersistFieldSqlPrecompiledCacheParent$$fPersistFieldPrecompiledCacheParent%$fPersistEntityPrecompiledCacheParent$$fSafeToInsertPrecompiledCacheSubLib.$fSymbolToField"value"PrecompiledCacheSubLib[]0$fSymbolToField"parent"PrecompiledCacheSubLibKey,$fSymbolToField"id"PrecompiledCacheSubLibKey+$fAtLeastOneUniqueKeyPrecompiledCacheSubLib($fOnlyOneUniqueKeyPrecompiledCacheSubLib.$fToBackendKeySqlBackendPrecompiledCacheSubLib'$fPersistFieldSqlPrecompiledCacheSubLib$$fPersistFieldPrecompiledCacheSubLib%$fPersistEntityPrecompiledCacheSubLib!$fSafeToInsertPrecompiledCacheExe+$fSymbolToField"value"PrecompiledCacheExe[]-$fSymbolToField"parent"PrecompiledCacheExeKey)$fSymbolToField"id"PrecompiledCacheExeKey($fAtLeastOneUniqueKeyPrecompiledCacheExe%$fOnlyOneUniqueKeyPrecompiledCacheExe+$fToBackendKeySqlBackendPrecompiledCacheExe$$fPersistFieldSqlPrecompiledCacheExe!$fPersistFieldPrecompiledCacheExe"$fPersistEntityPrecompiledCacheExe!$fSafeToInsertDockerImageExeCache2$fSymbolToField"compatible"DockerImageExeCacheBool7$fSymbolToField"exeTimestamp"DockerImageExeCacheUTCTime-$fSymbolToField"exePath"DockerImageExeCache[]1$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"CompilerCache[].$fSymbolToField"cabalVersion"CompilerCacheText+$fSymbolToField"haddockPath"CompilerCache[]*$fSymbolToField"runghcPath"CompilerCache[]*$fSymbolToField"ghcPkgPath"CompilerCache[].$fSymbolToField"ghcModified"CompilerCacheInt64*$fSymbolToField"ghcSize"CompilerCacheInt64'$fSymbolToField"ghcPath"CompilerCache[]&$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"ConfigCacheParent[]'$fSymbolToField"id"ConfigCacheParentKey&$fAtLeastOneUniqueKeyConfigCacheParent#$fOnlyOneUniqueKeyConfigCacheParent)$fToBackendKeySqlBackendConfigCacheParent"$fPersistFieldSqlConfigCacheParent$fPersistFieldConfigCacheParent $fPersistEntityConfigCacheParent"$fSafeToInsertConfigCacheDirOption,$fSymbolToField"value"ConfigCacheDirOption[]-$fSymbolToField"index"ConfigCacheDirOptionInt.$fSymbolToField"parent"ConfigCacheDirOptionKey*$fSymbolToField"id"ConfigCacheDirOptionKey)$fAtLeastOneUniqueKeyConfigCacheDirOption&$fOnlyOneUniqueKeyConfigCacheDirOption,$fToBackendKeySqlBackendConfigCacheDirOption%$fPersistFieldSqlConfigCacheDirOption"$fPersistFieldConfigCacheDirOption#$fPersistEntityConfigCacheDirOption$$fSafeToInsertConfigCacheNoDirOption.$fSymbolToField"value"ConfigCacheNoDirOption[]/$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 HasNoLibraryBDDependencyCycleDetectedLatestApplicableVersionConstructPlanExceptionDependencyCycleDetectedDependencyPlanFailuresUnknownPackageBuildPrettyExceptionConstructPlanFailedExecutionFailureCabalExitedUnsuccessfullySetupHsBuildFailureTargetParseExceptionSomeTargetsNotBuildableInvalidFlagSpecificationGHCProfOptionInvalidBuildExceptionCouldn'tFindPkgIdCompilerVersionMismatchCouldn'tParseTargetsUnknownTargetsTestSuiteFailureTestSuiteTypeUnsupportedLocalPackageDoesn'tMatchTargetNoSetupHsFoundInvalidGhcOptionsSpecificationTestSuiteExeMissingCabalCopyFailedLocalPackagesPresentCouldNotLockDistDir TaskCycleBugPackageIdMissingBugAllInOneBuildBugMultipleResultsBugTemplateHaskellNotFoundBugHaddockIndexNotFoundShowBuildErrorBugpprintTargetParseErrors$fExceptionBuildException$fExceptionBuildPrettyException$fPrettyBuildPrettyException $fEqDepsPath $fOrdDepsPath$fShowDepsPath$fShowBuildPrettyException$fEqConstructPlanException$fShowConstructPlanException$fEqBadDependency$fOrdBadDependency$fShowBadDependency$fShowBuildExceptionTool ToolGhcGit toolStringtoolNameString parseToolText markInstalledunmarkInstalled listInstalled filterToolsgetCompilerVersion extraDirs installDirtempInstallDir $fOrdTool$fEqTool getGlobalDBcreateDatabaseghcPkgPathEnvVarfindGhcPkgFieldunregisterGhcPkgIdsmkGhcPackagePathLine ghcPkgDumpghcPkgDescribe pruneDeps sinkMatchingconduitDumpPackage eachSectioneachPair$fExceptionPackageDumpException$fShowPackageDumpExceptionSnapshotCandidateDumpedGlobalPackagemkProjectPackageadditionalDepPackagesnapToDepPackage loadVersion getPLIVersionglobalsFromDumpglobalsFromHints actualFromGhcactualFromHintsglobalCondCheckcheckFlagsUsedThrowing pruneGlobalsgetCompilerInfoimmutableLocShaloadProjectSnapshotCandidateLockedlckSnapshotLocationslckPkgImmutableLocationsLockedLocation llOriginal llCompletedlockCachedWanted$fToJSONLockedLocation$fToJSONLocked$fExceptionLockPrettyException$fPrettyLockPrettyException$fShowLockPrettyException $fEqLocked $fShowLocked$fEqLockedLocation$fShowLockedLocation RawTargetRTPackageComponent RTComponent RTPackageRTPackageIdentifierUnresolvedComponentResolvedComponent NeedTargetsAllowNoTargetsparseRawTarget parseTargets $fEqRawTarget$fShowRawTarget$fEqUnresolvedComponent$fOrdUnresolvedComponent$fShowUnresolvedComponentobjectInterfaceDirLghciDirLbuildCachesDirtestSuccessFile testBuiltFileconfigCabalModconfigSetupConfigModconfigPackageProjectRoot hpcDirFromDirhpcRelativeDirsetupConfigFromDirdistDirFromDirrootDistDirFromDirworkDirFromDir templatesDirprojectDockerSandboxDirimageStagingDirnixOptsFromMonoid nixCompilernixCompilerVersion$fExceptionConfigNixException$fShowConfigNixExceptionPackageDescriptionPairpdpOrigBuildablepdpModifiedBuildablereadDotBuildinforesolvePackagepackageFromPackageDescriptionpackageDependenciesresolvePackageDescription buildLogPathapplyForceCustomBuildBuildPlanCheckBuildPlanCheckOkBuildPlanCheckPartialBuildPlanCheckFailDepError deVersion deNeededBy DepErrorsBuildPlanExceptionUnknownPackagesSnapshotNotFound"NeitherCompilerOrResolverSpecifiedDuplicatePackagesBugremoveSrcPkgDefaultFlagscheckSnapBuildPlanselectBestSnapshot showItems$fExceptionBuildPlanException$fShowBuildPlanCheck$fShowDepError$fShowBuildPlanExceptionopenHaddocksInBrowsershouldHaddockPackageshouldHaddockDepsgenerateLocalHaddockIndexgenerateDepsHaddockIndexgenerateSnapHaddockIndexgetImplicitGlobalProjectDir getSnapshotsmakeConcreteResolverwithNewLogFunc loadConfigwithBuildConfigcheckOwnershipgetInContainer getInNixShellloadConfigYamlgetProjectConfigpackagesParserdefaultConfigYamlrunShellAndExit nixCmdNamenixHelpOptName$fExceptionNixException$fShowNixException nixOptsParser ConfigCmdSetConfigCmdSetResolverConfigCmdSetSystemGhcConfigCmdSetInstallGhcConfigCmdSetDownloadPrefix cfgCmdSet cfgCmdName cfgCmdSetName cfgCmdEnvNameconfigCmdSetParserconfigCmdEnvParser cfgCmdEnv$fExceptionConfigCmdException$fShowEnvVarAction $fEqKeyType $fShowKeyType$fShowConfigCmdException TestStatus TSSuccess TSFailure TSUnknowngetInstalledExesmarkExeInstalledmarkExeNotInstalledtryGetBuildCachetryGetConfigCachetryGetCabalModtryGetSetupConfigModtryGetPackageProjectRootwriteBuildCachewriteConfigCache writeCabalModwriteSetupConfigModwritePackageProjectRoot deleteCachestryGetFlagCachewriteFlagCache setTestStatus getTestStatuswritePrecompiledCachereadPrecompiledCacheprojectLocalPackageslocalDependencieshashSourceMapData getLocalFlagsloadCommonPackageloadLocalPackageaddUnlistedToBuildCache toInstallMap getInstalled$fShowLoadHelper $fEqAllowed $fShowAllowed constructPlan $fMonoidW $fSemigroupW$fHasEnvConfigCtx$fHasCompilerCtx$fHasSourceMapCtx$fHasBuildConfigCtx$fHasProcessContextCtx$fHasPantryConfigCtx$fHasConfigCtx $fHasTermCtx$fHasStylesUpdateCtx$fHasRunnerCtx$fHasLogFuncCtx$fHasGHCVariantCtx$fHasPlatformCtx$fExceptionNotOnlyLocal$fShowToolWarning$fShowNotOnlyLocal $fGenericW$fShowAddDepRes$fShowPackageInfointerpreterArgsParsergetInterpreterArgsPagerExceptionPagerExitFailure pageWriterpageText$fExceptionPagerException$fShowPagerExceptiongetTerminalWidth fixCodePagehIsTerminalDeviceOrMinTTY$fStorableWindowWidth$fEqWindowWidth$fOrdWindowWidth$fShowWindowWidthStackReleaseInfo SetupOptssoptsInstallIfMissingsoptsUseSystemsoptsWantedCompilersoptsCompilerChecksoptsStackYamlsoptsForceReinstallsoptsSanityChecksoptsSkipGhcCheck soptsSkipMsyssoptsResolveMissingGHCsoptsGHCBindistURLdefaultSetupInfoYamlsetupEnvwithNewLocalBuildTargetsensureCompilerAndMsysensureDockerStackExedownloadStackReleaseInfopreferredPlatformsdownloadStackExegetDownloadVersion$fExceptionSetupException$fExceptionSetupPrettyException$fPrettySetupPrettyException'$fExceptionPerformPathCheckingException$fHasCompilerWithGHC$fHasBuildConfigWithGHC$fHasConfigWithGHC$fHasGHCVariantWithGHC$fHasPlatformWithGHC$fHasPantryConfigWithGHC$fHasTermWithGHC$fHasStylesUpdateWithGHC$fHasProcessContextWithGHC$fHasRunnerWithGHC$fHasLogFuncWithGHC$fAlternativeCheckDependency$fApplicativeCheckDependency$fShowHaskellStackOrg$fFunctorCheckDependency$fShowSetupOpts"$fShowPerformPathCheckingException$fShowSetupPrettyException$fShowSetupExceptionpreventInContainerrunContainerAndExitpullreset entrypointgetProjectRoot$fFromJSONImageConfig$fFromJSONInspect $fShowInspect$fShowImageConfig ShouldReexec YesReexecNoReexecwithGlobalProjectwithDefaultEnvConfig withEnvConfig withConfigwithRunnerGlobal$fExceptionRunnersException$fShowRunnersException updateCmd unpackCmdunpackPackages $fExceptionUnpackPrettyException$fPrettyUnpackPrettyException$fShowUnpackPrettyException uninstallCmd templatesCmd templatesHelp#$fExceptionTemplatesPrettyException $fPrettyTemplatesPrettyException$fShowTemplatesPrettyException SetupCmdOptsscoCompilerVersionscoForceReinstallscoGHCBindistURLscoGHCJSBootOptsscoGHCJSBootCleansetupCmdsetupsetupOptsParserqueryCmdqueryBuildInfo$fExceptionQueryException$fShowQueryExceptionPathInfopaths$fHasBuildConfigPathInfo$fHasProcessContextPathInfo$fHasPantryConfigPathInfo$fHasConfigPathInfo$fHasGHCVariantPathInfo$fHasTermPathInfo$fHasStylesUpdatePathInfo$fHasRunnerPathInfo$fHasLogFuncPathInfo$fHasPlatformPathInfo pathParserlistCmd listPackages$fExceptionListException$fShowListExceptionInitOpts searchDirs omitPackagesforceOverwriteincludeSubDirsinitCmd initProject$fExceptionInitException$fExceptionInitPrettyException$fPrettyInitPrettyException$fShowInitPrettyException$fShowInitExceptioninitOptsParserNewOptsnewOptsProjectNamenewOptsCreateBarenewOptsTemplatenewOptsNonceParamsnewCmdnew$fExceptionNewPrettyException$fPrettyNewPrettyException$fShowNewPrettyException newOptsParserListPackagesCmdListPackageNamesListPackageCabalFiles OutputStream OutputLogInfo OutputStdoutidePackagesCmd ideTargetsCmd listTargets HpcReportOpts hroptsInputs hroptsAll hroptsDestDirhroptsOpenBrowser hpcReportCmddeleteHpcReports updateTixFilegenerateHpcReportgenerateHpcReportForTargetsgenerateHpcUnifiedReportgenerateHpcMarkupIndex"$fExceptionCoveragePrettyException$fPrettyCoveragePrettyException$fShowHpcReportOpts$fShowCoveragePrettyExceptionKeepOutputOpenKeepOpenCloseOnExceptionExcludeTHLoading KeepTHLoading ExecuteEnvpreFetch printPlanwithExecuteEnv executePlanwithSingleContext$fEqKeepOutputOpen$fEqExecutableBuildStatus$fOrdExecutableBuildStatus$fShowExecutableBuildStatus CleanCommandCleanPurge CleanOpts CleanShallow CleanFullcleanCmdclean$fExceptionCleanException$fShowCleanExceptioncleanOptsParserdockerOptsParser dockerPullCmddockerResetCmdbuildCmdbuildbuildLocalTargetssplitObjsWarningmkBaseConfigOpts&$fExceptionCabalVersionPrettyException#$fPrettyCabalVersionPrettyException!$fShowCabalVersionPrettyException UpgradeOpts _uoBinary _uoSource SourceOpts BinaryOpts _boPlatform_boForce_boOnlyLocalBin _boVersion _boGitHubOrg _boGitHubRepo upgradeCmdupgrade!$fExceptionUpgradePrettyException$fPrettyUpgradePrettyException$fShowUpgradeOpts$fShowSourceOpts$fShowBinaryOpts$fShowUpgradePrettyExceptionupgradeOptsParser ScriptOpts soPackagessoFilesoArgs soCompile soUseRoot soGhcOptionssoScriptExtraDeps soShouldRun ShouldRunYesRunNoRun ScriptExecute SEInterpret SECompile SEOptimize scriptCmd$fExceptionScriptException$fShowScriptOpts$fShowShouldRun$fShowScriptExecute$fShowScriptException SDistOptssdoptsDirsToWorkWithsdoptsPvpBoundssdoptsIgnoreChecksdoptsBuildTarball sdoptsTarPathsdistCmdgetSDistTarballcheckSDistTarballcheckSDistTarball'$fExceptionSDistException$fShowSDistException HackageAuthHAKeyHACreds HackageCreds HackageKey UploadOptsuoptsSDistOptsuoptsUploadVariant UploadVariant Publishing Candidate uploadCmdmaybeGetHackageKeyloadAuthwriteFilePrivate uploadBytesuploaduploadRevision $fExceptionUploadPrettyException$fPrettyUploadPrettyException $fFromJSONFUN$fToJSONHackageCreds$fEqHackageAuth$fShowHackageAuth$fEqHackageCreds$fShowHackageCreds$fEqHackageKey$fShowHackageKey$fShowUploadPrettyExceptionbuildOptsMonoidParsercabalVerbosityOptsParsercabalVerbosityParsercabalVerboseParserconfigOptsParserglobalOptsParserglobalOptsFromMonoidghcOptsCompletertargetCompleter flagCompleterprojectExeCompleterscriptOptsParserhpcReportOptsParserpvpBoundsOptionsdistOptsParseruploadOptsParserbuildOptsParser targetsParser flagsParser hoogleCmd$fExceptionHoogleException $fExceptionHooglePrettyException$fPrettyHooglePrettyException$fShowHooglePrettyException$fShowHoogleException GhciPkgInfo ghciPkgName ghciPkgOpts ghciPkgDirghciPkgModules ghciPkgCFiles ghciPkgMainIsghciPkgTargetFilesghciPkgPackageGhciOpts ghciTargetsghciArgsghciGhcOptions ghciFlagsghciGhcCommandghciNoLoadModulesghciAdditionalPackages ghciMainIsghciLoadLocalDepsghciSkipIntermediateghciHidePackages ghciNoBuild ghciOnlyMainGhciPrettyExceptionGhciTargetParseException GhciExceptionInvalidPackageOptionLoadingDuplicateModulesMissingFileTargetCan'tSpecifyFilesAndTargetsCan'tSpecifyFilesAndMainIsghciCmdghci$fExceptionGhciException$fExceptionGhciPrettyException$fPrettyGhciPrettyException$fShowGhciPkgInfo$fShowGhciOpts$fShowGhciPrettyException$fShowGhciExceptionghciOptsParserExecOptseoCmdeoArgseoExtra ExecOptsExtra eoEnvSettings eoPackages eoRtsOptionseoCwdSpecialExecCmdExecCmdExecRunExecGhc ExecRunGhcexecCmd$fExceptionExecException$fExceptionExecPrettyException$fPrettyExecPrettyException$fShowExecOpts$fShowExecOptsExtra$fEqSpecialExecCmd$fShowSpecialExecCmd$fShowExecPrettyException$fShowExecExceptionexecOptsParserexecOptsExtraParserEvalOptsevalArg evalExtraevalCmd$fShowEvalOptsevalOptsParser DotPayloadpayloadVersionpayloadLicensepayloadLocation ListDepsOptslistDepsFormatlistDepsDotOptsListDepsFormat ListDepsText ListDepsTree ListDepsJSONListDepsConstraintsListDepsFormatOpts listDepsSeplistDepsLicenseDotOptsdotIncludeExternaldotIncludeBasedotDependencyDepthdotPrune dotTargetsdotFlagsdotTestTargetsdotBenchTargetsdotGlobalHintsdotlistDependencies pruneGraphresolveDependencies printGraph$fExceptionDotException$fToJSONDependencyTree$fHasSourceMapDotConfig$fHasBuildConfigDotConfig$fHasConfigDotConfig$fHasProcessContextDotConfig$fHasRunnerDotConfig$fHasPlatformDotConfig$fHasGHCVariantDotConfig$fHasStylesUpdateDotConfig$fHasTermDotConfig$fHasPantryConfigDotConfig$fHasLogFuncDotConfig$fEqDotPayload$fShowDotPayload$fShowDotException dotOptsParserseparatorParser licenseParserlistDepsFormatOptsParserlistDepsTreeParserlistDepsTextParserlistDepsJsonParserlistDepsConstraintsParsertoListDepsOptsParserformatSubCommandlistDepsOptsParser LsCmdOptslsViewLsCmds LsSnapshotLsDependenciesLsStylesLsTools ListToolsOpts toptFilterListStylesOpts coptBasiccoptSGR coptExample SnapshotOpts soptViewTypesoptLtsSnapViewsoptNightlySnapViewLsViewRemotelsCmd$fExceptionLsException$fFromJSONSnapshot$fFromJSONSnapshotData$fEqSnapshotData$fOrdSnapshotData$fShowSnapshotData $fEqSnapshot $fOrdSnapshot$fShowSnapshot$fEqListStylesOpts$fOrdListStylesOpts$fShowListStylesOpts$fEqSnapshotOpts$fOrdSnapshotOpts$fShowSnapshotOpts$fEqSnapshotType$fOrdSnapshotType$fShowSnapshotType $fEqLsView $fOrdLsView $fShowLsView$fShowLsException lsOptsParserbytesfmt fileExtension addExtensionreplaceExtension parseAbsDir parseAbsFilecollapseFilePathSystem.IO.ErrorisDoesNotExistError InvalidAbsDirInvalidAbsFile findPathUpparent RIO.ProcessProcessContextbugDeclaration bugRequest maybeGitHash quoteFileName fileWatchConf OptionsApplicativeExtraException4optparse-applicative-0.17.0.0-6JUNcVh0BAEKpT90L8ECrcOptions.Applicative.Builder abortOptionoptionargument eitherReaderExecuteException sortActionsGhcPkgIdParseFailConfigCacheType UpgradeCheckConfigCacheTypeConfigConfigCacheTypeFlagLibraryConfigCacheTypeFlagExecutableTypesResolverExceptionProjectStorage UserStorageStoragePrettyExceptionunProjectStorage unUserStorageStorageMigrationFailureTypeTemplateNameException parseRepoPath Data.Version showVersionDepTypeDepValue AsLibrary AsBuildTooldvVersionRangedvTypeConstantsExceptionDual addCommand' hsubparser' helpOptionOptions.Applicative.ExtrahandleParseResulthooksDirplatformGhcVerOnlyRelDirStrPackageWarningUnlistedModulesWarningGetPackageFilesDotCabalDescriptor DotCabalPathgetPackageFilesDotCabalModule DotCabalMain DotCabalFile DotCabalCFileDotCabalModulePathDotCabalMainPathDotCabalFilePathDotCabalCFilePathGetPackageFileContextctxFile ctxDistDirctxBuildConfig ctxCabalVerhandleSetGroups handleSignals PkgDepsOracleStorageUserExceptionwithUserStorage sizeToInt64 timeToInt64withProjectStoragereadConfigCachedpLength dpNameLengthdpPathgetShortestDepsPathghcPkgpackageDbFlagsPackageDumpException ghcPkgCmdArgs takeWhileCLockPrettyException rrComponent rrAddedDep ComponentNameRawInputparseRawTargetDirsresolveRawTarget ResolveResultrootDistRelativeDirConfigNixException)NixCannotUseShellFileAndPackagesExceptionbenchmarkFiles testFilesexecutableFiles libraryFilesresolveComponentFilesresolveFilesAndDepsgetDependenciesparseHIcomponentOutputDir resolveFiles findCandidatelogPossibilitiesbuildOtherSourcestargetJsSourcesresolveDirFile warnMultipleparsePackageNameFromFilePathresolveDirOrWarnpackageAutogenDircomponentAutogenDirbuildDir resolveOrWarnresolveFileOrWarnpackageDescModulesAndFilesresolveGlobFilesgetPackageFileBioInputgenerateBuildInfoOptsgeneratePkgDescOptsmakeObjectFilePathFromCpackageDescToolsDistribution.Types.BuildInfobuildToolDepends buildTools hardCodedMappreInstalledPackages allBuildInfo',Distribution.Types.GenericPackageDescriptionGenericPackageDescription%Distribution.Types.PackageDescriptionPackageDescriptionflagMapmkResolveConditionsresolveConditionsselectPackageBuildPlancheckPackageBuildPlancheckPackageDepscombineDepErrorcheckBundleBuildPlancompareBuildPlanCheckgenerateHaddockIndexlookupDumpPackagehaddockIndexFile localDocDirlocalDepsDocDir snapDocDirtryDeprecatedPathgetLatestResolverwithLocalLogFuncgetDefaultLocalProgramsBasecheckDuplicateNamesdetermineStackRootAndOwnershipgetDirAndOwnership isOwnedByUsergetExtraConfigsloadYamlloadProjectConfiggetDefaultGlobalConfigPathgetDefaultUserConfigPathconfigFromConfigMonoid NixExceptionCannotDetermineProjectRootescapeKeyTypePlainKeySingleQuotedKeyDoubleQuotedKeyCommandScopeGlobalCommandScopeProjectConfigCmdExceptioncfgCmdSetValueexeInstalledDirgetPrecompiledCacheKeygeneralCabalConfigOptsgeneralGhcOptionscheckBuildCachegetPackageFilesForTargetsgetFileDigestMaybegetPackageConfig loadDatabase isAllowed ToolWarningUnregisterStatewInstallwDirty wWarningswParentsPIOnlyInstalled PIOnlySourcePIBotherrorOnSnapshotmkUnregisterLocaladdFinaladdDepaddPackageDepsaddDep'addDep'' PackageInfoinstallPackageinstallPackageGivenDepspackageBuildTypeConfigcheckAndWarnForUnknownTools stripLocals inSnapshotuname getRelease SRIGitHubSRIHaskellStackOrgWithGHCPerformPathCheckingExceptionperformPathCheckingSetupPrettyExceptionSetupException runWithGHC rebuildEnv addIncludeLibwarnUnsupportedCompilerwarnUnsupportedCompilerCabal ensureMsysensureCompilerrunGHCInstallHook getGhcBuilds mungeReleasesourceSystemCompilers getSetupInfo#downloadAndInstallPossibleCompilerscheckDependencieswithUnpackedTarball7zsetup7z sanityCheckgetUtf8EnvVarsdownloadStackReleaseInfoGitHubpathsFromCompilergetInstalledToolchattyDownloadrelocateStackExeFile ImageConfigInspect getCmdArgsinspectinspects pullImagecheckDockerVersionentrypointMVarremoveDirectoryContentsreadDockerProcess-typed-process-0.2.11.0-FazLEOOC6jT23wuyuFCE1ISystem.Process.Typed readProcess_ homeDirName hostBinDir decodeUtf8oldSandboxIdEnvVarRunnersExceptionreexecshouldUpgradeCheckUnpackPrettyExceptionTemplatesPrettyExceptiondefaultTemplatesHelpUrlQueryExceptionerr rawBuildInfo ListExceptionInitPrettyException InitExceptionrenderStackYamlgetDefaultResolverminSupportedLts ignoredDirsgetWorkingResolverPlancheckBundleResolverTemplateDownloadSettings tplBasicAuthNewPrettyException loadTemplatesettingsFromRepoTemplatePath applyTemplatecheckForOverwritewriteTemplateFilesrunTemplateInitsdefaultRepoServiceCoveragePrettyException hpcPkgPath tixFilePathremoveExeModules htmlEscapegenerateHpcReportInternalgenerateUnionReportPrefixWithTimestamps OutputType eeSetupHs eeSetupShimHs eeSetupExe eeCustomBuilteeLargestPackageName eePathEnvVarExecutableBuildStatus displayTask getSetupExewindowsRenameCopy executePlan'getConfigCache ensureConfigpackageNamePrefixwithLockedDistDirgetExecutableBuildStatusescheckExeStatuscheckForUnlistedFiles singleTest singleBenchmungeBuildOutputsinkWithTimestampsformatZonedTimeForLog getSetupHs exesToBuildcabalIsSatisfied singleBuildCleanException/warnIfExecutablesWithSameNameCouldBeOverwrittencheckSubLibraryDependenciesUpgradePrettyExceptionScriptException blacklistgetPackagesFromImportsSDistException getCabalLbs gtraverseTreadLocalPackagegetSDistFileListcheckPackageInExtractedTarballwithTempTarGzContents packFileEntryUploadPrettyExceptionloadUserAndPassworddefaultLogLevelMutedHooglePrettyExceptionHoogleException GhciPkgDescdisplayPkgComponentfigureOutMainFileloadGhciPkgDescmakeGhciPkgInforunGrabFirstLineExecPrettyException ExecException DotExceptioncreatePrunedDependencyGraphcreateDependencyGraphpruneUnreachablecreateDepLoaderprojectPackageDependenciesprintLocalNodes printLeaves printEdges printEdgenodeName printLeaf isWiredIn SnapshotTypeLts LsException listStylesCmd listToolsCmd