h&W}      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\] ^ _ ` a b c d e f g h i j k l m n o p q r s tuvwxyz{|}~         !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""""""""""""""""""""""""""#################$$$$$$$$$$$$$$$$$$%%%%%%&&&&&&&&&&&&&'''''''''''''(((((((((((((((()))))))))))************++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,--------------------------------------.....................////////////////000000000111111111111122222222222                             33333333333333333333333333333333333333333333333333333333333334444444444444444444444444444444444444444444444444455667777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777788 8 8 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 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 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 B 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 C C C C C C C C C C C C C C C C C C C C C C C 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 D D D D D D D D E F                       G H H H H H H H H H H H H H H H H H H H H I I I I I I I I I I I I I I I I I I I I I I I I I I I I I J J J J J J J J J J K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K 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 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 LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMNNNNOOPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRSSSSSSSSSSSSTTUUUUUVVWXXXXXXXXXXXXXYZZZ[PPPPPPPPPPPPPPPPPPPPPPPPPPP\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]^^^^^^^^^^^^^^^^^^^^^^^^^^_________```````````````aaaabbbbbbbbbbbbbbbbcccccccccccccccccccccccccccddddeeeeeefffffffgghiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkklmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooopppppppppppppppppqqqqqqqqqqqqqqqqqqqqqqqqrrrsssssssssssssssssssstttttuuuuuuuuuvvvvvvvvvvwwwwwwwxxxxxxxxyyyyyyyyyzzzzzzzz{{{{{{{{||||||||||}}~~  Safe-Inferred?popqrorqp Safe-Inferred@ cabal-install Reads the FilePath1 pointed to by the symbolic link and returns it.See readlink(2)t cabal-install8Returns 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.0tt Safe-InferredA Safe-InferredA1KTUVXWY\[Z KTUVXWY\[Z(c) Duncan Coutts 2009BSD-likecabal-devel@haskell.orgportable Safe-Inferred;F  cabal-install&The package this build report is about cabal-install(The OS and Arch the package was built on cabal-install1The Haskell compiler (and hopefully version) used cabal-install,The uploading client, ie cabal-install-x.y.z cabal-install"Which configurations flags we used cabal-install.Which dependent packages we were using exactly cabal-installDid installing work ok? cabal-install)Configure outcome, did configure work ok? cabal-install)Configure outcome, did configure work ok?z}{|~~z}{| Safe-InferredG]   Safe-Inferred6Hu cabal-install 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. Safe-Inferred;L cabal-installGlobal policy for all packages to say if we prefer package versions that are already installed locally or if we just prefer the latest available. cabal-installAlways prefer the latest version irrespective of any existing installed version.(This is the standard policy for upgrade. cabal-installAlways prefer the oldest version irrespective of any existing installed version or packages explicitly requested.#This is enabled by --prefer-oldest. cabal-installAlways 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). cabal-installPrefer 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. cabal-install!All the solvers that can be used. cabal-install%All the solvers that can be selected.  (c) Dmitry Astapov 2010BSD-likecabal-devel@gmail.com provisionalportable Safe-InferredO cabal-installAttempts 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/678 Safe-Inferred;TK  cabal-installe.g. "/", "c:" or result of  cabal-installA piece of a globbing pattern cabal-install6A single directory or file component of a globbed path cabal-installtrailing dir, a glob ending in / cabal-install!A file path specified by globbing cabal-install 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. cabal-installGet the  corresponding to a .The 2 argument is required to supply the path for the  case. cabal-installMatch 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. cabal-installMatch a  against the file system, starting from a given root directory. The results are all relative to the given root. cabal-install6Match a globbing pattern against a file path component cabal-installroot for relative paths(c) Andrea Vezzosi 2009BSD-likecabal-devel@haskell.orgportable Safe-InferredU Safe-Inferred6;W- cabal-install&Hash some data. Currently uses SHA256. cabal-install(Hash the content of a file. Uses SHA256. cabal-install(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. cabal-install!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(c) 2016 Herbert Valerio RiedelBSD3 Safe-Inferred"%&;Y cabal-installUNIX timestamp (expressed in seconds since unix epoch, i.e. 1970). cabal-installCompute the maximum  valueReturns & for the empty list. Also note that  compares as smaller to all non- values. cabal-installPretty-prints " in ISO8601/RFC3339 format (e.g. "2017-12-31T23:59:59Z")Returns empty string for  in order for $null (display nullTimestamp) == Trueto hold. cabal-install(Special timestamp value to be used when  timestamp is missingunknowninvalid4Factory functions for producing known license types.BSD-likecabal-devel@haskell.org provisionalportable Safe-InferredZ  (c) Duncan Coutts 2012BSD-likecabal-devel@haskell.org provisionalportable Safe-Inferred_N cabal-installA simple concurrency abstraction. Jobs can be spawned and can complete in any order. This allows both serial and parallel implementations. cabal-install!Add a new job to the pool of jobs cabal-installWait until one job is complete cabal-installReturns True if there are any outstanding jobs (ie spawned but yet to be collected) cabal-install>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). cabal-installMake 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. cabal-installMake 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.   Safe-Inferred;_ Safe-Inferred";c cabal-install)The cabal project file name; defaults to  cabal.project. The name itself 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 the path is not found in the current working directory, we will successively probe relative to parent directories until this name is found. cabal-installWhether to ignore the local project (i.e. don't search for cabal.project) The exact interpretation might be slightly different per command. cabal-installAs almost all commands use  but not all can honour "ignore-project" flag, provide this utility to remove the flag parsing from the help message. Safe-Inferred6e< cabal-installWrite 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. cabal-installRead command-line arguments, separated by null characters, from a file. Returns the default flags if the file does not exist. Safe-Inferredj; cabal-installTry 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. cabal-installExtract list of mirrors from  result cabal-installHelper used by  for extracting urlbase keys from Rfc1464-encoded data cabal-installSplit a TXT string into key and value according to RFC1464. Returns  if parsing fails. Safe-Inferredk cabal-installTerminated is an asynchronous exception, thrown when SIGTERM is received. It's to kill what  UserInterrupt is to Ctrl-C. cabal-installInstall 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. (c) 2007 Bjorn Bringert, 2008 Andrea Vezzosi, 2008-2009 Duncan CouttsBSD3duncan@community.haskell.orgportable Safe-Inferred8o  cabal-installType 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. cabal-install7Type code for the local build tree snapshot entry type. cabal-install/Is this a type code for a build tree reference? cabal-installFull Tarball path cabal-installBase directory cabal-install*Directory to archive, relative to base dir cabal-installDestination directory cabal-install'Expected subdir (to check for tarbombs) cabal-installTarball! Safe-Inferred;z cabal-install Express whether to relax bounds on all packages, or a single package cabal-install"Modifier for dependency relaxation cabal-installDefault semantics cabal-installApply relaxation only to ^>= constraints cabal-installSpecify the scope of a relaxation, i.e. limit which depending packages are allowed to have their version constraints relaxed. cabal-installApply relaxation in any package cabal-install0Apply relaxation to in all versions of a package cabal-install8Apply relaxation to a specific version of a package only cabal-installDependencies can be relaxed either for all packages in the install plan, or only for some packages. cabal-installGeneric 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). cabal-installIgnore 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. cabal-installIgnore 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 ) cabal-install* in the context of lower bounds (i.e. for  --allow-older flag) cabal-install* in the context of upper bounds (i.e. for  --allow-newer flag) cabal-installReturn  if ) specifies a non-empty set of relaxationsEquivalent to isRelaxDeps = (/= ) cabal-install A smarter RelaxedDepsSome, *:* is the same as all. cabal-install [] is the identity element cabal-install is the absorbing element cabal-install%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 RelaxDepsNothing" Safe-Inferred;{7 cabal-install>A summary of the outcome for building a whole set of packages. cabal-install7A summary of the outcome for building a single package.# Safe-Inferred; cabal-install8A 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). cabal-install-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.  $ Safe-Inferred; cabal-installA  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. cabal-installpackage info, including repo cabal-install(complete flag assignment for the package cabal-install0list of enabled optional stanzas for the package cabal-install0set 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. cabal-install# indicates data types which have a . This type class is mostly used to conveniently finesse between ElaboratedPackage and ElaboratedComponent.% Safe-InferredU& Safe-Inferred; cabal-installLast' Safe-Inferred;( Safe-Inferred;%  ) Safe-Inferred8; cabal-install5A fully or partially resolved reference to a package. cabal-installA partially specified reference to a package (either source or installed). It is specified by package name and optionally some required properties. Use a dependency resolver to pick a specific package satisfying these properties. cabal-install!A fully specified source package.* Safe-Inferred;% cabal-installRepository name.May be used as path segment. cabal-install4simpleParsec "hackage.haskell.org" :: Maybe RepoName%Just (RepoName "hackage.haskell.org")%simpleParsec "0123" :: Maybe RepoNameNothing+ Safe-Inferred;p cabal-installDifferent kinds of repositories:NOTE: It is important that this type remains serializable. cabal-install Local repository, without index. ,https://github.com/haskell/cabal/issues/6359 cabal-install(Standard (unsecured) remote repositories cabal-installSecure 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. cabal-installno-index style local repositories. ,https://github.com/haskell/cabal/issues/6359 cabal-installEnable 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) cabal-install Root key IDs (for bootstrapping) cabal-install/Threshold for verification during bootstrapping cabal-installNormally 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. cabal-installConstruct a partial * value to fold the field parser list over. cabal-installConstruct a partial * value to fold the field parser list over. cabal-install%Calculate a cache key for local-repo.For remote repositories we just use name, but local repositories may all be named "local", so we add a bit of  into the mix. cabal-installCheck if this is a remote repo cabal-installExtract  RemoteRepo from Repo if remote. cabal-install#Note: serialised format represents  only partially. cabal-installNote: doesn't parse  field.,(c) 2016 Herbert Valerio RiedelBSD3 Safe-Inferred";  cabal-install;Specification of the state of a specific repo package index cabal-installUse all available entries cabal-install2Use all entries that existed at the specified time cabal-install$Index state of multiple repositories cabal-installRemove non-default values from . cabal-install where all repositories are at HEAD index state. cabal-installCreate . cabal-install Lookup a # for an individual repository from . cabal-install Insert a  to . cabal-install,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 "hackage.haskell.org",IndexStateHead)]))simpleParsec "hackage.haskell.org 2020-02-04T12:34:56Z" :: Maybe TotalIndexStateJust (TIS IndexStateHead (fromList [(RepoName "hackage.haskell.org",IndexStateTime (TS 1580819696))]))- Safe-Inferred";q  cabal-installskip this repository cabal-installmerge existing versions cabal-installif later repository specifies a package, all package versions are replaced cabal-install1rest repositories, i.e. not explicitly listed as  cabal-installexplicit repository name cabal-install$Ordered list of active repositories. cabal-installNote, this does nothing if  is present. cabal-install Sort values  according to  list.6let repos = [RepoName "a", RepoName "b", RepoName "c"]organizeByRepos (ActiveRepos [ActiveRepoRest CombineStrategyMerge]) id reposRight [(RepoName "a",CombineStrategyMerge),(RepoName "b",CombineStrategyMerge),(RepoName "c",CombineStrategyMerge)]organizeByRepos (ActiveRepos [ActiveRepo (RepoName "b") CombineStrategyOverride, ActiveRepoRest CombineStrategyMerge]) id reposRight [(RepoName "b",CombineStrategyOverride),(RepoName "a",CombineStrategyMerge),(RepoName "c",CombineStrategyMerge)]organizeByRepos (ActiveRepos [ActiveRepoRest CombineStrategyMerge, ActiveRepo (RepoName "b") CombineStrategyOverride]) id reposRight [(RepoName "a",CombineStrategyMerge),(RepoName "c",CombineStrategyMerge),(RepoName "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. cabal-install 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 "hackage.haskell.org") CombineStrategyMerge,ActiveRepoRest CombineStrategyMerge,ActiveRepo (RepoName "head.hackage") CombineStrategyOverride])  . Safe-Inferred "/5;=p cabal-install without subdir. Used in clone errors. Cloning doesn't care about subdirectory. cabal-installDistilled from  cabal-install Read from  cabal.project cabal-installsource-repository-package definition cabal-install Split single source-repository-package declaration with multiple subdirs, into multiple ones with at most single subdir./ Safe-Inferred8; cabal-install7Convenience alias for 'SourcePackage UnresolvedPkgLoc'. cabal-install4An unpacked package in the given dir, or current dir cabal-install:A package as a tarball that's available as a local tarball cabal-install(A package as a tarball from a remote URI cabal-install3A package available as a tarball from a repository.It may be from a local repository or from a remote repository, with a locally cached copy. ie a package available from hackage cabal-installA package available from a version control system source repository  0 Safe-Inferred; cabal-install&This is the information we get from a 00-index.tar.gz hackage index. cabal-installDoes a case-sensitive search by package name and a range of versions.We get back any number of versions of the specified package name, all satisfying the version range constraint.Additionally, `preferred-versions` (such as version deprecation) are honoured in this lookup, which is the only difference to  cabal-install-Does a case-sensitive search by package name.Additionally, `preferred-versions` (such as version deprecation) are honoured in this lookup, which is the only difference to  cabal-installfilterPreferredVersions range versions. If a range: is given, only keep versions that satisfy the range. If range is , all versions are kept.The range% is expected to be obtained from the .1 Safe-Inferred; cabal-installLike , but with all dependencies guaranteed to be installed already, hence itself ready to be installed.2 Safe-Inferred; cabal-installWhether '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 -').(c) David Himmelstrup 2005 Duncan Coutts 2011BSD-likecabal-devel@haskell.org provisionalportable Safe-Inferred "68; (c) Duncan Coutts 2008BSD-likeduncan@community.haskell.org provisionalportable Safe-Inferred6;1 cabal-installBuild an installation plan from a valid set of resolved packages. cabal-installRemove 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. cabal-install7A 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. cabal-installFor 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. cabal-installCompute 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. cabal-installCompute 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. cabal-install#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). cabal-install2The setup dependencies of each package in the plan cabal-installGiven 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. cabal-installThe 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. cabal-installAn 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. cabal-installAn 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. cabal-installThe 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. cabal-install=Compute the dependency closure of a package in a install plan`_^`_^3 Safe-Inferred%&'6;ǎ cabal-installThose parts of the package configuration that contribute to the package hash. cabal-installAll the information that contributes to a package's hash, and thus its . cabal-install 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 . cabal-install 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). cabal-installOn 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). cabal-installOn 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. cabal-install-Calculate the overall hash to be used for an . cabal-install'Render a textual representation of the .The * of this text is the overall package hash.<<4(c) Duncan Coutts 2008BSD-likeduncan@community.haskell.org provisionalportable Safe-Inferred /6;D cabal-install9The set of results we get from executing an install plan. cabal-installThe  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. cabal-install) specialised to most commonly used types. cabal-installPackages 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. cabal-install'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.) cabal-install.Smart constructor that deals with caching the  representation. cabal-installBuild an installation plan from a valid set of resolved packages. cabal-installRemove 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. cabal-install#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 ). cabal-installLookup a package in the plan. cabal-install6Find all the direct dependencies of the given package.?Note that the package must exist in the plan or it is an error. cabal-install>Find all the direct reverse dependencies of the given package.?Note that the package must exist in the plan or it is an error. cabal-installReturn 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. cabal-installReturn the packages in the plan that are direct or indirect dependencies of the given packages. cabal-installReturn the packages in the plan that depend directly or indirectly on the given packages. cabal-installConversion of  to . Similar to elaboratedInstallPlan cabal-installThe 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. cabal-installGiven 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. cabal-install 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 . cabal-install-Lookup the build result for a single package. cabal-installExecute 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 . cabal-installA 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. cabal-installFor 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. cabal-installThe 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. cabal-installKeep going after failure cabal-install'Value for dependents of failed packages&& Safe-InferredZ" cabal-installPhase of building a dependency. Represents current status of package dependency processing. See #4040 for details. cabal-installGeneric merging utility. For sorted input lists this is a full outer join. cabal-installLike , but does not throw an exception when the file does not exist. cabal-install 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. cabal-install/Executes the action in the specified directory.Warning: This operation is NOT thread-safe, because current working directory is a process-global concept. cabal-installExecutes 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. cabal-installExecutes 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. cabal-installExecutes the action, increasing the PATH environment in some wayWarning: This operation is NOT thread-safe, because the environment variables are a process-global concept. cabal-installLog directory change in make compatible syntax cabal-installDetermine the number of jobs to use given the value of the '-j' flag. cabal-installGiven a relative path, make it absolute relative to the current directory. Absolute paths are returned unmodified. cabal-installGiven a path (relative or absolute), make it relative to the current directory, including using ../.. if necessary. cabal-installGiven a path (relative or absolute), make it relative to the given directory, including using ../.. if necessary. cabal-installGiven 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. cabal-install Convert a  to a lazy  ByteString. Each  is encoded as a little-endian . cabal-installReverse operation to . cabal-install-Workaround for the inconsistent behaviour of . Always throws an error if the path refers to a non-existent file. cabal-installA non-throwing wrapper for . If < throws an exception, returns the path argument unmodified. cabal-installLike 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. cabal-installLike -, but also checks that the first file exists. cabal-installSets 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. cabal-installLike -, but with error specific to add-source deps. cabal-installTry to find 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. cabal-installGiven 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.*). cabal-install6Increment the nth version component (counting from 0). cabal-install"Returns the current calendar year. cabal-installFrom System.Directory.Extra /https://hackage.haskell.org/package/extra-1.7.9 cabal-installFrom System.Directory.Extra /https://hackage.haskell.org/package/extra-1.7.9 cabal-installFrom System.Directory.Extra /https://hackage.haskell.org/package/extra-1.7.9 cabal-installFrom Control.Monad.Extra /https://hackage.haskell.org/package/extra-1.7.9 cabal-install with swapped branches: ifNotM b t f = ifM (not  $ b) t f cabal-installFrom Control.Monad.Extra /https://hackage.haskell.org/package/extra-1.7.9 cabal-installFrom Control.Monad.Extra /https://hackage.haskell.org/package/extra-1.7.9 cabal-installhasElem 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.//5 Safe-Inferred" cabal-installList 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. cabal-install-Create a tarball for a package in a directory cabal-install read in GPD cabal-installdirectory containing that GPD cabal-installresulting sdist tarball6cabal-devel@haskell.orgportable Safe-Inferred cabal-installReturn the executable to run and any extra arguments that should be forwarded to it. Die in case of error. cabal-installRun a given executable.7%(c) Brent Yorgey, Benedikt Huber 2009BSD-likecabal-devel@haskell.org provisionalportable Safe-Inferred8; cabal-install'Annotations for cabal file PrettyField. cabal-installGuess the main file, returns a default value if none is found.  cabal-installJuggling characters around to guess the desired cabal version based on the system's cabal version.  cabal-install9Guess the language specification based on the GHC version  cabal-install9Guess the package name based on the given root directory.  cabal-install2Try 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.  cabal-installTry to guess the package type from the files in the package directory, looking for unique characteristics from each type, defaults to Executable.  cabal-installTry to guess the application directories from the package directory, using a default value as fallback.  cabal-installTry to guess the source directories, using a default value as fallback.  cabal-install7Guess author and email using git configuration options. > Safe-Inferred(U  cabal-install(Main driver for interactive prompt code.  cabal-installGet 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.  cabal-installGet 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.  cabal-install-Package version: use 0.1.0.0 as a last resort  cabal-installChoose 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.  cabal-installThe author's name. Prompt, or try to guess from an existing git repo.  cabal-installThe author's email. Prompt, or try to guess from an existing git repo.  cabal-install*Prompt for a homepage URL for the package.  cabal-installPrompt for a project synopsis.  cabal-installPrompt 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.  cabal-install Try to guess extra source files.  cabal-installTry to guess if the project builds a library, an executable, or both.  cabal-installTry to guess the main file, if nothing is found, fallback to a default value.  cabal-install1Ask for the Haskell base language of the package.  cabal-install-Ask whether to generate explanatory comments.  cabal-install'Ask for the application root directory.  cabal-install,Ask for the source (library) root directory.  cabal-install$Retrieve the list of exposed modules  cabal-installRetrieve the list of other modules for Libraries, filtering them based on the last component of the module name  cabal-installRetrieve the list of other modules for Executables, it lists everything that is a Haskell file within the application directory, excluding the main file  cabal-installRetrieve the list of other modules for Tests, it lists everything that is a Haskell file within the tests directory, excluding the main file  cabal-install Retrieve the list of build tools  cabal-install!Retrieve the list of dependencies  cabal-installRetrieve the list of extensions ?(c) Brent Yorgey 2009BSD-likecabal-devel@haskell.org provisionalportable Safe-Inferred.Z  cabal-install(Main driver for interactive prompt code.  cabal-installExtract 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.  cabal-installExtract 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.  cabal-installExtract 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.  cabal-installExtract 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.  cabal-install'Ask for the application root directory.  cabal-install,Ask for the source (library) root directory.  @(c) Brent Yorgey 2009BSD-likecabal-devel@haskell.org provisionalportable Safe-Inferred"1  cabal-installWrite 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.  cabal-install.Writes the changelog to the current directory. cabal-installPossibly generate a message to stdout, taking into account the --quiet flag. cabal-installWrite a file "safely" if it doesn't exist, backing up any existing version when the overwrite flag is set. cabal-install .cabal fields  A Safe-Inferred '8;p= cabal-installWe 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.  cabal-installA timestamp to help with the problem of file changes during actions. See   for details.  cabal-installWhat kind of change   detected.  cabal-installOne of the files changed (existence, file type, mtime or file content, depending on the   in question)  cabal-installThe 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).  cabal-installThere was no saved monitor state, cached value etc. Ie the file for the   does not exist.  cabal-installThere 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.  cabal-installThe 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.  cabal-installThe 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.  cabal-install>The monitor found that something changed. The reason is given.  cabal-installA 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.  cabal-installThe file where this   should store its state.  cabal-installCompares 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.  cabal-installWhen 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.  cabal-installThe state necessary to determine whether the files matched by a globbing match have changed. cabal-installcached file mtime cabal-installcached mtime and content hash cabal-installcached dir mtime  cabal-installThe 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.  cabal-installThe 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.  cabal-installA description of a file (or set of files) to monitor for changes.Where file paths are relative they are relative to a common directory (e.g. project root), not necessarily the process current directory.  cabal-installMonitor a single file for changes, based on its modification time. The monitored file is considered to have changed if it no longer exists or if its modification time has changed.  cabal-installMonitor a single file for changes, based on its modification time and content hash. The monitored file is considered to have changed if it no longer exists or if its modification time and content hash have changed.  cabal-installMonitor a single non-existent file for changes. The monitored file is considered to have changed if it exists.  cabal-installMonitor a single file for existence only. The monitored file is considered to have changed if it no longer exists.  cabal-installMonitor a single directory for changes, based on its modification time. The monitored directory is considered to have changed if it no longer exists or if its modification time has changed.  cabal-installMonitor a single non-existent directory for changes. The monitored directory is considered to have changed if it exists.  cabal-installMonitor a single directory for existence. The monitored directory is considered to have changed only if it no longer exists.  cabal-installMonitor a single file or directory for changes, based on its modification time. The monitored file is considered to have changed if it no longer exists or if its modification time has changed.  cabal-installMonitor a set of files (or directories) identified by a file glob. The monitored glob is considered to have changed if the set of files matching the glob changes (i.e. creations or deletions), or for files if the modification time and content hash of any matching file has changed.  cabal-installMonitor a set of files (or directories) identified by a file glob for existence only. The monitored glob is considered to have changed if the set of files matching the glob changes (i.e. creations or deletions).  cabal-installCreates a list of files to monitor when you search for a file which unsuccessfully looked in notFoundAtPaths before finding it at  foundAtPath.  cabal-install Similar to  ?, but also instructs us to monitor the hash of the found file. cabal-installWe 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.  cabal-installDefine a new file monitor.It's best practice to define file monitor values once, and then use the same value for   and  ) as this ensures you get the same types a and b for reading and writing.The path of the file monitor itself must be unique because it keeps state on disk and these would clash.  cabal-install2Test if the input value or files monitored by the  0 have changed. If not, return the cached value.See   for a full explanation. cabal-installLazily 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. cabal-install"Helper for reading the cache file.=This determines the type and format of the binary cache file. cabal-install"Helper for writing the cache file.=This determines the type and format of the binary cache file. cabal-installProbe 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. cabal-installProbe the file system to see if a single monitored file has changed. cabal-installProbe the file system to see if a monitored file glob has changed.  cabal-install>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.  cabal-installRecord a timestamp at the beginning of an action, and when the action completes call   passing it the timestamp. See   for details. cabal-installTake 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. cabal-installIf 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. cabal-install 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. cabal-installWe declare it a cache hit if the mtime of a file is the same as before. cabal-install0Either get it from the cache or go read the file cabal-installBuild 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. cabal-install Within the root directory, check if file has its  is the same as mtime&, short-circuiting if it is different. cabal-install Within the root directory, check if file has its  and  is the same as mtime and hash', short-circuiting if it is different. cabal-install Within the root directory, check if file still exists as a file. If it *does not* exist, short-circuit. cabal-install Within the root directory, check if dir6 still exists. If it *does not* exist, short-circuit. cabal-install Within the root directory, check if file: still does not exist. If it *does* exist, short-circuit. cabal-installReturns True if, inside the root directory, file has the same  as mtime. cabal-installReturns True if, inside the root directory, file has the same  and  as  mtime and chash@. cabal-install#Read a non-cryptographic hash of a file. cabal-installGiven a directory dir , return Nothing if its  is the same as mtime, and the new  if it is not. cabal-install4Run an IO computation, returning the first argument e if there is an  call. () cabal-install!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.  cabal-installThe file to cache the state of the file monitor. Must be unique.  cabal-installcache file path cabal-installroot directory cabal-installguard or key value cabal-install did the key or any paths change? cabal-install root path cabal-install root path cabal-install7path of the directory we are looking in relative to root  cabal-installcache file path cabal-installroot directory cabal-install(timestamp when the update action started cabal-install"files of interest relative to root cabal-installthe current key value cabal-installthe current result value cabal-install/optional: timestamp of the start of the action cabal-installexisting file hashes cabal-installroot directory cabal-install(patterns of interest relative to root cabal-installstart time of update cabal-installexisting file hashes cabal-installthe root directory cabal-installstart time of update cabal-installexisting file hashes cabal-installthe root directory cabal-installthe matching glob cabal-installstart time of update cabal-installexisting file hashes cabal-installthe root directory cabal-install2directory we are examining relative to the root cabal-installthe matching glob3 3  B Safe-Inferred  cabal-installA 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  .  cabal-install#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  . cabal-installRun a   IO action.  cabal-installRun a   IO action.  cabal-installRun a   IO action.  cabal-installThe root that relative paths are interpreted as being relative to.  cabal-install-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  .  cabal-install 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 | ... ]  cabal-install Much like  " but for a keyed set of resources. getResource <- delayInitSharedResource mkResource sequence [ rerunIfChanged verbosity monitor key $ do resource <- getResource key ... -- use the resource | ... ]  cabal-installUtility 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.  cabal-installMonitor a directory as in   if it currently exists or as   if it does not.  cabal-installLike  , but in the  . monad. This does NOT track the contents of ; use   in that case.  cabal-installMonitor a single file  cabal-installMonitor 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).  cabal-installLike findFileWithExtension , but in the   monad.  cabal-installLike  findFirstFile , but in the   monad.  cabal-installLike  , but in the   monad.2 2  C Safe-Inferred6O  cabal-install4Detail on the reason that a package failed to build.  cabal-install?Information arising from the failure to build a single package.  cabal-installInformation arising from successfully building a single package.  cabal-installA summary of the outcome for building a single package: either success or failure.  cabal-install>A summary of the outcome for building a whole set of packages.  cabal-installThe dependencies of this package have been (re)built so the build phase needs to be rerun.  cabal-installChanges in files within the package (or first run or corrupt cache)  cabal-installAn 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 L 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.  cabal-installAlthough 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.  cabal-installFor 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.  cabal-installThe package configuration changed, so the configure and build phases needs to be (re)run.  cabal-installThe 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.)  cabal-installThe 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.  cabal-installThe package is in the % state, so does not need building.  cabal-installThe package is in the % state, so does not need building.  cabal-installThe package has not been downloaded yet, so it will have to be downloaded, unpacked and built.  cabal-installThe package has not been unpacked yet, so it will have to be unpacked and built.  cabal-installThe package exists in a local dir already, and just needs building or rebuilding. So this can only happen for BuildInplaceOnly style packages.  cabal-installThe 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.  cabal-installThe   of every package in the ElaboratedInstallPlan.This is used as the result of the dry-run of building an install plan.  cabal-installWhich   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.  cabal-installThis is primarily here for debugging. It's not actually used anywhere.- - (c) David Himmelstrup 2005, Bjorn Bringert 2007 Duncan Coutts 2008BSD-likecabal-devel@gmail.com provisionalportable Safe-Inferred- cabal-install Errors for  . cabal-installA 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.  cabal-install8A 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.  cabal-install-A suggested constraint on the version number.  cabal-install=If we prefer versions of packages that are already installed.  cabal-installIf we would prefer to enable these optional stanzas (i.e. test suites and/or benchmarks)  cabal-installThe 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. cabal-install;Whether to allow base and its dependencies to be installed. cabal-installWhether to only allow explicitly constrained packages plus goals or to allow any package. cabal-installWhether 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. cabal-install;Function to override the solver's goal-ordering heuristics. cabal-installProvide a textual representation of a package preference for debugging purposes. cabal-installSome packages are specific to a given compiler version and should never be upgraded. cabal-installThe 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.Note: the list of non-upgradable/non-installable packages used to be respectively in this module and in . Since they were kept synced, they are now combined in the following list.See:  ,https://github.com/haskell/cabal/issues/8581 and  ,https://github.com/haskell/cabal/issues/9064.  cabal-installRemove 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.  cabal-installDual of   cabal-install"Common internal implementation of  /  cabal-install1Relax the dependencies of this package if needed.Helper function used by  cabal-installInternal helper for   cabal-installSupply 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.  cabal-installIf a package has a custom setup then we need to add a setup-depends on Cabal.  cabal-install Variant of   which sets an upper bound on  setup.Cabal labeled with .  cabal-install4A basic solver policy on which all others are built.  cabal-installThe 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.  cabal-installRun the dependency solver.Since this is potentially an expensive operation, the result is wrapped in a a e structure that can be unfolded to provide progress information, logging messages and the final result or an error. cabal-install%Give an interpretation to the global PackagesPreference as specific per-package  . cabal-installMake 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. cabal-installA 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.  cabal-installA 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.9aecbdflkjihgnm 9 ecbda lkjihgnmf  D Safe-Inferred"  cabal-install%A type that can be converted to JSON.  cabal-install=Convert a Haskell value to a JSON-friendly intermediate type.  cabal-install A JSON "object" (key/value map).  cabal-installA key/value pair for an   cabal-install,A JSON value represented as a Haskell value.  cabal-install,A key-value pair for encoding a JSON object.  cabal-install Create a   from a list of name/value  s.  cabal-install%Serialise value as JSON/UTF8-encoded   cabal-install(Serialise value as JSON-encoded Unicode   cabal-installTry to convert  into  , return - if not representable loss-free as integral  value. cabal-installMinimally escape a  * in accordance with RFC 7159, "7. Strings"  cabal-install$Possibly lossy due to conversion to   cabal-install$Possibly lossy due to conversion to   cabal-install$Possibly lossy due to conversion to    8E Safe-Inferred  cabal-install;Render parse error highlighting the part of the input file.  F(c) Lennart Kolmodin 2008BSD-likekolmodin@haskell.org provisionalportable Safe-Inferred  cabal-installNote: must be called with the CWD set to the directory containing the '.cabal' file.   Safe-Inferred %&'j  cabal-install;A driver for a version control system, e.g. git, darcs etc.  cabal-install*The type of repository this driver is for.  cabal-install.The vcs program itself. This is used at type I and J. cabal-installThe program invocation(s) to get/clone a repository into a fresh local directory. cabal-install8The 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.  cabal-installValidates 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.  cabal-installAs   but for a bunch of  SourceRepo6s, and return things in a convenient form to pass to  , or to report problems.  cabal-installClone 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.  cabal-installSynchronise 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.  cabal-install3The set of all supported VCS drivers, organised by S.  cabal-installVCS driver for Bazaar.  cabal-installVCS driver for Darcs.  cabal-installVCS driver for Git.  cabal-installVCS driver for Mercurial.  cabal-installVCS driver for Subversion.  cabal-install?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.IJS  SIJ G Safe-Inferred  H Safe-InferredT  cabal-installGET 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.  cabal-installPOST a resource to a URI, with optional auth (username, password) and return the HTTP status code and any redirect URL.  cabal-installPOST a file resource to a URI using multipart/form-data encoding, with optional auth (username, password) and return the HTTP status code and any error string.  cabal-installPUT a file resource to a URI, with optional auth (username, password), extra headers and return the HTTP status code and any error string.  cabal-install3Whether this transport supports https or just http.  cabal-installWhether 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. cabal-install%already downloaded and sha256 matches cabal-install#already downloaded and we have etag cabal-install'needs download with optional hash check  cabal-install$Utility function for legacy support.  cabal-installWhat to download cabal-installWhere to put it   Safe-Inferred %&56y  cabal-install"Translate from hackage-security's 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 s 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  . cabal-installInternal generalization of  and s s I Safe-Inferred %&;  cabal-installWrapper around  Repository, hiding the type argument  cabal-installAccess to repositories  cabal-installAll user-specified repositories  cabal-installGet 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.  cabal-install!Get the (initialized) secure repo(the  type itself is stateless and must remain so, because it must be serializable)  cabal-install7Should we ignore expiry times (when checking security)?  cabal-install:Flags that apply at the top level, not to any sub-command.  cabal-installAvailable Hackage servers.  cabal-installIgnore security expiry dates  cabal-installIntegrate with Nix  cabal-installExtra program path used for packagedb lookups in a global context (i.e. for http transports) cabal-install+Initialize the provided secure repositoriesAssumed invariant: # should be set for all these repos. cabal-install 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. cabal-install Secure repo ( assumed) cabal-install Cache dir cabal-installCallback  J(c) David Himmelstrup 2005 Duncan Coutts 2011BSD-likecabal-devel@gmail.com provisionalportable Safe-Inferred%&  cabal-installReturns True if the package has already been fetched or does not need fetching.  cabal-installChecks 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.  cabal-installLike   but for the specific case of a .  cabal-install,Fetch a package if we don't have it already.  cabal-install1Fetch a repo package if we don't have it already.  cabal-install&Downloads an index file to [config-dirpackagesserv-id] without hackage-security. You probably don't want to call this directly; use  updateRepo instead.  cabal-installFork 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  .  cabal-install3Expect 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. cabal-installGenerate the full path to the locally cached copy of the tarball for a given PackageIdentifier. cabal-installGenerate the full path to the directory where the local cached copy of the tarball for a given PackageIdentifier is stored. cabal-install4Generate the URI of the tarball for a given package. K(c) Duncan Coutts 2011BSD-likeduncan@community.haskell.org Safe-Inferred 89:;<  cabal-install Version of n0 that the user can specify on the command line.  cabal-install Version of . that a user may specify on the command line.  cabal-installScope that applies to the package when it has the specified qualifier.  cabal-installScope that applies to the package when it has a setup qualifier.  cabal-installcabal install http://code.haskell.org/~user/foo/foo-0.9.tar.gz  cabal-installGiven 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).  cabal-installGiven a user-specified target, expand it to a bunch of package targets (each of which refers to only one package).  cabal-install2Fetch any remote targets so that they can be read.  cabal-installGiven a package target that has been fetched, read the .cabal file.This only affects targets given by location, named targets are unaffected.  cabal-installUsers are allowed to give package names case-insensitively, so we must disambiguate named package references.  cabal-installReport problems to the user. That is, if there are any problems then raise an exception.  cabal-installGiven 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 .* * L Safe-Inferred6;  cabal-installResolved 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).  cabal-installResolved 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).  cabal-installAvailable Hackage servers.  cabal-installFor all local packages  cabal-installNewtype wrapper for  that provides a  instance that :s values of overlapping keys rather than taking the first.  cabal-installNewtype wrapper for  that provides a  instance that takes the last value rather than the first value for overlapping keys.  cabal-installProject configuration that is specific to each package, that is where we can in principle have different values for different packages in the same project. cabal-installSpecifies the provenance of project configuration, whether defaults were used or if the configuration was read from an explicit file path. cabal-installThe configuration is implicit due to no explicit configuration being found. See n/ for how implicit configuration is determined. cabal-installThe path the project configuration was explicitly read from. | The configuration was explicitly read from the specified . cabal-installProject configuration that is shared between all packages in the project. In particular this includes configuration that affects the solver. cabal-installAvailable Hackage servers. cabal-install9That 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. cabal-install>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. cabal-installPackages 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. cabal-installLike 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. cabal-install9Packages in this project from remote source repositories. cabal-install3Packages in this project from hackage repositories. cabal-installConfiguration to be applied to *all* packages, whether named in `cabal.project` or not. cabal-installConfiguration to be applied to *local* packages; i.e., any packages which are explicitly named in `cabal.project`.   M(c) David Waern 2008BSD-likedavid.waern@gmail.com experimentalportable Safe-Inferred"/ z}{|~ ~z}{|N(c) David Waern 2008BSD-likedavid.waern@gmail.com experimentalportable Safe-InferredO(c) Duncan Coutts 2008BSD-likecabal-devel@haskell.org provisionalportable Safe-Inferred["(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgportable Safe-Inferred)*u" cabal-installConsumes and returns the next character. Fails if there is no input left. cabal-installLook-ahead: returns the part of the input that is left, without consuming it. cabal-install Always fails. cabal-install'Succeeds iff we are at the end of input cabal-installSymmetric choice. cabal-installLocal, exclusive, left-biased choice: If left parser locally produces any result at all, then right parser is not used. cabal-installTransforms 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. cabal-installConsumes and returns the next character, if it satisfies the specified predicate. cabal-install+Parses and returns the specified character. cabal-install(Parses and returns the specified string. cabal-installParses the first zero or more characters satisfying the predicate. cabal-installParses the first one or more characters satisfying the predicate. cabal-install+Combines all parsers in the specified list. cabal-installSkips all whitespace. cabal-installLike  but succeeds only if there is at least one whitespace character to skip. cabal-install count n p  parses n occurrences of p/ in sequence. A list of results is returned. cabal-install between open close p  parses open, followed by p and finally close. Only the value of p is returned. cabal-install option x p will either parse p or return x without consuming any input. cabal-install optional p optionally parses p and always returns (). cabal-install4Parses zero or more occurrences of the given parser. cabal-install3Parses one or more occurrences of the given parser. cabal-installLike , but discards the result. cabal-installLike , but discards the result. cabal-install sepBy p sep$ parses zero or more occurrences of p, separated by sep*. Returns a list of values returned by p. cabal-install sepBy1 p sep# parses one or more occurrences of p, separated by sep*. Returns a list of values returned by p. cabal-install endBy p sep$ parses zero or more occurrences of p, separated and ended by sep. cabal-install endBy p sep# parses one or more occurrences of p, separated and ended by sep. cabal-install 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. cabal-install 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. cabal-installLike (, but parses one or more occurrences of p. cabal-installLike (, but parses one or more occurrences of p. cabal-installmanyTill p end$ parses zero or more occurrences of p, until end3 succeeds. Returns a list of values returned by p. cabal-installConverts 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)]  cabal-installConverts a Haskell ReadS-style function into a parser. Warning: This introduces local backtracking in the resulting parser, and therefore a possible inefficiency.&&55"(c) The University of Glasgow 2004BSD3cabal-devel@haskell.orgportable Safe-InferredS cabal-install A regular  property: value field cabal-installA section with a name and possible parameter. The syntactic structure is:   sectionname  arg {  field* }  cabal-installThe 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). cabal-install!Field descriptor. The parameter a< parameterizes over where the field's value is stored in. cabal-installfieldSet 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. cabal-install'The parser for the stuff between commas2Q"(c) Duncan Coutts 2012, 2015, 2016BSD-likeduncan@community.haskell.org Safe-Inferred %&'8;9 cabal-installThe 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. cabal-installMatches an unknown thing e.g. parses as a package name without it being a specific known package cabal-installMatches a known thing inexactly e.g. matches a known package case insensitively cabal-installExactly matches a known thing, e.g. matches a known package case sensitively cabal-installA 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 . cabal-installSyntax for the : the matcher and renderer cabal-installQualification levels. Given the filepath src/F, executable component A, and package foo: cabal-install src/F cabal-install foo:src F | A:srcF cabal-install  foo:A:src F | exe:A:srcF cabal-install pkg:foo:exe:A:file:src/F cabal-install*The various ways that trying to resolve a  to a  can fail. cabal-install expected thing(actually got) cabal-install  ([in thing., no such thing, actually got, alternatives)] cabal-install2Syntax error when trying to parse a target string. cabal-installbool that flags when it is acceptable to suggest "all" as a target cabal-installThe outline parse of a target selector. It takes one of the forms: 1str1 str1:str2 str1:str2:str3 str1:str2:str3:str4 cabal-installEither the component as a whole or detail about a file or module target within a component. cabal-installThe component as a whole cabal-install%A specific module within a component. cabal-installA specific file within a component. Note that this does not carry the file extension. cabal-install 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. cabal-installA 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 ] cabal-installOne (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. cabal-install/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. cabal-installAll packages, or all components of a particular kind in all packages. cabal-install5A specific component in a package within the project. cabal-installA 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. cabal-install&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). cabal-installParse a bunch of 's (purely without throwing exceptions). cabal-install Render a  back as the external syntax. This is mainly for error messages. cabal-installGiven a bunch of user-specified targets, try to resolve what it is they refer to. cabal-installThrow an exception with a formatted message if there are any problems. cabal-installAll the forms of syntax for . cabal-install3Syntax: "all" to select all packages in the project cabal build all cabal-installSyntax: filter cabal build tests cabal-install#Syntax: package (name, dir or file) 3cabal build foo cabal build ../bar ../bar/bar.cabal cabal-installSyntax: component cabal build foo cabal-installSyntax: module cabal build Data.Foo cabal-installSyntax: file name $cabal build Data/Foo.hs bar/Main.hsc cabal-install Syntax: :all cabal build :all cabal-installSyntax: all : filer cabal build all:tests cabal-installSyntax: package : filer cabal build foo:tests cabal-installSyntax: pkg : package name cabal build pkg:foo cabal-installSyntax: package : component cabal build foo:foo cabal build ./foo:foo cabal build ./foo.cabal:foo cabal-installSyntax: namespace : component cabal build lib:foo exe:foo cabal-installSyntax: package : module cabal build foo:Data.Foo cabal build ./foo:Data.Foo cabal build ./foo.cabal:Data.Foo cabal-installSyntax: component : module cabal build foo:Data.Foo cabal-installSyntax: package : filename cabal build foo:Data/Foo.hs cabal build ./foo:Data/Foo.hs cabal build ./foo.cabal:Data/Foo.hs cabal-installSyntax: component : filename cabal build foo:Data/Foo.hs cabal-installSyntax: :all : filter cabal build :all:tests cabal-installSyntax: :pkg : package name cabal build :pkg:foo cabal-install'Syntax: package : namespace : component cabal build foo:lib:foo cabal build foo/:lib:foo cabal build foo.cabal:lib:foo cabal-install$Syntax: package : component : module cabal build foo:foo:Data.Foo cabal build foo/:foo:Data.Foo cabal build foo.cabal:foo:Data.Foo cabal-install&Syntax: namespace : component : module cabal build lib:foo:Data.Foo cabal-install&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 cabal-install(Syntax: namespace : component : filename cabal build lib:foo:Data/Foo.hs cabal-install.Syntax: :pkg : package : namespace : component cabal build :pkg:foo:lib:foo cabal-installSyntax: :pkg : package : namespace : component : module : module ,cabal build :pkg:foo:lib:foo:module:Data.Foo cabal-installSyntax: :pkg : package : namespace : component : file : filename -cabal build :pkg:foo:lib:foo:file:Data/Foo.hs cabal-installCompare two filepaths for equality using DirActions' canonicalizePath to normalize AND canonicalize filepaths before comparison. cabal-installCombine 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. cabal-install)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. cabal-install)Lift a list of matches to an exact match. cabal-install)Lift a list of matches to an exact match. cabal-installGiven 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. cabal-install6A primitive matcher that looks up a value in a finite  . The value must match exactly. cabal-install6A 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). cabal-installMake a L given an  and knowing the . We also need the  to distinguish the package's primary library from named private libraries. cabal-installThis 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)883R Safe-Inferred:0(c) David Himmelstrup 2005BSD-likelemmih@gmail.com provisionalportable Safe-Inferred %&;A*  cabal-install9Is this a candidate package or a package to be published? cabal-installInstall takes the same flags as configure along with a few extras. cabal-installcabal configure takes some extra flags beyond runghc Setup configure cabal-install 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-install'Get the package database settings from ?, accounting for  --package-db and --user flags. cabal-install>Configure the compiler, but reduce verbosity during this step. cabal-install 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-install!List of lines describing command get. cabal-installNotes for the command get. cabal-installEither "get" or "unpack". cabal-installE.g. "cabal". cabal-installList of lines.?>=<;:9876543210/.-,+*)('&%$#"!  HGFEDCBA@  ?>=<;:9876543210/.-,+*)('&%$#"!  HGFEDCBA@S Safe-InferredE  T(c) Maciek Makowski 2015BSD-likecabal-devel@haskell.org provisionalportable Safe-InferredG cabal-installpath, description cabal-install=A list of files that should be documented in the manual page. cabal-installProduces a manual page with troff markup.U(c) Duncan Coutts 2008BSD-likecabal-devel@haskell.org provisionalportable Safe-Inferred;S cabal-install0The file doesn't exist so we can make a symlink. cabal-installA symlink already exists, though it is ours. We'll have to delete it first before we make a new symlink. cabal-installA 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). cabal-installWe 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. cabal-installSymlink binary.The paths are take in pieces, so we can make relative link when possible. cabal-installCheck 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). cabal-installTake two canonical paths and produce a relative path to get from the first to the second, even if it means adding .. path components. cabal-install/Try to make a symlink in a temporary directory.6If this works, we can try to symlink: even on Windows. cabal-install+Whether to force overwrite an existing file cabal-install/The canonical path of the public bin dir eg homeuser/bin cabal-install0The canonical path of the private bin dir eg homeuser.cabalbin cabal-install>The name of the executable to go in the public bin dir, eg foo cabal-installs, still maintaining the lazy nature of the original tar read. cabal-install 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. cabal-install/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  cabal-installDoes the given filename match with the expected name of 'preferred-versions'? cabal-install=Parse `preferred-versions` file, ignoring any parse failures.To obtain parse errors, use . cabal-installParse `preferred-versions` file, collecting parse errors that can be shown in error messages. cabal-install 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. cabal-installA lazy unfolder for lookup operations which return the current value and (possibly) the next key cabal-installReturn  if ' uses 01-index format (aka secure repo) cabal-install4Read 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. cabal-installRead 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. cabal-install Read the  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 dies if it fails again). cabal-install Read the  cache from the filesystem without attempting to regenerate on parsing failures. cabal-install Write the  cache to the filesystem cabal-install Write the  IndexState to the filesystem cabal-installRead out the "current" index timestamp, i.e., what timestamp you would use to revert to this version cabal-install Read the  IndexState from the filesystem cabal-install(Optimise sharing of equal values inside c.f. *https://en.wikipedia.org/wiki/Hash_consing cabal-install)We need to save only .cabal file contents$$V(c) David Himmelstrup 2005 Duncan Coutts 2008-2011BSD-likecabal-devel@haskell.org Safe-Inferredy~ cabal-installCovers source dependencies and installed dependencies in one type. cabal-installThe info that we can display for each package. It is information per package name and covers all installed and available versions. cabal-install8Return a list of packages matching given search strings. cabal-install Show information about packages. cabal-install We get the  by combining the info for the installed and available versions of a package.We're building info about a various versions of a single named package so the input package info records are all supposed to refer to the same package name. cabal-installNot all the info is pure. We have to check if the docs really are installed, because the registered package info lies. Similarly we have to check if the tarball has indeed been fetched. cabal-installRearrange installed and source packages into groups referring to the same package by name. In the result pairs, the lists are guaranteed to not both be empty. cabal-installReorder a bunch of versions to put the most interesting / significant versions first. A preferred version range is taken into account.This may be used in a user interface to select a small number of versions to present to the user, e.g. =let selectVersions = sort . take 5 . interestingVersions prefW(c) Brent Yorgey 2009BSD-likecabal-devel@haskell.org provisionalportable Safe-Inferredz= cabal-install,This is the main driver for the init script.X(c) Andrea Vezzosi 2008 Duncan Coutts 2011 John Millikin 2012BSD-likecabal-devel@haskell.org provisionalportable Safe-Inferred~c cabal-install(Entry point for the 'cabal get' command. cabal-installWrite a  pkgId.cabal file with the package description to the destination directory, unless one already exists. cabal-installGiven a bunch of package ids and their corresponding available  SourceRepos, pick a single  SourceRepo for each one and clone into new subdirs of the given directory. cabal-install Pick the  SourceRepo( to use to get the package sources from.Note that this does not depend on what   drivers we are able to successfully configure. It is based only on the  SourceRepo:s declared in the package, and optionally on a preferred . cabal-installdestination dir prefix cabal-install preferred  cabal-install"the packages and their available  SourceRepos  Y Safe-Inferred~ cabal-install0Fetch a list of packages and their dependencies.Z Safe-Inferred)[ Safe-Inferred cabal-installto view as a FieldDescr, we sort the list of interfaces (Req > Bool > Choice > Opt) and consider only the first one.Pcabal-devel@haskell.orgportable Safe-Inferred' cabal-install FieldGrammar section description cabal-installThe description of a section in a config file. It can contain both fields and optionally further subsections. See also . cabal-installGiven a collection of field descriptions, keep only a given list of them, identified by name. cabal-installApply a name mangling function to the field names of all the field descriptions. The typical use case is to apply some prefix. cabal-installReuse a command line  as a config file . cabal-installReuse a bunch of command line s as config file s. cabal-installTo 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. cabal-installParse 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 . cabal-installThis is a customised version of the functions from Distribution.Deprecated.ParseUtils that also optionally print default values for empty fields as comments. cabal-installPretty print a section.Since  does not cover subsections you can use this to add them. Or alternatively use a  and use . cabal-install Much like  but it also allows subsections. The permitted subsections are given by a list of s. cabal-install 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. cabal-installUnlike 6 which has to be called directly, this gets used via % and so does not need to be exported. cabal-install2TODO: subsections TODO: this should simply build  PrettyField cabal-installParse 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. cabal-installRender a value in the config file syntax, based on a description of the configuration file in terms of its fields and sections. cabal-installfield cabal-installlegacy sections cabal-installFieldGrammar sections cabal-install section name cabal-install parameter!!\(c) David Himmelstrup 2005BSD-likelemmih@gmail.com provisionalportable Safe-Inferred;9 cabal-installProvenance of the config file. cabal-installThese 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. cabal-installThis 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. cabal-installIssue a warning if both $XDG_CONFIG_HOMEcabalconfig and ~/.cabal exists. cabal-installIf  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. cabal-installThe 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. cabal-install)The default prefix used for installation. cabal-installThe current hackage.haskell.org repo root keys that we ship with cabal. cabal-installThe required threshold of root key signatures for hackage.haskell.org cabal-installLoads the main configuration, and applies additional defaults to give the effective configuration. To loads just what is actually in the config file, use . cabal-installLike  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. cabal-installReturns the config file path, without checking that the file exists. The order of precedence is: input flag, CABAL_CONFIG, default location. cabal-installThese 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. cabal-installAll config file fields. cabal-install'Fields for the 'install-dirs' sections. cabal-installFields for the haddock section. cabal-installFields for the  section. cabal-install+Fields for the 'program-locations' section. cabal-install1Fields for the 'program-default-options' section. cabal-installGet 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. cabal-installUpdate the user's config file keeping the user's customizations.++] Safe-Inferred^(c) The University of Glasgow 2006, Duncan Coutts 2008cabal-devel@haskell.orgalphaportable Safe-Inferred" cabal-installA  SetupRunner implements a . cabal-installSetupScriptOptions' are options used to configure and run ?, as opposed to options given to the Cabal command at runtime. cabal-install,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 . cabal-installThis 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. cabal-install;Extra things to add to PATH when invoking the setup script. cabal-install8Extra environment variables paired with overrides, where v0 means "set the environment variable's value to v".( means "unset the environment variable". cabal-install3List of dependencies to use when building Setup.hs. cabal-install,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. cabal-installShould 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. cabal-installIs 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 task cabal-install SetupMethod: represents one of the methods used to run Cabal commands. cabal-install:run Cabal commands through "cabal" in the current process cabal-install6run Cabal commands through "cabal" as a child process cabal-install6run Cabal commands through a custom "Setup" executable cabal-installSetup encapsulates the outcome of configuring a setup method to build a particular package. cabal-install,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 . cabal-installDecide 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. cabal-installRun a configured  with specific arguments. cabal-installThis 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. cabal-install#Run a command through a configured . cabal-install Configure a  and run a command in one step. The command flags may depend on the Cabal library version in use. cabal-installcommand-line arguments cabal-installcommand definition cabal-install command flags cabal-installextra command-line arguments cabal-install5produce command flags given the Cabal library version_(c) David Himmelstrup 2005, Duncan Coutts 2005BSD-likecabal-devel@haskell.orgportable Safe-Inferred  cabal-installChoose 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. cabal-install2Configure the package found in the local directory cabal-installWarn if any constraints or preferences name packages that are not in the source package index or installed package index. cabal-installMake an  InstallPlan for the unpacked package in the current directory, and all its dependencies. cabal-installCall 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. cabal-installRead saved configure flags and restore the saved environment from the specified files. cabal-installThe path (relative to  --build-dir) where the arguments to  configure should be saved. cabal-installRead saved configure flags and restore the saved environment from the usual location. cabal-installSave the configure flags and environment to the specified files. cabal-install+Save the build flags to the usual location. cabal-installpath to saved flags file cabal-install  --build-dir cabal-installpath to saved flags file cabal-install  --build-dir  `cabal-devel@haskell.orgportable Safe-Inferred;M  cabal-installAccumulator type for  parseSections. cabal-install(Type of the current package environment. cabal-install'./cabal.config' cabal-install'~.config cabal/config' cabal-installOptional package environment file that can be used to customize the default settings. Created by the user. cabal-install Is there a 'cabal.config' in this directory? cabal-installLoad 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. cabal-installSame as userPackageEnvironmentFile, but returns a SavedConfig. cabal-install;Descriptions of all fields in the package environment file. cabal-install"Read the package environment file. cabal-install#Parse the package environment file. cabal-install%Pretty-print the package environment. cabal-installPretty-print the package environment with default values for empty fields commented out (just like the default Cabal config file).  acabal-devel@haskell.orgportable Safe-Inferred cabal-installCheck which type of package environment we're in and return a correctly-initialised  SavedConfig and a  UseSandbox: value that indicates whether we're working in a sandbox. cabal-install7Return the saved "dist/" prefix, or the default prefix. cabal-install 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. cabal-install8Directory to change to before starting the installation. cabal-installFile to log output to (if any)g(c) David Himmelstrup 2005 Duncan Coutts 2011BSD-likecabal-devel@gmail.com provisionalportable Safe-Inferred cabal-installFreeze all of the dependencies by writing a constraints section constraining each dependency to an exact version. cabal-install?Get the list of packages whose versions would be frozen by the freeze command. cabal-install2Remove all unneeded packages from an install plan.%A package is unneeded if it is either'1) the package that we are freezing, or2) not a dependency (directly or transitively) of the package we are freezing. This is useful for removing previously installed packages which are no longer required from the install plan. Invariant:  pkgSpecifiers' must refer to packages which are not  PreExisting in the .h(c) Doug Beardsley 2015BSD-likecabal-devel@gmail.com provisionalportable Safe-Inferredq cabal-installGiven a version, return an API-compatible (according to PVP) version range. Example: 0.4.1.2 produces the version range >= 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. cabal-install:Show the PVP-mandated version range for this package. The padTo; parameter specifies the width of the package name column. cabal-installEntry point for the  gen-bounds command. cabal-installThe message printed when some dependencies are found to be lacking proper PVP-mandated bounds.i Safe-Inferred%&@ cabal-install4Information about the root directory of the project.It can either be an implicit project root in the current dir if no  cabal.project9 file is found, or an explicit root if the file is found. cabal-install- ^ An implicit project root. It contains the absolute project root dir. cabal-install- ^ An explicit project root. It contains the absolute project root dir and the relative  cabal.project file (or explicit override) cabal-install9The 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. cabal-install&The layout of a cabal nix-style store. cabal-installThe layout of the project state directory. Traditionally this has been called the dist directory. cabal-installThe root directory of the project. Many other files are relative to this location. In particular, the  cabal.project lives here. cabal-installThe  cabal.project file and related like cabal.project.freeze. The parameter is for the extension, like "freeze", or "" for the main file. cabal-installThe "dist" directory, which is the root of where cabal keeps all its state including the build artifacts from each package we build. cabal-installThe 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). cabal-installThe directory under dist where we download tarballs and source control repos to. cabal-installThe 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. cabal-installThe location for project-wide cache files (e.g. state used in incremental rebuilds). cabal-installThe location for package-specific cache files (e.g. state used in incremental rebuilds). cabal-install/The location that sdists are placed by default. cabal-installInformation 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. cabal-installMake the default  based on the project root dir and optional overrides for the location of the dist directory and the  cabal.project file. cabal-installthe project root cabal-installthe dist9 directory or default (absolute or relative to the root) cabal-install!Store directory. Must be absolute cabal-install Log directory00j Safe-Inferred%&'? cabal-installThe 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. cabal-installCheck if a particular  exists in the store. cabal-install Return the =s of all packages/components already installed in the store. cabal-installPlace 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). cabal-installAction to place files. cabal-installRegister action, if necessary.k Safe-Inferred'6;t7 cabal-install1There 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. cabal-installSpecific targets within a package or component to act on e.g. to build, haddock or open a repl. cabal-installThis is used in the install plan to indicate how the package will be built. cabal-installThe 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. cabal-installThe 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. cabal-install/The exact dependencies (on other plan packages) cabal-installComponents 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 cabal-install$Dependencies on executable packages. cabal-install)Paths where executable dependencies live. cabal-installDependencies 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. cabal-installWhich optional stanzas (ie testsuites, benchmarks) will actually be enabled during the package configure step. cabal-install(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.) cabal-install=The name of the component to be built according to the solver cabal-installThe name of the component to be built. Nothing if it's a setup dep. cabal-installThe *external* library dependencies of this component. We pass this to the configure script. cabal-installIn 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. cabal-installThe executable dependencies of this component (including internal executables). cabal-installThe  pkg-config dependencies of the component cabal-installThe paths all our executable dependencies will be installed to once they are installed. cabal-installThe 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. cabal-installThe 4 which uniquely identifies this item in a build plan cabal-installThis 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. cabal-installThe  of the originating package cabal-install-Shape of the package/component, for Backpack. cabal-installA total flag assignment for the package. TODO: Actually this can be per-component if we drop all flags that don't affect a component. cabal-install>The original default flag assignment, used only for reporting. cabal-installWhere 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. cabal-installThe hash of the source, e.g. the tarball. We don't have this for local source dir packages. cabal-installIs this package one of the ones specified by location in the project file? (As opposed to a dependency, or a named package pulled in) cabal-installAre we going to build and install this package to the store, or are we going to build it and register it locally. cabal-installAnother way of phrasing pkgStanzasAvailable. cabal-installWhich 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. cabal-installWhich 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.) cabal-installOne 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. cabal-installThe 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. cabal-install&Component/package specific information cabal-installThe programs that the compiler configured (e.g. for GHC, the progs ghc & ghc-pkg). Once constructed, only the configuredPrograms are used. cabal-install6The 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). cabal-install$User-friendly display string for an . cabal-install The packagecomponent contains&is a library and so must be registered cabal-installConstruct the environment needed for the data files to work. This consists of a separate  *_datadir0 variable for each inplace package in the plan. cabal-installConstruct 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). cabal-install"A user-friendly descriptor for an . cabal-installThe 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. cabal-installLike ., but only returns dependencies on libraries. cabal-installThe 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. cabal-installLike , but only returns dependencies on executables. (This coincides with .) cabal-installThe 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. cabal-installThis 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.) cabal-installThe 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.) cabal-installThe 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. cabal-installSee . cabal-installSee . cabal-installSee . This gives the unflattened version, which can be useful in some circumstances. cabal-installUnambiguously render a ), e.g., to pass to a Cabal Setup script.l Safe-Inferred,m Safe-Inferred %&'6;/ cabal-installPackages 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. cabal-installPackages 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 . cabal-installPackages 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). cabal-installPackages 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). cabal-installPackages 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 . cabal-installA 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 . cabal-installAs 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). cabal-installAs 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). cabal-installAs 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. cabal-install:Write out a representation of the elaborated install plan.This is for the benefit of debugging and external tools like editors. cabal-installRenders a subset of the elaborated install plan in a semi-stable JSON format. cabal-installWork out which packages are out of date or invalid after a build. cabal-install"Helper for reading the cache file.=This determines the type and format of the binary cache file. cabal-install5Helper for writing the package up-to-date cache file.=This determines the type and format of the binary cache file. cabal-installPrepare a package environment 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.n Safe-Inferred %&'6;J & cabal-installWhen looking for a package's .cabal file we can find none, or several, both of which are failures. cabal-install(Errors reported upon failing to parse a .cabal file. cabal-installException thrown by . cabal-installThe 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. cabal-installErrors returned by . cabal-install 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. cabal-installUse a   based on the  . cabal-installUse 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   cabal-installResolve the project configuration, with all its optional fields, into  0 with no optional fields (by applying defaults). cabal-installResolve the project configuration, with all its optional fields, into  0 with no optional fields (by applying defaults). cabal-installFind the root of this project.Searches for an explicit  cabal.project file, in the current directory or parent directories. If no project file is found then the current dir is the project root (and the project will use an implicit config). cabal-installRead all the config relevant for a project. This includes the project file if any, plus other global config. cabal-installReads an explicit  cabal.project file in the given project root dir, or returns the default project config for an implicitly defined project. cabal-installReads 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. cabal-installReads 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. cabal-installReads a named extended (with imports and conditionals) config file in the given project root dir, or returns empty. cabal-install Render the  format.For the moment this is implemented in terms of a pretty printer for the legacy configuration types, plus a conversion. cabal-installWrite a cabal.project.local$ file in the given project root dir. cabal-installWrite a cabal.project.freeze$ file in the given project root dir. cabal-install Write in the  cabal.project format to the given file. cabal-install*Read the user's cabal-install config file. cabal-installRender 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. cabal-installGiven the project config,Throws . cabal-install2A 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. cabal-install 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. cabal-install A helper for  to handle the case of  and . We simply read the .cabal file. cabal-install A helper for  to handle the case of . We scan through the .tar.gz file to find the .cabal file and read that. cabal-install 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. cabal-install A helper for  to handle all the cases of . cabal-install#Utility used by all the helpers of  to make an appropriate  ( (..)), for a given package from a given location. cabal-installWrapper for the .cabal file parser. It reports warnings on higher verbosity levels and throws  on failure. cabal-install Find the .cabal3 file within a tarball file and return it by value.Can fail with a  or  exception. cabal-install/Scan through a tar file stream and collect the .cabal file, or fail. cabal-install6The 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. cabal-install5The 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. cabal-installTruncate a string, with a visual indication that it is truncated. cabal-installThe 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  cabal-install)Manual instance which skips file contents cabal-install.cabal file path cabal-install.cabal file contents cabal-installerrors cabal-install4We might discover the spec version the package needs cabal-installwarnings cabal-install(starting directory, or current directory cabal-install cabal.project file name override cabal-install verbosity cabal-install --cabal-config cabal-install with global cabal-install verbosity cabal-install7whether to ignore local project (--ignore-project flag) cabal-install --cabal-config cabal-install with project cabal-installwithout project cabal-install --ignore-project cabal-installThe package directory cabal-install The package .cabal file     o Safe-Inferred %&'(68u(, cabal-installIt 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. cabal-installThis 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. cabal-installHow # should interpret the per-package %s: as build, repl or haddock targets. cabal-installThis 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. cabal-installTo be built by default cabal-installNot to be built by default cabal-installThe 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. cabal-installWhen the user does  tests: False cabal-install&When the solver could not enable tests cabal-installWhen the component has buildable: False cabal-install5When the component is non-core in a non-local package cabal-install!The target can or should be built cabal-installAn 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. cabal-installA 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. cabal-installCheck that an " actually makes sense under some . cabal-installReturn the up-to-date project config and information about the local packages within the project. cabal-install-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. cabal-installIf a 7 refers to a single package, return Just that package. cabal-installSelect the bits of a $ to monitor for value changes. Use  for the files to monitor. cabal-installSelect the config values to monitor for changes package source hashes. cabal-installGet 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. cabal-installAppend the given package databases to an existing PackageDBStack. A Nothing' entry will clear everything before it. cabal-installProduce 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 cabal-installGiven a , report if it matches a L. cabal-installGet the appropriate L* which identifies an installed component. cabal-installGiven a , report if it matches a L. cabal-install Given an , generate the mapping from  and L to the # that should be used in this case. cabal-install Given an , generate the mapping from 6 to the shape of this package, as per mix-in linking. cabal-installGet 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. cabal-install+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. cabal-installMerge 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. cabal-installThe 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). cabal-installGiven 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). cabal-installSet the build targets based on the user targets (but not rev deps yet). This is required before we can prune anything. cabal-installAssuming 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. cabal-install*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. cabal-install6Try to remove the given targets from the install plan.This is not always possible. cabal-install Work out the  given the package description. cabal-installPart 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 the solver 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-installWork 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-install2To be used for the input for elaborateInstallPlan.>TODO: [code cleanup] make InstallDirs.defaultInstallDirs pure. cabal-install Given the ( for a nix-style package store, and an , replace configured source packages by installed packages from the store whenever they exist. cabal-installThe 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. cabal-installThe path to the build directory for an inplace build. cabal-install '(improvedPlan, elaboratedPlan, _, _, _)p Safe-Inferred8y cabal-installType alias for a & with no user-defined problems/errors.=Can use the utilities below for reporting/rendering problems. cabal-install8Target problems that occur during project orchestration. cabal-installThe  matches component (test benchmark...) but none are buildable cabal-installThere are no targets at all cabal-installA custom target problemq Safe-Inferred%&'  cabal-installA tag used in rendering messages to distinguish singular or plural. cabal-install8Used to render a singular or plural version of something 0plural (listPlural theThings) "it is" "they are" cabal-install2Singular for singleton lists and plural otherwise. cabal-install%Render a list of things in the style foo, bar and baz cabal-install%Render a list of things in the style #blah blah; this that; and the other cabal-installWhen 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 ] cabal-installThe optional stanza type (test suite or benchmark), if it is one. cabal-install Does the * potentially refer to one package or many? cabal-install Does the $ refer to packages or to components? cabal-installDefault implementation of % simply renders one problem per line. cabal-installDefault implementation of . cabal-installSeveral commands have a TargetProblemNoneEnabled problem constructor. This renders an error message for those cases. cabal-installSeveral commands have a TargetProblemNoTargets problem constructor. This renders an error message for those cases. cabal-installverb cabal-installhow to render custom problems++r Safe-Inferred %&'/  cabal-install"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). cabal-installAs 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 . cabal-install/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. cabal-install=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. cabal-installHelper function for ,  and .It selects the info from a  that are used by the   s (in the ) to detect value changes. cabal-installDo all the checks on whether a package has changed and thus needs either rebuilding or reconfiguring and rebuilding. cabal-installBuild things for real.It requires the   gathered by . cabal-installCreate a package DB if it does not currently exist. Note that this action is not safe to run concurrently. cabal-installGiven all the context and resources, (re)build an individual package. cabal-installGiven 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. cabal-installCheck if a package needs downloading, and if so expect to find a download in progress in the given   and wait on it to finish. cabal-installEnsure that the package is unpacked in an appropriate directory, either a temporary one or a persistent one under the shared dist directory. cabal-installThis 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./ /   Safe-Inferred %&'Z cabal-install>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. cabal-installThis holds the context between the pre-build, build and post-build phases. cabal-installThis 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. cabal-install 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. cabal-installThe 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. cabal-installThe result of the dry-run phase. This tells us about each member of the . cabal-installThe targets selected by selectPlanSubset. This is useful eg. in CmdRun, where we need a valid target to execute. cabal-installThis holds the context of a project prior to solving: the content of the  cabal.project and all the local package .cabal files. cabal-installTracks what command is being executed, because we need to hide this somewhere for cases that need special handling (usually for error reporting). cabal-installLike % but doesn't search for project root. cabal-install#Pre-build phase: decide what to do. cabal-installBuild phase: now do it.Execute all or parts of the description of what to do to build or rebuild the various packages needed. cabal-install.Post-build phase: various administrative tasksUpdate bits of state based on the build outcomes and report any failures. cabal-installGet all target selectors. cabal-install Get all unique target selectors. cabal-installGiven 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. cabal-installA 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 cabal-installWrapper around 2 that adjusts for the extra unneeded info in the . cabal-installUtility used by repl and run to check if the targets spans multiple components, since those commands do not support multiple components. cabal-installPrint a user-oriented presentation of the install plan, indicating what will be built. cabal-installIf there are build failures then report them and throw an exception. cabal-installCreate a dummy project context, without a .cabal or a .cabal.project file (a place where to put a temporary dist directory is still needed) cabal-install;Project configuration including the global config if needed cabal-installWhere to put the dist directory cabal-install*The packages to be included in the projectLRQPONM  LRQPONMRQPOs Safe-Inferred"%&' cabal-install4Information about the context in which we found the s. cabal-install+The target selectors are part of a project. cabal-install1The target selectors are from the global context. cabal-installThe target selectors refer to a script. Contains the path to the script and the executable metadata parsed from the script cabal-install6What your command should do when no targets are found. cabal-installdie on  cabal-installreturn a default  cabal-install)Get the hash of a script's absolute path)Two hashes will be the same as long as the absolute paths are the same. cabal-install-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. cabal-installGet 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. cabal-installDetermine 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. cabal-installAdd the 2 to the context and use it to write a .cabal file. cabal-installAdd add the executable metadata to the context and write a .cabal file. cabal-installExtract the first encountered executable metadata block started and terminated by the below tokens or die.  {- cabal: -}Return the metadata. cabal-installExtract the first encountered project metadata block started and terminated by the below tokens.  {- project: -}Return the metadata. cabal-installExtract 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. cabal-installThe base for making a ! for a fake project. It needs a  or  depending on the command. cabal-installFind the path of an exe that has been relocated with a "-o" option cabal-installA lens for the  field of  cabal-install6What your command should do when no targets are found. cabal-installA target filter cabal-installCommand line flags cabal-install$Target strings or a script and args. cabal-install Global flags. cabal-install.Current Command (usually for error reporting). cabal-install The body of your command action.t Safe-Inferred %&'(Uu Safe-Inferred%& cabal-install=The various error conditions that can occur when matching a  against  s for the test command. cabal-installThe # matches targets but no test-suites cabal-installThe / refers to a component that is not a test-suite cabal-install command we just need the basic checks on being buildable etc.y Safe-Inferred%& cabal-install=The various error conditions that can occur when matching a  against  s for the bench command. cabal-installThe " matches targets but no benchmarks cabal-installThe . refers to a component that is not a benchmark cabal-installAsking to benchmark an individual file or module is not supported cabal-installThe 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.ProjectOrchestration cabal-installThis 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. cabal-installFor 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.z Safe-Inferred "%&'({ Safe-Inferred"%&'M cabal-install=The various error conditions that can occur when matching a  against  s for the repl command. cabal-install Multiple s match multiple targets cabal-installThe repl 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 repl target and then executes the plan. Compared to build the difference is that only one target is allowed (given or implicit) and the target type is repl rather than build. The general plan execution infrastructure handles both build and repl targets.4For more details on how this works, see the module (Distribution.Client.ProjectOrchestration cabal-installAdd 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.  cabal-install=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 cabal-installThis 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. cabal-installFor a  *, check if the component can be selected.For the repl> command we just need the basic checks on being buildable etc.| Safe-Inferred"%&' cabal-install=The various error conditions that can occur when matching a  against  s for the run command. cabal-installThe # matches targets but no executables cabal-install A single  matches multiple targets cabal-install Multiple s match multiple targets cabal-installThe 0 refers to a component that is not an executable cabal-install;Asking to run an individual file or module is not supported cabal-installThis 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. cabal-installFor 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. Safe-Inferred%} Safe-Inferred%&' cabal-installTo 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 cabal-installGiven the install plan, produce a config value with constraints that freezes the versions of packages used in the plan. cabal-installGiven the install plan, produce solver constraints that will ensure the solver picks the same solution again in future in different environments.~cabal-devel@haskell.orgportable Safe-Inferred%& cabal-installExecute 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. Safe-Inferred%& cabal-installTo 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.ProjectOrchestrationcabal-devel@haskell.orgportable Safe-Inferred%&'S  cabal-install/Various knobs for customising the behaviour of . cabal-installShould this package be ignored? cabal-install7Should major version bumps be ignored for this package? cabal-installEntry point for the outdated command. cabal-installPrint either the list of all outdated dependencies, or a message that there are none. cabal-installConvert a list of  s to a  list. cabal-install3Read the list of dependencies from the freeze file. cabal-install=Read the list of dependencies from the new-style freeze file. cabal-install;Read the list of dependencies from the package description. cabal-installFind all outdated dependencies. Safe-Inferred%&'" cabal-installThe 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.ProjectOrchestration cabal-installTreat all direct targets of install command as local packages: #8637 cabal-installVerify that invalid config options were not passed to the install command.6If an invalid configuration is found the command will die'. cabal-installPartitions the target selectors into known local targets and hackage packages. cabal-installInstall any built exe by symlinking/copying it we don't use BuildOutcomes because we also need the component names cabal-installInstall any built library by adding it to the default ghc environment cabal-installReturn the package specifiers and non-global environment file entries. cabal-installDisables tests and benchmarks if they weren't explicitly enabled. cabal-installSymlink/copy every exe from a package from the store to a given location cabal-installInstall a specific exe. cabal-installCreate &s for packages with exposed libraries. cabal-install3Gets the file path to the request environment file. cabal-installReturns the list of GhcEnvFilePackageIj values already existing in the environment being operated on. cabal-install7Constructs the path to the global GHC environment file.2TODO(m-renaud): Create PkgEnvName newtype wrapper. cabal-install4Constructs the path to a local GHC environment file. cabal-installThis 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 cabal-installFor a  *, check if the component can be selected.For the build> command we just need the basic checks on being buildable etc. cabal-installThe synthetic base context to use to produce the full build context. cabal-installEnvironment file cabal-install#Whether to overwrite existing files cabal-install0A function to get an UnitId's ^ store directory cabal-install&A function to get an ^ exe's filename cabal-installA function to get an ^ exe's final possibly ^ different to the name in the store. cabal-install,The directory where the built exe is located cabal-installThe exe's filename cabal-install2The exe's filename in the public install directory cabal-install*the directory where it should be installed cabal-install'Whether the installation was successful Safe-Inferred%&g(c) David Himmelstrup 2005BSD-likelemmih@gmail.com provisionalportable Safe-Inferredu cabal-install Entry point cabal-installCheck whether assertions are enabled and print a warning in that case. cabal-installActually do the work of building the package. This is separate from  so that  and  do not invoke  twice. cabal-installMake sure that we don't pass new flags to setup scripts compiled against old versions of Cabal. cabal-installReturn the names of all buildable components matching a given predicate. cabal-installUsed as an entry point when cabal-install needs to invoke itself as a setup script. This can happen e.g. when doing parallel builds.         !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""""""""""""""""""""""""""#################$$$$$$$$$$$$$$$$$$%%%%%%&&&&&&&&&&&&&'''''''''''''(((((((((((((((()))))))))))************++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,--------------------------------------.....................////////////////000000000111111111111122222222222                             3333333333333333333333333333333333333333333333333333333333333444444444444444444444444444444444444444444444444445566777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 77 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 8 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 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 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 B B B BB B B B B B B B B B B B B C CCCCCC C CC CCCC C CCC C C CCC C C C C C C C C C C C C C C C C C CCC 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 D D D D D D D D E F                       G H H H H H H H H H H H H H H H H H H H H I I I I I I I I I I I I I I I I I I I I I I I I I I I I I J J J J J J J J J J K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K L L L L L L L L L L L L L L L L L L L L LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMNNNNOOQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRSSSSSSSSSSSSTTUUUUUVVWXXXXXXXXXXXXXYZZZ[PPPPPPPPPPPPPPPPPPPPPPPPPPP\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]^^^^^^^^^^^^^^^^^^^^^^^^^^_________```````````````aaaabbbbbbbbbbbbbbbbcccccccccccccccccccccccccccddddeeeeeefffffffgghiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkklmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooopppppppppppppppppqqqqqqqqqqqqqqqqqqqqqqqqrrrsssssssssssssssssssstttttuuuuuuuuuvvvvvvvvvvwwwwwwwxxxxxxxxyyyyyyyyyzzzzzzzz{{{{{{{{||||||||||}}~~  ,0      344444888;<@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB                DDHHH  IIIJJ JKK QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQTTUUUUUVVVVVVVXXPP\\\\\\\\\^^^^^^^^^__````cccccccfffffffghhhkkkkmmmmmnnnnnnnnnnnnnnnnnnooooooooooooooooooooooooorrrrrrrrrrrrrsssuuuuuvvvvvvvyyyy{{{{||||||}}~,cabal-install-3.10.2.1-65TuIanu7V1TeNXBEsQf0(Distribution.Client.ProjectOrchestration"Distribution.Client.Compat.PreludeDistribution.Client.UtilsDistribution.Deprecated.ReadPDistribution.Client.IndexUtils%Distribution.Client.CmdHaddockProjectDistribution.Client.SetupDistribution.Client.VCSDistribution.Client.Init.Utils%Distribution.Client.SolverInstallPlanDistribution.Client.Dependency$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.GlobDistribution.Client.HaddockDistribution.Client.HashValue(Distribution.Client.IndexUtils.Timestamp!Distribution.Client.Init.LicensesDistribution.Client.JobControl 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.InstallPlanDistribution.Client.SrcDistDistribution.Client.RunDistribution.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.RebuildMonad)Distribution.Client.ProjectBuilding.TypesDistribution.Client.Utils.Json Distribution.Client.Utils.ParsecDistribution.Client.CheckDistribution.Client.VersionDistribution.Client.HttpUtilsDistribution.Client.GlobalFlagsDistribution.Client.FetchUtilsDistribution.Client.Targets'Distribution.Client.ProjectConfig.Types*Distribution.Client.BuildReports.Anonymous(Distribution.Client.BuildReports.Storage$Distribution.Client.Win32SelfUpgradeDistribution.Client.ParseUtils"Distribution.Client.TargetSelector:Distribution.Client.CmdInstall.ClientInstallTargetSelector#Distribution.Client.NixStyleOptionsDistribution.Client.Manpage"Distribution.Client.InstallSymlinkDistribution.Client.ListDistribution.Client.InitDistribution.Client.GetDistribution.Client.Fetch'Distribution.Client.BuildReports.Upload(Distribution.Deprecated.ViewAsFieldDescrDistribution.Client.ConfigDistribution.Client.Upload Distribution.Client.SetupWrapperDistribution.Client.Configure.Distribution.Client.Sandbox.PackageEnvironmentDistribution.Client.SandboxDistribution.Client.CmdLegacy(Distribution.Client.ProjectConfig.LegacyDistribution.Client.NixDistribution.Client.ReconfigureDistribution.Client.InstallDistribution.Client.FreezeDistribution.Client.GenBounds!Distribution.Client.DistDirLayoutDistribution.Client.Store)Distribution.Client.ProjectPlanning.TypesDistribution.Client.SourceFiles%Distribution.Client.ProjectPlanOutput!Distribution.Client.ProjectConfig#Distribution.Client.ProjectPlanning!Distribution.Client.TargetProblem$Distribution.Client.CmdErrorMessages#Distribution.Client.ProjectBuildingDistribution.Client.ScriptUtilsDistribution.Client.CmdUpdateDistribution.Client.CmdTestDistribution.Client.CmdRunDistribution.Client.CmdHaddockDistribution.Client.CmdBuildDistribution.Client.CmdBenchDistribution.Client.CmdSdistDistribution.Client.CmdReplDistribution.Client.CmdListBinDistribution.Client.CmdFreezeDistribution.Client.CmdExec Distribution.Client.CmdConfigureDistribution.Client.CmdOutdatedDistribution.Client.CmdInstallDistribution.Client.CmdCleanDistribution.Client.MainDistribution.Types.SourceRepo SourceRepoSourcePackageDbpackagePreferencesDistribution.Client.Types PackageIndexdependencyCyclesbrokenPackagesdependencyInconsistencies InstallPlan PreExisting InstalledDistribution.Solver.ModularSolverreadProjectConfig"Distribution.Deprecated.ParseUtilsDistribution.ClientInitDistribution.Types.LibraryLibrary+Cabal-syntax-3.10.2.0-IMknsbS72h3ZjM7pQqM9nDistribution.Types.PackageId PackageIdDistribution.Pretty prettyShowbase Text.Read readMaybeText.ParserCombinators.ReadPReadS%Cabal-3.10.2.1-GyzoJJgKHqN4rPN6ewqdAHDistribution.Simple.Configure getInstalledPackagesMonitorFilesDistribution.Simple.SetuphaddockProjectCommand!configAllowDependingOnPrivateLibsconfigUseResponseFilesconfigDumpBuildInfoconfigDebugInfoconfigRelocatableconfigFlagErrorconfigExactConfigurationconfigLibCoverageconfigCoverageconfigBenchmarks configTestsconfigConfigurationsFlagsconfigInstantiateWithconfigDependenciesconfigConstraintsconfigStripLibsconfigStripExesconfigSplitObjsconfigSplitSections configGHCiLibconfigPackageDBsconfigUserInstallconfigVerbosityconfigCabalFilePathconfigDistPrefconfigDeterministic configCID configIPIDconfigExtraIncludeDirsconfigExtraFrameworkDirsconfigExtraLibDirsStaticconfigExtraLibDirsconfigScratchDirconfigInstallDirsconfigProgSuffixconfigProgPrefixconfigOptimizationconfigConfigureArgsconfigProfLibDetailconfigProfDetail configProf configProfExeconfigFullyStaticExe configDynExeconfigStaticLibconfigSharedLib configProfLibconfigVanillaLib configHcPkg configHcPathconfigHcFlavorconfigProgramPathExtraconfigProgramArgsconfigProgramPathsconfigPrograms_ configArgs ConfigFlagsbuildCabalFilePath buildArgs buildNumJobsbuildVerbosity buildDistPrefbuildProgramArgsbuildProgramPaths BuildFlags!Distribution.Simple.Program.TypesProgramConfiguredProgramDistribution.Verbosity Verbosity Distribution.Types.ComponentName ComponentNameCLibName CNotLibName CBenchName CTestNameCExeName CFLibNameRepoTypeDistribution.ParsecexplicitEitherParsec eitherParsec simpleParsecparsecParsec CabalParsingprettyVersionedprettyPrettyDistribution.Utils.Stringtrim4cabal-install-solver-3.10.2.1-GnF3uB9dEL2KuhzkWzaRPT)Distribution.Solver.Types.ResolverPackage ConfiguredResolverPackage"Distribution.Solver.Types.Progress foldProgressDoneFailStepProgress+Distribution.Solver.Types.PackageConstraint scopeToplevelPackagePropertyStanzasPackagePropertyFlagsPackagePropertySourcePackagePropertyInstalledPackagePropertyVersionPackagePropertyPackageConstraint(directory-1.3.7.1-5opj6QQ4DFqGFOHgd4OGISSystem.DirectorysetModificationTimegetSymbolicLinkTargetpathIsSymbolicLinkcreateFileLink/hackage-security-0.6.2.3-AwTIWwlEtNOExk8RpBOEn5*Hackage.Security.Client.Repository.HttpLibHttpLibgetExecutablePath$fStructuredSomeException$fBinarySomeException$fBinaryURIAuth$fStructuredURI $fBinaryURIOutcomeNotTriedFailedOkInstallOutcomePlanningFailedDependencyFailedDownloadFailed UnpackFailed SetupFailedConfigureFailed BuildFailed TestsFailed InstallFailed InstallOk BuildReportpackageosarchcompilerclientflagAssignment dependenciesinstallOutcome docsOutcome testsOutcome ReportLevel NoReportsAnonymousReportsDetailedReports$fParsecReportLevel$fPrettyReportLevel$fStructuredReportLevel$fBinaryReportLevel$fParsecInstallOutcome$fPrettyInstallOutcome$fParsecOutcome$fPrettyOutcome$fEqBuildReport$fShowBuildReport$fGenericBuildReport $fEqOutcome $fShowOutcome $fEnumOutcome$fBoundedOutcome$fGenericOutcome$fEqInstallOutcome$fShowInstallOutcome$fGenericInstallOutcome$fEqReportLevel$fOrdReportLevel$fEnumReportLevel$fBoundedReportLevel$fShowReportLevel$fGenericReportLevelQSemnewQSemwaitQSem signalQSem$fEqQSemPackagesPreferenceDefaultPreferAllLatestPreferAllOldestPreferAllInstalledPreferLatestForSelectedModular PreSolver AlwaysModular$fParsecPreSolver$fPrettyPreSolver$fStructuredPreSolver$fBinaryPreSolver$fStructuredSolver$fBinarySolver$fShowPackagesPreferenceDefault $fEqSolver $fOrdSolver $fShowSolver$fBoundedSolver $fEnumSolver$fGenericSolver $fEqPreSolver$fOrdPreSolver$fShowPreSolver$fBoundedPreSolver$fEnumPreSolver$fGenericPreSolvermaybeDecompress FilePathRootFilePathRelativeFilePathHomeDir GlobPieceWildCardLiteralUnionGlobFilePathGlobRelGlobDirGlobFileGlobDirTrailing FilePathGlobisTrivialFilePathGlobgetFilePathRootDirectory matchFileGlobmatchFileGlobRel matchGlob$fStructuredGlobPiece$fBinaryGlobPiece$fParsecFilePathGlobRel$fPrettyFilePathGlobRel$fStructuredFilePathGlobRel$fBinaryFilePathGlobRel$fParsecFilePathRoot$fPrettyFilePathRoot$fStructuredFilePathRoot$fBinaryFilePathRoot$fParsecFilePathGlob$fPrettyFilePathGlob$fStructuredFilePathGlob$fBinaryFilePathGlob$fEqFilePathGlob$fShowFilePathGlob$fGenericFilePathGlob$fEqFilePathRoot$fShowFilePathRoot$fGenericFilePathRoot$fEqFilePathGlobRel$fShowFilePathGlobRel$fGenericFilePathGlobRel $fEqGlobPiece$fShowGlobPiece$fGenericGlobPieceregenerateHaddockIndex HashValue hashValue showHashValueshowHashValueBase64readFileHashValue hashFromTUF truncateHash$fStructuredHashValue$fBinaryHashValue $fEqHashValue$fGenericHashValue$fShowHashValue TimestampepochTimeToTimestamptimestampToUTCTimeutcTimeToTimestampmaximumTimestamp nullTimestamp$fParsecTimestamp$fPrettyTimestamp$fStructuredTimestamp$fBinaryTimestamp $fEqTimestamp$fOrdTimestamp$fEnumTimestamp$fNFDataTimestamp$fShowTimestamp$fGenericTimestampLicensebsd2bsd3gplv2gplv3agplv3lgpl21lgpl3apache20mitmpl20iscLockJobLimit JobControlspawnJob collectJob remainingJobs cancelJobsnewSerialJobControlnewParallelJobControl newJobLimit withJobLimitnewLockcriticalSection ManpageFlagsmanpageVerbosity manpageRawdefaultManpageFlagsmanpageOptions$fSemigroupManpageFlags$fMonoidManpageFlags$fEqManpageFlags$fShowManpageFlags$fGenericManpageFlags ProjectFlagsflagProjectFileNameflagIgnoreProjectdefaultProjectFlagsprojectFlagsOptionsremoveIgnoreProjectOption$fSemigroupProjectFlags$fMonoidProjectFlags$fShowProjectFlags$fGenericProjectFlagswriteSavedArgswriteCommandFlags readSavedArgsreadCommandFlags$fExceptionSavedArgsError$fShowSavedArgsErrorqueryBootstrapMirrors TerminatedinstallTerminationHandler$fShowTerminated$fExceptionTerminatedcreateTarGzFileextractTarGzFilebuildTreeRefTypeCodebuildTreeSnapshotTypeCodeisBuildTreeRefTypeCode filterEntriesfilterEntriesM entriesToList$fExceptionEitherRelaxDepSubjectRelaxDepSubjectAllRelaxDepSubjectPkg RelaxDepModRelaxDepModNoneRelaxDepModCaret RelaxDepScopeRelaxDepScopeAllRelaxDepScopePackageRelaxDepScopePackageId RelaxedDep RelaxDeps RelaxDepsSome RelaxDepsAll AllowOlder unAllowOlder AllowNewer unAllowNewer isRelaxDepsmkRelaxDepSome$fStructuredRelaxDepScope$fBinaryRelaxDepScope$fStructuredRelaxDepMod$fBinaryRelaxDepMod$fStructuredRelaxDepSubject$fBinaryRelaxDepSubject$fParsecRelaxDepSubject$fPrettyRelaxDepSubject$fStructuredRelaxedDep$fBinaryRelaxedDep$fParsecRelaxedDep$fPrettyRelaxedDep$fMonoidRelaxDeps$fSemigroupRelaxDeps$fStructuredRelaxDeps$fBinaryRelaxDeps$fParsecRelaxDeps$fPrettyRelaxDeps$fMonoidAllowOlder$fSemigroupAllowOlder$fStructuredAllowOlder$fBinaryAllowOlder$fMonoidAllowNewer$fSemigroupAllowNewer$fStructuredAllowNewer$fBinaryAllowNewer$fEqAllowNewer$fReadAllowNewer$fShowAllowNewer$fGenericAllowNewer$fEqAllowOlder$fReadAllowOlder$fShowAllowOlder$fGenericAllowOlder $fEqRelaxDeps$fReadRelaxDeps$fShowRelaxDeps$fGenericRelaxDeps$fEqRelaxedDep$fReadRelaxedDep$fShowRelaxedDep$fGenericRelaxedDep$fEqRelaxDepSubject$fOrdRelaxDepSubject$fReadRelaxDepSubject$fShowRelaxDepSubject$fGenericRelaxDepSubject$fEqRelaxDepMod$fReadRelaxDepMod$fShowRelaxDepMod$fGenericRelaxDepMod$fEqRelaxDepScope$fReadRelaxDepScope$fShowRelaxDepScope$fGenericRelaxDepScope TestsResult TestsNotTriedTestsOk DocsResult DocsNotTried DocsFailedDocsOk BuildResult BuildFailureDependentFailed BuildOutcomes BuildOutcome$fStructuredBuildFailure$fBinaryBuildFailure$fExceptionBuildFailure$fStructuredDocsResult$fBinaryDocsResult$fStructuredTestsResult$fBinaryTestsResult$fStructuredBuildResult$fBinaryBuildResult$fShowBuildResult$fGenericBuildResult$fShowTestsResult$fGenericTestsResult$fShowDocsResult$fGenericDocsResult$fShowBuildFailure$fGenericBuildFailureHasConfiguredId configuredId ConfiguredId confSrcId confCompName confInstIdInstalledPackageIdannotatedIdToConfiguredId$fPackageConfiguredId$fShowConfiguredId$fStructuredConfiguredId$fBinaryConfiguredId%$fHasConfiguredIdInstalledPackageInfo$fEqConfiguredId$fOrdConfiguredId$fGenericConfiguredIdConfiguredPackage confPkgId confPkgSource confPkgFlagsconfPkgStanzas confPkgDeps#$fPackageInstalledConfiguredPackage$fHasUnitIdConfiguredPackage%$fHasMungedPackageIdConfiguredPackage$fPackageConfiguredPackage$fBinaryConfiguredPackage$fIsNodeConfiguredPackage#$fPackageFixedDepsConfiguredPackage"$fHasConfiguredIdConfiguredPackage$fEqConfiguredPackage$fShowConfiguredPackage$fGenericConfiguredPackagePassword unPasswordUsername unUsername InstallMethodInstallMethodCopyInstallMethodSymlink$fPrettyInstallMethod$fParsecInstallMethod$fSemigroupInstallMethod$fStructuredInstallMethod$fBinaryInstallMethod$fEqInstallMethod$fShowInstallMethod$fGenericInstallMethod$fBoundedInstallMethod$fEnumInstallMethodOverwritePolicyNeverOverwriteAlwaysOverwritePromptOverwrite$fPrettyOverwritePolicy$fParsecOverwritePolicy$fStructuredOverwritePolicy$fBinaryOverwritePolicy$fShowOverwritePolicy$fEqOverwritePolicy$fGenericOverwritePolicy$fBoundedOverwritePolicy$fEnumOverwritePolicyClientInstallFlagscinstInstallLibscinstEnvironmentPathcinstOverwritePolicycinstInstallMethodcinstInstalldirdefaultClientInstallFlagsclientInstallOptions$fStructuredClientInstallFlags$fBinaryClientInstallFlags$fSemigroupClientInstallFlags$fMonoidClientInstallFlags$fEqClientInstallFlags$fShowClientInstallFlags$fGenericClientInstallFlagsPackageSpecifier NamedPackageSpecificSourcePackagepkgSpecifierTargetpkgSpecifierConstraints$fStructuredPackageSpecifier$fBinaryPackageSpecifier$fEqPackageSpecifier$fShowPackageSpecifier$fFunctorPackageSpecifier$fGenericPackageSpecifierRepoName unRepoName$fParsecRepoName$fPrettyRepoName$fNFDataRepoName$fStructuredRepoName$fBinaryRepoName$fShowRepoName $fEqRepoName $fOrdRepoName$fGenericRepoNameRepoRepoLocalNoIndex RepoRemote RepoSecure repoLocal repoLocalDir repoRemote LocalRepo localRepoName localRepoPathlocalRepoSharedCache RemoteReporemoteRepoName remoteRepoURIremoteRepoSecureremoteRepoRootKeysremoteRepoKeyThresholdremoteRepoShouldTryHttpsemptyRemoteRepoemptyLocalRepolocalRepoCacheKey isRepoRemotemaybeRepoRemoterepoName$fParsecRemoteRepo$fPrettyRemoteRepo$fStructuredRemoteRepo$fBinaryRemoteRepo$fPrettyLocalRepo$fParsecLocalRepo$fStructuredLocalRepo$fBinaryLocalRepo$fStructuredRepo $fBinaryRepo $fShowRepo$fEqRepo $fOrdRepo $fGenericRepo$fShowLocalRepo $fEqLocalRepo$fOrdLocalRepo$fGenericLocalRepo$fShowRemoteRepo$fEqRemoteRepo$fOrdRemoteRepo$fGenericRemoteRepoRepoIndexStateIndexStateHeadIndexStateTimeTotalIndexStateheadTotalIndexStatemakeTotalIndexStatelookupIndexStateinsertIndexState$fParsecRepoIndexState$fPrettyRepoIndexState$fNFDataRepoIndexState$fStructuredRepoIndexState$fBinaryRepoIndexState$fParsecTotalIndexState$fPrettyTotalIndexState$fNFDataTotalIndexState$fStructuredTotalIndexState$fBinaryTotalIndexState$fEqTotalIndexState$fShowTotalIndexState$fGenericTotalIndexState$fEqRepoIndexState$fGenericRepoIndexState$fShowRepoIndexStateCombineStrategyCombineStrategySkipCombineStrategyMergeCombineStrategyOverrideActiveRepoEntryActiveRepoRest ActiveRepo ActiveReposdefaultActiveReposfilterSkippedActiveReposorganizeByRepos$fParsecCombineStrategy$fPrettyCombineStrategy$fNFDataCombineStrategy$fStructuredCombineStrategy$fBinaryCombineStrategy$fParsecActiveRepoEntry$fPrettyActiveRepoEntry$fNFDataActiveRepoEntry$fStructuredActiveRepoEntry$fBinaryActiveRepoEntry$fParsecActiveRepos$fPrettyActiveRepos$fNFDataActiveRepos$fStructuredActiveRepos$fBinaryActiveRepos$fEqActiveRepos$fShowActiveRepos$fGenericActiveRepos$fEqActiveRepoEntry$fShowActiveRepoEntry$fGenericActiveRepoEntry$fEqCombineStrategy$fShowCombineStrategy$fEnumCombineStrategy$fBoundedCombineStrategy$fGenericCombineStrategySourceRepoProxySourceRepoMaybeSourceRepoListSourceRepositoryPackagesrpType srpLocationsrpTag srpBranch srpSubdir srpCommandsrpHoist srpToProxy srpFanOutsourceRepositoryPackageGrammar $fGenericSourceRepositoryPackage#$fStructuredSourceRepositoryPackage$fBinarySourceRepositoryPackage$fShowSourceRepositoryPackage$fOrdSourceRepositoryPackage$fEqSourceRepositoryPackageUnresolvedSourcePackagePackageLocationLocalUnpackedPackageLocalTarballPackageRemoteTarballPackageRepoTarballPackageRemoteSourceRepoPackageResolvedPkgLocUnresolvedPkgLoc$fStructuredPackageLocation$fBinaryPackageLocation$fShowPackageLocation$fFunctorPackageLocation$fEqPackageLocation$fOrdPackageLocation$fGenericPackageLocation packageIndexlookupDependencylookupPackageName$fBinarySourcePackageDb$fEqSourcePackageDb$fGenericSourcePackageDb ReadyPackageGenericReadyPackage$fIsNodeGenericReadyPackage$fEqGenericReadyPackage$fShowGenericReadyPackage$fGenericGenericReadyPackage$fPackageGenericReadyPackage%$fPackageFixedDepsGenericReadyPackage'$fHasMungedPackageIdGenericReadyPackage$fHasUnitIdGenericReadyPackage%$fPackageInstalledGenericReadyPackage$fBinaryGenericReadyPackageWriteGhcEnvironmentFilesPolicyAlwaysWriteGhcEnvironmentFilesNeverWriteGhcEnvironmentFiles-WriteGhcEnvironmentFilesOnlyForGhc844AndNewer*$fStructuredWriteGhcEnvironmentFilesPolicy&$fBinaryWriteGhcEnvironmentFilesPolicy"$fEqWriteGhcEnvironmentFilesPolicy$$fEnumWriteGhcEnvironmentFilesPolicy'$fBoundedWriteGhcEnvironmentFilesPolicy'$fGenericWriteGhcEnvironmentFilesPolicy$$fShowWriteGhcEnvironmentFilesPolicySolverPlanProblemPackageMissingDeps PackageCyclePackageInconsistencyPackageStateInvalidSolverInstallPlan planIndexplanIndepGoalsSolverPlanPackage showPlanIndexshowInstallPlannewtoListtoMapremovevalidshowPlanProblemproblemsacyclicclosed consistentdependencyClosurereverseDependencyClosuretopologicalOrderreverseTopologicalOrder$fStructuredSolverInstallPlan$fBinarySolverInstallPlan$fGenericSolverInstallPlanPackageHashConfigInputspkgHashCompilerIdpkgHashPlatformpkgHashFlagAssignmentpkgHashConfigureScriptArgspkgHashVanillaLibpkgHashSharedLib pkgHashDynExepkgHashFullyStaticExepkgHashGHCiLibpkgHashProfLibpkgHashProfExepkgHashProfLibDetailpkgHashProfExeDetailpkgHashCoveragepkgHashOptimizationpkgHashSplitObjspkgHashSplitSectionspkgHashStripLibspkgHashStripExespkgHashDebugInfopkgHashProgramArgspkgHashExtraLibDirspkgHashExtraLibDirsStaticpkgHashExtraFrameworkDirspkgHashExtraIncludeDirspkgHashProgPrefixpkgHashProgSuffixpkgHashPackageDbspkgHashDocumentationpkgHashHaddockHooglepkgHashHaddockHtmlpkgHashHaddockHtmlLocationpkgHashHaddockForeignLibspkgHashHaddockExecutablespkgHashHaddockTestSuitespkgHashHaddockBenchmarkspkgHashHaddockInternalpkgHashHaddockCsspkgHashHaddockLinkedSourcepkgHashHaddockQuickJumppkgHashHaddockContentspkgHashHaddockIndexpkgHashHaddockBaseUrlpkgHashHaddockLibPackageSourceHashPackageHashInputs pkgHashPkgIdpkgHashComponentpkgHashSourceHashpkgHashPkgConfigDepspkgHashDirectDepspkgHashOtherConfighashedInstalledPackageIdhashedInstalledPackageIdLonghashedInstalledPackageIdShorthashPackageHashInputsrenderPackageHashInputs$fShowPackageHashConfigInputs ProcessingGenericInstallPlan PlanPackageIsUnitGenericPlanPackagefoldPlanPackagedepends showPlanGraphtoGraphkeyskeysSet installedlookup directDeps revDirectDepsfromSolverInstallPlan!fromSolverInstallPlanWithProgressconfigureInstallPlanready completedfailedexecutionOrderlookupBuildOutcomeexecute#$fHasConfiguredIdGenericPlanPackage$fHasUnitIdGenericPlanPackage&$fHasMungedPackageIdGenericPlanPackage$fPackageGenericPlanPackage$fStructuredGenericPlanPackage$fBinaryGenericPlanPackage$fIsNodeGenericPlanPackage$fBinaryGenericInstallPlan$fStructuredGenericInstallPlan$fEqGenericPlanPackage$fShowGenericPlanPackage$fGenericGenericPlanPackage ProgressPhaseProgressDownloadingProgressDownloadedProgressStartingProgressBuildingProgressHaddockProgressInstallingProgressCompleted MergeResult OnlyInLeftInBoth OnlyInRightmergeBy duplicates duplicatesByremoveExistingFilewithTempFileNameinDirwithEnvwithEnvOverrideswithExtraPathEnv logDirChangenumberOfProcessorsdetermineNumJobsmakeAbsoluteToCwdmakeRelativeToCwdmakeRelativeToDirmakeRelativeCanonicalfilePathToByteStringbyteStringToFilePathtryCanonicalizePathcanonicalizePathNoThrowmoreRecentFileexistsAndIsMoreRecentThanrelaxEncodingErrorstryFindAddSourcePackageDesctryFindPackageDescfindOpenProgramLocationprogressMessagepvpize incVersiongetCurrentYearlistFilesInsidelistFilesRecursivesafeReadhasElemallPackageSourceFilespackageDirToSdist splitRunArgsrunFieldAnnotationannCommentedOutannCommentLines DefaultPromptOptionalPromptMandatoryPromptIsSimple IsLiterateSeverityLogInfoWarningErrorBreakException InteractivegetLinereadFilegetCurrentDirectorygetHomeDirectorygetDirectoryContents listDirectorydoesDirectoryExist doesFileExistreadProcessWithExitCodegetEnvironmentputStrputStrLncreateDirectoryremoveDirectory writeFilecopyFilerenameDirectoryhFlushmessagebreak throwPrompt PurePrompt _runPrompt HsFilePath _hsFilePath _hsFileType HsFileTypeLiterateStandard InvalidHsPath PackageType ExecutableLibraryAndExecutable TestSuiteProjectSettings_pkgOpts_pkgDesc _pkgLibTarget _pkgExeTarget_pkgTestTarget WriteOpts _optOverwrite _optMinimal_optNoComments _optVerbosity _optPkgDir _optPkgType _optPkgName _optCabalSpec TestTarget _testMainIs _testDirs _testLanguage_testOtherModules_testOtherExts_testDependencies_testBuildTools ExeTarget _exeMainIs_exeApplicationDirs _exeLanguage_exeOtherModules _exeOtherExts_exeDependencies_exeBuildTools LibTarget_libSourceDirs _libLanguage_libExposedModules_libOtherModules _libOtherExts_libDependencies_libBuildToolsPkgDescription_pkgCabalVersion_pkgName _pkgVersion _pkgLicense _pkgAuthor _pkgEmail _pkgHomePage _pkgSynopsis _pkgCategory_pkgExtraSrcFiles_pkgExtraDocFiles InitFlags interactivequiet packageDir noCommentsminimal simpleProject packageNameversion cabalVersionlicenseauthoremailhomepagesynopsiscategoryextraSrcextraDoc packageTypemainIslanguageexposedModules otherModules otherExtsapplicationDirs sourceDirs buildToolsinitializeTestSuitetestDirs initHcPath initVerbosity overwritefromHsFilePath isHsFilePath toHsFilePath toLiterateHs toStandardHs mkLiterate evalPrompt$fSemigroupInitFlags$fMonoidInitFlags$fShowHsFilePath$fExceptionBreakException$fMonadPurePrompt$fApplicativePurePrompt$fInteractivePurePrompt$fInteractiveIO$fEqDefaultPrompt$fFunctorDefaultPrompt $fEqSeverity$fShowSeverity$fFunctorPurePrompt$fEqBreakException$fShowBreakException$fEqProjectSettings$fShowProjectSettings$fShowExeTarget $fEqExeTarget$fShowTestTarget$fEqTestTarget$fEqHsFilePath$fEqHsFileType$fShowHsFileType $fEqInitFlags$fShowInitFlags$fGenericInitFlags $fEqWriteOpts$fShowWriteOpts$fEqPackageType$fShowPackageType$fGenericPackageType$fShowLibTarget $fEqLibTarget$fShowPkgDescription$fEqPkgDescription promptStr promptYesNoprompt promptListfieldfieldDcommentedOutWithComments withComments annNoCommentspostProcessFieldLinesmkCommonStanza mkLibStanza mkExeStanza mkTestStanzamkPkgDescription listFieldSdefaultVersiondefaultApplicationDirdefaultSourceDirdefaultTestDirdefaultCabalVersiondefaultPackageTypedefaultChangelogdefaultLicense defaultMainIsdefaultLanguagedefaultLicenseIdsdefaultCategoriesdefaultCabalVersionsdefaultInitFlags myLibModule myLibTestFile myLibFilemyLibHsmyExeHs myLibExeHsmyTestHsSourceFileEntryrelativeSourcePath moduleName fileExtensionimports extensionsisMain isHaskellretrieveBuildToolsretrieveSourceFilesretrieveModuleNameretrieveModuleImportsretrieveModuleExtensions isSourceFileretrieveDependenciesfilePathToPkgNamecurrentDirPkgNamemkPackageNameDep fixupDocFiles mkStringyDep getBaseDepaddLibDepToTestaddLibDepToExe$fShowSourceFileEntry getPackageDirgetSimpleProject getMinimalgetCabalVersiongetCabalVersionNoPromptgetPackageName getVersion getLicense getAuthorgetEmail getHomepage getSynopsis getCategorygetExtraSrcFilesgetExtraDocFilesgetPackageType getMainFilegetInitializeTestSuite getTestDirs getLanguage getNoComments getAppDirs getSrcDirsgetExposedModulesgetOtherModules getBuildToolsgetDependencies getOtherExts getOverwritesimpleProjectPromptinitializeTestSuitePromptpackageTypePrompttestMainPromptdependenciesPrompt createProjectgenSimplePkgDescgenSimpleLibTargetgenSimpleExeTargetgenSimpleTestTarget guessMainFileguessCabalSpecVersion guessLanguageguessPackageName guessLicenseguessExtraDocFilesguessPackageTypeguessApplicationDirectoriesguessSourceDirectoriesguessAuthorNameguessAuthorEmailgenPkgDescription genLibTarget genExeTarget genTestTargetminimalHeuristicsoverwriteHeuristicscabalVersionHeuristicspackageNameHeuristicsversionHeuristicslicenseHeuristicsauthorHeuristicsemailHeuristicshomepageHeuristicssynopsisHeuristicscategoryHeuristicsextraDocFileHeuristicspackageTypeHeuristicsmainFileHeuristicsinitializeTestSuiteHeuristicstestDirsHeuristicslanguageHeuristicsnoCommentsHeuristicsappDirsHeuristicssrcDirsHeuristicsexposedModulesHeuristicslibOtherModulesHeuristicsexeOtherModulesHeuristicstestOtherModulesHeuristicsbuildToolsHeuristicsdependenciesHeuristicsotherExtsHeuristicscabalVersionPromptpackageNamePrompt versionPrompt licensePrompt authorPrompt emailPrompthomepagePromptsynopsisPromptcategoryPromptmainFilePrompttestDirsPromptlanguagePromptnoCommentsPrompt appDirsPrompt srcDirsPrompt writeProjectprepareLibTargetprepareExeTargetprepareTestTarget writeLicensewriteChangeLog$fShowWriteAction$fEqWriteActionMonitorTimestampMonitorChangedReasonMonitoredFileChangedMonitoredValueChangedMonitorFirstRunMonitorCorruptCacheMonitorChangedMonitorUnchanged FileMonitorfileMonitorCacheFilefileMonitorKeyValid"fileMonitorCheckIfOnlyValueChangedMonitorStateGlobMonitorStateFileMonitorStateFileSetMonitorKindDir DirExists DirModTime DirNotExistsMonitorKindFile FileExists FileModTime FileHashed FileNotExistsMonitorFilePath MonitorFileMonitorFileGlobmonitorKindFilemonitorKindDir monitorPathmonitorPathGlob monitorFilemonitorFileHashedmonitorNonExistentFilemonitorFileExistencemonitorDirectorymonitorNonExistentDirectorymonitorDirectoryExistencemonitorFileOrDirectorymonitorFileGlobmonitorFileGlobExistencemonitorFileSearchPathmonitorFileHashedSearchPathnewFileMonitorcheckFileMonitorChangedupdateFileMonitorbeginUpdateFileMonitor$fStructuredMonitorKindFile$fBinaryMonitorKindFile$fStructuredMonitorKindDir$fBinaryMonitorKindDir$fStructuredMonitorFilePath$fBinaryMonitorFilePath"$fStructuredMonitorStateFileStatus$fBinaryMonitorStateFileStatus$fStructuredMonitorStateFile$fBinaryMonitorStateFile$fStructuredMonitorStateGlobRel$fBinaryMonitorStateGlobRel$fStructuredMonitorStateGlob$fBinaryMonitorStateGlob$fStructuredMonitorStateFileSet$fBinaryMonitorStateFileSet$fFunctorChangedM$fApplicativeChangedM$fMonadChangedM$fMonadIOChangedM$fShowMonitorChanged$fEqMonitorChangedReason$fShowMonitorChangedReason$fFunctorMonitorChangedReason$fShowMonitorStateFileSet$fGenericMonitorStateFileSet$fShowMonitorStateGlob$fGenericMonitorStateGlob$fShowMonitorStateGlobRel$fGenericMonitorStateGlobRel$fShowMonitorStateFile$fGenericMonitorStateFile$fShowMonitorStateFileStatus$fGenericMonitorStateFileStatus$fEqMonitorFilePath$fShowMonitorFilePath$fGenericMonitorFilePath$fEqMonitorKindDir$fShowMonitorKindDir$fGenericMonitorKindDir$fEqMonitorKindFile$fShowMonitorKindFile$fGenericMonitorKindFileRebuild monitorFiles runRebuild execRebuildaskRootrerunIfChangeddelayInitSharedResourcedelayInitSharedResourcesgetDirectoryContentsMonitoredcreateDirectoryMonitoredmonitorDirectoryStatusdoesFileExistMonitoredneed needIfExistsfindFileWithExtensionMonitoredfindFirstFileMonitoredfindFileMonitored$fFunctorRebuild$fApplicativeRebuild$fMonadRebuild$fMonadIORebuildBuildFailureReason ReplFailedHaddocksFailed BenchFailedbuildFailureLogFilebuildFailureReasonbuildResultDocsbuildResultTestsbuildResultLogFile BuildReasonBuildReasonDepsRebuiltBuildReasonFilesChangedBuildReasonExtraTargetsBuildReasonEphemeralTargetsBuildStatusRebuildBuildStatusConfigureBuildStatusBuild BuildStatusBuildStatusPreExistingBuildStatusInstalledBuildStatusDownloadBuildStatusUnpackBuildStatusUpToDateBuildStatusMapbuildStatusRequiresBuildbuildStatusToString$fShowBuildFailureReasonPackagePreferencePackageVersionPreferencePackageInstalledPreferencePackageStanzasPreferenceDepResolverParamsaddConstraintsaddPreferencessetPreferenceDefaultsetReorderGoalssetCountConflictssetFineGrainedConflictssetMinimizeConflictSetsetIndependentGoalssetAvoidReinstalls setShadowPkgssetStrongFlagssetAllowBootLibInstallssetOnlyConstrainedsetMaxBackjumpssetEnableBackjumpingsetSolveExecutables setGoalOrdersetSolverVerbosityremoveUpperBoundsremoveLowerBoundsaddDefaultSetupDependencies!addSetupCabalMinVersionConstraint!addSetupCabalMaxVersionConstraintupgradeDependenciesreinstallTargetsbasicInstallPolicystandardInstallPolicy chooseSolverresolveDependenciesresolveWithoutDependencies$fShowResolveNoDepsErrorToJSONtoJSONObjectPairValueArrayStringNumberBoolNull.=objectencodeToBuilderencodeToString$fIsStringValue$fToJSONInteger$fToJSONWord64 $fToJSONInt64$fToJSONWord32$fToJSONWord16 $fToJSONWord8 $fToJSONWord $fToJSONInt32 $fToJSONInt16 $fToJSONInt8 $fToJSONInt$fToJSONDouble $fToJSONFloat $fToJSON(,,,) $fToJSON(,,) $fToJSON(,) $fToJSONMaybe $fToJSON[] $fToJSONBool $fToJSONValue $fToJSON() $fEqValue $fReadValue $fShowValuerenderParseErrorcheckSourceRepoProblemSourceRepoRepoTypeUnspecifiedSourceRepoRepoTypeUnsupportedSourceRepoLocationUnspecifiedVCS vcsRepoType vcsProgramvalidateSourceRepovalidatePDSourceRepovalidateSourceRepos configureVCS configureVCSscloneSourceReposyncSourceRepos knownVCSsvcsBzrvcsDarcsvcsGitvcsHgvcsSvnvcsPijul$fShowSourceRepoProblemcabalInstallVersionHttpCode HttpTransportgetHttppostHttp postHttpFile putHttpFiletransportSupportsHttpstransportManuallySelectedDownloadResultFileAlreadyInCacheFileDownloaded downloadURIremoteRepoCheckHttpstransportCheckHttpsremoteRepoTryUpgradeToHttpsisOldHackageURIconfigureTransport$fEqDownloadCheck$fEqDownloadResulttransportAdapter$fExceptionUnexpectedResponse$fPrettyUnexpectedResponse$fShowUnexpectedResponse RepoContextrepoContextReposrepoContextGetTransportrepoContextWithSecureReporepoContextIgnoreExpiry GlobalFlags globalVersionglobalNumericVersionglobalConfigFileglobalConstraintsFileglobalRemoteReposglobalCacheDirglobalLocalNoIndexReposglobalActiveRepos globalLogsDirglobalIgnoreExpiryglobalHttpTransport globalNixglobalStoreDirglobalProgPathExtradefaultGlobalFlagswithRepoContextwithRepoContext'$fSemigroupGlobalFlags$fMonoidGlobalFlags$fShowGlobalFlags$fGenericGlobalFlags AsyncFetchMap isFetched checkFetchedcheckRepoTarballFetchedverifyFetchedTarball fetchPackagefetchRepoTarball downloadIndexasyncFetchPackageswaitAsyncFetchPackageUserConstraintUserConstraintScope UserQualifiedUserAnySetupQualifierUserAnyQualifier UserQualifierUserQualToplevel UserQualSetup UserQualExePackageTargetProblemPackageNameUnknownPackageNameAmbiguous PackageTargetPackageTargetNamedPackageTargetNamedFuzzyPackageTargetLocationUserTargetProblemUserTargetUnexpectedFileUserTargetNonexistantFileUserTargetUnexpectedUriSchemeUserTargetUnrecognisedUriUserTargetUnrecognised UserTargetUserTargetNamedUserTargetLocalDirUserTargetLocalCabalFileUserTargetLocalTarballUserTargetRemoteTarballreadUserTargetsreadUserTargetreportUserTargetProblemsresolveUserTargetsexpandUserTargetfetchPackageTargetreadPackageTargetdisambiguatePackageTargetsreportPackageTargetProblemsdisambiguatePackageNameuserConstraintPackageNameuserToPackageConstraintreadUserConstraint$fSemigroupPackageNameEnv$fMonoidPackageNameEnv$fStructuredUserQualifier$fBinaryUserQualifier$fStructuredUserConstraintScope$fBinaryUserConstraintScope$fParsecUserConstraint$fPrettyUserConstraint$fStructuredUserConstraint$fBinaryUserConstraint$fEqUserConstraint$fShowUserConstraint$fGenericUserConstraint$fEqUserConstraintScope$fShowUserConstraintScope$fGenericUserConstraintScope$fEqUserQualifier$fShowUserQualifier$fGenericUserQualifier$fShowPackageTargetProblem$fShowPackageTarget$fFunctorPackageTarget$fFoldablePackageTarget$fTraversablePackageTarget$fShowUserTargetProblem$fShowUserTarget$fEqUserTargetBuildTimeSettingsbuildSettingDryRunbuildSettingOnlyDepsbuildSettingOnlyDownloadbuildSettingSummaryFilebuildSettingLogFilebuildSettingLogVerbositybuildSettingBuildReports!buildSettingReportPlanningFailurebuildSettingSymlinkBinDirbuildSettingNumJobsbuildSettingKeepGoingbuildSettingOfflineModebuildSettingKeepTempFilesbuildSettingRemoteReposbuildSettingLocalNoIndexReposbuildSettingCacheDirbuildSettingHttpTransportbuildSettingIgnoreExpirybuildSettingProgPathExtrabuildSettingHaddockOpenSolverSettingssolverSettingRemoteRepossolverSettingLocalNoIndexRepossolverSettingConstraintssolverSettingPreferencessolverSettingFlagAssignmentsolverSettingFlagAssignmentssolverSettingCabalVersionsolverSettingSolversolverSettingAllowOldersolverSettingAllowNewersolverSettingMaxBackjumpssolverSettingReorderGoalssolverSettingCountConflicts!solverSettingFineGrainedConflicts solverSettingMinimizeConflictSetsolverSettingStrongFlags!solverSettingAllowBootLibInstallssolverSettingOnlyConstrainedsolverSettingIndexStatesolverSettingActiveRepossolverSettingIndependentGoalssolverSettingPreferOldest MapMappend getMapMappendMapLast getMapLast PackageConfigpackageConfigProgramPathspackageConfigProgramArgspackageConfigProgramPathExtrapackageConfigFlagAssignmentpackageConfigVanillaLibpackageConfigSharedLibpackageConfigStaticLibpackageConfigDynExepackageConfigFullyStaticExepackageConfigProfpackageConfigProfLibpackageConfigProfExepackageConfigProfDetailpackageConfigProfLibDetailpackageConfigConfigureArgspackageConfigOptimizationpackageConfigProgPrefixpackageConfigProgSuffixpackageConfigExtraLibDirspackageConfigExtraLibDirsStaticpackageConfigExtraFrameworkDirspackageConfigExtraIncludeDirspackageConfigGHCiLibpackageConfigSplitSectionspackageConfigSplitObjspackageConfigStripExespackageConfigStripLibspackageConfigTestspackageConfigBenchmarkspackageConfigCoveragepackageConfigRelocatablepackageConfigDebugInfopackageConfigDumpBuildInfopackageConfigRunTestspackageConfigDocumentationpackageConfigHaddockHooglepackageConfigHaddockHtml packageConfigHaddockHtmlLocationpackageConfigHaddockForeignLibspackageConfigHaddockExecutablespackageConfigHaddockTestSuitespackageConfigHaddockBenchmarkspackageConfigHaddockInternalpackageConfigHaddockCss packageConfigHaddockLinkedSourcepackageConfigHaddockQuickJumppackageConfigHaddockHscolourCsspackageConfigHaddockContentspackageConfigHaddockIndexpackageConfigHaddockBaseUrlpackageConfigHaddockLibpackageConfigHaddockForHackagepackageConfigTestHumanLogpackageConfigTestMachineLogpackageConfigTestShowDetailspackageConfigTestKeepTixpackageConfigTestWrapper%packageConfigTestFailWhenNoTestSuitespackageConfigTestTestOptionspackageConfigBenchmarkOptionsProjectConfigProvenanceImplicitExplicitProjectConfigSharedprojectConfigDistDirprojectConfigConfigFileprojectConfigProjectFileprojectConfigIgnoreProjectprojectConfigHcFlavorprojectConfigHcPathprojectConfigHcPkgprojectConfigHaddockIndexprojectConfigInstallDirsprojectConfigPackageDBsprojectConfigRemoteReposprojectConfigLocalNoIndexReposprojectConfigActiveReposprojectConfigIndexStateprojectConfigStoreDirprojectConfigConstraintsprojectConfigPreferencesprojectConfigCabalVersionprojectConfigSolverprojectConfigAllowOlderprojectConfigAllowNewer+projectConfigWriteGhcEnvironmentFilesPolicyprojectConfigMaxBackjumpsprojectConfigReorderGoalsprojectConfigCountConflicts!projectConfigFineGrainedConflicts projectConfigMinimizeConflictSetprojectConfigStrongFlags!projectConfigAllowBootLibInstallsprojectConfigOnlyConstrainedprojectConfigPerComponentprojectConfigIndependentGoalsprojectConfigPreferOldestprojectConfigProgPathExtraProjectConfigBuildOnlyprojectConfigVerbosityprojectConfigDryRunprojectConfigOnlyDepsprojectConfigOnlyDownloadprojectConfigSummaryFileprojectConfigLogFileprojectConfigBuildReports"projectConfigReportPlanningFailureprojectConfigSymlinkBinDirprojectConfigNumJobsprojectConfigKeepGoingprojectConfigOfflineModeprojectConfigKeepTempFilesprojectConfigHttpTransportprojectConfigIgnoreExpiryprojectConfigCacheDirprojectConfigLogsDirprojectConfigClientInstallFlags ProjectConfigprojectPackagesprojectPackagesOptionalprojectPackagesRepoprojectPackagesNamedprojectConfigBuildOnlyprojectConfigSharedprojectConfigProvenanceprojectConfigAllPackagesprojectConfigLocalPackagesprojectConfigSpecificPackage!$fSemigroupProjectConfigBuildOnly$fMonoidProjectConfigBuildOnly"$fStructuredProjectConfigBuildOnly$fBinaryProjectConfigBuildOnly$fSemigroupProjectConfigShared$fMonoidProjectConfigShared$fStructuredProjectConfigShared$fBinaryProjectConfigShared#$fStructuredProjectConfigProvenance$fBinaryProjectConfigProvenance$fSemigroupMapLast$fMonoidMapLast$fStructuredMapLast$fSemigroupMapMappend$fMonoidMapMappend$fStructuredMapMappend$fSemigroupPackageConfig$fMonoidPackageConfig$fStructuredPackageConfig$fBinaryPackageConfig$fSemigroupProjectConfig$fMonoidProjectConfig$fStructuredProjectConfig$fBinaryProjectConfig$fStructuredSolverSettings$fBinarySolverSettings$fEqSolverSettings$fShowSolverSettings$fGenericSolverSettings$fEqProjectConfig$fShowProjectConfig$fGenericProjectConfig$fEqPackageConfig$fShowPackageConfig$fGenericPackageConfig$fEqMapMappend$fShowMapMappend$fFunctorMapMappend$fGenericMapMappend$fBinaryMapMappend $fEqMapLast $fShowMapLast$fFunctorMapLast$fGenericMapLast$fBinaryMapLast$fEqProjectConfigProvenance$fOrdProjectConfigProvenance$fShowProjectConfigProvenance $fGenericProjectConfigProvenance$fEqProjectConfigShared$fShowProjectConfigShared$fGenericProjectConfigShared$fEqProjectConfigBuildOnly$fShowProjectConfigBuildOnly$fGenericProjectConfigBuildOnlynewBuildReportcabalInstallIDparseBuildReportparseBuildReportListshowBuildReportstoreAnonymous storeLocalfromInstallPlanfromPlanningFailurepossibleSelfUpgradedeleteOldExeFileReadPParsergetlookpfaileof+++<++gathersatisfycharstringmunchmunch1choice skipSpaces skipSpaces1countbetweenoptionoptionalmanymany1skipMany skipMany1sepBysepBy1endByendBy1chainrchainlchainr1chainl1manyTill readP_to_S readS_to_P readP_to_E $fMonadPlusP$fAlternativeP $fMonadFailP$fMonadP$fApplicativeP $fFunctorP$fMonadPlusParser$fMonadFailParser $fMonadParser$fAlternativeParser$fApplicativeParser$fFunctorParser FieldDescr fieldNamefieldGetfieldSet liftField QualLevelQL1QL2QL3QLFullTargetSelectorProblemTargetSelectorExpectedTargetSelectorNoSuchTargetSelectorAmbiguousMatchingInternalErrorTargetSelectorUnrecognisedTargetSelectorNoCurrentPackageTargetSelectorNoTargetsInCwd TargetSelectorNoTargetsInProjectTargetSelectorNoScript TargetString TargetString1 TargetString2 TargetString3 TargetString4 TargetString5 TargetString7 DirActionscanonicalizePathSubComponentTargetWholeComponent ModuleTarget FileTargetComponentKindFilter ComponentKindLibKindFLibKindExeKindTestKind BenchKindTargetImplicitCwdTargetExplicitNamedTargetSelector TargetPackageTargetPackageNamedTargetAllPackagesTargetComponentTargetComponentUnknownreadTargetSelectorsreadTargetSelectorsWithdefaultDirActionsparseTargetStringshowTargetStringshowTargetSelectorreportTargetSelectorProblems componentKind$fStructuredSubComponentTarget$fBinarySubComponentTarget$fMonadPlusMatch $fMonadMatch$fAlternativeMatch$fApplicativeMatch$fFunctorMatch$fShowMaybeAmbiguous $fShowMatch$fShowMatchError$fEqMatchError$fShowMatchClass$fEqMatchClass$fOrdMatchClass$fShowKnownTargets$fShowKnownPackage$fShowKnownComponent $fEqQualLevel$fEnumQualLevel$fShowQualLevel$fShowTargetSelectorProblem$fEqTargetSelectorProblem$fEqTargetStringFileStatus$fOrdTargetStringFileStatus$fShowTargetStringFileStatus$fEqFileStatus$fOrdFileStatus$fShowFileStatus$fShowTargetString$fEqTargetString$fEqTargetSelector$fOrdTargetSelector$fShowTargetSelector$fGenericTargetSelector$fEqSubComponentTarget$fOrdSubComponentTarget$fShowSubComponentTarget$fGenericSubComponentTarget$fEqComponentKind$fOrdComponentKind$fEnumComponentKind$fShowComponentKind$fEqTargetImplicitCwd$fOrdTargetImplicitCwd$fShowTargetImplicitCwd$fGenericTargetImplicitCwdWithoutProjectTargetSelector WoPackageIdWoPackageComponentWoURI!parseWithoutProjectTargetSelectorwoPackageNameswoPackageTargetswoPackageSpecifiers"$fShowWithoutProjectTargetSelectorUserConfigFlagsuserConfigVerbosityuserConfigForceuserConfigAppendLinesActAsSetupFlagsactAsSetupBuildType UploadFlagsuploadCandidate uploadDocuploadUsernameuploadPassworduploadPasswordCmduploadVerbosity IsCandidate IsPublished InstallFlagsinstallDocumentationinstallHaddockIndex installDest installDryRuninstallOnlyDownloadinstallMaxBackjumpsinstallReorderGoalsinstallCountConflictsinstallFineGrainedConflictsinstallMinimizeConflictSetinstallIndependentGoalsinstallPreferOldestinstallShadowPkgsinstallStrongFlagsinstallAllowBootLibInstallsinstallOnlyConstrainedinstallReinstallinstallAvoidReinstallsinstallOverrideReinstallinstallUpgradeDeps installOnlyinstallOnlyDepsinstallIndexStateinstallRootCmdinstallSummaryFileinstallLogFileinstallBuildReportsinstallReportPlanningFailureinstallSymlinkBinDirinstallPerComponentinstallNumJobsinstallKeepGoinginstallRunTestsinstallOfflineMode InfoFlags infoVerbosityinfoPackageDBs ListFlags listInstalledlistSimpleOutputlistCaseInsensitive listVerbositylistPackageDBs listHcPathGetFlags getDestDirgetOnlyPkgDescr getPristine getIndexStategetActiveReposgetSourceRepository getVerbosity ReportFlagsreportUsernamereportPasswordreportVerbosity UpdateFlagsupdateVerbosityupdateIndexState FreezeFlags freezeDryRun freezeTestsfreezeBenchmarks freezeSolverfreezeMaxBackjumpsfreezeReorderGoalsfreezeCountConflictsfreezeFineGrainedConflictsfreezeMinimizeConflictSetfreezeIndependentGoalsfreezePreferOldestfreezeShadowPkgsfreezeStrongFlagsfreezeAllowBootLibInstallsfreezeOnlyConstrainedfreezeVerbosity FetchFlags fetchDeps fetchDryRun fetchSolverfetchMaxBackjumpsfetchReorderGoalsfetchCountConflictsfetchFineGrainedConflictsfetchMinimizeConflictSetfetchIndependentGoalsfetchPreferOldestfetchShadowPkgsfetchStrongFlagsfetchAllowBootLibInstallsfetchOnlyConstrained fetchTestsfetchBenchmarksfetchVerbosity ConfigExFlagsconfigCabalVersion configAppend configBackupconfigExConstraintsconfigPreferences configSolverconfigAllowNewerconfigAllowOlder$configWriteGhcEnvironmentFilesPolicy globalCommandconfigureCommandconfigureOptionsfilterConfigureFlagsconfigPackageDB'configCompilerAux'defaultConfigExFlagsconfigureExCommandconfigureExOptionsreconfigureCommand buildCommandfilterTestFlags replCommand testCommandbenchmarkCommand fetchCommand freezeCommandgenBoundsCommanddefaultUpdateFlags cleanCommand checkCommand formatCommandmanpageCommand runCommand reportCommand getCommand unpackCommand listCommandlistNeedsCompiler infoCommanddefaultInstallFlagsdefaultMaxBackjumps defaultSolverinstallCommandhaddockCommandfilterHaddockArgsfilterHaddockFlagshaddockOptions testOptionsbenchmarkOptionsinstallOptions uploadCommand initCommand initOptions copyCommandregisterCommandactAsSetupCommanduserConfigCommand liftOptionsyesNoOpt$fSemigroupConfigExFlags$fMonoidConfigExFlags$fSemigroupReportFlags$fMonoidReportFlags$fSemigroupGetFlags$fMonoidGetFlags$fSemigroupListFlags$fMonoidListFlags$fSemigroupInfoFlags$fMonoidInfoFlags$fSemigroupInstallFlags$fMonoidInstallFlags$fBinaryInstallFlags$fSemigroupUploadFlags$fMonoidUploadFlags$fSemigroupActAsSetupFlags$fMonoidActAsSetupFlags$fSemigroupUserConfigFlags$fMonoidUserConfigFlags$fGenericUserConfigFlags$fGenericActAsSetupFlags$fGenericUploadFlags$fEqIsCandidate$fEqInstallFlags$fShowInstallFlags$fGenericInstallFlags$fGenericInfoFlags$fGenericListFlags$fGenericGetFlags$fGenericReportFlags$fGenericUpdateFlags$fEqConfigExFlags$fShowConfigExFlags$fGenericConfigExFlags NixStyleFlags configFlags configExFlags installFlags haddockFlags testFlagsbenchmarkFlags projectFlags extraFlagsnixStyleOptionsdefaultNixStyleFlags manpageCmdmanpagesymlinkBinaries symlinkBinary promptRun trySymlink$fShowSymlinkStatusIndex RepoIndex SandboxIndexPreferredVersionsParseErrorpreferredVersionsParsecError#preferredVersionsOriginalDependencyBuildTreeRefType SnapshotRefLinkRef PackageEntry NormalPackage BuildTreeRefgetInstalledPackages indexBaseNamegetSourcePackagesgetSourcePackagesAtIndexStategetIndexFileAgegetSourcePackagesMonitorFilesupdateRepoIndexCacherefTypeFromTypeCodetypeCodeFromRefTypeparsePackageIndexpreferredVersionsisPreferredVersionsparsePreferredVersionsWarningsupdatePackageIndexCacheFilewriteIndexTimestampcurrentIndexTimestamp$fStructuredBuildTreeRefType$fBinaryBuildTreeRefType$fPackagePackageEntry$fStructuredIndexCacheEntry$fBinaryIndexCacheEntry$fNFDataIndexCacheEntry$fStructuredCache $fBinaryCache $fNFDataCache$fStructuredNoIndexCacheEntry$fBinaryNoIndexCacheEntry$fNFDataNoIndexCacheEntry$fStructuredNoIndexCache$fBinaryNoIndexCache$fNFDataNoIndexCache$fShowNoIndexCache$fGenericNoIndexCache$fEqNoIndexCacheEntry$fShowNoIndexCacheEntry$fGenericNoIndexCacheEntry $fShowCache$fGenericCache$fEqIndexCacheEntry$fShowIndexCacheEntry$fGenericIndexCacheEntry$$fGenericPreferredVersionsParseError!$fReadPreferredVersionsParseError!$fShowPreferredVersionsParseError$fEqPreferredVersionsParseError $fOrdPreferredVersionsParseError$fEqBuildTreeRefType$fShowBuildTreeRefType$fGenericBuildTreeRefTypelistinfoinitCmdClonePackageExceptionClonePackageNoSourceReposClonePackageNoSourceReposOfKindClonePackageNoRepoTypeClonePackageUnsupportedRepoTypeClonePackageNoRepoLocationClonePackageDestinationExistsClonePackageFailedWithExitCodeclonePackagesFromSourceRepo $fExceptionClonePackageException$fShowClonePackageException$fEqClonePackageExceptionfetchBuildLog BuildReportId uploadReportsviewAsFieldDescrFGSectionDescr fgSectionNamefgSectionGrammar fgSectionGet fgSectionSet SectionDescr sectionName sectionFieldssectionSubsections sectionGet sectionSet sectionEmpty liftFields filterFields mapFieldNamescommandOptionToFieldcommandOptionsToFields liftSection parseFieldsppFields ppSectionparseFieldsAndSectionsppFieldsAndSections parseConfig showConfig SavedConfigsavedGlobalFlagssavedInitFlagssavedInstallFlagssavedClientInstallFlagssavedConfigureFlagssavedConfigureExFlagssavedUserInstallDirssavedGlobalInstallDirssavedUploadFlagssavedReportFlagssavedHaddockFlagssavedTestFlagssavedBenchmarkFlagssavedProjectFlagsbaseSavedConfiginitialSavedConfigdefaultConfigFiledefaultCacheDirdefaultScriptBuildsDirdefaultStoreDirdefaultLogsDirdefaultReportsDirdefaultInstallPathdefaultCompilerdefaultUserInstall loadConfiggetConfigFilePathcreateDefaultConfigFilecommentSavedConfigconfigFieldDescriptionspostProcessReposhowConfigWithCommentsinstallDirsFieldsremoteRepoFieldshaddockFlagsFieldswithProgramsFieldswithProgramOptionsFieldsuserConfigDiffuserConfigUpdate$fSemigroupSavedConfig$fMonoidSavedConfig$fGenericSavedConfiguploadreportSetupScriptOptionsuseCabalVersionuseCabalSpecVersion useCompiler usePlatform usePackageDBusePackageIndex useProgramDb useDistPrefuseLoggingHandle useWorkingDiruseExtraPathEnvuseExtraEnvOverridesforceExternalSetupMethoduseDependenciesuseDependenciesExclusiveuseVersionMacrosuseWin32CleanHacksetupCacheLock isInteractivedefaultSetupScriptOptionsgetSetuprunSetuprunSetupCommand setupWrapperchooseCabalVersion configureconfigureSetupScriptcheckConfigExFlagsreadConfigFlagsFromcabalConfigFlagsFilereadConfigFlagswriteConfigFlagsTowriteConfigFlagsPackageEnvironmentTypeUserPackageEnvironmentAmbientPackageEnvironmentPackageEnvironmentpkgEnvSavedConfiguserPackageEnvironmentFileclassifyPackageEnvironmentloadUserConfigreadPackageEnvironmentFileshowPackageEnvironment"showPackageEnvironmentWithComments$fSemigroupPackageEnvironment$fMonoidPackageEnvironment$fGenericPackageEnvironmentupdateInstallDirsloadConfigOrSandboxConfigfindSavedDistPrefgetPersistOrConfigCompiler legacyCmdlegacyWrapperCmdnewCmd$fHasVerbosityCleanFlags$fHasVerbosityUpdateFlags$fHasVerbosityHaddockFlags$fHasVerbosityFreezeFlags$fHasVerbosityReplFlags$fHasVerbosityConfigFlags$fHasVerbosityBuildFlags$fHasVerbosity(,,,,,)$fHasVerbosity(,,,,)$fHasVerbosity(,,,)$fHasVerbosity(,,)$fHasVerbosity(,)$fHasVerbosityFlagLegacyProjectConfigProjectConfigSkeletonsingletonProjectConfigSkeleton0instantiateProjectConfigSkeletonFetchingCompiler,instantiateProjectConfigSkeletonWithCompilerprojectSkeletonImportsparseProjectSkeletoncommandLineFlagsToProjectConfigconvertLegacyGlobalConfigconvertLegacyProjectConfigconvertToLegacyProjectConfigparseLegacyProjectConfigshowLegacyProjectConfigparsePackageLocationTokenQrenderPackageLocationToken$fSemigroupLegacyPackageConfig$fMonoidLegacyPackageConfig$fSemigroupLegacySharedConfig$fMonoidLegacySharedConfig$fSemigroupLegacyProjectConfig$fMonoidLegacyProjectConfig$fShowLegacyProjectConfig$fGenericLegacyProjectConfig$fShowLegacySharedConfig$fGenericLegacySharedConfig$fShowLegacyPackageConfig$fGenericLegacyPackageConfig findNixExprnixInstantiatenixShell inNixShellCheckrunCheck reconfigure $fMonoidCheck$fSemigroupCheck InstallArgsInstallContextinstallmakeInstallContextmakeInstallPlanprocessInstallPlanpruneInstallPlanfreeze getFreezePkgs genBounds ProjectRootProjectRootImplicitProjectRootExplicitCabalDirLayoutcabalStoreDirLayoutcabalLogsDirectoryStoreDirLayoutstoreDirectorystorePackageDirectorystorePackageDBPathstorePackageDBstorePackageDBStackstoreIncomingDirectorystoreIncomingLock DistDirLayoutdistProjectRootDirectorydistProjectFile distDirectorydistBuildDirectorydistBuildRootDirectorydistDownloadSrcDirectorydistUnpackedSrcDirectorydistUnpackedSrcRootDirectorydistProjectCacheFiledistProjectCacheDirectorydistPackageCacheFiledistPackageCacheDirectory distSdistFiledistSdistDirectorydistTempDirectorydistBinDirectory distPackageDB DistDirParamsdistParamUnitIddistParamPackageIddistParamComponentIddistParamComponentNamedistParamCompilerIddistParamPlatformdistParamOptimizationdefaultDistDirLayoutdefaultStoreDirLayoutdefaultCabalDirLayoutmkCabalDirLayout$fEqProjectRoot$fShowProjectRootNewStoreEntryOutcomeUseNewStoreEntryUseExistingStoreEntrydoesStoreEntryExistgetStoreEntries newStoreEntry$fEqNewStoreEntryOutcome$fShowNewStoreEntryOutcomeSetupScriptStyleSetupCustomExplicitDepsSetupCustomImplicitDepsSetupNonCustomExternalLibSetupNonCustomInternalLibComponentTargetElaboratedReadyPackage CabalFileText BuildStyleBuildAndInstallBuildInplaceOnlyElaboratedPackagepkgInstalledIdpkgLibDependenciespkgDependsOnSelfLibpkgExeDependenciespkgExeDependencyPathspkgPkgConfigDependenciespkgStanzasEnabledElaboratedComponentcompSolverNamecompComponentNamecompLibDependenciescompLinkedLibDependenciescompExeDependenciescompPkgConfigDependenciescompExeDependencyPathscompOrderLibDependenciesElaboratedPackageOrComponent ElabPackage ElabComponentElaboratedConfiguredPackage elabUnitIdelabComponentIdelabInstantiatedWithelabLinkedInstantiatedWithelabIsCanonicalelabPkgSourceIdelabModuleShapeelabFlagAssignmentelabFlagDefaultselabPkgDescriptionelabPkgSourceLocationelabPkgSourceHashelabLocalToProjectelabBuildStyleelabEnabledSpecelabStanzasAvailableelabStanzasRequestedelabPackageDbselabSetupPackageDBStackelabBuildPackageDBStackelabRegisterPackageDBStackelabInplaceSetupPackageDBStackelabInplaceBuildPackageDBStack!elabInplaceRegisterPackageDBStackelabPkgDescriptionOverrideelabVanillaLib elabSharedLib elabStaticLib elabDynExeelabFullyStaticExe elabGHCiLib elabProfLib elabProfExeelabProfLibDetailelabProfExeDetail elabCoverageelabOptimization elabSplitObjselabSplitSections elabStripLibs elabStripExes elabDebugInfoelabDumpBuildInfoelabProgramPathselabProgramArgselabProgramPathExtraelabConfigureScriptArgselabExtraLibDirselabExtraLibDirsStaticelabExtraFrameworkDirselabExtraIncludeDirselabProgPrefixelabProgSuffixelabInstallDirselabHaddockHoogleelabHaddockHtmlelabHaddockHtmlLocationelabHaddockForeignLibselabHaddockForHackageelabHaddockExecutableselabHaddockTestSuiteselabHaddockBenchmarkselabHaddockInternalelabHaddockCsselabHaddockLinkedSourceelabHaddockQuickJumpelabHaddockHscolourCsselabHaddockContentselabHaddockIndexelabHaddockBaseUrlelabHaddockLibelabTestMachineLogelabTestHumanLogelabTestShowDetailselabTestKeepTixelabTestWrapperelabTestFailWhenNoTestSuiteselabTestTestOptionselabBenchmarkOptionselabSetupScriptStyleelabSetupScriptCliVersionelabConfigureTargetselabBuildTargetselabTestTargetselabBenchTargetselabReplTargetelabHaddockTargetselabBuildHaddocks elabPkgOrCompElaboratedSharedConfigpkgConfigPlatformpkgConfigCompilerpkgConfigCompilerProgspkgConfigReplOptionsElaboratedPlanPackageElaboratedInstallPlanelabPlanPackageNamenormaliseConfiguredPackageelabRequiresRegistrationdataDirsEnvironmentForPlanelabComponentNameelabConfiguredNameelabDistDirParamselabOrderLibDependencieselabLibDependencieselabOrderExeDependencieselabExeDependencieselabExeDependencyPathselabSetupDependencieselabPkgConfigDependencies$elabInplaceDependencyBuildCacheFilespkgOrderDependenciesshowComponentTargetshowTestComponentTargetisTestComponentTargetshowBenchComponentTargetisBenchComponentTargetisForeignLibComponentTargetisExeComponentTargetisSubLibComponentTargetcomponentOptionalStanza"$fStructuredElaboratedSharedConfig$fBinaryElaboratedSharedConfig$fStructuredElaboratedComponent$fBinaryElaboratedComponent$fStructuredElaboratedPackage$fBinaryElaboratedPackage($fStructuredElaboratedPackageOrComponent$$fBinaryElaboratedPackageOrComponent$fMonoidBuildStyle$fSemigroupBuildStyle$fStructuredBuildStyle$fBinaryBuildStyle$fStructuredComponentTarget$fBinaryComponentTarget$fStructuredSetupScriptStyle$fBinarySetupScriptStyle'$fStructuredElaboratedConfiguredPackage#$fBinaryElaboratedConfiguredPackage#$fIsNodeElaboratedConfiguredPackage&$fHasUnitIdElaboratedConfiguredPackage,$fHasConfiguredIdElaboratedConfiguredPackage$$fPackageElaboratedConfiguredPackage$fEqElaboratedConfiguredPackage!$fShowElaboratedConfiguredPackage$$fGenericElaboratedConfiguredPackage$fEqSetupScriptStyle$fShowSetupScriptStyle$fGenericSetupScriptStyle$fEqComponentTarget$fOrdComponentTarget$fShowComponentTarget$fGenericComponentTarget$fEqBuildStyle$fShowBuildStyle$fGenericBuildStyle $fEqElaboratedPackageOrComponent"$fShowElaboratedPackageOrComponent%$fGenericElaboratedPackageOrComponent$fEqElaboratedPackage$fShowElaboratedPackage$fGenericElaboratedPackage$fEqElaboratedComponent$fShowElaboratedComponent$fGenericElaboratedComponent$fShowElaboratedSharedConfig$fGenericElaboratedSharedConfigneedElaboratedConfiguredPackagePostBuildProjectStatuspackagesDefinitelyUpToDatepackagesProbablyUpToDatepackagesOutOfDatepackagesInvalidByChangedLibDepspackagesInvalidByFailedBuildpackagesLibDepGraphpackagesBuildLocalpackagesBuildInplacepackagesAlreadyInStorewritePlanExternalRepresentationupdatePostBuildProjectStatuscreatePackageEnvironmentwritePlanGhcEnvironment"argsEquivalentOfGhcEnvironmentFileBadPerPackageCompilerPathsBadPackageLocationMatchBadLocUnexpectedFileBadLocNonexistantFileBadLocDirNoCabalFileBadLocDirManyCabalFilesBadPackageLocationBadPackageLocationFileBadLocGlobEmptyMatchBadLocGlobBadMatchesBadLocUnexpectedUriSchemeBadLocUnrecognisedUriBadLocUnrecognisedBadPackageLocationsProjectPackageLocationProjectPackageLocalCabalFileProjectPackageLocalDirectoryProjectPackageLocalTarballProjectPackageRemoteTarballProjectPackageRemoteRepoProjectPackageNamedBadProjectRootBadProjectRootExplicitFilelookupLocalPackageConfig#projectConfigWithBuilderRepoContext"projectConfigWithSolverRepoContextresolveSolverSettingsresolveBuildTimeSettingsfindProjectRootwithGlobalConfigwithProjectOrGlobalConfigreadProjectLocalExtraConfigreadProjectLocalFreezeConfigshowProjectConfigwriteProjectLocalExtraConfigwriteProjectLocalFreezeConfigwriteProjectConfigFilereadGlobalConfigreportParseResultfindProjectPackagesfetchAndReadSourcePackagescheckBadPerPackageCompilerPaths$fExceptionBadProjectRoot$fExceptionBadPackageLocations$fExceptionCabalFileParseError$fShowCabalFileParseError!$fExceptionCabalFileSearchFailure%$fExceptionBadPerPackageCompilerPaths $fShowBadPerPackageCompilerPaths$fShowCabalFileSearchFailure$fShowBadPackageLocations$fShowBadPackageLocation$fShowBadPackageLocationMatch$fShowProjectPackageLocation$fShowBadProjectRootCannotPruneDependencies TargetActionTargetActionConfigureTargetActionBuildTargetActionReplTargetActionTestTargetActionBenchTargetActionHaddockTargetRequestedTargetRequestedByDefaultTargetNotRequestedByDefaultAvailableTargetStatusTargetDisabledByUserTargetDisabledBySolverTargetNotBuildableTargetNotLocalTargetBuildableAvailableTargetavailableTargetPackageIdavailableTargetComponentNameavailableTargetStatusavailableTargetLocalToProjectrebuildProjectConfigconfigureCompilerrebuildInstallPlanbinDirectoriesavailableTargetsnubComponentTargetspkgHasEphemeralBuildTargetselabBuildTargetWholeComponentspruneInstallPlanToTargetspruneInstallPlanToDependenciessetupHsScriptOptionsstorePackageInstallDirsstorePackageInstallDirs'setupHsConfigureFlagssetupHsConfigureArgssetupHsBuildFlagssetupHsBuildArgssetupHsTestFlagssetupHsTestArgssetupHsBenchFlagssetupHsBenchArgssetupHsReplFlagssetupHsReplArgssetupHsCopyFlagssetupHsRegisterFlagssetupHsHaddockFlagssetupHsHaddockArgspackageHashInputsbinDirectoryFor'$fIsNodeNonSetupLibDepSolverPlanPackage($fPackageNonSetupLibDepSolverPlanPackage$fIsNodePrunedPackage$fHasUnitIdPrunedPackage$fPackagePrunedPackage$fShowCannotPruneDependencies$fEqAvailableTarget$fShowAvailableTarget$fFunctorAvailableTarget$fEqAvailableTargetStatus$fOrdAvailableTargetStatus$fShowAvailableTargetStatus$fFunctorAvailableTargetStatus$fEqTargetRequested$fOrdTargetRequested$fShowTargetRequestedTargetProblem' TargetProblemTargetNotInProjectTargetAvailableInIndexTargetComponentNotProjectLocalTargetComponentNotBuildable"TargetOptionalStanzaDisabledByUser$TargetOptionalStanzaDisabledBySolverTargetProblemUnknownComponentTargetProblemNoneEnabledTargetProblemNoTargetsTargetProblemNoSuchPackageTargetProblemNoSuchComponentCustomTargetProblem$fEqTargetProblem$fShowTargetProblem$fFunctorTargetProblemPluralSingularplural listPluralrenderListCommaAndrenderListTabularrenderListPrettyrenderListSemiAnd sortGroupOnrenderTargetSelectorrenderSubComponentTargetrenderOptionalStanzaoptionalStanzatargetSelectorPluralPkgstargetSelectorRefersToPkgstargetSelectorFilterrenderComponentNamerenderComponentKindreportTargetProblemsrenderTargetProblemrenderTargetProblemNoneEnabledrenderTargetProblemNoTargetsrenderCannotPruneDependenciesrebuildTargetsDryRun&improveInstallPlanWithUpToDatePackagesrebuildTargets TargetsMapProjectBuildContextelaboratedPlanOriginalelaboratedPlanToExecuteelaboratedSharedpkgsBuildStatus targetsMapProjectBaseContext distDirLayoutcabalDirLayout projectConfig localPackages buildSettingscurrentCommandinstalledPackagesCurrentCommandInstallCommandHaddockCommand BuildCommand ReplCommand OtherCommandestablishProjectBaseContext#establishProjectBaseContextWithRootwithInstallPlanrunProjectPreBuildPhaserunProjectBuildPhaserunProjectPostBuildPhaseallTargetSelectorsuniqueTargetSelectorsresolveTargetsfilterTargetsKindfilterTargetsKindWithselectBuildableTargetsselectBuildableTargetsWithselectBuildableTargets'selectBuildableTargetsWith'forgetTargetsDetailselectComponentTargetBasicdistinctTargetComponents printPlandieOnBuildFailures establishDummyProjectBaseContextestablishDummyDistDirLayout$fShowCurrentCommand$fEqCurrentCommand TargetContextProjectContext GlobalContext ScriptContextAcceptNoTargetsRejectNoTargets getScriptHashgetScriptCacheDirectoryensureScriptCacheDirectorywithContextAndSelectors!updateContextAndWriteProjectFile' updateContextAndWriteProjectFilefakeProjectSourcePackage movedExePathlSrcpkgDescription$fEqTargetContext$fShowTargetContext$fEqAcceptNoTargets$fShowAcceptNoTargets updateCommand updateAction$fParsecUpdateRequest$fPrettyUpdateRequest$fShowUpdateRequest testActionselectPackageTargetsselectComponentTargetnoTestsProblemnotTestProblemisSubComponentProblem$fEqTestProblem$fShowTestProblem runAction validScript handleShebang noExesProblemmatchesMultipleProblem$fEqRunProblem$fShowRunProblemClientHaddockFlags openInBrowser haddockActionbuildOnlyConfiguredefaultBuildFlags buildAction benchCommand benchActionnoBenchmarksProblemcomponentNotBenchmarkProblem$fEqBenchProblem$fShowBenchProblem OutputFormat SourceList TarGzArchive sdistCommand sdistActionpackageToSdist$fShowOutputFormat$fEqOutputFormat replAction$fEqReplProblem$fShowReplProblem$fShowOriginalComponentInfolistbinCommand listbinActionnoComponentsProblemmultipleTargetsProblemcomponentNotRightKindProblem$fEqListBinProblem$fShowListBinProblemhaddockProjectAction freezeAction execCommand execActionconfigureActionconfigureAction'ListOutdatedSettingslistOutdatedIgnorePredlistOutdatedMinorPredoutdatedCommandoutdatedAction listOutdated"$fSemigroupIgnoreMajorVersionBumps$fMonoidIgnoreMajorVersionBumps installAction cleanAction$fEqCleanFlagsmainreadSymbolicLinkGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip System.IOprint Data.Tuplefstsnd otherwisemap$GHC.Real fromIntegral realToFrac Control.MonadguardjoinGHC.EnumBoundedminBoundmaxBoundEnum enumFromThenenumFrom enumFromToenumFromThenTotoEnumsuccfromEnumpred GHC.ClassesEq==/= GHC.FloatFloatingtantanhsqrtsinhsinpilogBaselogexpcoshcosatanhatanasinhasinacosh**acos Fractionalrecip/ fromRationalIntegralrem toIntegerquotRemquotmoddivdivModMonad>>return>>= Data.DataDataFunctorfmap<$GHC.NumNum- fromIntegernegatesignumabs*+Ord<>=<=>compareminmaxGHC.ReadRead readsPrecreadListReal toRational RealFloat scaleFloat significandisNegativeZeroisNaN isInfiniteisIEEEisDenormalized floatRange floatRadix floatDigitsexponent encodeFloatatan2 decodeFloatRealFracroundtruncateproperFractionceilingfloorGHC.ShowShowshowListshow showsPrecData.Typeable.InternalTypeableControl.Monad.Fail MonadFailfail Data.StringIsString fromString Applicativepure<*><**> Data.FoldableFoldablesumproductminimummaximumlengthfoldrfoldl'foldlfoldMapnullelemData.Traversable Traversabletraverse sequenceA GHC.GenericsGeneric Semigroup<>Monoidmappendmconcatmempty GHC.TypesFalseTrueCharDoubleFloatIntGHC.IntInt8Int16Int32Int64 ghc-bignumGHC.Num.IntegerInteger GHC.MaybeMaybeNothingJustOrderingEQGTLTRationalIOWordGHC.WordWord8Word16Word32Word64 Data.EitherEitherLeftRightNonEmpty:| Data.VoidVoidvacuousabsurdData.List.NonEmptytailnonEmptylastinithead System.ExitexitWith exitSuccess exitFailureunlessfoldMfilterMforData.Functor.IdentityIdentity runIdentityreadLnreadIOputCharinteract getContentsgetChar appendFileGHC.IO.ExceptionExitCode ExitSuccess ExitFailureioErrorGHC.IOFilePaththrowIOevaluatecatch IOExceptionIOError userErrorGHC.Exception.Type Exception fromExceptiondisplayException toException Data.TypeableTypeReptypeRepData.Functor.ConstConstgetConst traverse_ sequence_ornotElemfor_find concatMapconcatanyandall Data.OldListwordsunwordsunlinesunfoldrsortBysort partitionnubBynublines isSuffixOf isPrefixOf intersperse dropWhileEndreadspartitionEitherseither Data.ProxyProxy readParenlex GHC.UnicodetoUppertoLowerisUpperisSpaceisDigit isAlphaNumisAlphaoddlcmgcdeven^^^GHC.CharchrShowSshows showString showParenshowCharzipWith3zipWithzip3unzip3unzip takeWhiletakesplitAtspanscanr1scanrscanl1scanlreverse replicaterepeatiterate dropWhiledropcycle!! Data.Maybe maybeToListmaybemapMaybe listToMaybe isNothingisJust fromMaybe catMaybes Data.Functionon Data.Functorvoid<$>uncurrycurrysubtract MonadPlusmzeromplus Alternativesome<|>emptywhenuntilordliftM2liftMidflipconstasTypeOfap=<<.$!GHC.Err undefinederrorWithoutStackTraceerror SomeException&&not||binary-0.8.9.0Data.Binary.ClassBinaryputputListcontainers-0.6.5.1Data.Map.InternalMapData.Set.InternalSetdeepseq-1.4.6.1Control.DeepSeqNFDatarnfforcedeepseqpretty-1.1.3.6Text.PrettyPrint.HughesPJ<+>Distribution.Compat.ExceptiontryIOcatchIO catchExitDistribution.Utils.Structured StructuredDistribution.Compat.SemigroupgmappendgmemptyDistribution.Compat.NonEmptySet NonEmptySetDistribution.Compat.Prelude<<>> genericRnffoldr1foldl1trace traceShowId traceShow intercalateData.Ord comparing Control.Arrowfirstfilepath-1.4.2.2System.FilePath.Posix takeDrive showTimestampextractMirrors%resolv-0.2.0.2-HhVyuJr72HJ6BM42lc2dBL Network.DNSqueryTXT isUrlBase splitRfc1464 normalise&Distribution.Solver.Types.PackageIndexfilterPreferredVersionsrootSets libraryRoots setupRootsdependencyInconsistencies'stateDependencyRelation!hashedInstalledPackageIdVeryShort mkInstallPlanDistribution.Compat.GraphGraph removeFile listContentsifMifNotM concatMapM partitionM mkDefPrompt promptDefaultbreakOrContinueDistribution.Fields.Pretty PrettyFieldDocfromFlagOrPromptaddBaseDepToFlags writeFileSafewriteCabalFile FileHashCacheMonitorStateFileModTimeMonitorStateFileHashedMonitorStateDirModTimereconstructMonitorFilePathsstructuredDecodeTriple withCacheFilerewriteCacheFileprobeFileSystemprobeMonitorStateFileStatusprobeMonitorStateGlobbuildMonitorStateFileSetchangedDuringUpdatebuildMonitorStateGloblookupFileHashCache getFileHashreadCacheFileHashesprobeFileModificationTimeDistribution.Compat.TimeModTime probeFileModificationTimeAndHashHashprobeFileExistenceprobeDirExistenceprobeFileNonExistencecheckModificationTimeUnchanged)checkFileModificationTimeAndHashUnchanged readFileHashcheckDirectoryModificationTimehandleErrorCall GHC.Exception ErrorCallhandleIOExceptionprobeMonitorStateGlobRelbuildMonitorStateFilebuildMonitorStateGlobRel unRebuildfindFileResolveNoDepsErrorResolveUnsatisfiabledepResolverAllowBootLibInstallsdepResolverOnlyConstraineddepResolverSolveExecutablesdepResolverGoalOrdershowPackagePreference!dontUpgradeNonUpgradeablePackagesnonUpgradeablePackagesaddSourcePackages removeBoundsrelaxPackageDeps removeBound*Distribution.Solver.Types.ConstraintSourceConstraintSetupCabalMaxVersioninterpretPackagesPreferencevalidateSolverResultconfiguredPackageProblemsbytestring-0.11.3.1 Data.ByteString.Builder.InternalBuilder doubleToInt64 escapeString vcsCloneRepo vcsSyncRepos Downloaded CheckETag NeedsDownloadget'getRange SecureRepoinitSecureReposinitSecureRepo packageFile packageURIConstraintScope%Distribution.Solver.Types.PackagePath Qualifier Unambiguous AmbiguousFSectionUnrecFieldParserparseSpaceList showFreeText showToken showFilePathField ParseResult ParseFailedParseOkPWarning UTFWarningPErrorAmbiguousParseNoParse TabsError FromStringLineNo showPWarning parseFailrunPrunElocatedErrorMsg syntaxErrorwarning fieldParsec simpleFieldsimpleFieldParseccommaListFieldParseccommaNewLineListFieldParsecspaceListFieldnewLineListFieldlistFieldWithSep listFieldlistFieldParseclineNo readFieldsparseHaskellString parseTokenQparseOptCommaList readPToMaybe MatchClassExactInexactUnknownMatch matchExactlymatchInexactly matchPlusmatchPlusShadowing findMatchSyntaxparseTargetStringsresolveTargetSelectors syntaxFormssyntaxForm1AllsyntaxForm1FiltersyntaxForm1PackagesyntaxForm1ComponentsyntaxForm1ModulesyntaxForm1FilesyntaxForm2MetaAllsyntaxForm2AllFiltersyntaxForm2PackageFiltersyntaxForm2NamespacePackagesyntaxForm2PackageComponentsyntaxForm2KindComponentsyntaxForm2PackageModulesyntaxForm2ComponentModulesyntaxForm2PackageFilesyntaxForm2ComponentFilesyntaxForm3MetaAllFiltersyntaxForm3MetaNamespacePackagesyntaxForm3PackageKindComponent!syntaxForm3PackageComponentModulesyntaxForm3KindComponentModulesyntaxForm3PackageComponentFilesyntaxForm3KindComponentFile,syntaxForm5MetaNamespacePackageKindComponent;syntaxForm7MetaNamespacePackageKindComponentNamespaceModule9syntaxForm7MetaNamespacePackageKindComponentNamespaceFilecompareFilePath exactMatchesinexactMatchesNonemkComponentName&Distribution.Types.UnqualComponentNameUnqualComponentNameDistribution.Types.PackageName PackageNameDistribution.Types.VersionVersion TestFlagsdescriptionOfGetCommandnotesOfGetCommandFileInfofiles NotExists OkToOverwrite NotOurFiletargetOkToOverwrite makeRelativeBlockNo NoIndexCacheCache cacheHeadTs cacheEntries PackageOrDepData.ByteString.Lazy.Internal ByteStringIndexStateInfo filterCache isiMaxTime isiHeadTime'Distribution.Solver.Types.SourcePackage SourcePackage readRepoIndex"tar-0.5.1.1-Cvo1F3CgsHr7V2aFsJw5rdCodec.Archive.Tar.ReadreadtarEntriesList lazySequenceparsePreferredVersions lazyUnfold is01IndexwithIndexEntriespackageListFromCachereadIndexCachereadIndexCache'writeIndexCachereadIndexTimestamp hashConsCache ExtDependencyPackageDisplayInfo getPkgListmergePackageInfoupdateFileSystemPackageDetails mergePackagesinterestingVersionsunpackOnlyPkgDescrselectPackageSourceRepoRepoKindDistribution.Simple.Command OptionFieldppSectionAndSubsections ppFgSectionConfigFileSourcewarnOnTwoConfigsmaybeGetCabalDir getDefaultDirdefaultInstallPrefixdefaultHackageRemoteRepoKeys$defaultHackageRemoteRepoKeyThreshold loadRawConfiginitFlagsFields SetupRunner SetupMethodSetupInternalMethodSelfExecMethodExternalMethodsetupScriptOptionsgetSetupMethod verbosityHackplanLocalPackageconfigurePackage SectionsAccumuserPackageEnvironmentpkgEnvFieldDescrsparsePackageEnvironmentconvertLegacyAllPackageFlagsconvertLegacyPerPackageFlagsconvertLegacyBuildOnlyFlags!packageSpecificOptionsFieldDescrs"packageSpecificOptionsSectionDescrprogramDbOptionsmonoidFieldParsecData.Semigroup.InternalAny UseLogFilecheckPrintPlanreportPlanningFailurepostInstallActionstheSpecifiedPackageinstallReadyPackageDistribution.Types.FlagFlagAssignmentinstallUnpackedPackage showBoundsboundsNeededMsgDistribution.Types.UnitIdUnitIdDistribution.Backpack OpenUnitIddataDirEnvVarForPackageelabOrderDependencies nodeNeighborscompOrderDependenciescompOrderExeDependencies intersection PackageIdSet differenceencodePlanAsJsonpostBuildProjectStatusreadPackagesUpToDateCacheFilewritePackagesUpToDateCacheFileCabalFileSearchFailureCabalFileParseErrorreadProjectLocalConfigOrDefaultreadProjectFileSkeleton renderImplicitBadPackageLocationglobStarDotCabalreadSourcePackageLocalDirectoryreadSourcePackageLocalTarball&fetchAndReadSourcePackageRemoteTarball$syncAndReadSourcePackagesRemoteReposmkSpecificSourcePackagereadSourcePackageCabalFileextractTarballPackageCabalFile FormatError"extractTarballPackageCabalFilePurelocalFileNameForRemoteTarballlocalFileNameForRemoteRepotruncateString PrunedPackageNonSetupLibDepSolverPlanPackage&sanityCheckElaboratedConfiguredPackageprogramDbSignatureDistribution.Simple.Program.Db ProgramDbprogramsMonitorFilespackageLocationsSignaturegetPackageSourceHashesapplyPackageDbFlagselaborateInstallPlan matchPlanPkgipiComponentName matchElabPkg mkCCMappingDistribution.Types.ComponentId ComponentIdmkShapeMappingsetRootTargetspruneInstallPlanPass1 optionalStanzasWithDepsAvailablepackageSetupScriptStyledefaultSetupDeps planPackagespackageSetupScriptSpecVersionuserInstallDirTemplates'improveInstallPlanWithInstalledPackages Distribution.Simple.PackageIndexInstalledPackageIndexinplaceBinRootBuildResultMisc'Distribution.Types.InstalledPackageInfoInstalledPackageInfoPackageFileMonitorcheckPackageFileMonitorChangedupdatePackageConfigFileMonitorupdatePackageBuildFileMonitorfoldMInstallPlanDepOrderpackageFileMonitorKeyValuescreatePackageDBIfMissing rebuildTargetasyncDownloadPackageswaitAsyncPackageDownloadwithTarballLocalDirectorymoveTarballShippedDistDirectoryreadExecutableBlockFromScriptreadProjectBlockFromScriptextractScriptBlockDistribution.Types.ExecutablesrcpkgDescription TestProblemTargetProblemNoTestsTargetProblemComponentNotTestTargetProblemIsSubComponentrenderAllowedNoTestsProblem RunProblemTargetProblemNoExesTargetProblemMatchesMultipleTargetProblemMultipleTargetsTargetProblemComponentNotExematchingPackagesByUnitId BenchProblemTargetProblemNoBenchmarks"TargetProblemComponentNotBenchmarkReplTargetProblemusingGhciScriptminGhciScriptVersionListBinProblemTargetProblemNoRightComps"TargetProblemComponentNotRightKindprojectFreezeConfigprojectFreezeConstraintswithTempEnvFile showResultuserConstraintsToDependenciesDistribution.Types.Dependency DependencydepsFromFreezeFiledepsFromNewFreezeFiledepsFromPkgDescaddLocalConfigToTargetsverifyPreconditionsOrDie)partitionToKnownTargetsAndHackagePackages installExesinstallLibrariesgetEnvSpecsAndNonGlobalEntriesdisableTestsBenchsByDefaultinstallUnitExesinstallBuiltExeentriesForLibraryComponents Distribution.Simple.GHC.InternalGhcEnvironmentFileEntry getEnvFilegetExistingEnvEntries getGlobalEnv getLocalEnvconstructProjectBuildContextwarnIfAssertionsAreEnabledbuildbenchmarkActionfilterBuildFlagscomponentNamesFromLBIactAsSetupAction