h-       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                   !!!!!""""""##############################################################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&''''''''''((((((((((((()))))))))))))****************++++++++++++,,,,,,,,,,,,-------------------------------------------------........................//////////////////////////////////////0000000000000000000001111111111111111222222222333333333333344444444444555555555555555555555555555555555555555555555555555555555555555566666666666666666666666666666666666666667                                                 8888889999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999::                     ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = > > > > ? ? ? ? ? ? ? ? ? ? ? ? @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A B B B B B C C C C C C C C C C C D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D E E E E E E E E E E E E E E E E E E E E F F F F F F F F G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G                                              H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H           IIJJKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMN88888888888888888888888888888OOPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUVVWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^_````````aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb                                                             cccccccccccccccccccccccccccddddeeeeeeeeeeeeeeeeffghhhhhhhhhhhhhiijjjkllllllllmmmmmmnnnooooopppqqqrrrrsssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssstttttttttttttttttuuuuuuuuuuuuuvvvvvvwwwxxxxxxxxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyzzzzz{{{{{{{{{||||||||}}}}}}}}}}~~~~~~~~~~~~~~3.16.1.0None Safe-Inferred 8Returns the absolute pathname of the current executable.Note that for scripts and interactive sessions, this is the path to the interpreter (e.g. ghci.)Since: 4.6.0.0 Reads the FilePath1 pointed to by the symbolic link and returns it.See readlink(2)None* *  . ." None) )(c) Duncan Coutts 2009BSD-likecabal-devel@haskell.orgportableNone? ,The uploading client, ie cabal-install-x.y.z1The Haskell compiler (and hopefully version) used.Which dependent packages we were using exactly)Configure outcome, did configure work ok?"Which configurations flags we usedDid installing work ok?(The OS and Arch the package was built on&The package this build report is about)Configure outcome, did configure work ok?) )$''#''   ' '&-'+'2''  1 1  , ,'%')* * None   Safe-Inferred is a quantity semaphore in which the resource is acquired and released in units of one. It provides guaranteed FIFO ordering for satisfying blocked  calls. None?Global policy for all packages to say if we prefer package versions that are already installed locally or if we just prefer the latest available.Always prefer the installed versions over ones that would need to be installed. Secondarily, prefer latest versions (eg the latest installed version or if there are none then the latest source version).Always prefer the latest version irrespective of any existing installed version.(This is the standard policy for upgrade.Always prefer the oldest version irrespective of any existing installed version or packages explicitly requested.#This is enabled by --prefer-oldest.Prefer the latest version for packages that are explicitly requested but prefers the installed version for any other packages.(This is the standard policy for install.%All the solvers that can be selected.!All the solvers that can be used.    ##%)%)  +2+2! ! > >  (c) Dmitry Astapov 2010BSD-likecabal-devel@gmail.com provisionalportableNoneAttempts to decompress the bytes under the assumption that "data format" error at the very beginning of the stream means that it is already decompressed. Caller should make sanity checks to verify that it is not, in fact, garbage.This is to deal with http proxies that lie to us and transparently decompress without removing the content-encoding header. See: +https://github.com/haskell/cabal/issues/678NoneFull Tarball pathBase directory*Directory to archive, relative to base dirDestination directory'Expected subdir (to check for tarbombs)Tarball# #>NoneGet the  corresponding to a .The 2 argument is required to supply the path for the  case. Check if a  doesn't actually make use of any globbing and is in fact equivalent to a non-glob .If it is trivial in this sense then the result is the equivalent constant . On the other hand, if it is not trivial (so could in principle match more than one file), then the result is Nothing.Match a  against the file system, starting from a given root directory for relative paths. The results of relative globs are relative to the given root. Matches for absolute globs are absolute.root for relative paths+      (c) Andrea Vezzosi 2009BSD-likecabal-devel@haskell.orgportableNoneNone?(Convert a hash from TUF metadata into a PackageSourceHash.Note that TUF hashes don't necessarily have to be SHA256, since it can support new algorithms in future.&Hash some data. Currently uses SHA256.(Hash the content of a file. Uses SHA256.!Truncate a 32 byte SHA256 hash toFor example 20 bytes render as 40 hex chars, which we use for unit-ids. Or even 4 bytes for hashedInstalledPackageIdShort/ /( (((((0 0(c) 2016 Herbert Valerio RiedelBSD3None#&'?PCompute the maximum  valueReturns & for the empty list. Also note that  compares as smaller to all non- values.UNIX timestamp (expressed in seconds since unix epoch, i.e. 1970).Pretty-prints non-null " in ISO8601/RFC3339 format (e.g. "2017-12-31T23:59:59Z").  $ $$$$+$$$$  $$" 4Factory functions for producing known license types.BSD-likecabal-devel@haskell.org provisionalportable Safe-Inferred  None?    None#?As almost all commands use  but not all can honour "ignore-project" flag, provide this utility to remove the flag parsing from the help message.Whether to ignore the local project (i.e. don't search for cabal.project) The exact interpretation might be slightly different per command.The project directory.)The cabal project file path; defaults to  cabal.project. This path, when relative, is relative to the project directory. The filename portion of the path denotes the cabal project file name, but it also is the base of auxiliary project files, such as cabal.project.local and cabal.project.freeze which are also read and written out in some cases. If a project directory was not specified, and the path is not found in the current working directory, we will successively probe relative to parent directories until this name is found.33  3 3NoneRead command-line arguments, separated by null characters, from a file. Returns the default flags if the file does not exist.Write command-line flags to a file, separated by null characters. This format is also suitable for the xargs -0 command. Using the null character also avoids the problem of escaping newlines or spaces, because unlike other whitespace characters, the null character is not valid in command-line arguments. "  NoneTry to lookup RFC1464-encoded mirror urls for a Hackage repository url by performing a DNS TXT lookup on the  _mirrors.-prefixed URL hostname. Example: for  http://hackage.haskell.org/, perform a DNS TXT query for the hostname _mirrors.hackage.haskell.org which may look like e.g. _mirrors.hackage.haskell.org. 300 IN TXT "0.urlbase=http://hackage.fpcomplete.com/" "1.urlbase=http://objects-us-west-1.dream.io/hackage-mirror/"NB: hackage-security doesn't require DNS lookups being trustworthy, as the trust is established via the cryptographically signed TUF meta-data that is retrieved from the resolved Hackage repository. Moreover, we already have to protect against a compromised hackage.haskell.org" DNS entry, so an the additional _mirrors.hackage.haskell.org DNS entry in the same SOA doesn't constitute a significant new attack vector anyway.Extract list of mirrors from  resultHelper used by  for extracting urlbase keys from Rfc1464-encoded dataSplit a TXT string into key and value according to RFC1464. Returns  if parsing fails.! Safe-InferredjInstall a signal handler that initiates a controlled shutdown on receiving SIGTERM by throwing an asynchronous exception at the main thread. Must be called from the main thread.It is a noop on Windows.Terminated is an asynchronous exception, thrown when SIGTERM is received. It's to kill what  UserInterrupt is to Ctrl-C. ( "(c) 2007 Bjorn Bringert, 2008 Andrea Vezzosi, 2008-2009 Duncan CouttsBSD3duncan@community.haskell.orgportableNoneType code for the local build tree reference entry type. We don't use the symbolic link entry type because it allows only 100 ASCII characters for the path.7Type code for the local build tree snapshot entry type./Is this a type code for a build tree reference?#None? Return  if ) specifies a non-empty set of relaxationsEquivalent to isRelaxDeps = (/= ) A smarter RelaxedDepsSome, *:* is the same as all.* in the context of upper bounds (i.e. for  --allow-newer flag)* in the context of lower bounds (i.e. for  --allow-older flag)"Modifier for dependency relaxationApply relaxation only to ^>= constraintsDefault semanticsSpecify the scope of a relaxation, i.e. limit which depending packages are allowed to have their version constraints relaxed.Apply relaxation in any package0Apply relaxation to in all versions of a package8Apply relaxation to a specific version of a package only Express whether to relax bounds on all packages, or a single packageGeneric data type for policy when relaxing bounds in dependencies. Don't use this directly: use  or  depending on whether or not you are relaxing an lower or upper bound (respectively).Ignore upper (resp. lower) bounds in dependencies on all packages.Note.: This is should be semantically equivalent to RelaxDepsSome [RelaxedDep RelaxDepScopeAll RelaxDepModNone RelaxDepSubjectAll](TODO: consider normalising  and/or )Ignore upper (resp. lower) bounds in some (or no) dependencies on the given packages.RelaxDepsSome [] is the default, i.e. honor the bounds in all dependencies, never choose versions newer (resp. older) than allowed.Dependencies can be relaxed either for all packages in the install plan, or only for some packages. [] is the identity element is the absorbing element%simpleParsec "all" :: Maybe RelaxDepsJust RelaxDepsAll&simpleParsec "none" :: Maybe RelaxDepsJust (RelaxDepsSome [])&simpleParsec "*, *" :: Maybe RelaxDepsJust RelaxDepsAll%simpleParsec "*:*" :: Maybe RelaxDepsJust RelaxDepsAll2simpleParsec "foo:bar, quu:puu" :: Maybe RelaxDepsJust (RelaxDepsSome [RelaxedDep (RelaxDepScopePackage (PackageName "foo")) RelaxDepModNone (RelaxDepSubjectPkg (PackageName "bar")),RelaxedDep (RelaxDepScopePackage (PackageName "quu")) RelaxDepModNone (RelaxDepSubjectPkg (PackageName "puu"))]))This is not a glitch, even it looks like:'simpleParsec ", all" :: Maybe RelaxDepsJust RelaxDepsAll"simpleParsec "" :: Maybe RelaxDepsNothing7        # # ' '   ; ;##$''$$$");;$$             ##'';;##'' ;;     " $  $None?7A summary of the outcome for building a single package.>A summary of the outcome for building a whole set of packages.7 78 89 9: :% % # ###0033550 03 35 5< >? ? %None?8A ConfiguredId is a package ID for a configured package.Once we configure a source package we know its UnitId. It is still however useful in lots of places to also know the source ID for the package. We therefore bundle the two.An already installed package of course is also "configured" (all its configuration parameters and dependencies have been specified).-Within Cabal the library we no longer have a InstalledPackageId type. That's because it deals with the compilers' notion of a registered library, and those really are libraries not packages. Those are now named units.The package management layer does however deal with installed packages, as whole packages not just as libraries. So we do still need a type for installed package ids. At the moment however we track installed packages via their primary library, which is a unit id. In future this may change slightly and we may distinguish these two types and have an explicit conversion when we register units with the compiler.  ? ?5 555 .55   !&None ?A  is a not-yet-installed package along with the total configuration information. The configuration information is total in the sense that it provides all the configuration information and so the final configure process will be independent of the environment.0 is assumed to not support Backpack. Only the v2-build codepath supports Backpack.0set of exact dependencies (installed or source)."These must be consistent with the  buildDepends in the PackageDescription that you'd get by applying the flag assignment and optional stanzas.(complete flag assignment for the packagepackage info, including repo0list of enabled optional stanzas for the package# indicates data types which have a . This type class is mostly used to conveniently finesse between ElaboratedPackage and ElaboratedComponent.  60 0005 51 4 += =( ): :2 200' Safe-Inferred?3Either (username, password) or authentacation token  (None?Last   ')-    ! ")None?    ')-      $*None?  9 9#0 0002 2#6 6&00: :'+None parseURI "file+noindex://C:/foo.txt"Just "/foo.txt"$parseURI "file+noindex://C:\foo.txt"Nothing1uriPath <$> parseURI "file+noindex:///C:/foo.txt"Just "/C:/foo.txt".uriPath <$> parseURI "file+noindex:C:/foo.txt"Just "C:/foo.txt"Out of the ones above, only the last one can be used from anywhere in the system.no-index style local repositories. ,https://github.com/haskell/cabal/issues/6359/Threshold for verification during bootstrapping Root key IDs (for bootstrapping)Enable secure access? here represents "whatever the default is"; this is important to allow for a smooth transition from opt-in to opt-out security (once we switch to opt-out, all access to the central Hackage repository should be secure by default)Normally a repo just specifies an HTTP or HTTPS URI, but as a special case we may know a repo supports both and want to try HTTPS if we can, but still allow falling back to HTTP.This field is not currently stored in the config file, but is filled in automagically for known repos.Different kinds of repositories:NOTE: It is important that this type remains serializable. Local repository, without index. ,https://github.com/haskell/cabal/issues/6359(Standard (unsecured) remote repositoriesSecure repositories*Although this contains the same fields as <, we use a separate constructor to avoid confusing the two.Not all access to a secure repo goes through the hackage-security library currently; code paths that do not still make use of the  and  fields directly.Note: doesn't parse  field.#Note: serialised format represents  only partially.   ###          .(c) 2016 Herbert Valerio RiedelBSD3None#?U  where all repositories are at HEAD index state. Insert a  to . Lookup a # for an individual repository from .Create .;Specification of the state of a specific repo package indexUse all available entries2Use all entries that existed at the specified time$Index state of multiple repositories,simpleParsec "HEAD" :: Maybe TotalIndexState'Just (TIS IndexStateHead (fromList []))(simpleParsec "" :: Maybe TotalIndexStateNothingsimpleParsec "hackage.haskell.org HEAD" :: Maybe TotalIndexState'Just (TIS IndexStateHead (fromList []))simpleParsec "2020-02-04T12:34:56Z, hackage.haskell.org HEAD" :: Maybe TotalIndexStateJust (TIS (IndexStateTime (TS 1580819696)) (fromList [(RepoName {unRepoName = "hackage.haskell.org"},IndexStateHead)]))simpleParsec "hackage.haskell.org 2020-02-04T12:34:56Z" :: Maybe TotalIndexStateJust (TIS IndexStateHead (fromList [(RepoName {unRepoName = "hackage.haskell.org"},IndexStateTime (TS 1580819696))]))Remove non-default values from . * *  ( ((( , ,    . . (( #+ +$/None#?V Note, this does nothing if  is present. Sort values  according to  list.6let repos = [RepoName "a", RepoName "b", RepoName "c"]organizeByRepos (ActiveRepos [ActiveRepoRest CombineStrategyMerge]) id reposRight [(RepoName {unRepoName = "a"},CombineStrategyMerge),(RepoName {unRepoName = "b"},CombineStrategyMerge),(RepoName {unRepoName = "c"},CombineStrategyMerge)]organizeByRepos (ActiveRepos [ActiveRepo (RepoName "b") CombineStrategyOverride, ActiveRepoRest CombineStrategyMerge]) id reposRight [(RepoName {unRepoName = "b"},CombineStrategyOverride),(RepoName {unRepoName = "a"},CombineStrategyMerge),(RepoName {unRepoName = "c"},CombineStrategyMerge)]organizeByRepos (ActiveRepos [ActiveRepoRest CombineStrategyMerge, ActiveRepo (RepoName "b") CombineStrategyOverride]) id reposRight [(RepoName {unRepoName = "a"},CombineStrategyMerge),(RepoName {unRepoName = "c"},CombineStrategyMerge),(RepoName {unRepoName = "b"},CombineStrategyOverride)]organizeByRepos (ActiveRepos [ActiveRepoRest CombineStrategyMerge, ActiveRepo (RepoName "d") CombineStrategyOverride]) id reposLeft "no repository provided d"Note: currently if  is provided more than once, rest-repositories will be multiple times in the output.explicit repository name1rest repositories, i.e. not explicitly listed as $Ordered list of active repositories.merge existing versionsif later repository specifies a package, all package versions are replacedskip this repository Note: empty string is not valid .$simpleParsec "" :: Maybe ActiveReposNothing)simpleParsec ":none" :: Maybe ActiveReposJust (ActiveRepos []))simpleParsec ":rest" :: Maybe ActiveRepos8Just (ActiveRepos [ActiveRepoRest CombineStrategyMerge])simpleParsec "hackage.haskell.org, :rest, head.hackage:override" :: Maybe ActiveReposJust (ActiveRepos [ActiveRepo (RepoName {unRepoName = "hackage.haskell.org"}) CombineStrategyMerge,ActiveRepoRest CombineStrategyMerge,ActiveRepo (RepoName {unRepoName = "head.hackage"}) CombineStrategyOverride])   1 1 $     &- 3 3       5 5     $2 2  $0None #19?T Split single source-repository-package declaration with multiple subdirs, into multiple ones with at most single subdir. Read from  cabal.projectDistilled from  without subdir. Used in clone errors. Cloning doesn't care about subdirectory.source-repository-package definition**''% %(())++1None 4None?Whether 'v2-build' should write a .ghc.environment file after success. Possible values: always, never (the default), 'ghc8.4.4+' (8.4.4 is the earliest version that supports '-package-env -'). /  ')- 3(c) David Himmelstrup 2005 Duncan Coutts 2011BSD-likecabal-devel@haskell.org provisionalportableNone (c) Duncan Coutts 2008BSD-likeduncan@community.haskell.org provisionalportableNone ?PThe graph of packages (nodes) and dependencies (edges) must be acyclic.if the result is False use  to find out which packages are involved in dependency cycles.An installation plan is closed if for every package in the set, all of its dependencies are also in the set. That is, the set is closed under the dependency relation.if the result is False use  to find out which packages depend on packages not in the index.An installation plan is consistent if all dependencies that target a single package name, target the same version.This is slightly subtle. It is not the same as requiring that there be at most one version of any package in the set. It only requires that of packages which have more than one other package depending on them. We could actually make the condition even more precise and say that different versions are OK so long as they are not both in the transitive closure of any other package (or equivalently that their inverse closures do not intersect). The point is we do not want to have any packages depending directly or indirectly on two different versions of the same package. The current definition is just a safe approximation of that.if the result is False use # to find out which packages are.=Compute the dependency closure of a package in a install planBuild an installation plan from a valid set of resolved packages.For an invalid plan, produce a detailed list of problems as human readable error messages. This is mainly intended for debugging purposes. Use " for a human readable explanation.Remove packages from the install plan. This will result in an error if there are remaining packages that depend on any matching package. This is primarily useful for obtaining an install plan for the dependencies of a package or set of packages without actually installing the package itself, as when doing development.7A valid installation plan is a set of packages that is ,  and . Also, every ConfiguredPackage5 in the plan has to have a valid configuration (see configuredPackageValid).if the result is False use  to get a detailed list.Compute all roots of the install plan, and verify that the transitive plans from those roots are all consistent.NOTE: This does not check for dependency cycles. Moreover, dependency cycles may be absent from the subplans even if the larger plan contains a dependency cycle. Such cycles may or may not be an issue; either way, we don't check for them here.Given a package index where we assume we want to use all the packages (use  if you need to get such a index subset) find out if the dependencies within it use consistent versions of each package. Return all cases where multiple packages depend on different versions of some other package.Each element in the result is a package name along with the packages that depend on it and the versions they require. These are guaranteed to be distinct.#Compute the library roots of a planThe library roots are the set of packages with no reverse dependencies (no reverse library dependencies but also no reverse setup dependencies).Compute the root sets of a planA root set is a set of packages whose dependency closure must be consistent. This is the set of all top-level library roots (taken together normally, or as singletons sets if we are considering them as independent goals), along with all setup dependencies of all packages.2The setup dependencies of each package in the planThe states of packages have that depend on each other must respect this relation. That is for very case where package a depends on package b we require that dependencyStatesOk a b = True. "  &5None&'( N-Calculate the overall hash to be used for an . Calculate a : for a package using our nix-style inputs hashing method.Note that due to path length limitations on Windows, this function uses a different method on Windows that produces shorted package ids. See  vs . Calculate a : for a package using our nix-style inputs hashing method.This produces large ids with big hashes. It is only suitable for systems without significant path length limitations (ie not Windows).On Windows we have serious problems with path lengths. Windows imposes a maximum path length of 260 chars, and even if we can use the windows long path APIs ourselves, we cannot guarantee that ghc, gcc, ld, ar, etc etc all do so too.So our only choice is to limit the lengths of the paths, and the only real way to do that is to limit the size of the s that we generate. We do this by truncating the package names and versions and also by truncating the hash sizes.Truncating the package names and versions is technically ok because they are just included for human convenience, the full source package id is included in the hash.Truncating the hash size is disappointing but also technically ok. We rely on the hash primarily for collision avoidance not for any security properties (at least for now).'Render a textual representation of the .The * of this text is the overall package hash.Those parts of the package configuration that contribute to the package hash.All the information that contributes to a package's hash, and thus its .On macOS we shorten the name very aggressively. The mach-o linker on macOS has a limited load command size, to which the name of the library as well as its relative path (@rpath) entry count. To circumvent this, on macOS the libraries are not stored as store librarynamelibHS libraryname.dylib where libraryname contains the libraries name, version and abi hash, but in storeliblibHS veryshort libraryname.dylib where the very short library name drops all vowels from the package name, and truncates the hash to 4 bytes..We therefore we only need one @rpath entry to  store/lib instead of one @rpath entry for each library. And the reduced library name saves some additional space.This however has two major drawbacks: 1) Packages can collide more easily due to the shortened hash. 2) The libraries are *not* prefix relocatable anymore as they all end up in the same  store/lib folder.The ultimate solution would have to include generating proxy dynamic libraries on macOS, such that the proxy libraries and the linked libraries stay under the load command limit, and the recursive linker is still able to link all of them.?? 6None#,A key-value pair for encoding a JSON object.%Serialise value as JSON/UTF8-encoded (Serialise value as JSON-encoded Unicode  Create a  from a list of name/value s. A JSON "object" (key/value map).A key/value pair for an %A type that can be converted to JSON.=Convert a Haskell value to a JSON-friendly intermediate type.,A JSON value represented as a Haskell value.$Possibly lossy due to conversion to $Possibly lossy due to conversion to $Possibly lossy due to conversion to Try to convert  into  , return - if not representable loss-free as integral  value.Minimally escape a * in accordance with RFC 7159, "7. Strings"% %7 7%%%%           & / < ? ?      7NoneG;Render parse error highlighting the part of the input file. "(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgportableNone+, z"Symmetric choice.Local, exclusive, left-biased choice: If left parser locally produces any result at all, then right parser is not used. between open close p  parses open, followed by p and finally close. Only the value of p is returned. chainl p op x$ parses zero or more occurrences of p, separated by op#. Returns a value produced by a left9 associative application of all functions returned by op!. If there are no occurrences of p, x is returned.Like (, but parses one or more occurrences of p. chainr p op x$ parses zero or more occurrences of p, separated by op#. Returns a value produced by a right9 associative application of all functions returned by op!. If there are no occurrences of p, x is returned.Like (, but parses one or more occurrences of p.+Parses and returns the specified character.+Combines all parsers in the specified list. count n p  parses n occurrences of p/ in sequence. A list of results is returned. endBy p sep$ parses zero or more occurrences of p, separated and ended by sep. endBy p sep# parses one or more occurrences of p, separated and ended by sep.'Succeeds iff we are at the end of inputTransforms a parser into one that does the same, but in addition returns the exact characters read. IMPORTANT NOTE:  gives a runtime error if its first argument is built using any occurrences of readS_to_P.Consumes and returns the next character. Fails if there is no input left.Look-ahead: returns the part of the input that is left, without consuming it.4Parses zero or more occurrences of the given parser.3Parses one or more occurrences of the given parser.manyTill p end$ parses zero or more occurrences of p, until end3 succeeds. Returns a list of values returned by p.Parses the first zero or more characters satisfying the predicate.Parses the first one or more characters satisfying the predicate. option x p will either parse p or return x without consuming any input. optional p optionally parses p and always returns (). Always fails.Converts a parser into a Haskell ReadS-style function. This is the main way in which you can "run" a " parser: the expanded type is 1 readP_to_S :: ReadP a -> String -> [(a,String)] Converts a Haskell ReadS-style function into a parser. Warning: This introduces local backtracking in the resulting parser, and therefore a possible inefficiency.Consumes and returns the next character, if it satisfies the specified predicate. sepBy p sep$ parses zero or more occurrences of p, separated by sep*. Returns a list of values returned by p. sepBy1 p sep# parses one or more occurrences of p, separated by sep*. Returns a list of values returned by p.Like , but discards the result.Like , but discards the result.Skips all whitespace.Like  but succeeds only if there is at least one whitespace character to skip.(Parses and returns the specified string.&&    . "     %   ,"(c) The University of Glasgow 2004BSD3cabal-devel@haskell.orgportableNonem A regular  property: value fieldA section with a name and possible parameter. The syntactic structure is:   sectionname  arg {  field* } !Field descriptor. The parameter a< parameterizes over where the field's value is stored in.fieldSet n str x5 Parses the field value from the given input string str and stores the result in x if the parse was successful. Otherwise, reports an error on line number n.The type of a function which, given a name-value pair of an unrecognized field, and the current structure being built, decides whether to incorporate the unrecognized field (by returning Just x, where x is a possibly modified version of the structure being built), or not (by returning Nothing).'The parser for the stuff between commas5  !      $    !None ' '(# #$+ +"  9None15 < :(c) Duncan Coutts 2008BSD-likecabal-devel@haskell.org provisionalportableNone None3'#Reverse operation to .A non-throwing wrapper for . If < throws an exception, returns the path argument unmodified.From Control.Monad.Extra /https://hackage.haskell.org/package/extra-1.7.9Determine the number of jobs to use given the value of the '-j' flag.Like  -, but also checks that the first file exists. Convert a  to a lazy  ByteString. Each  is encoded as a little-endian ."Returns the current calendar year.hasElem xs x = elem x xs except that xs is turned into a  first. Use underapplied to speed up subsequent lookups, e.g. filter (hasElem xs) ys,. Only amortized when used several times!Time complexity O((n+m) \log(n)) for m lookups in a list of length n. (Compare this to elem's O(nm).)This is  https://hackage.haskell.org/package/Agda-2.6.2.2/docs/Agda-Utils-List.html#v:hasElemAgda.Utils.List.hasElem.6Increment the nth version component (counting from 0).From System.Directory.Extra /https://hackage.haskell.org/package/extra-1.7.9From System.Directory.Extra /https://hackage.haskell.org/package/extra-1.7.9Log directory change in make compatible syntaxGiven a relative path, make it absolute relative to the current directory. Absolute paths are returned unmodified.Given a canonical absolute path and canonical absolute dir, make the path relative to the directory, including using ../.. if necessary. Returns the original absolute path if it is not on the same drive as the given dir.Given a path (relative or absolute), make it relative to the current directory, including using ../.. if necessary.Given a path (relative or absolute), make it relative to the given directory, including using ../.. if necessary."makeRelativeToDir for SymbolicPathGeneric merging utility. For sorted input lists this is a full outer join. Like Distribution.Simple.Utils.moreRecentFile, but uses getModTime instead of getModificationTime for higher precision. We can't merge the two because Distribution.Client.Time uses MIN_VERSION macros. Given a version, return an API-compatible (according to PVP) version range.If the boolean argument denotes whether to use a desugared representation (if ) or the new-style ^>= -form (if ). Example: pvpize True (mkVersion [0,4,1]) produces the version range >= 0.4 && < 0.5 (which is the same as 0.4.*). Sets the handler for encoding errors to one that transliterates invalid characters into one present in the encoding (i.e., '?'). This is opposed to the default behavior, which is to throw an exception on error. This function will ignore file handles that have a Unicode encoding set. It's a no-op for versions of base less than 4.4. Like , but does not throw an exception when the file does not exist. -Workaround for the inconsistent behaviour of . Always throws an error if the path refers to a non-existent file. Like tryFindPackageDesc-, but with error specific to add-source deps. Try to read a .cabal file, in directory depPath'. Fails if one cannot be found, with err prefixing the error message. This function simply allows us to give a more descriptive error than that provided by findPackageDesc. Executes the action with an environment variable set to some value.Warning: This operation is NOT thread-safe, because current environment is a process-global concept. Executes the action with a list of environment variables and corresponding overrides, where v0 means "set the environment variable's value to v".( means "unset the environment variable".Warning: This operation is NOT thread-safe, because current environment is a process-global concept. Executes the action, increasing the PATH environment in some wayWarning: This operation is NOT thread-safe, because the environment variables are a process-global concept.  A variant of  withTempFile that only gives us the file name, and while it will clean up the file afterwards, it's lenient if the file is moved/deleted. Phase of building a dependency. Represents current status of package dependency processing. See #4040 for details.From Control.Monad.Extra /https://hackage.haskell.org/package/extra-1.7.9 with swapped branches: ifNotM b t f = ifM (not  $ b) t f From System.Directory.Extra /https://hackage.haskell.org/package/extra-1.7.9 From Control.Monad.Extra /https://hackage.haskell.org/package/extra-1.7.9 Internal helper function for   and  .1  1         ;(c) Duncan Coutts 2012BSD-likecabal-devel@haskell.org provisionalportableNone* Concurrently execute actions on a list using the given JobControl. The maximum number of concurrent jobs is tied to the JobControl instance. The resulting list does not preserve the original order! Make a   that eagerly executes jobs in parallel, with a given maximum degree of parallelism.Cancelling will cancel jobs that have not yet begun executing, but jobs that have already been executed or are currently executing cannot be cancelled. Make a  4 where the parallelism is controlled by a semaphore.This uses the GHC -jsem option to allow GHC to take additional semaphore slots if we are not using them all. Make a   that executes all jobs serially and in order. It only executes jobs on demand when they are collected, not eagerly.Cancelling will cancel all' jobs that have not been collected yet. A simple concurrency abstraction. Jobs can be spawned and can complete in any order. This allows both serial and parallel implementations. >Try to cancel any outstanding but not-yet-started jobs. Call   after this to find out if any jobs are left (ie could not be cancelled). cleanup any resources created by the JobControl, intended to be used as the finaliser for  . Wait until one job is complete Name of the semaphore which can be used to control parallelism, if one is available for that job control type. Returns True if there are any outstanding jobs (ie spawned but yet to be collected) !Add a new job to the pool of jobs The compiler, used to determine whether Jsem is supported. When Nothing, Jsem is assumed to be unsupported.The parallel strategyA cap on the number of jobs (e.g. to force a maximum of 2 concurrent downloads despite a -j8 parallel strategy)  <(c) Duncan Coutts 2008BSD-likeduncan@community.haskell.org provisionalportableNone  1?  Given a package in the processing state, mark the package as completed and return any packages that are newly in the processing state (ie ready to process), along with the updated   state. Conversion of  to  . Similar to elaboratedInstallPlan Return the packages in the plan that are direct or indirect dependencies of the given packages. 6Find all the direct dependencies of the given package.?Note that the package must exist in the plan or it is an error. Execute an install plan. This traverses the plan in dependency order.Executing each individual package can fail and if so all dependents fail too. The result for each package is collected as a   map.Visiting each package happens with optional parallelism, as determined by the  . By default, after any failure we stop as soon as possible (using the   to try to cancel in-progress tasks). This behaviour can be reversed to keep going and build as many packages as possible.Note that the   is not guaranteed to cover all the packages in the plan. In particular in the default mode where we stop as soon as possible after a failure then there may be packages which are skipped and these will have no .  Flatten an  , producing the sequence of source packages in the order in which they would be processed when the plan is executed. This can be used for simulations or presenting execution dry-runs.1It is guaranteed to give the same order as using   (with a serial in-order  ), which is a reverse topological orderings of the source packages in the dependency graph, albeit not necessarily exactly the same ordering as that produced by  . 'Convenience combinator for destructing  . This is handy because if you case manually, you have to handle   and  8 separately (where often you want them to be the same.) #Change a number of packages in the   state to the   state.To preserve invariants, the package must have all of its dependencies already installed too (that is   or  ). Lookup a package in the plan. -Lookup the build result for a single package. Build an installation plan from a valid set of resolved packages. The packages in the plan that are initially ready to be installed. That is they are in the configured state and have all their dependencies installed already.The result is both the packages that are now ready to be installed and also a   state containing those same packages. The assumption is that all the packages that are ready will now be processed and so we can consider them to be in the processing state. Remove packages from the install plan. This will result in an error if there are remaining packages that depend on any matching package. This is primarily useful for obtaining an install plan for the dependencies of a package or set of packages without actually installing the package itself, as when doing development. >Find all the direct reverse dependencies of the given package.?Note that the package must exist in the plan or it is an error. Return the packages in the plan that depend directly or indirectly on the given packages. Return all the packages in the   in reverse topological order. That is, for each package, all dependencies of the package appear first. Compared to  , this function returns all the installed and source packages rather than just the source ones. Also, while both this and   produce reverse topological orderings of the package dependency graph, it is not necessarily exactly the same order. Generic way to show a  ) which elicits quite a lot of information 9The set of results we get from executing an install plan. Packages in an install planNOTE: ,  and   intentionally have no PackageInstalled instance. `This is important: PackageInstalled returns only library dependencies, but for package that aren't yet installed we know many more kinds of dependencies (setup dependencies, exe, test-suite, benchmark, ..). Any functions that operate on dependencies in cabal-install should consider what to do with these dependencies; if we give a PackageInstalled instance it would be too easy to get this wrong (and, for instance, call graph traversal functions from Cabal rather than from cabal-install). Instead, see PackageInstalled.  ) specialised to most commonly used types. The   type is used to keep track of the state of a traversal and includes the set of packages that are in the processing state, e.g. in the process of being installed, plus those that have been completed and those where processing failed. .Smart constructor that deals with caching the   representation. For an invalid plan, produce a detailed list of problems as human readable error messages. This is mainly intended for debugging purposes. Use  " for a human readable explanation. The states of packages have that depend on each other must respect this relation. That is for very case where package a depends on package b we require that "stateDependencyRelation a b = True. A valid installation plan is a set of packages that is closed, acyclic and respects the package state relation.if the result is False use   to get a detailed list. Keep going after failure'Value for dependents of failed packages, , -      6 9 ' - .     =%(c) Brent Yorgey, Benedikt Huber 2009BSD-likecabal-devel@haskell.org provisionalportableNone      #(     *1                   >(c) Brent Yorgey 2009BSD-likecabal-devel@haskell.org provisionalportableNoneT Create a prompt with optional default value that returns a value of some Text instance. &Create a prompt from a list of strings Create a prompt with optional default value that returns a String. 3Create a yes/no prompt with optional default value. /Create a prompt with an optional default value. Prompt utility for breaking out of an interactive loop in the pure case Create a prompt from a prompt string and a String representation of an optional default value. promptchoicesoptional default valuemodify the default value to present in-prompt e.g. empty string maps to "(none)", but only in the prompt.whether to allow an other option prompt messageoptional default value parserpretty-printerprompt messageoptional default value  ?(c) Brent Yorgey 2009BSD-likecabal-devel@haskell.org provisionalportableNone# $A field annotation with no comments. A field annotation instructing the pretty printer to comment out the field and any contents, with no comments.  Construct a  : from a field that can be automatically converted to a   via display.  Construct a   from a   Flag. 4A field annotation with the specified comment lines. Name of the fieldField contentsComment to explain the field;Should the field be included (commented out) even if blank? @(c) Brent Yorgey 2009BSD-likecabal-devel@haskell.org provisionalportableNone_ 3Default MyLib.hs file. Used when no Lib.hs exists. Default MyLibTest.hs file.  None&' -Check if a given file has a Haskell extension 3Check if a given file has main file characteristics Check whether a potential source file is located in one of the source directories. 4Given a module, retrieve all of its language pragmas +Given a module, retrieve all of its imports !Given a module, retrieve its name 8Data type of source files found in the working directory    > >ANone 'Ask for the application root directory. The author's name. Prompt, or try to guess from an existing darcs repo.  Retrieve the list of build tools )Get the version of the cabal spec to use.The spec version can be specified by the InitFlags cabalVersion field. If none is specified then the user is prompted to pick from a list of supported versions (see code below). Prompt for a package category. Note that it should be possible to do some smarter guessing here too, i.e. look at the name of the top level source directory. !Retrieve the list of dependencies The author's email. Prompt, or try to guess from an existing darcs repo. $Retrieve the list of exposed modules 8Try to guess extra source files (don't prompt the user). 8Try to guess extra source files (don't prompt the user). *Prompt for a homepage URL for the package. 1Ask for the Haskell base language of the package. Choose a license for the package. The license can come from Initflags (license field), if it is not present then prompt the user from a predefined list of licenses. 4Extract minimal cabal file flag (implies nocomments) -Ask whether to generate explanatory comments. Retrieve the list of extensions "Retrieve the list of other modules (Tell whether to overwrite files on write Get the package name: use the package directory (supplied, or the current directory by default) as a guess. It looks at the SourcePackageDb to avoid using an existing package name. 7Ask whether the project builds a library or executable. Ask if a simple project with sensible defaults should be created. ,Ask for the source (library) root directory. Prompt for a project synopsis. Package version: use 0.1.0.0 as a last resort, but try prompting the user if possible. If a flag is defined, return its value or else execute an interactive action." " BNone If deps are defined, and base is present, we skip the search for base. otherwise, we look up base and add it to the list.  C(c) Benedikt Huber 2009BSD-likecabal-devel@haskell.org provisionalportableNone Try to guess the application directories from the package directory, using a default value as fallback. 7Guess author and email using git configuration options. Juggling characters around to guess the desired cabal version based on the system's cabal version. 9Guess the language specification based on the GHC version 2Try to guess the license from an already existing LICENSE file in the package directory, comparing the file contents with the ones listed in  Licenses.hs*, for now it only returns a default value. >Guess the main file, returns a default value if none is found. 9Guess the package name based on the given root directory. Try to guess the package type from the files in the package directory, looking for unique characteristics from each type, defaults to Executable. Try to guess the source directories, using a default value as fallback. DNone 'Ask for the application root directory. The author's name. Prompt, or try to guess from an existing git repo.  Retrieve the list of build tools Get the version of the cabal spec to use. The spec version can be specified by the InitFlags cabalVersion field. If none is specified then the default version is used. Prompt for a package category. Note that it should be possible to do some smarter guessing here too, i.e. look at the name of the top level source directory. (Main driver for interactive prompt code. !Retrieve the list of dependencies The author's email. Prompt, or try to guess from an existing git repo. Retrieve the list of other modules for Executables, it lists everything that is a Haskell file within the application directory, excluding the main file $Retrieve the list of exposed modules  Try to guess extra source files. *Prompt for a homepage URL for the package. 1Ask for the Haskell base language of the package. Retrieve the list of other modules for Libraries, filtering them based on the last component of the module name Choose a license for the package. The license can come from Initflags (license field), if it is not present then prompt the user from a predefined list of licenses. Try to guess the main file, if nothing is found, fallback to a default value. -Ask whether to generate explanatory comments. Retrieve the list of extensions Get the package name: use the package directory (supplied, or the current directory by default) as a guess. It looks at the SourcePackageDb to avoid using an existing package name. Try to guess if the project builds a library, an executable, or both. ,Ask for the source (library) root directory. Prompt for a project synopsis. Retrieve the list of other modules for Tests, it lists everything that is a Haskell file within the tests directory, excluding the main file -Package version: use 0.1.0.0 as a last resort E(c) Brent Yorgey 2009BSD-likecabal-devel@haskell.org provisionalportableNone 'Ask for the application root directory. (Main driver for interactive prompt code. Extract flags relevant to a executable target and interactively generate a   object for creation. If the user specifies the generation of a simple package, then a simple target with defaults is generated. Extract flags relevant to a library target and interactively generate a   object for creation. If the user specifies the generation of a simple package, then a simple target with defaults is generated. Extract flags relevant to a package description and interactively generate a   object for creation. If the user specifies the generation of a simple package, then a simple target with defaults is generated. Extract flags relevant to a test target and interactively generate a   object for creation. If the user specifies the generation of a simple package, then a simple target with defaults is generated.Note: this workflow is only enabled if the user answers affirmatively when prompted, or if the user passes in the flag to enable test suites at command line. ,Ask for the source (library) root directory.  F(c) Brent Yorgey 2009BSD-likecabal-devel@haskell.org provisionalportableNone#> .Writes the changelog to the current directory. Write the LICENSE file.For licenses that contain the author's name(s), the values are taken from the authors field of  1, and if not specified will be the string "???".If the license type is unknown no license file will be prepared and a warning will be raised. Write a file "safely" if it doesn't exist, backing up any existing version when the overwrite flag is set. Possibly generate a message to stdout, taking into account the --quiet flag.  .cabal fields   ;=  GNone (Update the input value and the set of files monitored by the  7, plus the cached value that may be returned in future.This takes a snapshot of the state of the monitored files right now, so  > will look for file system changes relative to this snapshot.This is typically done once the action has been completed successfully and we have the action's result and we know what files it looked at. See   for a full explanation.If we do take the snapshot after the action has completed then we have a problem. The problem is that files might have changed while the action was running but after the action read them. If we take the snapshot after the action completes then we will miss these changes. The solution is to record a timestamp before beginning execution of the action and then we make the conservative assumption that any file that has changed since then has already changed, ie the file monitor state for these files will be such that  $ will report that they have changed.So if you do use   after the action (so you can discover the files used rather than predicting them in advance) then use   to get a timestamp and pass that. Alternatively, if you take the snapshot in advance of the action, or you're not monitoring any files then you can use Nothing for the timestamp parameter. A monitor for detecting changes to a set of files. It can be used to efficiently test if any of a set of files (specified individually or by glob patterns) has changed since some snapshot. In addition, it also checks for changes in a value (of type a), and when there are no changes in either it returns a saved value (of type b).The main use case looks like this: suppose we have some expensive action that depends on certain pure inputs and reads some set of files, and produces some pure result. We want to avoid re-running this action when it would produce the same result. So we need to monitor the files the action looked at, the other pure input values, and we need to cache the result. Then at some later point, if the input value didn't change, and none of the files changed, then we can re-use the cached result rather than re-running the action.This can be achieved using a  . Each   instance saves state in a disk file, so the file for that has to be specified, making sure it is unique. The pattern is to use   to see if there's been any change. If there is, re-run the action, keeping track of the files, then use   to record the current set of files to monitor, the current input value for the action, and the result of the action.6The typical occurrence of this pattern is captured by rerunIfChanged and the Rebuild0 monad. More complicated cases may need to use   and   directly. The file where this   should store its state. When this mode is enabled, if   returns   then we have the guarantee that no files changed, that the value change was the only change. In the default mode no such guarantee is provided which is slightly faster. Compares a new cache key with old one to determine if a corresponding cached value is still valid.Typically this is just an equality test, but in some circumstances it can make sense to do things like subset comparisons.The first arg is the new value, the second is the old cached value. The result of  : either the monitored files or value changed (and it tells us which it was) or nothing changed and we get the cached result. >The monitor found that something changed. The reason is given. The monitored files and value did not change. The cached result is b.The set of monitored files is also returned. This is useful for composing or nesting  s. What kind of change   detected. There was existing state, but we could not read it. This typically happens when the code has changed compared to an existing   cache file and type of the input value or cached value has changed such that we cannot decode the values. This is completely benign as we can treat is just as if there were no cache file and re-run. There was no saved monitor state, cached value etc. Ie the file for the   does not exist. One of the files changed (existence, file type, mtime or file content, depending on the  in question) The pure input value changed.The previous cached key value is also returned. This is sometimes useful when using a   function that is not simply , when invalidation can be partial. In such cases it can make sense to   with a key value that's a combination of the new and old (e.g. set union). The state necessary to determine whether a monitored file has changed.This covers all the cases of 2 except for globs which is covered separately by  .The  Maybe ModTime is to cover the case where we already consider the file to have changed, either because it had already changed by the time we did the snapshot (i.e. too new, changed since start of update process) or it no longer exists at all. The state necessary to determine whether a set of monitored files has changed. It consists of two parts: a set of specific files to be monitored (index by their path), and a list of globs, which monitor may files at once. The state necessary to determine whether the files matched by a globbing match have changed. A timestamp to help with the problem of file changes during actions. See   for details. cached file mtime cached mtime and content hash cached dir mtime We really want to avoid re-hashing files all the time. We already make the assumption that if a file mtime has not changed then we don't need to bother checking if the content hash has changed. We can apply the same assumption when updating the file monitor state. In the typical case of updating a file monitor the set of files is the same or largely the same so we can grab the previously known content hashes with their corresponding mtimes. Take the snapshot of the monitored files. That is, given the specification of the set of files we need to monitor, inspect the state of the file system now and collect the information we'll need later to determine if anything has changed.  Much like  7 but for the somewhat complicated case of a file glob.This gets used both by  : when we're taking the file system snapshot, but also by probeGlobStatus as part of checking the monitored (globed) files for changes when we find a whole new subtree. If we have a timestamp for the beginning of the update, then any file mtime later than this means that it changed during the update and we ought to consider the file as already changed. Given a directory dir , return Nothing if its   is the same as mtime, and the new   if it is not. Returns True if, inside the root directory, file has the same   and  as  mtime and chash@. Returns True if, inside the root directory, file has the same   as mtime. 0Either get it from the cache or go read the file 4Run an IO computation, returning the first argument e if there is an  call. ( ) !Run an IO computation, returning e if there is any .This policy is OK in the file monitor code because it just causes the monitor to report that something changed, and then code reacting to that will normally encounter the same IO exception when it re-runs the action that uses the file. We declare it a cache hit if the mtime of a file is the same as before.  Within the root directory, check if dir6 still exists. If it *does not* exist, short-circuit.  Within the root directory, check if file still exists as a file. If it *does not* exist, short-circuit.  Within the root directory, check if file has its   is the same as mtime&, short-circuiting if it is different.  Within the root directory, check if file has its   and  is the same as mtime and hash', short-circuiting if it is different.  Within the root directory, check if file: still does not exist. If it *does* exist, short-circuit. Probe the file system to see if any of the monitored files have changed.It returns Nothing if any file changed, or returns a possibly updated file  2 plus an indicator of whether it actually changed.We may need to update the cache since there may be changes in the filesystem state which don't change any of our affected files.Consider the glob {proj1,proj2}/*.cabal. Say we first run and find a proj1 directory containing  proj1.cabal yet no proj2. If we later run and find proj2- was created, yet contains no files matching *.cabal then we want to update the cache despite no changes in our relevant file set. Specifically, we should add an mtime for this directory so we can avoid re-traversing the directory in future runs. Probe the file system to see if a single monitored file has changed. Probe the file system to see if a monitored file glob has changed. Build a   from the previous  . While in principle we could preserve the structure of the previous state, given that the set of files to monitor can change then it's simpler just to throw away the structure and use a finite map. We can build a   from a set of  by inspecting the state of the file system, and we can go in the reverse direction by just forgetting the extra info. "Helper for writing the cache file.=This determines the type and format of the binary cache file. Lazily decode a triple, parsing the first two fields strictly and returning a lazy value containing either the last one or an error. This is helpful for cabal cache files where the first two components contain header data that lets one test if the cache is still valid, and the last (potentially large) component is the cached value itself. This way we can test for cache validity without needing to pay the cost of the decode of stale cache data. This lives here rather than Distribution.Utils.Structured because it depends on a newer version of binary than supported in the Cabal library proper. "Helper for reading the cache file.=This determines the type and format of the binary cache file. cache file pathroot directoryguard or key value did the key or any paths change? The file to cache the state of the file monitor. Must be unique. cache file pathroot directory(timestamp when the update action started"files of interest relative to rootthe current key valuethe current result value /optional: timestamp of the start of the actionexisting file hashesroot directory(patterns of interest relative to root start time of updateexisting file hashesthe root directorythe matching glob  root path start time of updateexisting file hashesthe root directory start time of updateexisting file hashesthe root directory2directory we are examining relative to the rootthe matching glob  root path7path of the directory we are looking in relative to root8  "!     !    !  $  !  '  $         #( *1               %  (  +  %  (None3  The root that relative paths are interpreted as being relative to.  When using   for each element of a list of actions, it is sometimes the case that each action needs to make use of some resource. e.g. sequence [ rerunIfChanged verbosity monitor key $ do resource <- mkResource ... -- use the resource | ... ]For efficiency one would like to share the resource between the actions but the straightforward way of doing this means initialising it every time even when no actions need re-running. resource <- mkResource sequence [ rerunIfChanged verbosity monitor key $ do ... -- use the resource | ... ]7This utility allows one to get the best of both worlds: getResource <- delayInitSharedResource mkResource sequence [ rerunIfChanged verbosity monitor key $ do resource <- getResource ... -- use the resource | ... ]  Much like  " but for a keyed set of resources. getResource <- delayInitSharedResource mkResource sequence [ rerunIfChanged verbosity monitor key $ do resource <- getResource key ... -- use the resource | ... ] Like   , but in the  . monad. This does NOT track the contents of ; use   in that case. Run a   IO action. Like   , but in the   monad. Like findFileWithExtension , but in the   monad. Like  findFirstFile , but in the   monad. Utility to match a file glob against the file system, starting from a given root directory. The results are all relative to the given root.Since this operates in the  5 monad, it also monitors the given glob for changes. Monitor a directory as in  if it currently exists or as  if it does not. #Use this within the body action of   to declare that the action depends on the given files. This can be based on what the action actually did. It is these files that will be checked for changes next time   is called for that  .Relative paths are interpreted as relative to an implicit root, ultimately passed in to  . Monitor a single file Monitor a file if it exists; otherwise check for when it gets created. This is a bit better for recompilation avoidance because sometimes users give bad package metadata, and we don't want to repeatedly rebuild in this case (which we would if we need'ed a non-existent file). Like   meets mapConcurrently: For when we want multiple actions that need to do be re-run-if-changed asynchronously. The function returns when all values have finished computing. -This captures the standard use pattern for a  : given a monitor, an action and the input value the action depends on, either re-run the action to get its output, or if the value and files the action depends on have not changed then return a previously cached action result.The result is still in the   monad, so these can be nested. Do not share  s between different uses of  . Run a   IO action. A monad layered on top of  to help with re-running actions when the input files and values they depend on change. The crucial operations are   and  . Run a   IO action.4 "!    4 !"     !   *1 #(None &'( Clone a single source repo into a fresh directory, using a configured VCS.This is for making a new copy, not synchronising an existing copy. It will fail if the destination directory already exists.Make sure to validate the  SourceRepo using   first. 3The set of all supported VCS drivers, organised by . Synchronise a set of  SourceRepos referring to the same repository with corresponding local directories. The local directories may or may not already exist.The  SourceRepo' values used in a single invocation of  , or used across a series of invocations with any local directory must refer to the same repository. That means it must be the same location but they can differ in the branch, or tag or subdir.%The reason to allow multiple related  SourceRepos is to allow for the network or storage to be shared between different checkouts of the repo. For example if a single repo contains multiple packages in different subdirs and in some project it may make sense to use a different state of the repo for one subdir compared to another. Validates that the  SourceRepo specifies a location URI and a repository type that is supported by a VCS driver.| It also returns the  & driver we should use to work with it. As   but for a bunch of  SourceRepo6s, and return things in a convenient form to pass to  , or to report problems. VCS driver for Bazaar. VCS driver for Darcs. VCS driver for Git. VCS driver for Mercurial. ?VCS driver for Pijul. Documentation for Pijul can be found at *https://pijul.org/manual/introduction.html2020-04-09 Oleg:As far as I understand pijul, there are branches and "tags" in pijul, but there aren't a "commit hash" identifying an arbitrary state.One can create `a pijul tag`, which will make a patch hash, which depends on everything currently in the repository. I guess if you try to apply that patch, you'll be forced to apply all the dependencies too. In other words, there are no named tags.It's not clear to me whether there is an option to "apply this patch *and* all of its dependencies". And relatedly, whether how to make sure that there are no other patches applied.&With branches it's easier, as you can pull and checkout them, and they seem to be similar enough. Yet, pijul documentations says Note that the purpose of branches in Pijul is quite different from Git,since Git's "feature branches" can usually be implemented by just patches.I guess it means that indeed instead of creating a branch and making PR in GitHub workflow, you'd just create a patch and offer it. You can do that with git too. Push (a branch with) commit to remote and ask other to cherry-pick that commit. Yet, in git identity of commit changes when it applied to other trees, where patches in pijul have will continue to have the same hash.Unfortunately pijul doesn't talk about conflict resolution. It seems that you get something like:&% pijul status On branch mergeUnresolved conflicts: (fix conflicts and record the resolution with "pijul record ...")foo% cat foo first line >> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> branch BBB ================================ branch AAA <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< last line=And then the `pijul dependencies` would draw you a graph like----> foo on branch B -----> resolve conflict Initial patch----> foo on branch A ----->Which is seems reasonable.So currently, pijul support is very experimental, and most likely won't work, even the basics are in place. Tests are also written but disabled, as the branching model differs from git& one, for which tests are written. VCS driver for Subversion. ;A driver for a version control system, e.g. git, darcs etc. .The vcs program itself. This is used at type + and *. *The type of repository this driver is for. The program invocation(s) to get/clone a repository into a fresh local directory. 8The program invocation(s) to synchronise a whole set of related repositories with corresponding local directories. Also returns the files that the command depends on, for change monitoring. Extra prog paths Extra prog paths *+  +*   HNone Which   values indicate we'll have to do some build work of some sort. In particular we use this as part of checking if any of a package's deps have changed. This is primarily here for debugging. It's not actually used anywhere. ?Information arising from the failure to build a single package. 4Detail on the reason that a package failed to build. A summary of the outcome for building a single package: either success or failure. >A summary of the outcome for building a whole set of packages. The dependencies of this package have been (re)built so the build phase needs to be rerun. Although we're not going to build any additional targets as a whole, we're going to build some part of a component or run a repl or any other action that does not result in additional persistent artifacts. An important special case is that no files have changed but the set of components the user asked to build. has changed. We track the set of components  we have built, which of course only grows (until some other change resets it).The Set  is the set of components we have built previously. When we update the monitor we take the union of the ones we have built previously with the ones the user has asked for this time and save those. See updatePackageBuildFileMonitor. Changes in files within the package (or first run or corrupt cache) Information arising from successfully building a single package. The build status for an individual package is the state that the package is in prior to initiating a (re)build.#This should not be confused with a   which is the result after! successfully building a package.It serves two purposes:For dry-run output, it lets us explain to the user if and why a package is going to be (re)built.It tell us what step to start or resume building from, and carries enough information for us to be able to do so. The package has not been downloaded yet, so it will have to be downloaded, unpacked and built. The package is in the % state, so does not need building. The package is in the % state, so does not need building. The package exists in a local dir already, and just needs building or rebuilding. So this can only happen for BuildInplaceOnly style packages. The package has not been unpacked yet, so it will have to be unpacked and built. The package exists in a local dir already, and is fully up to date. So this package can be put into the + state and it does not need to be built. The   of every package in the ElaboratedInstallPlan.This is used as the result of the dry-run of building an install plan. For a package that is going to be built or rebuilt, the state it's in now.So again, this tells us why a package needs to be rebuilt and what build phases need to be run. The   gives us details like which file changed, which is mainly for high verbosity debug output. The configuration has not changed but the build phase needs to be rerun. We record the reason the (re)build is needed.The optional registration info here tells us if we've registered the package already, or if we still need to do that after building.  Just Nothing indicates that we know that no registration is necessary (e.g., executable.) The package configuration changed, so the configure and build phases needs to be (re)run.. .          (c) David Himmelstrup 2005, Bjorn Bringert 2007 Duncan Coutts 2008BSD-likecabal-devel@gmail.com provisionalportableNone Supply defaults for packages without explicit Setup dependenciesNote: It's important to apply addDefaultSetupDepends after  '. Otherwise, the packages inserted by  1 won't have upper bounds in dependencies relaxed.  Variant of   which sets an upper bound on  setup.Cabal labeled with  . If a package has a custom setup then we need to add a setup-depends on Cabal. Add an a lower bound setup.Cabal >= 3.13 labeled with  4A basic solver policy on which all others are built. Dual of  Remove upper bounds in dependencies using the policy specified by the  argument (allsomenone).Note: It's important to apply   after  '. Otherwise, the packages inserted by  1 won't have upper bounds in dependencies relaxed. Run the dependency solver.Since this is potentially an expensive operation, the result is wrapped in a a  structure that can be unfolded to provide progress information, logging messages and the final result or an error. A simplistic method of resolving a list of target package names to available packages.Specifically, it does not consider package dependencies at all. Unlike  , no attempt is made to ensure that the selected packages have dependencies that are satisfiable or consistent with each other.It is suitable for tasks such as selecting packages to download for user inspection. It is not suitable for selecting packages to install.Note: if no installed package index is available, it is OK to pass . It simply means preferences for installed packages will be ignored.The policy used by all the standard commands, install, fetch, freeze etc (but not the v2-build and related commands).It extends the   with a policy on setup deps.The set of parameters to the dependency resolver. These parameters are relatively low level but many kinds of high level policies can be implemented in terms of adjustments to the parameters.8A package selection preference for a particular package.Preferences are soft constraints that the dependency resolver should try to respect where possible. It is not specified if preferences on some packages are more important than others.=If we prefer versions of packages that are already installed.If we would prefer to enable these optional stanzas (i.e. test suites and/or benchmarks)-A suggested constraint on the version number. A package name which cannot be resolved to a specific package. Also gives the constraint on the version and whether there was a constraint on the package being installed. ;Whether to allow base and its dependencies to be installed. Whether to only allow explicitly constrained packages plus goals or to allow any package. Whether or not to solve for dependencies on executables. This should be true, except in the legacy code path where we can't tell if an executable has been installed or not, so we shouldn't solve for them. See #3875. ;Function to override the solver's goal-ordering heuristics.  Errors for  . "Common internal implementation of  / A ConfiguredPackage is valid if the flag assignment is total and if in the configuration given by the flag assignment, all the package dependencies are satisfied by the specified packages. Some packages are specific to a given compiler version and should never be reinstalled. %Give an interpretation to the global PackagesPreference as specific per-package . The set of non-reinstallable packages includes those which cannot be rebuilt using a GHC installation and Hackage-published source distribution. There are a few reasons why this might be true:3the package overrides its unit ID (e.g. with ghc's  -this-unit-id flag), which can result in multiple indistinguishable packages (having potentially different ABIs) with the same unit ID.the package contains definitions of wired-in declarations which tie it to a particular compiler (e.g. we can't build link against  base-4.18.0.0 using GHC 9.6.1).the package does not have a complete (that is, buildable) source distribution. For instance, some packages provided by GHC rely on files outside of the source tree generated by GHC's build system. 1Relax the dependencies of this package if needed.Helper function used by  Internal helper for  Provide a textual representation of a package preference for debugging purposes. Make an install plan from the output of the dep resolver. It checks that the plan is valid, or it's an error in the dep resolver.9 9       !INone#List all source files of a given add-source dependency. Exits with error if something is wrong (e.g. there is no .cabal file in the given directory).Used in sandbox and projectbuilding. TODO: when sandboxes are removed, move to ProjectBuilding.-Create a tarball for a package in a directory read in GPDdirectory containing that GPDresulting sdist tarballJcabal-devel@haskell.orgportableNone3Run a given executable.Return the executable to run and any extra arguments that should be forwarded to it. Die in case of error.K(c) Lennart Kolmodin 2008BSD-likekolmodin@haskell.org provisionalportableNone3,Checks a package for common errors. Returns True. if the package is fit to upload to Hackage, False otherwise. Note: must be called with the CWD set to the directory containing the '.cabal' file.(List of check-ids in String form (e.g. invalid-path-win ) to ignore.L"(c) Duncan Coutts 2012, 2015, 2016BSD-likeduncan@community.haskell.orgNone &'(? &Parse a bunch of command line args as s, failing with an error if any are unrecognised. The possible target selectors are based on the available packages (and their locations).Throw an exception with a formatted message if there are any problems. Render a  back as the external syntax. This is mainly for error messages.Qualification levels. Given the filepath src/F, executable component A, and package foo: src/F foo:src F | A:srcF  foo:A:src F | exe:A:srcF pkg:foo:exe:A:file:src/FEither the component as a whole or detail about a file or module target within a component.A specific file within a component. Note that this does not carry the file extension.%A specific module within a component.The component as a whole Does this  selector arise from syntax referring to a package in the current directory (e.g. tests or no giving no explicit target at all) or does it come from syntax referring to a package name or location.A target selector is expression selecting a set of components (as targets for a actions like build, run, test etc). A target selector corresponds to the user syntax for referring to targets on the command line.From the users point of view a target can be many things: packages, dirs, component names, files etc. Internally we consider a target to be a specific component (or module/file within a component), and all the users' notions of targets are just different ways of referring to these component targets.So target selectors are expressions in the sense that they are interpreted to refer to one or more components. For example a  gets interpreted differently by different commands to refer to all or a subset of components within the package.&The syntax has lots of optional parts: [ package name | package dir | package .cabal file ] [ [lib:|exe:] component name ] [ module name | source file ]All packages, or all components of a particular kind in all packages.5A specific component in a package within the project.A component in a package, but where it cannot be verified that the package has such a component, or because the package is itself not known.One (or more) packages as a whole, or all the components of a particular kind within the package(s).These are always packages that are local to the project. In the case that there is more than one, they all share the same directory location./A package specified by name. This may refer to extra-packages from the  cabal.project file, or a dependency of a known project package or could refer to a package from a hackage archive. It needs further context to resolve to a specific package.*The various ways that trying to resolve a  to a  can fail. expected thing(actually got)  ([in thing., no such thing, actually got, alternatives)]bool that flags when it is acceptable to suggest "all" as a target2Syntax error when trying to parse a target string.The outline parse of a target selector. It takes one of the forms: 1str1 str1:str2 str1:str2:str3 str1:str2:str3:str4 Combine two matchers. Exact matches are used over inexact matches but if we have multiple exact, or inexact then the we collect all the ambiguous matches.'This operator is associative, has unit  and is also commutative. Matches an unknown thing e.g. parses as a package name without it being a specific known package Matches a known thing inexactly e.g. matches a known package case insensitively Exactly matches a known thing, e.g. matches a known package case sensitively A matcher embodies a way to match some input as being some recognised value. In particular it deals with multiple and ambiguous matches.&There are various matcher primitives ( ,  ), ways to combine matchers ( ,  ;) and finally we can run a matcher against an input using  . The kind of match, inexact or exact. We keep track of this so we can prefer exact over inexact matches. The 1 here is important: we try to maximise this, so   is the top value and   the bottom. Syntax for the : the matcher and renderer 6A primitive matcher that looks up a value in a finite  . The value must match exactly. 6A primitive matcher that looks up a value in a finite . It checks for an exact or inexact match. We get an inexact match if the match is not exact, but the canonical forms match. It takes a canonicalisation function for this purpose.So for example if we used string case fold as the canonicalisation function, then we would get case insensitive matching (but it will still report an exact match when the case matches too). )Combine two matchers. This is similar to   with the difference that an exact match from the left matcher shadows any exact match on the right. Inexact matches are still collected however.'This operator is associative, has unit  and is not commutative. Given a matcher and a key to look up, use the matcher to find all the possible matches. There may be   , a single   match or you may have an  " match with several possibilities. Compare two filepaths for equality using DirActions' canonicalizePath to normalize AND canonicalize filepaths before comparison. )Lift a list of matches to an exact match. )Lift a list of matches to an exact match. Make a  given an   and knowing the . We also need the   to distinguish the package's primary library from named private libraries. Parse a bunch of 's (purely without throwing exceptions). Given a bunch of user-specified targets, try to resolve what it is they refer to. 3Syntax: "all" to select all packages in the project cabal build all Syntax: component cabal build foo Syntax: file name $cabal build Data/Foo.hs bar/Main.hsc Syntax: filter cabal build tests Syntax: module cabal build Data.Foo #Syntax: package (name, dir or file) 3cabal build foo cabal build ../bar ../bar/bar.cabal Syntax: all : filer cabal build all:tests Syntax: component : filename cabal build foo:Data/Foo.hs Syntax: component : module cabal build foo:Data.Foo Syntax: namespace : component cabal build lib:foo exe:foo  Syntax: :all cabal build :all Syntax: pkg : package name cabal build pkg:foo Syntax: package : component cabal build foo:foo cabal build ./foo:foo cabal build ./foo.cabal:foo Syntax: package : filename cabal build foo:Data/Foo.hs cabal build ./foo:Data/Foo.hs cabal build ./foo.cabal:Data/Foo.hs Syntax: package : filer cabal build foo:tests!Syntax: package : module cabal build foo:Data.Foo cabal build ./foo:Data.Foo cabal build ./foo.cabal:Data.Foo!(Syntax: namespace : component : filename cabal build lib:foo:Data/Foo.hs!&Syntax: namespace : component : module cabal build lib:foo:Data.Foo!Syntax: :all : filter cabal build :all:tests!Syntax: :pkg : package name cabal build :pkg:foo!&Syntax: package : component : filename cabal build foo:foo:Data/Foo.hs cabal build foo/:foo:Data/Foo.hs cabal build foo.cabal:foo:Data/Foo.hs!$Syntax: package : component : module cabal build foo:foo:Data.Foo cabal build foo/:foo:Data.Foo cabal build foo.cabal:foo:Data.Foo!'Syntax: package : namespace : component cabal build foo:lib:foo cabal build foo/:lib:foo cabal build foo.cabal:lib:foo!.Syntax: :pkg : package : namespace : component cabal build :pkg:foo:lib:foo!Syntax: :pkg : package : namespace : component : file : filename -cabal build :pkg:foo:lib:foo:file:Data/Foo.hs!Syntax: :pkg : package : namespace : component : module : module ,cabal build :pkg:foo:lib:foo:module:Data.Foo!All the forms of syntax for .This parameter is used when there are ambiguous selectors. If it is , then we attempt to resolve ambiguity by applying it, since otherwise there is no way to allow contextually valid yet syntactically ambiguous selectors. (#4676, #5461)88.    #       ###             'MNone NNoneto view as a FieldDescr, we sort the list of interfaces (Req > Bool > Choice > Opt) and consider only the first one.8cabal-devel@haskell.orgportableNone( Add fields to a field list.Add a new field which is identical to an existing field but with a different name.Reuse a command line ! as a config file .Reuse a bunch of command line !s as config file s.Given a collection of field descriptions, keep only a given list of them, identified by name.TODO: This makes it easy to footgun by providing a non-existent field name.To help construction of config file descriptions in a modular way it is useful to define fields and sections on local types and then hoist them into the parent types when combining them in bigger descriptions.)This is essentially a lens operation for ' to help embedding one inside another.Apply a name mangling function to the field names of all the field descriptions. The typical use case is to apply some prefix.Parse a string in the config file syntax into a value, based on a description of the configuration file in terms of its fields and sections.It accumulates the result on top of a given initial (typically empty) value.Parse a bunch of semi-parsed s according to a set of field descriptions. It accumulates the result on top of a given initial value.This only covers the case of flat configuration without subsections. See also . Much like  but it also allows subsections. The permitted subsections are given by a list of s.This is a customised version of the functions from Distribution.Deprecated.ParseUtils that also optionally print default values for empty fields as comments. Much like  but also pretty prints any subsections. Subsection are only shown if they are non-empty.Note that unlike , at present it does not support printing default values. If needed, adding such support would be quite reasonable.Pretty print a section.Since  does not cover subsections you can use this to add them. Or alternatively use a  and use .Render a value in the config file syntax, based on a description of the configuration file in terms of its fields and sections. FieldGrammar section descriptionThe description of a section in a config file. It can contain both fields and optionally further subsections. See also .!Given a collection of field descriptions, get a field with a given name.!2TODO: subsections TODO: this should simply build  PrettyField!Unlike 6 which has to be called directly, this gets used via % and so does not need to be exported.The existing field name.The new field name.fieldlegacy sectionsFieldGrammar sections! section name parameter##Data file location, and package version and installation directories. Safe-Inferred!The package version.!If the argument is a filename, the result is the name of a corresponding file on the system on which the program is running, if the file were listed in the  data-files field of the package's Cabal package description file. No check is performed that the given filename is listed in that field.!3The location of the directory specified by Cabal's --bindir option (where executables that the user might invoke are installed). This can be overridden at runtime using the environment variable cabal_install_bindir.!3The location of the directory specified by Cabal's --libdir option (where object libraries are installed). This can be overridden at runtime using the environment variable cabal_install_libdir.!3The location of the directory specified by Cabal's  --dynlibdir option (where dynamic libraries are installed). This can be overridden at runtime using the environment variable cabal_install_dynlibdir.!3The location of the directory specified by Cabal's  --datadir option (where architecture-independent data files are installed). This can be overridden at runtime using the environment variable cabal_install_datadir.!3The location of the directory specified by Cabal's  --libexedir option (where executables that are not expected to be invoked directly by the user are installed). This can be overridden at runtime using the environment variable cabal_install_libexedir.!3The location of the directory specified by Cabal's  --sysconfdir option (where configuration files are installed). This can be overridden at runtime using the environment variable cabal_install_sysconfdir.!!!!!!!!ONone`cabal-install` Git information. Only filled in if built in a Git tree in developmnent mode and Template Haskell is available.>This value determines the output of `cabal-install --version`.PNoneb $Utility function for legacy support.If the remote repo is accessed over HTTPS, ensure that the transport supports HTTPS.If the URI scheme is HTTPS, ensure the transport supports HTTPS.GET a URI, with an optional ETag (to do a conditional fetch), write the resource to the given file and return the HTTP status code, and optional ETag.(POST a resource to a URI, with optional 7 and return the HTTP status code and any redirect URL.POST a file resource to a URI using multipart/form-data encoding, with optional 7 and return the HTTP status code and any error string.,PUT a file resource to a URI, with optional , extra headers and return the HTTP status code and any error string.Whether this transport implementation was specifically chosen by the user via configuration, or whether it was automatically selected. Strictly speaking this is not a property of the transport itself but about how it was chosen. Nevertheless it's convenient to keep here.3Whether this transport supports https or just http.!%already downloaded and sha256 matches!#already downloaded and we have etag!'needs download with optional hash check!If the URI scheme is HTTPS, ensure the transport supports HTTPS. If not, fail with the given error.What to downloadWhere to put it  None9"Translate from hackage-security's  to cabal-install's NOTE: The match between these two APIs is currently not perfect:0We don't get any response headers back from the , so we don't know if the server supports range requests. For now we optimistically assume that it does.The  wants to know where to place the resulting file, whereas the  expects an  action which streams the download; the security library then makes sure that the file gets written to a location which is suitable (in particular, to a temporary file in the directory where the file needs to end up, so that it can "finalize" the file simply by doing  renameFile). Right now we write the file to a temporary file in the system temp directory here and then read it again to pass it to the security library; this is a problem for two reasons: it is a source of inefficiency; and it means that the security library cannot insist on a minimum download rate (potential security attack). Fixing it however would require changing the .!Internal generalization of  and ! &* &QNone &'?) :Flags that apply at the top level, not to any sub-command.Ignore security expiry datesIntegrate with NixExtra program path used for packagedb lookups in a global context (i.e. for http transports)Available Hackage servers.Access to repositoriesGet the HTTP transportThe transport will be initialized on the first call to this function.NOTE: It is important that we don't eagerly initialize the transport. Initializing the transport is not free, and especially in contexts where we don't know a priori whether or not we need the transport (for instance when using cabal in "nix mode") incurring the overhead of transport initialization on _every_ invocation (eg  cabal build) is undesirable.7Should we ignore expiry times (when checking security)?All user-specified repositories!Get the (initialized) secure repo(the  type itself is stateless and must remain so, because it must be serializable)!Wrapper around  Repository, hiding the type argument! Initialize the given secure repoThe security library has its own concept of a "local" repository, distinct from  cabal-install's; these are secure repositories, but live in the local file system. We use the convention that these repositories are identified by URLs of the form file:pathtolocalrepo.!+Initialize the provided secure repositoriesAssumed invariant: # should be set for all these repos.! Secure repo ( assumed) Cache dirCallback   R(c) David Himmelstrup 2005 Duncan Coutts 2011BSD-likecabal-devel@gmail.com provisionalportableNone&'T Fork off an async action to download the given packages (by location).The downloads are initiated in order, so you can arrange for packages that will likely be needed sooner to be earlier in the list.The body action is passed a map from those packages (identified by their location) to a completion var for that package. So the body action should lookup the location and use  to get the result.Synchronous exceptions raised by the download actions are delivered via .Checks if the package has already been fetched (or does not need fetching) and if so returns evidence in the form of a & with a resolved local file location.Like  but for the specific case of a .&Downloads an index file to [config-dirpackagesserv-id] without hackage-security. You probably don't want to call this directly; use  updateRepo instead.,Fetch a package if we don't have it already.1Fetch a repo package if we don't have it already.Returns True if the package has already been fetched or does not need fetching.3Expect to find a download in progress in the given  and wait on it to finish.If the download failed with an exception then this will be thrown.Note: This function is supposed to be idempotent, as our install plans can now use the same tarball for many builds, e.g. different components and/or qualified goals, and these all go through the download phase so we end up using ( twice on the same package. C.f. #4461.!Generate the full path to the locally cached copy of the tarball for a given PackageIdentifier.!Generate the full path to the directory where the local cached copy of the tarball for a given PackageIdentifier is stored.!4Generate the URI of the tarball for a given package.  S(c) Duncan Coutts 2011BSD-likeduncan@community.haskell.orgNone<=>? Given a package name and a list of matching names, figure out which one it might be referring to. If there is an exact case-sensitive match then that's ok (i.e. returned via !). If it matches just one package case-insensitively or if it matches multiple packages case-insensitively, in that case the result is !.Note: Before cabal 2.2, when only a single package matched case-insensitively it would be considered !.Users are allowed to give package names case-insensitively, so we must disambiguate named package references.Given a user-specified target, expand it to a bunch of package targets (each of which refers to only one package).2Fetch any remote targets so that they can be read.Given a package target that has been fetched, read the .cabal file.This only affects targets given by location, named targets are unaffected.Report problems to the user. That is, if there are any problems then raise an exception.Given a bunch of user-specified targets, try to resolve what it is they refer to. They can either be specific packages (local dirs, tarballs etc) or they can be named packages (with or without version info).An intermediate between a  and a resolved  . Unlike a , a ! refers only to a single package.A package identified by name, but case insensitively, so it needs to be resolved to the right case-sensitive name. Version of 0 that the user can specify on the command line. Version of !. that a user may specify on the command line.cabal install http://code.haskell.org/~user/foo/foo-0.9.tar.gz**  $    $  "       # ( "&1(c) David Himmelstrup 2005BSD-likelemmih@gmail.com provisionalportableNone?IOptions for the bench command.Not to be confused with the benchmarkOptions field of the ! record!>Configure the compiler, but reduce verbosity during this step.'Get the package database settings from 5, accounting for  --package-db and --user flags. Given some ! for the version of Cabal that  cabal-install$ was built with, and a target older ! of Cabal that we want to pass these flags to, convert the flags into a form that will be accepted by the older Setup script. Generally speaking, this just means filtering out flags that the old Cabal library doesn't understand, but in some cases it may also mean "emulating" a feature using some more legacy flags. Given some v for the version of Cabal that  cabal-install$ was built with, and a target older ! of Cabal that we want to pass these flags to, convert the flags into a form that will be accepted by the older Setup script. Generally speaking, this just means filtering out flags that the old Cabal library doesn't understand, but in some cases it may also mean "emulating" a feature using some more legacy flags. Given some 5 for the version of Cabal that cabal-install was built with, and a target older ! of Cabal that we want to pass these flags to, convert the flags into a form that will be accepted by the older Setup script. Generally speaking, this just means filtering out flags that the old Cabal library doesn't understand, but in some cases it may also mean "emulating" a feature using some more legacy flags. Given some ! for the version of Cabal that  cabal-install$ was built with, and a target older ! of Cabal that we want to pass these flags to, convert the flags into a form that will be accepted by the older Setup script. Generally speaking, this just means filtering out flags that the old Cabal library doesn't understand, but in some cases it may also mean "emulating" a feature using some more legacy flags. Given some ! for the version of Cabal that  cabal-install$ was built with, and a target older ! of Cabal that we want to pass these flags to, convert the flags into a form that will be accepted by the older Setup script. Generally speaking, this just means filtering out flags that the old Cabal library doesn't understand, but in some cases it may also mean "emulating" a feature using some more legacy flags. Given some ! for the version of Cabal that  cabal-install$ was built with, and a target older ! of Cabal that we want to pass these flags to, convert the flags into a form that will be accepted by the older Setup script. Generally speaking, this just means filtering out flags that the old Cabal library doesn't understand, but in some cases it may also mean "emulating" a feature using some more legacy flags. Given some ! for the version of Cabal that  cabal-install$ was built with, and a target older ! of Cabal that we want to pass these flags to, convert the flags into a form that will be accepted by the older Setup script. Generally speaking, this just means filtering out flags that the old Cabal library doesn't understand, but in some cases it may also mean "emulating" a feature using some more legacy flags. Given some ! for the version of Cabal that cabal-install was built with, and a target older ! of Cabal that we want to pass these flags to, convert the flags into a form that will be accepted by the older Setup script. Generally speaking, this just means filtering out flags that the old Cabal library doesn't understand, but in some cases it may also mean "emulating" a feature using some more legacy flags.cabal configure takes some extra flags beyond runghc Setup configureInstall takes the same flags as configure along with a few extras.9Is this a candidate package or a package to be published?!Notes for the command get.!!List of lines describing command get.!Either "get" or "unpack".E.g. "cabal".List of lines.vwxyz{|}~,-./012356789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstu ,-./012356789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstu6vwxyz{|}~w #               #  !                # TNone  . .+ + > >UNoneV(c) Maciek Makowski 2015BSD-likecabal-devel@haskell.org provisionalportableNoneProduces a manual page with troff markup.!path, description!=A list of files that should be documented in the manual page.W(c) Duncan Coutts 2008BSD-likecabal-devel@haskell.org provisionalportableNone&'(\We would like by default to install binaries into some location that is on the user's PATH. For per-user installations on Unix systems that basically means the ~bin- directory. On the majority of platforms the ~bin directory will be on the user's PATH. However some people are a bit nervous about letting a package manager install programs into ~bin.A compromise solution is that instead of installing binaries directly into ~bin4, we could install them in a private location under ~.cabalbin and then create symlinks in ~bin. We can be careful when setting up the symlinks that we do not overwrite any binary that the user installed. We can check if it was a symlink we made because it would point to the private dir where we install our binaries. This means we can install normally without worrying and in a later phase set up symlinks, and if that fails then we report it to the user, but even in this case the package is still in an OK installed state.This is an optional feature that users can choose to use or not. It is controlled from the config file. Of course it only works on POSIX systems with symlinks so is not available to Windows users.Symlink binary.The paths are take in pieces, so we can make relative link when possible. True) if creating the symlink was successful. False if there was another file there already that we did not own. Other errors like permission errors just propagate as exceptions.Can we symlink a binary?True if creating the symlink would be succeed, being optimistic that the user will agree if prompted to overwrite./Try to make a symlink in a temporary directory.6If this works, we can try to symlink: even on Windows.A record needed to either check if a symlink is possible or to create a symlink. Also used if copying instead of symlinking.,Whether to force overwrite an existing file.-The canonical path of the private bin dir eg homeuser.cabalbin.9The name of the executable to in the private bin dir, eg foo-1.0.,The canonical path of the public bin dir eg homeuser/bin.;The name of the executable to go in the public bin dir, eg foo.!0The file doesn't exist so we can make a symlink.!A symlink already exists, though it is ours. We'll have to delete it first before we make a new symlink.!A file already exists and it is not one of our existing symlinks (either because it is not a symlink or because it points somewhere other than our managed space).!Take two canonical paths and produce a relative path to get from the first to the second, even if it means adding .. path components.!After checking if a target is writeable given the overwrite policy, dispatch to an appropriate action; *  onMissing! if the target doesn't exist *  onOverwrite= if the target exists and we are allowed to overwrite it * onNever if the target exists and we are never allowed to overwrite it * onPrompt if the target exists and we are allowed to overwrite after prompting!Check a file path of a symlink that we would like to create to see if it is OK. For it to be OK to overwrite it must either not already exist yet or be a symlink to our target (in which case we can assume ownership).!Missing actionOverwrite action Never action Prompt action!The file path of the symlink to the private binary that we would like to create/The canonical path of the private binary. Use  to make this.   None?$Resolved configuration for things that affect how we build and not the value of the things we build. The idea is that this is easier to use than the raw configuration because in the raw configuration everything is optional (monoidial). In the 6 every field is filled in, if only with the defaults.Use resolveBuildTimeSettings to make one from the project config (by applying defaults etc).Newtype wrapper for  that provides a  instance that takes the last value rather than the first value for overlapping keys.Newtype wrapper for  that provides a  instance that :s values of overlapping keys rather than taking the first.Project configuration that is specific to each package, that is where we can in principle have different values for different packages in the same project.>This type corresponds directly to what can be written in the  cabal.project file. Other sources of configuration can also be injected into this type, such as the user-wide config file and the command line of cabal configure or  cabal build.Since it corresponds to the external project file it is an instance of  and all the fields can be empty. This also means there has to be a step where we resolve configuration. At a minimum resolving means applying defaults but it can also mean merging information from multiple sources. For example for package-specific configuration the project file can specify configuration that applies to all local packages, and then additional configuration for a specific package.Future directions: multiple profiles, conditionals. If we add these features then the gap between configuration as written in the config file and resolved settings we actually use will become even bigger.Configuration to be applied to *all* packages, whether named in `cabal.project` or not.Configuration to be applied to *local* packages; i.e., any packages which are explicitly named in `cabal.project`.Packages in this project, including local dirs, local .cabal files local and remote tarballs. When these are file globs, they must match at least one package.3Packages in this project from hackage repositories.Like projectConfigPackageGlobs but optional in the sense that file globs are allowed to match nothing. The primary use case for this is to be able to say optional-packages: */ to automagically pick up deps that we unpack locally without erroring when there aren't any.9Packages in this project from remote source repositories.9That part of the project configuration that only affects how we build and not the value of the things we build. This means this information does not need to be tracked for changes since it does not affect the outcome.Specifies the provenance of project configuration, whether defaults were used or if the configuration was read from an explicit file path.The path the project configuration was explicitly read from. | The configuration was explicitly read from the specified !.The configuration is implicit due to no explicit configuration being found. See b/ for how implicit configuration is determined.Project configuration that is shared between all packages in the project. In particular this includes configuration that affects the solver.Available Hackage servers.The project configuration is configuration that is parsed but parse configuration may import more configuration. Holds the unparsed contents of an imported file contributing to the project config.Resolved configuration for the solver. The idea is that this is easier to use than the raw configuration because in the raw configuration everything is optional (monoidial). In the 6 every field is filled in, if only with the defaults.Use resolveSolverSettings to make one from the project config (by applying defaults etc).For all local packagesAvailable Hackage servers.#$%&'(%&'(#$7)/)/   ( ' $          ' '# ' * 9 <  !  ! ' * $ '   " " + , ( #X(c) David Himmelstrup 2005BSD-likelemmih@gmail.com provisionalportableNone3? These are the absolute basic defaults. The fields that must be initialised. When we load the config from the file we layer the loaded values over these ones, so any missing fields in the file take their values from here.These are the default values that get used in Cabal if a no value is given. We use these here to include in comments when we write out the initial config file so that the user can see what default value they are overriding.All config file fields.Returns the config file path, without checking that the file exists. The order of precedence is: input flag, CABAL_CONFIG, default location.Fields for the haddock section.This is the initial configuration that we write out to the config file if the file does not exist (or the config we use if the file cannot be read for some other reason). When the config gets loaded it gets layered on top of  so we do not need to include it into the initial values we save into the config file.'Fields for the 'install-dirs' sections.Loads the main configuration, and applies additional defaults to give the effective configuration. To loads just what is actually in the config file, use !.Get the differences (as a pseudo code diff) between the user's config file and the one that cabal would generate if it didn't exist.Update the user's config file keeping the user's customizations.1Fields for the 'program-default-options' section.+Fields for the 'program-locations' section.!Provenance of the config file.!The current hackage.haskell.org repo root keys that we ship with cabal.!The required threshold of root key signatures for hackage.haskell.org!)The default prefix used for installation.!The default behaviour of cabal-install is to use the XDG directory standard. However, if  CABAL_DIR is set, we instead use that directory as a single store for everything cabal-related, like the old ~/.cabal4 behaviour. Also, for backwards compatibility, if ~/.cabal' exists we treat that as equivalent to  CABAL_DIR; being set. This function abstracts that decision-making.!Fields for the  section.!Like  but does not apply any additional defaults, it just loads what is actually in the config file. This is thus suitable for comparing or editing a config file, but not suitable for using as the effective configuration.!If  CABAL_DIR is set, return Just its value. Otherwise, if ~/.cabal exists and $XDG_CONFIG_HOMEcabalconfig does not exist, return Just "~/.cabal". Otherwise, return Nothing. If this function returns Nothing, then it implies that we are not using a single directory for everything, but instead use XDG paths. Fundamentally, this function is used to implement transparent backwards compatibility with pre-XDG versions of cabal-install.!Issue a warning if both $XDG_CONFIG_HOMEcabalconfig and ~/.cabal exists.--   Ycabal-devel@haskell.orgportableNone3?y  Is there a 'cabal.config' in this directory?Same as userPackageEnvironmentFile, but returns a SavedConfig."Read the package environment file.%Pretty-print the package environment.Pretty-print the package environment with default values for empty fields commented out (just like the default Cabal config file).Optional package environment file that can be used to customize the default settings. Created by the user.(Type of the current package environment.'~.config cabal/config''./cabal.config'!Accumulator type for  parseSections.!;Descriptions of all fields in the package environment file.!#Parse the package environment file.!Load the user package environment if it exists (the optional "cabal.config" file). If it does not exist locally, attempt to load an optional global one.    # &ZNone&'()13? =Convert configuration from the cabal configure or  cabal build command line into a  value that can combined with configuration from other sources.At the moment this uses the legacy command line flag types. See  for an explanation.Convert from the types currently used for the user-wide Cabal config file into the  type.Only a subset of the  can be represented in the user-wide config. In particular it does not include packages that are in the project, and it also doesn't support package-specific configuration (only configuration that applies to all packages).8Convert the project config from the legacy types to the  and associated types. See % for an explanation of the approach.This is a bit tricky since it has to cover globs which have embedded , chars. But we don't just want to parse strictly as a glob since we want to allow http urls which don't parse as globs, and possibly some system-dependent file paths. So we parse fairly liberally as a token, but we allow , inside matched {} braces.Parses a project from its root config file, typically cabal.project.We already have parsers/pretty-printers for almost all the fields in the project config file, but they're in terms of the types used for the command line flags for Setup.hs or cabal commands. We don't want to redefine them all, at least not yet so for the moment we use the parsers at the old types and use conversion functions.Ultimately if/when this project-based approach becomes the default then we can redefine the parsers directly for the new types.ProjectConfigSkeleton is a tree of conditional blocks and imports wrapping a config. It can be finalized by providing the conditional resolution info and then resolving and downloading the imports!The root of the project configuration, typically cabal.project!The contents of the file to parse!The directory of the project configuration, typically the directory of cabal.project?The path of the file being parsed, either the root or an import!The contents of the file to parse  $ ' $ ' # &   [NoneThe action to perform inside a nix-shell. This is also the action that will be performed immediately if Nix is disabled.\None&' IMake the default  based on the project root dir and optional overrides for the location of the dist directory, the  cabal.project& file and the documentation directory.9The layout of the user-wide cabal directory, that is the ~/.cabal0 dir on unix, and equivalents on other systems.At the moment this is just a partial specification, but the idea is eventually to cover it all.The layout of the project state directory. Traditionally this has been called the dist directory.The directory under dist where we keep the build artifacts for a package we're building from a local directory. This uses a ! not just a  PackageName because technically we can have multiple instances of the same package in a solution (e.g. setup deps).The "dist" directory, which is the root of where cabal keeps all its state including the build artifacts from each package we build.The directory under dist where we download tarballs and source control repos to.3Is needed when `--haddock-output-dir` flag is used.The location for package-specific cache files (e.g. state used in incremental rebuilds).The location for project-wide cache files (e.g. state used in incremental rebuilds).The  cabal.project file and related like cabal.project.freeze. The parameter is for the extension, like "freeze", or "" for the main file.The root directory of the project. Many other files are relative to this location (e.g. the  cabal.project file)./The location that sdists are placed by default.The directory under dist where we put the unpacked sources of packages, in those cases where it makes sense to keep the build artifacts to reduce rebuild times.Information which can be used to construct the path to the build directory of a build. This is LESS fine-grained than what goes into the hashed InstalledPackageId, and for good reason: we don't want this path to change if the user, say, adds a dependency to their project.4Information about the root directory of the project.It can either be an implicit project root in the current dir if no  cabal.project file is found, or an explicit root if either the file is found or the project root directory was specified.An explicit project root. It contains the absolute project root dir and the relative  cabal.project file (or explicit override)An explicit, absolute project root dir and an explicit, absolute  cabal.project file.An implicit project root. It contains the absolute project root dir.&The layout of a cabal nix-style store.the project rootthe dist% directory (relative to package root)the documentation directory!Store directory. Must be absolute Log directory33 ]None&'(Check if a particular ! exists in the store. Return the !=s of all packages/components already installed in the store.Place a new entry into the store. See the concurrency strategy description for full details.In particular, it takes two actions: one to place files into a temporary location, and a second to perform any necessary registration. The first action is executed without any locks held (the temp dir is unique). The second action holds a lock that guarantees that only one cabal process is able to install this store entry. This means it is safe to register into the compiler package DB or do other similar actions.Note that if you need to use the registration information later then you must check the  and if its'UseExistingStoreEntry then you must read the existing registration information (unless your registration information is constructed fully deterministically).The outcome of : either the store entry was newly created or it existed already. The latter case happens if there was a race between two builds of the same store entry.Action to place files.Register action, if necessary. ^None  (?-"Extract the component name from a .Construct the environment needed for the data files to work. This consists of a separate  *_datadir0 variable for each inplace package in the plan."A user-friendly descriptor for an .The executable dependencies (i.e., the executables we depend on); these are the executables we must add to the PATH before we invoke the setup script.This returns the paths of all the executables we depend on; we must add these paths to PATH before invoking the setup script. (This is usually what you want, not ,, if you actually want to build something.)The cache files of all our inplace dependencies which, when updated, require us to rebuild. See #4202 for more details. Essentially, this is a list of filepaths that, if our dependencies get rebuilt, will themselves get updated.Note: the hash of these cache files gets built into the build cache ourselves, which means that we end up tracking transitive dependencies!Note: This tracks the "build" cache file, but not "registration" or "config" cache files. Why not? Arguably we should...Note: This is a bit of a hack, because it is not really the hashes of the SOURCES of our (transitive) dependencies that we should use to decide whether or not to rebuild, but the output BUILD PRODUCTS. The strategy we use here will never work if we want to implement unchanging rebuilds.The library dependencies (i.e., the libraries we depend on, NOT the dependencies of the library), NOT including setup dependencies. These are passed to the Setup script via  --dependency or --promised-dependency.Like !, but only returns dependencies on executables. (This coincides with .)Like !., but only returns dependencies on libraries.$User-friendly display string for an . The packagecomponent contains&is a library and so must be registeredThe setup dependencies (the library dependencies of the setup executable; note that it is not legal for setup scripts to have executable dependencies at the moment.)See !. This gives the unflattened version, which can be useful in some circumstances.Unambiguously render a ), e.g., to pass to a Cabal Setup script.Display the reason we had to fall-back to a per-package build instead of a per-component build.This is used in the install plan to indicate how the package will be built.The classic approach where the package is built, then the files installed into some location and the result registered in a package db.If the package came from a tarball then it's built in a temp dir and the results discarded.For : The package is built, but the files are not installed anywhere, rather the build dir is kept and the package is registered inplace.2Such packages can still subsequently be installed. Typically % packages will only depend on other  style packages and not on  ones.For : Built in-memory only using GHC multi-repl, they are not built or installed anywhere on disk. BuildInMemory packages can't be depended on by BuildAndInstall nor BuildInplaceOnly packages (because they don't exist on disk) but can depend on other BuildStyles.At the moment   is only used by the repl command.We use single constructor ; as for most cases inplace packages are handled similarly.Specific targets within a package or component to act on e.g. to build, haddock or open a repl.(Some extra metadata associated with an  which indicates that the "package" in question is actually a single component to be built. Arguably it would be clearer if there were an ADT which branched into package work items and component work items, but I've structured it this way to minimize change to the existing code (which I don't feel qualified to rewrite.)The name of the component to be built. Nothing if it's a setup dep.The executable dependencies of this component (including internal executables).The paths all our executable dependencies will be installed to once they are installed.The *external* library dependencies of this component. We pass this to the configure script. The Bool indicates whether the dependency is a promised dependency (True) or not (False).In a component prior to instantiation, this list specifies the !s which, after instantiation, are the actual dependencies of this package. Note that this does NOT include signature packages, which do not turn into real ordering dependencies when we instantiate. This is intended to be a purely temporary field, to carry some information to the instantiation phase. It's more precise than ;, and also stores information about internal dependencies.The UnitIds of the libraries (identifying elaborated packages/ components) that must be built before this project. This is used purely for ordering purposes. It can contain both references to definite and indefinite packages; an indefinite UnitId indicates that we must typecheck that indefinite package before we can build this one.The  pkg-config dependencies of the component=The name of the component to be built according to the solverAre we going to build and install this package to the store, or are we going to build it and register it locally.Another way of phrasing pkgStanzasAvailable.A total flag assignment for the package. TODO: Actually this can be per-component if we drop all flags that don't affect a component.>The original default flag assignment, used only for reporting.This is true if this is an indefinite package, or this is a package with no signatures. (Notably, it's not true for instantiated packages.) The motivation for this is if you ask to build  foo-indef, this probably means that you want to typecheck it, NOT that you want to rebuild all of the various instantiations of it.Is this package one of the ones specified by location in the project file? (As opposed to a dependency, or a named package pulled in)-Shape of the package/component, for Backpack.&Component/package specific informationThe hash of the source, e.g. the tarball. We don't have this for local source dir packages.The  of the originating packageWhere the package comes from, e.g. tarball, local dir etc. This is not the same as where it may be unpacked to for the build.The version of the Cabal command line interface that we are using for this package. This is typically the version of the Cabal lib that the Setup.hs is built against.TODO: We might want to turn this into a enum, yet different enum than CabalSpecVersion.One of four modes for how we build and interact with the Setup.hs script, based on whether it's a build-type Custom, with or without explicit deps and the cabal spec version the .cabal file needs.Which optional stanzas (ie testsuites, benchmarks) can be built. This means the solver produced a plan that has them available. This doesn't necessary mean we build them by default.Which optional stanzas the user explicitly asked to enable or to disable. This tells us which ones we build by default, and helps with error messages when the user asks to build something they explicitly disabled. TODO: The  here should be refined into an ADT with three cases: NotRequested, ExplicitlyRequested and ImplicitlyRequested. A stanza is explicitly requested if the user asked, for this *specific* package, that the stanza be enabled; it's implicitly requested if the user asked for all global packages to have this stanza enabled. The difference between an explicit and implicit request is error reporting behavior: if a user asks for tests to be enabled for a specific package that doesn't have any tests, we should warn them about it, but we shouldn't complain that a user enabled tests globally, and some local packages just happen not to have any tests. (But perhaps we should warn if ALL local packages don't have any tests.)The !4 which uniquely identifies this item in a build plan6The combination of an elaborated install plan plus a  contains all the details necessary to be able to execute the plan without having to make further policy decisions.It does not include dynamic elements such as resources (such as http connections).Components which depend (transitively) on an internally defined library. These are used by , to determine if a user-requested build is going to need a library registration$Dependencies on executable packages.)Paths where executable dependencies live.The exact dependencies (on other plan packages) The boolean value indicates whether the dependency is a promised dependency or not.Dependencies on  pkg-config packages. NB: this is NOT per-component (although it could be) because Cabal library does not track per-component pkg-config depends; it always does them all at once.Which optional stanzas (ie testsuites, benchmarks) will actually be enabled during the package configure step.&Why is this not a per-component build?The programs that the compiler configured (e.g. for GHC, the progs ghc & ghc-pkg). Once constructed, only the configuredPrograms are used.How  component is built.Why did we fall-back to a per-package build, instead of using a per-component build?5The build-type does not support per-component builds.;The Cabal spec version is too old for per-component builds.The user passed --disable-per-component.There are no buildable components, so we fall-back to a per-package build for error-reporting purposes.1There are four major cases for Setup.hs handling:  build-type Custom with a  custom-setup section build-type Custom without a  custom-setup section build-type not Custom with #cabal-version > $our-cabal-version build-type not Custom with #cabal-version <= $our-cabal-version0It's also worth noting that packages specifying cabal-version: >= 1.23 or later that have  build-type Custom will always have a  custom-setup. section. Therefore in case 2, the specified  cabal-version will always be less than 1.23.In cases 1 and 2 we obviously have to build an external Setup.hs script, while in case 4 we can use the internal library API. In case 3 we also have to build an external Setup.hs script because the package needs a later Cabal lib version than we can support internally.!The full set of dependencies which dictate what order we need to build things in the install plan: "order dependencies" balls everything together. This is mostly only useful for ordering; if you are, for example, trying to compute what  --dependency3 flags to pass to a Setup script, you need to use . This method is the same as !.(NB: this method DOES include setup deps.!See !.!See .!Construct an environment variable that points the package's datadir to its correct location. This might be: *  the package's source directory plus the data subdirectory for inplace packages. *  for packages installed in the store (the path was already included in the package at install/build time).?    $ , " & - '  ) !          ### 5 / ,   -   $ ( 0 & 1 + ! - * %_None`None < cabal-install Part of our Setup.hs handling policy is implemented by getting the solver to work out setup dependencies for packages. The solver already handles packages that explicitly specify setup dependencies, but we can also tell the solver to treat other packages as if they had setup dependencies. That's what this function does, it gets called by  planPackages> for all packages that don't already have setup dependencies.6The dependencies we want to add is different for each .= 1.20 for Setup scripts. cabal-install Work out which version of the Cabal we will be using to talk to the Setup.hs interface for this package.This depends somewhat on the  but most cases are a result of what the solver picked for us, based on the explicit setup deps or the ones added implicitly by . cabal-install  Work out the  given the package description. cabal-install A newtype for  for which the dependency graph considers only dependencies on libraries which are NOT from setup dependencies. Used to compute the set of packages needed for profiling and dynamic libraries. 0 1aNone&'(3Prepare a package environment and args that includes all the library dependencies for a plan.When running cabal new-exec, we want to set things up so that the compiler can find all the right packages (and nothing else). This function is intended to do that work. It takes a location where it can write files temporarily, in case the compiler wants to learn this information via the filesystem, and returns any environment variable overrides the compiler needs.The function returns both the arguments you need to pass to the compiler and the environment variables you need to set.:Write out a representation of the elaborated install plan.This is for the benefit of debugging and external tools like editors.As a convenience for  or  with any of the other !s to select only packages that were pre-installed or already in the store prior to the build.As a convenience for  with any of the other !s to select only packages that are being built in-place within the project (i.e. not destined for the store).As a convenience for  with any of the other !s to select only packages that are part of the project locally (i.e. with a local source dir).Packages that are known to be up to date. These were found to be up to date before the build, or they have a successful build outcome afterwards.This does not include any packages outside of the subset of the plan that was executed because we did not check those and so don't know for sure that they're still up to date.Packages that depend on libraries that have changed during the build (either build success or failure).This corresponds to the fact that libraries and dynamic executables are invalid once any of the libs they depend on change.This does include packages that themselves failed (i.e. it is a superset of ). It does not include changes in dependencies on executables (i.e. build tools).Packages that themselves failed during the build (i.e. them directly not a dep).This corresponds to the fact that static executables are invalid in unlucky circumstances such as linking failing half way though, or data file generation failing.This is a subset of .A subset of the plan graph, including only dependency-on-library edges. That is, dependencies on libraries, not dependencies of libraries. This tells us all the libraries that packages link to.This is here as a convenience, as strictly speaking it's not status as it's just a function of the original .Packages that are known to be out of date. These are packages that were determined to be out of date before the build, and they do not have a successful build outcome afterwards.Note that this can sometimes include packages outside of the subset of the plan that was executed. For example suppose package A and B depend on C, and A is the target so only A and C are in the subset to be built. Now suppose C is found to have changed, then both A and B are out-of-date before the build and since B is outside the subset to be built then it will remain out of date.Note also that this is not the inverse of  or . There are packages where we have no information (ones that were not in the subset of the plan that was executed).Packages that are probably still up to date (and at least not known to be out of date, and certainly not invalid). This includes  plus packages that were up to date previously and are outside of the subset of the plan that was executed. It excludes .!Renders a subset of the elaborated install plan in a semi-stable JSON format.!Work out which packages are out of date or invalid after a build.!"Helper for reading the cache file.=This determines the type and format of the binary cache file.!5Helper for writing the package up-to-date cache file.=This determines the type and format of the binary cache file.bNone&'(/The project configuration is not allowed to specify program locations for programs used by the compiler as these have to be the same for each set of packages.We cannot check this until we know which programs the compiler uses, which in principle is not until we've configured the compiler.Throws  Read the .cabal files for a set of packages. For remote tarballs and VCS source repos this also fetches them if needed.Note here is where we convert from project-root relative paths to absolute paths.Determines the location of all packages mentioned in the project configuration.Throws .Find the root of this project.:The project directory will be one of the following: 1.  mprojectDir3 when present 2. The first directory containing  mprojectFile/ cabal.project, starting from the current directory and recursively checking parent directories 3. The current directoryGet ProjectRootUsability of a given file Look up a  field in the  for a specific  . This returns the configuration that applies to all local packages plus any package-specific configuration for this package.The maximum amount of fetch jobs that can run concurrently. For instance, this is used to limit the amount of concurrent downloads from hackage, or the amount of concurrent git clones for source-repository-package stanzas.)Filter out non-top-level project configs.Use a  based on the .Use a , but only for the solver. The solver does not use the full facilities of the  so we can get away with making one that doesn't have an http transport. And that avoids having to have access to the *Read the user's cabal-install config file.Read all the config relevant for a project. This includes the project file if any, plus other global config.Reads a cabal.project.local file in the given project root dir, or returns empty. This file gets written by cabal configure<, or in principle can be edited manually or by other tools.Reads a cabal.project.freeze file in the given project root dir, or returns empty. This file gets written by  cabal freeze<, or in principle can be edited manually or by other tools.Wrapper for the .cabal file parser. It reports warnings on higher verbosity levels and throws  on failure.Like  , but the ! function is an argument.This is used when reading .cabal? files in indexes, where warnings should generally be ignored.Resolve the project configuration, with all its optional fields, into 0 with no optional fields (by applying defaults).?Determine the number of jobs (ParStrat) from the project configResolve the project configuration, with all its optional fields, into 0 with no optional fields (by applying defaults). Render the  format.For the moment this is implemented in terms of a pretty printer for the legacy configuration types, plus a conversion. Write in the  cabal.project format to the given file.Write a cabal.project.local$ file in the given project root dir.Write a cabal.project.freeze$ file in the given project root dir.Exception thrown by .Errors returned by .(Errors reported upon failing to parse a .cabal file.The location of a package as part of a project. Local file paths are either absolute (if the user specified it as such) or they are relative to the project root.:State of the project file, encodes if the file can be usedThe file is not present;The file is present but can't be used (e.g. broken symlink)#The file is present and can be used)Manual instance which skips file contents!Render bad package location error information for the implicit  cabal.project configuration.TODO: This is currently not fully realized, with only one of the implicit cases handled. More cases should be added with informative help text about the issues related specifically when having no project configuration is present.!When looking for a package's .cabal file we can find none, or several, both of which are failures.!Reads a named extended (with imports and conditionals) config file in the given project root dir, or returns empty.! Find the .cabal3 file within a tarball file and return it by value.Can fail with a  or ! exception.!/Scan through a tar file stream and collect the .cabal file, or fail.! A helper for  to handle the case of . We download the tarball to the dist src dir and after that handle it like the local tarball case.!2A glob to find all the cabal files in a directory.For a directory somedir, this is a glob of the form somedir*.cabal9. The directory part can be either absolute or relative.!5The name to use for a local file or dir for a remote  SourceRepo. This is deterministic based on the source repo identity details, and intended to produce non-clashing file names for different repos.!6The name to use for a local file for a remote tarball  SourceRepo. This is deterministic based on the remote tarball URI, and is intended to produce non-clashing file names for different tarballs.!#Utility used by all the helpers of  to make an appropriate  (! (..)), for a given package from a given location.!Reads an explicit  cabal.project file in the given project root dir, or returns the default project config for an implicitly defined project.! A helper for  to handle the case of  and . We simply read the .cabal file.! A helper for  to handle the case of . We scan through the .tar.gz file to find the .cabal file and read that.! A helper for  to handle all the cases of .!Truncate a string, with a visual indication that it is truncated.Explicit project directoryExplicit project file --ignore-project"Whether to use a semaphore (-jsem)&The number of jobs to run concurrently verbosity --cabal-config with global7whether to ignore local project (--ignore-project flag)continuation with projectcontinuation without project.cabal file path.cabal file contentserrors4We might discover the spec version the package needswarnings!The package directory The package .cabal file!continuation with projectcontinuation without project  '  .  "  ' " *     (c) Duncan Coutts 2008BSD-likeduncan@community.haskell.org provisionalportableNone#&'+,3?5.Read out the "current" index timestamp, i.e., what timestamp you would use to revert to this version.Note: this is not the same as !%! This resolves HEAD to the index's !), i.e. the index latest known timestamp.7Return NoTimestamp if the index has never been updated.7Return the age of the index file in days (as a Double).Reduced-verbosity version of Read a repository index from disk, from the local files specified by a list of s.All the !2s are marked as having come from the appropriate .This is a higher level wrapper used internally in cabal-install. Variant of ; which allows getting the source packages at a particular  IndexState.Current choices are either the latest (aka HEAD), or the index as it was at a particular time.Returns also the total index where repositories' RepoIndexState's are not HEAD. This is used in v2-freeze.A set of files (or directories) that can be monitored to detect when there might have been a change in the source packages.Get filename base (i.e. without file extension) for index-related filesSecure6 cabal repositories use a new extended & incremental  01-index.tar. In order to avoid issues resulting from clobbering new/old-style index data, we save them locally to different names. Example: Use indexBaseName repo  . "tar.gz" to compute the  of the 00-index.tar.gz/01-index.tar.gz file.Does the given filename match with the expected name of 'preferred-versions'?Read 00-index.tar.gz and extract .cabal and preferred-versions filesWe read the index using ', which gives us a lazily constructed  TarEntries.. We translate it to a list of entries using !&, which preserves the lazy nature of  TarEntries, and finally  a function over this to translate it to a list of IO actions returning !s. We can use ! to turn this into a list of !>s, still maintaining the lazy nature of the original tar read.Parse `preferred-versions` file, collecting parse errors that can be shown in error messages./Expected name of the 'preferred-versions' file.Contains special constraints, such as a preferred version of a package or deprecations of certain package versions.Expected format: .binary > 0.9.0.0 || < 0.9.0.0 text == 1.2.1.0 It is not necessary to call this, as the cache will be updated when the index is read normally. However you can do the work earlier if you like. Write the  IndexState to the filesystem6A build tree reference is either a link or a snapshot.Which index do we mean?+The main index for the specified repositoryAn index entry is either a normal package, or a local build tree reference..Parser error of the `preferred-versions` file..Original input that produced the parser error.Parser error to show to a user.)We need to save only .cabal file contents!Tar files are block structured with 512 byte blocks. Every header and file content starts on a block boundary.!8Cabal caches various information about the Hackage index!maximum/latest  among !; unless the invariant of ! being in chronological order is violated, this corresponds to the last (seen)  in !!!9 contains meta-information about the resulting filtered ! 'after applying ! according to a requested  IndexState.! of maximum/latest , in the current filtered view of the cache.The following property holds ?filterCache (IndexState (isiMaxTime isi)) cache == (cache, isi)! equivalent to , i.e. the latest known ; ! is always greater or equal to !.!,Cache format for 'file+noindex' repositories!Parse an uncompressed "00-index.tar" repository index file represented as a !.! Filters a ! according to an  IndexState specification. Also returns !' describing the resulting index cache.Note: ! is idempotent in the ! value! Read the  IndexState from the filesystem!Read ! and ! from the repository index file. Throws IOException if any arise (e.g. the index or its cache are missing). Dies if the index cache is corrupted and cannot be regenerated correctly.!(Optimise sharing of equal values inside !c.f. *https://en.wikipedia.org/wiki/Hash_consing!Return  if ' uses 01-index format (aka secure repo)! Variation on sequence# which evaluates the actions lazilyPattern matching on the result list will execute just the first action; more generally pattern matching on the first n (:) nodes will execute the first n actions.!A lazy unfolder for lookup operations which return the current value and (possibly) the next key!Read package listThe result package releases and preference entries are guaranteed to be unique.Note: 01-index.tar is an append-only index and therefore contains all .cabal edits and preference-updates. The masking happens here, i.e. the semantics that later entries in a tar file mask earlier ones is resolved in this function.! Turn the Entries data structure from the tar package into a list, and pair each entry with its block number.(NOTE: This preserves the lazy nature of Entries=: the tar file is only read as far as the list is evaluated."=Parse `preferred-versions` file, ignoring any parse failures.To obtain parse errors, use ."+Read a repository cache from the filesystemIf a corrupted index cache is detected this function regenerates the index cache and then reattempt to read the index once (and "s if it fails again)." Read the  cache from the filesystem. Throws IO exceptions if any arise and returns Left on invalid input."4Read a no-index repository cache from the filesystemIf a corrupted index cache is detected this function regenerates the index cache and then reattempts to read the index once (and "6s if it fails again). Throws IOException if any arise."Read package data from a repository. Throws IOException if any arise while accessing the index (unless the repo is local+no-index) and dies if the cache is corrupted and cannot be regenerated correctly."Read a repository index from disk, from the local file specified by the .All the !+s are marked as having come from the given .This is a higher level wrapper used internally in cabal-install."4Read the index (for the purpose of building a cache)The callback is provided with list of cache entries, which is guaranteed to be lazily constructed. This list must ONLY be used in the scope of the callback; when the callback is terminated the file handle to the index will be closed and further attempts to read from the list will result in (pure) I/O exceptions.In the construction of the index for a secure repo we take advantage of the index built by the hackage-security library to avoid reading the .tar file as much as possible (we need to read it only to extract preferred versions). This helps performance, but is also required for correctness: the new 01-index.tar.gz> may have multiple versions of preferred-versions files, and  does not correctly deal with that (see #2956); by reading the already-built cache from the security library we will be sure to only read the latest versions of all files.=TODO: It would be nicer if we actually incrementally updated cabal's cache, rather than reconstruct it from zero on each update. However, this would require a change in the cache format." Write the  cache to the filesystem##! !    "   "$             "&)         %  $ ! &c(c) The University of Glasgow 2006, Duncan Coutts 2008cabal-devel@haskell.orgalphaportableNone#3>,Prepare to build a package by configuring a ". The returned "# object identifies the method. The  may be changed during the configuration process; the final values are given by ".Run a configured " with specific arguments.#Run a command through a configured ". Configure a " and run a command in one step. The command flags may depend on the Cabal library version in use.SetupScriptOptions' are options used to configure and run "?, as opposed to options given to the Cabal command at runtime.Is the task we are going to run an interactive foreground task, or an non-interactive background task? Based on this flag we decide whether or not to delegate ctrl+c to the spawned taskLet the setup script logic know if it is being run to build a main library or executable component. This is used to determine if we should use the configure command, if the build-type is ". For configure, only the main library and execomponents have  configure support, and thus we can skip running configure for other components.This is the version of the Cabal specification that we believe that this package uses. This affects the semantics and in particular the Setup command line interface.This is similar to 9 but instead of probing the system for a version of the  Cabal library, you just say exactly which version of the spec we will use. Using this also avoid adding the Cabal library as an additional dependency, so add it to  if needed.,The version of the Cabal library to use (if  is not set). A suitable version of the Cabal library must be installed (or for some build-types be the one cabal-install was built with).The version found also determines the version of the Cabal specification that we us for talking to the Setup.hs, unless overridden by .3List of dependencies to use when building Setup.hs.,Is the list of setup dependencies exclusive? When this is False?, if we compile the Setup.hs script we do so with the list in  but all other packages in the environment are also visible. A suitable version of Cabal library (see 5) is also added to the list of dependencies, unless % already contains a Cabal dependency.When True , only the  packages are used, with other packages in the environment hidden.This feature is here to support the setup stanza in .cabal files that specifies explicit (and exclusive) dependencies, as well as the old style with no dependencies.8Extra environment variables paired with overrides, where v0 means "set the environment variable's value to v".( means "unset the environment variable".;Extra things to add to PATH when invoking the setup script.Should we build the Setup.hs with CPP version macros available? We turn this on when we have a setup stanza in .cabal that declares explicit setup dependencies."Setup encapsulates the outcome of configuring a setup method to build a particular package." SetupMethod: represents one of the methods used to run Cabal commands.":run Cabal commands through "cabal" in the current process"6run Cabal commands through "cabal" as a child process"6run Cabal commands through a custom "Setup" executable"A  SetupRunner implements a "."Decide if we're going to be able to do a direct internal call to the entry point in the Cabal library or if we're going to have to compile and execute an external Setup.hs script.",Run a Setup script by directly invoking the Cabal library."This is a horrible hack to make sure passing fancy verbosity flags (e.g., -v'info +callstack';) doesn't break horribly on old Setup. We can't do it in filterConfigureFlags, because verbosity applies to ALL commands.command-line argumentscommand definition command flagsextra command-line arguments5produce command flags given the Cabal library versiondcabal-devel@haskell.orgportableNone37Return the saved "dist/" prefix, or the default prefix.= 0.4.1 && < 0.5.4This version is slightly different than the one in . This one uses a.b.c as the lower bound because the user could be using a new function introduced in a.b.c which would make ">= a.b" incorrect.kNone<0Fetch a list of packages and their dependencies.l(c) David Himmelstrup 2005, Duncan Coutts 2005BSD-likecabal-devel@haskell.orgportableNone3 Warn if any constraints or preferences name packages that are not in the source package index or installed package index.Choose the Cabal version such that the setup scripts compiled against this version will support the given command-line flags. Currently, it implements no specific restrictions and allows any version, unless the second argument is filled with a !', in which case this version is picked.2Configure the package found in the local directoryRead saved configure flags and restore the saved environment from the usual location.Read saved configure flags and restore the saved environment from the specified files.+Save the build flags to the usual location.Save the configure flags and environment to the specified files."?The path (relative to the package root) where the arguments to  configure should be saved."Call an installer for an !> but override the configure flags with the ones given by the . In particular the  specifies an exact FlagAssignment and exactly versioned package dependencies. So we ignore any previous partial flag assignment or dependency constraints and use the new ones.>NB: when updating this function, don't forget to also update installReadyPackage in D.C.Install."Make an  InstallPlan for the unpacked package in the current directory, and all its dependencies.  --build-dirpath to saved flags file  --build-dirpath to saved flags filemNone3+Re-configure the package in the current directory if needed. Deciding when to reconfigure and with which options is convoluted:,If we are reconfiguring, we must always run  configure with the verbosity option we are given; however, that a previous configuration uses a different verbosity setting is not reason enough to reconfigure.The package should be configured to use the same "dist" prefix as given to the build command, otherwise the build will probably fail. Not only does this determine the "dist" prefix setting if we need to reconfigure anyway, but an existing configuration should be invalidated if its "dist" prefix differs.If the package has never been configured (i.e., there is no LocalBuildInfo), we must configure first, using the default options.4If the package has been configured, there will be a LocalBuildInfo=. If there no package description file, we assume that the PackageDescription is up to date, though the configuration may need to be updated for other reasons (see above). If there is a package description file, and it has been modified since the LocalBuildInfo- was generated, then we need to reconfigure.The caller of this function may also have specific requirements regarding the flags the last configuration used. For example,  testAction requires that the package be configured with test suites enabled. The caller may pass the required settings to this function along with a function to check the validity of the saved 5; these required settings will be checked first upon determining that a previous configuration exists.Check7 represents a function to check some condition on type a. The returned " is % if any part of the condition failed.configure actionVerbosity setting "dist" prefix(j flag for reinstalling add-source deps.Check that the required flags are set. If they are not set, provide a message explaining the reason for reconfiguration.Extra arguments Global flags0 0* *nNone&'3 o(c) David Waern 2008BSD-likedavid.waern@gmail.com experimentalportableNone#1  pNoneqNoner(c) David Waern 2008BSD-likedavid.waern@gmail.com experimentalportableNonesNone  &'(3<9'+Given the install plan, produce the set of #s for each package-component pair.Typically there will only be one such target for each component, but for example if we have a plan with both normal and profiling variants of a component then we would get both as available targets, or similarly if we had a plan that contained two instances of the same version of a package. This approach makes it relatively easy to select all instances/variants of a component.Get the bin/ directories that a package's executables should reside in.The result may be empty if the package does not build any executables.The result may have several entries if this is an inplace build of a package with multiple executables.The path to the directory that contains a specific executable. NB: For inplace NOT InstallPaths.bindir installDirs; for an inplace build those values are utter nonsense. So we have to guess where the directory is going to be. Fortunately this is "stable" part of Cabal API. But the way we get the build directory is A HORRIBLE HACK.The components that we'll build all of, meaning that after they're built we can skip building them again (unlike with building just some modules or other files within a component).Merge component targets that overlap each other. Specially when we have multiple targets for the same component and one of them refers to the whole component (rather than a module or file within) then all the other targets for that component are subsumed.We also allow for information associated with each component target, and whenever we targets subsume each other we aggregate their associated info.6Try to remove the given targets from the install plan.This is not always possible.Given a set of per-package/per-component targets, take the subset of the install plan needed to build those targets. Also, update the package config to specify which optional stanzas to enable, and which targets within each package to build.NB: Pruning happens after improvement, which is important because we will prune differently depending on what is already installed (to implement "sticky" test suite enabling behavior).-Return an up-to-date elaborated install plan.Two variants of the install plan are returned: with and without packages from the store. That is, the "improved" plan where source packages are replaced by pre-existing installed packages from the store (when their ids match), and also the original elaborated plan which uses primarily source packages.Return the up-to-date project config and information about the local packages within the project.An available target represents a component within a package that a user command could plausibly refer to. In this sense, all the components defined within the package are things the user could refer to, whether or not it would actually be possible to build that component./In particular the available target contains an  which informs us about whether it's actually possible to select this component to be built, and if not why not. This detail makes it possible for command implementations (like build, test8 etc) to accurately report why a target cannot be used.Note that the type parameter is used to help enforce that command implementations can only select targets that can actually be built (by forcing them to return the k1 value for the selected targets). In particular resolveTargets makes use of this (with k as (!, ComponentName')() to identify the targets thus selected.The status of a an  component. This tells us whether it's actually possible to select this component to be built, and if not why not.!The target can or should be built&When the solver could not enable testsWhen the user does  tests: FalseWhen the component has buildable: False5When the component is non-core in a non-local packageIt is not always possible to prune to only the dependencies of a set of targets. It may be the case that removing a package leaves something else that still needed the pruned package.This lists all the packages that would be broken, and their dependencies that would be missing if we did prune.How # should interpret the per-package %s: as build, repl or haddock targets.This tells us whether a target ought to be built by default, or only if specifically requested. The policy is that components like libraries and executables are built by default by build, but test suites and benchmarks are not, unless this is overridden in the project configuration.Not to be built by defaultTo be built by default"This is a temporary data type, where we temporarily override the graph dependencies of an , so we can take a closure over them. We'll throw out the overridden dependencies when we're done so it's strictly temporary.For , this the cached unit IDs always coincide with the real thing."Produce an elaborated install plan using the policy for local builds with a nix-style shared store.In theory should be able to make an elaborated install plan with a policy matching that of the classic cabal install --user or --global"Get the  for all the source packages where we use hashes, and download any packages required to do so.:Note that we don't get hashes for local unpacked packages." Given the "( for a nix-style package store, and an , replace configured source packages by installed packages from the store whenever they exist."The path to the build directory for an inplace build."Get the appropriate * which identifies an installed component."Given a , report if it matches a ."Given a , report if it matches a ." Given an , generate the mapping from   and  to the "# that should be used in this case." Given an , generate the mapping from "6 to the shape of this package, as per mix-in linking."*Given a set of already installed packages  availablePkgs8, determine the set of available optional stanzas from pkg which have all of their dependencies already installed. This is used to implement "sticky" testsuites, where once we have installed all of the deps needed for the test suite, we go ahead and enable it always."Select the config values to monitor for changes package source hashes."Select the bits of a "$ to monitor for value changes. Use " for the files to monitor."Assuming we have previously set the root build targets (i.e. the user targets but not rev deps yet), the first pruning pass does two things:A first go at determining which optional stanzas (testsuites, benchmarks) are needed. We have a second go in the next pass.Take the dependency closure using pruned dependencies. We prune deps that are used only by unneeded optional stanzas. These pruned deps are only used for the dependency closure and are not persisted in this pass."If a 7 refers to a single package, return Just that package."Check that an " actually makes sense under some ."Set the build targets based on the user targets (but not rev deps yet). This is required before we can prune anything."2To be used for the input for elaborateInstallPlan.>TODO: [code cleanup] make InstallDirs.defaultInstallDirs pure. '(improvedPlan, elaboratedPlan, _, _, _)How to transform a path which is relative to cabal-install cwd to one which is relative to the route of the package about to be compiled. The simplest way to do this is to convert the potentially relative path into an absolute path.")The package or component being configured   # ! $  tNone<]8Target problems that occur during project orchestration.A custom target problemThere are no targets at allThe  matches component (test benchmark...) but none are buildableType alias for a & with no user-defined problems/errors.=Can use the utilities below for reporting/rendering problems.3 33333uNone&'(Do all the checks on whether a package has changed and thus needs either rebuilding or reconfiguring and rebuilding.Helper function for ,  and .It selects the info from a  that are used by the   s (in the ) to detect value changes."This is all the components of the   other than the ["].We have to split up the   components since they get produced at different times (or rather, when different things change).As part of the dry run for local unpacked packages we have to check if the package config or files have changed. That is the purpose of  and .When a package is (re)built, the monitor must be updated to reflect the new state of the package. Because we sometimes build without reconfiguring the state updates are split into two, one for package config changes and one for other changes. This is the purpose of  and .  vNone &'(3Structures the phases of building and registering a package amongst others (see ). Delegates logic specific to a certain building style (notably, inplace vs install) to the delegate function that receives as an argument );Each unpacked package is processed in the following phases:Configure phase Build phase Haddock phaseInstall phase (copy + register)Register phase Test phase Bench phase Repl phaseDepending on whether we are installing the package or building it inplace, the phases will be carried out differently. For example, when installing, the test, benchmark, and repl phase are ignored."The copy part of the installation phase when doing build-and-installWhether to pass a semaphore to build process this is different to BuildTimeSettings because the name of the semaphore is created freshly each time.Whether to pass a semaphore to build process this is different to BuildTimeSettings because the name of the semaphore is created freshly each time. The path to an  initialized log file"The "< function which invokes ./Setup copy for the given filepathThe temporary dir file pathwNone  &'(13 Build things for real.It requires the   gathered by ./Do the dry run pass. This is a prerequisite of .It gives us the  . This should be used with % to give an improved version of the  with packages switched to the 4 state when we find that they're already up to date."Given the current  InstallPlan and  , select all the packages we have to download and fork off an async action to download them. We download them in dependency order so that the one's we'll need first are the ones we will start downloading first.The body action is passed a map from those packages (identified by their location) to a completion var for that package. So the body action should lookup the location and use " to get the result."Check if a package needs downloading, and if so expect to find a download in progress in the given  and wait on it to finish."Create a package DB if it does not currently exist. Note that this action is not safe to run concurrently."=A specialised traversal over the packages in an install plan.The packages are visited in dependency order, starting with packages with no dependencies. The result for each package is accumulated into a  and returned as the final result. In addition, when visiting a package, the visiting function is passed the results for all the immediate package dependencies. This can be used to propagate information from dependencies."This is a bit of a hacky workaround. A number of packages ship pre-processed .hs files in a dist directory inside the tarball. We don't use the standard dist location so unless we move this dist dir to the right place then we'll miss the shipped pre-processed files. This hacky approach to shipped pre-processed files ought to be replaced by a proper system, though we'll still need to keep this hack for older packages."Given all the context and resources, (re)build an individual package."Ensure that the package is unpacked in an appropriate directory, either a temporary one or a persistent one under the shared dist directory.0 0  xNone(G 2Singular for singleton lists and plural otherwise.The optional stanza type (test suite or benchmark), if it is one.8Used to render a singular or plural version of something 0plural (listPlural theThings) "it is" "they are"%Render a list of things in the style foo, bar and baz%Render a list of things in the style #blah blah; this that; and the otherDefault implementation of .Several commands have a TargetProblemNoTargets problem constructor. This renders an error message for those cases.Several commands have a TargetProblemNoneEnabled problem constructor. This renders an error message for those cases.Default implementation of % simply renders one problem per line.When rendering lists of things it often reads better to group related things, e.g. grouping components by package name renderListSemiAnd [ "the package " ++ prettyShow pkgname ++ " components " ++ renderListCommaAnd showComponentName components | (pkgname, components) <- sortGroupOn packageName allcomponents ] Does the * potentially refer to one package or many? Does the $ refer to packages or to components?A tag used in rendering messages to distinguish singular or plural.verbhow to render custom problems++None &'()Get all target selectors.If there are build failures then report them and throw an exception.Utility used by repl and run to check if the targets spans multiple components, since those commands do not support multiple components.Create a dummy project context, without a .cabal or a .cabal.project file (a place where to put a temporary dist directory is still needed)Like % but doesn't search for project root.Print a user-oriented presentation of the install plan, indicating what will be built.Wrapper around 2 that adjusts for the extra unneeded info in the .$Resolve targets from local packages.%This is a convenience wrapper around " that takes a list of ?s directly, rather than requiring the caller to construct the " first.%Resolve targets from a solver result.%This is a convenience wrapper around  that takes an > directly, rather than requiring the caller to construct the " first.Build phase: now do it.Execute all or parts of the description of what to do to build or rebuild the various packages needed..Post-build phase: various administrative tasksUpdate bits of state based on the build outcomes and report any failures.A basic selectComponentTarget# implementation to use or pass to ", that does the basic checks that the component is buildable and isn't a test suite or benchmark that is disabled. This can also be used to do these basic checks as part of a custom impl that Get all unique target selectors.#Pre-build phase: decide what to do.Tracks what command is being executed, because we need to hide this somewhere for cases that need special handling (usually for error reporting).This holds the context of a project prior to solving: the content of the  cabal.project,  cabal/config and all the local package .cabal files.Note: these are all the packages mentioned in the project configuration. Whether or not they will be considered local to the project will be decided by  shouldBeLocal in ProjectPlanning.This holds the context between the pre-build, build and post-build phases.This is the improved plan, before we select a plan subset based on the build targets, and before we do the dry-run. So this contains all packages in the project. This is the  after we select a plan subset and do the dry-run phase to find out what is up-to or out-of date. This is the plan that will be executed during the build phase. So this contains only a subset of packages in the project.The part of the install plan that's shared between all packages in the plan. This does not change between the two plan variants above, so there is just the one copy.The result of the dry-run phase. This tells us about each member of the .The targets selected by selectPlanSubset. This is useful eg. in CmdRun, where we need a valid target to execute.>The set of components to build, represented as a mapping from ! s to the s within the unit that will be selected (e.g. selected to build, test or repl).Associated with each  is the set of s that matched this target. Typically this is exactly one, but in general it is possible to for different selectors to match the same target. This extra information is primarily to help make helpful error messages."5Create available target indexes from source packages.This is useful when we need to resolve targets before solver resolution."Given a set of s, resolve which !s and s they ought to refer to.The idea is that every user target identifies one or more roots in the , which we will use to determine the closure of what packages need to be built, dropping everything from the plan that is unnecessary. This closure and pruning is done by 2 and this needs to be told the roots in terms of ! s and the s within those.*This means we first need to translate the  s into the !s and s. This translation has to be different for the different command line commands, like build, repl etc. For example the command  build pkgfoo< could select a different set of components in pkgfoo than  repl pkgfoo. The build command would select any library and all executables, whereas repl would select the library or a single executable. Furthermore, both of these examples could fail, and fail in different ways and each needs to be able to produce helpful error messages.So " takes two helpers: one to select the targets to be used by user targets that refer to a whole package (), and another to check user targets that refer to a component (or a module or file within a component). These helpers can fail, and use their own error type. Both helpers get given the  info about the component(s).While commands vary quite a bit in their behaviour about which components to select for a whole-package target, most commands have the same behaviour for checking a user target that refers to a specific component. To help with this commands can use /, either directly or as a basis for their own selectComponentTarget implementation.;Project configuration including the global config if neededWhere to put the dist directory*The packages to be included in the project yNone#&'( Get the directory for caching a script build and ensure it exists.The only identity of a script is it's absolute path, so append the hashed path to the  script-builds dir to get the cache directory.The base for making a !! for a fake project. It needs a  or " depending on the command.-Get the directory for caching a script build.The only identity of a script is it's absolute path, so append the hashed path to the  script-builds dir to get the cache directory.)Get the hash of a script's absolute path.Two hashes will be the same as long as the absolute paths are the same.A lens for the " field of !Find the path of an exe that has been relocated with a "-o" optionAdd the executable metadata to the context and write a .cabal file.Add the !2 to the context and use it to write a .cabal file.Determine whether the targets represent regular targets or a script and return the proper context and target selectors. Die with an error message if selectors are valid as neither regular targets or as a script.In the case that the context refers to a temporary directory, delete it after the action finishes.6What your command should do when no targets are found.return a default die on 4Information about the context in which we found the s.1The target selectors are from the global context.+The target selectors are part of a project.The target selectors refer to a script. Contains the path to the script and the executable metadata parsed from the script"Extract the first encountered script metadata block started end terminated by the tokens {-  header: -}appearing alone on lines (while tolerating trailing whitespace). These tokens are not part of the  result.,In case of missing or unterminated blocks a -error is returned."Extract the first encountered executable metadata block started and terminated by the below tokens or die.  {- cabal: -}Return the metadata."Extract the first encountered project metadata block started and terminated by the below tokens.  {- project: -}Return the metadata.6What your command should do when no targets are found.A target filterCommand line flags$Target strings or a script and args. Global flags..Current Command (usually for error reporting). The body of your command action.  zNone&'   {None&'For a  *, check if the component can be selected.For the test command we just need to check it is a test-suite, in addition to the basic checks on being buildable etc.This defines what a  means for the test command. It selects the  s that the 1 refers to, or otherwise classifies the problem.For the test command we select all buildable test-suites, or fail if there are no test-suites or no buildable test-suites.The test command is very much like build. It brings the install plan up to date, selects that part of the plan needed by the given or implicit test target(s) and then executes the plan. Compared to build the difference is that there's also test targets which are ephemeral.4For more details on how this works, see the module (Distribution.Client.ProjectOrchestration"The # matches targets but no test-suites"The / refers to a component that is not a test-suite" command we just need the basic checks on being buildable etc.This defines what a  means for the repl command. It selects the  s that the 1 refers to, or otherwise classifies the problem.For repl we select:7the library if there is only one and it's buildable; or3the exe if there is only one and it's buildable; orany other buildable component.Fail if there are no buildable lib/exe components, or if there are multiple libs or exes." Multiple s match multiple targets"=The various error conditions that can occur when matching a  against  s for the repl command."=First version of GHC where GHCi supported the flag we need. https://downloads.haskell.org/~ghc/7.6.1/docs/html/users_guide/release-7-6-1.html":First version of GHC which supports multiple home packages"Create a constraint which requires a later version of Cabal. This is used for commands which require a specific feature from the Cabal library such as multi-repl or the --with-repl flag."Target selection behaviour which only select a single target. This is used when the compiler version doesn't support multi-repl or the user didn't request it."Add repl options to ensure the repl actually starts in the current working directory.In a global or script context, when we are using a fake package,  cabal repl starts in the fake package directory instead of the directory it was called from, so we need to tell ghci to change back to the correct directory.The  -ghci-script flag is path to the ghci script responsible for changing to the correct directory. Only works on GHC >= 7.6, though. "Invariant: validatedTargets returns at least one target for the REPL.   cabal-devel@haskell.orgportableNone:Entry point for the path command."$A path that can be retrieved by the  cabal path command.":Find the FilePath location for common configuration paths.TODO: this should come from a common source of truth to avoid code path divergence"%The configuration name for this path.")(/ "&      cabal-devel@haskell.orgportableNone&' Find all outdated dependencies.Print either the list of all outdated dependencies, or a message that there are none./Various knobs for customising the behaviour of .Should this package be ignored?7Should major version bumps be ignored for this package?"Pretty print an "."3Read the list of dependencies from the freeze file."1Read the list of dependencies from local packages";Read the list of dependencies from the package description."Read the list of dependencies from the cabal.project context. This will get dependencies from * cabal.project.freeze * cabal.project.local * cabal.project files"For the outdated command, when a specific component is specified we simply select that component."For the outdated command, when a whole package is specified we want to select all buildable components."Convert a list of s to a " list.   ( + ) .None#For a  *, check if the component can be selected.For the run command we just need to check it is a executable-like (an executable, a test, or a benchmark), in addition to the basic checks on being buildable etc.This defines what a  means for the list-bin command. It selects the  s that the 1 refers to, or otherwise classifies the problem.For the list-bin command we select the exe or flib if there is only one and it's buildable. Fail if there are no or multiple buildable exe components."=The various error conditions that can occur when matching a  against  s for the run command."The # matches targets but no executables" A single  matches multiple targets" Multiple s match multiple targets"The 0 refers to a component that is not an executable";Asking to run an individual file or module is not supported None &'(The install command actually serves four different needs. It installs: * exes: For example a program from hackage. The behavior is similar to the old install command, except that now conflicts between separate runs of the command are impossible thanks to the store. Exes are installed in the store like a normal dependency, then they are symlinked/copied in the directory specified by --installdir. To do this we need a dummy projectBaseContext containing the targets as extra packages and using a temporary dist directory. * libraries Libraries install through a similar process, but using GHC environment files instead of symlinks. This means that 'v2-install'ing libraries only works on GHC >= 8.0.4For more details on how this works, see the module (Distribution.Client.ProjectOrchestrationFor a  *, check if the component can be selected.For the build> command we just need the basic checks on being buildable etc.This defines what a  means for the bench command. It selects the  s that the 1 refers to, or otherwise classifies the problem.For the build command select all components except non-buildable and disabled tests/benchmarks, fail if there are no such components"Check or check then install an exe. The check is to see if the overwrite policy allows installation."#Only check if install is permitted.".Actually install but check first if permitted."A record of install method, install directory and file path functions needed by actions that either check if an install is possible or actually perform an installation. This is for installation of executables only.".A function to get an UnitId's store directory."$A function to get an exe's filename."A function to get an exe's final possibly different to the name in the store."Disables tests and benchmarks if they weren't explicitly enabled."Create "&s for packages with exposed libraries."Apply the given 4 on top of one coming from the global configuration."8Gets the file path to the request environment file. The Bool is True* if we got an explicit instruction using  --package-env, False if we used the default.#Return the package specifiers and non-global environment file entries.#Returns the list of GhcEnvFilePackageId values already existing in the environment being operated on. The Bool is True/ if we took settings from an existing file, False otherwise.#7Constructs the path to the global GHC environment file.2TODO(m-renaud): Create PkgEnvName newtype wrapper.#4Constructs the path to a local GHC environment file.#8Disables program prefix and suffix, in order to get the  canonical( executable name in the store and thus:avoid making the package hash depend on these options and needless rebuild;provide the correct executable path to the install methods (copy, symlink).#Install a specific exe.# - * When ", warn if install would fail overwrite policy checks but don't install anything. - * When ", try to symlink or copy every package exe from the store to a given location. When not permitted by the overwrite policy, stop with a message.#Install any built library by adding it to the default ghc environment#Partitions the target selectors into known local targets and hackage packages.#From an install configuration, prepare the record needed by actions that will either check if an install of a single executable is possible or actually perform its installation.#Prepares a record containing the information needed to either symlink or copy an executable.#Verify that invalid config options were not passed to the install command.6If an invalid configuration is found the command will dieWithException.#,The directory where the built exe is locatedThe exe's filename2The exe's filename in the public install directory*the directory where it should be installed'Whether the installation was successful#Environment fileWhether we need to show a warning (i.e. we created a new environment file, and the user did not use --package-env)#The synthetic base context to use to produce the full build context.#The local packages, to resolve  selectorsNone&'The haddock command is TODO.4For more details on how this works, see the module (Distribution.Client.ProjectOrchestrationFor a  *, check if the component can be selected.For the haddock? command we just need the basic checks on being buildable etc.This defines what a  means for the haddock command. It selects the  s that the 1 refers to, or otherwise classifies the problem.For the haddock command we select all buildable libraries. Additionally, depending on the  --executables flag we also select all the buildable exes. We do similarly for test-suites, benchmarks and foreign libs.None(T'Default values for the gen-bounds flagsThe action for the  gen-bounds( command when used in a project context.The  gen-bounds command definition*The data type for gen-bounds command flags#Process a single BuildInfo to identify and report missing upper bounds#-Report target problems for gen-bounds command#For a  , check if the component can be selected. Copy of selectComponentTarget from CmdBuild.hs#This defines what a  means for the  gen-bounds8 command. Copy of selectPackageTargets from CmdBuild.hsNone(vTo a first approximation, the freeze& command runs the first phase of the build command where we bring the install plan up to date, and then based on the install plan we write out a cabal.project.freeze config file.4For more details on how this works, see the module (Distribution.Client.ProjectOrchestration#Given the install plan, produce a config value with constraints that freezes the versions of packages used in the plan.#Given the install plan, produce solver constraints that will ensure the solver picks the same solution again in future in different environments.cabal-devel@haskell.orgportableNone&'O#?Get paths to all dependency executables to be included in PATH.#?Get paths to all dependency executables to be included in PATH.#Execute an action with a temporary .ghc.environment file reflecting the current environment. The action takes an environment containing the env variable which points ghc to the file.None&'To a first approximation, the  configure# just runs the first phase of the build command where we bring the install plan up to date (thus checking that it's possible).The only difference is that  configure also allows the user to specify some extra config flags which we save in the file cabal.project.local.4For more details on how this works, see the module (Distribution.Client.ProjectOrchestrationNoneThe build command does a lot. It brings the install plan up to date, selects that part of the plan needed by the given or implicit targets and then executes the plan.4For more details on how this works, see the module (Distribution.Client.ProjectOrchestrationFor a  *, check if the component can be selected.For the build> command we just need the basic checks on being buildable etc.This defines what a  means for the bench command. It selects the  s that the 1 refers to, or otherwise classifies the problem.For the build command select all components except non-buildable and disabled tests/benchmarks, fail if there are no such componentsNone#&'(None44NoneIThe build command does a lot. It brings the install plan up to date, selects that part of the plan needed by the given or implicit targets and then executes the plan.4For more details on how this works, see the module (Distribution.Client.ProjectOrchestrationFor a  *, check if the component can be selected.For the bench command we just need to check it is a benchmark, in addition to the basic checks on being buildable etc.This defines what a  means for the bench command. It selects the  s that the 1 refers to, or otherwise classifies the problem.For the bench command we select all buildable benchmarks, or fail if there are no benchmarks or no buildable benchmarks.#The " matches targets but no benchmarks#The . refers to a component that is not a benchmark#Asking to benchmark an individual file or module is not supported#=The various error conditions that can occur when matching a  against  s for the bench command. (c) 2005 David Himmelstrup 2007 Bjorn Bringert 2007-2010 Duncan CouttsBSD-likecabal-devel@haskell.org provisionalportableNone3 ?Installs the packages needed to satisfy a list of dependencies.0Make an install context given install arguments.Make an install plan given install context and install arguments.8Given an install plan, perform the actual installations.2Remove the provided targets from the install plan.Initial arguments given to  or .:Common context for makeInstallPlan and processInstallPlan.#If logging is enabled, contains location of the log file and the verbosity level for logging.#Perform post-solver checks of the install plan and print it if either requested or needed.#Call an installer for an !> but override the configure flags with the ones given by the . In particular the  specifies an exact # and exactly versioned package dependencies. So we ignore any previous partial flag assignment or dependency constraints and use the new ones.>NB: when updating this function, don't forget to also update configurePackage in D.C.Configure.#Various stuff we do after successful or unsuccessfully installing a bunch of packages. This includes:!build reporting, local and remotesymlinking binariesupdating indexeserror reporting#=Report a solver failure. This works slightly differently to #3, as (by definition) we don't have an install plan.#If a 7 refers to a single package, return Just that package.#8Directory to change to before starting the installation.File to log output to (if any)(c) David Himmelstrup 2005BSD-likelemmih@gmail.com provisionalportableNone3 Entry pointThis does three things.One, it initializes the program, providing support for termination signals, preparing console linebuffering, and relaxing encoding errors.>Two, it processes (via an IO action) response files, calling #* in Cabal/Distribution.Compat.ResponseFileNote that here, it splits the arguments on a strict match to "--", and won't parse response files after the split.Three, it calls the #., which calls the argument parser, producing # data, which mainWorker pattern-matches into IO actions for execution.#Used as an entry point when cabal-install needs to invoke itself as a setup script. This can happen e.g. when doing parallel builds.#Actually do the work of building the package. This is separate from # so that # and # do not invoke  twice.#Return the names of all buildable components matching a given predicate.#Make sure that we don't pass new flags to setup scripts compiled against old versions of Cabal.#Core worker, similar to defaultMainHelper in Cabal/Distribution.SimpleWith an exception-handler  topHandler, mainWorker calls commandsRun to parse arguments, then pattern-matches the CommandParse data into IO actions for execution.#Check whether assertions are enabled and print a warning in that case.#working directory# !!!!!""""""##############################################################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&''''''''''((((((((((((()))))))))))))****************++++++++++++,,,,,,,,,,,,-------------------------------------------------........................//////////////////////////////////////0000000000000000000001111111111111111222222222333333333333344444444444555555555555555555555555555555555555555555555555555555555555555566666666666666666666666666666666666666667            9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 : :             ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; < < << < < < < < < < < < < < < << << <<<< < < < <<<< < < <<<<< < < < < < < < < < < < < < < < < < < = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = == = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = > > > > ? ? ? ? ? ? ? ? ? ? ? ? @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @        A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A B B B B B C C C C C C C C C C C D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D EEEEE EE E E E EEEEEEEEEEFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH                                    IIJJKLLLLLLLLLLLLLLLLLLL L L LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMN88888888888888888888888888888OOPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUVVWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^_````````aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb                                                             cccccccccccccccccccccccccccddddeeeeeeeeeeeeeeeeffghh hhhhhhhhhhhiijjjkllllllllmmmmmmnnnooooopppqqqrrrrsssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssstttttttttttttttttuuuuuuuuuuuuuvvvvvvwwwxxxxxxxxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyzzzzz{{{{{{{{{||||||||}}}}}}}}}}~~~~~~~~~~~~~~                    . 2      5  6 6                                                                               <   <<< <> > >    A B F F F G G G G G!G!G!G!!!G!G!G!G!!!G!G!G!G!G!G!G!G!G!G!G!G!G!G!G!G!G!G!!!!!!!!!!!!!!!!! !!! !!!! !!!!! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !L!L!L!L!L!L!L!L!L!L!L!L!L!L!L!L!L!L!!!!!L!L!L!L!L!L!L!L!L!L!L!L!L!L!L!L!L!L!L!L!L!L!L!L!L!L!L!L!L!!!8!8!8! !!!!"""P"P"P"P"""Q"Q"Q"R"R R"S!S!"""""""""""""""""V"V"W"W"W"W"W"W"""X"X"X"X"X"X"X"X"X"Y"Y"Y"Y"Z"Z"Z"Z Z"Z"Z"Z"""^""" "^"^"^"a"a"a"a"a"""b"b"b"b"b"b"b"b"b"b"""b"b"b"b"b"b" " "" " " " " " "" "" " " "" " "" " " " " " " """ " " " " " "c"c"c"""c#c#c#c#c#c#c#f#f#f#f#f#f#f#h##h#ij l#l#l###s#s#s#s###s#s#s#s#s###s#s#s#s###s#s#s#s#s#s#s###v#v##w#w#w#w#w#w#w##### ""#y#y#y#{#{#{#{#{#}#}#}#}#}#}#}#~#~#~#~#~#~#~#~#################################################$$$$$$$$$$#$$$$$$$#$$$$$!$$$$$$$cabal-install-3.16.1.0-inplace(Distribution.Client.ProjectOrchestrationDistribution.Client.Glob Distribution.Client.RebuildMonad'Distribution.Client.ProjectConfig.Types"Distribution.Client.Compat.PreludeDistribution.Client.VCSDistribution.Client.Setup%Distribution.Client.CmdHaddockProjectDistribution.Client.IndexUtilsDistribution.Client.UtilsDistribution.Deprecated.ReadPDistribution.Client.Init.UtilsDistribution.Client.Dependency%Distribution.Client.SolverInstallPlan$Distribution.Client.Compat.Directory!Distribution.Client.Security.HTTP)Distribution.Client.Compat.ExecutablePath"Distribution.Client.Compat.Orphans&Distribution.Client.BuildReports.Types%Distribution.Client.BuildReports.Lens$Distribution.Client.Compat.Semaphore$Distribution.Client.Dependency.TypesDistribution.Client.GZipUtilsDistribution.Client.Compat.TarDistribution.Client.HaddockDistribution.Client.HashValue(Distribution.Client.IndexUtils.Timestamp!Distribution.Client.Init.Licenses Distribution.Client.ManpageFlags Distribution.Client.ProjectFlagsDistribution.Client.SavedFlags Distribution.Client.Security.DNSDistribution.Client.SignalDistribution.Client.Tar$Distribution.Client.Types.AllowNewer&Distribution.Client.Types.BuildResults&Distribution.Client.Types.ConfiguredId+Distribution.Client.Types.ConfiguredPackage%Distribution.Client.Types.Credentials'Distribution.Client.Types.InstallMethod)Distribution.Client.Types.OverwritePolicy1Distribution.Client.CmdInstall.ClientInstallFlags*Distribution.Client.Types.PackageSpecifier"Distribution.Client.Types.RepoNameDistribution.Client.Types.Repo)Distribution.Client.IndexUtils.IndexState*Distribution.Client.IndexUtils.ActiveRepos$Distribution.Client.Types.SourceRepo)Distribution.Client.Types.PackageLocation)Distribution.Client.Types.SourcePackageDb&Distribution.Client.Types.ReadyPackage8Distribution.Client.Types.WriteGhcEnvironmentFilesPolicyDistribution.Client.PackageHashDistribution.Client.Utils.Json Distribution.Client.Utils.ParsecDistribution.Client.ParseUtilsDistribution.Client.Errors$Distribution.Client.Win32SelfUpgradeDistribution.Client.JobControlDistribution.Client.InstallPlanDistribution.Client.Init.TypesDistribution.Client.Init.PromptDistribution.Client.Init.Format!Distribution.Client.Init.Defaults'Distribution.Client.Init.FlagExtractorsDistribution.Client.Init.Simple2Distribution.Client.Init.NonInteractive.Heuristics/Distribution.Client.Init.NonInteractive.Command,Distribution.Client.Init.Interactive.Command%Distribution.Client.Init.FileCreatorsDistribution.Client.FileMonitor)Distribution.Client.ProjectBuilding.TypesDistribution.Client.SrcDistDistribution.Client.RunDistribution.Client.Check"Distribution.Client.TargetSelector:Distribution.Client.CmdInstall.ClientInstallTargetSelector(Distribution.Deprecated.ViewAsFieldDescrDistribution.Client.VersionDistribution.Client.HttpUtilsDistribution.Client.GlobalFlagsDistribution.Client.FetchUtilsDistribution.Client.TargetsDistribution.Client.ReplFlags#Distribution.Client.NixStyleOptionsDistribution.Client.Manpage"Distribution.Client.InstallSymlinkDistribution.Client.Config.Distribution.Client.Sandbox.PackageEnvironment(Distribution.Client.ProjectConfig.LegacyDistribution.Client.Nix!Distribution.Client.DistDirLayoutDistribution.Client.Store)Distribution.Client.ProjectPlanning.TypesDistribution.Client.SourceFiles/Distribution.Client.ProjectPlanning.SetupPolicy%Distribution.Client.ProjectPlanOutput!Distribution.Client.ProjectConfig Distribution.Client.SetupWrapperDistribution.Client.SandboxDistribution.Client.CmdLegacyDistribution.Client.ListDistribution.Client.InitDistribution.Client.GetDistribution.Client.FreezeDistribution.Client.GenBoundsDistribution.Client.FetchDistribution.Client.ConfigureDistribution.Client.ReconfigureDistribution.Client.CmdClean*Distribution.Client.BuildReports.Anonymous'Distribution.Client.BuildReports.UploadDistribution.Client.Upload(Distribution.Client.BuildReports.Storage#Distribution.Client.ProjectPlanning!Distribution.Client.TargetProblem6Distribution.Client.ProjectBuilding.PackageFileMonitor3Distribution.Client.ProjectBuilding.UnpackedPackage#Distribution.Client.ProjectBuilding$Distribution.Client.CmdErrorMessagesDistribution.Client.ScriptUtilsDistribution.Client.CmdUpdateDistribution.Client.CmdTestDistribution.Client.CmdSdistDistribution.Client.CmdRunDistribution.Client.CmdReplDistribution.Client.CmdPathDistribution.Client.CmdOutdatedDistribution.Client.CmdListBinDistribution.Client.CmdInstallDistribution.Client.CmdHaddock Distribution.Client.CmdGenBoundsDistribution.Client.CmdFreezeDistribution.Client.CmdExec Distribution.Client.CmdConfigureDistribution.Client.CmdBuildDistribution.Client.CmdTargetDistribution.Client.CmdBenchDistribution.Client.InstallDistribution.Client.Main cabal-install)src/Distribution/Client/Compat/Orphans.hs-src/Distribution/Client/BuildReports/Types.hs+src/Distribution/Client/Compat/Semaphore.hs+src/Distribution/Client/Dependency/Types.hs%src/Distribution/Client/Compat/Tar.hs$src/Distribution/Client/HashValue.hs/src/Distribution/Client/IndexUtils/Timestamp.hs'src/Distribution/Client/ManpageFlags.hs'src/Distribution/Client/ProjectFlags.hs%src/Distribution/Client/SavedFlags.hs!src/Distribution/Client/Signal.hs+src/Distribution/Client/Types/AllowNewer.hs-src/Distribution/Client/Types/BuildResults.hs-src/Distribution/Client/Types/ConfiguredId.hs2src/Distribution/Client/Types/ConfiguredPackage.hs.src/Distribution/Client/Types/InstallMethod.hs0src/Distribution/Client/Types/OverwritePolicy.hs8src/Distribution/Client/CmdInstall/ClientInstallFlags.hs1src/Distribution/Client/Types/PackageSpecifier.hs)src/Distribution/Client/Types/RepoName.hs%src/Distribution/Client/Types/Repo.hs0src/Distribution/Client/IndexUtils/IndexState.hs1src/Distribution/Client/IndexUtils/ActiveRepos.hsDistribution.Types.SourceRepo SourceRepo+src/Distribution/Client/Types/SourceRepo.hs0src/Distribution/Client/Types/PackageLocation.hs PackageIndexlookupDependencylookupPackageNameSourcePackageDbpackagePreferences0src/Distribution/Client/Types/SourcePackageDb.hs-src/Distribution/Client/Types/ReadyPackage.hs?src/Distribution/Client/Types/WriteGhcEnvironmentFilesPolicy.hsDistribution.Client.TypesdependencyCyclesbrokenPackagesdependencyInconsistencies,src/Distribution/Client/SolverInstallPlan.hs&src/Distribution/Client/PackageHash.hs%src/Distribution/Client/Utils/Json.hs$src/Distribution/Deprecated/ReadP.hs"Distribution.Deprecated.ParseUtils)src/Distribution/Deprecated/ParseUtils.hs)Distribution.Deprecated.ProjectParseUtils0src/Distribution/Deprecated/ProjectParseUtils.hs!src/Distribution/Client/Errors.hs&src/Distribution/Client/InstallPlan.hs%src/Distribution/Client/Init/Types.hs%src/Distribution/Client/Init/Utils.hs,src/Distribution/Client/Init/FileCreators.hs&src/Distribution/Client/FileMonitor.hs'src/Distribution/Client/RebuildMonad.hssrc/Distribution/Client/VCS.hs InstallPlan Installed PreExisting0src/Distribution/Client/ProjectBuilding/Types.hs%src/Distribution/Client/Dependency.hs)src/Distribution/Client/TargetSelector.hssrc/Distribution/Client/CmdInstall/ClientInstallTargetSelector.hsPaths_cabal_install$src/Distribution/Client/HttpUtils.hs(src/Distribution/Client/Security/HTTP.hs&src/Distribution/Client/GlobalFlags.hs"src/Distribution/Client/Targets.hs src/Distribution/Client/Setup.hs$src/Distribution/Client/ReplFlags.hs)src/Distribution/Client/InstallSymlink.hsreadProjectConfig.src/Distribution/Client/ProjectConfig/Types.hs!src/Distribution/Client/Config.hs5src/Distribution/Client/Sandbox/PackageEnvironment.hs/src/Distribution/Client/ProjectConfig/Legacy.hs(src/Distribution/Client/DistDirLayout.hs src/Distribution/Client/Store.hs0src/Distribution/Client/ProjectPlanning/Types.hs6src/Distribution/Client/ProjectPlanning/SetupPolicy.hsSet intersection differenceTar FormatError(src/Distribution/Client/ProjectConfig.hs ConfiguregetInstalledPackagesread%src/Distribution/Client/IndexUtils.hs$src/Distribution/Client/CmdLegacy.hssrc/Distribution/Client/Get.hsDistribution.ClientInit&src/Distribution/Client/Reconfigure.hs#src/Distribution/Client/CmdClean.hs*src/Distribution/Client/ProjectPlanning.hs(src/Distribution/Client/TargetProblem.hsProjectPlanningpruneInstallPlanToTargets/src/Distribution/Client/ProjectOrchestration.hsDistribution.Types.LibraryLibrary&src/Distribution/Client/ScriptUtils.hs$src/Distribution/Client/CmdUpdate.hs"src/Distribution/Client/CmdTest.hs#src/Distribution/Client/CmdSdist.hs!src/Distribution/Client/CmdRun.hs"src/Distribution/Client/CmdRepl.hs"src/Distribution/Client/CmdPath.hs&src/Distribution/Client/CmdOutdated.hs%src/Distribution/Client/CmdListBin.hs#src/Distribution/Client/CmdBench.hsCabal-syntax-3.16.1.0-inplace Distribution.Types.ComponentName ComponentName CBenchNameCExeName CFLibNameCLibName CNotLibName CTestNameCabal-3.16.1.0-inplace!Distribution.Simple.Glob.Internal GlobPieceWildCardLiteralUnion GlobPiecesGlobGlobDirGlobDirRecursiveGlobFileGlobDirTrailing%Distribution.Simple.FileMonitor.TypesMonitorFilePath FilePathRootFilePathRelativeFilePathHomeDir RootedGlob monitorFilemonitorFileHashedmonitorNonExistentFilemonitorDirectorymonitorNonExistentDirectorymonitorDirectoryExistencemonitorFileOrDirectorymonitorFileGlobmonitorFileGlobExistencemonitorFileSearchPathmonitorFileHashedSearchPathDistribution.Types.ParStratisParallelBuildParStrat ParStratXNumJobsSerialUseSemDistribution.Verbosity Verbosity!Distribution.Simple.Program.TypesConfiguredProgramProgram Distribution.Simple.Setup.CommonCommonSetupFlagssetupCabalFilePath setupDistPrefsetupKeepTempFiles setupTargetssetupVerbositysetupWorkingDir!Distribution.Simple.Setup.HaddockhaddockProjectCommand Distribution.Simple.Setup.Config ConfigFlagsConfigCommonFlags!configAllowDependingOnPrivateLibsconfigBenchmarks configCIDconfigCabalFilePathconfigCommonFlagsconfigConfigurationsFlagsconfigConfigureArgsconfigConstraintsconfigCoverageconfigCoverageForconfigDebugInfoconfigDependenciesconfigDeterministicconfigDistPrefconfigDumpBuildInfo configDynExeconfigExactConfigurationconfigExtraFrameworkDirsconfigExtraIncludeDirsconfigExtraLibDirsconfigExtraLibDirsStaticconfigFlagErrorconfigFullyStaticExe configGHCiLibconfigHcFlavor configHcPath configHcPkg configIPIDconfigIgnoreBuildToolsconfigInstallDirsconfigInstantiateWithconfigLibCoverageconfigOptimizationconfigPackageDBs configProfconfigProfDetail configProfExe configProfLibconfigProfLibDetailconfigProfSharedconfigProgPrefixconfigProgSuffixconfigProgramArgsconfigProgramPathExtraconfigProgramPathsconfigPrograms_configPromisedDependenciesconfigRelocatableconfigScratchDirconfigSharedLibconfigSplitObjsconfigSplitSectionsconfigStaticLibconfigStripExesconfigStripLibs configTargets configTestsconfigUseResponseFilesconfigUserInstallconfigVanillaLibconfigVerbosityconfigWorkingDirDistribution.Simple.Setup.Build BuildFlagsBuildCommonFlagsbuildCabalFilePathbuildCommonFlags buildDistPref buildNumJobsbuildProgramArgsbuildProgramPaths buildTargetsbuildUseSemaphorebuildVerbositybuildWorkingDirDistribution.Simple.Configure getInstalledPackagesMonitorFiles ghc-internalGHC.Internal.Text.Read readMaybe)GHC.Internal.Text.ParserCombinators.ReadPReadSDistribution.Pretty prettyShowDistribution.Types.PackageId PackageIdDistribution.Utils.StringtrimPrettyprettyprettyVersioned$dmprettyVersionedDistribution.Parsec eitherParsecexplicitEitherParsec simpleParsec CabalParsingParsecparsecRepoType%cabal-install-solver-3.16.1.0-inplace+Distribution.Solver.Types.PackageConstraint scopeToplevelPackageConstraintPackagePropertyPackagePropertyFlagsPackagePropertyInstalledPackagePropertySourcePackagePropertyStanzasPackagePropertyVersion"Distribution.Solver.Types.Progress foldProgressProgressDoneFailStep)Distribution.Solver.Types.ResolverPackageResolverPackage Configureddirectory-1.3.9.0-1539b8325864ecaffa7c16e3d5bdfe0bf79338bddb5a1638376928a137f60cb2System.DirectorycreateFileLinkgetSymbolicLinkTargetpathIsSymbolicLinksetModificationTime hackage-security-0.6.3.2-inplace*Hackage.Security.Client.Repository.HttpLibHttpLibgetExecutablePath$fBinarySomeException $fBinaryURI$fBinaryURIAuth$fStructuredSomeException$fStructuredURI BuildReportarchclientcompiler dependencies docsOutcomeflagAssignmentinstallOutcomeospackage testsOutcomeInstallOutcome BuildFailedConfigureFailedDependencyFailedDownloadFailed InstallFailed InstallOkPlanningFailed SetupFailed TestsFailed UnpackFailedOutcomeFailedNotTriedOk ReportLevelAnonymousReportsDetailedReports NoReports$fBinaryReportLevel$fBoundedOutcome$fBoundedReportLevel $fEnumOutcome$fEnumReportLevel$fEqBuildReport$fEqInstallOutcome $fEqOutcome$fEqReportLevel$fGenericBuildReport$fGenericInstallOutcome$fGenericOutcome$fGenericReportLevel$fOrdReportLevel$fParsecInstallOutcome$fParsecOutcome$fParsecReportLevel$fPrettyInstallOutcome$fPrettyOutcome$fPrettyReportLevel$fShowBuildReport$fShowInstallOutcome $fShowOutcome$fShowReportLevel$fStructuredReportLevelnewQSem signalQSemwaitQSemQSem$fEqQSemPackagesPreferenceDefaultPreferAllInstalledPreferAllLatestPreferAllOldestPreferLatestForSelected PreSolver AlwaysModularSolverModular$fBinaryPreSolver$fBinarySolver$fBoundedPreSolver$fBoundedSolver$fEnumPreSolver $fEnumSolver $fEqPreSolver $fEqSolver$fGenericPreSolver$fGenericSolver$fOrdPreSolver $fOrdSolver$fParsecPreSolver$fPrettyPreSolver$fShowPackagesPreferenceDefault$fShowPreSolver $fShowSolver$fStructuredPreSolver$fStructuredSolvermaybeDecompresscreateTarGzFileextractTarGzFiletar-0.7.0.0-l-tar-internal-0357a08317bc6cf7c691657548a57787ba08d0091f250159adca9d205db97308Codec.Archive.Tar.TypesEntriesEntry GenEntriesNext entryContentGenEntryContent BlockDeviceCharacterDevice DirectoryHardLink NamedPipe NormalFileOtherEntryType SymbolicLink$fExceptionEithergetFilePathRootDirectoryisTrivialRootedGlob matchFileGlobregenerateHaddockIndex hashFromTUF hashValuereadFileHashValue showHashValue truncateHash HashValue$fBinaryHashValue $fEqHashValue$fGenericHashValue$fShowHashValue$fStructuredHashValueepochTimeToTimestampmaximumTimestamptimestampToUTCTimeutcTimeToTimestamp Timestamp NoTimestamp$fBinaryTimestamp $fEqTimestamp$fGenericTimestamp$fNFDataTimestamp$fOrdTimestamp$fParsecTimestamp$fPrettyTimestamp$fShowTimestamp$fStructuredTimestampagplv3apache20bsd2bsd3gplv2gplv3isclgpl21lgpl3mitmpl20LicensedefaultManpageFlagsmanpageOptions ManpageFlags manpageRawmanpageVerbosity$fEqManpageFlags$fGenericManpageFlags$fMonoidManpageFlags$fSemigroupManpageFlags$fShowManpageFlagsdefaultProjectFlagsprojectFlagsOptionsremoveIgnoreProjectOption ProjectFlagsflagIgnoreProjectflagProjectDirflagProjectFile$fGenericProjectFlags$fMonoidProjectFlags$fSemigroupProjectFlags$fShowProjectFlagsreadCommandFlags readSavedArgswriteCommandFlagswriteSavedArgs$fExceptionSavedArgsError$fShowSavedArgsErrorqueryBootstrapMirrorsinstallTerminationHandler Terminated$fExceptionTerminated$fShowTerminatedbuildTreeRefTypeCodebuildTreeSnapshotTypeCode entriesToList filterEntriesfilterEntriesMisBuildTreeRefTypeCode isRelaxDepsmkRelaxDepSome AllowNewer unAllowNewer AllowOlder unAllowOlder RelaxDepModRelaxDepModCaretRelaxDepModNone RelaxDepScopeRelaxDepScopeAllRelaxDepScopePackageRelaxDepScopePackageIdRelaxDepSubjectRelaxDepSubjectAllRelaxDepSubjectPkg RelaxDeps RelaxDepsAll RelaxDepsSome RelaxedDep$fBinaryAllowNewer$fBinaryRelaxedDep$fBinaryAllowOlder$fBinaryRelaxDepMod$fBinaryRelaxDepScope$fBinaryRelaxDepSubject$fBinaryRelaxDeps$fEqAllowNewer$fEqRelaxedDep$fEqAllowOlder$fEqRelaxDepMod$fEqRelaxDepScope$fEqRelaxDepSubject $fEqRelaxDeps$fGenericAllowNewer$fGenericAllowOlder$fGenericRelaxDepMod$fGenericRelaxDepScope$fGenericRelaxDepSubject$fGenericRelaxDeps$fGenericRelaxedDep$fMonoidAllowNewer$fSemigroupAllowNewer$fMonoidAllowOlder$fSemigroupAllowOlder$fMonoidRelaxDeps$fSemigroupRelaxDeps$fOrdRelaxDepSubject$fParsecRelaxDepSubject$fParsecRelaxDeps$fParsecRelaxedDep$fPrettyRelaxDepSubject$fPrettyRelaxDeps$fPrettyRelaxedDep$fReadAllowNewer$fReadAllowOlder$fReadRelaxDepMod$fReadRelaxDepScope$fReadRelaxDepSubject$fReadRelaxDeps$fReadRelaxedDep$fShowAllowNewer$fShowAllowOlder$fShowRelaxDepMod$fShowRelaxDepScope$fShowRelaxDepSubject$fShowRelaxDeps$fShowRelaxedDep$fStructuredAllowNewer$fStructuredAllowOlder$fStructuredRelaxDepMod$fStructuredRelaxDepScope$fStructuredRelaxDepSubject$fStructuredRelaxDeps$fStructuredRelaxedDep BuildFailureDependentFailedGracefulFailure BuildOutcome BuildOutcomes BuildResult DocsResult DocsFailed DocsNotTriedDocsOk TestsResult TestsNotTriedTestsOk$fBinaryBuildFailure$fBinaryBuildResult$fBinaryDocsResult$fBinaryTestsResult$fExceptionBuildFailure$fShowBuildFailure$fGenericBuildFailure$fGenericBuildResult$fGenericDocsResult$fGenericTestsResult$fShowBuildResult$fShowDocsResult$fShowTestsResult$fStructuredBuildFailure$fStructuredBuildResult$fStructuredDocsResult$fStructuredTestsResultannotatedIdToConfiguredId ConfiguredId confCompName confInstId confSrcIdHasConfiguredId configuredIdInstalledPackageId$fBinaryConfiguredId$fEqConfiguredId$fGenericConfiguredId%$fHasConfiguredIdInstalledPackageInfo$fOrdConfiguredId$fPackageConfiguredId$fShowConfiguredId$fStructuredConfiguredIdConfiguredPackage confPkgDeps confPkgFlags confPkgId confPkgSourceconfPkgStanzas$fBinaryConfiguredPackage$fEqConfiguredPackage$fGenericConfiguredPackage"$fHasConfiguredIdConfiguredPackage%$fHasMungedPackageIdConfiguredPackage$fHasUnitIdConfiguredPackage$fIsNodeConfiguredPackage$fPackageConfiguredPackage#$fPackageFixedDepsConfiguredPackage#$fPackageInstalledConfiguredPackage$fShowConfiguredPackageAuthPassword unPasswordTokenunTokenUsername unUsername InstallMethodInstallMethodCopyInstallMethodSymlink$fBinaryInstallMethod$fBoundedInstallMethod$fEnumInstallMethod$fEqInstallMethod$fGenericInstallMethod$fParsecInstallMethod$fPrettyInstallMethod$fSemigroupInstallMethod$fShowInstallMethod$fStructuredInstallMethodOverwritePolicyAlwaysOverwriteNeverOverwritePromptOverwrite$fBinaryOverwritePolicy$fBoundedOverwritePolicy$fEnumOverwritePolicy$fEqOverwritePolicy$fGenericOverwritePolicy$fParsecOverwritePolicy$fPrettyOverwritePolicy$fShowOverwritePolicy$fStructuredOverwritePolicyclientInstallOptionsdefaultClientInstallFlagsClientInstallFlagscinstEnvironmentPathcinstInstallLibscinstInstallMethodcinstInstalldircinstOverwritePolicy$fBinaryClientInstallFlags$fEqClientInstallFlags$fGenericClientInstallFlags$fMonoidClientInstallFlags$fSemigroupClientInstallFlags$fShowClientInstallFlags$fStructuredClientInstallFlagsmkNamedPackagepkgSpecifierConstraintspkgSpecifierTargetPackageSpecifier NamedPackageSpecificSourcePackage$fBinaryPackageSpecifier$fEqPackageSpecifier$fFunctorPackageSpecifier$fGenericPackageSpecifier$fShowPackageSpecifier$fStructuredPackageSpecifierRepoName unRepoName$fBinaryRepoName $fEqRepoName$fGenericRepoName$fNFDataRepoName $fOrdRepoName$fParsecRepoName$fPrettyRepoName$fShowRepoName$fStructuredRepoNameemptyLocalRepoemptyRemoteRepo isRepoRemotelocalRepoCacheKeymaybeRepoRemotenormaliseFileNoIndexURIrepoName LocalRepo localRepoName localRepoPathlocalRepoSharedCache RemoteReporemoteRepoKeyThresholdremoteRepoNameremoteRepoRootKeysremoteRepoSecureremoteRepoShouldTryHttps remoteRepoURIRepoRepoLocalNoIndex RepoRemote RepoSecure repoLocal repoLocalDir repoRemote$fBinaryLocalRepo$fBinaryRemoteRepo $fBinaryRepo $fEqLocalRepo$fEqRemoteRepo$fEqRepo$fGenericLocalRepo$fGenericRemoteRepo $fGenericRepo$fOrdLocalRepo$fOrdRemoteRepo $fOrdRepo$fParsecLocalRepo$fParsecRemoteRepo$fPrettyLocalRepo$fPrettyRemoteRepo$fShowLocalRepo$fShowRemoteRepo $fShowRepo$fStructuredLocalRepo$fStructuredRemoteRepo$fStructuredRepoheadTotalIndexStateinsertIndexStatelookupIndexStatemakeTotalIndexStateRepoIndexStateIndexStateHeadIndexStateTimeTotalIndexState$fBinaryRepoIndexState$fBinaryTotalIndexState$fEqRepoIndexState$fEqTotalIndexState$fGenericRepoIndexState$fGenericTotalIndexState$fNFDataRepoIndexState$fNFDataTotalIndexState$fParsecRepoIndexState$fParsecTotalIndexState$fPrettyRepoIndexState$fPrettyTotalIndexState$fShowRepoIndexState$fShowTotalIndexState$fStructuredRepoIndexState$fStructuredTotalIndexStatedefaultActiveReposfilterSkippedActiveReposorganizeByReposActiveRepoEntry ActiveRepoActiveRepoRest ActiveReposCombineStrategyCombineStrategyMergeCombineStrategyOverrideCombineStrategySkip$fBinaryActiveRepoEntry$fBinaryActiveRepos$fBinaryCombineStrategy$fBoundedCombineStrategy$fEnumCombineStrategy$fEqActiveRepoEntry$fEqActiveRepos$fEqCombineStrategy$fGenericActiveRepoEntry$fGenericActiveRepos$fGenericCombineStrategy$fNFDataActiveRepoEntry$fNFDataActiveRepos$fNFDataCombineStrategy$fParsecActiveRepoEntry$fParsecActiveRepos$fParsecCombineStrategy$fPrettyActiveRepoEntry$fPrettyActiveRepos$fPrettyCombineStrategy$fShowActiveRepoEntry$fShowActiveRepos$fShowCombineStrategy$fStructuredActiveRepoEntry$fStructuredActiveRepos$fStructuredCombineStrategysourceRepositoryPackageGrammar srpFanOutsrpHoist srpToProxySourceRepoListSourceRepoMaybeSourceRepoProxySourceRepositoryPackage srpBranch srpCommand srpLocation srpSubdirsrpTagsrpType$fBinarySourceRepositoryPackage$fEqSourceRepositoryPackage $fGenericSourceRepositoryPackage$fOrdSourceRepositoryPackage$fShowSourceRepositoryPackage#$fStructuredSourceRepositoryPackagePackageLocationLocalTarballPackageLocalUnpackedPackageRemoteSourceRepoPackageRemoteTarballPackageRepoTarballPackageResolvedPkgLocUnresolvedPkgLocUnresolvedSourcePackage$fBinaryPackageLocation$fEqPackageLocation$fFunctorPackageLocation$fGenericPackageLocation$fOrdPackageLocation$fShowPackageLocation$fStructuredPackageLocation packageIndex$fBinarySourcePackageDb$fEqSourcePackageDb$fGenericSourcePackageDbGenericReadyPackage ReadyPackage$fBinaryGenericReadyPackage$fEqGenericReadyPackage$fGenericGenericReadyPackage'$fHasMungedPackageIdGenericReadyPackage$fHasUnitIdGenericReadyPackage$fIsNodeGenericReadyPackage%$fPackageFixedDepsGenericReadyPackage$fPackageGenericReadyPackage%$fPackageInstalledGenericReadyPackage$fShowGenericReadyPackageWriteGhcEnvironmentFilesPolicyAlwaysWriteGhcEnvironmentFilesNeverWriteGhcEnvironmentFiles-WriteGhcEnvironmentFilesOnlyForGhc844AndNewer&$fBinaryWriteGhcEnvironmentFilesPolicy'$fBoundedWriteGhcEnvironmentFilesPolicy$$fEnumWriteGhcEnvironmentFilesPolicy"$fEqWriteGhcEnvironmentFilesPolicy'$fGenericWriteGhcEnvironmentFilesPolicy$$fShowWriteGhcEnvironmentFilesPolicy*$fStructuredWriteGhcEnvironmentFilesPolicyacyclicclosed consistentdependencyClosurenewproblemsremovereverseDependencyClosurereverseTopologicalOrdershowInstallPlan showPlanIndexshowPlanProblemtoListtoMaptopologicalOrdervalidSolverInstallPlanplanIndepGoals planIndexSolverPlanPackageSolverPlanProblem PackageCyclePackageInconsistencyPackageMissingDepsPackageStateInvalid$fBinarySolverInstallPlan$fGenericSolverInstallPlan$fStructuredSolverInstallPlanhashPackageHashInputshashedInstalledPackageIdhashedInstalledPackageIdLonghashedInstalledPackageIdShortrenderPackageHashInputsPackageHashConfigInputspkgHashCompilerABIpkgHashCompilerIdpkgHashConfigureScriptArgspkgHashCoveragepkgHashDebugInfopkgHashDocumentation pkgHashDynExepkgHashExtraFrameworkDirspkgHashExtraIncludeDirspkgHashExtraLibDirspkgHashExtraLibDirsStaticpkgHashFlagAssignmentpkgHashFullyStaticExepkgHashGHCiLibpkgHashHaddockBaseUrlpkgHashHaddockBenchmarkspkgHashHaddockContentspkgHashHaddockCsspkgHashHaddockExecutablespkgHashHaddockForeignLibspkgHashHaddockHooglepkgHashHaddockHtmlpkgHashHaddockHtmlLocationpkgHashHaddockIndexpkgHashHaddockInternalpkgHashHaddockLinkedSourcepkgHashHaddockOutputDirpkgHashHaddockQuickJumppkgHashHaddockResourcesDirpkgHashHaddockTestSuitespkgHashHaddockUseUnicodepkgHashOptimizationpkgHashPackageDbspkgHashPlatformpkgHashProfExepkgHashProfExeDetailpkgHashProfLibpkgHashProfLibDetailpkgHashProgPrefixpkgHashProgSuffixpkgHashProgramArgspkgHashSharedLibpkgHashSplitObjspkgHashSplitSectionspkgHashStripExespkgHashStripLibspkgHashVanillaLibPackageHashInputspkgHashComponentpkgHashDirectDepspkgHashOtherConfigpkgHashPkgConfigDeps pkgHashPkgIdpkgHashSourceHashPackageSourceHash$fShowPackageHashConfigInputs.=encodeToBuilderencodeToStringobjectObjectPairToJSONtoJSONValueArrayBoolNullNumberString $fEqValue$fIsStringValue $fReadValue $fShowValue $fToJSONBool$fToJSONDouble $fToJSONFloat $fToJSONInt $fToJSONInt16 $fToJSONInt32 $fToJSONInt64 $fToJSONInt8$fToJSONInteger $fToJSONList $fToJSONMaybe$fToJSONTuple2$fToJSONTuple3$fToJSONTuple4 $fToJSONUnit $fToJSONValue $fToJSONWord$fToJSONWord16$fToJSONWord32$fToJSONWord64 $fToJSONWord8renderParseError+++<++betweenchainlchainl1chainrchainr1charchoicecountendByendBy1eofgathergetlookmanymany1manyTillmunchmunch1optionoptionalpfail readP_to_E readP_to_S readS_to_PsatisfysepBysepBy1skipMany skipMany1 skipSpaces skipSpaces1stringParserReadP$fAlternativeP$fApplicativeP$fAlternativeParser$fApplicativeParser $fFunctorP$fFunctorParser $fMonadFailP$fMonadP$fMonadFailParser $fMonadParser $fMonadPlusP$fMonadPlusParser liftField FieldDescrfieldGet fieldNamefieldSetexceptionCodeCabalInstallexceptionMessageCabalInstallCabalInstallExceptionBenchActionExceptionBrokenExceptionCabalFileNotFoundCan'tDownloadPackagesOfflineCan'tWriteMultipleTarballsCannotConvertTarballPackageCannotParseURIFragmentCannotReadCabalFile CheckAction CheckTarget CleanActionCmdErrorMessagesCmdHaddockReportTargetProblemsCmdPathAcceptsNoTargets"CmdPathCommandDoesn'tSupportDryRunCmdRunReportTargetProblemsConfigBenchmarksConfigStateFileException ConfigTestsConfigureInstallInternalErrorCorruptedIndexCacheCouldNotFindExecutableCouldn'tEstablishHttpConnectionDieIfNotHaddockFailureExceptionDirectoryAlreadyExistsDirectoryExistsEmptyValuePagerEnvVariableErrorPackingSdistErrorUpdatingIndexExpectedMatchingFileNameExtractTarballPackageErrFailNoConfigFileFailedExtractingScriptBlockFailedToDownloadURI FetchPackageFetchPackageErrFileAlreadyExistsFileDoesntExist FileExists FileNotFoundFinalizePDFailedFindOpenProgramLocationErrFoundMultipleMatchingExes FreezeActionFreezeExceptionFreezeFileExistsErr GatherPkgInfoGenBoundsDoesNotSupportScript GetPkgListHaddockCommandDoesn'tSupportImpossibleHappened InitActionInstallUnitExesInstalledCabalVersion InternalErrorListBinTargetException MakeDownload ManpageActionMatchingInternalErrorErrMissingPackageListMultipleMatchingExecutablesMultipleTargetsFoundNoOrMultipleTargetsGiven NoPostYetNoRemoteRepositoriesNoSuchTargetSelectorErrNoSupportForRunCommand NoTargetFoundNoTargetProvidedNotATarDotGzFile NotTarballDirNullUnknownreposOneTargetRequiredOutdatedActionPackageDotCabalFileNotFoundPackageNameAmbiguousErrPackagesAlreadyExistInEnvfile ParseErrorParseExtraLinesFailedErrParseExtraLinesOkErrorParseFailedErrPhaseRunSolverErrPkgConfParseFailedPkgConfParsedFailedPkgSpecifierException PlanPackagesProjectTargetSelectorReadIndexCacheReadTarballPackageTargetRemoteRepoCheckHttpsRenderBenchTargetProblemRenderReplTargetProblemReplCommandDoesn'tSupportReplTakesNoArgumentsReplTakesSingleArgument ReportActionReportCannotPruneDependenciesReportPackageTargetProblemsReportParseResultReportPlanningFailureReportSourceRepoProblemsReportTargetProblemsReportTargetSelectorProblemsReportUserTargerNonexistantFileReportUserTargetProblemsReportUserTargetUnexpectedFile#ReportUserTargetUnexpectedUriSchemeReportUserTargetUnrecognisedUriResolveWithoutDependencyRunPhaseReachedSdistActionExceptionSdistExceptionSelectComponentTargetErrorSomePackagesFailedToInstallSpecifyAnExecutableSpecifySubcommand SplitRunArgsStatusParseFailTargetSelectorAmbiguousErr!TargetSelectorNoCurrentPackageErrTargetSelectorNoScriptErr!TargetSelectorNoTargetsInCwdFalse TargetSelectorNoTargetsInCwdTrue#TargetSelectorNoTargetsInProjectErrTestCommandDoesn'tSupport ThisIsABugTransportCheckHttpsTryFindPackageDescErrTryUpgradeToHttpsUnableToParseRepoUnableToPerformInplaceUpdateUnexpectedNamedPkgSpecifiersUnexpectedSourcePkgSpecifiersUnknownExecutableUnknownHttpTransportSpecifiedUnknownPackageUnknownUserConfigSubcommand UnpackGetUnrecognisedTargetUnrecognizedResponseUnusableIndexStateUpdateSetupScript UploadActionUploadActionDocumentationUploadActionOnlyArchivesUserConfigActionWGetServerErrorWin32SelfUpgradeNotNeededWithoutProject$fExceptionVerboseException$fShowCabalInstallExceptiondeleteOldExeFilepossibleSelfUpgradebyteStringToFilePathcanonicalizePathNoThrow concatMapMdetermineNumJobs duplicates duplicatesByexistsAndIsMoreRecentThanfilePathToByteStringgetCurrentYeargiveRTSWarninghasElem incVersionlistFilesInsidelistFilesRecursive logDirChangemakeAbsoluteToCwdmakeRelativeCanonicalmakeRelativeToCwdmakeRelativeToDirmakeRelativeToDirSmergeBymoreRecentFilenumberOfProcessorsoccursOnlyOrBeforeprogressMessagepvpizerelaxEncodingErrorsremoveExistingFilesafeReadtryCanonicalizePathtryReadAddSourcePackageDesctryReadGenericPackageDescwithEnvwithEnvOverrideswithExtraPathEnvwithTempFileName MergeResultInBoth OnlyInLeft OnlyInRight ProgressPhaseProgressBuildingProgressCompletedProgressDownloadedProgressDownloadingProgressHaddockProgressInstallingProgressStartingcriticalSectionmapConcurrentWithJobsnewJobControlFromParStrat newJobLimitnewLocknewParallelJobControlnewSemaphoreJobControlnewSerialJobControlwithJobControl withJobLimit JobControl cancelJobscleanupJobControl collectJobjobControlSemaphore remainingJobsspawnJobJobLimitLock completedconfigureInstallPlandepends directDepsexecuteexecutionOrderfailedfoldPlanPackagefromSolverInstallPlan!fromSolverInstallPlanWithProgress installedkeyskeysSetlookuplookupBuildOutcomeready revDirectDepsshowInstallPlan_gen showPlanGraphshowPlanPackageTagtoGraphGenericInstallPlanGenericPlanPackageIsUnit PlanPackage Processing ShowPlanNodeshowPlanHeraldshowPlanNeighbours$fBinaryGenericInstallPlan$fBinaryGenericPlanPackage$fEqGenericPlanPackage$fGenericGenericPlanPackage#$fHasConfiguredIdGenericPlanPackage&$fHasMungedPackageIdGenericPlanPackage$fHasUnitIdGenericPlanPackage$fIsNodeGenericPlanPackage$fPackageGenericPlanPackage$fShowGenericPlanPackage$fStructuredGenericInstallPlan$fStructuredGenericPlanPackage evalPromptfromHsFilePath isHsFilePath mkLiterate runPrompt runPromptIO toHsFilePath toLiterateHs toStandardHsBreakException DefaultPromptMandatoryPromptOptionalPrompt ExeTarget_exeApplicationDirs_exeBuildTools_exeDependencies _exeLanguage _exeMainIs _exeOtherExts_exeOtherModulesFieldAnnotationannCommentLinesannCommentedOut HsFilePath _hsFilePath _hsFileType HsFileType InvalidHsPathLiterateStandard InitFlagsapplicationDirsauthor buildTools cabalVersioncategoryemailexposedModulesextraDocextraSrchomepage initHcPath initVerbosityinitializeTestSuite interactivelanguagelicensemainIsminimal noComments otherExts otherModules overwrite packageDir packageName packageTypequiet simpleProject sourceDirssynopsistestDirsversionInputs InteractivebreakcopyFilecreateDirectorydoesDirectoryExist doesFileExistgetCurrentDirectorygetDirectoryContentsgetEnvironmentgetHomeDirectorygetLastChosenLanguagegetLinehFlush listDirectorymaybeReadProcessWithExitCodemessageputStrputStrLnreadFilereadProcessWithExitCoderemoveDirectoryrenameDirectorysetLastChosenLanguage throwPrompt writeFile IsLiterateIsSimple LibTarget_libBuildTools_libDependencies_libExposedModules _libLanguage _libOtherExts_libOtherModules_libSourceDirs PackageType ExecutableLibraryAndExecutable TestSuitePkgDescription _pkgAuthor_pkgCabalVersion _pkgCategory _pkgEmail_pkgExtraDocFiles_pkgExtraSrcFiles _pkgHomePage _pkgLicense_pkgName _pkgSynopsis _pkgVersionProjectSettings_pkgDesc _pkgExeTarget _pkgLibTarget_pkgOpts_pkgTestTargetPromptIO PurePromptSeverityErrorInfoWarning TestTarget_testBuildTools_testDependencies _testDirs _testLanguage _testMainIs_testOtherExts_testOtherModules WriteOpts _optCabalSpec _optMinimal_optNoComments _optOverwrite _optPkgDir _optPkgName _optPkgType _optVerbosity$fApplicativePromptIO$fFunctorPromptIO$fApplicativePurePrompt$fFunctorPurePrompt$fEqBreakException$fEqDefaultPrompt $fEqExeTarget$fEqHsFilePath$fEqHsFileType $fEqInitFlags $fEqLibTarget$fEqPackageType$fEqPkgDescription$fEqProjectSettings $fEqSeverity$fEqTestTarget $fEqWriteOpts$fExceptionBreakException$fShowBreakException$fFunctorDefaultPrompt$fGenericInitFlags$fGenericPackageType$fInteractivePromptIO$fMonadPromptIO$fInteractivePurePrompt$fMonadPurePrompt$fMonadIOPromptIO$fMonoidInitFlags$fSemigroupInitFlags$fShowExeTarget$fShowHsFilePath$fShowHsFileType$fShowInitFlags$fShowLibTarget$fShowPackageType$fShowPkgDescription$fShowProjectSettings$fShowTestTarget$fShowWriteOptsprompt promptList promptStr promptYesNo annNoCommentscommentedOutWithCommentsfieldfieldD listFieldSmkCommonStanza mkExeStanza mkLibStanzamkPkgDescription mkTestStanzapostProcessFieldLines withCommentsdefaultApplicationDirdefaultCabalVersiondefaultCabalVersionsdefaultCategoriesdefaultChangelogdefaultInitFlagsdefaultLanguagedefaultLicensedefaultLicenseIds defaultMainIsdefaultPackageTypedefaultSourceDirdefaultTestDirdefaultVersionmyExeHs myLibExeHs myLibFilemyLibHs myLibModule myLibTestFilemyTestHsaddLibDepToExeaddLibDepToTestcurrentDirPkgNamefilePathToPkgName fixupDocFiles getBaseDep isHaskellisMain isSourceFilemkPackageNameDep mkStringyDepretrieveBuildToolsretrieveDependenciesretrieveModuleExtensionsretrieveModuleImportsretrieveModuleNameretrieveSourceFilesSourceFileEntry extensions fileExtensionimports moduleNamerelativeSourcePath$fShowSourceFileEntrydependenciesPrompt getAppDirs getAuthor getBuildToolsgetCabalVersiongetCabalVersionNoPrompt getCategorygetDependenciesgetEmailgetExposedModulesgetExtraDocFilesgetExtraSrcFiles getHomepagegetInitializeTestSuite getLanguage getLicense getMainFile getMinimal getNoComments getOtherExtsgetOtherModules getOverwrite getPackageDirgetPackageNamegetPackageTypegetSimpleProject getSrcDirs getSynopsis getTestDirs getVersioninitializeTestSuitePromptpackageTypePromptsimpleProjectPrompttestMainPrompt createProjectgenSimpleExeTargetgenSimpleLibTargetgenSimplePkgDescgenSimpleTestTargetguessApplicationDirectoriesguessAuthorEmailguessAuthorNameguessCabalSpecVersionguessExtraDocFiles guessLanguage guessLicense guessMainFileguessPackageNameguessPackageTypeguessSourceDirectoriesappDirsHeuristicsauthorHeuristicsbuildToolsHeuristicscabalVersionHeuristicscategoryHeuristicsdependenciesHeuristicsemailHeuristicsexeOtherModulesHeuristicsexposedModulesHeuristicsextraDocFileHeuristics genExeTarget genLibTargetgenPkgDescription genTestTargethomepageHeuristicsinitializeTestSuiteHeuristicslanguageHeuristicslibOtherModulesHeuristicslicenseHeuristicsmainFileHeuristicsminimalHeuristicsnoCommentsHeuristicsotherExtsHeuristicsoverwriteHeuristicspackageNameHeuristicspackageTypeHeuristicssrcDirsHeuristicssynopsisHeuristicstestDirsHeuristicstestOtherModulesHeuristicsversionHeuristics appDirsPrompt authorPromptcabalVersionPromptcategoryPrompt emailPrompthomepagePromptlanguagePrompt licensePromptmainFilePromptnoCommentsPromptpackageNamePrompt srcDirsPromptsynopsisPrompttestDirsPrompt versionPromptprepareExeTargetprepareLibTargetprepareTestTargetwriteChangeLog writeLicense writeProject$fEqWriteAction$fShowWriteActionbeginUpdateFileMonitorcheckFileMonitorChangednewFileMonitorupdateFileMonitor FileMonitorfileMonitorCacheFile"fileMonitorCheckIfOnlyValueChangedfileMonitorKeyValidMonitorChangedMonitorUnchangedMonitorChangedReasonMonitorCorruptCacheMonitorFirstRunMonitoredFileChangedMonitoredValueChangedMonitorStateFileMonitorStateFileSetMonitorStateGlobMonitorTimestamp$fApplicativeChangedM$fFunctorChangedM$fBinaryMonitorStateFile$fBinaryMonitorStateFileSet$fBinaryMonitorStateGlob$fBinaryMonitorStateFileStatus$fBinaryMonitorStateGlobRel$fEqMonitorChangedReason$fFunctorMonitorChangedReason$fGenericMonitorStateFile$fGenericMonitorStateFileSet$fGenericMonitorStateFileStatus$fGenericMonitorStateGlob$fGenericMonitorStateGlobRel$fMonadChangedM$fMonadIOChangedM$fShowMonitorChanged$fShowMonitorChangedReason$fShowMonitorStateFile$fShowMonitorStateFileSet$fShowMonitorStateFileStatus$fShowMonitorStateGlob$fShowMonitorStateGlobRel$fStructuredMonitorStateFile$fStructuredMonitorStateFileSet"$fStructuredMonitorStateFileStatus$fStructuredMonitorStateGlob$fStructuredMonitorStateGlobRelaskRootcreateDirectoryMonitoreddelayInitSharedResourcedelayInitSharedResourcesdoesFileExistMonitored execRebuildfindFileMonitoredfindFileWithExtensionMonitoredfindFirstFileMonitoredgetDirectoryContentsMonitoredmonitorDirectoryStatus monitorFilesneed needIfExistsrerunConcurrentlyIfChangedrerunIfChanged runRebuildRebuild$fApplicativeRebuild$fFunctorRebuild$fMonadIORebuild$fMonadRebuildcloneSourceRepo configureVCS configureVCSs knownVCSssyncSourceReposvalidatePDSourceRepovalidateSourceRepovalidateSourceReposvcsBzrvcsDarcsvcsGitvcsHgvcsPijulvcsSvnSourceRepoProblemSourceRepoLocationUnspecifiedSourceRepoRepoTypeUnspecifiedSourceRepoRepoTypeUnsupportedVCS vcsProgram vcsRepoType$fShowSourceRepoProblembuildStatusRequiresBuildbuildStatusToStringbuildFailureLogFilebuildFailureReasonBuildFailureReason BenchFailedHaddocksFailed ReplFailed BuildReasonBuildReasonDepsRebuiltBuildReasonEphemeralTargetsBuildReasonExtraTargetsBuildReasonFilesChangedbuildResultDocsbuildResultLogFilebuildResultTests BuildStatusBuildStatusDownloadBuildStatusInstalledBuildStatusPreExistingBuildStatusRebuildBuildStatusUnpackBuildStatusUpToDateBuildStatusMapBuildStatusBuildBuildStatusConfigure$fShowBuildFailureReasonaddConstraintsaddDefaultSetupDependenciesaddPreferences!addSetupCabalMaxVersionConstraint!addSetupCabalMinVersionConstraintaddSetupCabalProfiledDynamicbasicInstallPolicyreinstallTargetsremoveLowerBoundsremoveUpperBoundsresolveDependenciesresolveWithoutDependenciessetAllowBootLibInstallssetAvoidReinstallssetCountConflictssetEnableBackjumpingsetFineGrainedConflicts setGoalOrdersetIndependentGoalssetMaxBackjumpssetMinimizeConflictSetsetOnlyConstrainedsetPreferenceDefaultsetReorderGoals setShadowPkgssetSolveExecutablessetSolverVerbositysetStrongFlagsstandardInstallPolicyupgradeDependenciesDepResolverParamsPackagePreferencePackageInstalledPreferencePackageStanzasPreferencePackageVersionPreference$fShowResolveNoDepsErrorallPackageSourceFilespackageDirToSdistrun splitRunArgscheck componentKinddefaultDirActionsparseTargetStringreadTargetSelectorsreadTargetSelectorsWithreportTargetSelectorProblemsshowTargetSelectorshowTargetString ComponentKind BenchKindExeKindFLibKindLibKindTestKindComponentKindFilter DirActionscanonicalizePath QualLevelQL1QL2QL3QLFullSubComponentTarget FileTarget ModuleTargetWholeComponentTargetImplicitCwdTargetExplicitNamedTargetSelectorTargetAllPackagesTargetComponentTargetComponentUnknown TargetPackageTargetPackageNamedTargetSelectorProblemMatchingInternalErrorTargetSelectorAmbiguousTargetSelectorExpectedTargetSelectorNoCurrentPackageTargetSelectorNoScriptTargetSelectorNoSuchTargetSelectorNoTargetsInCwd TargetSelectorNoTargetsInProjectTargetSelectorUnrecognised TargetString TargetString1 TargetString2 TargetString3 TargetString4 TargetString5 TargetString7$fAlternativeMatch$fApplicativeMatch$fFunctorMatch$fBinarySubComponentTarget$fEnumComponentKind$fEnumQualLevel$fEqComponentKind$fEqFileStatus$fEqMatchClass$fEqMatchError $fEqQualLevel$fEqSubComponentTarget$fEqTargetImplicitCwd$fEqTargetSelector$fEqTargetSelectorProblem$fEqTargetString$fEqTargetStringFileStatus$fGenericSubComponentTarget$fGenericTargetImplicitCwd$fGenericTargetSelector $fMonadMatch$fMonadPlusMatch$fOrdComponentKind$fOrdFileStatus$fOrdMatchClass$fOrdSubComponentTarget$fOrdTargetImplicitCwd$fOrdTargetSelector$fOrdTargetStringFileStatus$fShowComponentKind$fShowFileStatus$fShowKnownComponent$fShowKnownPackage$fShowKnownTargets $fShowMatch$fShowMatchClass$fShowMatchError$fShowMaybeAmbiguous$fShowQualLevel$fShowSubComponentTarget$fShowTargetImplicitCwd$fShowTargetSelector$fShowTargetSelectorProblem$fShowTargetString$fShowTargetStringFileStatus$fStructuredSubComponentTarget!parseWithoutProjectTargetSelectorwoPackageNameswoPackageSpecifierswoPackageTargetsWithoutProjectTargetSelectorWoPackageComponent WoPackageIdWoURI"$fShowWithoutProjectTargetSelectorviewAsFieldDescr addFields aliasFieldcommandOptionToFieldcommandOptionsToFields filterFields liftFields liftSection mapFieldNames parseConfig parseFieldsparseFieldsAndSectionsppFieldsppFieldsAndSections ppSection showConfigFGSectionDescr fgSectionGetfgSectionGrammar fgSectionName fgSectionSet SectionDescr sectionEmpty sectionFields sectionGet sectionName sectionSetsectionSubsectionscabalInstallGitInfocabalInstallVersionconfigureTransport downloadURIisOldHackageURIremoteRepoCheckHttpsremoteRepoTryUpgradeToHttpstransportCheckHttpsDownloadResultFileAlreadyInCacheFileDownloadedHttpCode HttpTransportgetHttppostHttp postHttpFile putHttpFiletransportManuallySelectedtransportSupportsHttps$fEqDownloadCheck$fEqDownloadResulttransportAdapter$fExceptionUnexpectedResponse$fShowUnexpectedResponse$fPrettyUnexpectedResponsedefaultGlobalFlagswithRepoContextwithRepoContext' GlobalFlagsglobalActiveReposglobalCacheDirglobalConfigFileglobalConstraintsFileglobalHttpTransportglobalIgnoreExpiryglobalLocalNoIndexRepos globalLogsDir globalNixglobalNumericVersionglobalProgPathExtraglobalRemoteReposglobalStoreDir globalVersion RepoContextrepoContextGetTransportrepoContextIgnoreExpiryrepoContextReposrepoContextWithSecureRepo$fGenericGlobalFlags$fMonoidGlobalFlags$fSemigroupGlobalFlags$fShowGlobalFlagsasyncFetchPackages checkFetchedcheckRepoTarballFetched downloadIndex fetchPackagefetchRepoTarball isFetchedverifyFetchedTarballswaitAsyncFetchPackage AsyncFetchMapdisambiguatePackageNamedisambiguatePackageTargetsexpandUserTargetfetchPackageTargetreadPackageTargetreadUserConstraintreadUserTargetreadUserTargetsreportPackageTargetProblemsreportUserTargetProblemsresolveUserTargetsuserConstraintPackageNameuserToPackageConstraint PackageTargetPackageTargetLocationPackageTargetNamedPackageTargetNamedFuzzyPackageTargetProblemPackageNameAmbiguousPackageNameUnknownUserConstraintUserConstraintScopeUserAnyQualifierUserAnySetupQualifier UserQualified UserQualifier UserQualExe UserQualSetupUserQualToplevel UserTargetUserTargetLocalCabalFileUserTargetLocalDirUserTargetLocalTarballUserTargetNamedUserTargetRemoteTarballUserTargetProblemUserTargetNonexistantFileUserTargetUnexpectedFileUserTargetUnexpectedUriSchemeUserTargetUnrecognisedUserTargetUnrecognisedUri$fBinaryUserConstraint$fBinaryUserConstraintScope$fBinaryUserQualifier$fEqUserConstraint$fEqUserConstraintScope$fEqUserQualifier$fEqUserTarget$fFoldablePackageTarget$fFunctorPackageTarget$fGenericUserConstraint$fGenericUserConstraintScope$fGenericUserQualifier$fMonoidPackageNameEnv$fSemigroupPackageNameEnv$fParsecUserConstraint$fPrettyUserConstraint$fShowPackageTarget$fShowPackageTargetProblem$fShowUserConstraint$fShowUserConstraintScope$fShowUserQualifier$fShowUserTarget$fShowUserTargetProblem$fStructuredUserConstraint$fStructuredUserConstraintScope$fStructuredUserQualifier$fTraversablePackageTargetactAsSetupCommandbenchmarkCommandbenchmarkOptions buildCommand checkCommand cleanCommandconfigCompilerAux'configPackageDB'configureCommandconfigureExCommandconfigureExOptionsconfigureOptions copyCommanddefaultConfigExFlagsdefaultInstallFlagsdefaultMaxBackjumps defaultSolverdefaultUpdateFlags fetchCommandfilterBenchmarkFlagsfilterBuildFlagsfilterCommonFlagsfilterConfigureFlagsfilterCopyFlagsfilterHaddockArgsfilterHaddockFlagsfilterRegisterFlagsfilterReplFlagsfilterTestFlags formatCommand freezeCommandgenBoundsCommand getCommand globalCommandhaddockCommandhaddockOptions infoCommand initCommand initOptionsinstallCommandinstallOptions liftOptions listCommandlistNeedsCompilermanpageCommandreconfigureCommandregisterCommand replCommand reportCommand runCommand testCommand testOptions unpackCommand uploadCommanduserConfigCommandyesNoOptActAsSetupFlagsactAsSetupBuildType CheckFlags checkIgnorecheckVerbosity ConfigExFlagsconfigAllowNewerconfigAllowOlder configAppend configBackupconfigCabalVersionconfigExConstraintsconfigPreferences configSolver$configWriteGhcEnvironmentFilesPolicy FetchFlagsfetchAllowBootLibInstallsfetchBenchmarksfetchCountConflicts fetchDeps fetchDryRunfetchFineGrainedConflictsfetchIndependentGoalsfetchMaxBackjumpsfetchMinimizeConflictSetfetchOnlyConstrainedfetchPreferOldestfetchReorderGoalsfetchShadowPkgs fetchSolverfetchStrongFlags fetchTestsfetchVerbosity FreezeFlagsfreezeAllowBootLibInstallsfreezeBenchmarksfreezeCountConflicts freezeDryRunfreezeFineGrainedConflictsfreezeIndependentGoalsfreezeMaxBackjumpsfreezeMinimizeConflictSetfreezeOnlyConstrainedfreezePreferOldestfreezeReorderGoalsfreezeShadowPkgs freezeSolverfreezeStrongFlags freezeTestsfreezeVerbosityGetFlagsgetActiveRepos getDestDir getIndexStategetOnlyPkgDescr getPristinegetSourceRepository getVerbosity InfoFlagsinfoPackageDBs infoVerbosity InstallFlagsinstallAllowBootLibInstallsinstallAvoidReinstallsinstallBuildReportsinstallCountConflicts installDestinstallDocumentation installDryRuninstallFineGrainedConflictsinstallHaddockIndexinstallIndependentGoalsinstallIndexStateinstallKeepGoinginstallLogFileinstallMaxBackjumpsinstallMinimizeConflictSetinstallNumJobsinstallOfflineMode installOnlyinstallOnlyConstrainedinstallOnlyDepsinstallOnlyDownloadinstallOverrideReinstallinstallPerComponentinstallPreferOldestinstallReinstallinstallReorderGoalsinstallReportPlanningFailureinstallRootCmdinstallRunTestsinstallShadowPkgsinstallStrongFlagsinstallSummaryFileinstallSymlinkBinDirinstallUpgradeDepsinstallUseSemaphore IsCandidate IsPublished ListFlagslistCaseInsensitive listHcPath listInstalledlistPackageDBslistSimpleOutput listVerbosity ReportFlagsreportPassword reportTokenreportUsernamereportVerbosity UpdateFlagsupdateIndexStateupdateVerbosity UploadFlagsuploadCandidate uploadDocuploadPassworduploadPasswordCmd uploadTokenuploadUsernameuploadVerbosityUserConfigFlagsuserConfigAppendLinesuserConfigForceuserConfigVerbosity$fBinaryInstallFlags$fEqConfigExFlags$fEqInstallFlags$fEqIsCandidate$fGenericActAsSetupFlags$fGenericConfigExFlags$fGenericGetFlags$fGenericInfoFlags$fGenericInstallFlags$fGenericListFlags$fGenericReportFlags$fGenericUpdateFlags$fGenericUploadFlags$fGenericUserConfigFlags$fMonoidActAsSetupFlags$fSemigroupActAsSetupFlags$fMonoidConfigExFlags$fSemigroupConfigExFlags$fMonoidGetFlags$fSemigroupGetFlags$fMonoidInfoFlags$fSemigroupInfoFlags$fMonoidInstallFlags$fSemigroupInstallFlags$fMonoidListFlags$fSemigroupListFlags$fMonoidReportFlags$fSemigroupReportFlags$fMonoidUploadFlags$fSemigroupUploadFlags$fMonoidUserConfigFlags$fSemigroupUserConfigFlags$fShowCheckFlags$fShowConfigExFlags$fShowInstallFlagsdefaultReplFlagsmultiReplOptiontopReplOptionsEnvFlagsenvIncludeTransitive envPackages ReplFlagsconfigureReplOptions replEnvFlags replUseMulti$fMonoidEnvFlags$fSemigroupEnvFlags$fMonoidReplFlags$fSemigroupReplFlags cfgVerbositydefaultNixStyleFlagsnixStyleOptionsupdNixStyleCommonSetupFlags NixStyleFlagsbenchmarkFlags configExFlags configFlags extraFlags haddockFlags installFlags projectFlags testFlagsmanpage manpageCmd promptRunsymlinkBinaries symlinkBinarysymlinkableBinary trySymlinkSymlinkoverwritePolicy privateBindir privateName publicBindir publicName$fShowSymlinkStatusBuildTimeSettingsbuildSettingBuildReportsbuildSettingCacheDirbuildSettingDryRunbuildSettingHaddockOpenbuildSettingHttpTransportbuildSettingIgnoreExpirybuildSettingKeepGoingbuildSettingKeepTempFilesbuildSettingLocalNoIndexReposbuildSettingLogFilebuildSettingLogVerbositybuildSettingNumJobsbuildSettingOfflineModebuildSettingOnlyDepsbuildSettingOnlyDownloadbuildSettingProgPathExtrabuildSettingRemoteRepos!buildSettingReportPlanningFailurebuildSettingSummaryFilebuildSettingSymlinkBinDirMapLast getMapLast MapMappend getMapMappend PackageConfigpackageConfigBenchmarkOptionspackageConfigBenchmarkspackageConfigConfigureArgspackageConfigCoveragepackageConfigDebugInfopackageConfigDocumentationpackageConfigDumpBuildInfopackageConfigDynExepackageConfigExtraFrameworkDirspackageConfigExtraIncludeDirspackageConfigExtraLibDirspackageConfigExtraLibDirsStaticpackageConfigFlagAssignmentpackageConfigFullyStaticExepackageConfigGHCiLibpackageConfigHaddockBaseUrlpackageConfigHaddockBenchmarkspackageConfigHaddockContentspackageConfigHaddockCsspackageConfigHaddockExecutablespackageConfigHaddockForHackagepackageConfigHaddockForeignLibspackageConfigHaddockHooglepackageConfigHaddockHscolourCsspackageConfigHaddockHtml packageConfigHaddockHtmlLocationpackageConfigHaddockIndexpackageConfigHaddockInternal packageConfigHaddockLinkedSourcepackageConfigHaddockOutputDirpackageConfigHaddockQuickJump packageConfigHaddockResourcesDirpackageConfigHaddockTestSuitespackageConfigHaddockUseUnicodepackageConfigOptimizationpackageConfigProfpackageConfigProfDetailpackageConfigProfExepackageConfigProfLibpackageConfigProfLibDetailpackageConfigProfSharedpackageConfigProgPrefixpackageConfigProgSuffixpackageConfigProgramArgspackageConfigProgramPathExtrapackageConfigProgramPathspackageConfigRelocatablepackageConfigRunTestspackageConfigSharedLibpackageConfigSplitObjspackageConfigSplitSectionspackageConfigStaticLibpackageConfigStripExespackageConfigStripLibs%packageConfigTestFailWhenNoTestSuitespackageConfigTestHumanLogpackageConfigTestKeepTixpackageConfigTestMachineLogpackageConfigTestShowDetailspackageConfigTestTestOptionspackageConfigTestWrapperpackageConfigTestspackageConfigVanillaLib ProjectConfigprojectConfigAllPackagesprojectConfigBuildOnlyprojectConfigLocalPackagesprojectConfigProvenanceprojectConfigSharedprojectConfigSpecificPackageprojectPackagesprojectPackagesNamedprojectPackagesOptionalprojectPackagesRepoProjectConfigBuildOnlyprojectConfigBuildReportsprojectConfigCacheDirprojectConfigClientInstallFlagsprojectConfigDryRunprojectConfigHttpTransportprojectConfigIgnoreExpiryprojectConfigKeepGoingprojectConfigKeepTempFilesprojectConfigLogFileprojectConfigLogsDirprojectConfigNumJobsprojectConfigOfflineModeprojectConfigOnlyDepsprojectConfigOnlyDownload"projectConfigReportPlanningFailureprojectConfigSummaryFileprojectConfigSymlinkBinDirprojectConfigUseSemaphoreprojectConfigVerbosityProjectConfigProvenanceExplicitImplicitProjectConfigSharedprojectConfigActiveRepos!projectConfigAllowBootLibInstallsprojectConfigAllowNewerprojectConfigAllowOlderprojectConfigCabalVersionprojectConfigConfigFileprojectConfigConstraintsprojectConfigCountConflictsprojectConfigDistDir!projectConfigFineGrainedConflictsprojectConfigHaddockIndexprojectConfigHcFlavorprojectConfigHcPathprojectConfigHcPkgprojectConfigIgnoreProjectprojectConfigIndependentGoalsprojectConfigIndexStateprojectConfigInstallDirsprojectConfigLocalNoIndexReposprojectConfigMaxBackjumps projectConfigMinimizeConflictSetprojectConfigMultiReplprojectConfigOnlyConstrainedprojectConfigPackageDBsprojectConfigPerComponentprojectConfigPreferOldestprojectConfigPreferencesprojectConfigProgPathExtraprojectConfigProjectDirprojectConfigProjectFileprojectConfigRemoteReposprojectConfigReorderGoalsprojectConfigSolverprojectConfigStoreDirprojectConfigStrongFlags+projectConfigWriteGhcEnvironmentFilesPolicyProjectConfigToParseSolverSettingssolverSettingActiveRepos!solverSettingAllowBootLibInstallssolverSettingAllowNewersolverSettingAllowOldersolverSettingCabalVersionsolverSettingConstraintssolverSettingCountConflicts!solverSettingFineGrainedConflictssolverSettingFlagAssignmentsolverSettingFlagAssignmentssolverSettingIndependentGoalssolverSettingIndexStatesolverSettingLocalNoIndexRepossolverSettingMaxBackjumps solverSettingMinimizeConflictSetsolverSettingOnlyConstrainedsolverSettingPreferOldestsolverSettingPreferencessolverSettingRemoteRepossolverSettingReorderGoalssolverSettingSolversolverSettingStrongFlags$fBinaryMapLast$fBinaryMapMappend$fBinaryPackageConfig$fBinaryProjectConfig$fBinaryProjectConfigProvenance$fBinaryProjectConfigBuildOnly$fBinaryProjectConfigShared$fBinarySolverSettings $fEqMapLast$fEqMapMappend$fEqPackageConfig$fEqProjectConfig$fEqProjectConfigBuildOnly$fEqProjectConfigProvenance$fEqProjectConfigShared$fEqSolverSettings$fFunctorMapLast$fFunctorMapMappend$fGenericMapLast$fGenericMapMappend$fGenericPackageConfig$fGenericProjectConfig$fGenericProjectConfigBuildOnly $fGenericProjectConfigProvenance$fGenericProjectConfigShared$fGenericSolverSettings$fMonoidMapLast$fSemigroupMapLast$fMonoidMapMappend$fSemigroupMapMappend$fMonoidPackageConfig$fSemigroupPackageConfig$fMonoidProjectConfig$fSemigroupProjectConfig$fMonoidProjectConfigBuildOnly!$fSemigroupProjectConfigBuildOnly$fMonoidProjectConfigShared$fSemigroupProjectConfigShared$fOrdProjectConfigProvenance $fShowMapLast$fShowMapMappend$fShowPackageConfig$fShowProjectConfig$fShowProjectConfigBuildOnly$fShowProjectConfigProvenance$fShowProjectConfigShared$fShowSolverSettings$fStructuredMapLast$fStructuredMapMappend$fStructuredPackageConfig$fStructuredProjectConfig"$fStructuredProjectConfigBuildOnly#$fStructuredProjectConfigProvenance$fStructuredProjectConfigShared$fStructuredSolverSettingsbaseSavedConfigcommentSavedConfigconfigFieldDescriptionscreateDefaultConfigFiledefaultCacheDirdefaultCacheHomedefaultCompilerdefaultConfigFiledefaultInstallPathdefaultLogsDirdefaultReportsDirdefaultScriptBuildsDirdefaultStoreDirdefaultUserInstallgetConfigFilePathhaddockFlagsFieldsinitialSavedConfiginstallDirsFields loadConfigpostProcessReporemoteRepoFieldsshowConfigWithCommentsuserConfigDiffuserConfigUpdatewithProgramOptionsFieldswithProgramsFields SavedConfigsavedBenchmarkFlagssavedClientInstallFlagssavedConfigureExFlagssavedConfigureFlagssavedGlobalFlagssavedGlobalInstallDirssavedHaddockFlagssavedInitFlagssavedInstallFlagssavedProjectFlagssavedReplMultisavedReportFlagssavedTestFlagssavedUploadFlagssavedUserInstallDirs$fGenericSavedConfig$fMonoidSavedConfig$fSemigroupSavedConfigclassifyPackageEnvironmentloadUserConfigreadPackageEnvironmentFileshowPackageEnvironment"showPackageEnvironmentWithCommentsuserPackageEnvironmentFilePackageEnvironmentpkgEnvSavedConfigPackageEnvironmentTypeAmbientPackageEnvironmentUserPackageEnvironment$fGenericPackageEnvironment$fMonoidPackageEnvironment$fSemigroupPackageEnvironmentcommandLineFlagsToProjectConfigconvertLegacyGlobalConfigconvertLegacyProjectConfigconvertToLegacyProjectConfig0instantiateProjectConfigSkeletonFetchingCompiler,instantiateProjectConfigSkeletonWithCompilerparseLegacyProjectConfigparsePackageLocationTokenQ parseProjectprojectSkeletonImportsrenderPackageLocationTokenshowLegacyProjectConfigsingletonProjectConfigSkeletonLegacyProjectConfigProjectConfigSkeleton$fGenericLegacyPackageConfig$fGenericLegacyProjectConfig$fGenericLegacySharedConfig$fMonoidLegacyPackageConfig$fSemigroupLegacyPackageConfig$fMonoidLegacyProjectConfig$fSemigroupLegacyProjectConfig$fMonoidLegacySharedConfig$fSemigroupLegacySharedConfig$fShowLegacyPackageConfig$fShowLegacyProjectConfig$fShowLegacySharedConfig findNixExpr inNixShellnixInstantiatenixShelldefaultCabalDirLayoutdefaultDistDirLayoutdefaultProjectFiledefaultStoreDirLayoutmkCabalDirLayoutCabalDirLayoutcabalLogsDirectorycabalStoreDirLayout DistDirLayoutdistBinDirectorydistBuildDirectorydistBuildRootDirectory distDirectorydistDownloadSrcDirectorydistHaddockOutputDirdistPackageCacheDirectorydistPackageCacheFile distPackageDBdistProjectCacheDirectorydistProjectCacheFiledistProjectFiledistProjectRootDirectorydistSdistDirectory distSdistFiledistTempDirectorydistUnpackedSrcDirectorydistUnpackedSrcRootDirectory DistDirParamsdistParamCompilerIddistParamComponentIddistParamComponentNamedistParamOptimizationdistParamPackageIddistParamPlatformdistParamUnitId ProjectRootProjectRootExplicitProjectRootExplicitAbsoluteProjectRootImplicitStoreDirLayoutstoreDirectorystoreIncomingDirectorystoreIncomingLockstorePackageDBstorePackageDBPathstorePackageDBStackstorePackageDirectory$fEqProjectRoot$fShowProjectRootdoesStoreEntryExistgetStoreEntries newStoreEntryNewStoreEntryOutcomeUseExistingStoreEntryUseNewStoreEntry$fEqNewStoreEntryOutcome$fShowNewStoreEntryOutcomecomponentOptionalStanzacomponentTargetNamedataDirsEnvironmentForPlanelabComponentNameelabConfiguredNameelabDistDirParamselabExeDependencieselabExeDependencyPaths$elabInplaceDependencyBuildCacheFileselabLibDependencieselabOrderExeDependencieselabOrderLibDependencieselabPkgConfigDependencieselabPlanPackageNameelabRequiresRegistrationelabSetupDependenciesisBenchComponentTargetisExeComponentTargetisForeignLibComponentTargetisInplaceBuildStyleisSubLibComponentTargetisTestComponentTargetnormaliseConfiguredPackagepkgOrderDependenciesshowBenchComponentTargetshowComponentTargetshowElaboratedInstallPlanshowTestComponentTargetwhyNotPerComponent BuildStyleBuildAndInstallBuildInplaceOnly CabalFileTextComponentTargetElaboratedComponentcompComponentNamecompExeDependenciescompExeDependencyPathscompLibDependenciescompLinkedLibDependenciescompOrderLibDependenciescompPkgConfigDependenciescompSolverNameElaboratedConfiguredPackageelabBenchTargetselabBenchmarkOptionselabBuildHaddockselabBuildOptionselabBuildPackageDBStackelabBuildStyleelabBuildTargetselabComponentIdelabConfigureScriptArgselabConfigureTargetselabConfiguredProgramselabDumpBuildInfoelabEnabledSpecelabExtraFrameworkDirselabExtraIncludeDirselabExtraLibDirselabExtraLibDirsStaticelabFlagAssignmentelabFlagDefaultselabHaddockBaseUrlelabHaddockBenchmarkselabHaddockContentselabHaddockCsselabHaddockExecutableselabHaddockForHackageelabHaddockForeignLibselabHaddockHoogleelabHaddockHscolourCsselabHaddockHtmlelabHaddockHtmlLocationelabHaddockIndexelabHaddockInternalelabHaddockLinkedSourceelabHaddockOutputDirelabHaddockQuickJumpelabHaddockResourcesDirelabHaddockTargetselabHaddockTestSuiteselabHaddockUseUnicodeelabInplaceBuildPackageDBStack!elabInplaceRegisterPackageDBStackelabInplaceSetupPackageDBStackelabInstallDirselabInstantiatedWithelabIsCanonicalelabLinkedInstantiatedWithelabLocalToProjectelabModuleShapeelabPackageDbselabPkgDescriptionelabPkgDescriptionOverride elabPkgOrCompelabPkgSourceHashelabPkgSourceIdelabPkgSourceLocationelabProgPrefixelabProgSuffixelabProgramArgselabProgramPathExtraelabProgramPathselabRegisterPackageDBStackelabReplTargetelabSetupPackageDBStackelabSetupScriptCliVersionelabSetupScriptStyleelabStanzasAvailableelabStanzasRequestedelabTestFailWhenNoTestSuiteselabTestHumanLogelabTestKeepTixelabTestMachineLogelabTestShowDetailselabTestTargetselabTestTestOptionselabTestWrapper elabUnitIdElaboratedInstallPlanElaboratedPackagepkgDependsOnSelfLibpkgExeDependenciespkgExeDependencyPathspkgInstalledIdpkgLibDependenciespkgPkgConfigDependenciespkgStanzasEnabledpkgWhyNotPerComponentElaboratedPackageOrComponent ElabComponent ElabPackageElaboratedPlanPackageElaboratedReadyPackageElaboratedSharedConfigpkgConfigCompilerpkgConfigCompilerProgspkgConfigPlatformpkgConfigReplOptions MemoryOrDiskInMemoryOnDiskNotPerComponentBuildTypeCuzConfigureBuildTypeCuzCustomBuildTypeCuzHooksBuildTypeCuzMakeBuildTypeNotPerComponentReason CuzBuildTypeCuzCabalSpecVersionCuzDisablePerComponentCuzNoBuildableComponentsSetupScriptStyleSetupCustomExplicitDepsSetupCustomImplicitDepsSetupNonCustomExternalLibSetupNonCustomInternalLib$fBinaryBuildStyle$fBinaryComponentTarget$fBinaryElaboratedComponent#$fBinaryElaboratedConfiguredPackage$fBinaryElaboratedPackage$fBinaryNotPerComponentReason$$fBinaryElaboratedPackageOrComponent$fBinaryElaboratedSharedConfig$fBinaryMemoryOrDisk $fBinaryNotPerComponentBuildType$fBinarySetupScriptStyle$fEqBuildStyle$fEqComponentTarget$fEqElaboratedComponent$fEqElaboratedConfiguredPackage$fEqElaboratedPackage $fEqElaboratedPackageOrComponent$fEqMemoryOrDisk$fEqNotPerComponentBuildType$fEqNotPerComponentReason$fEqSetupScriptStyle$fGenericBuildStyle$fGenericComponentTarget$fGenericElaboratedComponent$$fGenericElaboratedConfiguredPackage$fGenericElaboratedPackage%$fGenericElaboratedPackageOrComponent$fGenericElaboratedSharedConfig$fGenericMemoryOrDisk!$fGenericNotPerComponentBuildType$fGenericNotPerComponentReason$fGenericSetupScriptStyle,$fHasConfiguredIdElaboratedConfiguredPackage&$fHasUnitIdElaboratedConfiguredPackage#$fIsNodeElaboratedConfiguredPackage$fMonoidBuildStyle$fSemigroupBuildStyle$fOrdBuildStyle$fOrdComponentTarget$fOrdMemoryOrDisk$$fPackageElaboratedConfiguredPackage$fShowBuildStyle$fShowComponentTarget$fShowElaboratedComponent!$fShowElaboratedConfiguredPackage$fShowElaboratedPackage"$fShowElaboratedPackageOrComponent$fShowElaboratedSharedConfig$fShowMemoryOrDisk$fShowNotPerComponentBuildType$fShowNotPerComponentReason$fShowSetupScriptStyle$fStructuredBuildStyle$fStructuredComponentTarget$fStructuredElaboratedComponent'$fStructuredElaboratedConfiguredPackage$fStructuredElaboratedPackage($fStructuredElaboratedPackageOrComponent"$fStructuredElaboratedSharedConfig$fStructuredMemoryOrDisk$$fStructuredNotPerComponentBuildType!$fStructuredNotPerComponentReason$fStructuredSetupScriptStyleneedElaboratedConfiguredPackagemkDefaultSetupDepspackageSetupScriptSpecVersionpackageSetupScriptStyleNonSetupLibDepSolverPlanPackage!unNonSetupLibDepSolverPlanPackage'$fIsNodeNonSetupLibDepSolverPlanPackage($fPackageNonSetupLibDepSolverPlanPackage"argsEquivalentOfGhcEnvironmentFilecreatePackageEnvironmentAndArgsupdatePostBuildProjectStatuswritePlanExternalRepresentationwritePlanGhcEnvironmentPostBuildProjectStatuspackagesAlreadyInStorepackagesBuildInplacepackagesBuildLocalpackagesDefinitelyUpToDatepackagesInvalidByChangedLibDepspackagesInvalidByFailedBuildpackagesLibDepGraphpackagesOutOfDatepackagesProbablyUpToDatecheckBadPerPackageCompilerPathsfetchAndReadSourcePackagesfindProjectPackagesfindProjectRootgetProjectRootUsabilitylookupLocalPackageConfigmaxNumFetchJobsonlyTopLevelProvenance#projectConfigWithBuilderRepoContext"projectConfigWithSolverRepoContextreadGlobalConfigreadProjectLocalExtraConfigreadProjectLocalFreezeConfigreadSourcePackageCabalFilereadSourcePackageCabalFile'reportParseResultresolveBuildTimeSettingsresolveNumJobsSettingresolveSolverSettingsshowProjectConfigwithGlobalConfigwithProjectOrGlobalConfigwriteProjectConfigFilewriteProjectLocalExtraConfigwriteProjectLocalFreezeConfigBadPackageLocationBadLocGlobBadMatchesBadLocGlobEmptyMatchBadLocUnexpectedUriSchemeBadLocUnrecognisedBadLocUnrecognisedUriBadPackageLocationFileBadPackageLocationMatchBadLocDirManyCabalFilesBadLocDirNoCabalFileBadLocNonexistantFileBadLocUnexpectedFileBadPackageLocationsBadPerPackageCompilerPathsBadProjectRoot"BadProjectRootAbsoluteFileNotFoundBadProjectRootDirFileNotFoundBadProjectRootDirNotFound"BadProjectRootExplicitFileNotFoundBadProjectRootFileBrokenCabalFileParseErrorProjectPackageLocationProjectPackageLocalCabalFileProjectPackageLocalDirectoryProjectPackageLocalTarballProjectPackageNamedProjectPackageRemoteRepoProjectPackageRemoteTarballProjectRootUsabilityProjectRootUsabilityNotPresent&ProjectRootUsabilityPresentAndUnusable$ProjectRootUsabilityPresentAndUsable$fEqBadProjectRoot$fEqProjectRootUsability$fExceptionBadPackageLocations$fShowBadPackageLocations%$fExceptionBadPerPackageCompilerPaths $fShowBadPerPackageCompilerPaths$fExceptionBadProjectRoot$fShowBadProjectRoot$fExceptionCabalFileParseError$fShowCabalFileParseError!$fExceptionCabalFileSearchFailure$fShowCabalFileSearchFailure$fShowBadPackageLocation$fShowBadPackageLocationMatch$fShowProjectPackageLocation$fShowProjectRootUsabilitycurrentIndexTimestampgetIndexFileAgegetSourcePackagesgetSourcePackagesAtIndexStategetSourcePackagesMonitorFiles indexBaseNameisPreferredVersionsparsePackageIndexparsePreferredVersionsWarningspreferredVersionsrefTypeFromTypeCodetypeCodeFromRefTypeupdatePackageIndexCacheFileupdateRepoIndexCachewriteIndexTimestampBuildTreeRefTypeLinkRef SnapshotRefIndex RepoIndex PackageEntry BuildTreeRef NormalPackagePreferredVersionsParseError#preferredVersionsOriginalDependencypreferredVersionsParsecError$fBinaryBuildTreeRefType $fBinaryCache$fBinaryIndexCacheEntry$fBinaryNoIndexCache$fBinaryNoIndexCacheEntry$fEqBuildTreeRefType$fEqIndexCacheEntry$fEqNoIndexCacheEntry$fEqPreferredVersionsParseError$fGenericBuildTreeRefType$fGenericCache$fGenericIndexCacheEntry$fGenericNoIndexCache$fGenericNoIndexCacheEntry$$fGenericPreferredVersionsParseError $fNFDataCache$fNFDataIndexCacheEntry$fNFDataNoIndexCache$fNFDataNoIndexCacheEntry $fOrdPreferredVersionsParseError$fPackagePackageEntry!$fReadPreferredVersionsParseError$fShowBuildTreeRefType $fShowCache$fShowIndexCacheEntry$fShowNoIndexCache$fShowNoIndexCacheEntry!$fShowPreferredVersionsParseError$fStructuredBuildTreeRefType$fStructuredCache$fStructuredIndexCacheEntry$fStructuredNoIndexCache$fStructuredNoIndexCacheEntrydefaultSetupScriptOptionsgetSetuprunSetuprunSetupCommand setupWrapperSetupScriptOptionsforceExternalSetupMethod isInteractiveisMainLibOrExeComponentsetupCacheLockuseCabalSpecVersionuseCabalVersion useCompileruseDependenciesuseDependenciesExclusive useDistPrefuseExtraEnvOverridesuseExtraPathEnvuseLoggingHandle usePackageDBusePackageIndex usePlatform useProgramDbuseVersionMacrosuseWin32CleanHack useWorkingDirfindSavedDistPrefgetPersistOrConfigCompilerloadConfigOrSandboxConfigupdateInstallDirs legacyCmdlegacyWrapperCmdnewCmd$fHasVerbosityBuildFlags$fHasVerbosityCleanFlags$fHasVerbosityConfigFlags$fHasVerbosityFreezeFlags$fHasVerbosityHaddockFlags$fHasVerbosityLast$fHasVerbosityReplFlags$fHasVerbosityTuple2$fHasVerbosityTuple3$fHasVerbosityTuple4$fHasVerbosityTuple5$fHasVerbosityTuple6$fHasVerbosityUpdateFlagsinfolistinitCmdclonePackagesFromSourceRepoClonePackageExceptionClonePackageDestinationExistsClonePackageFailedWithExitCodeClonePackageNoRepoLocationClonePackageNoRepoTypeClonePackageNoSourceReposClonePackageNoSourceReposOfKindClonePackageUnsupportedRepoType$fEqClonePackageException $fExceptionClonePackageException$fShowClonePackageExceptionfreeze getFreezePkgsboundsNeededMsg genBounds showBoundsfetchcheckConfigExFlagschooseCabalVersion configureconfigureSetupScriptreadConfigFlagsreadConfigFlagsFromwriteConfigFlagswriteConfigFlagsTo reconfigureCheckrunCheck $fMonoidCheck$fSemigroupCheck cleanAction$fEqCleanFlagscabalInstallIDnewBuildReportparseBuildReportparseBuildReportListshowBuildReport uploadReportsBuildLog BuildReportIdreportuploadfromInstallPlanfromPlanningFailurestoreAnonymous storeLocalavailableTargetsbinDirectoriesbinDirectoryForconfigureCompilerelabBuildTargetWholeComponentsnubComponentTargetspackageHashInputspkgHasEphemeralBuildTargetspruneInstallPlanToDependenciesrebuildInstallPlanrebuildProjectConfigsetupHsBenchArgssetupHsBenchFlagssetupHsBuildArgssetupHsBuildFlagssetupHsCommonFlagssetupHsConfigureArgssetupHsConfigureFlagssetupHsCopyFlagssetupHsHaddockArgssetupHsHaddockFlagssetupHsRegisterFlagssetupHsReplArgssetupHsReplFlagssetupHsScriptOptionssetupHsTestArgssetupHsTestFlagsstorePackageInstallDirsstorePackageInstallDirs'AvailableTargetavailableTargetComponentNameavailableTargetLocalToProjectavailableTargetPackageIdavailableTargetStatusAvailableTargetStatusTargetBuildableTargetDisabledBySolverTargetDisabledByUserTargetNotBuildableTargetNotLocalCannotPruneDependencies TargetActionTargetActionBenchTargetActionBuildTargetActionConfigureTargetActionHaddockTargetActionReplTargetActionTestTargetRequestedTargetNotRequestedByDefaultTargetRequestedByDefault$fEqAvailableTarget$fEqAvailableTargetStatus$fEqTargetRequested$fFunctorAvailableTarget$fFunctorAvailableTargetStatus$fHasUnitIdPrunedPackage$fIsNodePrunedPackage$fOrdAvailableTargetStatus$fOrdTargetRequested$fPackagePrunedPackage$fShowAvailableTarget$fShowAvailableTargetStatus$fShowCannotPruneDependencies$fShowTargetRequested TargetProblemCustomTargetProblemTargetAvailableInIndexTargetComponentNotBuildableTargetComponentNotProjectLocalTargetNotInProject$TargetOptionalStanzaDisabledBySolver"TargetOptionalStanzaDisabledByUserTargetProblemNoSuchComponentTargetProblemNoSuchPackageTargetProblemNoTargetsTargetProblemNoneEnabledTargetProblemUnknownComponentTargetProblem'$fEqTargetProblem$fFunctorTargetProblem$fShowTargetProblemcheckPackageFileMonitorChangedinvalidatePackageRegFileMonitornewPackageFileMonitorpackageFileMonitorKeyValuesupdatePackageBuildFileMonitorupdatePackageConfigFileMonitorupdatePackageRegFileMonitorBuildResultMiscPackageFileMonitorpkgFileMonitorBuildpkgFileMonitorConfigpkgFileMonitorRegannotateFailureannotateFailureNoLogbuildAndInstallUnpackedPackagebuildAndRegisterUnpackedPackagebuildInplaceUnpackedPackagePackageBuildingPhase&improveInstallPlanWithUpToDatePackagesrebuildTargetsrebuildTargetsDryRun listPluraloptionalStanzapluralrenderCannotPruneDependenciesrenderComponentKindrenderComponentNamerenderListCommaAndrenderListPrettyrenderListSemiAndrenderListTabularrenderOptionalStanzarenderSubComponentTargetrenderTargetProblemrenderTargetProblemNoTargetsrenderTargetProblemNoneEnabledrenderTargetSelectorreportTargetProblems sortGroupOntargetSelectorFiltertargetSelectorPluralPkgstargetSelectorRefersToPkgsPluralSingularallTargetSelectorsdieOnBuildFailuresdistinctTargetComponentsestablishDummyDistDirLayout establishDummyProjectBaseContextestablishProjectBaseContext#establishProjectBaseContextWithRootfilterTargetsKindfilterTargetsKindWithforgetTargetsDetail printPlanresolveTargetsFromLocalPackagesresolveTargetsFromSolverrunProjectBuildPhaserunProjectPostBuildPhaserunProjectPreBuildPhaseselectBuildableTargetsselectBuildableTargets'selectBuildableTargetsWithselectBuildableTargetsWith'selectComponentTargetBasicuniqueTargetSelectorswithInstallPlanCurrentCommand BuildCommandHaddockCommandInstallCommand OtherCommand ReplCommandProjectBaseContext buildSettingscabalDirLayoutcurrentCommand distDirLayoutinstalledPackages localPackages projectConfigProjectBuildContextelaboratedPlanOriginalelaboratedPlanToExecuteelaboratedSharedpkgsBuildStatus targetsMap TargetsMap$fEqCurrentCommand$fShowCurrentCommandensureScriptCacheDirectoryfakeProjectSourcePackagegetScriptCacheDirectory getScriptHashlSrcpkgDescription movedExePath updateContextAndWriteProjectFile!updateContextAndWriteProjectFile'withContextAndSelectorsAcceptNoTargetsRejectNoTargets TargetContext GlobalContextProjectContext ScriptContext$fEqAcceptNoTargets$fEqTargetContext$fShowAcceptNoTargets$fShowTargetContext updateAction updateCommand$fParsecUpdateRequest$fPrettyUpdateRequest$fShowUpdateRequestisSubComponentProblemnoTestsProblemnotTestProblemselectComponentTargetselectPackageTargets testAction$fEqTestProblem$fShowTestProblempackageToSdist sdistAction sdistCommand OutputFormat SourceList TarGzArchive$fEqOutputFormat$fShowOutputFormat handleShebangmatchesMultipleProblem noExesProblem runAction validScript$fEqRunProblem$fShowRunProblem replActionMultiReplDecisioncompilerVersion enabledByFlag$fEqMultiReplDecision$fEqReplProblem$fShowMultiReplDecision$fShowOriginalComponentInfo$fShowReplProblem pathAction pathCommand$fBoundedConfigPath$fBoundedPathOutputFormat$fEnumConfigPath$fEnumPathOutputFormat$fEqConfigPath$fEqPathCompilerInfo $fEqPathFlags$fEqPathOutputFormat$fEqPathOutputs$fOrdConfigPath$fOrdPathCompilerInfo$fOrdPathOutputFormat$fOrdPathOutputs$fReadPathOutputFormat$fShowConfigPath$fShowPathCompilerInfo$fShowPathFlags$fShowPathOutputFormat$fShowPathOutputs listOutdatedoutdatedActionoutdatedCommand showResultIgnoreMajorVersionBumpsIgnoreMajorVersionBumpsAllIgnoreMajorVersionBumpsNoneIgnoreMajorVersionBumpsSomeListOutdatedSettingslistOutdatedIgnorePredlistOutdatedMinorPred$fMonoidIgnoreMajorVersionBumps"$fSemigroupIgnoreMajorVersionBumps$fPrettyOutdatedDependencyX$fPrettyOutdatedDependencyX0componentNotRightKindProblem listbinActionlistbinCommandmultipleTargetsProblemnoComponentsProblem$fEqListBinProblem$fShowListBinProblem installAction haddockActionClientHaddockFlags openInBrowserdefaultGenBoundsFlagsgenBoundsActionGenBoundsFlags freezeAction execAction execCommandconfigureActionconfigureAction' buildActiondefaultBuildFlagsbuildOnlyConfigure targetAction targetCommandhaddockProjectAction benchAction benchCommandcomponentNotBenchmarkProblemnoBenchmarksProblem$fEqBenchProblem$fShowBenchProbleminstallmakeInstallContextmakeInstallPlanprocessInstallPlanpruneInstallPlan InstallArgsInstallContextmainreadSymbolicLinkDistribution.Compat.Exception catchExitcatchIOtryIODistribution.Compat.Prelude<<>>foldl1foldr1 genericRnftracetraceM traceShow traceShowId traceShowMDistribution.Compat.Semigroupgmappendgmemptybase-4.21.0.0-8bb5Data.List.NonEmptyheadinitlastnonEmptytaildeepseq-1.5.1.0-4a4cControl.DeepSeqdeepseqforceGHC.Internal.Base$$!++.=<<absurdapasTypeOfconstflipidjoinliftMliftM2mapord otherwiseuntilvacuouswhenGHC.Internal.CharchrGHC.Internal.Control.MonadfilterMfoldMguardunlessGHC.Internal.Data.EithereitherpartitionEithersGHC.Internal.Data.Foldableallandanyconcat concatMapfindfor_notElemor sequence_ traverse_GHC.Internal.Data.FunctiononGHC.Internal.Data.Functor<$>voidGHC.Internal.Data.Maybe catMaybes fromMaybeisJust isNothing listToMaybemapMaybemaybe maybeToListGHC.Internal.Data.OldList dropWhileEnd intercalate intersperse isPrefixOf isSuffixOflinesnubnubBy partitionsortsortByunfoldrunlinesunwordswordsGHC.Internal.Data.Ord comparingGHC.Internal.Data.TraversableforGHC.Internal.Data.TuplecurryfstsnduncurryGHC.Internal.Data.TypeabletypeRepGHC.Internal.ErrerrorerrorWithoutStackTrace undefinedGHC.Internal.IOcatchevaluatethrowIOGHC.Internal.IO.ExceptionioError userErrorGHC.Internal.List!!cycledrop dropWhilefilteriteraterepeat replicatereversescanlscanl1scanrscanr1spansplitAttake takeWhileunzipunzip3zipzip3zipWithzipWith3GHC.Internal.NumsubtractGHC.Internal.Readlex readParenGHC.Internal.Real^^^even fromIntegralgcdlcmodd realToFracGHC.Internal.ShowshowChar showParen showStringshowsGHC.Internal.System.Exit exitFailure exitSuccessexitWithGHC.Internal.System.IO appendFilegetChar getContentsinteractprintputCharreadIOreadLnreadsGHC.Internal.UnicodeisAlpha isAlphaNumisDigitisSpaceisUppertoLowertoUpperghc-prim GHC.Classes&&not||pretty-1.1.3.6-934aText.PrettyPrint.HughesPJ<+>GHC.PrimseqDistribution.Compat.NonEmptySet NonEmptySetDistribution.Utils.Structured Structuredbinary-0.8.9.3-940fData.Binary.ClassBinaryputputListcontainers-0.7-8423Data.Map.InternalMapData.Set.InternalNFDatarnf Alternative<|>emptysome Applicative*><*<*>liftA2pureFunctor<$fmapMonad>>>>=return MonadPlusmplusmzeroMonoidmappendmconcatmemptyNonEmpty:| Semigroup<>VoidGHC.Internal.Control.ArrowfirstGHC.Internal.Control.Monad.Fail MonadFailfailGHC.Internal.Data.DataDataEitherLeftRightFoldableelemfoldMapfoldlfoldl'foldrlengthmaximumminimumnullproductsumGHC.Internal.Data.Functor.ConstConstgetConst"GHC.Internal.Data.Functor.IdentityIdentity runIdentityGHC.Internal.Data.ProxyProxyGHC.Internal.Data.StringIsString fromString Traversable sequenceAtraverseTypeRep#GHC.Internal.Data.Typeable.InternalTypeableGHC.Internal.EnumBoundedmaxBoundminBoundEnumenumFrom enumFromThenenumFromThenTo enumFromTofromEnumpredsucctoEnumGHC.Internal.Exception.Type ExceptionbacktraceDesireddisplayException fromException toException SomeExceptionGHC.Internal.FloatFloating**acosacoshasinasinhatanatanhcoscoshexploglogBasepisinsinhsqrttantanh RealFloatatan2 decodeFloat encodeFloatexponent floatDigits floatRadix floatRangeisDenormalizedisIEEE isInfiniteisNaNisNegativeZero scaleFloat significandGHC.Internal.GenericsGenericFilePathExitCode ExitFailure ExitSuccessIOError IOExceptionGHC.Internal.IntInt16Int32Int64Int8Num*+-abs fromIntegernegatesignumReadreadList readsPrec Fractional/ fromRationalrecipIntegraldivdivModmodquotquotRemrem toIntegerRationalReal toRationalRealFracceilingfloorproperFractionroundtruncateShowshowshowList showsPrecShowSGHC.Internal.WordWord16Word32Word64Word8Eq/===Ord<<=>>=comparemaxmin GHC.TypesIOOrderingEQGTLT ghc-bignumGHC.Num.IntegerIntegerGHC.Internal.MaybeMaybeJustNothingFalseTrueCharDoubleFloatIntWord~Distribution.Simple.GlobexplainGlobSyntaxErrorfileGlobMatches globMatchesisRecursiveInRootmatchDirFileGlobmatchDirFileGlobWithDie matchGlobmatchGlobPieces parseFileGlobrunDirFileGlob GlobResult GlobMatchGlobMatchesDirectoryGlobMissingDirectoryGlobWarnMultiDotGlobSyntaxError EmptyGlobLiteralFileNameGlobStarNoExtensionOnStarStarInDirectoryStarInExtensionStarInFileNameVersionDoesNotSupportGlobVersionDoesNotSupportGlobStar showTimestampextractMirrorsresolv-0.2.0.3-6115f2c6f919dbaba468a2da46a2d2f7ed5b6e5bddd2e0f85fc1cc14630936fc Network.DNSqueryTXT isUrlBase splitRfc1464 normalisefilterPreferredVersionsdependencyInconsistencies' libraryRootsrootSets setupRootsstateDependencyRelation!hashedInstalledPackageIdVeryShortbytestring-0.12.2.0-ab94 Data.ByteString.Builder.InternalBuilder doubleToInt64 escapeStringFSectionUnrecFieldParserparseSpaceList showFilePath showFreeText showTokencommaListFieldParseccommaNewLineListFieldParsec fieldParseclineNo listFieldlistFieldParseclistFieldWithSeplocatedErrorMsg monoidFieldmonoidFieldParsecnewLineListField parseFailparseHaskellStringparseOptCommaList parseTokenQ readFields readPToMayberunErunP showPWarning simpleFieldsimpleFieldParsecspaceListField syntaxErrorwarningFieldLineNoPErrorAmbiguousParseFieldShouldBeStanza FromStringNoParse TabsErrorPWarning UTFWarning ParseResult ParseFailedParseOk$fApplicativeParseResult$fFunctorParseResult $fEqField $fEqPError $fEqPWarning$fFoldableParseResult$fMonadFailParseResult$fMonadParseResult $fShowField $fShowPError$fShowPWarning$fShowParseResult$fTraversableParseResult projectParseprojectParseFailProjectParseErrorprojectParseErrorprojectParseSnippetprojectParseSourceProjectParseResultProjectParseFailedProjectParseOkProjectParseWarning$fApplicativeProjectParseResult$fFunctorProjectParseResult$fMonadProjectParseResult$fShowProjectParseError$fShowProjectParseResult removeFileifMifNotM listContents partitionMtry_find_package_desc#GHC.Internal.Control.Exception.Basebracket mkInstallPlanDistribution.Compat.GraphGraph promptDefaultbreakOrContinue mkDefPromptDistribution.Fields.Pretty PrettyFieldDocfromFlagOrPromptaddBaseDepToFlags writeFileSafewriteCabalFileMonitorStateFileModTimeMonitorStateFileHashedMonitorStateDirModTime FileHashCachebuildMonitorStateFileSetbuildMonitorStateGlobchangedDuringUpdatecheckDirectoryModificationTimeDistribution.Compat.TimeModTime)checkFileModificationTimeAndHashUnchangedcheckModificationTimeUnchanged getFileHashhandleErrorCallGHC.Internal.Exception ErrorCallhandleIOExceptionlookupFileHashCacheprobeDirExistenceprobeFileExistenceprobeFileModificationTime probeFileModificationTimeAndHashprobeFileNonExistenceprobeFileSystemprobeMonitorStateFileStatusprobeMonitorStateGlobreadCacheFileHashesreconstructMonitorFilePathsrewriteCacheFilestructuredDecodeTriple withCacheFilebuildMonitorStateFilebuildMonitorStateGlobRelprobeMonitorStateGlobRelmonitorFileExistence MonitorFileMonitorFileGlobmonitorKindDirmonitorKindFile monitorPathmonitorPathGlobMonitorKindDir DirExists DirModTime DirNotExistsMonitorKindFile FileHashed FileModTime FileNotExistsfindFile unRebuild vcsCloneRepo vcsSyncReposaddSourcePackages*Distribution.Solver.Types.ConstraintSourceConstraintSetupCabalMaxVersionConstraintSourceProfiledDynamicResolveUnsatisfiabledepResolverAllowBootLibInstallsdepResolverOnlyConstraineddepResolverSolveExecutablesdepResolverGoalOrderResolveNoDepsError removeBoundsconfiguredPackageProblems#dontInstallNonReinstallablePackagesinterpretPackagesPreferencenonReinstallablePackagesrelaxPackageDeps removeBoundshowPackagePreferencevalidateSolverResult matchPlusUnknownInexactExactMatch matchExactlymatchInexactlymatchPlusShadowing findMatch MatchClassSyntaxNone Unambiguous AmbiguouscompareFilePath exactMatchesinexactMatchesmkComponentName&Distribution.Types.UnqualComponentNameUnqualComponentNameDistribution.Types.PackageName PackageNameparseTargetStringsresolveTargetSelectorssyntaxForm1AllsyntaxForm1ComponentsyntaxForm1FilesyntaxForm1FiltersyntaxForm1ModulesyntaxForm1PackagesyntaxForm2AllFiltersyntaxForm2ComponentFilesyntaxForm2ComponentModulesyntaxForm2KindComponentsyntaxForm2MetaAllsyntaxForm2NamespacePackagesyntaxForm2PackageComponentsyntaxForm2PackageFilesyntaxForm2PackageFiltersyntaxForm2PackageModulesyntaxForm3KindComponentFilesyntaxForm3KindComponentModulesyntaxForm3MetaAllFiltersyntaxForm3MetaNamespacePackagesyntaxForm3PackageComponentFile!syntaxForm3PackageComponentModulesyntaxForm3PackageKindComponent,syntaxForm5MetaNamespacePackageKindComponent9syntaxForm7MetaNamespacePackageKindComponentNamespaceFile;syntaxForm7MetaNamespacePackageKindComponentNamespaceModule syntaxFormsDistribution.Simple.Command OptionFieldgetField ppFgSectionppSectionAndSubsectionsgetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDir Downloaded CheckETag NeedsDownloadtransportCheckHttpsWithErrorget'getRange SecureRepoinitSecureRepoinitSecureRepos packageFile packageURIConstraintScope%Distribution.Solver.Types.PackagePath Qualifier#Distribution.Simple.Setup.BenchmarkBenchmarkFlagsDistribution.Types.VersionVersionDistribution.Simple.Setup.Copy CopyFlags HaddockFlags"Distribution.Simple.Setup.Register RegisterFlagsDistribution.Simple.Setup.ReplDistribution.Simple.Setup.Test TestFlagsnotesOfGetCommanddescriptionOfGetCommandFileInfofiles NotExists OkToOverwrite NotOurFile makeRelativeonSymlinkBinarytargetOkToOverwrite+Distribution.Solver.Types.ProjectConfigPathProjectConfigPath loadRawConfigConfigFileSourcedefaultHackageRemoteRepoKeys$defaultHackageRemoteRepoKeyThresholddefaultInstallPrefix getDefaultDirinitFlagsFieldsmaybeGetCabalDirwarnOnTwoConfigs SectionsAccumpkgEnvFieldDescrsparsePackageEnvironmentuserPackageEnvironmentconvertLegacyPerPackageFlagsconvertLegacyAllPackageFlagsconvertLegacyBuildOnlyFlags!packageSpecificOptionsFieldDescrs"packageSpecificOptionsSectionDescrprogramDbOptionsparseProjectSkeletonDistribution.Types.UnitIdUnitIdelabOrderDependenciesDistribution.Backpack OpenUnitId nodeNeighborscompOrderDependenciescompOrderExeDependenciesdataDirEnvVarForPackage PackageIdSetencodePlanAsJsonpostBuildProjectStatusreadPackagesUpToDateCacheFilewritePackagesUpToDateCacheFileDistribution.Simple.Utilswarn renderImplicitBadPackageLocationCabalFileSearchFailurereadProjectFileSkeletonextractTarballPackageCabalFile"extractTarballPackageCabalFilePure&fetchAndReadSourcePackageRemoteTarballglobStarDotCaballocalFileNameForRemoteRepolocalFileNameForRemoteTarballmkSpecificSourcePackage'Distribution.Solver.Types.SourcePackage SourcePackagereadProjectLocalConfigOrDefaultreadSourcePackageLocalDirectoryreadSourcePackageLocalTarball$syncAndReadSourcePackagesRemoteRepostruncateStringwithProjectOrGlobalConfig'readIndexTimestampIndexStateInfo isiHeadTimetarEntriesList PackageOrDep lazySequenceBlockNoCache cacheHeadTs cacheEntries filterCache isiMaxTime NoIndexCacheData.ByteString.Lazy.Internal ByteString getIndexCache hashConsCache is01Index lazyUnfoldpackageListFromCacheparsePreferredVersionsreadIndexCachedieWithExceptionreadIndexCache'readNoIndexCachereadPackageIndexCacheFile readRepoIndexwithIndexEntrieswriteIndexCache SetupMethodSetupsetupScriptOptionsDistribution.Types.BuildTypeInternalMethodSelfExecMethodExternalMethod SetupRunnergetSetupMethodinternalSetupMethod verbosityHack ExtDependencyPackageDisplayInfo getPkgListinterestingVersionsmergePackageInfo mergePackagesupdateFileSystemPackageDetailsselectPackageSourceRepoRepoKindunpackOnlyPkgDescrcabalConfigFlagsFileconfigurePackageplanLocalPackage$GHC.Internal.Data.Semigroup.InternalAny PrunedPackageelaborateInstallPlangetPackageSourceHashes'improveInstallPlanWithInstalledPackages Distribution.Simple.PackageIndexInstalledPackageIndexinplaceBinRootipiComponentName matchElabPkg matchPlanPkg mkCCMappingDistribution.Types.ComponentId ComponentIdmkShapeMapping optionalStanzasWithDepsAvailablepackageLocationsSignatureprogramDbSignatureDistribution.Simple.Program.Db ProgramDbprogramsMonitorFilespruneInstallPlanPass1reportPlanningFailure&sanityCheckElaboratedConfiguredPackagesetRootTargetsuserInstallDirTemplatesdetermineCoverageFor'Distribution.Types.InstalledPackageInfoInstalledPackageInfo copyPkgFilesPBConfigurePhaserunCopyasyncDownloadPackageswaitAsyncPackageDownloadcreatePackageDBIfMissingfoldMInstallPlanDepOrdermoveTarballShippedDistDirectory rebuildTargetwithTarballLocalDirectoryresolveTargetsAvailableTargetIndexes(availableTargetIndexesFromSourcePackagesDistribution.Types.ExecutablesrcpkgDescriptionextractScriptBlockreadExecutableBlockFromScriptreadProjectBlockFromScriptTargetProblemNoTestsTargetProblemComponentNotTestTargetProblemIsSubComponent TestProblemrenderAllowedNoTestsProblem RunProblemTargetProblemNoExesTargetProblemMatchesMultipleTargetProblemMultipleTargetsTargetProblemComponentNotExematchingPackagesByUnitIdReplTargetProblemminGhciScriptVersionminMultipleHomeUnitsVersion requireCabalselectPackageTargetsSingleusingGhciScriptvalidatedTargets ConfigPathgetPathLocationpathNameprettyOutdatedDependencySourceOutdatedDependencySourcedepsFromFreezeFiledepsFromLocalPackagesdepsFromPkgDescdepsFromProjectContext selectComponentTargetForOutdatedselectPackageTargetsForOutdateduserConstraintsToDependenciesDistribution.Types.Dependency DependencyListBinProblemTargetProblemNoRightComps"TargetProblemComponentNotRightKind InstallCheckInstallCheckOnlyInstallCheckInstall InstallExemkSourceBinDir mkExeNamemkFinalExeNamedisableTestsBenchsByDefaultentriesForLibraryComponents Distribution.Simple.GHC.InternalGhcEnvironmentFileEntrygetClientInstallFlags getEnvFilegetEnvSpecsAndNonGlobalEntriesgetExistingEnvEntries getGlobalEnv getLocalEnvignoreProgramAffixesinstallBuiltExeinstallCheckUnitExesinstallLibraries)partitionToKnownTargetsAndHackagePackagesprepareExeInstallsymlinkverifyPreconditionsOrDieconstructProjectBuildContexttargetPkgNamesgetBoundsForComponentreportGenBoundsTargetProblemsprojectFreezeConfigprojectFreezeConstraints pathAdditionswithTempEnvFileTargetProblemNoBenchmarks"TargetProblemComponentNotBenchmark BenchProblem UseLogFilecheckPrintPlaninstallReadyPackageDistribution.Types.FlagFlagAssignmentpostInstallActionstheSpecifiedPackageinstallUnpackedPackage Distribution.Compat.ResponseFileexpandResponse mainWorker CommandParseactAsSetupActionbuildbenchmarkActioncomponentNamesFromLBIwarnIfAssertionsAreEnabled