h$dS       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\ ] ^ _ ` a b c d e f g h i j k l m n o p q r stuvwxyz{|}~         !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""""""""""""""""""""""""""#################$$$$$$$$$$$$$$$$$$%%%%%%&&&&&&&&&&&&&'''''''''''''(((((((((((((((()))))))))))************++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,--------------------------------------.....................////////////////000000000111111111111122222222222                             333333333333333333333333333333333333333333333333333333333444444444444444444444444444444444444444444444444445566777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777 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 B B B B B B B B B B B B B B 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 D D D D E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E F G                       H 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 J J J J J J J J J J J J J J J J J J J 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                                   MMMMMMMMMMMMNNOOOOOPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRSSSSSSSSSSSSSTUUUUUVVVWWWWXXYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\]]]]]]]]]]]]]]]]^^^^^^^^^_YYYYYYYYYYYYYYYYYYYYYYYYYYY````````````````````````````````````````````aaabbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccdddddddddddddddeeeeffffffffffffffffgggggggggggggggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjkkkkkkkkkkkkkkkkkkkkkklllmmmmmmmmmmmmmmmmmmmmnnnnnnnnnooooooooooppppppppppqqqqrrsssstttttttttuuuuuuuuvvvvvwwwwwwwwxxyyyzzz{{{{||||||}}}}}}}~~  Safe-Inferred>mnopmpon  Safe-Inferred?{r 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.0rrNone?None?JRSTVUWZYX JRSTVUWZYX(c) Duncan Coutts 2009BSD-likecabal-devel@haskell.orgportableNone8E=  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?x{yz|}~|}~x{yzNoneE  (c) 2013 Liu Hao, Brent Yorgey BSD-style (see the file LICENSE)cabal-devel@haskell.org provisionalportable Safe-InferredIz cabal-installreadProcessWithExitCode creates an external process, reads its standard output and standard error strictly, waits until the process terminates, and then returns the ExitCode of the process, the standard output, and the standard error.*See the documentation of the version from System.Process for more information.The version from System.Process behaves inconsistently across platforms when an executable with the given name is not found: in some cases it returns an  ExitFailure, in others it throws an exception. This variant catches "does not exist" and "permission denied" exceptions and turns them into  ExitFailures.TODO: this doesn't use . Safe-Inferred3Jf 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.None8M 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 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.None#$Y 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-installCabal directory cabal-install!Store directory. Must be absolute cabal-install Log directory00(c) Dmitry Astapov 2010BSD-likecabal-devel@gmail.com provisionalportableNone\ 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/678None8b  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.orgportableNonebNone38d 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 RiedelBSD3None #$8f 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-install(Special timestamp value to be used when  timestamp is missingunknowninvalid4Factory functions for producing known license types.BSD-likecabal-devel@haskell.org provisionalportable Safe-InferredgC  (c) Duncan Coutts 2012BSD-likecabal-devel@haskell.org provisionalportableNone?k 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.  None8lJNone 8o 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.None3q 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.Noneu 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. (c) 2007 Bjorn Bringert, 2008 Andrea Vezzosi, 2008-2009 Duncan CouttsBSD3duncan@community.haskell.orgportableNone5x 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!None8 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"None8 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.#None8A 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.  $None8l 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-Inferred&None8 cabal-installLast'None8'(None8W  )None58$ 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.*None8= 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+None8{ 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 RiedelBSD3None 8  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-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))]))-None 8%  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])  .None  -28:? 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./None58 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  0None8~ 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 1None8C cabal-installLike , but with all dependencies guaranteed to be installed already, hence itself ready to be installed.2None8U 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 provisionalportableNone  358 (c) Duncan Coutts 2008BSD-likeduncan@community.haskell.org provisionalportableNone38 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-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-install=Compute the dependency closure of a package in a install plan^]\^]\3None#$%38M 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-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.884(c) Duncan Coutts 2008BSD-likeduncan@community.haskell.org provisionalportableNone -38? 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-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-installKeep going after failure cabal-install'Value for dependents of failed packages&&None 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..5None  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.orgportableNone 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 provisionalportableNone58 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. >None  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 darcs repo.  cabal-installThe author's email. Prompt, or try to guess from an existing darcs 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 provisionalportableNone  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 provisionalportableNone "  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.  ANone%58H%!  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-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-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-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-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-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 value3 3  BNoneV*  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-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  CNone#$%\$  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.  DNone3k  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 K 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 provisionalportableNonew  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-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-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 c structure that can be unfolded to provide progress information, logging messages and the final result or an error.  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.8_ca`bdjihgfelk 8 ca`b_ jihgfelkd  ENone {  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-install$Possibly lossy due to conversion to   cabal-install$Possibly lossy due to conversion to   cabal-install$Possibly lossy due to conversion to    8FNone|<  cabal-install;Render parse error highlighting the part of the input file.  G(c) Lennart Kolmodin 2008BSD-likekolmodin@haskell.org provisionalportableNone}  cabal-installNote: must be called with the CWD set to the directory containing the '.cabal' file.  None#$%  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 H and I.  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-installSyncronise 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 Q.  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 confict 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.HIQ  QHI H Safe-Inferred   INone  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$Utility function for legacy support.  cabal-installWhat to download cabal-installWhere to put it  None #$23?  cabal-install"Translate from hackage-security's q 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 q 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  .q q JNone#$8*  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)  K(c) David Himmelstrup 2005 Duncan Coutts 2011BSD-likecabal-devel@gmail.com provisionalportableNone#$  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. L(c) Duncan Coutts 2011BSD-likeduncan@community.haskell.orgNone5678  cabal-install Version of l0 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 .* * (c) David Himmelstrup 2005BSD-likelemmih@gmail.com provisionalportableNone#$8  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.>=<;:9876543210/.-,+*)('&%$#"!  GFEDCBA@?   >=<;:9876543210/.-,+*)('&%$#"!  GFEDCBA@?     MNone  N(c) Maciek Makowski 2015BSD-likecabal-devel@haskell.org provisionalportableNone cabal-installProduces a manual page with troff markup.O(c) Duncan Coutts 2008BSD-likecabal-devel@haskell.org provisionalportableNone8Ƶ 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-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/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-installParse `preferred-versions` file, collecting parse errors that can be shown in error messages. 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)We need to save only .cabal file contents$$P(c) Brent Yorgey 2009BSD-likecabal-devel@haskell.org provisionalportableNone] cabal-install,This is the main driver for the init script.QNone38 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 h/ 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 ~.cabalconfig 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`.R(c) David Himmelstrup 2005 Duncan Coutts 2008-2011BSD-likecabal-devel@haskell.orgNone cabal-install Show information about packages.S(c) Andrea Vezzosi 2008 Duncan Coutts 2011 John Millikin 2012BSD-likecabal-devel@haskell.org provisionalportableNone cabal-install(Entry point for the 'cabal get' command. 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-installdestination dir prefix cabal-install preferred  cabal-install"the packages and their available  SourceRepos  TNone cabal-install0Fetch a list of packages and their dependencies.U(c) David Waern 2008BSD-likedavid.waern@gmail.com experimentalportableNone - x{yz|}~ |}~x{yzVNoneW(c) David Waern 2008BSD-likedavid.waern@gmail.com experimentalportableNoneX(c) Duncan Coutts 2008BSD-likecabal-devel@haskell.org provisionalportableNoneu"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgportableNone'(" 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.orgportableNone 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.1Z"(c) Duncan Coutts 2012, 2015, 2016BSD-likeduncan@community.haskell.orgNone#$%58? 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-install Render a  back as the external syntax. This is mainly for error messages. cabal-installThrow an exception with a formatted message if there are any problems. 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)883[None%38<3 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-install"A user-friendly descriptor for an . 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 . 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.\None?e]None #$%38N  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-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.^NoneNt_NoneO< cabal-installto view as a FieldDescr, we sort the list of interfaces (Req > Bool > Choice > Opt) and consider only the first one.Ycabal-devel@haskell.orgportableNone%Y/ 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-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!!`(c) David Himmelstrup 2005BSD-likelemmih@gmail.com provisionalportableNone8`  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-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-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-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 '~.cabalconfig' and the one that cabal would generate if it didn't exist. cabal-installUpdate the user's ~.cabal*config' keeping the user's customizations.))aNoneab(c) The University of Glasgow 2006, Duncan Coutts 2008cabal-devel@haskell.orgalphaportableNone ?n  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,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-installRun a configured  with specific arguments. 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 versionc(c) David Himmelstrup 2005, Duncan Coutts 2005BSD-likecabal-devel@haskell.orgportableNones cabal-installChoose the Cabal version such that the setup scripts compiled against this version will support the given command-line flags. 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-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  dcabal-devel@haskell.orgportableNone8v  cabal-install(Type of the current package environment. cabal-install'./cabal.config' cabal-install'~.cabalconfig' 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-installSame as userPackageEnvironmentFile, but returns a SavedConfig. cabal-install"Read 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 ~.cabalconfig).  ecabal-devel@haskell.orgportableNone?y4 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-installyhgNone#$%-8> cabal-installWe already have parsers/pretty-printers for almost all the fields in the project config file, but they're in terms of the types used for the command line flags for Setup.hs or cabal commands. We don't want to redefine them all, at least not yet so for the moment we use the parsers at the old types and use conversion functions.Ultimately if/when this project-based approach becomes the default then we can redefine the parsers directly for the new types. cabal-installProjectConfigSkeleton is a tree of conditional blocks and imports wrapping a config. It can be finalized by providing the conditional resolution info and then resolving and downloading the imports cabal-installConvert configuration from the cabal configure or  cabal build command line into a  value that can combined with configuration from other sources.At the moment this uses the legacy command line flag types. See  for an explanation. cabal-install8Convert from the types currently used for the user-wide ~.cabalconfig file into the  type.Only a subset of the  can be represented in the user-wide config. In particular it does not include packages that are in the project, and it also doesn't support package-specific configuration (only configuration that applies to all packages). cabal-install8Convert the project config from the legacy types to the  and associated types. See % for an explanation of the approach. cabal-installThis is a bit tricky since it has to cover globs which have embedded , chars. But we don't just want to parse strictly as a glob since we want to allow http urls which don't parse as globs, and possibly some system-dependent file paths. So we parse fairly liberally as a token, but we allow , inside matched {} braces.hNone#$%38( 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 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-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-installRead the user's ~.cabalconfig file. cabal-installGiven the project config,Throws . 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-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(starting directory, or current directory cabal-install cabal.project file name override cabal-install verbosity cabal-install7whether to ignore local project (--ignore-project flag) cabal-install --cabal-config cabal-install with project cabal-installwithout projet cabal-install --ignore-projectiNone #$%&35& 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-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-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-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-install6Try to remove the given targets from the install plan.This is not always possible. 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-install '(improvedPlan, elaboratedPlan, _, _, _)jNone5l 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 problemkNone#$%  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))lNone #$%-+ 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-installBuild things for real.It requires the   gathered by ./ /  None#$%_ 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 projectKPONMLKPONMLmNone #$% 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-install1Get the directory where script builds are cached. CABAL_DIR/script-builds/ 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 CABAL_DIR/script-builds/ 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 CABAL_DIR/script-builds/ 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-installThe base for making a ! for a fake project. It needs a  or  depending on the command. 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 The body of your command action.nNone#$ cabal-installThe test command is very much like build. It brings the install plan up to date, selects that part of the plan needed by the given or implicit test target(s) and then executes the plan. Compared to build the difference is that there's also test targets which are ephemeral.4For more details on how this works, see the module (Distribution.Client.ProjectOrchestration cabal-installThis defines what a  means for the test command. It selects the  s that the 1 refers to, or otherwise classifies the problem.For the test command we select all buildable test-suites, or fail if there are no test-suites or no buildable test-suites. cabal-installFor a  *, check if the component can be selected.For the test command we just need to check it is a test-suite, in addition to the basic checks on being buildable etc.oNone #$%? cabal-installThe run command runs a specified executable-like component, building it first if necessary. The component can be either an executable, a test, or a benchmark. This is particularly useful for passing arguments to exestests(benchs by simply appending them after a --.4For more details on how this works, see the module (Distribution.Client.ProjectOrchestration cabal-install;Used by the main CLI parser as heuristic to decide whether cabal/ was invoked as a script interpreter, i.e. via #! /usr/bin/env cabalor #! /usr/bin/cabal As the first argument passed to cabal5 will be a filepath to the script to be interpreted. See also  cabal-installHandle cabal) invoked as script interpreter, see also First argument is the  to the script to be executed; second argument is a list of arguments to be passed to the script. cabal-installThis defines what a  means for the run command. It selects the  s that the 1 refers to, or otherwise classifies the problem.For the run command we select the exe 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.pNone #$% 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.qNone#$ cabal-installThe haddock command is TODO.4For more details on how this works, see the module (Distribution.Client.ProjectOrchestration cabal-installThis defines what a  means for the haddock command. It selects the  s that the 1 refers to, or otherwise classifies the problem.For the haddock command we select all buildable libraries. Additionally, depending on the  --executables flag we also select all the buildable exes. We do similarly for test-suites, benchmarks and foreign libs. cabal-installFor a  *, check if the component can be selected.For the haddock? command we just need the basic checks on being buildable etc.rcabal-devel@haskell.orgportableNone#$VsNone#$ 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 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.tNone#$ 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.uNone #$% 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-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.vNone #$%&wNone #$%&0xNone#$% 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.ProjectOrchestrationyNone#$ 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.ProjectOrchestrationzNone#${None& cabal-installThe action to perform inside a nix-shell. This is also the action that will be performed immediately if Nix is disabled.|None cabal-installCheck7 represents a function to check some condition on type a. The returned  is % if any part of the condition failed. cabal-installRe-configure the package in the current directory if needed. Deciding when to reconfigure and with which options is convoluted:,If we are reconfiguring, we must always run  configure with the verbosity option we are given; however, that a previous configuration uses a different verbosity setting is not reason enough to reconfigure.The package should be configured to use the same "dist" prefix as given to the build command, otherwise the build will probably fail. Not only does this determine the "dist" prefix setting if we need to reconfigure anyway, but an existing configuration should be invalidated if its "dist" prefix differs.If the package has never been configured (i.e., there is no LocalBuildInfo), we must configure first, using the default options.4If the package has been configured, there will be a LocalBuildInfo=. If there no package description file, we assume that the PackageDescription is up to date, though the configuration may need to be updated for other reasons (see above). If there is a package description file, and it has been modified since the LocalBuildInfo- was generated, then we need to reconfigure.The caller of this function may also have specific requirements regarding the flags the last configuration used. For example,  testAction requires that the package be configured with test suites enabled. The caller may pass the required settings to this function along with a function to check the validity of the saved >; these required settings will be checked first upon determining that a previous configuration exists. cabal-installconfigure action cabal-installVerbosity setting cabal-install "dist" prefix cabal-install(j flag for reinstalling add-source deps. cabal-installCheck that the required flags are set. If they are not set, provide a message explaining the reason for reconfiguration. cabal-installExtra arguments cabal-install Global flags}(c) 2005 David Himmelstrup 2007 Bjorn Bringert 2007-2010 Duncan CouttsBSD-likecabal-devel@haskell.org provisionalportableNonel cabal-installInitial arguments given to  or . cabal-install:Common context for makeInstallPlan and processInstallPlan. cabal-install?Installs the packages needed to satisfy a list of dependencies. cabal-install0Make an install context given install arguments. cabal-installMake an install plan given install context and install arguments. cabal-install8Given an install plan, perform the actual installations. cabal-install2Remove the provided targets from the install plan.~(c) David Himmelstrup 2005 Duncan Coutts 2011BSD-likecabal-devel@gmail.com provisionalportableNone 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.(c) Doug Beardsley 2015BSD-likecabal-devel@gmail.com provisionalportableNone cabal-installEntry point for the  gen-bounds command.cabal-devel@haskell.orgportableNone#$%M 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-installFind all outdated dependencies.None#$%  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-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.          !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""""""""""""""""""""""""""#################$$$$$$$$$$$$$$$$$$%%%%%%&&&&&&&&&&&&&'''''''''''''(((((((((((((((()))))))))))************++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,--------------------------------------.....................////////////////000000000111111111111122222222222                             33333333333333333333333333333333333333333333333333333333344444444444444444444444444444444444444444444444444556677777777777777777777777777777777777777777777777777777777777777777777 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 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 C C C C C C C D DDDDDD D DD DDDD D DDD D D DDD D D D D D D D D D D D D D D D D D DDD D      E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E F G                       H 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 J J J J J J J J J J J J J J J J J J J 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 LLLLLLLLLLLLLLLLLLMMMMMMMMMMMMNNOOOOOPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRSSSSSSSSSSSSSTUUUUUVVVWWWWXXZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\]]]]]]]]]]]]]]]]^^^^^^^^^_YYYYYYYYYYYYYYYYYYYYYYYYYYY````````````````````````````````````````````aaabbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccdddddddddddddddeeeeffffffffffffffffgggggggggggggggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjkkkkkkkkkkkkkkkkkkkkkklllmmmmmmmmmmmmmmmmmmmmnnnnnnnnnooooooooooppppppppppqqqqrrsssstttttttttuuuuuuuuvvvvvwwwwwwwwxxyyyzzz{{{{||||||}}}}}}}~~   LL Z[]`bbb,cabal-install-3.8.1.0-7iNu5HGLMqL9QLfLAUJqbd(Distribution.Client.ProjectOrchestration"Distribution.Client.Compat.PreludeDistribution.Client.UtilsDistribution.Deprecated.ReadPDistribution.Client.IndexUtilsDistribution.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.Process$Distribution.Client.Compat.Semaphore$Distribution.Client.Dependency.Types!Distribution.Client.DistDirLayoutDistribution.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.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.RebuildMonadDistribution.Client.Store)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.NixStyleOptionsDistribution.Client.Manpage"Distribution.Client.InstallSymlinkDistribution.Client.Init'Distribution.Client.ProjectConfig.TypesDistribution.Client.ListDistribution.Client.GetDistribution.Client.Fetch*Distribution.Client.BuildReports.Anonymous'Distribution.Client.BuildReports.Upload(Distribution.Client.BuildReports.Storage$Distribution.Client.Win32SelfUpgradeDistribution.Client.ParseUtils"Distribution.Client.TargetSelector)Distribution.Client.ProjectPlanning.TypesDistribution.Client.SourceFiles%Distribution.Client.ProjectPlanOutput:Distribution.Client.CmdInstall.ClientInstallTargetSelector(Distribution.Deprecated.ViewAsFieldDescrDistribution.Client.ConfigDistribution.Client.Upload Distribution.Client.SetupWrapperDistribution.Client.Configure.Distribution.Client.Sandbox.PackageEnvironmentDistribution.Client.SandboxDistribution.Client.CmdLegacy(Distribution.Client.ProjectConfig.Legacy!Distribution.Client.ProjectConfig#Distribution.Client.ProjectPlanning!Distribution.Client.TargetProblem$Distribution.Client.CmdErrorMessages#Distribution.Client.ProjectBuildingDistribution.Client.ScriptUtilsDistribution.Client.CmdTestDistribution.Client.CmdRunDistribution.Client.CmdListBinDistribution.Client.CmdHaddockDistribution.Client.CmdExecDistribution.Client.CmdBuildDistribution.Client.CmdBenchDistribution.Client.CmdReplDistribution.Client.CmdUpdateDistribution.Client.CmdSdistDistribution.Client.CmdFreeze Distribution.Client.CmdConfigureDistribution.Client.CmdCleanDistribution.Client.NixDistribution.Client.ReconfigureDistribution.Client.InstallDistribution.Client.FreezeDistribution.Client.GenBoundsDistribution.Client.CmdOutdatedDistribution.Client.CmdInstallDistrubution.CompatProcessDistribution.Types.SourceRepo SourceRepoDistribution.Client.Types PackageIndexdependencyCyclesbrokenPackagesdependencyInconsistencies InstallPlan PreExisting InstalledreadProjectConfig"Distribution.Deprecated.ParseUtilsDistribution.Types.LibraryLibrary+Cabal-syntax-3.8.1.0-3wqkBKyVQKyGg3OBBvtt1FDistribution.Types.PackageId PackageIdDistribution.Pretty prettyShowbase Text.Read readMaybeText.ParserCombinators.ReadPReadS$Cabal-3.8.1.0-B0R5uDiDOgc9Mcr4OAtXboDistribution.Simple.Configure getInstalledPackagesMonitorFilesDistribution.Simple.Setup!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 CFLibNameCExeName CTestName CBenchNameRepoTypeDistribution.ParsecexplicitEitherParsec eitherParsec simpleParsecparsecParsec CabalParsingprettyVersionedprettyPrettyDistribution.Utils.Stringtrim3cabal-install-solver-3.8.1.0-DQHDRT4McfjEkCZkJP5jZc)Distribution.Solver.Types.ResolverPackage ConfiguredResolverPackage"Distribution.Solver.Types.Progress foldProgressDoneFailStepProgress+Distribution.Solver.Types.PackageConstraint scopeToplevelPackagePropertyStanzasPackagePropertyFlagsPackagePropertySourcePackagePropertyInstalledPackagePropertyVersionPackagePropertyPackageConstraintdirectory-1.3.6.0System.DirectorysetModificationTimegetSymbolicLinkTargetpathIsSymbolicLinkcreateFileLink/hackage-security-0.6.2.1-AJtdIjhsj9G2iQdBd5f6e8*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$fGenericReportLevelreadProcessWithExitCodeQSemnewQSemwaitQSem signalQSem$fEqQSemPackagesPreferenceDefaultPreferAllLatestPreferAllInstalledPreferLatestForSelectedSolverModular PreSolver AlwaysModular$fParsecPreSolver$fPrettyPreSolver$fStructuredPreSolver$fBinaryPreSolver$fStructuredSolver$fBinarySolver$fShowPackagesPreferenceDefault $fEqSolver $fOrdSolver $fShowSolver$fBoundedSolver $fEnumSolver$fGenericSolver $fEqPreSolver$fOrdPreSolver$fShowPreSolver$fBoundedPreSolver$fEnumPreSolver$fGenericPreSolver ProjectRootProjectRootImplicitProjectRootExplicitCabalDirLayoutcabalStoreDirLayoutcabalLogsDirectoryStoreDirLayoutstoreDirectorystorePackageDirectorystorePackageDBPathstorePackageDBstorePackageDBStackstoreIncomingDirectorystoreIncomingLock DistDirLayoutdistProjectRootDirectorydistProjectFile distDirectorydistBuildDirectorydistBuildRootDirectorydistDownloadSrcDirectorydistUnpackedSrcDirectorydistUnpackedSrcRootDirectorydistProjectCacheFiledistProjectCacheDirectorydistPackageCacheFiledistPackageCacheDirectory distSdistFiledistSdistDirectorydistTempDirectorydistBinDirectory distPackageDB DistDirParamsdistParamUnitIddistParamPackageIddistParamComponentIddistParamComponentNamedistParamCompilerIddistParamPlatformdistParamOptimizationdefaultDistDirLayoutdefaultStoreDirLayoutdefaultCabalDirLayoutmkCabalDirLayout$fEqProjectRoot$fShowProjectRootmaybeDecompress 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 showHashValuereadFileHashValue 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$fShowSavedArgsErrorqueryBootstrapMirrorscreateTarGzFileextractTarGzFilebuildTreeRefTypeCodebuildTreeSnapshotTypeCodeisBuildTreeRefTypeCode 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$fGenericPackageLocationSourcePackageDb packageIndexpackagePreferenceslookupDependencylookupPackageName$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 pkgHashDynExepkgHashFullyStaticExepkgHashGHCiLibpkgHashProfLibpkgHashProfExepkgHashProfLibDetailpkgHashProfExeDetailpkgHashCoveragepkgHashOptimizationpkgHashSplitObjspkgHashSplitSectionspkgHashStripLibspkgHashStripExespkgHashDebugInfopkgHashProgramArgspkgHashExtraLibDirspkgHashExtraFrameworkDirspkgHashExtraIncludeDirspkgHashProgPrefixpkgHashProgSuffixpkgHashPackageDbspkgHashDocumentationpkgHashHaddockHooglepkgHashHaddockHtmlpkgHashHaddockHtmlLocationpkgHashHaddockForeignLibspkgHashHaddockExecutablespkgHashHaddockTestSuitespkgHashHaddockBenchmarkspkgHashHaddockInternalpkgHashHaddockCsspkgHashHaddockLinkedSourcepkgHashHaddockQuickJumppkgHashHaddockContentsPackageSourceHashPackageHashInputs 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 incVersiongetCurrentYearlistFilesInsidelistFilesRecursivesafeReadallPackageSourceFilespackageDirToSdist splitRunArgsrunFieldAnnotationannCommentedOutannCommentLines DefaultPromptOptionalPromptMandatoryPromptIsSimple IsLiterateSeverityLogInfoWarningErrorBreakException InteractivegetLinereadFilegetCurrentDirectorygetHomeDirectorygetDirectoryContents listDirectorydoesDirectoryExist doesFileExistgetEnvironmentputStrputStrLncreateDirectoryremoveDirectory 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$fMonadIORebuildNewStoreEntryOutcomeUseNewStoreEntryUseExistingStoreEntrydoesStoreEntryExistgetStoreEntries newStoreEntry$fEqNewStoreEntryOutcome$fShowNewStoreEntryOutcomeBuildFailureReason 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 checkFetchedcheckRepoTarballFetched 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$fEqUserTargetUserConfigFlagsuserConfigVerbosityuserConfigForceuserConfigAppendLinesActAsSetupFlagsactAsSetupBuildType UploadFlagsuploadCandidate uploadDocuploadUsernameuploadPassworduploadPasswordCmduploadVerbosity IsCandidate IsPublished InstallFlagsinstallDocumentationinstallHaddockIndex installDest installDryRuninstallOnlyDownloadinstallMaxBackjumpsinstallReorderGoalsinstallCountConflictsinstallFineGrainedConflictsinstallMinimizeConflictSetinstallIndependentGoalsinstallShadowPkgsinstallStrongFlagsinstallAllowBootLibInstallsinstallOnlyConstrainedinstallReinstallinstallAvoidReinstallsinstallOverrideReinstallinstallUpgradeDeps installOnlyinstallOnlyDepsinstallIndexStateinstallRootCmdinstallSummaryFileinstallLogFileinstallBuildReportsinstallReportPlanningFailureinstallSymlinkBinDirinstallPerComponentinstallNumJobsinstallKeepGoinginstallRunTestsinstallOfflineMode InfoFlags infoVerbosityinfoPackageDBs ListFlags listInstalledlistSimpleOutputlistCaseInsensitive listVerbositylistPackageDBs listHcPathGetFlags getDestDir getPristine getIndexStategetActiveReposgetSourceRepository getVerbosity ReportFlagsreportUsernamereportPasswordreportVerbosity UpdateFlagsupdateVerbosityupdateIndexState FreezeFlags freezeDryRun freezeTestsfreezeBenchmarks freezeSolverfreezeMaxBackjumpsfreezeReorderGoalsfreezeCountConflictsfreezeFineGrainedConflictsfreezeMinimizeConflictSetfreezeIndependentGoalsfreezeShadowPkgsfreezeStrongFlagsfreezeAllowBootLibInstallsfreezeOnlyConstrainedfreezeVerbosity FetchFlags fetchDeps fetchDryRun fetchSolverfetchMaxBackjumpsfetchReorderGoalsfetchCountConflictsfetchFineGrainedConflictsfetchMinimizeConflictSetfetchIndependentGoalsfetchShadowPkgsfetchStrongFlagsfetchAllowBootLibInstallsfetchOnlyConstrained 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$fGenericBuildTreeRefTypeinitCmdBuildTimeSettingsbuildSettingDryRunbuildSettingOnlyDepsbuildSettingOnlyDownloadbuildSettingSummaryFilebuildSettingLogFilebuildSettingLogVerbositybuildSettingBuildReports!buildSettingReportPlanningFailurebuildSettingSymlinkBinDirbuildSettingNumJobsbuildSettingKeepGoingbuildSettingOfflineModebuildSettingKeepTempFilesbuildSettingRemoteReposbuildSettingLocalNoIndexReposbuildSettingCacheDirbuildSettingHttpTransportbuildSettingIgnoreExpirybuildSettingProgPathExtrabuildSettingHaddockOpenSolverSettingssolverSettingRemoteRepossolverSettingLocalNoIndexRepossolverSettingConstraintssolverSettingPreferencessolverSettingFlagAssignmentsolverSettingFlagAssignmentssolverSettingCabalVersionsolverSettingSolversolverSettingAllowOldersolverSettingAllowNewersolverSettingMaxBackjumpssolverSettingReorderGoalssolverSettingCountConflicts!solverSettingFineGrainedConflicts solverSettingMinimizeConflictSetsolverSettingStrongFlags!solverSettingAllowBootLibInstallssolverSettingOnlyConstrainedsolverSettingIndexStatesolverSettingActiveRepossolverSettingIndependentGoals MapMappend getMapMappendMapLast getMapLast PackageConfigpackageConfigProgramPathspackageConfigProgramArgspackageConfigProgramPathExtrapackageConfigFlagAssignmentpackageConfigVanillaLibpackageConfigSharedLibpackageConfigStaticLibpackageConfigDynExepackageConfigFullyStaticExepackageConfigProfpackageConfigProfLibpackageConfigProfExepackageConfigProfDetailpackageConfigProfLibDetailpackageConfigConfigureArgspackageConfigOptimizationpackageConfigProgPrefixpackageConfigProgSuffixpackageConfigExtraLibDirspackageConfigExtraLibDirsStaticpackageConfigExtraFrameworkDirspackageConfigExtraIncludeDirspackageConfigGHCiLibpackageConfigSplitSectionspackageConfigSplitObjspackageConfigStripExespackageConfigStripLibspackageConfigTestspackageConfigBenchmarkspackageConfigCoveragepackageConfigRelocatablepackageConfigDebugInfopackageConfigDumpBuildInfopackageConfigRunTestspackageConfigDocumentationpackageConfigHaddockHooglepackageConfigHaddockHtml packageConfigHaddockHtmlLocationpackageConfigHaddockForeignLibspackageConfigHaddockExecutablespackageConfigHaddockTestSuitespackageConfigHaddockBenchmarkspackageConfigHaddockInternalpackageConfigHaddockCss packageConfigHaddockLinkedSourcepackageConfigHaddockQuickJumppackageConfigHaddockHscolourCsspackageConfigHaddockContentspackageConfigHaddockForHackagepackageConfigTestHumanLogpackageConfigTestMachineLogpackageConfigTestShowDetailspackageConfigTestKeepTixpackageConfigTestWrapper%packageConfigTestFailWhenNoTestSuitespackageConfigTestTestOptionspackageConfigBenchmarkOptionsProjectConfigProvenanceImplicitExplicitProjectConfigSharedprojectConfigDistDirprojectConfigConfigFileprojectConfigProjectFileprojectConfigIgnoreProjectprojectConfigHcFlavorprojectConfigHcPathprojectConfigHcPkgprojectConfigHaddockIndexprojectConfigPackageDBsprojectConfigRemoteReposprojectConfigLocalNoIndexReposprojectConfigActiveReposprojectConfigIndexStateprojectConfigStoreDirprojectConfigConstraintsprojectConfigPreferencesprojectConfigCabalVersionprojectConfigSolverprojectConfigAllowOlderprojectConfigAllowNewer+projectConfigWriteGhcEnvironmentFilesPolicyprojectConfigMaxBackjumpsprojectConfigReorderGoalsprojectConfigCountConflicts!projectConfigFineGrainedConflicts projectConfigMinimizeConflictSetprojectConfigStrongFlags!projectConfigAllowBootLibInstallsprojectConfigOnlyConstrainedprojectConfigPerComponentprojectConfigIndependentGoalsprojectConfigProgPathExtraProjectConfigBuildOnlyprojectConfigVerbosityprojectConfigDryRunprojectConfigOnlyDepsprojectConfigOnlyDownloadprojectConfigSummaryFileprojectConfigLogFileprojectConfigBuildReports"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$fGenericProjectConfigBuildOnlylistinfoClonePackageExceptionClonePackageNoSourceReposClonePackageNoSourceReposOfKindClonePackageNoRepoTypeClonePackageUnsupportedRepoTypeClonePackageNoRepoLocationClonePackageDestinationExistsClonePackageFailedWithExitCodegetclonePackagesFromSourceRepo $fExceptionClonePackageException$fShowClonePackageException$fEqClonePackageExceptionfetchnewBuildReportcabalInstallIDparseBuildReportparseBuildReportListshowBuildReportBuildLog BuildReportId uploadReportsstoreAnonymous storeLocalfromInstallPlanfromPlanningFailurepossibleSelfUpgradedeleteOldExeFileReadPParserlookpfaileof+++<++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$fGenericTargetImplicitCwdSetupScriptStyleSetupCustomExplicitDepsSetupCustomImplicitDepsSetupNonCustomExternalLibSetupNonCustomInternalLibComponentTargetElaboratedReadyPackage CabalFileText BuildStyleBuildAndInstallBuildInplaceOnlyElaboratedPackagepkgInstalledIdpkgLibDependenciespkgDependsOnSelfLibpkgExeDependenciespkgExeDependencyPathspkgPkgConfigDependenciespkgStanzasEnabledElaboratedComponentcompSolverNamecompComponentNamecompLibDependenciescompLinkedLibDependenciescompExeDependenciescompPkgConfigDependenciescompExeDependencyPathscompOrderLibDependenciesElaboratedPackageOrComponent ElabPackage ElabComponentElaboratedConfiguredPackage elabUnitIdelabComponentIdelabInstantiatedWithelabLinkedInstantiatedWithelabIsCanonicalelabPkgSourceIdelabModuleShapeelabFlagAssignmentelabFlagDefaultselabPkgDescriptionelabPkgSourceLocationelabPkgSourceHashelabLocalToProjectelabBuildStyleelabEnabledSpecelabStanzasAvailableelabStanzasRequestedelabPackageDbselabSetupPackageDBStackelabBuildPackageDBStackelabRegisterPackageDBStackelabInplaceSetupPackageDBStackelabInplaceBuildPackageDBStack!elabInplaceRegisterPackageDBStackelabPkgDescriptionOverrideelabVanillaLib elabSharedLib elabStaticLib elabDynExeelabFullyStaticExe elabGHCiLib elabProfLib elabProfExeelabProfLibDetailelabProfExeDetail elabCoverageelabOptimization elabSplitObjselabSplitSections elabStripLibs elabStripExes elabDebugInfoelabDumpBuildInfoelabProgramPathselabProgramArgselabProgramPathExtraelabConfigureScriptArgselabExtraLibDirselabExtraLibDirsStaticelabExtraFrameworkDirselabExtraIncludeDirselabProgPrefixelabProgSuffixelabInstallDirselabHaddockHoogleelabHaddockHtmlelabHaddockHtmlLocationelabHaddockForeignLibselabHaddockForHackageelabHaddockExecutableselabHaddockTestSuiteselabHaddockBenchmarkselabHaddockInternalelabHaddockCsselabHaddockLinkedSourceelabHaddockQuickJumpelabHaddockHscolourCsselabHaddockContentselabTestMachineLogelabTestHumanLogelabTestShowDetailselabTestKeepTixelabTestWrapperelabTestFailWhenNoTestSuiteselabTestTestOptionselabBenchmarkOptionselabSetupScriptStyleelabSetupScriptCliVersionelabConfigureTargetselabBuildTargetselabTestTargetselabBenchTargetselabReplTargetelabHaddockTargetselabBuildHaddocks 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"argsEquivalentOfGhcEnvironmentFileWithoutProjectTargetSelector WoPackageIdWoPackageComponentWoURI!parseWithoutProjectTargetSelectorwoPackageNameswoPackageTargetswoPackageSpecifiers"$fShowWithoutProjectTargetSelectorviewAsFieldDescrFGSectionDescr fgSectionNamefgSectionGrammar fgSectionGet fgSectionSet SectionDescr sectionName sectionFieldssectionSubsections sectionGet sectionSet sectionEmpty liftFields filterFields mapFieldNamescommandOptionToFieldcommandOptionsToFields liftSection parseFieldsppFields ppSectionparseFieldsAndSectionsppFieldsAndSections parseConfig showConfig SavedConfigsavedGlobalFlagssavedInitFlagssavedInstallFlagssavedClientInstallFlagssavedConfigureFlagssavedConfigureExFlagssavedUserInstallDirssavedGlobalInstallDirssavedUploadFlagssavedReportFlagssavedHaddockFlagssavedTestFlagssavedBenchmarkFlagssavedProjectFlagsbaseSavedConfiginitialSavedConfig getCabalDirdefaultConfigFiledefaultCacheDirdefaultLogsDirdefaultInstallPathdefaultCompilerdefaultUserInstall 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(,)$fHasVerbosityFlagLegacyProjectConfigProjectConfigSkeletonsingletonProjectConfigSkeleton instantiateProjectConfigSkeletonprojectSkeletonImportsparseProjectSkeletoncommandLineFlagsToProjectConfigconvertLegacyGlobalConfigconvertLegacyProjectConfigconvertToLegacyProjectConfigparseLegacyProjectConfigshowLegacyProjectConfigparsePackageLocationTokenQrenderPackageLocationToken$fSemigroupLegacyPackageConfig$fMonoidLegacyPackageConfig$fSemigroupLegacySharedConfig$fMonoidLegacySharedConfig$fSemigroupLegacyProjectConfig$fMonoidLegacyProjectConfig$fShowLegacyProjectConfig$fGenericLegacyProjectConfig$fShowLegacySharedConfig$fGenericLegacySharedConfig$fShowLegacyPackageConfig$fGenericLegacyPackageConfigBadPerPackageCompilerPathsBadPackageLocationMatchBadLocUnexpectedFileBadLocNonexistantFileBadLocDirNoCabalFileBadLocDirManyCabalFilesBadPackageLocationBadPackageLocationFileBadLocGlobEmptyMatchBadLocGlobBadMatchesBadLocUnexpectedUriSchemeBadLocUnrecognisedUriBadLocUnrecognisedBadPackageLocationsProjectPackageLocationProjectPackageLocalCabalFileProjectPackageLocalDirectoryProjectPackageLocalTarballProjectPackageRemoteTarballProjectPackageRemoteRepoProjectPackageNamedBadProjectRootBadProjectRootExplicitFilelookupLocalPackageConfig#projectConfigWithBuilderRepoContext"projectConfigWithSolverRepoContextresolveSolverSettingsresolveBuildTimeSettingsfindProjectRootwithProjectOrGlobalConfigreadProjectLocalExtraConfigreadProjectLocalFreezeConfigshowProjectConfigwriteProjectLocalExtraConfigwriteProjectLocalFreezeConfigwriteProjectConfigFilereadGlobalConfigreportParseResultfindProjectPackagesfetchAndReadSourcePackagescheckBadPerPackageCompilerPaths$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 listPluralrenderListCommaAndrenderListSemiAnd sortGroupOnrenderTargetSelectorrenderSubComponentTargetrenderOptionalStanzaoptionalStanzatargetSelectorPluralPkgstargetSelectorRefersToPkgstargetSelectorFilterrenderComponentNamerenderComponentKindreportTargetProblemsrenderTargetProblemrenderTargetProblemNoneEnabledrenderTargetProblemNoTargetsrenderCannotPruneDependenciesrebuildTargetsDryRun&improveInstallPlanWithUpToDatePackagesrebuildTargets TargetsMapProjectBuildContextelaboratedPlanOriginalelaboratedPlanToExecuteelaboratedSharedpkgsBuildStatus targetsMapProjectBaseContext distDirLayoutcabalDirLayout projectConfig localPackages buildSettingscurrentCommandCurrentCommandInstallCommandHaddockCommand OtherCommandestablishProjectBaseContext#establishProjectBaseContextWithRootwithInstallPlanrunProjectPreBuildPhaserunProjectBuildPhaserunProjectPostBuildPhaseallTargetSelectorsuniqueTargetSelectorsresolveTargetsfilterTargetsKindfilterTargetsKindWithselectBuildableTargetsselectBuildableTargetsWithselectBuildableTargets'selectBuildableTargetsWith'forgetTargetsDetailselectComponentTargetBasicdistinctTargetComponents printPlandieOnBuildFailures establishDummyProjectBaseContextestablishDummyDistDirLayout$fShowCurrentCommand$fEqCurrentCommand TargetContextProjectContext GlobalContext ScriptContextAcceptNoTargetsRejectNoTargetsgetScriptCacheDirectoryRoot getScriptHashgetScriptCacheDirectoryensureScriptCacheDirectorywithContextAndSelectors!updateContextAndWriteProjectFile' updateContextAndWriteProjectFilefakeProjectSourcePackagelSrcpkgDescription$fEqTargetContext$fShowTargetContext$fEqAcceptNoTargets$fShowAcceptNoTargets testActionselectPackageTargetsselectComponentTargetnoTestsProblemnotTestProblemisSubComponentProblem$fEqTestProblem$fShowTestProblem runAction validScript handleShebang noExesProblemmatchesMultipleProblem$fEqRunProblem$fShowRunProblemlistbinCommand listbinActionnoComponentsProblemmultipleTargetsProblemcomponentNotRightKindProblem$fEqListBinProblem$fShowListBinProblem haddockAction execCommand execAction buildAction benchCommand benchActionnoBenchmarksProblemcomponentNotBenchmarkProblem$fEqBenchProblem$fShowBenchProblem replAction$fEqReplProblem$fShowReplProblem$fShowOriginalComponentInfo updateCommand updateAction$fParsecUpdateRequest$fPrettyUpdateRequest$fShowUpdateRequest OutputFormat SourceList TarGzArchive sdistCommand sdistActionpackageToSdist$fShowOutputFormat$fEqOutputFormat freezeActionconfigureActionconfigureAction' cleanAction$fEqCleanFlags findNixExprnixInstantiatenixShell inNixShellCheckrunCheck reconfigure $fMonoidCheck$fSemigroupCheck InstallArgsInstallContextinstallmakeInstallContextmakeInstallPlanprocessInstallPlanpruneInstallPlanfreeze getFreezePkgs genBoundsListOutdatedSettingslistOutdatedIgnorePredlistOutdatedMinorPredoutdatedCommandoutdatedAction listOutdated"$fSemigroupIgnoreMajorVersionBumps$fMonoidIgnoreMajorVersionBumps installActionGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip System.IOprint Data.Tuplefstsnd otherwisemap$GHC.Real fromIntegral realToFrac Control.MonadguardjoinGHC.EnumBoundedmaxBoundminBoundEnum enumFromThenenumFrom enumFromToenumFromThenTofromEnumtoEnumsuccpred GHC.ClassesEq==/= GHC.FloatFloatingacoshatanhasinhtanhcoshsinhatanacosasintancossinlogBase**sqrtlogpiexp Fractionalrecip/ fromRationalIntegraldivMod toIntegerquotRemmoddivquotremMonad>>return>>= Data.DataDataFunctorfmap<$GHC.NumNum- fromIntegernegatesignumabs+*Ordcompare>=<<=>minmaxGHC.ReadReadreadList readsPrecReal toRational RealFloatisIEEEatan2isNegativeZeroisDenormalized isInfiniteisNaN scaleFloat significandexponent encodeFloat decodeFloat floatRange floatRadix floatDigitsRealFracceilingfloorroundproperFractiontruncateGHC.ShowShowshow showsPrecshowListData.Typeable.InternalTypeableControl.Monad.Fail MonadFailfail Data.StringIsString fromString Applicativepure<*><**> Data.FoldableFoldableproductsumminimummaximumelemlengthfoldl'foldlfoldrnullfoldMapData.Traversable Traversable sequenceAtraverse GHC.GenericsGeneric Semigroup<>Monoidmappendmconcatmempty GHC.TypesFalseTrueCharDoubleFloatIntGHC.IntInt8Int16Int32Int64integer-wired-inGHC.Integer.TypeInteger GHC.MaybeMaybeNothingJustOrderingEQGTLTRationalIOWordGHC.WordWord8Word16Word32Word64 Data.EitherEitherLeftRight Data.VoidvacuousabsurdVoidData.List.NonEmptyinitlasttailheadnonEmpty System.Exit exitSuccess exitFailureexitWithunlessfoldMfilterMforData.Functor.IdentityIdentity runIdentityreadIOreadLn appendFileinteract getContentsgetCharputCharGHC.IO.ExceptionioErrorExitCode ExitFailure ExitSuccessGHC.IOevaluatethrowIOcatchFilePath userError IOExceptionIOErrorGHC.Exception.Type Exception fromException toExceptiondisplayException Data.TypeabletypeRepTypeRepData.Functor.ConstConstgetConstfindnotElemallanyorand concatMapconcat sequence_for_ traverse_ Data.OldListunwordswordsunlineslinesunfoldrsortBysort partition interspersenubBynub isSuffixOf isPrefixOf dropWhileEndreadspartitionEitherseither Data.ProxyProxylex readParen GHC.UnicodetoUppertoLowerisUpper isAlphaNumisAlphaisDigitisSpacelcmgcd^^^oddevenGHC.Charchr showParen showStringshowCharshowsShowSunzip3unzipzipWith3zipWithzip3!!reversespansplitAtdroptake dropWhile takeWhilecycle replicaterepeatiteratescanr1scanrscanl1scanl Data.MaybemapMaybe catMaybes listToMaybe maybeToList fromMaybe isNothingisJustmaybe Data.Functionon Data.Functorvoid<$>uncurrycurrysubtractasTypeOfuntil$!flip.constidordapliftM2liftMwhen=<< Alternativesomeempty<|> MonadPlusmplusmzeroNonEmpty:|GHC.Err undefinederrorWithoutStackTraceerror SomeException&&||notbinary-0.8.8.0Data.Binary.ClassBinaryputputListcontainers-0.6.2.1Data.Map.InternalMapData.Set.InternalSetdeepseq-1.4.4.0Control.DeepSeqforcedeepseqNFDatarnfpretty-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.ArrowfirstDistribution.Types.UnitIdUnitIdfilepath-1.4.2.1System.FilePath.Posix takeDrive&Distribution.Solver.Types.PackageIndex removeFileDistribution.Fields.Pretty PrettyFieldDocfindFileaddSourcePackages*Distribution.Solver.Types.ConstraintSourceConstraintSetupCabalMaxVersionbytestring-0.10.10.0 Data.ByteString.Builder.InternalBuilderConstraintScope%Distribution.Solver.Types.PackagePath Qualifier Unambiguous AmbiguousDistribution.Types.VersionVersion TestFlags'Distribution.Solver.Types.SourcePackage SourcePackage"tar-0.5.1.1-FKCqTJLQAlB3TMWNtU7ZbKCodec.Archive.Tar.ReadreadtarEntriesList PackageOrDep lazySequenceRepoKindFSectionUnrecFieldParser showFreeText showToken showFilePathField ParseResult ParseFailedParseOkPWarning UTFWarningPErrorAmbiguousParseNoParse TabsError FromStringLineNo showPWarning parseFailrunPrunElocatedErrorMsg syntaxErrorwarning fieldParsec simpleFieldsimpleFieldParseccommaListFieldParseccommaNewLineListFieldParsecspaceListFieldnewLineListFieldlistFieldWithSep listFieldlistFieldParseclineNo readFieldsparseHaskellString parseTokenQparseOptCommaList readPToMaybeDistribution.Backpack OpenUnitIdelabOrderDependencies intersection PackageIdSet differenceDistribution.Simple.Command OptionField loadRawConfigSetup SetupMethodsetupScriptOptionsDistribution.Types.PackageName PackageNameDistribution.Types.ExecutablesrcpkgDescriptionData.Semigroup.InternalAny