From 49474fcb6055522d32656a6bb415f68212c7d87f Mon Sep 17 00:00:00 2001
From: zowoq <59103226+zowoq@users.noreply.github.com>
Date: Sun, 28 Apr 2024 13:39:53 +1000
Subject: [PATCH 1/4] Revert "separate runtime dependencies"

This reverts commit 71ab24a2ebb8a10cce8248e5f637067a9de6e6ff.
---
 flake.lock       | 17 -----------------
 flake.nix        |  4 +---
 pkgs/default.nix |  5 +----
 3 files changed, 2 insertions(+), 24 deletions(-)

diff --git a/flake.lock b/flake.lock
index 360539c..9b39967 100644
--- a/flake.lock
+++ b/flake.lock
@@ -55,26 +55,9 @@
       "inputs": {
         "mmdoc": "mmdoc",
         "nixpkgs": "nixpkgs",
-        "runtimeDeps": "runtimeDeps",
         "treefmt-nix": "treefmt-nix"
       }
     },
-    "runtimeDeps": {
-      "locked": {
-        "lastModified": 1714247354,
-        "narHash": "sha256-6dFKqP/aCKIdpOgqgIQUrRT0NOfVc14ftNcdELa4Pu4=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "c8d7c8a78fb516c0842cc65346506a565c88014d",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixos-unstable-small",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
     "treefmt-nix": {
       "inputs": {
         "nixpkgs": [
diff --git a/flake.nix b/flake.nix
index 18fd02b..edb9aad 100644
--- a/flake.nix
+++ b/flake.nix
@@ -7,12 +7,10 @@
   inputs.treefmt-nix.url = "github:numtide/treefmt-nix";
   inputs.treefmt-nix.inputs.nixpkgs.follows = "nixpkgs";
 
-  inputs.runtimeDeps.url = "github:NixOS/nixpkgs/nixos-unstable-small";
-
   nixConfig.extra-substituters = "https://nix-community.cachix.org";
   nixConfig.extra-trusted-public-keys = "nix-community.cachix.org-1:mB9FSh9qf2dCimDSUo8Zy7bkq5CX+/rkCWyvRCYg3Fs=";
 
-  outputs = { self, nixpkgs, mmdoc, treefmt-nix, runtimeDeps } @ args:
+  outputs = { self, nixpkgs, mmdoc, treefmt-nix } @ args:
     let
       systems = [ "x86_64-linux" "aarch64-linux" "x86_64-darwin" "aarch64-darwin" ];
       eachSystem = f: nixpkgs.lib.genAttrs systems (system: f nixpkgs.legacyPackages.${system});
diff --git a/pkgs/default.nix b/pkgs/default.nix
index 73a9c9f..1161c0a 100644
--- a/pkgs/default.nix
+++ b/pkgs/default.nix
@@ -1,6 +1,5 @@
 { nixpkgs
 , mmdoc
-, runtimeDeps
 , system
 , self
 , ...
@@ -8,11 +7,9 @@
 
 let
 
-  runtimePkgs = import runtimeDeps { inherit system; };
-
   pkgs = import nixpkgs { inherit system; config = { allowBroken = true; }; };
 
-  drvAttrs = attrs: with runtimePkgs; {
+  drvAttrs = attrs: with pkgs; {
     NIX = nix;
     GIT = git;
     JQ = jq;

From 71c57e3d7db6629287f6c016a682beeeb62077bd Mon Sep 17 00:00:00 2001
From: zowoq <59103226+zowoq@users.noreply.github.com>
Date: Sun, 28 Apr 2024 13:40:31 +1000
Subject: [PATCH 2/4] fix warning

> haskellLib.generateOptparseApplicativeCompletion is deprecated in favor of haskellPackages.generateOptparseApplicativeCompletions (plural!).
---
 pkgs/default.nix | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pkgs/default.nix b/pkgs/default.nix
index 1161c0a..fc257e6 100644
--- a/pkgs/default.nix
+++ b/pkgs/default.nix
@@ -30,7 +30,7 @@ let
           pkgs.haskell.lib.failOnAllWarnings (
             pkgs.haskell.lib.disableExecutableProfiling (
               pkgs.haskell.lib.disableLibraryProfiling (
-                pkgs.haskell.lib.generateOptparseApplicativeCompletion "nixpkgs-update" (
+                pkgs.haskellPackages.generateOptparseApplicativeCompletions [ "nixpkgs-update" ] (
                   (haskellPackages.callPackage ../nixpkgs-update.nix { }).overrideAttrs drvAttrs
                 )
               )

From 33042bdeb1b6543c2399ccd1deef73dd1467bba9 Mon Sep 17 00:00:00 2001
From: zowoq <59103226+zowoq@users.noreply.github.com>
Date: Sun, 28 Apr 2024 13:45:45 +1000
Subject: [PATCH 3/4] format

---
 src/CVE.hs           |   2 +-
 src/Check.hs         |   2 +-
 src/Data/Hex.hs      |   4 +-
 src/File.hs          |   6 +-
 src/GH.hs            |  18 ++---
 src/Git.hs           |  26 +++---
 src/NVDRules.hs      |   6 +-
 src/Nix.hs           |  52 ++++++------
 src/NixpkgsReview.hs |   2 +-
 src/OurPrelude.hs    |  18 ++---
 src/Outpaths.hs      |  22 ++---
 src/Process.hs       |   2 +-
 src/Rewrite.hs       | 186 +++++++++++++++++++++----------------------
 src/Skiplist.hs      |   2 +-
 src/Update.hs        |   6 +-
 src/Utils.hs         |  18 ++---
 src/Version.hs       |   2 +-
 17 files changed, 187 insertions(+), 187 deletions(-)

diff --git a/src/CVE.hs b/src/CVE.hs
index f48be3d..e86815f 100644
--- a/src/CVE.hs
+++ b/src/CVE.hs
@@ -123,7 +123,7 @@ instance Show CPE where
           ]
         <> "}"
       where
-        cpeField :: Show a => String -> Maybe a -> [String]
+        cpeField :: (Show a) => String -> Maybe a -> [String]
         cpeField _ Nothing = []
         cpeField name (Just value) = [name <> " = " <> show value]
 
diff --git a/src/Check.hs b/src/Check.hs
index a7cbbf6..4530574 100644
--- a/src/Check.hs
+++ b/src/Check.hs
@@ -176,7 +176,7 @@ duGist resultPath =
           return $ "- du listing: " <> g <> "\n"
       )
 
-result :: MonadIO m => UpdateEnv -> String -> m Text
+result :: (MonadIO m) => UpdateEnv -> String -> m Text
 result updateEnv resultPath =
   liftIO $ do
     let expectedVersion = newVersion updateEnv
diff --git a/src/Data/Hex.hs b/src/Data/Hex.hs
index 6dbc8aa..b4cc318 100644
--- a/src/Data/Hex.hs
+++ b/src/Data/Hex.hs
@@ -26,7 +26,7 @@ class Hex t where
   hex :: t -> t
 
   -- | Convert from hexadecimal and fail on invalid input.
-  unhex :: MonadFail m => t -> m t
+  unhex :: (MonadFail m) => t -> m t
 
 instance Hex String where
   hex = Prelude.concatMap w
@@ -42,7 +42,7 @@ instance Hex String where
     liftM (toEnum ((x * 16) + y) :) $ unhex r
   unhex [_] = fail "Non-even length"
 
-c :: MonadFail m => Char -> m Int
+c :: (MonadFail m) => Char -> m Int
 c '0' = return 0
 c '1' = return 1
 c '2' = return 2
diff --git a/src/File.hs b/src/File.hs
index 081a097..c36ee78 100644
--- a/src/File.hs
+++ b/src/File.hs
@@ -18,7 +18,7 @@ data File m a where
 makeSem ''File
 
 runIO ::
-  Member (Embed IO) r =>
+  (Member (Embed IO) r) =>
   Sem (File ': r) a ->
   Sem r a
 runIO =
@@ -38,7 +38,7 @@ runPure contentList =
       Write _file contents -> output contents
 
 replace ::
-  Member File r =>
+  (Member File r) =>
   Text ->
   Text ->
   FilePath ->
@@ -50,7 +50,7 @@ replace find replacement file = do
     File.write file newContents
   return $ contents /= newContents
 
-replaceIO :: MonadIO m => Text -> Text -> FilePath -> m Bool
+replaceIO :: (MonadIO m) => Text -> Text -> FilePath -> m Bool
 replaceIO find replacement file =
   liftIO $
     runFinal $
diff --git a/src/GH.hs b/src/GH.hs
index 7df2ae7..22c17a6 100644
--- a/src/GH.hs
+++ b/src/GH.hs
@@ -38,18 +38,18 @@ import qualified Utils as U
 
 default (T.Text)
 
-gReleaseUrl :: MonadIO m => GH.Auth -> URLParts -> ExceptT Text m Text
+gReleaseUrl :: (MonadIO m) => GH.Auth -> URLParts -> ExceptT Text m Text
 gReleaseUrl auth (URLParts o r t) =
   ExceptT $
     bimap (T.pack . show) (GH.getUrl . GH.releaseHtmlUrl)
       <$> liftIO (GH.github auth (GH.releaseByTagNameR o r t))
 
-releaseUrl :: MonadIO m => UpdateEnv -> Text -> ExceptT Text m Text
+releaseUrl :: (MonadIO m) => UpdateEnv -> Text -> ExceptT Text m Text
 releaseUrl env url = do
   urlParts <- parseURL url
   gReleaseUrl (authFrom env) urlParts
 
-pr :: MonadIO m => UpdateEnv -> Text -> Text -> Text -> Text -> ExceptT Text m (Bool, Text)
+pr :: (MonadIO m) => UpdateEnv -> Text -> Text -> Text -> Text -> ExceptT Text m (Bool, Text)
 pr env title body prHead base = do
   tryPR `catchE` \case
     -- If creating the PR returns a 422, most likely cause is that the
@@ -74,9 +74,9 @@ pr env title body prHead base = do
                   )
               )
 
-prUpdate :: forall m. MonadIO m => UpdateEnv -> Text -> Text -> Text -> Text -> ExceptT Text m (Bool, Text)
+prUpdate :: forall m. (MonadIO m) => UpdateEnv -> Text -> Text -> Text -> Text -> ExceptT Text m (Bool, Text)
 prUpdate env title body prHead base = do
-  let runRequest :: FromJSON a => GH.Request k a -> ExceptT Text m a
+  let runRequest :: (FromJSON a) => GH.Request k a -> ExceptT Text m a
       runRequest = ExceptT . fmap (first (T.pack . show)) . liftIO . GH.github (authFrom env)
   let inNixpkgs f = f (N "nixos") (N "nixpkgs")
 
@@ -149,11 +149,11 @@ parseURLMaybe url =
               )
    in url =~ regex
 
-parseURL :: MonadIO m => Text -> ExceptT Text m URLParts
+parseURL :: (MonadIO m) => Text -> ExceptT Text m URLParts
 parseURL url =
   tryJust ("GitHub: " <> url <> " is not a GitHub URL.") (parseURLMaybe url)
 
-compareUrl :: MonadIO m => Text -> Text -> ExceptT Text m Text
+compareUrl :: (MonadIO m) => Text -> Text -> ExceptT Text m Text
 compareUrl urlOld urlNew = do
   oldParts <- parseURL urlOld
   newParts <- parseURL urlNew
@@ -213,7 +213,7 @@ authFromToken = GH.OAuth . T.encodeUtf8
 authFrom :: UpdateEnv -> GH.Auth
 authFrom = authFromToken . U.githubToken . options
 
-checkExistingUpdatePR :: MonadIO m => UpdateEnv -> Text -> ExceptT Text m ()
+checkExistingUpdatePR :: (MonadIO m) => UpdateEnv -> Text -> ExceptT Text m ()
 checkExistingUpdatePR env attrPath = do
   searchResult <-
     ExceptT $
@@ -239,7 +239,7 @@ checkExistingUpdatePR env attrPath = do
         & T.unlines
     report i = "- " <> GH.issueTitle i <> "\n  " <> tshow (GH.issueUrl i)
 
-latestVersion :: MonadIO m => UpdateEnv -> Text -> ExceptT Text m Version
+latestVersion :: (MonadIO m) => UpdateEnv -> Text -> ExceptT Text m Version
 latestVersion env url = do
   urlParts <- parseURL url
   r <-
diff --git a/src/Git.hs b/src/Git.hs
index 7dbb5ff..827d016 100644
--- a/src/Git.hs
+++ b/src/Git.hs
@@ -80,7 +80,7 @@ deleteOrigin :: [Text] -> ProcessConfig () () ()
 deleteOrigin branches =
   silently $ procGit (["push", "origin", "--delete"] ++ fmap T.unpack branches)
 
-cleanAndResetTo :: MonadIO m => Text -> ExceptT Text m ()
+cleanAndResetTo :: (MonadIO m) => Text -> ExceptT Text m ()
 cleanAndResetTo branch =
   let target = "upstream/" <> branch
    in do
@@ -90,19 +90,19 @@ cleanAndResetTo branch =
         runProcessNoIndexIssue_ $ reset target
         runProcessNoIndexIssue_ clean
 
-show :: MonadIO m => Text -> Text -> ExceptT Text m Text
+show :: (MonadIO m) => Text -> Text -> ExceptT Text m Text
 show branch file =
   readProcessInterleavedNoIndexIssue_ $ silently $ procGit ["show", T.unpack ("remotes/upstream/" <> branch <> ":" <> file)]
 
-diff :: MonadIO m => Text -> ExceptT Text m Text
+diff :: (MonadIO m) => Text -> ExceptT Text m Text
 diff branch = readProcessInterleavedNoIndexIssue_ $ procGit ["diff", T.unpack branch]
 
-diffFileNames :: MonadIO m => Text -> ExceptT Text m [Text]
+diffFileNames :: (MonadIO m) => Text -> ExceptT Text m [Text]
 diffFileNames branch =
   readProcessInterleavedNoIndexIssue_ (procGit ["diff", T.unpack branch, "--name-only"])
     & fmapRT T.lines
 
-staleFetchHead :: MonadIO m => m Bool
+staleFetchHead :: (MonadIO m) => m Bool
 staleFetchHead =
   liftIO $ do
     nixpkgsGit <- getUserCacheDir "nixpkgs"
@@ -116,16 +116,16 @@ staleFetchHead =
         fetchedLast <- getModificationTime fetchHead
         return (fetchedLast < oneHourAgo)
 
-fetchIfStale :: MonadIO m => ExceptT Text m ()
+fetchIfStale :: (MonadIO m) => ExceptT Text m ()
 fetchIfStale = whenM staleFetchHead fetch
 
-fetch :: MonadIO m => ExceptT Text m ()
+fetch :: (MonadIO m) => ExceptT Text m ()
 fetch =
   runProcessNoIndexIssue_ $
     silently $
       procGit ["fetch", "-q", "--prune", "--multiple", "upstream", "origin"]
 
-push :: MonadIO m => UpdateEnv -> ExceptT Text m ()
+push :: (MonadIO m) => UpdateEnv -> ExceptT Text m ()
 push updateEnv =
   runProcessNoIndexIssue_
     ( procGit
@@ -176,7 +176,7 @@ mergeBase = do
 
 -- Return Nothing if a remote branch for this package doesn't exist. If a
 -- branch does exist, return a Just of its last commit message.
-findAutoUpdateBranchMessage :: MonadIO m => Text -> ExceptT Text m (Maybe Text)
+findAutoUpdateBranchMessage :: (MonadIO m) => Text -> ExceptT Text m (Maybe Text)
 findAutoUpdateBranchMessage pName = do
   remoteBranches <-
     readProcessInterleavedNoIndexIssue_ (procGit ["branch", "--remote", "--format=%(refname:short) %(subject)"])
@@ -190,11 +190,11 @@ inNixpkgsRepo = do
   currentDir <- getCurrentDirectory
   doesFileExist (currentDir <> "/nixos/release.nix")
 
-commit :: MonadIO m => Text -> ExceptT Text m ()
+commit :: (MonadIO m) => Text -> ExceptT Text m ()
 commit ref =
   runProcessNoIndexIssue_ (procGit ["commit", "-am", T.unpack ref])
 
-headRev :: MonadIO m => ExceptT Text m Text
+headRev :: (MonadIO m) => ExceptT Text m Text
 headRev = T.strip <$> readProcessInterleavedNoIndexIssue_ (procGit ["rev-parse", "HEAD"])
 
 deleteBranchesEverywhere :: Vector Text -> IO ()
@@ -227,7 +227,7 @@ runProcessNoIndexIssue_IO config = go
         ExitFailure _ -> throw $ ExitCodeException code config out e
 
 runProcessNoIndexIssue_ ::
-  MonadIO m => ProcessConfig () () () -> ExceptT Text m ()
+  (MonadIO m) => ProcessConfig () () () -> ExceptT Text m ()
 runProcessNoIndexIssue_ config = tryIOTextET go
   where
     go = do
@@ -241,7 +241,7 @@ runProcessNoIndexIssue_ config = tryIOTextET go
         ExitFailure _ -> throw $ ExitCodeException code config out e
 
 readProcessInterleavedNoIndexIssue_ ::
-  MonadIO m => ProcessConfig () () () -> ExceptT Text m Text
+  (MonadIO m) => ProcessConfig () () () -> ExceptT Text m Text
 readProcessInterleavedNoIndexIssue_ config = tryIOTextET go
   where
     go = do
diff --git a/src/NVDRules.hs b/src/NVDRules.hs
index 1e6d0f5..5616f1e 100644
--- a/src/NVDRules.hs
+++ b/src/NVDRules.hs
@@ -16,17 +16,17 @@ filter _ cpeMatch "socat" v
 filter _ cpeMatch "uzbl" v
   | isNothing (v =~ yearRegex)
       && "2009.12.22"
-      `anyVersionInfixOf` cpeMatchVersionMatcher cpeMatch =
+        `anyVersionInfixOf` cpeMatchVersionMatcher cpeMatch =
       False
   | isNothing (v =~ yearRegex)
       && "2010.04.03"
-      `anyVersionInfixOf` cpeMatchVersionMatcher cpeMatch =
+        `anyVersionInfixOf` cpeMatchVersionMatcher cpeMatch =
       False
 filter _ cpeMatch "go" v
   | "."
       `T.isInfixOf` v
       && "-"
-      `anyVersionInfixOf` cpeMatchVersionMatcher cpeMatch =
+        `anyVersionInfixOf` cpeMatchVersionMatcher cpeMatch =
       False
 filter _ cpeMatch "terraform" _
   | cpeTargetSoftware (cpeMatchCPE cpeMatch) == Just "aws" = False
diff --git a/src/Nix.hs b/src/Nix.hs
index 037b709..a3a480d 100644
--- a/src/Nix.hs
+++ b/src/Nix.hs
@@ -61,7 +61,7 @@ rawOpt Raw = ["--raw"]
 rawOpt NoRaw = []
 
 nixEvalApply ::
-  MonadIO m =>
+  (MonadIO m) =>
   Text ->
   Text ->
   ExceptT Text m Text
@@ -71,7 +71,7 @@ nixEvalApply applyFunc attrPath =
     & fmapRT (fst >>> T.strip)
 
 nixEvalApplyRaw ::
-  MonadIO m =>
+  (MonadIO m) =>
   Text ->
   Text ->
   ExceptT Text m Text
@@ -81,7 +81,7 @@ nixEvalApplyRaw applyFunc attrPath =
     & fmapRT (fst >>> T.strip)
 
 nixEvalExpr ::
-  MonadIO m =>
+  (MonadIO m) =>
   Text ->
   ExceptT Text m Text
 nixEvalExpr expr =
@@ -90,7 +90,7 @@ nixEvalExpr expr =
     & fmapRT (fst >>> T.strip)
 
 -- Error if the "new version" is actually newer according to nix
-assertNewerVersion :: MonadIO m => UpdateEnv -> ExceptT Text m ()
+assertNewerVersion :: (MonadIO m) => UpdateEnv -> ExceptT Text m ()
 assertNewerVersion updateEnv = do
   versionComparison <-
     nixEvalExpr
@@ -113,7 +113,7 @@ assertNewerVersion updateEnv = do
         )
 
 -- This is extremely slow but gives us the best results we know of
-lookupAttrPath :: MonadIO m => UpdateEnv -> ExceptT Text m Text
+lookupAttrPath :: (MonadIO m) => UpdateEnv -> ExceptT Text m Text
 lookupAttrPath updateEnv =
   -- lookup attrpath by nix-env
   ( proc
@@ -134,7 +134,7 @@ lookupAttrPath updateEnv =
     (getAttrString "name" (packageName updateEnv))
     & fmapRT (const (packageName updateEnv))
 
-getDerivationFile :: MonadIO m => Text -> ExceptT Text m Text
+getDerivationFile :: (MonadIO m) => Text -> ExceptT Text m Text
 getDerivationFile attrPath = do
   npDir <- liftIO $ Git.nixpkgsDir
   proc "env" ["EDITOR=echo", (binPath <> "/nix"), "--extra-experimental-features", "nix-command", "edit", attrPath & T.unpack, "-f", "."]
@@ -143,20 +143,20 @@ getDerivationFile attrPath = do
 
 -- Get an attribute that can be evaluated off a derivation, as in:
 -- getAttr "cargoSha256" "ripgrep" -> 0lwz661rbm7kwkd6mallxym1pz8ynda5f03ynjfd16vrazy2dj21
-getAttr :: MonadIO m => Text -> Text -> ExceptT Text m Text
+getAttr :: (MonadIO m) => Text -> Text -> ExceptT Text m Text
 getAttr attr = srcOrMain (nixEvalApply ("p: p." <> attr))
 
-getAttrString :: MonadIO m => Text -> Text -> ExceptT Text m Text
+getAttrString :: (MonadIO m) => Text -> Text -> ExceptT Text m Text
 getAttrString attr = srcOrMain (nixEvalApplyRaw ("p: p." <> attr))
 
-getHash :: MonadIO m => Text -> ExceptT Text m Text
+getHash :: (MonadIO m) => Text -> ExceptT Text m Text
 getHash = getAttrString "drvAttrs.outputHash"
 
-getMaintainers :: MonadIO m => Text -> ExceptT Text m Text
+getMaintainers :: (MonadIO m) => Text -> ExceptT Text m Text
 getMaintainers =
   nixEvalApplyRaw "p: let gh = m : m.github or \"\"; nonempty = s: s != \"\"; addAt = s: \"@\"+s; in builtins.concatStringsSep \" \" (map addAt (builtins.filter nonempty (map gh p.meta.maintainers or [])))"
 
-readNixBool :: MonadIO m => ExceptT Text m Text -> ExceptT Text m Bool
+readNixBool :: (MonadIO m) => ExceptT Text m Text -> ExceptT Text m Bool
 readNixBool t = do
   text <- t
   case text of
@@ -164,21 +164,21 @@ readNixBool t = do
     "false" -> return False
     a -> throwE ("Failed to read expected nix boolean " <> a <> " ")
 
-getIsBroken :: MonadIO m => Text -> ExceptT Text m Bool
+getIsBroken :: (MonadIO m) => Text -> ExceptT Text m Bool
 getIsBroken attrPath =
   getAttr "meta.broken" attrPath
     & readNixBool
 
-getChangelog :: MonadIO m => Text -> ExceptT Text m Text
+getChangelog :: (MonadIO m) => Text -> ExceptT Text m Text
 getChangelog = nixEvalApplyRaw "p: p.meta.changelog or \"\""
 
-getDescription :: MonadIO m => Text -> ExceptT Text m Text
+getDescription :: (MonadIO m) => Text -> ExceptT Text m Text
 getDescription = nixEvalApplyRaw "p: p.meta.description or \"\""
 
-getHomepage :: MonadIO m => Text -> ExceptT Text m Text
+getHomepage :: (MonadIO m) => Text -> ExceptT Text m Text
 getHomepage = nixEvalApplyRaw "p: p.meta.homepage or \"\""
 
-getSrcUrl :: MonadIO m => Text -> ExceptT Text m Text
+getSrcUrl :: (MonadIO m) => Text -> ExceptT Text m Text
 getSrcUrl =
   srcOrMain
     (nixEvalApplyRaw "p: builtins.elemAt p.drvAttrs.urls 0")
@@ -190,7 +190,7 @@ buildCmd attrPath =
 log :: Text -> ProcessConfig () () ()
 log attrPath = proc (binPath <> "/nix") ["--extra-experimental-features", "nix-command", "log", "-f", ".", attrPath & T.unpack]
 
-build :: MonadIO m => Text -> ExceptT Text m ()
+build :: (MonadIO m) => Text -> ExceptT Text m ()
 build attrPath =
   (buildCmd attrPath & runProcess_ & tryIOTextET)
     <|> ( do
@@ -204,7 +204,7 @@ build attrPath =
           & fmap (T.lines >>> reverse >>> take 30 >>> reverse >>> T.unlines)
       throwE ("nix build failed.\n" <> buildLog <> " ")
 
-cachix :: MonadIO m => Text -> ExceptT Text m ()
+cachix :: (MonadIO m) => Text -> ExceptT Text m ()
 cachix resultPath =
   ( setStdin
       (byteStringInput (TL.encodeUtf8 (TL.fromStrict resultPath)))
@@ -228,7 +228,7 @@ numberOfHashes derivationContents =
     countUp x = T.count x derivationContents
 
 assertOldVersionOn ::
-  MonadIO m => UpdateEnv -> Text -> Text -> ExceptT Text m ()
+  (MonadIO m) => UpdateEnv -> Text -> Text -> ExceptT Text m ()
 assertOldVersionOn updateEnv branchName contents =
   tryAssert
     ("Old version " <> oldVersionPattern <> " not present in " <> branchName <> " derivation file with contents: " <> contents)
@@ -236,7 +236,7 @@ assertOldVersionOn updateEnv branchName contents =
   where
     oldVersionPattern = oldVersion updateEnv <> "\""
 
-resultLink :: MonadIO m => ExceptT Text m Text
+resultLink :: (MonadIO m) => ExceptT Text m Text
 resultLink =
   T.strip
     <$> ( ourReadProcessInterleaved_ "readlink ./result"
@@ -252,7 +252,7 @@ fakeHashMatching oldHash =
     else "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
 
 -- fixed-output derivation produced path '/nix/store/fg2hz90z5bc773gpsx4gfxn3l6fl66nw-source' with sha256 hash '0q1lsgc1621czrg49nmabq6am9sgxa9syxrwzlksqqr4dyzw4nmf' instead of the expected hash '0bp22mzkjy48gncj5vm9b7whzrggcbs5pd4cnb6k8jpl9j02dhdv'
-getHashFromBuild :: MonadIO m => Text -> ExceptT Text m Text
+getHashFromBuild :: (MonadIO m) => Text -> ExceptT Text m Text
 getHashFromBuild =
   srcOrMain
     ( \attrPath -> do
@@ -275,26 +275,26 @@ getHashFromBuild =
           secondSplit
     )
 
-version :: MonadIO m => ExceptT Text m Text
+version :: (MonadIO m) => ExceptT Text m Text
 version = ourReadProcessInterleaved_ (proc (binPath <> "/nix") ["--version"])
 
-getPatches :: MonadIO m => Text -> ExceptT Text m Text
+getPatches :: (MonadIO m) => Text -> ExceptT Text m Text
 getPatches =
   nixEvalApply "p: map (patch: patch.name) p.patches"
 
-hasPatchNamed :: MonadIO m => Text -> Text -> ExceptT Text m Bool
+hasPatchNamed :: (MonadIO m) => Text -> Text -> ExceptT Text m Bool
 hasPatchNamed attrPath name = do
   ps <- getPatches attrPath
   return $ name `T.isInfixOf` ps
 
-hasUpdateScript :: MonadIO m => Text -> ExceptT Text m Bool
+hasUpdateScript :: (MonadIO m) => Text -> ExceptT Text m Bool
 hasUpdateScript attrPath = do
   nixEvalApply
     "p: builtins.hasAttr \"updateScript\" p"
     attrPath
     & readNixBool
 
-runUpdateScript :: MonadIO m => Text -> ExceptT Text m (ExitCode, Text)
+runUpdateScript :: (MonadIO m) => Text -> ExceptT Text m (ExitCode, Text)
 runUpdateScript attrPath = do
   let timeout = "10m" :: Text
   (exitCode, output) <-
diff --git a/src/NixpkgsReview.hs b/src/NixpkgsReview.hs
index e3589ba..7e50066 100644
--- a/src/NixpkgsReview.hs
+++ b/src/NixpkgsReview.hs
@@ -29,7 +29,7 @@ revDir :: FilePath -> Text -> FilePath
 revDir cache commit = cache <> "/rev-" <> T.unpack commit
 
 run ::
-  Members '[F.File, P.Process, Output Text] r =>
+  (Members '[F.File, P.Process, Output Text] r) =>
   FilePath ->
   Text ->
   Sem r Text
diff --git a/src/OurPrelude.hs b/src/OurPrelude.hs
index 552c293..648b293 100644
--- a/src/OurPrelude.hs
+++ b/src/OurPrelude.hs
@@ -62,46 +62,46 @@ import System.Process.Typed
 interpolate :: QuasiQuoter
 interpolate = NeatInterpolation.text
 
-tshow :: Show a => a -> Text
+tshow :: (Show a) => a -> Text
 tshow = show >>> pack
 
-tryIOTextET :: MonadIO m => IO a -> ExceptT Text m a
+tryIOTextET :: (MonadIO m) => IO a -> ExceptT Text m a
 tryIOTextET = syncIO >>> fmapLT tshow
 
-whenM :: Monad m => m Bool -> m () -> m ()
+whenM :: (Monad m) => m Bool -> m () -> m ()
 whenM c a = c >>= \res -> when res a
 
 bytestringToText :: BSL.ByteString -> Text
 bytestringToText = BSL.toStrict >>> (T.decodeUtf8With T.lenientDecode)
 
 ourReadProcessInterleavedBS_ ::
-  MonadIO m =>
+  (MonadIO m) =>
   ProcessConfig stdin stdoutIgnored stderrIgnored ->
   ExceptT Text m BSL.ByteString
 ourReadProcessInterleavedBS_ = readProcessInterleaved_ >>> tryIOTextET
 
 ourReadProcess_ ::
-  MonadIO m =>
+  (MonadIO m) =>
   ProcessConfig stdin stdout stderr ->
   ExceptT Text m (Text, Text)
 ourReadProcess_ = readProcess_ >>> tryIOTextET >>> fmapRT (\(stdout, stderr) -> (bytestringToText stdout, bytestringToText stderr))
 
 ourReadProcess_Sem ::
-  Members '[P.Process] r =>
+  (Members '[P.Process] r) =>
   ProcessConfig stdin stdoutIgnored stderrIgnored ->
   Sem r (Text, Text)
 ourReadProcess_Sem =
   P.read_ >>> fmap (\(stdout, stderr) -> (bytestringToText stdout, bytestringToText stderr))
 
 ourReadProcessInterleaved_ ::
-  MonadIO m =>
+  (MonadIO m) =>
   ProcessConfig stdin stdoutIgnored stderrIgnored ->
   ExceptT Text m Text
 ourReadProcessInterleaved_ =
   readProcessInterleaved_ >>> tryIOTextET >>> fmapRT bytestringToText
 
 ourReadProcessInterleaved ::
-  MonadIO m =>
+  (MonadIO m) =>
   ProcessConfig stdin stdoutIgnored stderrIgnored ->
   ExceptT Text m (ExitCode, Text)
 ourReadProcessInterleaved =
@@ -110,7 +110,7 @@ ourReadProcessInterleaved =
     >>> fmapRT (\(a, b) -> (a, bytestringToText b))
 
 ourReadProcessInterleavedSem ::
-  Members '[P.Process] r =>
+  (Members '[P.Process] r) =>
   ProcessConfig stdin stdoutIgnored stderrIgnored ->
   Sem r (ExitCode, Text)
 ourReadProcessInterleavedSem =
diff --git a/src/Outpaths.hs b/src/Outpaths.hs
index aedb15b..a1bc681 100644
--- a/src/Outpaths.hs
+++ b/src/Outpaths.hs
@@ -87,7 +87,7 @@ in
   tweak (builtins.removeAttrs hydraJobs blacklist)
 |]
 
-outPath :: MonadIO m => ExceptT Text m Text
+outPath :: (MonadIO m) => ExceptT Text m Text
 outPath = do
   cacheDir <- liftIO $ Utils.outpathCacheDir
   let outpathFile = (cacheDir </> "outpaths.nix")
@@ -131,7 +131,7 @@ data ResultLine = ResultLine
 -- testInput :: Text
 -- testInput =
 --   "haskellPackages.amazonka-dynamodb-streams.x86_64-linux                        doc=/nix/store/m4rpsc9nx0qcflh9ni6qdlg6hbkwpicc-amazonka-dynamodb-streams-1.6.0-doc;/nix/store/rvd4zydr22a7j5kgnmg5x6695c7bgqbk-amazonka-dynamodb-streams-1.6.0\nhaskellPackages.agum.x86_64-darwin                                            doc=/nix/store/n526rc0pa5h0krdzsdni5agcpvcd3cb9-agum-2.7-doc;/nix/store/s59r75svbjm724q5iaprq4mln5k6wcr9-agum-2.7"
-currentOutpathSet :: MonadIO m => ExceptT Text m (Set ResultLine)
+currentOutpathSet :: (MonadIO m) => ExceptT Text m (Set ResultLine)
 currentOutpathSet = do
   rev <- Git.headRev
   mayOp <- lift $ lookupOutPathByRev rev
@@ -145,12 +145,12 @@ currentOutpathSet = do
       pure paths
   parse parseResults "outpath" op & fmapL tshow & hoistEither
 
-currentOutpathSetUncached :: MonadIO m => ExceptT Text m (Set ResultLine)
+currentOutpathSetUncached :: (MonadIO m) => ExceptT Text m (Set ResultLine)
 currentOutpathSetUncached = do
   op <- outPath
   parse parseResults "outpath" op & fmapL tshow & hoistEither
 
-lookupOutPathByRev :: MonadIO m => Text -> m (Maybe Text)
+lookupOutPathByRev :: (MonadIO m) => Text -> m (Maybe Text)
 lookupOutPathByRev rev = do
   dir <- Utils.outpathCacheDir
   let file = dir <> "/" <> T.unpack rev
@@ -167,10 +167,10 @@ dummyOutpathSetBefore attrPath = S.singleton (ResultLine attrPath "x86-64" (V.si
 dummyOutpathSetAfter :: Text -> Set ResultLine
 dummyOutpathSetAfter attrPath = S.singleton (ResultLine attrPath "x86-64" (V.singleton (Outpath (Just "attrPath") "fakepath-edited")))
 
-parseResults :: CharParsing m => m (Set ResultLine)
+parseResults :: (CharParsing m) => m (Set ResultLine)
 parseResults = S.fromList <$> parseResultLine `sepEndBy` newline
 
-parseResultLine :: CharParsing m => m ResultLine
+parseResultLine :: (CharParsing m) => m ResultLine
 parseResultLine =
   ResultLine
     <$> (T.dropWhileEnd (== '.') <$> parseAttrpath)
@@ -178,19 +178,19 @@ parseResultLine =
     <* spaces
     <*> parseOutpaths
 
-parseAttrpath :: CharParsing m => m Text
+parseAttrpath :: (CharParsing m) => m Text
 parseAttrpath = T.concat <$> many (try parseAttrpathPart)
 
-parseAttrpathPart :: CharParsing m => m Text
+parseAttrpathPart :: (CharParsing m) => m Text
 parseAttrpathPart = T.snoc <$> (T.pack <$> many (noneOf ". ")) <*> char '.'
 
-parseArchitecture :: CharParsing m => m Text
+parseArchitecture :: (CharParsing m) => m Text
 parseArchitecture = T.pack <$> many (noneOf " ")
 
-parseOutpaths :: CharParsing m => m (Vector Outpath)
+parseOutpaths :: (CharParsing m) => m (Vector Outpath)
 parseOutpaths = V.fromList <$> (parseOutpath `sepBy1` char ';')
 
-parseOutpath :: CharParsing m => m Outpath
+parseOutpath :: (CharParsing m) => m Outpath
 parseOutpath =
   Outpath
     <$> optional (try (T.pack <$> (many (noneOf "=\n") <* char '=')))
diff --git a/src/Process.hs b/src/Process.hs
index 6d073d5..71eeeb4 100644
--- a/src/Process.hs
+++ b/src/Process.hs
@@ -17,7 +17,7 @@ data Process m a where
 makeSem ''Process
 
 runIO ::
-  Member (Embed IO) r =>
+  (Member (Embed IO) r) =>
   Sem (Process ': r) a ->
   Sem r a
 runIO =
diff --git a/src/Rewrite.hs b/src/Rewrite.hs
index 4704e87..05053de 100644
--- a/src/Rewrite.hs
+++ b/src/Rewrite.hs
@@ -77,23 +77,23 @@ runAll log args = do
 
 --------------------------------------------------------------------------------
 -- The canonical updater: updates the src attribute and recomputes the sha256
-version :: MonadIO m => (Text -> m ()) -> Args -> ExceptT Text m (Maybe Text)
+version :: (MonadIO m) => (Text -> m ()) -> Args -> ExceptT Text m (Maybe Text)
 version log args@Args {..} = do
   if
-      | Nix.numberOfFetchers derivationContents > 1 || Nix.numberOfHashes derivationContents > 1 -> do
-          lift $ log "generic version rewriter does not support multiple hashes"
-          return Nothing
-      | hasUpdateScript -> do
-          lift $ log "skipping because derivation has updateScript"
-          return Nothing
-      | otherwise -> do
-          srcVersionFix args
-          lift $ log "updated version and sha256"
-          return $ Just "Version update"
+    | Nix.numberOfFetchers derivationContents > 1 || Nix.numberOfHashes derivationContents > 1 -> do
+        lift $ log "generic version rewriter does not support multiple hashes"
+        return Nothing
+    | hasUpdateScript -> do
+        lift $ log "skipping because derivation has updateScript"
+        return Nothing
+    | otherwise -> do
+        srcVersionFix args
+        lift $ log "updated version and sha256"
+        return $ Just "Version update"
 
 --------------------------------------------------------------------------------
 -- Redirect homepage when moved.
-redirectedUrls :: MonadIO m => (Text -> m ()) -> Args -> ExceptT Text m (Maybe Text)
+redirectedUrls :: (MonadIO m) => (Text -> m ()) -> Args -> ExceptT Text m (Maybe Text)
 redirectedUrls log Args {..} = do
   homepage <- Nix.getHomepage attrPath
   response <- liftIO $ do
@@ -127,106 +127,106 @@ redirectedUrls log Args {..} = do
 -- Rewrite Rust on rustPlatform.buildRustPackage
 -- This is basically `version` above, but with a second pass to also update the
 -- cargoSha256 vendor hash.
-rustCrateVersion :: MonadIO m => (Text -> m ()) -> Args -> ExceptT Text m (Maybe Text)
+rustCrateVersion :: (MonadIO m) => (Text -> m ()) -> Args -> ExceptT Text m (Maybe Text)
 rustCrateVersion log args@Args {..} = do
   if
-      | and [(not (T.isInfixOf "cargoSha256" derivationContents)), (not (T.isInfixOf "cargoHash" derivationContents))] -> do
-          lift $ log "No cargoSha256 or cargoHash found"
-          return Nothing
-      | hasUpdateScript -> do
-          lift $ log "skipping because derivation has updateScript"
-          return Nothing
-      | otherwise -> do
-          _ <- lift $ File.replaceIO "cargoSha256 =" "cargoHash =" derivationFile
-          -- This starts the same way `version` does, minus the assert
-          srcVersionFix args
-          -- But then from there we need to do this a second time for the cargoHash!
-          oldCargoHash <- Nix.getAttrString "cargoHash" attrPath
-          let fakeHash = Nix.fakeHashMatching oldCargoHash
-          _ <- lift $ File.replaceIO oldCargoHash fakeHash derivationFile
-          newCargoHash <- Nix.getHashFromBuild attrPath
-          when (oldCargoHash == newCargoHash) $ throwE ("cargo hashes equal; no update necessary: " <> oldCargoHash)
-          lift . log $ "Replacing cargoHash with " <> newCargoHash
-          _ <- lift $ File.replaceIO fakeHash newCargoHash derivationFile
-          -- Ensure the package actually builds and passes its tests
-          Nix.build attrPath
-          lift $ log "Finished updating Crate version and replacing hashes"
-          return $ Just "Rust version update"
+    | and [(not (T.isInfixOf "cargoSha256" derivationContents)), (not (T.isInfixOf "cargoHash" derivationContents))] -> do
+        lift $ log "No cargoSha256 or cargoHash found"
+        return Nothing
+    | hasUpdateScript -> do
+        lift $ log "skipping because derivation has updateScript"
+        return Nothing
+    | otherwise -> do
+        _ <- lift $ File.replaceIO "cargoSha256 =" "cargoHash =" derivationFile
+        -- This starts the same way `version` does, minus the assert
+        srcVersionFix args
+        -- But then from there we need to do this a second time for the cargoHash!
+        oldCargoHash <- Nix.getAttrString "cargoHash" attrPath
+        let fakeHash = Nix.fakeHashMatching oldCargoHash
+        _ <- lift $ File.replaceIO oldCargoHash fakeHash derivationFile
+        newCargoHash <- Nix.getHashFromBuild attrPath
+        when (oldCargoHash == newCargoHash) $ throwE ("cargo hashes equal; no update necessary: " <> oldCargoHash)
+        lift . log $ "Replacing cargoHash with " <> newCargoHash
+        _ <- lift $ File.replaceIO fakeHash newCargoHash derivationFile
+        -- Ensure the package actually builds and passes its tests
+        Nix.build attrPath
+        lift $ log "Finished updating Crate version and replacing hashes"
+        return $ Just "Rust version update"
 
 --------------------------------------------------------------------------------
 -- Rewrite Golang packages with buildGoModule
 -- This is basically `version` above, but with a second pass to also update the
 -- vendorHash go vendor hash.
-golangModuleVersion :: MonadIO m => (Text -> m ()) -> Args -> ExceptT Text m (Maybe Text)
+golangModuleVersion :: (MonadIO m) => (Text -> m ()) -> Args -> ExceptT Text m (Maybe Text)
 golangModuleVersion log args@Args {..} = do
   if
-      | and [not (T.isInfixOf "buildGoModule" derivationContents && T.isInfixOf "vendorSha256" derivationContents), not (T.isInfixOf "buildGoModule" derivationContents && T.isInfixOf "vendorHash" derivationContents)] -> do
-          lift $ log "Not a buildGoModule package with vendorSha256 or vendorHash"
-          return Nothing
-      | hasUpdateScript -> do
-          lift $ log "skipping because derivation has updateScript"
-          return Nothing
-      | otherwise -> do
-          _ <- lift $ File.replaceIO "vendorSha256 =" "vendorHash =" derivationFile
-          -- This starts the same way `version` does, minus the assert
-          srcVersionFix args
-          -- But then from there we need to do this a second time for the vendorHash!
-          -- Note that explicit `null` cannot be coerced to a string by nix eval --raw
-          oldVendorHash <- Nix.getAttr "vendorHash" attrPath
-          lift . log $ "Found old vendorHash = " <> oldVendorHash
-          original <- liftIO $ T.readFile derivationFile
-          _ <- lift $ File.replaceIO oldVendorHash "null" derivationFile
-          ok <- runExceptT $ Nix.build attrPath
-          _ <-
-            if isLeft ok
-              then do
-                _ <- liftIO $ T.writeFile derivationFile original
-                let fakeHash = Nix.fakeHashMatching oldVendorHash
-                _ <- lift $ File.replaceIO oldVendorHash ("\"" <> fakeHash <> "\"") derivationFile
-                newVendorHash <- Nix.getHashFromBuild attrPath
-                _ <- lift $ File.replaceIO fakeHash newVendorHash derivationFile
-                -- Note that on some small bumps, this may not actually change if go.sum did not
-                lift . log $ "Replaced vendorHash with " <> newVendorHash
-              else do
-                lift . log $ "Set vendorHash to null"
-          -- Ensure the package actually builds and passes its tests
-          Nix.build attrPath
-          lift $ log "Finished updating vendorHash"
-          return $ Just "Golang update"
+    | and [not (T.isInfixOf "buildGoModule" derivationContents && T.isInfixOf "vendorSha256" derivationContents), not (T.isInfixOf "buildGoModule" derivationContents && T.isInfixOf "vendorHash" derivationContents)] -> do
+        lift $ log "Not a buildGoModule package with vendorSha256 or vendorHash"
+        return Nothing
+    | hasUpdateScript -> do
+        lift $ log "skipping because derivation has updateScript"
+        return Nothing
+    | otherwise -> do
+        _ <- lift $ File.replaceIO "vendorSha256 =" "vendorHash =" derivationFile
+        -- This starts the same way `version` does, minus the assert
+        srcVersionFix args
+        -- But then from there we need to do this a second time for the vendorHash!
+        -- Note that explicit `null` cannot be coerced to a string by nix eval --raw
+        oldVendorHash <- Nix.getAttr "vendorHash" attrPath
+        lift . log $ "Found old vendorHash = " <> oldVendorHash
+        original <- liftIO $ T.readFile derivationFile
+        _ <- lift $ File.replaceIO oldVendorHash "null" derivationFile
+        ok <- runExceptT $ Nix.build attrPath
+        _ <-
+          if isLeft ok
+            then do
+              _ <- liftIO $ T.writeFile derivationFile original
+              let fakeHash = Nix.fakeHashMatching oldVendorHash
+              _ <- lift $ File.replaceIO oldVendorHash ("\"" <> fakeHash <> "\"") derivationFile
+              newVendorHash <- Nix.getHashFromBuild attrPath
+              _ <- lift $ File.replaceIO fakeHash newVendorHash derivationFile
+              -- Note that on some small bumps, this may not actually change if go.sum did not
+              lift . log $ "Replaced vendorHash with " <> newVendorHash
+            else do
+              lift . log $ "Set vendorHash to null"
+        -- Ensure the package actually builds and passes its tests
+        Nix.build attrPath
+        lift $ log "Finished updating vendorHash"
+        return $ Just "Golang update"
 
 --------------------------------------------------------------------------------
 -- Rewrite NPM packages with buildNpmPackage
 -- This is basically `version` above, but with a second pass to also update the
 -- cargoSha256 vendor hash.
-npmDepsVersion :: MonadIO m => (Text -> m ()) -> Args -> ExceptT Text m (Maybe Text)
+npmDepsVersion :: (MonadIO m) => (Text -> m ()) -> Args -> ExceptT Text m (Maybe Text)
 npmDepsVersion log args@Args {..} = do
   if
-      | not (T.isInfixOf "npmDepsHash" derivationContents) -> do
-          lift $ log "No npmDepsHash"
-          return Nothing
-      | hasUpdateScript -> do
-          lift $ log "skipping because derivation has updateScript"
-          return Nothing
-      | otherwise -> do
-          -- This starts the same way `version` does, minus the assert
-          srcVersionFix args
-          -- But then from there we need to do this a second time for the cargoHash!
-          oldDepsHash <- Nix.getAttrString "npmDepsHash" attrPath
-          let fakeHash = Nix.fakeHashMatching oldDepsHash
-          _ <- lift $ File.replaceIO oldDepsHash fakeHash derivationFile
-          newDepsHash <- Nix.getHashFromBuild attrPath
-          when (oldDepsHash == newDepsHash) $ throwE ("deps hashes equal; no update necessary: " <> oldDepsHash)
-          lift . log $ "Replacing npmDepsHash with " <> newDepsHash
-          _ <- lift $ File.replaceIO fakeHash newDepsHash derivationFile
-          -- Ensure the package actually builds and passes its tests
-          Nix.build attrPath
-          lift $ log "Finished updating NPM deps version and replacing hashes"
-          return $ Just "NPM version update"
+    | not (T.isInfixOf "npmDepsHash" derivationContents) -> do
+        lift $ log "No npmDepsHash"
+        return Nothing
+    | hasUpdateScript -> do
+        lift $ log "skipping because derivation has updateScript"
+        return Nothing
+    | otherwise -> do
+        -- This starts the same way `version` does, minus the assert
+        srcVersionFix args
+        -- But then from there we need to do this a second time for the cargoHash!
+        oldDepsHash <- Nix.getAttrString "npmDepsHash" attrPath
+        let fakeHash = Nix.fakeHashMatching oldDepsHash
+        _ <- lift $ File.replaceIO oldDepsHash fakeHash derivationFile
+        newDepsHash <- Nix.getHashFromBuild attrPath
+        when (oldDepsHash == newDepsHash) $ throwE ("deps hashes equal; no update necessary: " <> oldDepsHash)
+        lift . log $ "Replacing npmDepsHash with " <> newDepsHash
+        _ <- lift $ File.replaceIO fakeHash newDepsHash derivationFile
+        -- Ensure the package actually builds and passes its tests
+        Nix.build attrPath
+        lift $ log "Finished updating NPM deps version and replacing hashes"
+        return $ Just "NPM version update"
 
 --------------------------------------------------------------------------------
 
 -- Calls passthru.updateScript
-updateScript :: MonadIO m => (Text -> m ()) -> Args -> ExceptT Text m (Maybe Text)
+updateScript :: (MonadIO m) => (Text -> m ()) -> Args -> ExceptT Text m (Maybe Text)
 updateScript log Args {..} = do
   if hasUpdateScript
     then do
@@ -246,7 +246,7 @@ updateScript log Args {..} = do
 -- Common helper functions and utilities
 -- Helper to update version and src attributes, re-computing the sha256.
 -- This is done by the generic version upgrader, but is also a sub-component of some of the others.
-srcVersionFix :: MonadIO m => Args -> ExceptT Text m ()
+srcVersionFix :: (MonadIO m) => Args -> ExceptT Text m ()
 srcVersionFix Args {..} = do
   let UpdateEnv {..} = updateEnv
   oldHash <- Nix.getHash attrPath
diff --git a/src/Skiplist.hs b/src/Skiplist.hs
index 78fc1b6..59f51f4 100644
--- a/src/Skiplist.hs
+++ b/src/Skiplist.hs
@@ -223,7 +223,7 @@ eq part reason = ((part ==), reason)
 regex :: RE' a -> Text -> (Text -> Bool, Text)
 regex pat reason = (isJust . (=~ pat), reason)
 
-python :: Monad m => Int -> Text -> ExceptT Text m ()
+python :: (Monad m) => Int -> Text -> ExceptT Text m ()
 python numPackageRebuilds derivationContents =
   tryAssert
     ( "Python package with too many package rebuilds "
diff --git a/src/Update.hs b/src/Update.hs
index a3aba14..c15e1b1 100644
--- a/src/Update.hs
+++ b/src/Update.hs
@@ -68,7 +68,7 @@ alsoLogToAttrPath attrPath topLevelLog = do
     topLevelLog text
     attrPathLog text
 
-log' :: MonadIO m => FilePath -> Text -> m ()
+log' :: (MonadIO m) => FilePath -> Text -> m ()
 log' logFile msg = liftIO $ T.appendFile logFile (msg <> "\n")
 
 attrPathLogFilePath :: Text -> IO String
@@ -628,7 +628,7 @@ untilOfBorgFree log waitUntil = do
       untilOfBorgFree log waitUntil
 
 assertNotUpdatedOn ::
-  MonadIO m => UpdateEnv -> Text -> Text -> ExceptT Text m ()
+  (MonadIO m) => UpdateEnv -> Text -> Text -> ExceptT Text m ()
 assertNotUpdatedOn updateEnv derivationFile branch = do
   derivationContents <- Git.show branch derivationFile
   Nix.assertOldVersionOn updateEnv branch derivationContents
@@ -700,7 +700,7 @@ cveReport updateEnv =
        <br/>
       |]
 
-doCachix :: MonadIO m => (Text -> m ()) -> UpdateEnv -> Text -> ExceptT Text m Text
+doCachix :: (MonadIO m) => (Text -> m ()) -> UpdateEnv -> Text -> ExceptT Text m Text
 doCachix log updateEnv resultPath =
   let o = options updateEnv
    in if batchUpdate o && "r-ryantm" == (GH.untagName $ githubUser o)
diff --git a/src/Utils.hs b/src/Utils.hs
index efa43f7..af5c55c 100644
--- a/src/Utils.hs
+++ b/src/Utils.hs
@@ -96,7 +96,7 @@ readField f@(Field (SQLText t) _) =
     Left e -> returnError ConversionFailed f $ "read error: " <> e
 readField f = returnError ConversionFailed f "expecting SQLText column type"
 
-showField :: Show a => a -> SQLData
+showField :: (Show a) => a -> SQLData
 showField = toField . show
 
 instance FromField VersionMatcher where
@@ -125,7 +125,7 @@ data UpdateEnv = UpdateEnv
     options :: Options
   }
 
-whenBatch :: Applicative f => UpdateEnv -> f () -> f ()
+whenBatch :: (Applicative f) => UpdateEnv -> f () -> f ()
 whenBatch updateEnv = when (batchUpdate . options $ updateEnv)
 
 prTitle :: UpdateEnv -> Text -> Text
@@ -147,7 +147,7 @@ regDirMode =
     .|. otherReadMode
     .|. otherExecuteMode
 
-logsDirectory :: MonadIO m => ExceptT Text m FilePath
+logsDirectory :: (MonadIO m) => ExceptT Text m FilePath
 logsDirectory = do
   dir <-
     noteT "Could not get environment variable LOGS_DIRECTORY" $
@@ -163,7 +163,7 @@ logsDirectory = do
     )
   return dir
 
-cacheDir :: MonadIO m => m FilePath
+cacheDir :: (MonadIO m) => m FilePath
 cacheDir = do
   cacheDirectory <- liftIO $ lookupEnv "CACHE_DIRECTORY"
   xdgCacheHome <- liftIO $ fmap (fmap (\dir -> dir </> "nixpkgs-update")) $ lookupEnv "XDG_CACHE_HOME"
@@ -172,7 +172,7 @@ cacheDir = do
   liftIO $ createDirectoryIfMissing True dir
   return dir
 
-outpathCacheDir :: MonadIO m => m FilePath
+outpathCacheDir :: (MonadIO m) => m FilePath
 outpathCacheDir = do
   cache <- cacheDir
   let dir = cache </> "outpath"
@@ -186,7 +186,7 @@ worktreeDir = do
   createDirectoryIfMissing False dir
   return dir
 
-xdgRuntimeDir :: MonadIO m => ExceptT Text m FilePath
+xdgRuntimeDir :: (MonadIO m) => ExceptT Text m FilePath
 xdgRuntimeDir = do
   xDir <-
     noteT "Could not get environment variable XDG_RUNTIME_DIR" $
@@ -204,7 +204,7 @@ xdgRuntimeDir = do
     )
   return dir
 
-tmpRuntimeDir :: MonadIO m => ExceptT Text m FilePath
+tmpRuntimeDir :: (MonadIO m) => ExceptT Text m FilePath
 tmpRuntimeDir = do
   dir <- liftIO $ mkdtemp "nixpkgs-update"
   dirExists <- liftIO $ doesDirectoryExist dir
@@ -241,7 +241,7 @@ parseUpdates = map (toTriple . T.words) . T.lines
     toTriple [package, oldVer, newVer, url] = Right (package, oldVer, newVer, Just url)
     toTriple line = Left $ "Unable to parse update: " <> T.unwords line
 
-srcOrMain :: MonadIO m => (Text -> ExceptT Text m a) -> Text -> ExceptT Text m a
+srcOrMain :: (MonadIO m) => (Text -> ExceptT Text m a) -> Text -> ExceptT Text m a
 srcOrMain et attrPath = et (attrPath <> ".src") <|> et (attrPath <> ".originalSrc") <|> et attrPath
 
 nixCommonOptions :: [String]
@@ -263,7 +263,7 @@ nixBuildOptions =
     <> nixCommonOptions
 
 runLog ::
-  Member (Embed IO) r =>
+  (Member (Embed IO) r) =>
   (Text -> IO ()) ->
   Sem ((Output Text) ': r) a ->
   Sem r a
diff --git a/src/Version.hs b/src/Version.hs
index 4c087b2..0748a23 100644
--- a/src/Version.hs
+++ b/src/Version.hs
@@ -91,7 +91,7 @@ versionIncompatibleWithPathPin :: Text -> Version -> Bool
 versionIncompatibleWithPathPin path version =
   not (versionCompatibleWithPathPin path version)
 
-assertCompatibleWithPathPin :: Monad m => UpdateEnv -> Text -> ExceptT Text m ()
+assertCompatibleWithPathPin :: (Monad m) => UpdateEnv -> Text -> ExceptT Text m ()
 assertCompatibleWithPathPin ue attrPath =
   tryAssert
     ( "Version in attr path "

From a1863fa89e85dd91d16239dbceaace3e6aa2c173 Mon Sep 17 00:00:00 2001
From: zowoq <59103226+zowoq@users.noreply.github.com>
Date: Sun, 28 Apr 2024 13:42:44 +1000
Subject: [PATCH 4/4] flake.lock: Update
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Flake lock file updates:

• Updated input 'mmdoc':
    'github:ryantm/mmdoc/cec02bafac9456bd1ed9b261b8d163a893885e5b?narHash=sha256-4ppYRBBY6lIqwMNYp0XA2mku1lSPyX4JaoTf%2Bgt5NDg%3D' (2022-11-21)
  → 'github:ryantm/mmdoc/b6ddf748b1d1c01ca582bb1b3dafd6bc3a4c83a6?narHash=sha256-5wa%2BJzxr%2BLygoxSZuZg0YU81jgdnx2IY/CqDIJMOgec%3D' (2024-03-17)
• Removed input 'mmdoc/nixpkgs-for-manual'
• Added input 'mmdoc/systems':
    'github:nix-systems/default/da67096a3b9bf56a91d16901293e51ba5b49a27e?narHash=sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768%3D' (2023-04-09)
• Updated input 'nixpkgs':
    'github:NixOS/nixpkgs/293a28df6d7ff3dec1e61e37cc4ee6e6c0fb0847?narHash=sha256-eejhqkDz2cb2vc5VeaWphJz8UXNuoNoM8/Op8eWv2tQ%3D' (2022-12-30)
  → 'github:NixOS/nixpkgs/d6f6eb2a984f2ba9a366c31e4d36d65465683450?narHash=sha256-Yg5D5LhyAZvd3DZrQQfJAVK8K3TkUYKooFtH1ulM0mw%3D' (2024-04-27)
• Updated input 'treefmt-nix':
    'github:numtide/treefmt-nix/49dc4a92b02b8e68798abd99184f228243b6e3ac?narHash=sha256-N3QDhoaX%2BpaWXHbEXZapqd1r95mdshxToGowtjtYkGI%3D' (2024-04-01)
  → 'github:numtide/treefmt-nix/c6aaf729f34a36c445618580a9f95a48f5e4e03f?narHash=sha256-Qv4RBm4LKuO4fNOfx9wl40W2rBbv5u5m%2BwhxRYUMiaA%3D' (2024-04-25)
---
 flake.lock | 51 +++++++++++++++++++++++++--------------------------
 1 file changed, 25 insertions(+), 26 deletions(-)

diff --git a/flake.lock b/flake.lock
index 9b39967..a7d4bb3 100644
--- a/flake.lock
+++ b/flake.lock
@@ -5,14 +5,14 @@
         "nixpkgs": [
           "nixpkgs"
         ],
-        "nixpkgs-for-manual": "nixpkgs-for-manual"
+        "systems": "systems"
       },
       "locked": {
-        "lastModified": 1669050835,
-        "narHash": "sha256-4ppYRBBY6lIqwMNYp0XA2mku1lSPyX4JaoTf+gt5NDg=",
+        "lastModified": 1710694589,
+        "narHash": "sha256-5wa+Jzxr+LygoxSZuZg0YU81jgdnx2IY/CqDIJMOgec=",
         "owner": "ryantm",
         "repo": "mmdoc",
-        "rev": "cec02bafac9456bd1ed9b261b8d163a893885e5b",
+        "rev": "b6ddf748b1d1c01ca582bb1b3dafd6bc3a4c83a6",
         "type": "github"
       },
       "original": {
@@ -23,11 +23,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1672428209,
-        "narHash": "sha256-eejhqkDz2cb2vc5VeaWphJz8UXNuoNoM8/Op8eWv2tQ=",
+        "lastModified": 1714213793,
+        "narHash": "sha256-Yg5D5LhyAZvd3DZrQQfJAVK8K3TkUYKooFtH1ulM0mw=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "293a28df6d7ff3dec1e61e37cc4ee6e6c0fb0847",
+        "rev": "d6f6eb2a984f2ba9a366c31e4d36d65465683450",
         "type": "github"
       },
       "original": {
@@ -35,22 +35,6 @@
         "type": "indirect"
       }
     },
-    "nixpkgs-for-manual": {
-      "locked": {
-        "lastModified": 1663819393,
-        "narHash": "sha256-SMWfyAOKRPBC95M8dhZJTlb0kHyilr2lKEAfQSHlM7I=",
-        "owner": "ryantm",
-        "repo": "nixpkgs",
-        "rev": "6a6caacfdd079a0fa249046514480a1c4597d861",
-        "type": "github"
-      },
-      "original": {
-        "owner": "ryantm",
-        "ref": "minman",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
     "root": {
       "inputs": {
         "mmdoc": "mmdoc",
@@ -58,6 +42,21 @@
         "treefmt-nix": "treefmt-nix"
       }
     },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
     "treefmt-nix": {
       "inputs": {
         "nixpkgs": [
@@ -65,11 +64,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1711963903,
-        "narHash": "sha256-N3QDhoaX+paWXHbEXZapqd1r95mdshxToGowtjtYkGI=",
+        "lastModified": 1714058656,
+        "narHash": "sha256-Qv4RBm4LKuO4fNOfx9wl40W2rBbv5u5m+whxRYUMiaA=",
         "owner": "numtide",
         "repo": "treefmt-nix",
-        "rev": "49dc4a92b02b8e68798abd99184f228243b6e3ac",
+        "rev": "c6aaf729f34a36c445618580a9f95a48f5e4e03f",
         "type": "github"
       },
       "original": {