hix 0.6.9 → 0.7.0

raw patch · 185 files changed

+12463/−586 lines, 185 filesdep +bytestringdep +cabal-installdep +cabal-install-solverdep ~hedgehogdep ~optparse-applicativePVP ok

version bump matches the API change (PVP)

Dependencies added: bytestring, cabal-install, cabal-install-solver, containers, exceptions, generics-sop, http-client, http-client-tls, http-types, pretty, these, time, typed-process

Dependency ranges changed: hedgehog, optparse-applicative

API changes (from Hackage documentation)

Files

• hix.cabal +186/−4
• lib/Hix.hs +26/−12
• lib/Hix/Bootstrap.hs +31/−186
• lib/Hix/Cabal.hs +2/−1
• lib/Hix/CabalParsec.hs +48/−0
• lib/Hix/Class/EncodeNix.hs +91/−0
• lib/Hix/Class/Map.hs +715/−0
• lib/Hix/Class/SOP.hs +54/−0
• lib/Hix/Component.hs +5/−9
• lib/Hix/Console.hs +84/−0
• lib/Hix/Data/Bounds.hs +49/−0
• lib/Hix/Data/ComponentConfig.hs +5/−9
• lib/Hix/Data/Dep.hs +59/−0
• lib/Hix/Data/EnvName.hs +15/−0
• lib/Hix/Data/Error.hs +2/−69
• lib/Hix/Data/GhciConfig.hs +2/−1
• lib/Hix/Data/GlobalOptions.hs +28/−0
• lib/Hix/Data/Json.hs +33/−0
• lib/Hix/Data/Monad.hs +51/−0
• lib/Hix/Data/NixExpr.hs +38/−0
• lib/Hix/Data/Options.hs +203/−0
• lib/Hix/Data/OutputFormat.hs +11/−0
• lib/Hix/Data/OutputTarget.hs +11/−0
• lib/Hix/Data/Overrides.hs +43/−0
• lib/Hix/Data/PackageId.hs +32/−0
• lib/Hix/Data/PackageName.hs +55/−0
• lib/Hix/Data/ProjectFile.hs +5/−5
• lib/Hix/Data/Version.hs +64/−0
• lib/Hix/Data/VersionBounds.hs +152/−0
• lib/Hix/Env.hs +8/−12
• lib/Hix/Error.hs +115/−0
• lib/Hix/Ghci.hs +12/−12
• lib/Hix/Hackage.hs +120/−0
• lib/Hix/Json.hs +14/−6
• lib/Hix/Log.hs +61/−0
• lib/Hix/Managed/Build.hs +216/−0
• lib/Hix/Managed/Build/Mutation.hs +77/−0
• lib/Hix/Managed/Build/Single.hs +25/−0
• lib/Hix/Managed/Build/Solve.hs +51/−0
• lib/Hix/Managed/BuildOutput.hs +67/−0
• lib/Hix/Managed/BuildOutput/CommitMsg.hs +32/−0
• lib/Hix/Managed/BuildOutput/GithubActionsPr.hs +58/−0
• lib/Hix/Managed/Bump/App.hs +17/−0
• lib/Hix/Managed/Bump/Candidates.hs +47/−0
• lib/Hix/Managed/Bump/Optimize.hs +126/−0
• lib/Hix/Managed/Cabal/Changes.hs +67/−0
• lib/Hix/Managed/Cabal/Config.hs +35/−0
• lib/Hix/Managed/Cabal/Data/Config.hs +64/−0
• lib/Hix/Managed/Cabal/Data/Packages.hs +23/−0
• lib/Hix/Managed/Cabal/Data/SolveResources.hs +23/−0
• lib/Hix/Managed/Cabal/Data/SolveTarget.hs +36/−0
• lib/Hix/Managed/Cabal/Data/SolverState.hs +83/−0
• lib/Hix/Managed/Cabal/Data/SourcePackage.hs +40/−0
• lib/Hix/Managed/Cabal/Init.hs +85/−0
• lib/Hix/Managed/Cabal/Installed.hs +14/−0
• lib/Hix/Managed/Cabal/Mock.hs +33/−0
• lib/Hix/Managed/Cabal/Mock/InstalledPackage.hs +28/−0
• lib/Hix/Managed/Cabal/Mock/SourcePackage.hs +111/−0
• lib/Hix/Managed/Cabal/Print.hs +26/−0
• lib/Hix/Managed/Cabal/Repo.hs +137/−0
• lib/Hix/Managed/Cabal/Resources.hs +76/−0
• lib/Hix/Managed/Cabal/Solve.hs +83/−0
• lib/Hix/Managed/Cabal/Targets.hs +50/−0
• lib/Hix/Managed/Constraints.hs +37/−0
• lib/Hix/Managed/Data/BuildConfig.hs +22/−0
• lib/Hix/Managed/Data/BuildOutput.hs +44/−0
• lib/Hix/Managed/Data/Bump.hs +18/−0
• lib/Hix/Managed/Data/Constraints.hs +89/−0
• lib/Hix/Managed/Data/CurrentBuild.hs +9/−0
• lib/Hix/Managed/Data/Diff.hs +66/−0
• lib/Hix/Managed/Data/EnvConfig.hs +14/−0
• lib/Hix/Managed/Data/EnvContext.hs +45/−0
• lib/Hix/Managed/Data/EnvRequest.hs +18/−0
• lib/Hix/Managed/Data/EnvResult.hs +14/−0
• lib/Hix/Managed/Data/EnvState.hs +36/−0
• lib/Hix/Managed/Data/Envs.hs +19/−0
• lib/Hix/Managed/Data/Initial.hs +14/−0
• lib/Hix/Managed/Data/Lower.hs +14/−0
• lib/Hix/Managed/Data/LowerConfig.hs +24/−0
• lib/Hix/Managed/Data/ManagedPackage.hs +40/−0
• lib/Hix/Managed/Data/ManagedPackageProto.hs +44/−0
• lib/Hix/Managed/Data/Mutable.hs +251/−0
• lib/Hix/Managed/Data/MutableId.hs +28/−0
• lib/Hix/Managed/Data/Mutation.hs +61/−0
• lib/Hix/Managed/Data/MutationMode.hs +7/−0
• lib/Hix/Managed/Data/MutationState.hs +40/−0
• lib/Hix/Managed/Data/Packages.hs +29/−0
• lib/Hix/Managed/Data/ProcessState.hs +52/−0
• lib/Hix/Managed/Data/ProjectContext.hs +17/−0
• lib/Hix/Managed/Data/ProjectContextProto.hs +29/−0
• lib/Hix/Managed/Data/ProjectResult.hs +11/−0
• lib/Hix/Managed/Data/ProjectState.hs +31/−0
• lib/Hix/Managed/Data/ProjectStateProto.hs +50/−0
• lib/Hix/Managed/Data/Query.hs +15/−0
• lib/Hix/Managed/Data/QueryDep.hs +18/−0
• lib/Hix/Managed/Data/StageContext.hs +17/−0
• lib/Hix/Managed/Data/StageResult.hs +33/−0
• lib/Hix/Managed/Data/StageState.hs +55/−0
• lib/Hix/Managed/Data/StateFileConfig.hs +17/−0
• lib/Hix/Managed/Data/Targets.hs +98/−0
• lib/Hix/Managed/Diff.hs +143/−0
• lib/Hix/Managed/EnvContext.hs +68/−0
• lib/Hix/Managed/EnvRequest.hs +77/−0
• lib/Hix/Managed/EnvResult.hs +122/−0
• lib/Hix/Managed/Flow.hs +144/−0
• lib/Hix/Managed/Handlers/Build.hs +95/−0
• lib/Hix/Managed/Handlers/Build/Prod.hs +188/−0
• lib/Hix/Managed/Handlers/Build/Test.hs +92/−0
• lib/Hix/Managed/Handlers/Cabal.hs +41/−0
• lib/Hix/Managed/Handlers/Cabal/Prod.hs +87/−0
• lib/Hix/Managed/Handlers/Hackage.hs +17/−0
• lib/Hix/Managed/Handlers/Hackage/Prod.hs +16/−0
• lib/Hix/Managed/Handlers/Mutation.hs +14/−0
• lib/Hix/Managed/Handlers/Mutation/Bump.hs +50/−0
• lib/Hix/Managed/Handlers/Mutation/Lower.hs +83/−0
• lib/Hix/Managed/Handlers/Report.hs +13/−0
• lib/Hix/Managed/Handlers/Report/Prod.hs +186/−0
• lib/Hix/Managed/Handlers/Report/Test.hs +27/−0
• lib/Hix/Managed/Handlers/StateFile.hs +15/−0
• lib/Hix/Managed/Handlers/StateFile/Prod.hs +54/−0
• lib/Hix/Managed/Handlers/StateFile/Test.hs +23/−0
• lib/Hix/Managed/Lower/App.hs +41/−0
• lib/Hix/Managed/Lower/Auto.hs +110/−0
• lib/Hix/Managed/Lower/Candidates.hs +196/−0
• lib/Hix/Managed/Lower/Data/LowerMode.hs +32/−0
• lib/Hix/Managed/Lower/Init.hs +94/−0
• lib/Hix/Managed/Lower/Optimize.hs +76/−0
• lib/Hix/Managed/Lower/Stabilize.hs +146/−0
• lib/Hix/Managed/ManagedPackage.hs +27/−0
• lib/Hix/Managed/ManagedPackageProto.hs +27/−0
• lib/Hix/Managed/Overrides.hs +26/−0
• lib/Hix/Managed/Path.hs +14/−0
• lib/Hix/Managed/Process.hs +70/−0
• lib/Hix/Managed/ProjectContext.hs +51/−0
• lib/Hix/Managed/ProjectContextProto.hs +89/−0
• lib/Hix/Managed/ProjectResult.hs +16/−0
• lib/Hix/Managed/ProjectStateProto.hs +141/−0
• lib/Hix/Managed/QueryDep.hs +36/−0
• lib/Hix/Managed/Report.hs +15/−0
• lib/Hix/Managed/StageContext.hs +39/−0
• lib/Hix/Managed/StageResult.hs +54/−0
• lib/Hix/Managed/StageState.hs +28/−0
• lib/Hix/Managed/StateFile.hs +70/−0
• lib/Hix/Managed/UpdateState.hs +67/−0
• lib/Hix/Maybe.hs +20/−0
• lib/Hix/Monad.hs +163/−22
• lib/Hix/New.hs +2/−2
• lib/Hix/NixExpr.hs +126/−0
• lib/Hix/Options.hs +155/−144
• lib/Hix/Optparse.hs +59/−25
• lib/Hix/Orphans/Version.hs +46/−0
• lib/Hix/OutputWriter.hs +64/−0
• lib/Hix/Path.hs +3/−3
• lib/Hix/Preproc.hs +11/−10
• lib/Hix/Pretty.hs +40/−0
• lib/Hix/These.hs +9/−0
• lib/Hix/Trace.hs +25/−0
• lib/Hix/Version.hs +151/−0
• lib/Hix/Zip.hs +15/−0
• test/Hix/Test/BootstrapTest.hs +6/−5
• test/Hix/Test/BoundsTest.hs +52/−0
• test/Hix/Test/CabalFile.hs +1/−0
• test/Hix/Test/CabalTest.hs +15/−10
• test/Hix/Test/GhciTest.hs +13/−12
• test/Hix/Test/Hedgehog.hs +57/−0
• test/Hix/Test/Managed/BuildOutputTest.hs +36/−0
• test/Hix/Test/Managed/Bump/CandidatesTest.hs +106/−0
• test/Hix/Test/Managed/Bump/MutationTest.hs +335/−0
• test/Hix/Test/Managed/DiffTest.hs +54/−0
• test/Hix/Test/Managed/LowerAuto/MutationOptimizeTest.hs +344/−0
• test/Hix/Test/Managed/LowerAuto/MutationStabilizeTest.hs +202/−0
• test/Hix/Test/Managed/LowerInit/MutationTest.hs +438/−0
• test/Hix/Test/Managed/LowerNativeTest.hs +268/−0
• test/Hix/Test/Managed/LowerOptimize/CandidatesTest.hs +99/−0
• test/Hix/Test/Managed/LowerOptimize/MutationTest.hs +154/−0
• test/Hix/Test/Managed/LowerStabilize/MutationTest.hs +141/−0
• test/Hix/Test/Managed/ProjectContextProtoTest.hs +287/−0
• test/Hix/Test/Managed/Run.hs +130/−0
• test/Hix/Test/Managed/UnsafeIsString.hs +73/−0
• test/Hix/Test/ManagedTest.hs +37/−0
• test/Hix/Test/NewTest.hs +4/−3
• test/Hix/Test/PreprocTest.hs +13/−11
• test/Hix/Test/Utils.hs +42/−0
• test/Hix/Test/VersionTest.hs +51/−0
• test/Main.hs +10/−13

@@ -1,11 +1,11 @@ cabal-version: 2.2 --- This file has been generated from package.yaml by hpack version 0.35.2.+-- This file has been generated from package.yaml by hpack version 0.36.0. -- -- see: https://github.com/sol/hpack  name:           hix-version:        0.6.9+version:        0.7.0 synopsis:       Haskell/Nix development build tools description:    See https://hackage.haskell.org/package/hix/docs/Hix.html category:       Build@@ -27,29 +27,171 @@       Hix       Hix.Bootstrap       Hix.Cabal+      Hix.CabalParsec+      Hix.Class.EncodeNix+      Hix.Class.Map+      Hix.Class.SOP       Hix.Compat       Hix.Component+      Hix.Console       Hix.Data.BootstrapProjectConfig+      Hix.Data.Bounds       Hix.Data.ComponentConfig+      Hix.Data.Dep+      Hix.Data.EnvName       Hix.Data.Error       Hix.Data.GhciConfig       Hix.Data.GhciTest+      Hix.Data.GlobalOptions+      Hix.Data.Json+      Hix.Data.Monad       Hix.Data.NewProjectConfig+      Hix.Data.NixExpr+      Hix.Data.Options+      Hix.Data.OutputFormat+      Hix.Data.OutputTarget+      Hix.Data.Overrides+      Hix.Data.PackageId+      Hix.Data.PackageName       Hix.Data.PreprocConfig       Hix.Data.ProjectFile+      Hix.Data.Version+      Hix.Data.VersionBounds       Hix.Env+      Hix.Error       Hix.Ghci+      Hix.Hackage       Hix.Json+      Hix.Log+      Hix.Managed.Build+      Hix.Managed.Build.Mutation+      Hix.Managed.Build.Single+      Hix.Managed.Build.Solve+      Hix.Managed.BuildOutput+      Hix.Managed.BuildOutput.CommitMsg+      Hix.Managed.BuildOutput.GithubActionsPr+      Hix.Managed.Bump.App+      Hix.Managed.Bump.Candidates+      Hix.Managed.Bump.Optimize+      Hix.Managed.Cabal.Changes+      Hix.Managed.Cabal.Config+      Hix.Managed.Cabal.Data.Config+      Hix.Managed.Cabal.Data.Packages+      Hix.Managed.Cabal.Data.SolveResources+      Hix.Managed.Cabal.Data.SolverState+      Hix.Managed.Cabal.Data.SolveTarget+      Hix.Managed.Cabal.Data.SourcePackage+      Hix.Managed.Cabal.Init+      Hix.Managed.Cabal.Installed+      Hix.Managed.Cabal.Mock+      Hix.Managed.Cabal.Mock.InstalledPackage+      Hix.Managed.Cabal.Mock.SourcePackage+      Hix.Managed.Cabal.Print+      Hix.Managed.Cabal.Repo+      Hix.Managed.Cabal.Resources+      Hix.Managed.Cabal.Solve+      Hix.Managed.Cabal.Targets+      Hix.Managed.Constraints+      Hix.Managed.Data.BuildConfig+      Hix.Managed.Data.BuildOutput+      Hix.Managed.Data.Bump+      Hix.Managed.Data.Constraints+      Hix.Managed.Data.CurrentBuild+      Hix.Managed.Data.Diff+      Hix.Managed.Data.EnvConfig+      Hix.Managed.Data.EnvContext+      Hix.Managed.Data.EnvRequest+      Hix.Managed.Data.EnvResult+      Hix.Managed.Data.Envs+      Hix.Managed.Data.EnvState+      Hix.Managed.Data.Initial+      Hix.Managed.Data.Lower+      Hix.Managed.Data.LowerConfig+      Hix.Managed.Data.ManagedPackage+      Hix.Managed.Data.ManagedPackageProto+      Hix.Managed.Data.Mutable+      Hix.Managed.Data.MutableId+      Hix.Managed.Data.Mutation+      Hix.Managed.Data.MutationMode+      Hix.Managed.Data.MutationState+      Hix.Managed.Data.Packages+      Hix.Managed.Data.ProcessState+      Hix.Managed.Data.ProjectContext+      Hix.Managed.Data.ProjectContextProto+      Hix.Managed.Data.ProjectResult+      Hix.Managed.Data.ProjectState+      Hix.Managed.Data.ProjectStateProto+      Hix.Managed.Data.Query+      Hix.Managed.Data.QueryDep+      Hix.Managed.Data.StageContext+      Hix.Managed.Data.StageResult+      Hix.Managed.Data.StageState+      Hix.Managed.Data.StateFileConfig+      Hix.Managed.Data.Targets+      Hix.Managed.Diff+      Hix.Managed.EnvContext+      Hix.Managed.EnvRequest+      Hix.Managed.EnvResult+      Hix.Managed.Flow+      Hix.Managed.Handlers.Build+      Hix.Managed.Handlers.Build.Prod+      Hix.Managed.Handlers.Build.Test+      Hix.Managed.Handlers.Cabal+      Hix.Managed.Handlers.Cabal.Prod+      Hix.Managed.Handlers.Hackage+      Hix.Managed.Handlers.Hackage.Prod+      Hix.Managed.Handlers.Mutation+      Hix.Managed.Handlers.Mutation.Bump+      Hix.Managed.Handlers.Mutation.Lower+      Hix.Managed.Handlers.Report+      Hix.Managed.Handlers.Report.Prod+      Hix.Managed.Handlers.Report.Test+      Hix.Managed.Handlers.StateFile+      Hix.Managed.Handlers.StateFile.Prod+      Hix.Managed.Handlers.StateFile.Test+      Hix.Managed.Lower.App+      Hix.Managed.Lower.Auto+      Hix.Managed.Lower.Candidates+      Hix.Managed.Lower.Data.LowerMode+      Hix.Managed.Lower.Init+      Hix.Managed.Lower.Optimize+      Hix.Managed.Lower.Stabilize+      Hix.Managed.ManagedPackage+      Hix.Managed.ManagedPackageProto+      Hix.Managed.Overrides+      Hix.Managed.Path+      Hix.Managed.Process+      Hix.Managed.ProjectContext+      Hix.Managed.ProjectContextProto+      Hix.Managed.ProjectResult+      Hix.Managed.ProjectStateProto+      Hix.Managed.QueryDep+      Hix.Managed.Report+      Hix.Managed.StageContext+      Hix.Managed.StageResult+      Hix.Managed.StageState+      Hix.Managed.StateFile+      Hix.Managed.UpdateState+      Hix.Maybe       Hix.Monad       Hix.New+      Hix.NixExpr       Hix.Options       Hix.Optparse+      Hix.Orphans.Version+      Hix.OutputWriter       Hix.Path       Hix.Prelude       Hix.Preproc+      Hix.Pretty+      Hix.These+      Hix.Trace+      Hix.Version+      Hix.Zip   hs-source-dirs:       lib   default-extensions:+      StrictData       AllowAmbiguousTypes       ApplicativeDo       BlockArguments@@ -64,6 +206,7 @@       GADTs       LambdaCase       LiberalTypeSynonyms+      MonadComprehensions       MultiWayIf       OverloadedLabels       OverloadedLists@@ -89,19 +232,32 @@       Cabal     , aeson >=2.0 && <2.2     , base ==4.*+    , bytestring+    , cabal-install+    , cabal-install-solver     , casing >=0.1.4 && <0.2+    , containers+    , exceptions ==0.10.*     , exon >=1.4 && <1.7     , extra ==1.7.*     , filepattern ==0.1.*     , generic-lens ==2.2.*+    , generics-sop ==0.5.*+    , http-client ==0.7.*+    , http-client-tls ==0.3.*+    , http-types ==0.12.*     , incipit-base ==0.5.*     , lens >=5.1 && <5.3     , lens-regex-pcre ==1.1.*-    , optparse-applicative ==0.17.*+    , optparse-applicative >=0.17 && <0.19     , path ==0.9.*     , path-io >=1.7 && <1.9+    , pretty     , random ==1.2.*+    , these ==1.2.*+    , time     , transformers+    , typed-process ==0.2.*     , unix   mixins:       base hiding (Prelude)@@ -114,6 +270,7 @@   hs-source-dirs:       app   default-extensions:+      StrictData       AllowAmbiguousTypes       ApplicativeDo       BlockArguments@@ -128,6 +285,7 @@       GADTs       LambdaCase       LiberalTypeSynonyms+      MonadComprehensions       MultiWayIf       OverloadedLabels       OverloadedLists@@ -164,14 +322,34 @@   main-is: Main.hs   other-modules:       Hix.Test.BootstrapTest+      Hix.Test.BoundsTest       Hix.Test.CabalFile       Hix.Test.CabalTest       Hix.Test.GhciTest+      Hix.Test.Hedgehog+      Hix.Test.Managed.BuildOutputTest+      Hix.Test.Managed.Bump.CandidatesTest+      Hix.Test.Managed.Bump.MutationTest+      Hix.Test.Managed.DiffTest+      Hix.Test.Managed.LowerAuto.MutationOptimizeTest+      Hix.Test.Managed.LowerAuto.MutationStabilizeTest+      Hix.Test.Managed.LowerInit.MutationTest+      Hix.Test.Managed.LowerNativeTest+      Hix.Test.Managed.LowerOptimize.CandidatesTest+      Hix.Test.Managed.LowerOptimize.MutationTest+      Hix.Test.Managed.LowerStabilize.MutationTest+      Hix.Test.Managed.ProjectContextProtoTest+      Hix.Test.Managed.Run+      Hix.Test.Managed.UnsafeIsString+      Hix.Test.ManagedTest       Hix.Test.NewTest       Hix.Test.PreprocTest+      Hix.Test.Utils+      Hix.Test.VersionTest   hs-source-dirs:       test   default-extensions:+      StrictData       AllowAmbiguousTypes       ApplicativeDo       BlockArguments@@ -186,6 +364,7 @@       GADTs       LambdaCase       LiberalTypeSynonyms+      MonadComprehensions       MultiWayIf       OverloadedLabels       OverloadedLists@@ -209,15 +388,18 @@   ghc-options: -threaded -rtsopts -with-rtsopts=-N -Wall -Widentities -Wincomplete-uni-patterns -Wmissing-deriving-strategies -Wredundant-constraints -Wunused-type-patterns -Wunused-packages   build-depends:       Cabal+    , aeson >=2.0 && <2.2     , base ==4.*     , exon >=1.4 && <1.7-    , hedgehog >=1.1 && <1.3+    , extra ==1.7.*+    , hedgehog >=1.1 && <1.5     , hix     , incipit-base ==0.5.*     , path ==0.9.*     , path-io >=1.7 && <1.9     , tasty ==1.4.*     , tasty-hedgehog >=1.3 && <1.5+    , these ==1.2.*     , transformers   mixins:       base hiding (Prelude)

@@ -1,26 +1,33 @@ module Hix where  import Hix.Bootstrap (bootstrapProject)-import Hix.Data.Error (+import qualified Hix.Console as Console+import Hix.Console (errorMessage)+import qualified Hix.Data.GlobalOptions+import Hix.Data.GlobalOptions (GlobalOptions (GlobalOptions))+import qualified Hix.Data.Options as Options+import Hix.Data.Options (+  Command (..),+  LowerCommand (LowerAutoCmd, LowerInitCmd, LowerOptimizeCmd, LowerStabilizeCmd),+  Options (Options),+  )+import Hix.Env (printEnvRunner)+import Hix.Error (   Error (..),   printBootstrapError,   printEnvError,+  printError,   printFatalError,   printGhciError,   printNewError,   printPreprocError,   )-import Hix.Env (printEnvRunner) import Hix.Ghci (printGhciCmdline, printGhcidCmdline)-import Hix.Monad (M, runM)+import Hix.Managed.Bump.App (bumpCli)+import Hix.Managed.Lower.App (lowerAutoCli, lowerInitCli, lowerOptimizeCli, lowerStabilizeCli)+import Hix.Monad (M, runMWith) import Hix.New (newProject)-import qualified Hix.Options as Options-import Hix.Options (-  Command (BootstrapCmd, EnvRunner, GhciCmd, GhcidCmd, NewCmd, Preproc),-  GlobalOptions (GlobalOptions),-  Options (Options),-  parseCli,-  )+import Hix.Options (parseCli) import Hix.Preproc (preprocess)  handleError ::@@ -34,9 +41,10 @@   GhciError err -> printGhciError err   NewError err -> printNewError err   BootstrapError err -> printBootstrapError err-  NoMatch msg | fromMaybe False verbose -> printPreprocError msg+  NoMatch msg | verbose -> printPreprocError msg   NoMatch _ -> unit   Fatal err -> printFatalError err+  Client err -> Console.err (errorMessage err)  runCommand :: Command -> M () runCommand = \case@@ -46,8 +54,14 @@   GhciCmd opts -> printGhciCmdline opts   NewCmd opts -> newProject opts.config   BootstrapCmd opts -> bootstrapProject opts.config+  BumpCmd opts -> bumpCli opts+  LowerCmd sub -> case sub of+    LowerInitCmd opts -> lowerInitCli opts+    LowerOptimizeCmd opts -> lowerOptimizeCli opts+    LowerStabilizeCmd opts -> lowerStabilizeCli opts+    LowerAutoCmd opts -> lowerAutoCli opts  main :: IO () main = do   Options global cmd <- parseCli-  leftA (handleError global) =<< runM global.cwd (runCommand cmd)+  leftA (printError global.verbose) =<< runMWith global (runCommand cmd)

@@ -2,7 +2,6 @@  import Control.Monad.Trans.Class (lift) import Control.Monad.Trans.Reader (ask)-import Data.List.NonEmpty ((<|)) import qualified Data.Text as Text import Distribution.Compiler (PerCompilerFlavor (PerCompilerFlavor)) import qualified Distribution.PackageDescription as Cabal@@ -16,10 +15,9 @@   unPackageName,   unUnqualComponentName,   )-import Distribution.Pretty (Pretty, pretty)+import Distribution.Pretty (pretty) import Distribution.Simple (Dependency (Dependency), depVerRange) import Distribution.Types.PackageDescription (license)-import Distribution.Utils.ShortText (ShortText, fromShortText) import qualified Distribution.Verbosity as Cabal import Exon (exon) import Path (Abs, Dir, File, Path, Rel, parent, parseRelFile, relfile, toFilePath, (</>))@@ -28,42 +26,19 @@ import Hix.Compat (readGenericPackageDescription) import qualified Hix.Data.BootstrapProjectConfig import Hix.Data.BootstrapProjectConfig (BootstrapProjectConfig)-import qualified Hix.Data.ComponentConfig-import Hix.Data.ComponentConfig (PackageName (PackageName))-import Hix.Data.Error (pathText, tryIO)+import qualified Hix.Data.Monad (AppResources (cwd))+import Hix.Data.Monad (M (M)) import qualified Hix.Data.NewProjectConfig+import Hix.Data.NixExpr (Expr (ExprAttrs, ExprLit, ExprPrefix, ExprString), ExprAttr (ExprAttr, ExprAttrNil))+import Hix.Data.PackageName (PackageName (PackageName)) import qualified Hix.Data.ProjectFile import Hix.Data.ProjectFile (ProjectFile (ProjectFile), createFile)-import qualified Hix.Monad-import Hix.Monad (Env (Env), M, noteBootstrap)+import Hix.Error (pathText, tryIO)+import Hix.Monad (AppResources (AppResources), noteBootstrap)+import Hix.NixExpr (mkAttrs, multi, multiOrSingle, nonEmptyAttrs, renderRootExpr, single, singleOpt) import qualified Hix.Prelude import Hix.Prelude (Prelude, findPrelude) -data ExprAttr =-  ExprAttr {-    name :: Text,-    value :: Expr-  }-  |-  ExprAttrNil-  deriving stock (Eq, Show, Generic)--data Expr =-  ExprString Text-  |-  ExprLit Text-  |-  ExprList [Expr]-  |-  ExprAttrs [ExprAttr]-  |-  ExprPrefix Text Expr-  deriving stock (Eq, Show, Generic)--exprStrings :: [Text] -> Expr-exprStrings =-  ExprList . fmap ExprString- data CabalInfo =   CabalInfo {     path :: Path Rel Dir,@@ -107,45 +82,6 @@   }   deriving stock (Eq, Show, Generic) -indent ::-  Functor t =>-  Int ->-  t Text ->-  t Text-indent n =-  fmap (Text.replicate n " " <>)--withSemicolon :: NonEmpty Text -> NonEmpty Text-withSemicolon = \case-  e :| [] ->-    [e <> ";"]-  h :| h1 : t -> h <| withSemicolon (h1 :| t)--renderAttrs :: Int -> [ExprAttr] -> [Text]-renderAttrs ind attrs =-  attrs >>= \case-    ExprAttr k v ->-      case renderExpr ind v of-        e :| [] -> [[exon|#{k} = #{e};|]]-        h :| (h1 : t) -> [exon|#{k} = #{h}|] : toList (withSemicolon (h1 :| t))-    ExprAttrNil ->-      []--renderExpr :: Int -> Expr -> NonEmpty Text-renderExpr ind = \case-  ExprString s -> indent ind [[exon|"#{Text.replace "\"" "\\\"" s}"|]]-  ExprLit e -> [e]-  ExprList l -> "[" :| (indent (ind + 2) (toList . renderExpr ind =<< l)) ++ ["]"]-  ExprAttrs a -> case renderAttrs ind a of-    [] -> ["{}"]-    as -> "{" :| indent (ind + 2) as ++ ["}"]-  ExprPrefix p (renderExpr ind -> h :| t) ->-    [exon|#{p} #{h}|] :| t--renderRootExpr :: Expr -> Text-renderRootExpr =-  Text.unlines . toList . renderExpr 0- readCabal ::   Path Abs Dir ->   Path Rel File ->@@ -156,105 +92,15 @@   where     dir = parent path -class RenderCabalOption a where-  renderCabalOption :: a -> Text--instance {-# overlappable #-} Pretty a => RenderCabalOption a where-  renderCabalOption = show . pretty--instance RenderCabalOption ShortText where-  renderCabalOption = toText . fromShortText--instance RenderCabalOption String where-  renderCabalOption = toText--checkEmpty ::-  Text ->-  Expr ->-  ExprAttr-checkEmpty key = \case-  ExprString value | Text.null value ->-    ExprAttrNil-  ExprList value | null value ->-    ExprAttrNil-  value ->-    ExprAttr key value--singleOpt ::-  RenderCabalOption a =>-  Text ->-  (e -> Maybe a) ->-  e ->-  ExprAttr-singleOpt key get entity =-  maybe ExprAttrNil (checkEmpty key . ExprString) (renderCabalOption <$> get entity)--single ::-  RenderCabalOption a =>-  Text ->-  (e -> a) ->-  e ->-  ExprAttr-single key get =-  singleOpt key (Just . get)--multiOpt ::-  RenderCabalOption a =>-  Text ->-  (e -> Maybe [a]) ->-  e ->-  ExprAttr-multiOpt key get entity =-  maybe ExprAttrNil (checkEmpty key . exprStrings) (fmap renderCabalOption <$> get entity)--multi ::-  RenderCabalOption a =>-  Text ->-  (e -> [a]) ->-  e ->-  ExprAttr-multi key get =-  multiOpt key (Just . get)--multiOrSingle ::-  ∀ a e .-  RenderCabalOption a =>-  Text ->-  (e -> [a]) ->-  e ->-  ExprAttr-multiOrSingle key get entity =-  check (renderCabalOption <$> get entity)-  where-    check :: [Text] -> ExprAttr-    check [] = ExprAttrNil-    check [sing] = ExprAttr key (ExprString sing)-    check values = ExprAttr key (exprStrings values)--mkAttrs :: [e -> ExprAttr] -> e -> [ExprAttr]-mkAttrs a e =-  (fmap ($ e) a)--notNil :: ExprAttr -> Bool-notNil = \case-  ExprAttrNil -> False-  _ -> True--nonEmptyAttrs :: Text -> [ExprAttr] -> ExprAttr-nonEmptyAttrs key =-  filter notNil >>> \case-    [] -> ExprAttrNil-    as -> ExprAttr key (ExprAttrs as)- -- TODO extract version and put it in a file knownPackageKeys :: PackageDescription -> [ExprAttr] knownPackageKeys =   mkAttrs [     single "author" (.author),-    single "build-type" buildType,+    single "build-type" (pretty . buildType),     single "copyright" (.copyright),-    single "license" license,-    singleOpt "license-file" (head . licenseFiles),+    single "license" (pretty . license),+    singleOpt "license-file" (fmap pretty . head . licenseFiles),     single "version" (.package.pkgVersion)   ] @@ -282,17 +128,17 @@   where     vals =       mkAttrs [-        multi "dependencies" (const deps),-        multi "default-extensions" (.defaultExtensions),-        multiOrSingle "source-dirs" (.hsSourceDirs),-        singleOpt "language" (.defaultLanguage),-        multi "ghc-options" (filter notDefaultGhcOption . ghcFlavour . (.options)),+        multi "dependencies" (fmap pretty . const deps),+        multi "default-extensions" (fmap pretty . (.defaultExtensions)),+        multiOrSingle "source-dirs" (fmap pretty . (.hsSourceDirs)),+        singleOpt "language" (fmap pretty . (.defaultLanguage)),+        multi "ghc-options" (fmap (ExprString . toText) . filter notDefaultGhcOption . ghcFlavour . (.options)),         misc       ] info      misc e =       nonEmptyAttrs "component" (mkAttrs [-        multi "other-modules" (.otherModules)+        multi "other-modules" (fmap pretty . (.otherModules))       ] e)      (preludeWithVersion, deps)@@ -323,7 +169,7 @@   convertComponent Library lib.libBuildInfo extra   where     extra = mkAttrs [-      multi "reexported-modules" (.reexportedModules)+      multi "reexported-modules" (fmap pretty . (.reexportedModules))       ] lib  convertExecutable :: UnqualComponentName -> Cabal.Executable -> HixComponent@@ -373,8 +219,8 @@     preludePackageAttrs p       | Just dep <- p.dep =         ExprAttrs [-          (ExprAttr "name" (ExprString (toText p.prelude.preludePackage))),-          (ExprAttr "version" (ExprString (show (pretty (depVerRange dep)))))+          ExprAttr "name" (ExprString (toText p.prelude.preludePackage)),+          ExprAttr "version" (ExprString (show (pretty (depVerRange dep))))         ]       | otherwise = ExprString (toText p.prelude.preludePackage)     key = case special of@@ -388,34 +234,33 @@  flakePackage :: HixPackage -> ExprAttr flakePackage pkg =-  ExprAttr name attrs+  ExprAttr (coerce pkg.name) attrs   where-    attrs = ExprAttrs (src : pkg.description : (ExprAttr "cabal" cabalConfig : comps))-    name = pkg.name.unPackageName+    attrs = ExprAttrs (src : pkg.description : ExprAttr "cabal" cabalConfig : comps)     src = ExprAttr "src" (ExprLit [exon|./#{Text.dropWhileEnd ('/' ==) (pathText pkg.src)}|])-    cabalConfig = ExprAttrs (pkg.known <> (if null pkg.meta then [] else [ExprAttr "meta" (ExprAttrs pkg.meta)]))+    cabalConfig = ExprAttrs (pkg.known <> [ExprAttr "meta" (ExprAttrs pkg.meta) | not (null pkg.meta)])     comps = renderComponent <$> pkg.components  mainPackage :: [HixPackage] -> ExprAttr mainPackage = \case-  pkg : _ : _ -> ExprAttr "main" (ExprString pkg.name.unPackageName)+  pkg : _ : _ -> ExprAttr "main" (ExprString (coerce pkg.name))   _ -> ExprAttrNil  flake :: BootstrapProjectConfig -> [HixPackage] -> Expr flake conf pkgs =   ExprAttrs [-    (ExprAttr "description" (ExprString "A Haskell project")),-    (ExprAttr "inputs.hix.url" (ExprString conf.hixUrl.unHixUrl)),-    (ExprAttr "outputs" (ExprPrefix "{hix, ...}: hix.lib.flake" (ExprAttrs [-      (ExprAttr "packages" (ExprAttrs (flakePackage <$> pkgs))),+    ExprAttr "description" (ExprString "A Haskell project"),+    ExprAttr "inputs.hix.url" (ExprString conf.hixUrl.unHixUrl),+    ExprAttr "outputs" (ExprPrefix "{hix, ...}: hix.lib.flake" (ExprAttrs [+      ExprAttr "packages" (ExprAttrs (flakePackage <$> pkgs)),       mainPackage pkgs-    ])))+    ]))   ]  bootstrapFiles :: BootstrapProjectConfig -> M [ProjectFile] bootstrapFiles conf = do-  Env {cwd} <- ask-  cabals <- paths =<< lift (tryIO (getDirectoryFilesIgnore (toFilePath cwd) ["**/*.cabal"] ["dist-newstyle/**"]))+  AppResources {cwd} <- M ask+  cabals <- paths =<< M (lift (tryIO (getDirectoryFilesIgnore (toFilePath cwd) ["**/*.cabal"] ["dist-newstyle/**"])))   pkgs <- fmap convert <$> traverse (readCabal cwd) cabals   pure [     ProjectFile {path = [relfile|flake.nix|], content = renderRootExpr (flake conf pkgs)}

@@ -29,7 +29,8 @@ import System.IO.Error (tryIOError)  import Hix.Compat (readGenericPackageDescription)-import Hix.Data.Error (Error (..), pathText, sourceError)+import Hix.Data.Error (Error (..))+import Hix.Error (pathText, sourceError)  noMatch :: Text -> Path b File -> ExceptT Error IO a noMatch reason source =

@@ -0,0 +1,48 @@+module Hix.CabalParsec where++import Distribution.Parsec (Parsec, eitherParsec)+import Exon (exon)+import Type.Reflection (typeRep)++import Hix.Data.Monad (M)+import Hix.Monad (eitherClient)++eitherParsecFor ::+  Parsec b =>+  ToString a =>+  String ->+  a ->+  Either String b+eitherParsecFor desc spec =+  first errorMessage (eitherParsec s)+  where+    errorMessage err = error [exon|parsing #{desc} "#{s}": #{err}|]+    s = toString spec++unsafeParsecFor ::+  Parsec b =>+  ToString a =>+  String ->+  a ->+  b+unsafeParsecFor desc spec =+  either error id (eitherParsecFor desc spec)++unsafeParsec ::+  ∀ a b .+  Parsec b =>+  Typeable b =>+  ToString a =>+  a ->+  b+unsafeParsec =+  unsafeParsecFor (show (typeRep @b))++parsecM ::+  Parsec b =>+  ToString a =>+  String ->+  a ->+  M b+parsecM desc spec =+  eitherClient (first toText (eitherParsecFor desc spec))

@@ -0,0 +1,91 @@+module Hix.Class.EncodeNix where++import qualified Data.Map.Strict as Map+import Distribution.Pretty (Pretty (pretty))+import Distribution.Utils.ShortText (ShortText, fromShortText)+import Distribution.Version (Version, VersionRange, simplifyVersionRange)+import Generics.SOP (All2, K (K), SListI2, hcmap, hcollapse)+import Text.PrettyPrint (Doc)++import Hix.Class.SOP (Field (Field), FieldK (FieldK), ToFields (toFields))+import Hix.Data.NixExpr (Expr (..), ExprAttr (ExprAttr), ViaPretty (ViaPretty), exprBool, exprShow)++type EncodeField :: FieldK -> Constraint+class EncodeField field where+  encodeField :: Field field -> ExprAttr++instance (+    KnownSymbol name,+    EncodeNix a+  ) => EncodeField ('FieldK name a) where+    encodeField (Field a) =+      ExprAttr (toText (symbolVal (Proxy @name))) (encodeNix a)++class EncodeProd a where+  encodeProd :: a -> Expr++instance (+    ToFields a fields,+    All2 EncodeField fields,+    SListI2 fields+  ) => EncodeProd a where+    encodeProd =+      ExprAttrs .+      hcollapse .+      hcmap (Proxy @EncodeField) (K . encodeField) .+      toFields++class EncodeNixKey a where+  encodeNixKey :: a -> Text++instance EncodeNixKey Text where+  encodeNixKey = id++class EncodeNix a where+  encodeNix :: a -> Expr+  default encodeNix :: EncodeProd a => a -> Expr+  encodeNix = encodeProd++instance EncodeNix Expr where+  encodeNix = id++instance EncodeNix Bool where+  encodeNix = exprBool++instance EncodeNix Int where+  encodeNix = exprShow++instance EncodeNix Version where+  encodeNix = encodeNix . pretty++instance EncodeNix VersionRange where+  encodeNix = encodeNix . pretty . simplifyVersionRange++instance EncodeNix a => EncodeNix (Maybe a) where+  encodeNix = \case+    Just a -> encodeNix a+    Nothing -> ExprNull++instance EncodeNix a => EncodeNix [a] where+  encodeNix = ExprList . fmap encodeNix++instance EncodeNix a => EncodeNix (NonEmpty a) where+  encodeNix = ExprList . toList . fmap encodeNix++instance (+    EncodeNixKey k,+    EncodeNix v+  ) => EncodeNix (Map k v) where+    encodeNix = ExprAttrs . fmap (uncurry ExprAttr . bimap encodeNixKey encodeNix) . Map.toList++instance EncodeNix Doc where+  encodeNix = ExprString . show++instance EncodeNix Text where+  encodeNix = ExprString++instance EncodeNix ShortText where+  encodeNix = encodeNix . toText . fromShortText++instance Pretty a => EncodeNix (ViaPretty a) where+  encodeNix (ViaPretty a) = encodeNix (pretty a)

@@ -0,0 +1,715 @@+module Hix.Class.Map where++import qualified Data.Map.Merge.Strict as Map+import Data.Map.Merge.Strict (+  SimpleWhenMatched,+  SimpleWhenMissing,+  WhenMatched,+  WhenMissing,+  dropMissing,+  mapMissing,+  preserveMissing,+  zipWithMatched,+  )+import qualified Data.Map.Strict as Map+import Distribution.Pretty (Pretty (pretty))+import Exon (exon)+import qualified Text.PrettyPrint as PrettyPrint+import Text.PrettyPrint (Doc, comma, hang, punctuate, sep, vcat, (<+>))++import Hix.Data.Monad (M)+import Hix.Monad (noteFatal)++data LookupMonoid+data LookupMaybe+data LookupFatal++type NMap :: Type -> Type -> Type -> Type -> Constraint+class (Ord k, Coercible map (Map k v)) => NMap map k v sort | map -> k v sort where+  nGet :: map -> Map k v+  nGet = coerce++lookupError ::+  ∀ k v .+  Show k =>+  Text ->+  k ->+  Maybe v ->+  M v+lookupError thing k =+  noteFatal [exon|No such #{thing}: #{show k}|]++nFatal ::+  ∀ map k v sort .+  Show k =>+  NMap map k v sort =>+  Text ->+  k ->+  map ->+  M v+nFatal thing k m =+  lookupError thing k (nGet m Map.!? k)++type NLookup :: Type -> Type -> Type -> Type -> Constraint+class NLookup sort k v l | sort v -> l where+  nLookup :: k -> Maybe v -> l++instance Monoid v => NLookup LookupMonoid k v v where+  nLookup _ = fold++instance NLookup LookupMaybe k v (Maybe v) where+  nLookup _ = id++instance Show k => NLookup LookupFatal k v (Text -> M v) where+  nLookup k v thing = lookupError thing k v++(!?) ::+  ∀ map k v sort .+  NMap map k v sort =>+  map ->+  k ->+  Maybe v+(!?) m k = nGet m Map.!? k++infixl !?++(!!) ::+  ∀ map k v sort l .+  NMap map k v sort =>+  NLookup sort k v l =>+  map ->+  k ->+  l+(!!) m k = nLookup @sort @k @v @l k (m !? k)++infixl !!++nInsert ::+  ∀ map k v sort .+  NMap map k v sort =>+  k ->+  v ->+  map ->+  map+nInsert k v m =+  coerce (Map.insert k v (nGet m))++nUpdate ::+  ∀ map k v sort l .+  NMap map k v sort =>+  NLookup sort k v l =>+  k ->+  map ->+  (l -> v) ->+  map+nUpdate k m f =+  nInsert k (f (m !! k)) m++nUpdateWith ::+  ∀ map k v sort l .+  NMap map k v sort =>+  NLookup sort k v l =>+  k ->+  (l -> v) ->+  map ->+  map+nUpdateWith k =+  flip (nUpdate k)++nAdjust ::+  ∀ map k v sort .+  NMap map k v sort =>+  k ->+  map ->+  (v -> v) ->+  map+nAdjust k m f =+  nVia (Map.adjust f k) m++nVia ::+  NMap map1 k1 v1 s1 =>+  NMap map2 k2 v2 s2 =>+  (Map k1 v1 -> Map k2 v2) ->+  map1 ->+  map2+nVia =+  coerce++nViaA ::+  Applicative m =>+  NMap map1 k1 v1 s1 =>+  NMap map2 k2 v2 s2 =>+  (Map k1 v1 -> m (Map k2 v2)) ->+  map1 ->+  m map2+nViaA f m =+  coerce <$> f (coerce m)++nMapKeys ::+  NMap map1 k1 v sort1 =>+  NMap map2 k2 v sort2 =>+  (k1 -> k2) ->+  map1 ->+  map2+nMapKeys f =+  nVia (Map.mapKeys f)++nMap ::+  NMap map1 k v1 sort1 =>+  NMap map2 k v2 sort2 =>+  (v1 -> v2) ->+  map1 ->+  map2+nMap f =+  coerce . fmap f . nGet++nMap1 ::+  ∀ map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2' .+  NMap map1 k map1' s1 =>+  NMap map2 k map2' s2 =>+  NMap map1' k' v1 s1' =>+  NMap map2' k' v2 s2' =>+  (v1 -> v2) ->+  map1 ->+  map2+nMap1 =+  nMap . nMap++nMapWithKey ::+  NMap map1 k v1 sort1 =>+  NMap map2 k v2 sort2 =>+  (k -> v1 -> v2) ->+  map1 ->+  map2+nMapWithKey f =+  coerce . Map.mapWithKey f . nGet++nMapWithKey1 ::+  ∀ map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2' .+  NMap map1 k map1' s1 =>+  NMap map2 k map2' s2 =>+  NMap map1' k' v1 s1' =>+  NMap map2' k' v2 s2' =>+  (k -> k' -> v1 -> v2) ->+  map1 ->+  map2+nMapWithKey1 f =+  nMapWithKey \ k -> nMapWithKey (f k)++nTransform ::+  NMap map1 k1 v1 sort1 =>+  NMap map2 k2 v2 sort2 =>+  (k1 -> v1 -> (k2, v2)) ->+  map1 ->+  map2+nTransform f =+  coerce .+  Map.fromList .+  fmap (uncurry f) .+  Map.toList .+  nGet++nTransformMaybe ::+  NMap map1 k1 v1 sort1 =>+  NMap map2 k2 v2 sort2 =>+  (k1 -> v1 -> Maybe (k2, v2)) ->+  map1 ->+  map2+nTransformMaybe f =+  coerce .+  Map.fromList .+  mapMaybe (uncurry f) .+  Map.toList .+  nGet++nMapMaybe ::+  NMap map1 k v1 sort1 =>+  NMap map2 k v2 sort2 =>+  (v1 -> Maybe v2) ->+  map1 ->+  map2+nMapMaybe f =+  coerce . Map.mapMaybeWithKey (const f) . nGet++nMapMaybe1 ::+  ∀ map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2' .+  NMap map1 k map1' s1 =>+  NMap map2 k map2' s2 =>+  NMap map1' k' v1 s1' =>+  NMap map2' k' v2 s2' =>+  (v1 -> Maybe v2) ->+  map1 ->+  map2+nMapMaybe1 =+  nMap . nMapMaybe++nMapMaybeWithKey ::+  NMap map1 k v1 sort1 =>+  NMap map2 k v2 sort2 =>+  (k -> v1 -> Maybe v2) ->+  map1 ->+  map2+nMapMaybeWithKey f =+  coerce .+  Map.mapMaybeWithKey f .+  nGet++nMapMaybeWithKey1 ::+  ∀ map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2' .+  NMap map1 k map1' s1 =>+  NMap map2 k map2' s2 =>+  NMap map1' k' v1 s1' =>+  NMap map2' k' v2 s2' =>+  (k' -> v1 -> Maybe v2) ->+  map1 ->+  map2+nMapMaybeWithKey1 =+  nMap . nMapMaybeWithKey++nCatMaybes ::+  NMap map1 k (Maybe v) sort1 =>+  NMap map2 k v sort2 =>+  map1 ->+  map2+nCatMaybes =+  nMapMaybe id++nFilter ::+  ∀ map k v sort .+  NMap map k v sort =>+  (v -> Bool) ->+  map ->+  map+nFilter =+  nVia . Map.filter++nFilter1 ::+  ∀ map map' k k' v s s' .+  NMap map k map' s =>+  NMap map' k' v s' =>+  (v -> Bool) ->+  map ->+  map+nFilter1 =+  nMap . nFilter++nPrettyWith ::+  Pretty k =>+  NMap map k v sort =>+  (v -> Doc) ->+  map ->+  Doc+nPrettyWith prettyV (nGet -> m) =+  sep (punctuate comma (assoc <$> Map.toList m))+  where+    assoc (k, v) = pretty k <+> "->" <+> prettyV v++nPretty ::+  Pretty k =>+  Pretty v =>+  NMap map k v sort =>+  map ->+  Doc+nPretty =+  nPrettyWith pretty++nPretty1 ::+  Pretty k =>+  Pretty v =>+  NMap map k v sort =>+  map ->+  Doc+nPretty1 (nGet -> m) =+  vcat (assoc <$> Map.toList m)+  where+    assoc (k, v) = hang (pretty k PrettyPrint.<> ":") 2 (pretty v)++nMergeA ::+  ∀ map1 map2 map3 k v1 v2 v3 s1 s2 s3 m .+  Applicative m =>+  NMap map1 k v1 s1 =>+  NMap map2 k v2 s2 =>+  NMap map3 k v3 s3 =>+  WhenMissing m k v1 v3 ->+  WhenMissing m k v2 v3 ->+  WhenMatched m k v1 v2 v3 ->+  map1 ->+  map2 ->+  m map3+nMergeA missing1 missing2 matched map1 map2 =+  nViaA (Map.mergeA missing1 missing2 matched (nGet map1)) map2++nMerge ::+  ∀ map1 map2 map3 k v1 v2 v3 s1 s2 s3 .+  NMap map1 k v1 s1 =>+  NMap map2 k v2 s2 =>+  NMap map3 k v3 s3 =>+  SimpleWhenMissing k v1 v3 ->+  SimpleWhenMissing k v2 v3 ->+  SimpleWhenMatched k v1 v2 v3 ->+  map1 ->+  map2 ->+  map3+nMerge missing1 missing2 matched map1 map2 =+  nVia (Map.merge missing1 missing2 matched (nGet map1)) map2++nAmendWithKey ::+  ∀ map1 map2 k v1 v2 s1 s2 .+  NMap map1 k v1 s1 =>+  NMap map2 k v2 s2 =>+  (k -> v1 -> v2 -> v2) ->+  map1 ->+  map2 ->+  map2+nAmendWithKey matched =+  nMerge dropMissing preserveMissing (zipWithMatched matched)++-- | For each key that is present in both maps, replace the value by the result of the combining function.+-- For everything else, leave @map2@ unchanged.+nAmend ::+  ∀ map1 map2 k v1 v2 s1 s2 .+  NMap map1 k v1 s1 =>+  NMap map2 k v2 s2 =>+  (v1 -> v2 -> v2) ->+  map1 ->+  map2 ->+  map2+nAmend matched =+  nAmendWithKey (const matched)++-- | For each key path that is present in both submaps, replace the value by the result of the combining function.+-- For everything else, leave @map2@ unchanged.+nAmend1 ::+  ∀ map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2' .+  NMap map1 k map1' s1 =>+  NMap map2 k map2' s2 =>+  NMap map1' k' v1 s1' =>+  NMap map2' k' v2 s2' =>+  (v1 -> v2 -> v2) ->+  map1 ->+  map2 ->+  map2+nAmend1 matched =+  nMerge dropMissing preserveMissing (zipWithMatched matched1)+  where+    matched1 _ map1' map2' = nAmend matched map1' map2'++-- | For each key that is present in both maps, replace the value by the result of the combining function.+-- For each key that is present in @map1@, insert the result of the conversion function.+-- Keep keys only present in @map2@.+nPad ::+  ∀ map1 map2 k v1 v2 s1 s2 .+  NMap map1 k v1 s1 =>+  NMap map2 k v2 s2 =>+  (v1 -> v2 -> v2) ->+  (v1 -> v2) ->+  map1 ->+  map2 ->+  map2+nPad matched conv =+  nMerge (mapMissing (const conv)) preserveMissing (zipWithMatched (const matched))++-- | For each key path that is present in both submaps, replace the value by the result of the combining function.+-- For each key and key path that is present only in @map1@ and each submap, insert the result of the conversion+-- function.+-- Keep keys only present in @map2@ and each submap.+nPad1 ::+  ∀ map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2' .+  NMap map1 k map1' s1 =>+  NMap map2 k map2' s2 =>+  NMap map1' k' v1 s1' =>+  NMap map2' k' v2 s2' =>+  (v1 -> v2 -> v2) ->+  (v1 -> v2) ->+  map1 ->+  map2 ->+  map2+nPad1 matched conv =+  nMerge (mapMissing missing) preserveMissing (zipWithMatched matched1)+  where+    missing _ = nMap conv+    matched1 _ = nPad matched conv++-- | For each key that is present only in @map1@, insert the result of the conversion function.+-- For everything else, leave @map2@ unchanged.+nPadKeep ::+  ∀ map1 map2 k v1 v2 s1 s2 .+  NMap map1 k v1 s1 =>+  NMap map2 k v2 s2 =>+  (v1 -> v2) ->+  map1 ->+  map2 ->+  map2+nPadKeep =+  nPad \ _ v2 -> v2++-- | For each key and key path that is present only in @map1@ and each submap, insert the result of the conversion+-- function.+-- For everything else, leave @map2@ and its submaps unchanged.+nPadKeep1 ::+  ∀ map1 map2 map1' map2' k k' v1 v2 s1 s2 s1' s2' .+  NMap map1 k map1' s1 =>+  NMap map2 k map2' s2 =>+  NMap map1' k' v1 s1' =>+  NMap map2' k' v2 s2' =>+  (v1 -> v2) ->+  map1 ->+  map2 ->+  map2+nPadKeep1 =+  nPad1 \ _ v2 -> v2++nZipWithKeyR ::+  ∀ map1 map2 map3 k v1 v2 v3 s1 s2 s3 .+  NMap map1 k v1 s1 =>+  NMap map2 k v2 s2 =>+  NMap map3 k v3 s3 =>+  (k -> Maybe v1 -> v2 -> v3) ->+  map1 ->+  map2 ->+  map3+nZipWithKeyR f =+  nMerge dropMissing (mapMissing missing) (zipWithMatched matched)+  where+    missing k = f k Nothing+    matched k v = f k (Just v)++nZipR ::+  ∀ map1 map2 map3 k v1 v2 v3 s1 s2 s3 .+  NMap map1 k v1 s1 =>+  NMap map2 k v2 s2 =>+  NMap map3 k v3 s3 =>+  (Maybe v1 -> v2 -> v3) ->+  map1 ->+  map2 ->+  map3+nZipR f = nZipWithKeyR (const f)++nZipWithKey ::+  ∀ map1 map2 map3 k v1 v2 v3 s1 s2 s3 .+  NMap map1 k v1 s1 =>+  NMap map2 k v2 s2 =>+  NMap map3 k v3 s3 =>+  (k -> v1 -> v2 -> v3) ->+  map1 ->+  map2 ->+  map3+nZipWithKey f =+  nMerge dropMissing dropMissing (zipWithMatched f)++nZip ::+  ∀ map1 map2 map3 k v1 v2 v3 s1 s2 s3 .+  NMap map1 k v1 s1 =>+  NMap map2 k v2 s2 =>+  NMap map3 k v3 s3 =>+  (v1 -> v2 -> v3) ->+  map1 ->+  map2 ->+  map3+nZip f = nZipWithKey (const f)++nFromList ::+  NMap map k v sort =>+  [(k, v)] ->+  map+nFromList =+  coerce . Map.fromList++nList ::+  NMap map k v sort =>+  map ->+  [(k, v)]+nList =+  Map.toList . coerce++nTo ::+  NMap map k v sort =>+  map ->+  (k -> v -> a) ->+  [a]+nTo m f =+  fmap (uncurry f) (nList m)++nToWith ::+  NMap map k v sort =>+  (k -> v -> a) ->+  map ->+  [a]+nToWith = flip nTo++nConcat ::+  Monoid a =>+  NMap map k v sort =>+  map ->+  (k -> v -> a) ->+  a+nConcat m f =+  mconcat (uncurry f <$> nList m)++nConcatWith ::+  Monoid a =>+  NMap map k v sort =>+  (k -> v -> a) ->+  map ->+  a+nConcatWith =+  flip nConcat++nToMaybe ::+  NMap map k v sort =>+  map ->+  (k -> v -> Maybe a) ->+  [a]+nToMaybe m f =+  mapMaybe (uncurry f) (nList m)++nTo1 ::+  ∀ map1 map2 k1 k2 v s1 s2 a .+  NMap map1 k1 map2 s1 =>+  NMap map2 k2 v s2 =>+  map1 ->+  (k1 -> k2 -> v -> a) ->+  [a]+nTo1 m1 f =+  nConcat m1 (nToWith . f)++nToWith1 ::+  ∀ map1 map2 k1 k2 v s1 s2 a .+  NMap map1 k1 map2 s1 =>+  NMap map2 k2 v s2 =>+  (k1 -> k2 -> v -> a) ->+  map1 ->+  [a]+nToWith1 f =+  nConcatWith (nToWith . f)++nFromKeys ::+  Foldable t =>+  NMap map k v sort =>+  t k ->+  (k -> v) ->+  map+nFromKeys keys f =+  nFromList (toList keys <&> \ k -> (k, f k))++nFromKeysMaybe ::+  Foldable t =>+  NMap map k v sort =>+  t k ->+  (k -> Maybe v) ->+  map+nFromKeysMaybe keys f =+  nFromList (flip mapMaybe (toList keys) \ k -> (k,) <$> f k)++nBy ::+  Foldable t =>+  NMap map k v sort =>+  t v ->+  (v -> k) ->+  map+nBy values f =+  nFromList (toList values <&> \ v -> (f v, v))++nGen ::+  Foldable t =>+  NMap map k v sort =>+  t a ->+  (a -> (k, v)) ->+  map+nGen values f =+  nFromList (f <$> toList values)++nGenWith ::+  Foldable t =>+  NMap map k v sort =>+  (a -> (k, v)) ->+  t a ->+  map+nGenWith =+  flip nGen++nGenMaybe ::+  Foldable t =>+  NMap map k v sort =>+  t a ->+  (a -> Maybe (k, v)) ->+  map+nGenMaybe values f =+  nFromList (mapMaybe f (toList values))++nForKeys ::+  Applicative m =>+  NMap map k v sort =>+  [k] ->+  (k -> m v) ->+  m map+nForKeys keys f =+  nFromList <$> for keys \ k -> (k,) <$> f k++nFor ::+  Applicative m =>+  NMap map k v sort =>+  [v] ->+  (v -> m k) ->+  m map+nFor values f =+  nFromList <$> for values \ v -> (,v) <$> f v++nElems ::+  ∀ map k v s .+  NMap map k v s =>+  map ->+  [v]+nElems =+  Map.elems . nGet++nElems1 ::+  ∀ map1 map2 k1 k2 v s1 s2 .+  NMap map1 k1 map2 s1 =>+  NMap map2 k2 v s2 =>+  map1 ->+  [v]+nElems1 =+  nElems <=< nElems++nFlatten ::+  ∀ map1 map2 map3 k1 k2 v1 v2 s1 s2 .+  Monoid map2 =>+  NMap map1 k1 map2 LookupMonoid =>+  NMap map2 k2 v1 s1 =>+  NMap map3 k2 v2 s2 =>+  (v1 -> v2) ->+  map1 ->+  map3+nFlatten f =+  nMap f . mconcat . nElems++nKeys ::+  NMap map k v sort =>+  map ->+  [k]+nKeys =+  Map.keys . nGet++nKeysSet ::+  NMap map k v sort =>+  map ->+  Set k+nKeysSet =+  Map.keysSet . nGet++nRestrictKeys ::+  NMap map k v sort =>+  Set k ->+  map ->+  map+nRestrictKeys keys =+  nVia (`Map.restrictKeys` keys)++nWithoutKeys ::+  NMap map k v sort =>+  Set k ->+  map ->+  map+nWithoutKeys keys =+  nVia (`Map.withoutKeys` keys)

@@ -0,0 +1,54 @@+module Hix.Class.SOP where++import Generics.SOP (I (I), NP (Nil, (:*)), NS (S, Z), SOP (SOP))+import Generics.SOP.GGP (GCode, GDatatypeInfoOf, GFrom, gfrom)+import Generics.SOP.Type.Metadata (ConstructorInfo (Record), DatatypeInfo (..), FieldInfo (FieldInfo))++data FieldK =+  FieldK {+    name :: Symbol,+    tpe :: Type+  }++type Field :: FieldK -> Type+data Field k where+  Field :: a -> Field ('FieldK name a)++type ProdFields :: [FieldInfo] -> [Type] -> [FieldK] -> Constraint+class ProdFields info as fields | info as -> fields where+  prodFields :: NP I as -> NP Field fields++instance ProdFields '[] '[] '[] where+  prodFields Nil = Nil++instance (+    ProdFields info as fields+  ) => ProdFields ('FieldInfo name : info) (a : as) ('FieldK name a : fields) where+    prodFields (I a :* fields) = Field a :* prodFields @info fields++type SumFields :: [ConstructorInfo] -> [[Type]] -> [[FieldK]] -> Constraint+class SumFields cons ass fields | cons ass -> fields where+  sumFields :: NS (NP I) ass -> NS (NP Field) fields++instance SumFields '[] '[] '[] where+  sumFields = \case++instance (+    ProdFields info as conFields,+    SumFields cons ass fields+  ) => SumFields ('Record con info : cons) (as : ass) (conFields : fields) where+    sumFields = \case+      Z con -> Z (prodFields @info con)+      S cons -> S (sumFields @cons cons)++class ToFields a fields | a -> fields where+  toFields :: a -> SOP Field fields++instance (+    Generic a,+    GFrom a,+    'ADT mod name cons sni ~ GDatatypeInfoOf a,+    ass ~ GCode a,+    SumFields cons ass fields+  ) => ToFields a fields where+    toFields (gfrom -> SOP fields) = SOP (sumFields @cons fields)

@@ -11,21 +11,17 @@ import Hix.Data.ComponentConfig (   ComponentConfig,   PackageConfig (PackageConfig),-  PackageName (PackageName),   PackagesConfig,   SourceDir (SourceDir),   Target (Target),   TargetOrDefault (DefaultTarget, ExplicitTarget, NoDefaultTarget),   )-import Hix.Data.Error (Error (EnvError), pathText)+import Hix.Data.Error (Error (EnvError))+import qualified Hix.Data.Options as Options+import Hix.Data.Options (ComponentCoords, ComponentSpec (ComponentSpec), PackageSpec (PackageSpec), TargetSpec (..))+import Hix.Data.PackageName (PackageName (PackageName))+import Hix.Error (pathText) import Hix.Monad (M, noteEnv, throwM)-import qualified Hix.Options as Options-import Hix.Options (-  ComponentCoords,-  ComponentSpec (ComponentSpec),-  PackageSpec (PackageSpec),-  TargetSpec (TargetForComponent, TargetForFile),-  ) import Hix.Path (rootDir)  data ResolvedPackage =

@@ -0,0 +1,84 @@+module Hix.Console where++import qualified Data.ByteString.Char8 as ByteString+import qualified Data.Text.IO as Text+import Exon (exon)+import System.IO (Handle, stderr, stdout)++hPrint ::+  MonadIO m =>+  Handle ->+  Text ->+  m ()+hPrint h msg =+  liftIO (Text.hPutStrLn h msg)++hPrintBS ::+  MonadIO m =>+  Handle ->+  ByteString ->+  m ()+hPrintBS h msg =+  liftIO (ByteString.hPutStrLn h msg)++out :: MonadIO m => Text -> m ()+out = hPrint stdout++err :: MonadIO m => Text -> m ()+err = hPrint stderr++bytesOut :: MonadIO m => ByteString -> m ()+bytesOut = hPrintBS stdout++bytesErr :: MonadIO m => ByteString -> m ()+bytesErr = hPrintBS stderr++sgi :: Text -> Text+sgi param =+  [exon|#{esc}[#{param}m|]+  where+    esc = "\ESC"++sgis :: [Text] -> Text -> Text+sgis params chunk =+  [exon|#{seqs}#{chunk}#{sgi "0"}|]+  where+    seqs = mconcat (sgi <$> params)++color :: Int -> Text -> Text+color n =+  sgis [show (30 + n)]++data ColorOffsets =+  ColorOffsets {+    black :: Int,+    red :: Int,+    green :: Int,+    yellow :: Int,+    blue :: Int,+    magenta :: Int,+    cyan :: Int,+    white :: Int+  }+  deriving stock (Eq, Show, Generic)++colors :: ColorOffsets+colors =+  ColorOffsets {+    black = 0,+    red = 1,+    green = 2,+    yellow = 3,+    blue = 4,+    magenta = 5,+    cyan = 6,+    white = 7+  }++withChevrons :: Int -> Text -> Text+withChevrons col msg =+  [exon|#{sgis [show (30 + col), "1"] ">>>"} #{msg}|]++errorMessage :: Text -> Text+errorMessage msg =+  withChevrons 1 [exon|Error: #{msg}|]

@@ -0,0 +1,49 @@+module Hix.Data.Bounds where++import Data.Aeson (FromJSON (parseJSON), ToJSON)+import Distribution.Pretty (Pretty (pretty))+import Distribution.Version (Version, VersionRange)+import GHC.Exts (IsList)++import Hix.Class.EncodeNix (EncodeNix)+import Hix.Class.Map (LookupMaybe, NMap, nPretty)+import Hix.Data.Json (jsonParsec)+import Hix.Data.PackageName (PackageName)+import Hix.Data.VersionBounds (VersionBounds)++newtype Bounds =+  Bounds (Map PackageName VersionBounds)+  deriving stock (Eq, Show, Generic)+  deriving newtype (Semigroup, Monoid, IsList, EncodeNix, FromJSON, ToJSON)++instance NMap Bounds PackageName VersionBounds LookupMaybe where++instance Pretty Bounds where+  pretty = nPretty++newtype Ranges =+  Ranges (Map PackageName VersionRange)+  deriving stock (Eq, Show, Generic)+  deriving newtype (Semigroup, Monoid, IsList)++instance NMap Ranges PackageName VersionRange LookupMaybe where++instance Pretty Ranges where+  pretty = nPretty++instance FromJSON Ranges where+  parseJSON v =+    Ranges . fmap jsonParsec <$> parseJSON v++data BoundExtension =+  LowerBoundExtension Version+  |+  UpperBoundExtension Version+  deriving stock (Eq, Show, Generic)++newtype BoundExtensions =+  BoundExtensions (Map PackageName BoundExtension)+  deriving stock (Eq, Show, Generic)+  deriving newtype (Semigroup, Monoid, IsList)++instance NMap BoundExtensions PackageName BoundExtension LookupMaybe where

@@ -1,8 +1,11 @@ module Hix.Data.ComponentConfig where  import Data.Aeson (FromJSON (parseJSON), FromJSONKey, withObject, (.:))+import Distribution.Pretty (Pretty (pretty)) import Path (Abs, Dir, File, Path, Rel) +import Hix.Data.PackageName (PackageName)+ newtype PackagePath =   PackagePath { unPackagePath :: Path Rel Dir }   deriving stock (Eq, Show, Ord, Generic)@@ -23,11 +26,6 @@     <|>     (SourceDirs . pure <$> parseJSON v) -newtype PackageName =-  PackageName { unPackageName :: Text }-  deriving stock (Eq, Show, Generic)-  deriving newtype (IsString, Ord, FromJSON, FromJSONKey)- newtype ModuleName =   ModuleName { unModuleName :: Text }   deriving stock (Eq, Show, Generic)@@ -38,10 +36,8 @@   deriving stock (Eq, Show, Generic)   deriving newtype (IsString, Ord, FromJSON, FromJSONKey) -newtype EnvName =-  EnvName { unEnvName :: Text }-  deriving stock (Eq, Show, Generic)-  deriving newtype (IsString, Ord, FromJSON, FromJSONKey)+instance Pretty ComponentName where+  pretty (ComponentName n) = fromString (toString n)  newtype EnvRunner =   EnvRunner (Path Abs File)

@@ -0,0 +1,59 @@+module Hix.Data.Dep where++import Data.Aeson (FromJSON (parseJSON), Value (Object, String), (.:))+import Data.Aeson.Types (Parser)+import Distribution.Package (mainLibSet)+import Distribution.Pretty (Pretty, pretty)+import Distribution.Types.Dependency (Dependency (Dependency))+import Distribution.Version (VersionRange, thisVersion)+import Exon (exon)++import Hix.Data.Json (aesonParsec, jsonParsec)+import qualified Hix.Data.PackageName as PackageName+import Hix.Data.PackageName (PackageName)+import Hix.Data.Version (Version)++data Dep =+  Dep {+    package :: PackageName,+    version :: VersionRange+  }+  deriving stock (Eq, Show, Generic)++toCabal :: Dep -> Dependency+toCabal Dep {..} =+  Dependency (PackageName.toCabal package) version mainLibSet++fromCabal :: Dependency -> Dep+fromCabal (Dependency (PackageName.fromCabal -> package) version _) =+  Dep {package, version}++instance Pretty Dep where+  pretty = pretty . toCabal++mkDep :: PackageName -> VersionRange -> Dep+mkDep package version = Dep {..}++jsonParseCabal :: String -> Parser Dep+jsonParseCabal v = fromCabal <$> aesonParsec v++renderDep :: Dep -> Text+renderDep = show . pretty++thisVersionDep :: PackageName -> Version -> Dep+thisVersionDep package version =+  mkDep package (thisVersion version)++instance FromJSON Dep where+  parseJSON = \case+    String s ->+      jsonParseCabal (toString s)+    Object o -> do+      fromName <- jsonParseCabal =<< o .: "name"+      version <- (jsonParsec <$> o .: "version") <|> pure fromName.version+      pure fromName {version}+    v ->+      fail [exon|Invalid dependency format: #{show v}|]++withVersion :: VersionRange -> Dep -> Dep+withVersion version dep = dep {version}

@@ -0,0 +1,15 @@+module Hix.Data.EnvName where++import Data.Aeson (FromJSON, FromJSONKey)+import Distribution.Pretty (Pretty (pretty))++import Hix.Class.EncodeNix (EncodeNixKey)+import Hix.Pretty (prettyText)++newtype EnvName =+  EnvName { unEnvName :: Text }+  deriving stock (Eq, Show, Generic)+  deriving newtype (IsString, Ord, FromJSON, FromJSONKey, EncodeNixKey)++instance Pretty EnvName where+  pretty (EnvName n) = prettyText n

@@ -1,12 +1,5 @@ module Hix.Data.Error where -import Control.Monad.Trans.Except (ExceptT, throwE)-import qualified Data.Text.IO as Text-import Exon (exon)-import Path (Path, toFilePath)-import System.IO (stderr)-import System.IO.Error (tryIOError)- data Error =   PreprocError Text   |@@ -21,66 +14,6 @@   NoMatch Text   |   Fatal Text+  |+  Client Text   deriving stock (Eq, Show, Generic)--pathText :: Path b t -> Text-pathText =-  toText . toFilePath--printPreprocError ::-  MonadIO m =>-  Text ->-  m ()-printPreprocError msg =-  liftIO (Text.hPutStrLn stderr [exon|>>> Preprocessor generator failed: #{msg}|])--printEnvError ::-  MonadIO m =>-  Text ->-  m ()-printEnvError msg =-  liftIO (Text.hPutStrLn stderr [exon|>>> Invalid env config: #{msg}|])--printGhciError ::-  MonadIO m =>-  Text ->-  m ()-printGhciError msg =-  liftIO (Text.hPutStrLn stderr [exon|>>> Invalid ghci config: #{msg}|])--printNewError ::-  MonadIO m =>-  Text ->-  m ()-printNewError msg =-  liftIO (Text.hPutStrLn stderr [exon|>>> Can't create new project: #{msg}|])--printBootstrapError ::-  MonadIO m =>-  Text ->-  m ()-printBootstrapError msg =-  liftIO (Text.hPutStrLn stderr [exon|>>> Can't bootstrap project: #{msg}|])--printFatalError ::-  MonadIO m =>-  Text ->-  m ()-printFatalError msg =-  liftIO (Text.hPutStrLn stderr [exon|>>> Fatal error: #{msg}|])--sourceError :: Text -> Path b t -> Text-sourceError reason source =-  [exon|#{reason} the source file '#{pathText source}'|]--tryIO ::-  IO a ->-  ExceptT Error IO a-tryIO ma =-  liftIO (tryIOError ma) >>= \case-    Right a -> pure a-    Left err -> throwE (Fatal (show err))--note :: Text -> Maybe a -> ExceptT Error IO a-note err =-  maybe (throwE (GhciError err)) pure

@@ -3,7 +3,8 @@ import Data.Aeson (FromJSON, FromJSONKey) import GHC.Exts (IsList) -import Hix.Data.ComponentConfig (EnvRunner, PackageName, PackagesConfig)+import Hix.Data.ComponentConfig (EnvRunner, PackagesConfig)+import Hix.Data.PackageName (PackageName)  newtype RunnerName =   RunnerName { unRunnerName :: Text }

@@ -0,0 +1,28 @@+module Hix.Data.GlobalOptions where++import Path (Abs, Dir, Path)++import Hix.Data.OutputFormat (OutputFormat (OutputNone))+import Hix.Data.OutputTarget (OutputTarget (OutputDefault))++data GlobalOptions =+  GlobalOptions {+    verbose :: Bool,+    debug :: Bool,+    quiet :: Bool,+    cwd :: Path Abs Dir,+    output :: OutputFormat,+    target :: OutputTarget+  }+  deriving stock (Eq, Show, Generic)++defaultGlobalOptions :: Path Abs Dir -> GlobalOptions+defaultGlobalOptions cwd =+  GlobalOptions {+    verbose = False,+    debug = False,+    quiet = False,+    cwd,+    output = OutputNone,+    target = OutputDefault+  }

@@ -0,0 +1,33 @@+module Hix.Data.Json where++import Data.Aeson (FromJSON (parseJSON), Key, Object, (.:?))+import Data.Aeson.Types (Parser)+import Distribution.Parsec (Parsec, eitherParsec)++aesonParsec ::+  Parsec a =>+  String ->+  Parser a+aesonParsec =+  leftA fail . eitherParsec++newtype JsonParsec a =+  JsonParsec a+  deriving stock (Eq, Show, Generic)++instance Parsec a => FromJSON (JsonParsec a) where+  parseJSON v = do+    raw <- parseJSON v+    JsonParsec <$> aesonParsec raw++jsonParsec :: JsonParsec a -> a+jsonParsec = coerce++foldMissing ::+  Monoid a =>+  FromJSON a =>+  Object ->+  Key ->+  Parser a+foldMissing o k =+  fold <$> o .:? k

@@ -0,0 +1,51 @@+module Hix.Data.Monad where++import Control.Monad.Catch (MonadCatch, MonadMask, MonadThrow)+import Control.Monad.Trans.Class (lift)+import Control.Monad.Trans.Except (ExceptT)+import Control.Monad.Trans.Reader (ReaderT, asks)+import GHC.Records (HasField (getField))+import Path (Abs, Dir, Path)++import Hix.Data.Error (Error)+import Hix.Data.OutputFormat (OutputFormat)+import Hix.Data.OutputTarget (OutputTarget)++data LogLevel =+  LogError+  |+  LogWarn+  |+  LogInfo+  |+  LogVerbose+  |+  LogDebug+  deriving stock (Eq, Show, Generic)++data AppResources =+  AppResources {+    cwd :: Path Abs Dir,+    tmp :: Path Abs Dir,+    verbose :: Bool,+    debug :: Bool,+    quiet :: Bool,+    output :: OutputFormat,+    target :: OutputTarget,+    logger :: LogLevel -> Text -> M ()+  }++newtype M a =+  M (ReaderT AppResources (ExceptT Error IO) a)+  deriving newtype (Functor, Applicative, Monad, MonadIO, MonadThrow, MonadCatch, MonadMask)++liftE :: ExceptT Error IO a -> M a+liftE = M . lift++data AppResProxy = AppResProxy++instance HasField name AppResources a => HasField name AppResProxy (M a) where+  getField AppResProxy = M (asks (getField @name))++appRes :: AppResProxy+appRes = AppResProxy

@@ -0,0 +1,38 @@+module Hix.Data.NixExpr where++data ExprAttr =+  ExprAttr {+    name :: Text,+    value :: Expr+  }+  |+  ExprAttrNil+  deriving stock (Eq, Show, Generic)++data Expr =+  ExprNull+  |+  ExprString Text+  |+  ExprLit Text+  |+  ExprList [Expr]+  |+  ExprAttrs [ExprAttr]+  |+  ExprPrefix Text Expr+  deriving stock (Eq, Show, Generic)++exprShow :: Show a => a -> Expr+exprShow =+  ExprLit . show++exprBool :: Bool -> Expr+exprBool =+  ExprLit . \case+    True -> "true"+    False -> "false"++newtype ViaPretty a =+  ViaPretty  a+  deriving stock (Eq, Show, Generic)

@@ -0,0 +1,203 @@+module Hix.Data.Options where++import Path (Abs, Dir, File, Path, SomeBase)++import Hix.Data.BootstrapProjectConfig (BootstrapProjectConfig)+import Hix.Data.ComponentConfig (ComponentName, ModuleName, SourceDir)+import Hix.Data.EnvName (EnvName)+import Hix.Data.GhciConfig (ChangeDir, EnvConfig, GhciConfig, RunnerName)+import Hix.Data.GlobalOptions (GlobalOptions)+import Hix.Data.NewProjectConfig (NewProjectConfig)+import Hix.Data.PackageName (PackageName)+import Hix.Data.PreprocConfig (PreprocConfig)+import Hix.Managed.Cabal.Data.Config (CabalConfig)+import Hix.Managed.Data.BuildConfig (BuildConfig)+import Hix.Managed.Data.ProjectContextProto (ProjectContextProto)+import Hix.Managed.Data.Query (RawQuery)+import Hix.Managed.Data.StateFileConfig (StateFileConfig)+import Hix.Managed.Handlers.Build (SpecialBuildHandlers)+import Hix.Optparse (JsonConfig)++data PreprocOptions =+  PreprocOptions {+    config :: Maybe (Either PreprocConfig JsonConfig),+    root :: Maybe (Path Abs Dir),+    source :: Path Abs File,+    inFile :: Path Abs File,+    outFile :: Path Abs File+  }+  deriving stock (Show, Generic)++data PackageSpec =+  PackageSpec {+    name :: PackageName,+    dir :: Maybe (SomeBase Dir)+  }+  deriving stock (Eq, Show, Generic)++data ComponentSpec =+  ComponentSpec {+    name :: ComponentName,+    dir :: Maybe SourceDir+  }+  deriving stock (Eq, Show, Generic)++data ComponentCoords =+  ComponentCoords {+    package :: Maybe PackageSpec,+    component :: Maybe ComponentSpec+  }+  deriving stock (Eq, Show, Generic)++data TargetSpec =+  TargetForFile (Path Abs File)+  |+  TargetForComponent ComponentCoords+  deriving stock (Eq, Show, Generic)++data TestOptions =+  TestOptions {+    mod :: ModuleName,+    test :: Maybe Text,+    runner :: Maybe RunnerName,+    cd :: ChangeDir+  }+  deriving stock (Eq, Show, Generic)++data EnvRunnerOptions =+  EnvRunnerOptions {+    config :: Either EnvConfig JsonConfig,+    root :: Maybe (Path Abs Dir),+    component :: Maybe TargetSpec+  }+  deriving stock (Show, Generic)++newtype ExtraGhciOptions =+  ExtraGhciOptions Text+  deriving stock (Eq, Show, Generic)+  deriving newtype (IsString)++newtype ExtraGhcidOptions =+  ExtraGhcidOptions Text+  deriving stock (Eq, Show, Generic)+  deriving newtype (IsString)++data GhciOptions =+  GhciOptions {+    config :: Either GhciConfig JsonConfig,+    root :: Maybe (Path Abs Dir),+    component :: TargetSpec,+    test :: TestOptions,+    extra :: Maybe ExtraGhciOptions+  }+  deriving stock (Show, Generic)++data GhcidOptions =+  GhcidOptions {+    ghci :: GhciOptions,+    extra :: Maybe ExtraGhcidOptions+  }+  deriving stock (Show, Generic)++data NewOptions =+  NewOptions {+    config :: NewProjectConfig+  }+  deriving stock (Eq, Show, Generic)++data BootstrapOptions =+  BootstrapOptions {+    config :: BootstrapProjectConfig+  }+  deriving stock (Eq, Show, Generic)++data EnvRunnerCommandOptions =+  EnvRunnerCommandOptions {+    options :: EnvRunnerOptions,+    test :: TestOptions,+    extraGhci :: Maybe ExtraGhciOptions,+    extraGhcid :: Maybe ExtraGhcidOptions+  }+  deriving stock (Show, Generic)++data ProjectOptions =+  ProjectOptions {+    build :: BuildConfig,+    envs :: [EnvName],+    query :: RawQuery,+    readUpperBounds :: Bool,+    mergeBounds :: Bool+  }+  deriving stock (Eq, Show, Generic)++instance Default ProjectOptions where+  def = ProjectOptions {+    build = def,+    envs = [],+    query = [],+    readUpperBounds = False,+    mergeBounds = False+  }++projectOptions :: [EnvName] -> ProjectOptions+projectOptions envs = def {envs}++data ManagedOptions =+  ManagedOptions {+    context :: Either ProjectContextProto JsonConfig,+    project :: ProjectOptions,+    stateFile :: StateFileConfig,+    cabal :: CabalConfig,+    handlers :: Maybe SpecialBuildHandlers+  }+  deriving stock (Show, Generic)++data BumpOptions =+  BumpOptions {+    common :: ManagedOptions+  }+  deriving stock (Show, Generic)++data LowerOptions =+  LowerOptions {+    common :: ManagedOptions,+    initOnly :: Bool,+    reset :: Bool,+    stabilize :: Bool+  }+  deriving stock (Show)++data LowerCommand =+  LowerInitCmd LowerOptions+  |+  LowerOptimizeCmd LowerOptions+  |+  LowerStabilizeCmd LowerOptions+  |+  LowerAutoCmd LowerOptions+  deriving stock (Show)++data Command =+  Preproc PreprocOptions+  |+  EnvRunner EnvRunnerCommandOptions+  |+  GhcidCmd GhcidOptions+  |+  GhciCmd GhciOptions+  |+  NewCmd NewOptions+  |+  BootstrapCmd BootstrapOptions+  |+  BumpCmd BumpOptions+  |+  LowerCmd LowerCommand+  deriving stock (Show)++data Options =+  Options {+    global :: GlobalOptions,+    cmd :: Command+  }+  deriving stock (Show)

@@ -0,0 +1,11 @@+module Hix.Data.OutputFormat where++data OutputFormat =+  OutputNone+  |+  OutputJson+  |+  OutputCommitMsg+  |+  OutputGaPr+  deriving stock (Eq, Show, Generic)

@@ -0,0 +1,11 @@+module Hix.Data.OutputTarget where++import Path (Abs, File, Path)++data OutputTarget =+  OutputDefault+  |+  OutputStdout+  |+  OutputFile (Path Abs File)+  deriving stock (Eq, Show, Generic)

@@ -0,0 +1,43 @@+module Hix.Data.Overrides where++import Data.Aeson (FromJSON (parseJSON), withObject, (.:))+import Distribution.Pretty (Pretty (pretty))+import Distribution.Types.Version (Version)+import GHC.Exts (IsList)+import Text.PrettyPrint (brackets, (<+>))++import Hix.Class.EncodeNix (EncodeNix)+import Hix.Class.Map (LookupMaybe, NMap, nPretty)+import Hix.Data.Json (JsonParsec (JsonParsec))+import Hix.Data.PackageName (PackageName)+import Hix.Data.Version (SourceHash)++data Override =+  Override {+    version :: Version,+    hash :: SourceHash+  }+  deriving stock (Eq, Show, Generic)+  deriving anyclass (EncodeNix)++instance FromJSON Override where+  parseJSON =+    withObject "Override" \ o -> do+      JsonParsec version <- o .: "version"+      hash <- o .: "hash"+      pure Override {..}++instance Pretty Override where+  pretty Override {..} = pretty version <+> brackets (pretty hash)++-- | Overrides can be either for mutable (direct, nonlocal) deps, or for transitive deps, so they must use+-- 'PackageName'.+newtype Overrides =+  Overrides (Map PackageName Override)+  deriving stock (Eq, Show, Generic)+  deriving newtype (FromJSON, Semigroup, Monoid, IsList, EncodeNix)++instance NMap Overrides PackageName Override LookupMaybe where++instance Pretty Overrides where+  pretty = nPretty

@@ -0,0 +1,32 @@+module Hix.Data.PackageId where++import Distribution.Package (PackageIdentifier (PackageIdentifier))+import Distribution.Pretty (Pretty (pretty))+import Distribution.Version (Version)+import Exon (exon)++import qualified Hix.Data.PackageName as PackageName+import Hix.Data.PackageName (PackageName (..))+import Hix.Pretty (prettyText, showP)++data PackageId =+  PackageId {+    name :: PackageName,+    version :: Version+  }+  deriving stock (Eq, Show, Generic)++renderPackage :: PackageId -> Text+renderPackage PackageId {..} =+  [exon|##{name}-#{showP version}|]++instance Pretty PackageId where+  pretty = prettyText . renderPackage++toCabal :: PackageId -> PackageIdentifier+toCabal PackageId {..} =+  PackageIdentifier (PackageName.toCabal name) version++fromCabal :: PackageIdentifier -> PackageId+fromCabal (PackageIdentifier (PackageName.fromCabal -> name) version) =+  PackageId {..}

@@ -0,0 +1,55 @@+module Hix.Data.PackageName where++import Data.Aeson (FromJSON, FromJSONKey, ToJSON, ToJSONKey)+import qualified Data.Set as Set+import qualified Distribution.Package as Cabal+import Distribution.Package (depPkgName, mkPackageName)+import Distribution.Pretty (Pretty (pretty))+import Distribution.Types.Dependency (Dependency)++import Hix.Class.EncodeNix (EncodeNixKey)+import Hix.Pretty (prettyText)++newtype PackageName =+  PackageName Text+  deriving stock (Eq, Show, Generic)+  deriving newtype (IsString, Ord, FromJSON, FromJSONKey, ToJSON, ToJSONKey, EncodeNixKey)++instance Pretty PackageName where+  pretty (PackageName n) = prettyText n++fromCabal :: Cabal.PackageName -> PackageName+fromCabal =+  fromString . Cabal.unPackageName++toCabal :: PackageName -> Cabal.PackageName+toCabal (PackageName name) =+  mkPackageName (toString name)++depPackageName :: Dependency -> PackageName+depPackageName =+  fromCabal . depPkgName++newtype LocalPackage =+  LocalPackage PackageName+  deriving stock (Eq, Show, Generic)+  deriving newtype (IsString, Ord, FromJSON, FromJSONKey, Pretty, EncodeNixKey)++localPackageName :: LocalPackage -> PackageName+localPackageName = coerce++localPackageNames :: [LocalPackage] -> [PackageName]+localPackageNames = coerce++sameLocalPackage :: LocalPackage -> PackageName -> Bool+sameLocalPackage (LocalPackage lp) p = lp == p++isLocalPackage :: Set LocalPackage -> PackageName -> Bool+isLocalPackage lps p = Set.member (LocalPackage p) lps++toLocalPackage :: Set LocalPackage -> PackageName -> Maybe LocalPackage+toLocalPackage lps p+  | isLocalPackage lps p+  = Just (LocalPackage p)+  | otherwise+  = Nothing

@@ -6,9 +6,9 @@ import Path (File, Path, Rel, parent, toFilePath, (</>)) import Path.IO (createDirIfMissing) -import Hix.Data.Error (tryIO)-import qualified Hix.Monad-import Hix.Monad (Env (Env), M)+import qualified Hix.Data.Monad (AppResources (cwd))+import Hix.Data.Monad (AppResources (AppResources), M (M))+import Hix.Error (tryIO)  data ProjectFile =   ProjectFile {@@ -19,9 +19,9 @@  createFile :: ProjectFile -> M () createFile f = do-  Env {cwd} <- ask+  AppResources {cwd} <- M ask   let     file = cwd </> f.path-  lift $ tryIO do+  M $ lift $ tryIO do     createDirIfMissing True (parent file)     Text.writeFile (toFilePath file) f.content

@@ -0,0 +1,64 @@+module Hix.Data.Version (+  module Hix.Data.Version,+  Version,+  VersionRange,+) where++import Data.Aeson (FromJSON (parseJSON))+import Data.Generics.Labels ()+import qualified Data.List.NonEmpty as NonEmpty+import Distribution.Pretty (Pretty (pretty))+import Distribution.Version (Version, VersionRange, anyVersion)+import Exon (exon)+import GHC.Exts (IsList)+import Text.PrettyPrint (Doc)++import Hix.Class.EncodeNix (EncodeNix)+import Hix.Class.Map (LookupMaybe, NMap, nGenWith, nPretty)+import Hix.Data.Json (jsonParsec)+import qualified Hix.Data.PackageId+import Hix.Data.PackageId (PackageId (PackageId))+import Hix.Data.PackageName (PackageName)+import Hix.Orphans.Version ()+import Hix.Pretty (prettyText)++range0 :: VersionRange+range0 = anyVersion++newtype SourceHash =+  SourceHash Text+  deriving stock (Eq, Show, Generic)+  deriving newtype (Ord, FromJSON, EncodeNix)++instance Pretty SourceHash where+  pretty (SourceHash h) = prettyText h++data Major =+  Major {+    prefix :: Version,+    versions :: NonEmpty Version+  }+  deriving stock (Eq, Show, Generic)++prettyMajors :: NonEmpty Major -> Doc+prettyMajors = \case+  [Major {prefix}] -> pretty prefix <> ".*"+  majors -> [exon|#{pretty (NonEmpty.head majors).prefix}–#{pretty (NonEmpty.last majors).prefix}|]++newtype Versions =+  Versions (Map PackageName Version)+  deriving stock (Eq, Show, Generic)+  deriving newtype (Semigroup, Monoid, IsList, EncodeNix)++instance NMap Versions PackageName Version LookupMaybe where++instance Pretty Versions where+  pretty = nPretty++instance FromJSON Versions where+  parseJSON v =+    Versions . fmap jsonParsec <$> parseJSON v++packageIdVersions :: [PackageId] -> Versions+packageIdVersions =+  nGenWith \ PackageId {name, version} -> (name, version)

@@ -0,0 +1,152 @@+module Hix.Data.VersionBounds where++import Data.Aeson (FromJSON (parseJSON), ToJSON (toJSON), Value (Object, String), object, (.:?), (.=))+import Data.Aeson.Types (typeMismatch)+import Distribution.Pretty (Pretty (pretty))+import Distribution.Version (+  Version,+  VersionRange,+  earlierVersion,+  intersectVersionRanges,+  orLaterVersion,+  simplifyVersionRange,+  thisVersion,+  )++import Hix.Class.EncodeNix (EncodeNix)+import Hix.Data.Json (aesonParsec, jsonParsec)+import Hix.Data.Version (range0)+import Hix.Pretty (showP)+import Hix.Version (lowerVersion, upperVersion)++data Bound =+  BoundLower+  |+  BoundUpper+  deriving stock (Eq, Show, Generic)++instance Pretty Bound where+  pretty = \case+    BoundLower -> "lower"+    BoundUpper -> "upper"++data VersionBounds =+  VersionBounds {+    lower :: Maybe Version,+    upper :: Maybe Version+  }+  deriving stock (Eq, Show, Generic)+  deriving anyclass (EncodeNix)++instance Semigroup VersionBounds where+  left <> right = VersionBounds {lower = left.lower <|> right.lower, upper = left.upper <|> right.upper}++instance Monoid VersionBounds where+  mempty = VersionBounds {lower = Nothing, upper = Nothing}++unsafeVersionBoundsFromRange :: VersionRange -> VersionBounds+unsafeVersionBoundsFromRange range =+  VersionBounds {lower = lowerVersion range, upper = upperVersion range}++instance FromJSON VersionBounds where+  parseJSON = \case+    String s -> do+      range <- aesonParsec (toString s)+      pure (unsafeVersionBoundsFromRange range)+    Object o -> do+      lower <- fmap jsonParsec <$> o .:? "lower"+      upper <- fmap jsonParsec <$> o .:? "upper"+      pure VersionBounds {..}+    v -> do+      let+        expected =+          "a managed bound as either a string containing a Cabal-style range or an object with 'lower' and/or 'upper'"+          <>+          " as keys and simple versions as values"+      typeMismatch expected v++instance ToJSON VersionBounds where+  toJSON VersionBounds {..} =+    object [+      "lower" .= toJSON (showP @Text <$> lower),+      "upper" .= toJSON (showP @Text <$> upper)+    ]++maybeRange ::+  (Bound -> Version -> VersionRange) ->+  VersionBounds ->+  Maybe VersionRange+maybeRange mkRange bounds+  | Just l <- bounds.lower+  , Just u <- bounds.upper+  , u <= l+  = Just (thisVersion l)++  | Just l <- lower+  , Just u <- upper+  = Just (simplifyVersionRange (intersectVersionRanges l u))++  | Just l <- lower+  , Nothing <- upper+  = Just l++  | Nothing <- lower+  , Just u <- upper+  = Just u++  | Nothing <- lower+  , Nothing <- upper+  = Nothing+  where+    lower = mkRange BoundLower <$> bounds.lower+    upper = mkRange BoundUpper <$> bounds.upper++-- | Return a @==lower@ range for invalid bounds.+-- The constructors prevent this from happening, so it's maybe for tests?+-- Probably better to make the type abstract and crash.+maybeMajorRange ::+  VersionBounds ->+  Maybe VersionRange+maybeMajorRange =+  maybeRange \case+    BoundLower -> orLaterVersion+    BoundUpper -> earlierVersion++majorRange :: VersionBounds -> VersionRange+majorRange = fromMaybe range0 . maybeMajorRange++instance Pretty VersionBounds where+  pretty = pretty . majorRange++anyBounds :: VersionBounds+anyBounds =+  VersionBounds {lower = Nothing, upper = Nothing}++versionBounds :: Version -> Version -> VersionBounds+versionBounds lower upper =+  VersionBounds {lower = Just lower, upper = Just upper}++fromLower :: Version -> VersionBounds+fromLower lower =+  VersionBounds {lower = Just lower, upper = Nothing}++fromUpper :: Version -> VersionBounds+fromUpper upper =+  VersionBounds {lower = Nothing, upper = Just upper}++exactVersion :: Version -> VersionBounds+exactVersion version = versionBounds version version++withLower :: Version -> VersionBounds -> VersionBounds+withLower lower VersionBounds {upper} =+  VersionBounds {lower = Just lower, upper = clamp =<< upper}+  where+    clamp old | old < lower = Nothing+              | otherwise = Just old++withUpper :: Version -> VersionBounds -> VersionBounds+withUpper upper VersionBounds {lower} =+  VersionBounds {lower = clamp =<< lower, upper = Just upper}+  where+    clamp old | old > upper = Nothing+              | otherwise = Just old

@@ -5,18 +5,14 @@  import Hix.Component (targetComponent) import qualified Hix.Data.ComponentConfig-import Hix.Data.ComponentConfig (-  EnvRunner (EnvRunner),-  PackageName,-  PackagesConfig,-  TargetOrDefault (DefaultTarget, ExplicitTarget),-  )-import Hix.Data.Error (pathText)+import Hix.Data.ComponentConfig (EnvRunner (EnvRunner), PackagesConfig, TargetOrDefault (DefaultTarget, ExplicitTarget))+import Hix.Error (Error (EnvError), pathText) import qualified Hix.Data.GhciConfig-import Hix.Json (jsonConfig)-import Hix.Monad (M)-import qualified Hix.Options as Options-import Hix.Options (EnvRunnerOptions, TargetSpec)+import qualified Hix.Data.Options as Options+import Hix.Data.Options (EnvRunnerOptions, TargetSpec)+import Hix.Data.PackageName (PackageName)+import Hix.Json (jsonConfigE)+import Hix.Data.Monad (M)  -- TODO when there is a solution for default command env fallback configuration, the DefaultTarget case must return -- Nothing when the config requests it@@ -34,7 +30,7 @@  envRunner :: EnvRunnerOptions -> M EnvRunner envRunner opts = do-  config <- either pure jsonConfig opts.config+  config <- jsonConfigE EnvError opts.config   let runner = componentRunner opts.root config.mainPackage config.packages   fromMaybe config.defaultEnv . join <$> traverse runner opts.component 

@@ -0,0 +1,115 @@+module Hix.Error (+  module Hix.Data.Error,+  module Hix.Error,+) where++import Control.Monad.Trans.Except (ExceptT, throwE)+import Exon (exon)+import Path (Path, toFilePath)+import System.IO.Error (tryIOError)++import qualified Hix.Console as Console+import Hix.Console (errorMessage)+import Hix.Data.Error (Error (..))++pathText :: Path b t -> Text+pathText =+  toText . toFilePath++prefixedError ::+  MonadIO m =>+  Text ->+  Text ->+  m ()+prefixedError desc msg =+  Console.err (errorMessage [exon|#{desc}: #{msg}|])++printPreprocError ::+  MonadIO m =>+  Text ->+  m ()+printPreprocError =+  prefixedError "Preprocessor generator failed"++printEnvError ::+  MonadIO m =>+  Text ->+  m ()+printEnvError =+  prefixedError "Invalid env config"++printGhciError ::+  MonadIO m =>+  Text ->+  m ()+printGhciError =+  prefixedError "Invalid ghci config"++printNewError ::+  MonadIO m =>+  Text ->+  m ()+printNewError =+  prefixedError "Can't create new project"++printBootstrapError ::+  MonadIO m =>+  Text ->+  m ()+printBootstrapError =+  prefixedError "Can't bootstrap project"++printFatalError ::+  MonadIO m =>+  Text ->+  m ()+printFatalError =+  prefixedError "Fatal error"++sourceError :: Text -> Path b t -> Text+sourceError reason source =+  [exon|#{reason} the source file '#{pathText source}'|]++catchIO ::+  (Text -> ExceptT Error IO a) ->+  IO a ->+  ExceptT Error IO a+catchIO handleError ma =+  liftIO (tryIOError ma) >>= \case+    Right a -> pure a+    Left err -> handleError (show err)++tryIOWith ::+  (Text -> Error) ->+  IO a ->+  ExceptT Error IO a+tryIOWith mkErr ma =+  liftIO (tryIOError ma) >>= \case+    Right a -> pure a+    Left err -> throwE (mkErr (show err))++tryIO ::+  IO a ->+  ExceptT Error IO a+tryIO =+  tryIOWith Fatal++note :: Text -> Maybe a -> ExceptT Error IO a+note err =+  maybe (throwE (GhciError err)) pure++printError ::+  MonadIO m =>+  Bool ->+  Error ->+  m ()+printError verbose = \case+  PreprocError err -> printPreprocError err+  EnvError err -> printEnvError err+  GhciError err -> printGhciError err+  NewError err -> printNewError err+  BootstrapError err -> printBootstrapError err+  NoMatch msg | verbose -> printPreprocError msg+  NoMatch _ -> unit+  Fatal err -> printFatalError err+  Client err -> Console.err (errorMessage err)

@@ -1,6 +1,5 @@ module Hix.Ghci where -import Control.Monad.Trans.Class (lift) import Control.Monad.Trans.Except (ExceptT, catchE) import Data.List.Extra (nubOrd) import qualified Data.Map.Strict as Map@@ -19,19 +18,16 @@   ComponentConfig,   ModuleName (ModuleName),   PackageConfig,-  PackageName,   SourceDir (SourceDir),   Target (Target),   )-import Hix.Data.Error (Error, note, pathText, tryIO) import qualified Hix.Data.GhciConfig import Hix.Data.GhciConfig (GhciConfig, GhciRunExpr (GhciRunExpr), GhciSetupCode (GhciSetupCode)) import qualified Hix.Data.GhciTest as GhciTest import Hix.Data.GhciTest (GhciRun (GhciRun), GhciTest (GhciTest), GhcidRun (GhcidRun))-import Hix.Json (jsonConfig)-import Hix.Monad (M, noteGhci)-import qualified Hix.Options as Options-import Hix.Options (+import Hix.Data.Monad (liftE)+import qualified Hix.Data.Options as Options+import Hix.Data.Options (   ExtraGhciOptions (ExtraGhciOptions),   ExtraGhcidOptions (ExtraGhcidOptions),   GhciOptions (GhciOptions),@@ -39,6 +35,10 @@   TargetSpec (TargetForFile),   TestOptions (TestOptions),   )+import Hix.Data.PackageName (PackageName)+import Hix.Error (Error (GhciError), note, pathText, tryIO)+import Hix.Json (jsonConfigE)+import Hix.Monad (M, noteGhci) import Hix.Path (rootDir)  relativeToComponent ::@@ -108,7 +108,7 @@  assemble :: GhciOptions -> M GhciTest assemble opt = do-  config <- either pure jsonConfig opt.config+  config <- jsonConfigE GhciError opt.config   root <- rootDir opt.root   Target {..} <- targetComponentOrError opt.root config.mainPackage config.packages opt.component   script <- ghciScript config package sourceDir opt@@ -175,8 +175,8 @@   M GhciRun ghciCmdlineFromOptions tmp opt = do   conf <- assemble opt-  shellScriptFile <- lift (ghciScriptFile tmp conf.script)-  runScriptFile <- lift (traverse (ghciScriptFile tmp) conf.test)+  shellScriptFile <- liftE (ghciScriptFile tmp conf.script)+  runScriptFile <- liftE (traverse (ghciScriptFile tmp) conf.test)   pure (ghciCmdline conf opt.extra shellScriptFile runScriptFile)  ghcidCmdlineFromOptions ::@@ -195,7 +195,7 @@   GhciOptions ->   M () printGhciCmdline opt = do-  tmp <- lift hixTempDir+  tmp <- liftE hixTempDir   cmd <- ghciCmdlineFromOptions tmp opt   liftIO (Text.putStrLn [exon|ghci #{cmd.shell} #{fold cmd.run}|]) @@ -203,6 +203,6 @@   GhcidOptions ->   M () printGhcidCmdline opt = do-  tmp <- lift hixTempDir+  tmp <- liftE hixTempDir   cmd <- ghcidCmdlineFromOptions tmp opt   liftIO (Text.putStrLn cmd.cmdline)

@@ -0,0 +1,120 @@+module Hix.Hackage where++import Control.Monad.Extra (fromMaybeM)+import Data.Aeson (FromJSON (parseJSON), eitherDecodeStrict', withObject, (.:))+import Data.IORef (IORef, modifyIORef', readIORef)+import qualified Data.Map.Strict as Map+import Data.Map.Strict ((!?))+import qualified Data.Text as Text+import Distribution.Parsec (eitherParsec)+import Hix.Data.Version (Version)+import Exon (exon)+import Network.HTTP.Client (Manager, Request (..), Response (..), defaultRequest, httpLbs)+import Network.HTTP.Types (+  Status (statusCode, statusMessage),+  hAccept,+  statusIsClientError,+  statusIsServerError,+  statusIsSuccessful,+  )+import System.Exit (ExitCode (ExitFailure, ExitSuccess))+import System.Process.Typed (proc, readProcess)++import Hix.Data.Error (Error (Fatal))+import Hix.Data.PackageId (PackageId, renderPackage)+import Hix.Data.PackageName (PackageName)+import Hix.Data.Version (SourceHash (SourceHash))+import qualified Hix.Log as Log+import Hix.Monad (M, throwM, tryIOM)+import Hix.Pretty (showP)++data HackageVersions =+  HackageVersions {+    versions :: [String]+  }+  deriving stock (Eq, Show, Generic)++instance FromJSON HackageVersions where+  parseJSON = withObject "HackageVersions" \ o -> HackageVersions <$> o .: "normal-version"++parseVersion :: String -> Either (String, String) Version+parseVersion s = first (s,) (eitherParsec s)++parseResult :: LByteString -> M (Either Text [Version])+parseResult body =+  case eitherDecodeStrict' (toStrict body) of+    Left err ->+      noVersion [exon|Hackage response parse error: #{toText err}|]+    Right (HackageVersions []) ->+      noVersion "No versions on Hackage"+    Right (HackageVersions versions) ->+      case traverse parseVersion versions of+        Left (v, err) -> noVersion (toText [exon|Version '#{v}' has invalid format (#{err})|])+        Right vs -> pure (Right vs)+  where+    noVersion = pure . Left++versionsHackage :: Manager -> PackageName -> M [Version]+versionsHackage manager pkg = do+  res <- liftIO (httpLbs request manager)+  let+    body = responseBody res++    status = responseStatus res++    errorStatus category = noVersion [exon|#{category} (#{decodeUtf8 (statusMessage status)})|]++  if+    | statusIsSuccessful status -> leftA noVersion =<< parseResult body+    | statusCode status == 404 -> noVersion "PackageId does not exist"+    | statusIsClientError status -> errorStatus "Client error"+    | statusIsServerError status -> errorStatus "Server error"+    | otherwise -> errorStatus "Weird error"++  where+    request =+      defaultRequest {+        host = "hackage.haskell.org",+        secure = False,+        method = "GET",+        path = [exon|/package/##{pkg}/preferred|],+        requestHeaders = [(hAccept, "application/json")]+      }++    noVersion msg =+      [] <$ Log.error [exon|Hackage request for '##{pkg}' failed: #{msg}|]++latestVersionHackage :: Manager -> PackageName -> M (Maybe Version)+latestVersionHackage manager pkg =+  head <$> versionsHackage manager pkg++fetchHashHackage ::+  PackageId ->+  M SourceHash+fetchHashHackage package = do+  Log.debug [exon|Fetching hash for '##{slug}' from ##{url}|]+  tryIOM (readProcess conf) >>= \case+    (ExitFailure _, _, err) ->+      throwM (Fatal [exon|Prefetching source of '##{slug}' from hackage failed: #{decodeUtf8 err}|])+    (ExitSuccess, hash, _) ->+      pure (SourceHash (Text.stripEnd (decodeUtf8 hash)))+  where+    conf = proc "nix-prefetch-url" ["--unpack", url]+    url = [exon|https://hackage.haskell.org/package/#{slug}/#{slug}.tar.gz|]+    slug = showP package++fetchHashHackageCached ::+  IORef (Map Text SourceHash) ->+  PackageId ->+  M SourceHash+fetchHashHackageCached cacheRef package =+  liftIO (readIORef cacheRef) >>= \ cache ->+    fromMaybeM fetch (pure (cache !? cacheKey))+  where+    fetch = do+      hash <- fetchHashHackage package+      hash <$ addToCache hash++    addToCache hash = liftIO (modifyIORef' cacheRef (Map.insert cacheKey hash))++    cacheKey = renderPackage package

@@ -1,20 +1,20 @@ module Hix.Json where -import Control.Monad.Trans.Class (lift)-import Control.Monad.Trans.Except (throwE) import qualified Data.Aeson as Aeson import Data.Aeson (FromJSON, fromJSON) import Exon (exon) -import Hix.Data.Error (Error (GhciError))-import Hix.Monad (M)+import Hix.Data.Error (Error)+import Hix.Data.Monad (M)+import Hix.Monad (throwM) import Hix.Optparse (JsonConfig (JsonConfig))  jsonConfig ::   FromJSON a =>+  (Text -> Error) ->   JsonConfig ->   M a-jsonConfig (JsonConfig mv) =+jsonConfig consError (JsonConfig mv) =   liftIO mv >>= \case     Left msg -> failure [exon|Invalid JSON: #{toText msg}|]     Right v -> case fromJSON v of@@ -22,4 +22,12 @@       Aeson.Error err -> failure [exon|Invalid JSON: #{toText err} #{show v}|]   where-    failure = lift . throwE . GhciError+    failure = throwM . consError++jsonConfigE ::+  FromJSON a =>+  (Text -> Error) ->+  Either a JsonConfig ->+  M a+jsonConfigE consError =+  either pure (jsonConfig consError)

@@ -0,0 +1,61 @@+module Hix.Log where++import Control.Monad.Trans.Reader (ask)+import Exon (exon)+import Text.PrettyPrint (Doc)++import Hix.Console (color, withChevrons)+import qualified Hix.Data.Monad+import Hix.Data.Monad (LogLevel (..), M (M))++log :: LogLevel -> Text -> M ()+log level msg = do+  env <- M ask+  env.logger level msg++verbose :: Text -> M ()+verbose msg =+  log LogVerbose (withChevrons 4 msg)++debug :: Text -> M ()+debug msg =+  log LogDebug [exon|[#{color 6 "debug"}] #{msg}|]++debugP :: Doc -> M ()+debugP = debug . show++info :: Text -> M ()+info msg =+  log LogInfo (withChevrons 5 msg)++infoPlain :: Text -> M ()+infoPlain msg =+  log LogInfo msg++warn :: Text -> M ()+warn msg =+  log LogWarn (withChevrons 3 msg)++infoCont :: Text -> M ()+infoCont msg =+  log LogInfo [exon|    #{msg}|]++error :: Text -> M ()+error msg =+  log LogError (withChevrons 1 [exon|Error: #{msg}|])++logWith :: (LogLevel -> Text -> IO ()) -> LogLevel -> Text -> M ()+logWith handler level msg = do+  env <- M ask+  let+    minVerbose = env.verbose || env.debug+    minInfo = minVerbose || not env.quiet+  case level of+    LogDebug | env.debug -> accept+    LogVerbose | minVerbose -> accept+    LogInfo | minInfo -> accept+    LogWarn | minInfo -> accept+    LogError -> accept+    _ -> unit+  where+    accept = liftIO (handler level msg)

@@ -0,0 +1,216 @@+module Hix.Managed.Build where++import Control.Monad (foldM)+import qualified Data.Map.Strict as Map+import Distribution.Pretty (Pretty)+import Exon (exon)+import Text.PrettyPrint (vcat)++import Hix.Data.EnvName (EnvName)+import Hix.Data.Monad (M)+import Hix.Data.Overrides (Overrides)+import Hix.Data.PackageId (PackageId)+import Hix.Data.Version (Version, Versions)+import Hix.Data.VersionBounds (VersionBounds)+import qualified Hix.Log as Log+import Hix.Managed.Build.Solve (solveMutation)+import qualified Hix.Managed.Cabal.Changes+import Hix.Managed.Cabal.Config (isNonReinstallableDep, isReinstallableId)+import Hix.Managed.Cabal.Data.SolverState (SolverState)+import qualified Hix.Managed.Data.BuildConfig+import Hix.Managed.Data.BuildConfig (BuildConfig)+import qualified Hix.Managed.Data.EnvContext+import Hix.Managed.Data.EnvContext (EnvContext)+import Hix.Managed.Data.Mutable (MutableDep, addBuildVersions)+import qualified Hix.Managed.Data.Mutation+import Hix.Managed.Data.Mutation (BuildMutation (BuildMutation), DepMutation, MutationResult (..))+import qualified Hix.Managed.Data.MutationState+import Hix.Managed.Data.MutationState (MutationState (MutationState), updateBoundsWith)+import Hix.Managed.Data.Query (Query (Query))+import qualified Hix.Managed.Data.QueryDep+import Hix.Managed.Data.QueryDep (QueryDep)+import qualified Hix.Managed.Data.StageContext+import Hix.Managed.Data.StageContext (StageContext (StageContext))+import qualified Hix.Managed.Data.StageState+import Hix.Managed.Data.StageState (+  BuildStatus (Failure, Success),+  StageState,+  failed,+  initStageState,+  iterations,+  justSuccess,+  )+import qualified Hix.Managed.Handlers.Build+import Hix.Managed.Handlers.Build (EnvBuilder)+import qualified Hix.Managed.Handlers.Mutation+import Hix.Managed.Handlers.Mutation (MutationHandlers)+import Hix.Managed.StageState (updateStageState)+import Hix.Pretty (prettyL, showP, showPL)++logBuildInputs ::+  EnvName ->+  Text ->+  [PackageId] ->+  M ()+logBuildInputs env description overrides = do+  Log.info [exon|Building targets in '##{env}' with #{description}...|]+  Log.debugP (vcat ["Overrides:", prettyL overrides])++logBuildResult :: Text -> BuildStatus -> M ()+logBuildResult description status =+  Log.info [exon|Build with ##{description} #{result status}|]+  where+    result = \case+      Success -> "succeeded"+      Failure -> "failed"++updateMutationState ::+  (Version -> VersionBounds -> VersionBounds) ->+  Versions ->+  Overrides ->+  MutationState ->+  MutationState+updateMutationState updateBound newVersions overrides MutationState {bounds, versions, initial} =+  updateBoundsWith updateBound MutationState {+    bounds,+    versions = addBuildVersions newVersions versions,+    overrides,+    initial+  }++-- | /Note/: This quietly discards non-reinstallable packages.+--+-- TODO Discard installed versions, for builds with initial versions.+buildVersions ::+  EnvBuilder ->+  EnvContext ->+  Text ->+  Versions ->+  [PackageId] ->+  M (Overrides, BuildStatus)+buildVersions builder context description versions overrideVersions = do+  logBuildInputs context.env description reinstallable+  (overrides, status) <- builder.buildWithState versions reinstallable+  logBuildResult description status+  pure (overrides, status)+  where+    reinstallable = filter isReinstallableId overrideVersions++buildConstraints ::+  EnvBuilder ->+  EnvContext ->+  Text ->+  SolverState ->+  M (Maybe (Versions, Overrides, BuildStatus))+buildConstraints builder context description state =+  solveMutation builder.cabal context.deps state >>= traverse \ changes -> do+    (overrides, status) <- buildVersions builder context description changes.versions changes.overrides+    pure (changes.versions, overrides, status)++buildMutation ::+  EnvBuilder ->+  EnvContext ->+  MutationState ->+  BuildMutation ->+  M (Maybe MutationState)+buildMutation builder context state BuildMutation {description, solverState, updateBound} =+  result <$> buildConstraints builder context description solverState+  where+    result = \case+      Just (versions, overrides, status) ->+        justSuccess (updateMutationState updateBound versions overrides state) status+      Nothing -> Nothing++logMutationResult ::+  MutableDep ->+  MutationResult s ->+  M ()+logMutationResult package = \case+  MutationSuccess candidate True _ _ ->+    Log.verbose [exon|Build succeeded for #{showP candidate}|]+  MutationSuccess _ False _ _ ->+    Log.verbose [exon|Build is up to date for '##{package}'|]+  MutationKeep ->+    Log.verbose [exon|No better version found for '##{package}'|]+  MutationFailed ->+    Log.verbose [exon|Could not find a buildable version of '##{package}'|]++validateMutation ::+  EnvBuilder ->+  EnvContext ->+  MutationHandlers a s ->+  StageState a s ->+  DepMutation a ->+  M (StageState a s)+validateMutation envBuilder context handlers stageState mutation = do+  result <- processReinstallable+  logMutationResult mutation.package result+  pure (updateStageState stageState mutation result)+  where+    processReinstallable+      | isNonReinstallableDep mutation.package+      = pure MutationKeep+      | otherwise+      = handlers.process stageState.ext mutation build+    build = buildMutation envBuilder context stageState.state++convergeMutations ::+  Pretty a =>+  MutationHandlers a s ->+  BuildConfig ->+  EnvBuilder ->+  EnvContext ->+  StageState a s ->+  [DepMutation a] ->+  M (StageState a s)+convergeMutations handlers conf builder context state0 =+  spin state0 {iterations = 0}+  where+    spin state mutations++      | [] <- mutations+      = pure state++      | state.iterations >= conf.maxIterations+      = pure state++      | otherwise+      = do+        Log.debug [exon|Iteration #{show (state.iterations + 1)} for '##{context.env :: EnvName}'|]+        newState <- build state mutations+        if Map.size newState.success == Map.size state.success+        then pure newState+        -- reversing so the build order is consistent+        else spin newState (reverse newState.failed)++    build statePre mutations = do+      let state = statePre {failed = [], iterations = statePre.iterations + 1}+      Log.debug [exon|Building targets with mutations: #{showPL mutations}|]+      foldM (validateMutation builder context handlers) state mutations++reinstallableCandidates ::+  (QueryDep -> M (Maybe (DepMutation a))) ->+  Query ->+  M [DepMutation a]+reinstallableCandidates candidates (Query query) =+  catMaybes <$> traverse reinstallableOnly (toList query)+  where+    reinstallableOnly dep+      | isNonReinstallableDep dep.package+      = pure Nothing+      | otherwise+      = candidates dep++processQuery ::+  Pretty a =>+  (QueryDep -> M (Maybe (DepMutation a))) ->+  MutationHandlers a s ->+  BuildConfig ->+  StageContext ->+  s ->+  M (StageState a s)+processQuery candidates handlers conf StageContext {env, builder, state, query = query} ext = do+  mutations <- reinstallableCandidates candidates query+  convergeMutations handlers conf builder env stageState mutations+  where+    stageState = initStageState state ext

@@ -0,0 +1,77 @@+module Hix.Managed.Build.Mutation where++import Control.Lens ((.~))+import Exon (exon)++import Hix.Class.Map (nAdjust, nAmendWithKey)+import Hix.Data.Monad (M)+import qualified Hix.Data.PackageId+import Hix.Data.PackageId (PackageId (PackageId))+import Hix.Data.Version (Version)+import Hix.Data.VersionBounds (VersionBounds, exactVersion)+import qualified Hix.Log as Log+import Hix.Managed.Cabal.Data.SolverState (SolverState, updateSolverState)+import Hix.Managed.Data.Constraints (EnvConstraints, MutationConstraints)+import Hix.Managed.Data.Mutable (MutableDep, depName, mutRelax)+import qualified Hix.Managed.Data.MutableId+import Hix.Managed.Data.MutableId (MutableId (MutableId))+import qualified Hix.Managed.Data.Mutation+import Hix.Managed.Data.Mutation (BuildMutation (BuildMutation))+import qualified Hix.Managed.Data.MutationState+import Hix.Managed.Data.MutationState (MutationState)+import Hix.Managed.Data.Packages (Deps)+import Hix.Pretty (showP)++candidateMutation ::+  SolverState ->+  MutableId ->+  (Version -> VersionBounds -> VersionBounds) ->+  BuildMutation+candidateMutation solverState candidate updateBound =+  BuildMutation {+    description = showP candidate,+    solverState,+    updateBound+  }++candidateConstraints :: MutableId -> EnvConstraints -> EnvConstraints+candidateConstraints MutableId {..} constraints =+  nAdjust (depName name) constraints (#mutation .~ exactVersion version)++updateConstraints ::+  (MutableId -> PackageId -> MutationConstraints -> MutationConstraints) ->+  MutableId ->+  MutationState ->+  EnvConstraints ->+  EnvConstraints+updateConstraints impl candidate state =+  nAmendWithKey update (mutRelax state.versions :: Deps (Maybe Version))+  where+    update name = \case+      Just version -> impl candidate PackageId {..}+      Nothing -> id++-- | Boilerplate for mutation handlers, could be better.+--+-- TODO If we'd use the @retract@ field from @DepMutation@ and the target bound here, we could probably use a universal+-- bounds updater without leaking implementation...investigate.+buildCandidate ::+  (BuildMutation -> M (Maybe MutationState)) ->+  (Version -> VersionBounds -> VersionBounds) ->+  (MutableId -> PackageId -> MutationConstraints -> MutationConstraints) ->+  SolverState ->+  MutableDep ->+  Version ->+  M (Maybe (MutableId, SolverState, MutationState))+buildCandidate build updateStateBound updateConstraintBound solverState package version = do+  Log.debug [exon|Mutation constraints for #{showP candidate}: #{showP mutationSolverState.constraints}|]+  fmap result <$> build (candidateMutation mutationSolverState candidate updateStateBound)+  where+    result newState = (candidate, newSolverState newState, newState)++    candidate = MutableId {name = package, version}++    mutationSolverState = updateSolverState (candidateConstraints candidate) solverState++    newSolverState newState =+      updateSolverState (updateConstraints updateConstraintBound candidate newState) solverState

@@ -0,0 +1,25 @@+module Hix.Managed.Build.Single where++import Hix.Data.Monad (M)+import Hix.Data.VersionBounds (exactVersion)+import Hix.Managed.Build (buildConstraints)+import Hix.Managed.Cabal.Data.SolverState (solverState)+import Hix.Managed.Constraints (fromVersions)+import qualified Hix.Managed.Data.EnvContext+import Hix.Managed.Data.EnvContext (EnvContext)+import Hix.Managed.Data.Mutable (MutableVersions)+import Hix.Managed.Data.StageState (BuildStatus (Failure))+import Hix.Managed.Handlers.Build (EnvBuilder)++buildVersions ::+  EnvBuilder ->+  EnvContext ->+  Text ->+  MutableVersions ->+  M BuildStatus+buildVersions builder context description versions =+  buildConstraints builder context description solver <&> \case+    Just (_, _, status) -> status+    Nothing -> Failure+  where+    solver = solverState context.solverBounds context.deps (fromVersions exactVersion versions) def

@@ -0,0 +1,51 @@+module Hix.Managed.Build.Solve where++import qualified Data.Set as Set+import Distribution.Pretty (pretty)+import Exon (exon)+import Text.PrettyPrint (hang)++import Hix.Class.Map (nRestrictKeys)+import Hix.Data.Monad (M)+import qualified Hix.Data.PackageId+import Hix.Data.PackageId (PackageId (PackageId))+import Hix.Data.PackageName (isLocalPackage)+import Hix.Data.Version (packageIdVersions)+import qualified Hix.Log as Log+import qualified Hix.Managed.Cabal.Changes+import Hix.Managed.Cabal.Changes (SolverChanges (SolverChanges), SolverPlan (SolverPlan))+import Hix.Managed.Cabal.Data.SolverState (SolverState)+import qualified Hix.Managed.Data.EnvContext+import Hix.Managed.Data.EnvContext (EnvDeps)+import Hix.Managed.Data.Mutable (depName)+import qualified Hix.Managed.Handlers.Cabal+import Hix.Managed.Handlers.Cabal (CabalHandlers)+import Hix.Pretty (showPL)++logNonReinstallable :: NonEmpty PackageId -> M ()+logNonReinstallable ids =+  Log.verbose [exon|NOTE: Cabal solver suggested new versions for non-reinstallable packages: #{showPL ids}|]++-- TODO Do we need to filter locals out of @matching@ or can those not be in there?+processSolverPlan ::+  EnvDeps ->+  SolverPlan ->+  M SolverChanges+processSolverPlan deps SolverPlan {..} = do+  Log.debugP (hang "New project deps from solver:" 2 (pretty projectDeps))+  traverse_ logNonReinstallable nonReinstallable+  pure SolverChanges {versions, overrides, projectDeps}+  where+    projectDeps = nRestrictKeys mutablePIds versions+    versions = packageIdVersions (overrides ++ matching)+    overrides = filter notLocal changes+    notLocal PackageId {name} = not (isLocalPackage deps.local name)+    mutablePIds = Set.fromList (depName <$> Set.toList deps.mutable)++solveMutation ::+  CabalHandlers ->+  EnvDeps ->+  SolverState ->+  M (Maybe SolverChanges)+solveMutation cabal deps state =+  traverse (processSolverPlan deps) =<< cabal.solveForVersion state

@@ -0,0 +1,67 @@+module Hix.Managed.BuildOutput where++import qualified Data.Aeson as Aeson+import Data.List.Extra (nubSortOn)+import qualified Data.Text as Text+import Data.These.Combinators (justThere)++import Hix.Data.Monad (M)+import Hix.Data.OutputFormat (OutputFormat (..))+import Hix.Data.OutputTarget (OutputTarget (..))+import Hix.Data.PackageName (PackageName (PackageName))+import Hix.Managed.BuildOutput.CommitMsg (formatCommit)+import Hix.Managed.BuildOutput.GithubActionsPr (githubActionsPr)+import qualified Hix.Managed.Data.BuildOutput+import Hix.Managed.Data.BuildOutput (BuildOutput (BuildOutput), ModifiedId (ModifiedId))+import Hix.Managed.Data.Mutable (MutableDep, depName)+import qualified Hix.Managed.Data.Mutation+import Hix.Managed.Data.ProjectResult (ProjectResult)+import qualified Hix.Managed.EnvResult+import Hix.Managed.EnvResult (+  DepModification (DepAdded, DepUpdated),+  DepResult,+  DepResultDetail (DepModified),+  DepResults (DepResults),+  )+import qualified Hix.Managed.ProjectResult as ProjectResult+import qualified Hix.OutputWriter+import Hix.OutputWriter (outputWriterGlobal)++outputResult :: BuildOutput -> OutputTarget -> OutputFormat -> M ()+outputResult output target = \case+  OutputNone -> unit+  OutputJson -> writer.bytes (toStrict (Aeson.encode output))+  OutputCommitMsg -> traverse_ writer.text (formatCommit output)+  OutputGaPr -> githubActionsPr output target+  where+    writer = outputWriterGlobal target++buildOutputFromLists :: [ModifiedId] -> [MutableDep] -> [MutableDep] -> BuildOutput+buildOutputFromLists modified unmodified failed =+  BuildOutput {+    modified,+    unmodified,+    failed,+    modifiedNames = comma ((.package) <$> modified),+    unmodifiedNames = comma unmodified,+    failedNames = comma failed+  }+  where+    comma = fmap (Text.intercalate ", " . fmap (coerce . depName) . toList) . nonEmpty++modifiedId :: DepResult -> ModifiedId+modifiedId result =+  ModifiedId {package = result.package, version = result.version, range}+  where+    range = case result.detail of+      DepModified (DepUpdated (justThere -> Just _)) -> Just result.bounds+      DepModified (DepAdded _) -> Just result.bounds+      _ -> Nothing++buildOutput :: ProjectResult -> BuildOutput+buildOutput result =+  buildOutputFromLists modified ((.package) <$> unmodified) failed+  where+    modified = modifiedId <$> nubSortOn (.package) (added ++ updated)+    failed = (.package) <$> ProjectResult.failures result+    DepResults {..} = ProjectResult.grouped result

@@ -0,0 +1,32 @@+module Hix.Managed.BuildOutput.CommitMsg where++import qualified Data.Text as Text+import Exon (exon)++import qualified Hix.Managed.Data.BuildOutput+import Hix.Managed.Data.BuildOutput (BuildOutput, ModifiedId)+import Hix.Pretty (showP)++commitMessage :: Int -> Text -> Text+commitMessage num names+  | num <= 3+  = [exon|Bump #{names}|]+  | otherwise+  = [exon|Bump #{show num} dependencies|]++candidateList :: [ModifiedId] -> [Text]+candidateList = fmap \ c -> [exon|* #{showP c}|]++commitBody :: [ModifiedId] -> [Text]+commitBody candidates =+  ["New versions:", ""] ++ candidateList candidates++commit :: BuildOutput -> Maybe (Text, [Text])+commit output =+  output.modifiedNames <&> \ names ->+    (commitMessage (length output.modified) names, commitBody output.modified)++formatCommit :: BuildOutput -> Maybe Text+formatCommit output =+  commit output <&> \ (msg, body) ->+    Text.intercalate "\n" ([msg, ""] ++ body)

@@ -0,0 +1,58 @@+module Hix.Managed.BuildOutput.GithubActionsPr where++import qualified Data.Map.Strict as Map+import qualified Data.Text as Text+import Exon (exon)+import Path (parseAbsFile)+import System.Environment (getEnv)+import System.Posix (epochTime)++import Hix.Data.Error (Error (Client, Fatal))+import Hix.Data.Monad (M)+import Hix.Data.OutputTarget (OutputTarget)+import Hix.Managed.BuildOutput.CommitMsg (commit)+import Hix.Managed.Data.BuildOutput (BuildOutput)+import Hix.Monad (note, throwM, tryIOMAs)+import qualified Hix.OutputWriter+import Hix.OutputWriter (OutputWriter, fileWriter, outputWriterM)++envVarWriter :: M OutputWriter+envVarWriter = do+  var <- tryIOMAs envVarError (getEnv "GITHUB_OUTPUT")+  outFile <- note envVarError (parseAbsFile var)+  pure (fileWriter writeError outFile)+  where+    envVarError = Client "The variable $GITHUB_OUTPUT does not contain a file path"+    writeError err = throwM (Fatal [exon|Couldn't write to $GITHUB_OUTPUT: #{err.msg}|])++formatOutput :: Text -> [Text] -> [Text]+formatOutput key = \case+  [value] -> [[exon|#{key}=#{value}|]]+  value -> [exon|#{key}<<EOF|] : value ++ ["EOF"]++formatOutputs :: Map Text [Text] -> [Text]+formatOutputs =+  concatMap (uncurry formatOutput) . Map.toList++writeOutputs :: OutputWriter -> Map Text [Text] -> M ()+writeOutputs writer values =+  writer.textAppend (Text.unlines (formatOutputs values))++modifiedOutputs :: Text -> Text -> [Text] -> Map Text [Text]+modifiedOutputs date msg body =+  [+    ("branch", [[exon|hix-managed/bump-#{date}|]]),+    ("commit-message", [msg, ""] ++ body),+    ("title", [msg]),+    ("body", body),+    ("committer", ["hix <noreply@github.com>"]),+    ("signoff", ["false"]),+    ("delete-branch", ["true"])+  ]++githubActionsPr :: BuildOutput -> OutputTarget -> M ()+githubActionsPr output target =+  for_ (commit output) \ (msg, body) -> do+    date <- liftIO epochTime+    writer <- outputWriterM envVarWriter target+    writeOutputs writer (modifiedOutputs (show date) msg body)

@@ -0,0 +1,17 @@+module Hix.Managed.Bump.App where++import Hix.Data.Error (Error (Client))+import Hix.Data.Monad (M)+import qualified Hix.Data.Options+import Hix.Data.Options (BumpOptions (BumpOptions))+import Hix.Json (jsonConfigE)+import Hix.Managed.Bump.Optimize (bumpOptimizeMain)+import qualified Hix.Managed.Data.ProjectContextProto+import Hix.Managed.Handlers.Build.Test (chooseHandlers)+import Hix.Managed.ProjectContext (withProjectContext)++bumpCli :: BumpOptions -> M ()+bumpCli BumpOptions {common = opts} = do+  context <- jsonConfigE Client opts.context+  handlers <- liftIO (chooseHandlers opts.stateFile context.envs context.buildOutputsPrefix opts.cabal opts.handlers)+  withProjectContext handlers opts.project context (bumpOptimizeMain handlers)

@@ -0,0 +1,47 @@+module Hix.Managed.Bump.Candidates where++import Distribution.Version (Version)++import Hix.Data.Monad (M)+import qualified Hix.Managed.Data.Bump+import Hix.Managed.Data.Bump (Bump (Bump))+import Hix.Managed.Data.Mutable (depName)+import qualified Hix.Managed.Data.Mutation+import Hix.Managed.Data.Mutation (DepMutation (DepMutation))+import qualified Hix.Managed.Data.QueryDep+import Hix.Managed.Data.QueryDep (QueryDep (QueryDep))+import qualified Hix.Managed.Handlers.Build+import Hix.Managed.Handlers.Build (BuildHandlers)+import Hix.Version (nextMajor)++-- | We only want to report a bump if the new version actually changes the build.+isBump :: Version -> Maybe Version -> Bool+isBump version = \case+  Just current -> version > current+  Nothing -> True++-- | Decide whether the latest version of a dependency requires changes to the currently specified bound.+--+-- If no latest version can be found, we return 'Nothing' to indicate that the dep should be skipped.+--+-- Otherwise, the range field of the 'DepMutation' is determined:+--+-- If the specified dependency has no upper bound (e.g. because the user has only entered the package name and ran the+-- app to resolve the bounds), or if the latest version is outside of the existing bounds, then we add a new bound to+-- the managed state, so we extend the version range by setting the upper bound to the major prefix of the next-highest+-- major of the latest version and return 'NewBounds'.+--+-- Otherwise, we return 'OldBounds'.+candidatesBump ::+  BuildHandlers ->+  QueryDep ->+  M (Maybe (DepMutation Bump))+candidatesBump handlers QueryDep {package, current} = do+  fmap mutation <$> handlers.latestVersion (depName package)+  where+    mutation version =+      DepMutation {+        package,+        retract = False,+        mutation = Bump {version, bound = nextMajor version, changed = isBump version current}+      }

@@ -0,0 +1,126 @@+module Hix.Managed.Bump.Optimize where++import Exon (exon)++import Hix.Class.Map (nMap)+import Hix.Data.Monad (M)+import qualified Hix.Data.Overrides+import Hix.Data.VersionBounds (fromLower)+import Hix.Managed.Build (processQuery)+import Hix.Managed.Bump.Candidates (candidatesBump)+import qualified Hix.Managed.Cabal.Data.SolverState+import Hix.Managed.Cabal.Data.SolverState (SolverFlags (SolverFlags), solverState)+import Hix.Managed.Constraints (fromVersions, preferInstalled, preferVersions)+import qualified Hix.Managed.Data.BuildConfig+import Hix.Managed.Data.BuildConfig (BuildConfig)+import Hix.Managed.Data.Bump (Bump (..))+import Hix.Managed.Data.Constraints (EnvConstraints)+import qualified Hix.Managed.Data.EnvContext+import Hix.Managed.Data.EnvContext (EnvDeps)+import Hix.Managed.Data.Initial (Initial (Initial))+import Hix.Managed.Data.Mutable (MutableDep)+import qualified Hix.Managed.Data.MutableId+import Hix.Managed.Data.MutableId (MutableId (MutableId))+import Hix.Managed.Data.Mutation (DepMutation (..))+import qualified Hix.Managed.Data.MutationState+import Hix.Managed.Data.MutationState (MutationState)+import qualified Hix.Managed.Data.ProjectContext+import Hix.Managed.Data.ProjectContext (ProjectContext)+import Hix.Managed.Data.ProjectResult (ProjectResult)+import Hix.Managed.Data.Query (Query (Query))+import qualified Hix.Managed.Data.StageContext+import Hix.Managed.Data.StageContext (StageContext (StageContext))+import Hix.Managed.Data.StageResult (StageResult, StageSummary (StageNoAction, StageReport))+import Hix.Managed.Data.StageState (BuildStatus, BuildSuccess)+import Hix.Managed.Flow (Flow, execStage, execStatelessStage)+import qualified Hix.Managed.Handlers.Build+import Hix.Managed.Handlers.Build (BuildHandlers)+import Hix.Managed.Handlers.Cabal (CabalHandlers, installedVersions)+import Hix.Managed.Handlers.Mutation.Bump (handlersBump)+import Hix.Managed.Process (processProject)+import Hix.Managed.Report (describeIterations)+import Hix.Managed.StageResult (stageResult)++-- | Solver params for Bump consist of, in decreasing order of precedence:+--+-- - User-specified bounds (added by the constructor 'solverState').+--+-- - The existing overrides from previous runs, used as preferred versions.+--   This ensures that the solver selects the same versions as in the last run while still allowing newer versions for+--   transitive dependencies that are later in the candidate list.+--+-- - Installed versions from the package db, used as lower bounds.+--+-- - The preference for using the installed version for mutable deps, which is a fallback for packages without overrides+--   (since their chosen versions are installed).+bumpSolverParams ::+  EnvDeps ->+  CabalHandlers ->+  Initial MutationState ->+  EnvConstraints+bumpSolverParams deps cabal (Initial state) =+  preferVersions (nMap (.version) state.overrides) <>+  fromVersions fromLower (installedVersions cabal deps.mutable) <>+  preferInstalled deps.mutable++success :: Map MutableDep BuildSuccess -> Natural -> Text+success _ iterations =+  [exon|Found working latest versions for all deps after #{iter}.|]+  where+    iter = describeIterations iterations++failure :: Natural -> Text+failure iterations =+  [exon|Couldn't find working latest versions for some deps after #{describeIterations iterations}.|]++bumpBuild ::+  BuildHandlers ->+  BuildConfig ->+  StageContext ->+  M StageResult+bumpBuild handlers conf stage@StageContext {env, builder, state} = do+  result <- processQuery (candidatesBump handlers) handlersBump conf stage ext+  pure (stageResult success failure result)+  where+    ext = solverState env.solverBounds env.deps (bumpSolverParams env.deps builder.cabal state) flags+    flags = SolverFlags {allowNewer = True}++bumpBuildStage ::+  BuildHandlers ->+  BuildConfig ->+  Flow BuildStatus+bumpBuildStage handlers conf =+  execStage "bump" (bumpBuild handlers conf)++bumpReportStage ::+  BuildHandlers ->+  Flow BuildStatus+bumpReportStage handlers =+  execStatelessStage "bump-report" \ StageContext {query = Query query} ->+    toSummary . toCandidates <$> traverse (candidatesBump handlers) (toList query)+  where+    toSummary = \case+      Just cs -> StageReport "Found new versions:" cs+      Nothing -> StageNoAction (Just "All dependencies are up to date.")++    toCandidates = nonEmpty . fmap toCandidate . catMaybes++    toCandidate DepMutation {package = name, mutation = Bump {version}} =+      MutableId {..}++bumpStages ::+  BuildHandlers ->+  BuildConfig ->+  Flow BuildStatus+bumpStages handlers conf+  | conf.lookup+  = bumpReportStage handlers+  | otherwise+  = bumpBuildStage handlers conf++bumpOptimizeMain ::+  BuildHandlers ->+  ProjectContext ->+  M ProjectResult+bumpOptimizeMain handlers project =+  processProject handlers project (void (bumpStages handlers project.build))

@@ -0,0 +1,67 @@+module Hix.Managed.Cabal.Changes where++import Data.List (partition)+import qualified Distribution.Client.SolverInstallPlan as SolverInstallPlan+import Distribution.Client.SolverInstallPlan (ResolverPackage (Configured, PreExisting), SolverInstallPlan)+import Distribution.InstalledPackageInfo (InstalledPackageInfo (..))+import Distribution.Pretty (Pretty, pretty)+import Distribution.Solver.Types.InstSolverPackage (InstSolverPackage (..))+import Distribution.Solver.Types.SolverPackage (SolverPackage (..))+import Distribution.Solver.Types.SourcePackage (SourcePackage (..))+import Text.PrettyPrint (hang, ($+$))++import qualified Hix.Data.PackageId as PackageId+import Hix.Data.PackageId (PackageId)+import Hix.Data.Version (Versions)+import Hix.Managed.Cabal.Config (isNonReinstallableId)+import Hix.Pretty (prettyL)++-- | Raw results from Cabal, which include local packages in the overrides.+data SolverPlan =+  SolverPlan {+    -- | Deps whose versions differ from those in the package db, i.e. where the GHC set from nixpkgs has a different+    -- version.+    -- We need to add Nix overrides for these.+    changes :: [PackageId],++    -- | Versions that match those in the package db.+    -- We don't need to add Nix overrides for these.+    matching :: [PackageId],++    -- | GHC boot packages that were selected for reinstallation, which is an error with the default settings.+    nonReinstallable :: Maybe (NonEmpty PackageId)+  }+  deriving stock (Eq, Show, Generic)++instance Pretty SolverPlan where+  pretty SolverPlan {changes, matching} =+    hang "changes:" 2 (prettyL changes) $+$ hang "matching:" 2 (prettyL matching)++solverPlan ::+  SolverInstallPlan ->+  SolverPlan+solverPlan plan =+  SolverPlan {..}+  where+    (nonEmpty -> nonReinstallable, changes) = partition isNonReinstallableId configured++    (configured, matching) = partitionEithers (mkVersion <$> SolverInstallPlan.toList plan)++    mkVersion = \case+      Configured SolverPackage {solverPkgSource = SourcePackage {srcpkgPackageId}} ->+        Left (PackageId.fromCabal srcpkgPackageId)+      PreExisting InstSolverPackage {instSolverPkgIPI = InstalledPackageInfo {sourcePackageId}} ->+        Right (PackageId.fromCabal sourcePackageId)++data SolverChanges =+  SolverChanges {+    versions :: Versions,+    overrides :: [PackageId],+    projectDeps :: Versions+  }+  deriving stock (Eq, Show, Generic)++instance Pretty SolverChanges where+  pretty SolverChanges {..} =+    hang "overrides:" 2 (prettyL overrides) $+$+    hang "projectDeps:" 2 (pretty projectDeps)

@@ -0,0 +1,35 @@+module Hix.Managed.Cabal.Config where++import qualified Data.Set as Set++import qualified Hix.Data.PackageId+import Hix.Data.PackageId (PackageId)+import Hix.Data.PackageName (PackageName)+import Hix.Managed.Data.Mutable (MutableDep, depName)++nonReinstallableNames :: Set PackageName+nonReinstallableNames =+  [+    "base",+    "ghc-bignum",+    "ghc-prim",+    "ghc",+    "integer-gmp",+    "integer-simple",+    "template-haskell"+  ]++isNonReinstallable :: PackageName -> Bool+isNonReinstallable = flip Set.member nonReinstallableNames++isReinstallable :: PackageName -> Bool+isReinstallable = not . isNonReinstallable++isNonReinstallableId :: PackageId -> Bool+isNonReinstallableId package = isNonReinstallable package.name++isReinstallableId :: PackageId -> Bool+isReinstallableId package = isReinstallable package.name++isNonReinstallableDep :: MutableDep -> Bool+isNonReinstallableDep = isNonReinstallable . depName

@@ -0,0 +1,64 @@+module Hix.Managed.Cabal.Data.Config where++import Data.Aeson (FromJSON (parseJSON))+import Distribution.Client.IndexUtils.Timestamp (Timestamp)+import Distribution.Verbosity (Verbosity, verbose)+import Path (Abs, Dir, Path)++import Hix.Managed.Cabal.Data.Packages (GhcPackages)++newtype HackageRepoName =+  HackageRepoName Text+  deriving stock (Eq, Show, Generic)+  deriving newtype (IsString, Ord)++instance Default HackageRepoName where+  def = "hackage.haskell.org"++newtype GhcPath =+  GhcPath (Path Abs Dir)+  deriving stock (Eq, Show, Generic)+  deriving newtype (FromJSON)++data GhcDb =+  GhcDbSystem (Maybe GhcPath)+  |+  GhcDbSynthetic GhcPackages+  deriving stock (Eq, Show, Generic)++instance FromJSON GhcDb where+  parseJSON = fmap GhcDbSystem . parseJSON++newtype HackageIndexState =+  HackageIndexState Timestamp+  deriving stock (Eq, Show, Generic)++data CabalConfig =+  CabalConfig {+    indexState :: Maybe HackageIndexState+  }+  deriving stock (Eq, Show, Generic)++instance Default CabalConfig where+  def =+    CabalConfig {indexState = Nothing}++data SolveConfig =+  SolveConfig {+    hackageRepoName :: HackageRepoName,+    verbosity :: Verbosity,+    ghc :: Maybe GhcPath,+    allowBoot :: Bool,+    cabal :: CabalConfig+  }+  deriving stock (Eq, Show, Generic)++instance Default SolveConfig where+  def =+    SolveConfig {+      hackageRepoName = def,+      verbosity = verbose,+      ghc = Nothing,+      allowBoot = False,+      cabal = def+    }

@@ -0,0 +1,23 @@+module Hix.Managed.Cabal.Data.Packages where++import GHC.Exts (IsList)++import Hix.Data.PackageId (PackageId)+import Hix.Managed.Cabal.Data.SourcePackage (SourcePackages)++newtype InstalledPackages =+  InstalledPackages [(PackageId, [PackageId])]+  deriving stock (Eq, Show, Generic)+  deriving newtype (IsList, Semigroup, Monoid)++-- | Mock data for package indexes for the solver.+--+-- Installed packages should not contain local packages, since they have fixed dependency versions.+-- Instead, they should be included in the available packages, but this is done automatically by the @SolveResources@+-- initializer, so these here correspond only to Hackage packages.+data GhcPackages =+  GhcPackages {+    installed :: InstalledPackages,+    available :: SourcePackages+  }+  deriving stock (Eq, Show, Generic)

@@ -0,0 +1,23 @@+module Hix.Managed.Cabal.Data.SolveResources where++import Distribution.Client.Dependency (DepResolverParams)+import Distribution.Client.Types (SourcePackageDb)+import Distribution.Simple (CompilerInfo)+import Distribution.Simple.PackageIndex (InstalledPackageIndex)+import Distribution.Solver.Types.PkgConfigDb (PkgConfigDb)+import Distribution.System (Platform)++import Hix.Managed.Cabal.Data.Config (SolveConfig (..))+import Hix.Managed.Cabal.Init (SolveFlags)++data SolveResources =+  SolveResources {+    conf :: SolveConfig,+    flags :: SolveFlags,+    platform :: Platform,+    compiler :: CompilerInfo,+    pkgConfigDb :: PkgConfigDb,+    installedPkgIndex :: InstalledPackageIndex,+    sourcePkgDb :: SourcePackageDb,+    solverParams :: DepResolverParams -> DepResolverParams+  }

@@ -0,0 +1,36 @@+module Hix.Managed.Cabal.Data.SolveTarget where++import Distribution.Client.Dependency (PackagePreference (..), PackageSpecifier (NamedPackage, SpecificSourcePackage))+import Distribution.Client.Types (UnresolvedSourcePackage)+import Distribution.Pretty (Pretty (pretty))+import Distribution.Solver.Types.PackageConstraint (dispPackageProperty)+import Distribution.Version (simplifyVersionRange)+import Text.PrettyPrint (Doc, (<+>))++import Hix.Pretty (prettyL)++data SolveTarget =+  SolveTarget {+    dep :: PackageSpecifier UnresolvedSourcePackage,+    prefs :: [PackagePreference]+  }++prettySpec :: PackageSpecifier UnresolvedSourcePackage -> Doc+prettySpec = \case+  NamedPackage name prop ->+    "Named:" <+> pretty name <+> prettyL (dispPackageProperty <$> prop)+  SpecificSourcePackage pkg ->+    "Source:" <+> show pkg++prettyPref :: PackagePreference -> Doc+prettyPref = \case+  PackageVersionPreference   pn vr ->+    pretty pn <+> pretty (simplifyVersionRange vr)+  PackageInstalledPreference pn ip ->+    pretty pn <+> show ip+  PackageStanzasPreference pn st ->+    pretty pn <+> show st++instance Pretty SolveTarget where+  pretty SolveTarget {..} =+    prettySpec dep <+> prettyL (prettyPref <$> prefs)

@@ -0,0 +1,83 @@+module Hix.Managed.Cabal.Data.SolverState (+  SolverState (SolverState, constraints, flags),+  solverState,+  updateSolverState,+  SolverFlags (..),+  compileSolverFlags,+) where++import Distribution.Client.Dependency (DepResolverParams, removeUpperBounds)+import Distribution.Client.Types (RelaxDeps (RelaxDepsAll))+import Distribution.Client.Types.AllowNewer (AllowNewer (AllowNewer))+import GHC.Records (HasField (getField))++import Hix.Class.Map (nGenWith)+import Hix.Data.Bounds (Ranges)+import Hix.Data.PackageName (LocalPackage (LocalPackage))+import Hix.Managed.Constraints (explicitBounds, noBounds)+import Hix.Managed.Data.Constraints (EnvConstraints)+import qualified Hix.Managed.Data.EnvContext+import Hix.Managed.Data.EnvContext (EnvDeps)+import Hix.Managed.Data.Mutable (MutableDep, depName)++data SolverFlags =+  SolverFlags {+    allowNewer :: Bool+  }+  deriving stock (Eq, Show, Generic)++instance Default SolverFlags where+  def = SolverFlags {allowNewer = False}++flagAllowNewer :: DepResolverParams -> DepResolverParams+flagAllowNewer =+  removeUpperBounds (AllowNewer RelaxDepsAll)++compileSolverFlags :: SolverFlags -> DepResolverParams -> DepResolverParams+compileSolverFlags SolverFlags {..} =+  flag flagAllowNewer allowNewer+  where+    flag f v | v = f+             | otherwise = id++data SolverState =+  UnsafeSolverState EnvConstraints SolverFlags+  deriving stock (Eq, Show)++pattern SolverState :: EnvConstraints -> SolverFlags -> SolverState+pattern SolverState {constraints, flags} <- UnsafeSolverState constraints flags++{-# complete SolverState #-}++instance HasField "constraints" SolverState EnvConstraints where+  getField (UnsafeSolverState c _) = c++instance HasField "flags" SolverState SolverFlags where+  getField (UnsafeSolverState _ p) = p++-- TODO What's the point of this now that there's no @local@ flag in the constraints anymore?+localDepConstraints :: Set LocalPackage -> EnvConstraints+localDepConstraints =+  nGenWith \ (LocalPackage package) -> (package, noBounds)++mutableDepConstraints :: Set MutableDep -> EnvConstraints+mutableDepConstraints =+  nGenWith \ package -> (depName package, noBounds)++solverState ::+  Ranges ->+  EnvDeps ->+  EnvConstraints ->+  SolverFlags ->+  SolverState+solverState user deps modeConstraints flags =+  UnsafeSolverState constraints flags+  where+    constraints =+      modeConstraints <>+      explicitBounds user <>+      localDepConstraints deps.local <>+      mutableDepConstraints deps.mutable++updateSolverState :: (EnvConstraints -> EnvConstraints) -> SolverState -> SolverState+updateSolverState f (UnsafeSolverState c p) = UnsafeSolverState (f c) p

@@ -0,0 +1,40 @@+module Hix.Managed.Cabal.Data.SourcePackage where++import Distribution.Pretty (Pretty (pretty))+import Distribution.Simple (Version)+import GHC.Exts (IsList)++import Hix.Class.Map (LookupMaybe, LookupMonoid, NMap, nPretty1, nPrettyWith)+import Hix.Data.Dep (Dep)+import Hix.Data.PackageName (PackageName)+import Hix.Pretty (prettyL)++newtype SourcePackageDeps =+  SourcePackageDeps (Map Version [Dep])+  deriving stock (Eq, Show, Generic)+  deriving newtype (Semigroup, Monoid, IsList)++instance NMap SourcePackageDeps Version [Dep] LookupMonoid where++instance Pretty SourcePackageDeps where+  pretty = nPrettyWith prettyL++newtype SourcePackages =+  SourcePackages (Map PackageName SourcePackageDeps)+  deriving stock (Eq, Show, Generic)+  deriving newtype (Semigroup, Monoid, IsList)++instance NMap SourcePackages PackageName SourcePackageDeps LookupMaybe where++instance Pretty SourcePackages where+  pretty = nPretty1++newtype SourcePackageVersions =+  SourcePackageVersions (Map PackageName [Version])+  deriving stock (Eq, Show, Generic)+  deriving newtype (Semigroup, Monoid, IsList)++instance NMap SourcePackageVersions PackageName [Version] LookupMaybe where++instance Pretty SourcePackageVersions where+  pretty = nPrettyWith prettyL

@@ -0,0 +1,85 @@+module Hix.Managed.Cabal.Init where++import Distribution.Client.Config (defaultCacheDir)+import Distribution.Client.GlobalFlags (GlobalFlags (..), defaultGlobalFlags)+import Distribution.Client.NixStyleOptions (NixStyleFlags (..), defaultNixStyleFlags)+import Distribution.Client.ProjectFlags (flagIgnoreProject)+import Distribution.Client.Types (RemoteRepo (..))+import Distribution.Parsec (eitherParsec)+import Distribution.Simple.Program (defaultProgramDb)+import Distribution.Simple.Setup (ConfigFlags (..), defaultConfigFlags, maybeToFlag, toFlag)+import Distribution.Utils.NubList (toNubList)+import Exon (exon)+import Path (reldir, relfile, toFilePath, (</>))++import Hix.Data.Error (Error (Fatal))+import qualified Hix.Managed.Cabal.Data.Config+import Hix.Managed.Cabal.Data.Config (GhcPath (GhcPath), HackageRepoName, SolveConfig)+import Hix.Managed.Cabal.Repo (ensureHackageIndex)+import Hix.Monad (M, throwM, tryIOMWith)++data SolveFlags =+  SolveFlags {+    global :: GlobalFlags,+    main :: NixStyleFlags ()+  }++emptySolveFlags :: SolveFlags+emptySolveFlags =+  SolveFlags {+    global = defaultGlobalFlags {globalConfigFile = toFlag "/dev/null"},+    main = defaultNixStyleFlags ()+  }++hackageRepo ::+  HackageRepoName ->+  M RemoteRepo+hackageRepo repoName =+  case eitherParsec [exon|##{repoName}:http://hackage.haskell.org/|] of+    Right repo -> pure repo {remoteRepoSecure = Just True}+    Left err -> throwM (Fatal [exon|Parse error: #{toText err}|])++globalFlags :: RemoteRepo -> FilePath -> GlobalFlags+globalFlags hackage cacheDir =+  defaultGlobalFlags {+    -- Cabal *always* reads ~/.cabal/config if no file is specified, and crashes if the file doesn't exist+    globalConfigFile = toFlag "/dev/null",+    globalCacheDir = toFlag cacheDir,+    globalRemoteRepos = toNubList [hackage]+  }++badCacheDir :: Text -> Error+badCacheDir err = Fatal [exon|Cannot access Cabal cache dir: #{err}|]++mainFlags ::+  SolveConfig ->+  NixStyleFlags ()+mainFlags conf =+  basic {+    configFlags,+    projectFlags = basic.projectFlags {flagIgnoreProject = toFlag True}+  }+  where+    basic = defaultNixStyleFlags ()++    configFlags =+      (defaultConfigFlags defaultProgramDb) {+        configHcPath = pathFlag [relfile|ghc|],+        configHcPkg = pathFlag [relfile|ghc-pkg|],+        configVerbosity = toFlag conf.verbosity+      }++    pathFlag exe = maybeToFlag (ghcPath exe <$> conf.ghc)++    ghcPath exe (GhcPath dir) = toFilePath (dir </> [reldir|bin|] </> exe)++initialize ::+  SolveConfig ->+  M SolveFlags+initialize conf = do+  hackage <- hackageRepo conf.hackageRepoName+  cacheDir <- tryIOMWith badCacheDir defaultCacheDir+  let global = globalFlags hackage cacheDir+  let main = mainFlags conf+  ensureHackageIndex conf global main+  pure SolveFlags {global, main}

@@ -0,0 +1,14 @@+module Hix.Managed.Cabal.Installed where++import Distribution.Simple.PackageIndex (InstalledPackageIndex, lookupPackageName)++import qualified Hix.Data.PackageName as PackageName+import Hix.Data.PackageName (PackageName)+import Hix.Data.Version (Version)++installedVersion ::+  InstalledPackageIndex ->+  PackageName ->+  Maybe Version+installedVersion index name =+  fst <$> head (lookupPackageName index (PackageName.toCabal name))

@@ -0,0 +1,33 @@+module Hix.Managed.Cabal.Mock where++import Distribution.Simple (buildCompilerId, unknownCompilerInfo)+import Distribution.Simple.Compiler (AbiTag (NoAbiTag))+import Distribution.Solver.Types.PkgConfigDb (PkgConfigDb (NoPkgConfigDb))+import Distribution.System (Arch (X86_64), OS (Linux), Platform (Platform))++import Hix.Managed.Data.ManagedPackage (ManagedPackage)+import Hix.Managed.Data.Packages (Packages)+import qualified Hix.Managed.Cabal.Data.Packages+import Hix.Managed.Cabal.Data.Packages (GhcPackages (GhcPackages))+import qualified Hix.Managed.Cabal.Data.SolveResources+import Hix.Managed.Cabal.Data.SolveResources (SolveResources (SolveResources))+import Hix.Managed.Cabal.Init (emptySolveFlags)+import Hix.Managed.Cabal.Mock.InstalledPackage (mockInstalledPackageIndex)+import qualified Hix.Managed.Cabal.Mock.SourcePackage as SourcePackage+import Hix.Managed.Cabal.Mock.SourcePackage (mockSourcePackageDb)++mockSolveResources ::+  Packages ManagedPackage ->+  GhcPackages ->+  SolveResources+mockSolveResources packages GhcPackages {installed, available} = do+  SolveResources {+    conf = def,+    flags = emptySolveFlags,+    platform = Platform X86_64 Linux,+    compiler = unknownCompilerInfo buildCompilerId NoAbiTag,+    pkgConfigDb = NoPkgConfigDb,+    installedPkgIndex = mockInstalledPackageIndex installed,+    sourcePkgDb = SourcePackage.dbWithManaged packages (mockSourcePackageDb available),+    solverParams = id+  }

@@ -0,0 +1,28 @@+module Hix.Managed.Cabal.Mock.InstalledPackage where++import Distribution.InstalledPackageInfo (InstalledPackageInfo (..), emptyInstalledPackageInfo)+import Distribution.Package (UnitId, mkUnitId)+import qualified Distribution.Simple.PackageIndex as PackageIndex+import Distribution.Simple.PackageIndex (InstalledPackageIndex)++import qualified Hix.Data.PackageId as PackageId+import Hix.Data.PackageId (PackageId)+import Hix.Managed.Cabal.Data.Packages (InstalledPackages (InstalledPackages))+import Hix.Pretty (showP)++mockUnitId :: PackageId -> UnitId+mockUnitId = mkUnitId . showP++installedPackageInfo :: PackageId -> [UnitId] -> InstalledPackageInfo+installedPackageInfo package depends =+  emptyInstalledPackageInfo {+    sourcePackageId = PackageId.toCabal package,+    installedUnitId = mockUnitId package,+    depends+  }++mockInstalledPackageIndex :: InstalledPackages -> InstalledPackageIndex+mockInstalledPackageIndex =+  PackageIndex.fromList .+  fmap (uncurry installedPackageInfo . second (fmap mockUnitId)) .+  coerce

@@ -0,0 +1,111 @@+module Hix.Managed.Cabal.Mock.SourcePackage where++import qualified Data.Map.Strict as Map+import Distribution.Client.Types (PackageLocation (LocalTarballPackage), SourcePackageDb (..), UnresolvedSourcePackage)+import Distribution.PackageDescription (+  CondTree (..),+  Library (libBuildInfo),+  LibraryVisibility (LibraryVisibilityPublic),+  PackageDescription (..),+  emptyLibrary,+  emptyPackageDescription, BuildInfo (targetBuildDepends),+  )+import Distribution.Simple (Version)+import qualified Distribution.Solver.Types.PackageIndex as PackageIndex+import Distribution.Solver.Types.PackageIndex (PackageIndex)+import Distribution.Solver.Types.SourcePackage (SourcePackage (..))+import Distribution.Types.GenericPackageDescription (GenericPackageDescription (..), emptyGenericPackageDescription)+import Distribution.Types.Library (libVisibility)+import Exon (exon)++import Hix.Class.Map (nGet, nKeys, nMap, nTo1, nTransform, nVia, (!!))+import qualified Hix.Data.Dep as Dep+import Hix.Data.Dep (Dep)+import Hix.Data.Monad (M)+import qualified Hix.Data.PackageId as PackageId+import Hix.Data.PackageId (PackageId (PackageId))+import Hix.Data.PackageName (LocalPackage (LocalPackage), PackageName, localPackageName)+import Hix.Managed.Cabal.Data.SourcePackage (SourcePackageDeps, SourcePackageVersions, SourcePackages)+import qualified Hix.Managed.Data.ManagedPackage as ManagedPackage+import Hix.Managed.Data.ManagedPackage (ManagedPackage)+import Hix.Managed.Data.Packages (Packages)+import Hix.Monad (noteClient)++allDeps :: [Dep] -> SourcePackageDeps -> SourcePackageDeps+allDeps deps = nVia (fmap (deps ++))++allDep :: Dep -> SourcePackageDeps -> SourcePackageDeps+allDep dep = nVia (fmap (dep :))++sourcePackageVersions :: SourcePackages -> SourcePackageVersions+sourcePackageVersions = nMap (sort . nKeys)++queryVersions :: SourcePackageVersions -> PackageName -> M [Version]+queryVersions packages query = noteClient [exon|No such package in the source db: ##{query}|] (packages !! query)++queryPackages :: SourcePackages -> PackageName -> M [Version]+queryPackages packages =+  queryVersions (sourcePackageVersions packages)++queryVersionsLatest :: SourcePackageVersions -> PackageName -> M (Maybe Version)+queryVersionsLatest packages query = last <$> queryVersions packages query++queryPackagesLatest :: SourcePackages -> PackageName -> M (Maybe Version)+queryPackagesLatest packages =+  queryVersionsLatest versions+  where+    versions = sourcePackageVersions packages++-- | This _must_ have the dependencies in both 'targetBuildDepends' and 'condTreeConstraints', otherwise they will be+-- ignored or deleted depending on what resolver params are used.+-- This is also evidenced by looking at a parsed Cabal file, see @CabalTest@.+mockSourcePackage :: PackageName -> Version -> [Dep] -> UnresolvedSourcePackage+mockSourcePackage name version deps =+  SourcePackage {+    srcpkgPackageId = cabalId,+    srcpkgDescription = emptyGenericPackageDescription {+      packageDescription = emptyPackageDescription {+        package = cabalId+      },+      condLibrary = Just library+    },+    srcpkgSource = LocalTarballPackage "/invalid",+    srcpkgDescrOverride = Nothing+  }+  where+    library =+      mempty {+        condTreeData = emptyLibrary {+          libVisibility = LibraryVisibilityPublic,+          libBuildInfo = mempty {targetBuildDepends = cabalDeps}+        },+        condTreeConstraints = cabalDeps+      }+    cabalId = PackageId.toCabal PackageId {..}+    cabalDeps = Dep.toCabal <$> deps++mockSourcePackageDb :: SourcePackages -> SourcePackageDb+mockSourcePackageDb packages =+  SourcePackageDb {+    packageIndex = PackageIndex.fromList (nTo1 packages mockSourcePackage),+    packagePreferences = []+  }++managedSourcePackageVersions :: Packages ManagedPackage -> SourcePackageVersions+managedSourcePackageVersions =+  nTransform \ (LocalPackage name) package -> (name, [package.version])++managedSourcePackage :: ManagedPackage -> UnresolvedSourcePackage+managedSourcePackage package =+  mockSourcePackage (localPackageName package.package) package.version (ManagedPackage.deps package)++managedPackageIndex :: Packages ManagedPackage -> PackageIndex UnresolvedSourcePackage+managedPackageIndex packages =+  PackageIndex.fromList (managedSourcePackage <$> Map.elems (nGet packages))++dbWithManaged :: Packages ManagedPackage -> SourcePackageDb -> SourcePackageDb+dbWithManaged packages SourcePackageDb {packageIndex, packagePreferences} =+  SourcePackageDb {+    packageIndex = PackageIndex.merge packageIndex (managedPackageIndex packages),+    packagePreferences+  }

@@ -0,0 +1,26 @@+module Hix.Managed.Cabal.Print where++import qualified Distribution.Client.SolverInstallPlan as SolverInstallPlan+import Distribution.Client.SolverInstallPlan (ResolverPackage (..), SolverInstallPlan, SolverPlanPackage)+import Distribution.InstalledPackageInfo (InstalledPackageInfo (InstalledPackageInfo, sourcePackageId))+import Distribution.Pretty (pretty)+import Distribution.Solver.Types.InstSolverPackage (InstSolverPackage (InstSolverPackage, instSolverPkgIPI))+import Distribution.Solver.Types.SolverPackage (SolverPackage (..))+import Distribution.Solver.Types.SourcePackage (SourcePackage (..))+import Exon (exon)++import Hix.Data.Monad (M)+import qualified Hix.Log as Log++showPackage :: SolverPlanPackage -> String+showPackage = \case+  PreExisting InstSolverPackage {instSolverPkgIPI = InstalledPackageInfo {sourcePackageId}} ->+    "existing: " <> show (pretty sourcePackageId)+  Configured SolverPackage {solverPkgSource = SourcePackage {srcpkgPackageId}} ->+    "configured: " <> show (pretty srcpkgPackageId)++printPlan :: SolverInstallPlan -> M ()+printPlan plan = do+  Log.info "Plan:"+  for_ (SolverInstallPlan.toList plan) \ pkg ->+    Log.infoCont [exon|📦 #{toText (showPackage pkg)}|]

@@ -0,0 +1,137 @@+module Hix.Managed.Cabal.Repo where++import Data.Time (UTCTime (..), showGregorian, timeToTimeOfDay)+import Distribution.Client.CmdUpdate (updateAction)+import qualified Distribution.Client.GlobalFlags+import Distribution.Client.GlobalFlags (GlobalFlags (..))+import Distribution.Client.IndexUtils (currentIndexTimestamp, indexBaseName)+import Distribution.Client.IndexUtils.Timestamp (timestampToUTCTime)+import Distribution.Client.NixStyleOptions (NixStyleFlags (..))+import Distribution.Client.Setup (RepoContext, withRepoContext)+import Distribution.Client.Types (RemoteRepo (..), Repo (RepoSecure), RepoName (RepoName))+import qualified Distribution.Client.Types.Repo+import Distribution.Compat.Time (getFileAge)+import Distribution.Verbosity (Verbosity)+import Exon (exon)+import Path (Abs, File, Path, addExtension, parseAbsFile, toFilePath)+import Path.IO (doesFileExist)++import Hix.Data.Error (Error (Fatal))+import Hix.Error (pathText)+import qualified Hix.Log as Log+import qualified Hix.Managed.Cabal.Data.Config+import Hix.Managed.Cabal.Data.Config (+  CabalConfig (CabalConfig),+  HackageIndexState (HackageIndexState),+  HackageRepoName (HackageRepoName),+  SolveConfig (SolveConfig),+  )+import Hix.Maybe (justIf)+import Hix.Monad (M, catchIOM, eitherFatalShow, noteFatal, tryIOM, tryIOMWith, withLower)++withRepoContextM ::+  SolveConfig ->+  GlobalFlags ->+  (RepoContext -> M a) ->+  M a+withRepoContextM conf flags f =+  withLower \ lower -> withRepoContext conf.verbosity flags \ ctx -> lower (f ctx)++fullHackageRepo ::+  SolveConfig ->+  RepoContext ->+  M Repo+fullHackageRepo SolveConfig {hackageRepoName = HackageRepoName (toString -> hackage)} ctx =+  noteFatal err $ flip find ctx.repoContextRepos \case+    RepoSecure {repoRemote = RemoteRepo {remoteRepoName = RepoName name}} -> name == hackage+    _ -> False+  where+    err = "Bad Hackage repo config"++data IndexProblem =+  IndexMissing+  |+  IndexOutdated+  |+  IndexMismatch+  deriving stock (Eq, Show, Generic)++indexOutdated :: Path Abs File -> IO Bool+indexOutdated (toFilePath -> index) =+  (> 7) <$> getFileAge index++updateRequest ::+  SolveConfig ->+  String+updateRequest SolveConfig {hackageRepoName, cabal = CabalConfig {indexState}} =+  [exon|#{hackage}#{extra}|]+  where+    extra = foldMap stateField (timestampToUTCTime . coerce =<< indexState)++    stateField UTCTime {..} = [exon|,#{showGregorian utctDay}T#{show (timeToTimeOfDay utctDayTime)}Z|]++    HackageRepoName (toString -> hackage) = hackageRepoName++updateIndex ::+  SolveConfig ->+  GlobalFlags ->+  NixStyleFlags () ->+  IndexProblem ->+  M ()+updateIndex conf global main problem = do+  Log.verbose [exon|Hackage snapshot #{message}, fetching...|]+  tryIOMWith (\ err -> Fatal [exon|Fetching hackage snapshot failed: #{err}|]) do+    updateAction main [updateRequest conf] global+  where+    message = case problem of+      IndexMissing -> "doesn't exist"+      IndexOutdated -> "is older than 7 days"+      IndexMismatch -> "differs from requested index state"++indexPath :: Repo -> M (Path Abs File)+indexPath repo =+  eitherFatalShow err do+    base <- parseAbsFile (indexBaseName repo)+    addExtension ".tar" base+  where+    err = "Bad Hackage repo config"++matchIndexState ::+  Verbosity ->+  RepoContext ->+  Repo ->+  HackageIndexState ->+  M (Maybe IndexProblem)+matchIndexState verbosity ctx repo (HackageIndexState target) =+  catchIOM (match <$> currentIndexTimestamp verbosity ctx repo) (\ _ -> pure (Just IndexMissing))+  where+    match current | current == target = Nothing+                  | otherwise = Just IndexMismatch++indexProblem ::+  SolveConfig ->+  RepoContext ->+  Repo ->+  Path Abs File ->+  M (Maybe IndexProblem)+indexProblem SolveConfig {verbosity, cabal} ctx repo path = do+  Log.debug [exon|Checking hackage snapshot at #{pathText path}|]+  tryIOM (doesFileExist path) >>= \case+    False -> pure (Just IndexMissing)+    True+      | Just target <- cabal.indexState+      -> matchIndexState verbosity ctx repo target+      | otherwise+      -> flip justIf IndexOutdated <$> tryIOM (indexOutdated path)++-- TODO currentIndexTimestamp has a different signature in later versions+ensureHackageIndex ::+  SolveConfig ->+  GlobalFlags ->+  NixStyleFlags () ->+  M ()+ensureHackageIndex conf global main =+  withRepoContextM conf global \ ctx -> do+    repo <- fullHackageRepo conf ctx+    path <- indexPath repo+    traverse_ (updateIndex conf global main) =<< indexProblem conf ctx repo path

@@ -0,0 +1,76 @@+module Hix.Managed.Cabal.Resources where++import Control.Monad.Trans.Reader (asks)+import Distribution.Client.IndexUtils (getInstalledPackages, getSourcePackages)+import qualified Distribution.Client.NixStyleOptions+import Distribution.Client.Setup (configCompilerAux', withRepoContext)+import Distribution.Simple (PackageDB (GlobalPackageDB), PackageDBStack, compilerInfo)+import Distribution.Solver.Types.PkgConfigDb (readPkgConfigDb)+import Distribution.Verbosity (lessVerbose, silent, verbose)++import qualified Hix.Data.Monad+import Hix.Data.Monad (M (M))+import qualified Hix.Log as Log+import Hix.Managed.Cabal.Data.Config (CabalConfig, GhcDb (GhcDbSynthetic, GhcDbSystem), SolveConfig (..))+import qualified Hix.Managed.Cabal.Data.SolveResources+import Hix.Managed.Cabal.Data.SolveResources (SolveResources (SolveResources))+import qualified Hix.Managed.Cabal.Init+import Hix.Managed.Cabal.Init (initialize)+import Hix.Managed.Cabal.Mock (mockSolveResources)+import qualified Hix.Managed.Cabal.Mock.SourcePackage as SourcePackage+import Hix.Managed.Data.ManagedPackage (ManagedPackage)+import Hix.Managed.Data.Packages (Packages)+import Hix.Monad (tryIOM)++packageDbs :: PackageDBStack+packageDbs = [GlobalPackageDB]++-- | This adds the 'ManagedPackage's to the source package DB, which is the set of available package IDs.+-- This means that the solver will find our local packages (for targets that depend on packages in other envs) like it+-- finds Hackage packages, and therefore local deps will be included in the plan.+--+-- Because we don't want local packages in the plan (as they are not mutable, but static in the Nix build), it would be+-- tempting to add 'ManagedPackage's to the installed package index instead, which would exclude them from the plan's+-- overrides.+-- However, their metadata must include concrete unit IDs for their dependencies with fixed versions, which would+-- require us to choose versions for them and might interfere with solving.+--+-- Maybe the basic installed package index could be queried to determine the dep versions.+-- Not sure this would be better than just filtering the plan.+resources ::+  Packages ManagedPackage ->+  SolveConfig ->+  M SolveResources+resources packages conf = do+  flags <- initialize conf+  Log.debug "Acquiring Cabal resources."+  tryIOM $ withRepoContext conf.verbosity flags.global \ repoContext -> do+    (compiler, platform, progdb) <- configCompilerAux' flags.main.configFlags+    pkgConfigDb <- readPkgConfigDb conf.verbosity progdb+    installedPkgIndex <- getInstalledPackages conf.verbosity compiler packageDbs progdb+    sourcePkgDb <- getSourcePackages conf.verbosity repoContext+    pure SolveResources {+      compiler = compilerInfo compiler,+      installedPkgIndex = installedPkgIndex,+      sourcePkgDb = SourcePackage.dbWithManaged packages sourcePkgDb,+      solverParams = id,+      ..+    }++-- TODO The Packages ManagedPackage are added in 'resources' as well as in 'mockSolveResources', which is probably ok since they+-- now come from @processProject@ and not from the tests, I think. still would be better to unify those+--+-- just add the managed packages to the result.+acquire ::+  Packages ManagedPackage ->+  CabalConfig ->+  GhcDb ->+  M SolveResources+acquire packages cabal = \case+  GhcDbSystem ghc -> do+    verbosity <- M (asks (.debug)) <&> \case+      True -> verbose+      False -> lessVerbose silent+    resources packages def {verbosity, ghc, cabal}+  GhcDbSynthetic db ->+    pure (mockSolveResources packages db)

@@ -0,0 +1,83 @@+module Hix.Managed.Cabal.Solve where++import Distribution.Client.Dependency (+  DepResolverParams,+  PackagePreference,+  PackageSpecifier,+  addPreferences,+  foldProgress,+  resolveDependencies,+  setAllowBootLibInstalls,+  standardInstallPolicy,+  )+import Distribution.Client.Dependency.Types (Solver (Modular))+import Distribution.Client.SolverInstallPlan (SolverInstallPlan)+import Distribution.Client.Types (UnresolvedSourcePackage)+import Distribution.Simple.Utils (debugNoWrap)+import Distribution.Solver.Types.Settings (AllowBootLibInstalls (AllowBootLibInstalls))+import Distribution.Verbosity (Verbosity)+import Exon (exon)++import Hix.Data.Error (Error (Fatal))+import qualified Hix.Log as Log+import Hix.Managed.Cabal.Changes (SolverPlan, solverPlan)+import qualified Hix.Managed.Cabal.Data.Config+import qualified Hix.Managed.Cabal.Data.SolveResources+import Hix.Managed.Cabal.Data.SolveResources (SolveResources)+import qualified Hix.Managed.Cabal.Data.SolveTarget+import Hix.Managed.Cabal.Data.SolveTarget (SolveTarget)+import qualified Hix.Managed.Cabal.Data.SolverState+import Hix.Managed.Cabal.Data.SolverState (SolverState (SolverState), compileSolverFlags)+import Hix.Managed.Cabal.Targets (solveTargets)+import Hix.Monad (M, tryIOMAs)++newtype Unresolvable =+  Unresolvable Text+  deriving stock (Eq, Show, Generic)+  deriving newtype (IsString, Ord)++logMsg :: Verbosity -> String -> IO a -> IO a+logMsg verbosity message rest =+  debugNoWrap verbosity message *> rest++solveSpecifiers ::+  SolveResources ->+  (DepResolverParams -> DepResolverParams) ->+  [PackageSpecifier UnresolvedSourcePackage] ->+  [PackagePreference] ->+  IO (Either String SolverInstallPlan)+solveSpecifiers res mapParams pkgSpecifiers prefs =+  foldProgress (logMsg res.conf.verbosity) (pure . Left) (pure . Right) $+  resolveDependencies res.platform res.compiler res.pkgConfigDb Modular params+  where+    params =+      mapParams $+      res.solverParams $+      setAllowBootLibInstalls (AllowBootLibInstalls res.conf.allowBoot) $+      addPreferences prefs $+      standardInstallPolicy res.installedPkgIndex res.sourcePkgDb pkgSpecifiers++solveForTargets ::+  SolveResources ->+  (DepResolverParams -> DepResolverParams) ->+  [SolveTarget] ->+  M (Either Unresolvable SolverInstallPlan)+solveForTargets res mapParams targets =+  first fromString <$> tryIOMAs (Fatal "Cabal solver crashed.") (solveSpecifiers res mapParams pkgSpecifiers prefs)+  where+    pkgSpecifiers = (.dep) <$> targets+    prefs = (.prefs) =<< targets++solveWithCabal ::+  SolveResources ->+  SolverState ->+  M (Maybe SolverPlan)+solveWithCabal solveResources SolverState {constraints, flags} = do+  solveForTargets solveResources (compileSolverFlags flags) targets >>= \case+    Right plan ->+      pure (Just (solverPlan plan))+    Left err -> do+      Log.debug [exon|Solver found no plan: ##{err}|]+      pure Nothing+  where+    targets = solveTargets constraints

@@ -0,0 +1,50 @@+module Hix.Managed.Cabal.Targets where++import Distribution.Client.Dependency (+  PackagePreference (PackageInstalledPreference, PackageVersionPreference),+  PackageProperty (PackagePropertyVersion),+  PackageSpecifier (NamedPackage),+  )+import Distribution.Solver.Types.InstalledPreference (InstalledPreference (PreferInstalled, PreferOldest))+import Distribution.Version (orEarlierVersion, orLaterVersion)++import Hix.Class.Map (nToWith)+import qualified Hix.Data.PackageName as PackageName+import Hix.Data.PackageName (PackageName)+import Hix.Data.Version (VersionRange)+import Hix.Data.VersionBounds (Bound (BoundLower, BoundUpper), VersionBounds, maybeRange)+import Hix.Managed.Cabal.Data.SolveTarget (SolveTarget (..))+import qualified Hix.Managed.Data.Constraints+import Hix.Managed.Data.Constraints (EnvConstraints, MutationConstraints (MutationConstraints))++reifyBounds :: VersionBounds -> Maybe VersionRange+reifyBounds =+  maybeRange \case+    BoundLower -> orLaterVersion+    BoundUpper -> orEarlierVersion++solveTarget ::+  PackageName ->+  MutationConstraints ->+  SolveTarget+solveTarget package MutationConstraints {mutation, oldest, installed, prefer, force} =+  SolveTarget {dep, prefs}+  where+    dep = NamedPackage cabalName (PackagePropertyVersion <$> ranges)++    ranges = catMaybes [reifyBounds mutation, force]++    prefs = catMaybes [prefVersion <$> prefer, flag prefOldest oldest, flag prefInstalled installed]++    flag v = \case+      Just True -> Just v+      _ -> Nothing++    prefVersion = PackageVersionPreference cabalName+    prefOldest = PackageInstalledPreference cabalName PreferOldest+    prefInstalled = PackageInstalledPreference cabalName PreferInstalled++    cabalName = PackageName.toCabal package++solveTargets :: EnvConstraints -> [SolveTarget]+solveTargets = nToWith solveTarget

@@ -0,0 +1,37 @@+module Hix.Managed.Constraints where++import Distribution.Version (thisVersion)++import Hix.Class.Map (nGenWith, nMap, nTransform)+import Hix.Data.Bounds (Ranges)+import Hix.Data.PackageName (PackageName)+import Hix.Data.Version (Version, Versions)+import Hix.Data.VersionBounds (VersionBounds, anyBounds)+import Hix.Managed.Data.Constraints (EnvConstraints, MutationConstraints (..))+import Hix.Managed.Data.Mutable (MutableDep (MutableDep), MutableVersions)++noBounds :: MutationConstraints+noBounds = mempty {mutation = anyBounds}++forDeps :: (PackageName -> MutationConstraints) -> Set MutableDep -> EnvConstraints+forDeps f =+  nGenWith \ (MutableDep package) -> (package, f package)++fromVersions :: (Version -> VersionBounds) -> MutableVersions -> EnvConstraints+fromVersions bound =+  nTransform \ (MutableDep package) v -> (package, mempty {mutation = foldMap bound v})++preferRanges :: Ranges -> EnvConstraints+preferRanges =+  nMap \ range -> mempty {mutation = mempty, prefer = Just range}++preferVersions :: Versions -> EnvConstraints+preferVersions = preferRanges . nMap thisVersion++preferInstalled :: Set MutableDep -> EnvConstraints+preferInstalled =+  forDeps \ _ -> mempty {mutation = mempty, installed = Just True}++explicitBounds :: Ranges -> EnvConstraints+explicitBounds =+  nMap \ range -> mempty {mutation = mempty, force = Just range}

@@ -0,0 +1,22 @@+module Hix.Managed.Data.BuildConfig where++data BuildConfig =+  BuildConfig {+    maxIterations :: Natural,+    maxFailedPre :: Natural,+    maxFailedPost :: Natural,+    lookup :: Bool,+    validate :: Bool,+    buildOutput :: Bool+  }+  deriving stock (Eq, Show, Generic)++instance Default BuildConfig where+  def = BuildConfig {+    maxIterations = 3,+    maxFailedPre = 99,+    maxFailedPost = 0,+    lookup = False,+    validate = False,+    buildOutput = False+  }

@@ -0,0 +1,44 @@+module Hix.Managed.Data.BuildOutput where++import Data.Aeson (ToJSON (toJSON), object, (.=))+import Distribution.Pretty (Pretty (pretty))+import Text.PrettyPrint (brackets, (<+>))++import Hix.Data.Version (Version)+import Hix.Data.VersionBounds (VersionBounds)+import Hix.Managed.Data.Mutable (MutableDep)+import qualified Hix.Managed.Data.MutableId+import Hix.Managed.Data.MutableId (MutableId (MutableId))+import Hix.Pretty (showP)++data ModifiedId =+  ModifiedId {+    package :: MutableDep,+    version :: Version,+    range :: Maybe VersionBounds+  }+  deriving stock (Eq, Show, Generic)++instance Pretty ModifiedId where+  pretty ModifiedId {..} =+    pretty MutableId {name = package, version} <+> brackets (maybe "old range matches" pretty range)++instance ToJSON ModifiedId where+  toJSON ModifiedId {..} =+    object [+      "package" .= toJSON package,+      "version" .= toJSON (showP version :: Text),+      "range" .= toJSON (showP <$> range :: Maybe Text)+    ]++data BuildOutput =+  BuildOutput {+    modified :: [ModifiedId],+    unmodified :: [MutableDep],+    failed :: [MutableDep],+    modifiedNames :: Maybe Text,+    unmodifiedNames :: Maybe Text,+    failedNames :: Maybe Text+  }+  deriving stock (Eq, Show, Generic)+  deriving anyclass (ToJSON)

@@ -0,0 +1,18 @@+module Hix.Managed.Data.Bump where++import Distribution.Pretty (Pretty (pretty))+import Text.PrettyPrint (brackets, parens, (<+>))++import Hix.Data.Version (Version)++data Bump =+  Bump {+    version :: Version,+    bound :: Version,+    changed :: Bool+  }+  deriving stock (Eq, Show, Generic)++instance Pretty Bump where+  pretty Bump {version, bound, changed} =+    pretty version <+> parens ("<" <> pretty bound) <+> brackets (if changed then "x" else " ")

@@ -0,0 +1,89 @@+module Hix.Managed.Data.Constraints where++import qualified Data.Map.Strict as Map+import Distribution.Pretty (Pretty (pretty))+import Distribution.Version (VersionRange)+import GHC.Exts (IsList)+import Text.PrettyPrint (Doc, parens, (<+>))++import Hix.Class.Map (LookupMaybe, NMap, nPretty)+import Hix.Data.PackageName (PackageName)+import Hix.Data.VersionBounds (VersionBounds, anyBounds)+import Hix.Pretty (prettyL)++-- | Left-biased semigroup op.+--+-- TODO it might be sensible to split the non-mutation deps out of this type so it can be keyed by @MutableDep@.+data MutationConstraints =+  MutationConstraints {+    -- | This used to be an abstraction, but there was no use case for it.+    -- Now it is hardcoded to use inclusive bounds for both, so a potential new mutation handler cannot customize that.+    -- All handlers only evolve one of the bounds, while this now allows both to be changed.+    mutation :: VersionBounds,++    -- | Prefer the oldest possible version.+    oldest :: Maybe Bool,++    -- | Prefer the installed version.+    installed :: Maybe Bool,++    -- | Concrete bounds overrides from user config.+    force :: Maybe VersionRange,++    -- | Prefer a concrete version range.+    prefer :: Maybe VersionRange+  }+  deriving stock (Eq, Show, Generic)++instance Pretty MutationConstraints where+  pretty MutationConstraints {mutation, oldest, installed, force, prefer} =+    pretty mutation <+>+    flags [("oldest", oldest), ("installed", installed)] <+>+    foldMap pref prefer <+>+    foldMap spec force+    where+      flags :: [(Doc, Maybe Bool)] -> Doc+      flags =+        mapMaybe flag >>> \case+          [] -> mempty+          fs -> parens (prettyL fs)++      flag = \case+        (desc, Just True) -> Just desc+        _ -> Nothing++      pref v = "~" <+> pretty v+      spec v = "+" <+> pretty v++instance Semigroup MutationConstraints where+  l <> r =+    MutationConstraints {+      mutation = l.mutation <> l.mutation,+      oldest = l.oldest <|> r.oldest,+      installed = l.installed <|> r.installed,+      force = l.force <|> r.force,+      prefer = l.prefer <|> r.prefer+    }++instance Monoid MutationConstraints where+  mempty =+    MutationConstraints {+      mutation = anyBounds,+      oldest = Nothing,+      installed = Nothing,+      force = Nothing,+      prefer = Nothing+    }++newtype EnvConstraints =+  EnvConstraints (Map PackageName MutationConstraints)+  deriving stock (Eq, Show, Generic)+  deriving newtype (Monoid, IsList)++instance Semigroup EnvConstraints where+  EnvConstraints l <> EnvConstraints r = EnvConstraints (Map.unionWith (<>) l r)++instance NMap EnvConstraints PackageName MutationConstraints LookupMaybe where++instance Pretty EnvConstraints where+  pretty = nPretty