h$o<       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                          !!!!!!!!!!!"""""""""####$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%&&''''''''''''((((((((((((()))))))))))))********** * * * + + + + + + + + + + + + , - - - . / / / / / / 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 22 Safe-InferredBcabal-install-solverLike assert, but only enabled with -fdebug-expensive-assertions. This function can be used for expensive assertions that should only be turned on during testing or debugging. Safe-Inferredl $() *+, -./01 23456789:;&%'<=>? @"#!AUXBCDEFGHIJKVWL\][MNOPQRSTYZhijklmnopqrstuvyxwz{|}~ $() *+, -./01 23456789:;&%'<=>? @"#!AUXBCDEFGHIJKVWL\][MOPQRSTYZhijklmnopqrstuvyxwz{|}~N Safe-Inferredcabal-install-solverConstruct an edge-labeled graph;This is a simple adaptation of the definition in Data.Graph   Safe-InferredS Safe-Inferred567 cabal-install-solverSort the list so that values satisfying the predicate are first.cabal-install-solver>Sort the list so that keys satisfying the predicate are first.cabal-install-solverWill partition the list according to the predicate. If there is any element that satisfies the predicate, then only the elements satisfying the predicate are returned. Otherwise, the rest is returned.cabal-install-solver Variant of ? that takes a predicate on the keys rather than on the values. Safe-Inferred# cabal-install-solver3Version range. Consists of a lower and upper bound.cabal-install-solverPreliminary type for versions.cabal-install-solver#String representation of a version.cabal-install-solver)String representation of a version range.cabal-install-solverUnconstrained version range.cabal-install-solver&Version range fixing a single version.cabal-install-solverIntersect two version ranges.cabal-install-solverUnion of two version ranges.cabal-install-solverSimplify a version range.cabal-install-solver+Checking a version against a version range.   Safe-Inferred567); cabal-install-solver-An association list that is sorted by weight.Each element has a key (k ), value (v), and weight (w). All operations that add elements or modify weights stably sort the elements by weight.cabal-install-solverO(N).cabal-install-solverO(1) . Return True if the  WeightedPSQ contains zero or one elements.cabal-install-solverO(1). Return the elements in order.cabal-install-solver O(N log N).cabal-install-solverO(N). Return the weights in order.cabal-install-solverO(N). Return the keys in order.cabal-install-solverO(N). Return the value associated with the first occurrence of the give key, if it exists.cabal-install-solver O(N log N). Update the weights.cabal-install-solverO(N). Update the values.cabal-install-solverO(N)9. Traverse and update values in some applicative functor.cabal-install-solverO((N + M) log (N + M)). Combine two  WeightedPSQ5s, preserving all elements. Elements from the first  WeightedPSQ come before elements in the second when they have the same weight.cabal-install-solverO(N). Return the prefix of values ending with the first element that satisfies p, or all elements if none satisfy p.   None58/cabal-install-solver(Fine-grained dependencies for a package.Typically used as ComponentDeps [Dependency], to represent the list of dependencies for each named component within a package.cabal-install-solver"Dependency for a single component.cabal-install-solverComponent of a package.cabal-install-solverZip two  together by , using ! as the neutral element when a  is present only in one.cabal-install-solver?Keep only selected components (and their associated deps info).cabal-install-solver2ComponentDeps containing library dependencies onlycabal-install-solver1ComponentDeps containing setup dependencies only.cabal-install-solver%ComponentDeps for installed packages.We assume that installed packages only record their library dependencies.cabal-install-solverAll dependencies of a package.This is just a synonym for  , but perhaps a use of  is more obvious than a use of  0, and moreover this avoids introducing lots of #ifdefs for 7.10 just for the use of  .cabal-install-solver/All dependencies except the setup dependencies.Prior to the introduction of setup dependencies in version 1.24 this would have been _all_ dependencies.cabal-install-solverLibrary dependencies proper only. (Includes dependencies of internal libraries.)cabal-install-solverList componentscabal-install-solverSetup dependencies.cabal-install-solver1Select dependencies satisfying a given predicate.  Safe-Inferred85= cabal-install-solver Source of a PackageConstraint.cabal-install-solverMain config file, which is ~.cabalconfig by default.cabal-install-solverLocal cabal.project filecabal-install-solver5User config file, which is ./cabal.config by default.cabal-install-solver#Flag specified on the command line.cabal-install-solver$Target specified by the user, e.g., cabal install package-0.1.0.0 implies package==0.1.0.0.cabal-install-solverInternal requirement to use installed versions of packages like ghc-prim.cabal-install-solverInternal constraint used by  cabal freeze.cabal-install-solverConstraint specified by a config file, a command line flag, or a user target, when a more specific source is not known.cabal-install-solver.The source of the constraint is not specified.cabal-install-solverAn internal constraint due to compatibility issues with the Setup.hs command line interface requires a minimum lower bound on Cabalcabal-install-solverAn internal constraint due to compatibility issues with the Setup.hs command line interface requires a maximum upper bound on Cabalcabal-install-solverDescription of a .    Safe-Inferred5  Safe-Inferred68cabal-install-solverWhether we prefer an installed version of a package or simply the latest version. None387hcabal-install-solverNote: this is total map.cabal-install-solver+String representation of an OptionalStanza.cabal-install-solverConvert a list of ! into the corresponding Cabal's  + which records what components are enabled.None9Vcabal-install-solver?Subclass of packages that have specific versioned dependencies.So for example a not-yet-configured package has dependencies on version ranges, not specific versions. A configured or an already installed package depends on exact versions. Some operations or data structures (like dependency graphs) only make sense on this subclass of package types.(c) David Himmelstrup 2005, Bjorn Bringert 2007, Duncan Coutts 2008cabal-devel@haskell.orgportableNone58Ccabal-install-solver>The collection of information about packages from one or more  PackageDBs.;It can be searched efficiently by package name and version.cabal-install-solver*Build an index out of a bunch of packages.6If there are duplicates, later ones mask earlier ones.cabal-install-solverMerge two indexes.Packages from the second mask packages of the same exact name (case-sensitively) from the first.cabal-install-solverOverride-merge of two indexes.Packages from the second mask packages of the same exact name (case-sensitively) from the first.cabal-install-solver(Inserts a single package into the index.8This is equivalent to (but slightly quicker than) using " or  with a singleton index.cabal-install-solver(Removes a single package from the index.cabal-install-solverRemoves all packages with this (case-sensitive) name from the index.cabal-install-solver?Removes all packages satisfying this dependency from the index.cabal-install-solver$Get all the packages from the index.cabal-install-solver$Get all the packages from the index.3They are grouped by package name, case-sensitively.cabal-install-solver-Does a lookup by package id (name & version).Since multiple package DBs mask each other case-sensitively by package name, then we get back at most one package.cabal-install-solver-Does a case-sensitive search by package name.cabal-install-solverDoes 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.cabal-install-solver/Does a case-insensitive search by package name.If there is only one package that compares case-insensitively to this name then the search is unambiguous and we get back all versions of that package. If several match case-insensitively but one matches exactly then it is also unambiguous.If however several match case-insensitively and none match exactly then we have an ambiguous result, and we get back all the versions of all the packages. The list of ambiguous results is split by exact package name. So it is a non-empty list of non-empty lists.cabal-install-solver9Does a case-insensitive substring search by package name.That is, all packages that contain the given string in their name.NoneMcabal-install-solverQualified package name.cabal-install-solver9A qualified entity. Pairs a package path with the entity.cabal-install-solver/Qualifier of a package within a namespace (see )cabal-install-solver&Top-level dependency in this namespacecabal-install-solver0Any dependency on base is considered independent*This makes it possible to have base shims.cabal-install-solverSetup dependencyBy rights setup dependencies ought to be nestable; after all, the setup dependencies of a package might themselves have setup dependencies, which are independent from everything else. However, this very quickly leads to infinite search trees in the solver. Therefore we limit ourselves to a single qualifier (within a given namespace).cabal-install-solver3If we depend on an executable from a package (via  build-tools), we should solve for the dependencies of that package separately (since we're not going to actually try to link it.) We qualify for EACH package separately; e.g., Exe pn1 pn2 qualifies the  build-tools dependency on pn2 from package pn1. (If we tracked only pn1, that would require a consistent dependency resolution for all of the depended upon executables from a package; if we tracked only pn2, that would require us to pick only one version of an executable over the entire install plan.)cabal-install-solverTop-level namespacePackage choices in different namespaces are considered completely independent by the solver.cabal-install-solverThe default namespacecabal-install-solver'A namespace for a specific build targetcabal-install-solverA package path consists of a namespace and a package path inside that namespace.cabal-install-solverPretty-prints a qualifier. The result is either empty or ends in a period, so it can be prepended onto a package name.NOTE: the base qualifier is for a dependency _on_ base; the qualifier is there to make sure different dependencies on base are all independent. So we want to print something like "A.base" , where the "A." part is the qualifier and "base"+ is the actual dependency (which, for the Base qualifier, will always be base).cabal-install-solver'Pretty-prints a qualified package name.cabal-install-solver2String representation of a qualified package name.None8T cabal-install-solverA package constraint consists of a scope plus a property that must hold for all packages within that scope.cabal-install-solver6A package property is a logical predicate on packages.cabal-install-solverDetermines to what packages and in what contexts a constraint applies.cabal-install-solverA scope that applies when the given package is used as a build target. In other words, the scope applies iff a goal has a top-level qualifier and its namespace matches the given package name. A namespace is considered to match a package name when it is either the default namespace (for --no-independent-goals) or it is an independent namespace with the given package name (for --independent-goals).cabal-install-solver2The package with the specified name and qualifier.cabal-install-solverThe package with the specified name when it has a setup qualifier.cabal-install-solver=The package with the specified name regardless of qualifier.cabal-install-solverConstructor for a common use case: the constraint applies to the package with the specified name when that package is a top-level dependency in the default namespace.cabal-install-solvercabal-install-solver labeled with its source.None5Z cabal-install-solver1Package instance. A package name and an instance.cabal-install-solver*Instance. A version number and a location.cabal-install-solverLocation. Info about whether a package is installed or not, and where exactly it is located. For installed packages, uniquely identifies the package instance via its  .0TODO: More information is needed about the repo.cabal-install-solverQualified package version.cabal-install-solverA package name.cabal-install-solverUnpacking a package name.cabal-install-solver%String representation of an instance.cabal-install-solver,String representation of a package instance.cabal-install-solverIs the package in the primary group of packages. This is used to determine (1) if we should try to establish stanza preferences for this goal, and (2) whether or not a user specified  --constraint( should apply to this dependency (grep  to see the use sites). In particular this does not include packages pulled in as setup deps.cabal-install-solverIs the package a dependency of a setup script. This is used to establish whether or not certain constraints should apply to this dependency (grep  to see the use sites).cabal-install-solverQualify a target package with its own name so that its dependencies are not required to be consistent with other targets.^_`abfedcggfedcba^`_None[cabal-install-solverA configured package is a package instance together with a flag assignment and complete dependencies.None5a cabal-install-solverValue shown for a flag in a solver log message. The message can refer to only the true choice, only the false choice, or both choices.cabal-install-solverA property of flag and stanza choices that determines whether the choice should be deferred in the solving process.A choice is called weak if we do want to defer it. This is the case for flags that should be implied by what's currently installed on the system, as opposed to flags that are used to explicitly enable or disable some functionality.A choice is called trivial if it clearly does not matter. The special case of triviality we actually consider is if there are no new dependencies introduced by the choice.cabal-install-solverQualified stanza name.cabal-install-solver:Stanza name. Paired with a package name, much like a flag.cabal-install-solverQualified flag name.cabal-install-solverFlag defaults.cabal-install-solverFlag info. Default value, whether the flag is manual, and whether the flag is weak. Manual flags can only be set explicitly. Weak flags are typically deferred by the solver.cabal-install-solverStanza identifier.cabal-install-solverFlag identifier. Just a string.cabal-install-solverFlag name. Consists of a package instance and the flag identifier itself.cabal-install-solver+String representation of a flag-value pair.None5ccabal-install-solverThe type of variables that play a role in the solver. Note that the tree currently does not use this type directly, and rather has separate tree nodes for the different types of variables. This fits better with the fact that in most cases, these have to be treated differently.cabal-install-solver#Extract the package name from a VarNoneiTcabal-install-solverVersion range with an 2 instance.cabal-install-solverMore detailed information about how a conflict set variable caused a conflict. This information can be used to determine whether a second value for that variable would lead to the same conflict.1TODO: Handle dependencies under flags or stanzas.cabal-install-solverThe conflict set variable represents a package which depends on the specified problematic package. For example, the conflict set entry '(P x, GoalConflict y)' means that package x introduced package y, and y led to a conflict.cabal-install-solverThe conflict set variable represents a package with a constraint that excluded the specified package and version. For example, the conflict set entry '(P x, VersionConstraintConflict y (mkVersion [2, 0]))' means that package x's constraint on y excluded y-2.0.cabal-install-solverThe conflict set variable represents a package that was excluded by a constraint from the specified package. For example, the conflict set entry '(P x, VersionConflict y (orLaterVersion (mkVersion [2, 0])))' means that package y's constraint 'x >= 2.0' excluded some version of x.cabal-install-solverAny other conflict.cabal-install-solverThe set of variables involved in a solver conflict, each paired with details about the conflict.None#$5cabal-install-solver/Reason why a goal is being added to a goal set.cabal-install-solverA goal is just a solver variable paired with a reason. The reason is only used for tracing.cabal-install-solverA map containing reverse dependencies between qualified package names.cabal-install-solver(Options for goal qualification (used in ) See also defaultQualifyOptionscabal-install-solverDo we have a version of base relying on another version of base?cabal-install-solverThe reason that a dependency is active. It identifies the package and any flag and stanza choices that introduced the dependency. It contains everything needed for creating ConflictSets or describing conflicts in solver log messages.cabal-install-solverA component that can be depended upon by another package, i.e., a library or an executable.cabal-install-solverAn exposed component within a package. This type is used to represent build-depends and build-tool-depends dependencies.cabal-install-solverA dependency (constraint) associates a package name with a constrained instance. It can also represent other types of dependencies, such as dependencies on language extensions.cabal-install-solver!dependency on a package componentcabal-install-solver"dependency on a language extensioncabal-install-solver dependency on a language versioncabal-install-solver"dependency on a pkg-config packagecabal-install-solverA + labeled with the reason it was introduced. intentionally has no 0 instance because the type variable is used both to record the dependencies as well as who's doing the depending; having a 0 instance makes bugs where we don't distinguish these two far too likely. (By rights # ought to have two type variables.)cabal-install-solverFlagged dependencies can either be plain dependency constraints, or flag-dependent dependency trees.cabal-install-solver4Dependencies which are conditional on a flag choice.cabal-install-solverDependencies which are conditional on whether or not a stanza (e.g., a test suite or benchmark) is enabled.cabal-install-solver9Dependencies which are always enabled, for the component comp.cabal-install-solverFlagged dependencies is the modular solver's view of a packages dependencies: rather than having the dependencies indexed by component, each dependency defines what component it is in.Note that each dependency is associated with a Component. We must know what component the dependencies belong to, or else we won't be able to construct fine-grained reverse dependencies.cabal-install-solverConstrained instance. It represents the allowed instances for a package, which can be either a fixed instance or a version range.cabal-install-solver/Conservatively flatten out flagged dependencies&NOTE: We do not filter out duplicates.cabal-install-solver2Print the reason that a dependency was introduced.cabal-install-solver+Apply built-in rules for package qualifiersAlthough the behaviour of  depends on the , it is important that these  are _static_. Qualification does NOT depend on flag assignment; in other words, it behaves the same no matter which choices the solver makes (modulo the global ); we rely on this in linkDeps (see comment there).NOTE: It's the _dependencies_ of a package that may or may not be independent from the package itself. Package flag choices must of course be consistent.cabal-install-solver*Remove qualifiers from set of dependencies:This is used during link validation: when we link package Q.A to Q'.A, then all dependencies Q.B need to be linked to Q'.B. In order to compute what to link these dependencies to, we need to requalify Q.B to become Q'.B; we do this by first removing all qualifiers and then calling  again.cabal-install-solver(Compute a singleton conflict set from a cabal-install-solver Convert a  to a 5 that can be used when the goal leads to a conflict.cabal-install-solver Convert a  to a  containing the reason that the conflict occurred, namely the conflict set variables caused a conflict by introducing the given package goal. See the documentation for  GoalConflict.This function currently only specifies the reason for the conflict in the simple case where the  does not involve any flags or stanzas. Otherwise, it falls back to calling .cabal-install-solverThis function returns the solver variables responsible for the dependency. It drops the values chosen for flag and stanza variables, which are only needed for log messages.cabal-install-solver Convert a  to a  specifying that the conflict occurred because the conflict set variables introduced a problematic version constraint. See the documentation for VersionConstraintConflict.This function currently only specifies the reason for the conflict in the simple case where the  does not involve any flags or stanzas. Otherwise, it falls back to calling .cabal-install-solver Convert a  to a  specifying that the conflict occurred because the conflict set variables introduced a version of a package that was excluded by a version constraint. See the documentation for VersionConflict.This function currently only specifies the reason for the conflict in the simple case where the  does not involve any flags or stanzas. Otherwise, it falls back to calling .55None567cabal-install-solverFunctor for the tree type. a! is the type of nodes' children. d and c have the same meaning as in .cabal-install-solverInformation about a dependency involved in a conflict, for error messages.cabal-install-solverA package option is a package instance with an optional linking annotationThe modular solver has a number of package goals to solve for, and can only pick a single package version for a single goal. In order to allow to install multiple versions of the same package as part of a single solution the solver uses qualified goals. For example, 0.P and 1.P$ might both be qualified goals for P4, allowing to pick a difference version of package P for 0.P and 1.P.Linking is an essential part of this story. In addition to picking a specific version for 1.P%, the solver can also decide to link 1.P to 0.P! (or vice versa). It means that 1.P and 0.P really must be the very same package (and hence must have the same build time configuration, and their dependencies must also be the exact same).See  7http://www.well-typed.com/blog/2015/03/qualified-goals/ for details.cabal-install-solverType of the search tree. Inlining the choice nodes for now. Weights on package, flag, and stanza choices control the traversal order.%The tree can hold additional data on  nodes (type d) and choice nodes (type c). For example, during the final traversal, choice nodes contain the variables that introduced the choices, and 2 nodes contain the assignments for all variables.TODO: The weight type should be changed from [Double] to Double to avoid giving too much weight to preferences that are applied later.cabal-install-solver2Choose a version for a package (or choose to link)cabal-install-solverChoose a value for a flagThe Bool is the default value.cabal-install-solver(Choose whether or not to enable a stanzacabal-install-solver Choose which choice to make next Invariants:PSQ should never be empty+For each choice we additionally record the  why we are introducing that goal into tree. Note that most of the time we are working with Tree QGoalReason7; in that case, we must have the invariant that the  cached in the ,  or  directly below a 0 node must equal the reason recorded on that  node.cabal-install-solver"We're done -- we found a solution!cabal-install-solver:We failed to find a solution in this path through the treecabal-install-solverDetermines whether a tree is active, i.e., isn't a failure node.cabal-install-solverApproximates the number of active choices that are available in a node. Note that we count goal choices as having one choice, always.cabal-install-solverCatamorphism on trees.cabal-install-solverParamorphism on trees.cabal-install-solverAnamorphism on trees.<<Nonecabal-install-solverWhether a component is made unbuildable by a "buildable: False" field.cabal-install-solver:Whether a component is visible in the current environment.cabal-install-solverInfo associated with each library and executable in a package instance.cabal-install-solverInfo associated with a package instance. Currently, dependencies, component names, flags and failure reasons. The component map records whether any components are unbuildable in the current environment (compiler, os, arch, and global flag constraints). Packages that have a failure reason recorded for them are disabled globally, for reasons external to the solver. We currently use this for shadowing which essentially is a GHC limitation, and for installed packages that are broken.cabal-install-solverAn index contains information about package instances. This is a nested dictionary. Package names are mapped to instances, which in turn is mapped to info.  None(cabal-install-solver2Find and reject any nodes with cyclic dependenciesNone$cabal-install-solver$A (partial) assignment of variables.cabal-install-solverA (partial) package assignment. Qualified package names are associated with instances.cabal-install-solver6Delivers an ordered list of fully configured packages.TODO: This function is (sort of) ok. However, there's an open bug w.r.t. unqualification. There might be several different instances of one package version chosen by the solver, which will lead to clashes.Nonecabal-install-solverValidate linked packages Verify that linked packages haveLinked dependencies,Equal flag assignmentsEqual stanza assignmentsNone~cabal-install-solverPer-package preferences on the version. It is a soft constraint that the DependencyResolver: should try to respect where possible. It consists of an  which says if we prefer versions of packages that are already installed. It also has (possibly multiple) PackageVersionPreferences which are suggested constraints on the version number. The resolver should try to use package versions that satisfy the maximum number of the suggested version constraints.It is not specified if preferences on some packages are more important than others. (c) Iaki Garca Etxebarria 2016BSD-likecabal-devel@haskell.orgportableNone38cabal-install-solver9The list of packages installed in the system visible to  pkg-config6. This is an opaque datatype, to be constructed with  and queried with pkgConfigPkgPresent.cabal-install-solverIf an entry is V, this means that the package seems to be present, but we don't know the exact version (because parsing of the version number failed).cabal-install-solver2For when we could not run pkg-config successfully.cabal-install-solverQuery pkg-config for the list of installed packages, together with their versions. Return a ! encapsulating this information.cabal-install-solver Create a  from a list of (packageName, version) pairs.cabal-install-solverCheck whether a given package range is satisfiable in the given  pkg-config database.cabal-install-solver&Query the version of a package in the  pkg-config database. Nothing6 indicates the package is not in the database, while  Just Nothing indicates that the package is in the database, but its version is not known.cabal-install-solverQuery pkg-config for the locations of pkg-config's package files. Use this to monitor for changes in the pkg-config DB.NoneNcabal-install-solver Interface.  Safe-Inferred`cabal-install-solverA type to represent the unfolding of an expensive long running calculation that may fail. We may get intermediate steps before the final result which may be used to indicate progress and/or logging messages.cabal-install-solver Consume a  calculation. Much like  for lists but with two base cases, one for a final result and one for failure.Eg to convert into a simple T result use: $foldProgress (flip const) Left Right!Nonecabal-install-solverincrease indentation levelcabal-install-solverdecrease indentation levelcabal-install-solverTransforms the structured message type to actual messages (strings).The log contains level numbers, which are useful for any trace that involves backtracking, because only the level numbers will allow to keep track of backjumps.  "Nonew cabal-install-solver as a difference list that allows efficient appends at failures.cabal-install-solverO(1) . Convert a  to a .cabal-install-solverO(N) . Convert a  to a .cabal-install-solverO(1)1. Apply a function to the failure value in a log.cabal-install-solverO(1)>. If the first log leads to failure, continue with the second.cabal-install-solverO(1)1. Create a log with one message before a failure.cabal-install-solverO(1)1. Create a log with one message before a success.cabal-install-solverO(1). Prepend a message to a log.cabal-install-solverO(1) . Prepend the given message and  to the log, and insert % before the failure if the log fails.  #Nonecabal-install-solver.Information about a dependency solver failure.cabal-install-solverPostprocesses a log file. This function discards all log messages and avoids calling ( if the log isn't needed (specified by keepLog), for efficiency.$None8cabal-install-solverShould we consider all packages we know about, or only those that have constraints explicitly placed on them or which are goals?%Nonecabal-install-solver Interface.Takes as an argument a limit on allowed backjumps. If the limit is V, then infinitely many backjumps are allowed. If the limit is 'Just 0', backtracking is completely disabled.&NoneScabal-install-solverInterface to the tree builder. Just takes an index and a list of package names, and computes the initial state and then the tree from there.cabal-install-solverPairs each element of a list with the list resulting from removal of that element from the original list.'None8tcabal-install-solverThe solver can produce references to existing packages or packages we plan to install. Unlike  ConfiguredId we don't yet know the   for planned packages, because it's not the solver's job to compute them.(None8cabal-install-solverAn  is a pre-existing installed package specified by the dependency solver.)None38cabal-install-solverWe sometimes need to override the .cabal file in the tarball with the newer one from the package index.cabal-install-solverA package description along with the location of the package sources.cabal-install-solverNote, this field is lazy, e.g. when reading in hackage index we parse only what we need, not whole index.*None8@cabal-install-solverA  is a package specified by the dependency solver. It will get elaborated into a ConfiguredPackage or even an ElaboratedConfiguredPackage.NB: s are essentially always with UnresolvedPkgLoc, but for symmetry we have the parameter. (Maybe it can be removed.)+None8T cabal-install-solverThe dependency resolver picks either pre-existing installed packages or it picks source packages along with package configuration.This is like the 34 but with fewer cases.  ,None cabal-install-solverA dependency resolver is a function that works out an installation plan given the set of installed and available packages and a set of deps to solve for.The reason for this interface is because there are dozens of approaches to solving the package dependency problem and we want to make it easy to swap in alternatives.  -None cabal-install-solverConvert both the installed package index and the source package index into one uniform solver index.We use allPackagesBySourcePackageId for the installed package index because that returns us several instances of the same package and version in order of preference. This allows us in principle to "shadow" packages if there are several installed packages of the same version. There are currently some shortcomings in both GHC and Cabal in resolving these situations. However, the right thing to do is to fix the problem there, so for now, shadowing is only activated if explicitly requested.  .NoneD cabal-install-solver)Converts from the solver specific result CP QPN into a  5, which can then be converted into the install plan.  /None cabal-install-solverVariables used by the dependency solver. This type is similar to the internal Var type.  0None6 cabal-install-solver*Prefer to link packages whenever possible. cabal-install-solverTraversal that tries to establish various kinds of user constraints. Works by selectively disabling choices that have been ruled out by global user constraints. cabal-install-solverTransformation that tries to enforce the rule that manual flags can only be set by the user.If there are no constraints on a manual flag, this function prunes all but the default value. If there are constraints, then the flag is allowed to have the values specified by the constraints. Note that the type used for flag values doesn't need to be Bool.This function makes an exception for the case where there are multiple goals for a single package (with different qualifiers), and flag constraints for manual flag x only apply to some of those goals. In that case, we allow the unconstrained goals to use the default value for x OR any of the values in the constraints on x (even though the constraints don't apply), in order to allow the unconstrained goals to be linked to the constrained goals. See  ,https://github.com/haskell/cabal/issues/4299. Removing the single instance restriction (SIR) would also fix #4299, so we may want to remove this exception and only let the user toggle manual flags if we remove the SIR.This function does not enforce any of the constraints, since that is done by  . cabal-install-solverRequire installed packages. cabal-install-solverAvoid reinstalls.This is a tricky strategy. If a package version is installed already and the same version is available from a repo, the repo version will never be chosen. This would result in a reinstall (either destructively, or potentially, shadowing). The old instance won't be visible or even present anymore, but other packages might have depended on it.TODO: It would be better to actually check the reverse dependencies of installed packages. If they're not depended on, then reinstalling should be fine. Even if they are, perhaps this should just result in trying to reinstall those other packages as well. However, doing this all neatly in one pass would require to change the builder, or at least to change the goal set after building. cabal-install-solverRequire all packages to be mentioned in a constraint or as a goal. cabal-install-solver+Sort all goals using the provided function. cabal-install-solverReduce the branching degree of the search tree by removing all choices after the first successful choice at each level. The returned tree is the minimal subtree containing the path to the first backjump. cabal-install-solverAlways choose the first goal in the list next, abandoning all other choices.This is unnecessary for the default search strategy, because it descends only into the first goal choice anyway, but may still make sense to just reduce the tree size a bit. cabal-install-solverTransformation that tries to make a decision on base as early as possible by pruning all other goals when base is available. In nearly all cases, there's a single choice for the base package. Also, fixing base early should lead to better error messages. cabal-install-solverDeal with setup and build-tool-depends dependencies after regular dependencies, so we will link setup/exe dependencies against package dependencies when possible cabal-install-solverTransformation that tries to avoid making weak flag choices early. Weak flags are trivial flags (not influencing dependencies) or such flags that are explicitly declared to be weak in the index. cabal-install-solver?Transformation that prefers goals with lower branching degrees.When a goal choice node has at least one goal with zero or one children, this function prunes all other goals. This transformation can help the solver find a solution in fewer steps by allowing it to backtrack sooner when it is exploring a subtree with no solutions. However, each step is more expensive. cabal-install-solver)Enforce ghc's single instance restrictionFrom the solver's perspective, this means that for any package instance (that is, package name + package version) there can be at most one qualified goal resolving to that instance (there may be other goals _linking_ to that instance however).  1None cabal-install-solverWhether to remove all choices after the first successful choice at each level in the search tree. cabal-install-solver'Various options for the modular solver. cabal-install-solverRun all solver phases.)In principle, we have a valid tree after validationPhase, which means that every * node should correspond to valid solution.There is one exception, though, and that is cycle detection, which has been added relatively recently. Cycles are only removed directly before exploration. cabal-install-solversolver parameterscabal-install-solver"all available packages as an indexcabal-install-solveravailable pkg-config pkgscabal-install-solver preferencescabal-install-solverglobal constraintscabal-install-solver global goals  2None cabal-install-solverTies the two worlds together: classic cabal-install vs. the modular solver. Performs the necessary translations before and after.  56789:5;<5;=5>?5@A5@B56C56D56E5FG5FH5IJ5KL5KM5KN5KO8PQ8PR5FS56T56U56V56W5XY5Z[5\]5I^5I_5I`5Ia5bc56d56e56f56g56h56i56j56k5Kl5Km8Pn5op5Iq5Ir56s5tu56v5Fw8Px5yz5I{5o|5I}5~55X5\565555656888885555585I8855555855855888555555555555b5b5b55555>5>5>5>5>5>5>5>5>5>5>5>5555555555555555555555555555555555555555555555555555y5y555555555I5I5I5I5I5I55~5~5~5~5~5;5;5;5;5;5;5;5;5;5;5;5;5;5;5;5;5;5;5;5;5;5;5;555555555555@5@5F565656565656565656565656565656565656565656565656555558P8P8P55555555555555565~5~5~5I5I5I5I5I5o5o5o5o5o5o5o5o5o5o5o5o5o5o5y5y8P8P8P8P8P8P5F5F5F5F565I5I5I5I5I5I5I5I5o5o5o5o5o5o5o5o5o5o5o5o5o5o5o5o5o5o8P5K5K5K5K5K5K55D<<                =                                                                                                          !!!!!!!!!!!"""""""""####$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%& & ' ' ' ' ' ' ' ' ' ' ' ' ( ( ( ( ( ( ( ( ( ( ( ( ( ) ) ) ) ) ) ) ) ) ) ) ) ) * * * * * * * * * * * * * + + + + + + + + + + + + , - - - . / / / / / / 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 5      3cabal-install-solver-3.8.1.0-DQHDRT4McfjEkCZkJP5jZc"Distribution.Solver.Compat.Prelude#Distribution.Solver.Modular.Package(Distribution.Solver.Modular.LabeledGraph#Distribution.Client.Utils.Assertion(Distribution.Solver.Modular.MessageUtilsDistribution.Solver.Modular.PSQ#Distribution.Solver.Modular.Version'Distribution.Solver.Modular.WeightedPSQ'Distribution.Solver.Types.ComponentDeps*Distribution.Solver.Types.ConstraintSourceDistribution.Solver.Types.Flag-Distribution.Solver.Types.InstalledPreference(Distribution.Solver.Types.OptionalStanza*Distribution.Solver.Types.PackageFixedDeps&Distribution.Solver.Types.PackageIndex%Distribution.Solver.Types.PackagePath+Distribution.Solver.Types.PackageConstraint2Distribution.Solver.Types.LabeledPackageConstraint&Distribution.Solver.Modular.Configured Distribution.Solver.Modular.FlagDistribution.Solver.Modular.Var'Distribution.Solver.Modular.ConflictSet&Distribution.Solver.Modular.Dependency Distribution.Solver.Modular.Tree!Distribution.Solver.Modular.Index"Distribution.Solver.Modular.Cycles&Distribution.Solver.Modular.Assignment#Distribution.Solver.Modular.Linking,Distribution.Solver.Types.PackagePreferences%Distribution.Solver.Types.PkgConfigDb$Distribution.Solver.Modular.Validate"Distribution.Solver.Types.Progress#Distribution.Solver.Modular.Message$Distribution.Solver.Modular.RetryLogDistribution.Solver.Modular.Log"Distribution.Solver.Types.Settings#Distribution.Solver.Modular.Explore#Distribution.Solver.Modular.Builder"Distribution.Solver.Types.SolverId+Distribution.Solver.Types.InstSolverPackage'Distribution.Solver.Types.SourcePackage'Distribution.Solver.Types.SolverPackage)Distribution.Solver.Types.ResolverPackage,Distribution.Solver.Types.DependencyResolver+Distribution.Solver.Modular.IndexConversion0Distribution.Solver.Modular.ConfiguredConversion"Distribution.Solver.Types.Variable&Distribution.Solver.Modular.Preference"Distribution.Solver.Modular.SolverDistribution.Solver.Modular InstallPlan PlanPackagebaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip System.IOprint Data.Tuplefstsnd otherwisemap$GHC.Num fromInteger-GHC.Real fromRationalGHC.EnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=negate>>=>>fmapreturnControl.Monad.Failfail Control.Arrowfirst Data.String fromString fromIntegral realToFrac toInteger toRational Control.Monadguard<>memptymappendmconcatjoin<*>pure*>BoundedEnumEq GHC.FloatFloating FractionalIntegralMonad Data.DataDataFunctorNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShowData.Typeable.InternalTypeable MonadFailIsString Applicative Data.FoldableFoldableData.Traversable Traversable GHC.GenericsGeneric SemigroupMonoid GHC.TypesBoolCharDoubleFloatIntGHC.IntInt8Int16Int32Int64integer-wired-inGHC.Integer.TypeInteger GHC.MaybeMaybeOrderingRationalIOWordGHC.WordWord8Word16Word32Word64 Data.EitherEitherFalseNothingJustTrueLeftRightLTEQGT+Cabal-syntax-3.8.1.0-3wqkBKyVQKyGg3OBBvtt1F Distribution.Types.PkgconfigName PkgconfigNameunPkgconfigNamemkPkgconfigNameDistribution.Types.PackageName unPackageName mkPackageNameDistribution.Types.PackageId pkgVersionpkgNamePackageIdentifier PackageId Data.VoidvacuousabsurdVoidData.List.NonEmptyinitlasttailheadnonEmpty System.Exit exitSuccess exitFailureexitWithunlessfoldMfilterMforData.Functor.Identity runIdentityIdentityreadIOreadLn appendFile writeFilereadFileinteract getContentsgetLinegetCharputStrLnputStrputCharGHC.IO.ExceptionioError ExitSuccess ExitFailureExitCodeGHC.IOevaluatethrowIOcatchFilePath userError IOExceptionIOErrorGHC.Exception.Type fromExceptiondisplayException toException Exception Data.TypeabletypeRepTypeRepData.Functor.ConstgetConstConstfindnotElemallanyorand concatMapconcat sequence_for_ traverse_ Data.OldListunwordswordsunlineslinesunfoldrsortBysort partition interspersenubBynub isSuffixOf isPrefixOf dropWhileEnd Text.Read readMaybereadspartitionEitherseither Data.ProxyProxylex readParenText.ParserCombinators.ReadPReadS GHC.UnicodetoUppertoLowerisUpper isAlphaNumisAlphaisDigitisSpacelcmgcd^^^oddevenGHC.Charchr showParen showStringshowCharshowsShowSunzip3unzipzipWith3zipWithzip3!!lookupreversebreakspansplitAtdroptake dropWhile takeWhilecycle replicaterepeatiteratescanr1scanrscanl1scanl Data.MaybemapMaybe catMaybes listToMaybe maybeToList fromMaybe isNothingisJustmaybe Data.Functionon Data.Functorvoid<$>uncurrycurrysubtractasTypeOfuntil$!flip.constidordapliftM2liftMwhen=<<somemany<|>empty Alternativemzeromplus MonadPlus:|NonEmptyStringGHC.Err undefinederrorWithoutStackTraceerror SomeException&&||notbinary-0.8.8.0Data.Binary.ClassgetputListputBinarycontainers-0.6.2.1Data.Map.InternalMapData.Set.InternalSetdeepseq-1.4.4.0Control.DeepSeqforcedeepseqrnfNFDatapretty-1.1.3.6Text.PrettyPrint.HughesPJ<+>Distribution.Compat.ExceptiontryIOcatchIO catchExitDistribution.Utils.Structured StructuredDistribution.Compat.SemigroupgmappendgmemptyDistribution.Compat.NonEmptySet NonEmptySetDistribution.Compat.Prelude<<>> genericRnffoldr1foldl1trace traceShowId traceShowtraverse sequenceAproducttoListsumminimummaximumelemlengthnullfoldl'foldlfoldrfoldMap<*showshowList showsPrecceilingfloorroundtruncateproperFractionisIEEEatan2isNegativeZeroisDenormalized isInfiniteisNaN scaleFloat significandexponent encodeFloat decodeFloat floatRange floatDigits floatRadix readsPrecreadListcompare<<=>maxminsignumabs*+<$divModquotRemmoddivremquotrecip/acoshatanhasinhtanhcoshsinhatanacosasintancossinlogBase**sqrtlogexppi/=fromEnumtoEnumpredsuccminBoundmaxBound PackageName intercalateData.Ord comparing Data.GraphVertexexpensiveAssertGraphgraphFromEdgesgraphFromEdges' transposeGbuildGverticesedges forgetLabelstopSortshowUnsupportedExtensionshowUnsupportedLanguageallKnownExtensionsmostSimilarElement cutoffRange withinRangePSQkeysmapKeys mapWithKeyfromListconssnoccasePSQ sortByKeys maximumBy minimumByprefer preferByKeys filterIfAnyfilterIfAnyByKeys filterKeys isZeroOrOne firstOnlyunion$fEqPSQ $fShowPSQ $fFunctorPSQ $fFoldablePSQ$fTraversablePSQVRVershowVershowVRanyVReqVR.&&..||. simplifyVRcheckVR WeightedPSQweightsmapWeightsWithKeytraverseWithKey takeUntil$fEqWeightedPSQ$fShowWeightedPSQ$fFunctorWeightedPSQ$fFoldableWeightedPSQ$fTraversableWeightedPSQ ComponentDeps ComponentDep Component ComponentLibComponentSubLib ComponentFLib ComponentExe ComponentTestComponentBenchComponentSetupcomponentNameToComponent singletoninsert filterDepsfromLibraryDeps fromSetupDeps fromInstalledflatDeps nonSetupDeps libraryDeps components setupDepsselect$fPrettyComponent$fStructuredComponent$fBinaryComponent$fStructuredComponentDeps$fBinaryComponentDeps$fTraversableComponentDeps$fFoldableComponentDeps$fSemigroupComponentDeps$fMonoidComponentDeps$fShowComponentDeps$fFunctorComponentDeps$fEqComponentDeps$fOrdComponentDeps$fGenericComponentDeps$fShowComponent $fEqComponent$fOrdComponent$fGenericComponentConstraintSourceConstraintSourceMainConfigConstraintSourceProjectConfigConstraintSourceUserConfigConstraintSourceCommandlineFlagConstraintSourceUserTarget%ConstraintSourceNonUpgradeablePackageConstraintSourceFreeze"ConstraintSourceConfigFlagOrTargetConstraintSourceUnknownConstraintSetupCabalMinVersionConstraintSetupCabalMaxVersionshowConstraintSource$fStructuredConstraintSource$fBinaryConstraintSource$fEqConstraintSource$fShowConstraintSource$fGenericConstraintSourceFlagTypeManual Automatic $fEqFlagType$fShowFlagTypeInstalledPreferencePreferInstalled PreferLatest$fShowInstalledPreferenceOptionalStanzaMapOptionalStanzaSetOptionalStanza TestStanzas BenchStanzas showStanza showStanzas enableStanzasoptStanzaSetFromListoptStanzaSetToListoptStanzaSetInsertoptStanzaSetMemberoptStanzaSetSingletonoptStanzaSetIntersectionoptStanzaSetNulloptStanzaSetIsSubsetoptStanzaTabulateoptStanzaIndexoptStanzaLookupoptStanzaKeysFilteredByValue$fStructuredOptionalStanza$fBinaryOptionalStanza$fMonoidOptionalStanzaSet$fSemigroupOptionalStanzaSet$fStructuredOptionalStanzaSet$fBinaryOptionalStanzaSet$fStructuredOptionalStanzaMap$fBinaryOptionalStanzaMap$fEqOptionalStanzaMap$fOrdOptionalStanzaMap$fShowOptionalStanzaMap$fGenericOptionalStanzaMap$fEqOptionalStanzaSet$fOrdOptionalStanzaSet$fShowOptionalStanzaSet$fEqOptionalStanza$fOrdOptionalStanza$fEnumOptionalStanza$fBoundedOptionalStanza$fShowOptionalStanza$fGenericOptionalStanzaPackageFixedDepsdepends&$fPackageFixedDepsInstalledPackageInfo SearchResultNone Unambiguous Ambiguous PackageIndexmergeoverridedeletePackageIddeletePackageNamedeleteDependency allPackagesallPackagesByNameelemByPackageIdelemByPackageNamelookupPackageIdlookupPackageNamelookupDependency searchByNamesearchByNameSubstringsearchWithPredicate$fBinaryPackageIndex$fMonoidPackageIndex$fSemigroupPackageIndex$fEqPackageIndex$fShowPackageIndex$fReadPackageIndex$fFunctorPackageIndex$fGenericPackageIndexQPN QualifiedQ Qualifier QualToplevelQualBase QualSetupQualExe NamespaceDefaultNamespace Independent PackagePath dispQualifierdispQPNshowQPN $fEqQualified$fOrdQualified$fShowQualified$fEqPackagePath$fOrdPackagePath$fShowPackagePath $fEqQualifier$fOrdQualifier$fShowQualifier $fEqNamespace$fOrdNamespace$fShowNamespacePackageConstraintPackagePropertyPackagePropertyVersionPackagePropertyInstalledPackagePropertySourcePackagePropertyFlagsPackagePropertyStanzasConstraintScope ScopeTargetScopeQualifiedScopeAnySetupQualifierScopeAnyQualifier scopeToplevelscopeToPackageNameconstraintScopeMatchesdispPackagePropertydispPackageConstraintshowPackageConstraintpackageConstraintToDependency$fStructuredPackageProperty$fBinaryPackageProperty$fEqPackageConstraint$fShowPackageConstraint$fEqPackageProperty$fShowPackageProperty$fGenericPackageProperty$fEqConstraintScope$fShowConstraintScopeLabeledPackageConstraintunlabelPackageConstraintPIILocInstInRepoQPVPNunPNshowIshowPIinstI primaryPPsetupPPmakeIndependent$fEqPI$fOrdPI$fShowPI $fFunctorPI$fEqI$fOrdI$fShowI$fEqLoc$fOrdLoc $fShowLocCP FlagValueFlagTrue FlagFalseFlagBoth WeakOrTrivialunWeakOrTrivialQSNSNQFNFlagInfoFInfofdefaultfmanualfweakStanzaFlagFNmkFlag showQFNBool showQSNBool showFlagValue showSBoolshowQFNshowQSN $fEqFlagValue$fShowFlagValue $fEqFInfo $fShowFInfo$fEqWeakOrTrivial$fOrdWeakOrTrivial$fShowWeakOrTrivial$fEqSN$fOrdSN$fShowSN $fFunctorSN$fEqFN$fOrdFN$fShowFN $fFunctorFNVarPFSshowVarvarPN$fEqVar$fOrdVar $fShowVar $fFunctorVar ConflictMapOrderedVersionRangeConflict GoalConflictVersionConstraintConflictVersionConflict OtherConflict ConflictSetshowConflictSetshowCSSortedByFrequencyshowCSWithFrequencytoSetunionsdeletesingletonWithConflictsizemember$fOrdOrderedVersionRange$fOrdConflictSet$fEqConflictSet$fShowConflictSet $fEqConflict $fOrdConflict$fShowConflict$fEqOrderedVersionRange$fShowOrderedVersionRange QGoalReason GoalReasonUserGoalDependencyGoalGoal RevDepMapQualifyOptionsQO qoBaseShimqoSetupIndependentDependencyReasonExposedComponent ExposedLib ExposedExe PkgComponentDepExtLangPkgLDep FlaggedDepFlaggedSimple FlaggedDepsCIFixed ConstrainedflattenFlaggedDepsshowDependencyReason qualifyDeps unqualifyDeps goalToVarvarToConflictSetgoalReasonToConflictSet#goalReasonToConflictSetWithConflictdependencyReasonToConflictSet:dependencyReasonToConflictSetWithVersionConstraintConflict0dependencyReasonToConflictSetWithVersionConflict$fEqGoal $fShowGoal $fFunctorGoal$fEqGoalReason$fShowGoalReason$fFunctorGoalReason$fShowQualifyOptions$fFunctorDependencyReason$fEqDependencyReason$fShowDependencyReason $fFunctorDep$fEqPkgComponent$fOrdPkgComponent$fFunctorPkgComponent$fShowPkgComponent$fEqExposedComponent$fOrdExposedComponent$fShowExposedComponent$fEqCI$fShowCI EndoTreeTravTreeTravTreeFPChoiceFFChoiceFSChoiceF GoalChoiceFDoneFFailFConflictingDep FailReasonUnsupportedExtensionUnsupportedLanguageMissingPkgconfigPackage(NewPackageDoesNotMatchExistingConstraintConflictingConstraints$NewPackageIsMissingRequiredComponent%NewPackageHasPrivateRequiredComponent)NewPackageHasUnbuildableRequiredComponentPackageRequiresMissingComponentPackageRequiresPrivateComponent#PackageRequiresUnbuildableComponent CannotInstallCannotReinstall NotExplicitShadowedBrokenUnknownPackageGlobalConstraintVersionGlobalConstraintInstalledGlobalConstraintSourceGlobalConstraintFlag ManualFlagMalformedFlagChoiceMalformedStanzaChoiceEmptyGoalChoiceBackjumpMultipleInstancesDependenciesNotLinkedCyclicDependenciesUnsupportedSpecVerPOptionTreePChoiceFChoiceSChoice GoalChoiceDoneFailWeightinninnMactivezeroOrOneChoicescatatravparaana$fFunctorTreeF$fFoldableTreeF$fTraversableTreeF$fEqFailReason$fShowFailReason$fEqConflictingDep$fShowConflictingDep $fEqPOption $fShowPOption IsBuildable IsVisible ComponentInfo compIsVisiblecompIsBuildablePInfoIndexmkIndexdefaultQualifyOptions$fShowComponentInfo$fEqIsBuildable$fShowIsBuildable $fEqIsVisible$fShowIsVisibledetectCyclesPhase$fIsNodeRevDepMapNode AssignmentA SAssignment FAssignment PAssignmenttoCPs$fShowAssignment$fEqAssignmentvalidateLinking$$fMonadStateValidateStateUpdateState$fFunctorUpdateState$fApplicativeUpdateState$fMonadUpdateState$fShowLinkGroup $fEqLinkGroupPackagePreferences PkgConfigDb NoPkgConfigDbreadPkgConfigDbpkgConfigDbFromListpkgConfigPkgIsPresentpkgConfigDbPkgVersiongetPkgConfigDbDirs$fStructuredPkgConfigDb$fBinaryPkgConfigDb$fShowPkgConfigDb$fGenericPkgConfigDb validateTree$fFunctorValidate$fApplicativeValidate$fMonadValidate"$fMonadReaderValidateStateValidateProgressStep foldProgress$fAlternativeProgress$fApplicativeProgress$fMonadProgress$fFunctorProgressMessageEnterLeaveTryPTryFTrySNextSkipSuccessFailure showMessagesRetryLog toProgress fromProgress mapFailureretryfailWith succeedWith continueWithtryWith SolverFailureExhaustiveSearchBackjumpLimitReacheddisplayLogMessagesSolveExecutablesEnableBackjumpingOnlyConstrainedOnlyConstrainedNoneOnlyConstrainedAllAllowBootLibInstalls StrongFlags ShadowPkgsAvoidReinstallsIndependentGoalsMinimizeConflictSetFineGrainedConflictsCountConflicts ReorderGoals$fStructuredReorderGoals$fBinaryReorderGoals$fStructuredCountConflicts$fBinaryCountConflicts $fStructuredFineGrainedConflicts$fBinaryFineGrainedConflicts$fStructuredMinimizeConflictSet$fBinaryMinimizeConflictSet$fStructuredIndependentGoals$fBinaryIndependentGoals$fStructuredAvoidReinstalls$fBinaryAvoidReinstalls$fStructuredShadowPkgs$fBinaryShadowPkgs$fStructuredStrongFlags$fBinaryStrongFlags $fStructuredAllowBootLibInstalls$fBinaryAllowBootLibInstalls$fParsecOnlyConstrained$fPrettyOnlyConstrained$fStructuredOnlyConstrained$fBinaryOnlyConstrained$fStructuredSolveExecutables$fBinarySolveExecutables$fBooleanFlagSolveExecutables$fEqSolveExecutables$fGenericSolveExecutables$fShowSolveExecutables$fBooleanFlagEnableBackjumping$fEqEnableBackjumping$fGenericEnableBackjumping$fShowEnableBackjumping$fEqOnlyConstrained$fGenericOnlyConstrained$fShowOnlyConstrained!$fBooleanFlagAllowBootLibInstalls$fEqAllowBootLibInstalls$fGenericAllowBootLibInstalls$fShowAllowBootLibInstalls$fBooleanFlagStrongFlags$fEqStrongFlags$fGenericStrongFlags$fShowStrongFlags$fBooleanFlagShadowPkgs$fEqShadowPkgs$fGenericShadowPkgs$fShowShadowPkgs$fBooleanFlagAvoidReinstalls$fEqAvoidReinstalls$fGenericAvoidReinstalls$fShowAvoidReinstalls$fBooleanFlagIndependentGoals$fEqIndependentGoals$fGenericIndependentGoals$fShowIndependentGoals $fBooleanFlagMinimizeConflictSet$fEqMinimizeConflictSet$fGenericMinimizeConflictSet$fShowMinimizeConflictSet!$fBooleanFlagFineGrainedConflicts$fEqFineGrainedConflicts$fGenericFineGrainedConflicts$fShowFineGrainedConflicts$fBooleanFlagCountConflicts$fEqCountConflicts$fGenericCountConflicts$fShowCountConflicts$fBooleanFlagReorderGoals$fEqReorderGoals$fGenericReorderGoals$fShowReorderGoalsbackjumpAndExplore buildTreesplitsSolverId PreExistingId PlannedId solverSrcId solverInstId$fPackageSolverId$fShowSolverId$fStructuredSolverId$fBinarySolverId $fEqSolverId $fOrdSolverId$fGenericSolverIdInstSolverPackageinstSolverPkgIPIinstSolverPkgLibDepsinstSolverPkgExeDeps$fHasUnitIdInstSolverPackage%$fHasMungedPackageIdInstSolverPackage$fPackageInstSolverPackage$fStructuredInstSolverPackage$fBinaryInstSolverPackage$fEqInstSolverPackage$fShowInstSolverPackage$fGenericInstSolverPackagePackageDescriptionOverride SourcePackagesrcpkgPackageIdsrcpkgDescription srcpkgSourcesrcpkgDescrOverride$fPackageSourcePackage$fStructuredSourcePackage$fBinarySourcePackage$fEqSourcePackage$fShowSourcePackage$fGenericSourcePackage SolverPackagesolverPkgSourcesolverPkgFlagssolverPkgStanzassolverPkgLibDepssolverPkgExeDeps$fPackageSolverPackage$fStructuredSolverPackage$fBinarySolverPackage$fEqSolverPackage$fShowSolverPackage$fGenericSolverPackageResolverPackage PreExisting ConfiguredresolverPackageLibDepsresolverPackageExeDeps$fIsNodeResolverPackage$fPackageResolverPackage$fStructuredResolverPackage$fBinaryResolverPackage$fEqResolverPackage$fShowResolverPackage$fGenericResolverPackageDependencyResolverconvPIs$fEqSimpleFlaggedDepKey$fOrdSimpleFlaggedDepKeyconvCPVariable PackageVarFlagVar StanzaVar $fEqVariable$fShowVariable preferLinkedpreferPackagePreferencesenforcePackageConstraintsenforceManualFlagsrequireInstalledavoidReinstallsonlyConstrained sortGoalspruneAfterFirstSuccess firstGoalpreferBaseGoalChoicedeferSetupExeChoicesdeferWeakFlagChoicespreferReallyEasyGoalChoices enforceSingleInstanceRestrictionPruneAfterFirstSuccess SolverConfig reorderGoalscountConflictsfineGrainedConflictsminimizeConflictSetindependentGoals shadowPkgs strongFlagsallowBootLibInstalls maxBackjumpsenableBackjumpingsolveExecutables goalOrdersolverVerbositysolvemodularResolverfold)Distribution.Types.ComponentRequestedSpecComponentRequestedSpecPIdDistribution.Types.UnitIdUnitId