Merge staging-next into staging

maintainers/scripts/haskell/dependencies.nix

···
+# Nix script to calculate the Haskell dependencies of every haskellPackage. Used by ./hydra-report.hs.
+let
+  pkgs = import ../../.. {};
+  inherit (pkgs) lib;
+  getDeps = _: pkg: {
+    deps = builtins.filter (x: !isNull x) (map (x: x.pname or null) (pkg.propagatedBuildInputs or []));
+    broken = (pkg.meta.hydraPlatforms or [null]) == [];
+  };
+in
+  lib.mapAttrs getDeps pkgs.haskellPackages

maintainers/scripts/haskell/hydra-report.hs

···
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TupleSections #-}
 {-# OPTIONS_GHC -Wall #-}
+{-# LANGUAGE ViewPatterns #-}
+{-# LANGUAGE TupleSections #-}
 
 import Control.Monad (forM_, (<=<))
 import Control.Monad.Trans (MonadIO (liftIO))
···
 import qualified Data.List.NonEmpty as NonEmpty
 import Data.Map.Strict (Map)
 import qualified Data.Map.Strict as Map
-import Data.Maybe (fromMaybe, mapMaybe)
+import Data.Maybe (fromMaybe, mapMaybe, isNothing)
 import Data.Monoid (Sum (Sum, getSum))
 import Data.Sequence (Seq)
 import qualified Data.Sequence as Seq
···
 import System.Environment (getArgs)
 import System.Process (readProcess)
 import Prelude hiding (id)
+import Data.List (sortOn)
+import Control.Concurrent.Async (concurrently)
+import Control.Exception (evaluate)
+import qualified Data.IntMap.Strict as IntMap
+import qualified Data.IntSet as IntSet
+import Data.Bifunctor (second)
 
 newtype JobsetEvals = JobsetEvals
    { evals :: Seq Eval
···
 hydraEvalParams :: [String]
 hydraEvalParams = ["-I", ".", "pkgs/top-level/release-haskell.nix"]
 
-handlesCommand :: FilePath
-handlesCommand = "nix-instantiate"
+nixExprCommand :: FilePath
+nixExprCommand = "nix-instantiate"
 
-handlesParams :: [String]
-handlesParams = ["--eval", "--strict", "--json", "-"]
-
-handlesExpression :: String
-handlesExpression = "with import ./. {}; with lib; zipAttrsWith (_: builtins.head) (mapAttrsToList (_: v: if v ? github then { \"${v.email}\" = v.github; } else {}) (import maintainers/maintainer-list.nix))"
+nixExprParams :: [String]
+nixExprParams = ["--eval", "--strict", "--json"]
 
 -- | This newtype is used to parse a Hydra job output from @hydra-eval-jobs@.
 -- The only field we are interested in is @maintainers@, which is why this
 -- is just a newtype.
 --
--- Note that there are occassionally jobs that don't have a maintainers
+-- Note that there are occasionally jobs that don't have a maintainers
 -- field, which is why this has to be @Maybe Text@.
 newtype Maintainers = Maintainers { maintainers :: Maybe Text }
   deriving stock (Generic, Show)
···
 -- @@
 type MaintainerMap = Map Text (NonEmpty Text)
 
--- | Generate a mapping of Hydra job names to maintainer GitHub handles.
+-- | Information about a package which lists its dependencies and whether the
+-- package is marked broken.
+data DepInfo = DepInfo {
+   deps :: Set Text,
+   broken :: Bool
+}
+   deriving stock (Generic, Show)
+   deriving anyclass (FromJSON, ToJSON)
+
+-- | Map from package names to their DepInfo. This is the data we get out of a
+-- nix call.
+type DependencyMap = Map Text DepInfo
+
+-- | Map from package names to its broken state, number of reverse dependencies (fst) and
+-- unbroken reverse dependencies (snd).
+type ReverseDependencyMap = Map Text (Int, Int)
+
+-- | Calculate the (unbroken) reverse dependencies of a package by transitively
+-- going through all packages if it’s a dependency of them.
+calculateReverseDependencies :: DependencyMap -> ReverseDependencyMap
+calculateReverseDependencies depMap = Map.fromDistinctAscList $ zip keys (zip (rdepMap False) (rdepMap True))
+ where
+    -- This code tries to efficiently invert the dependency map and calculate
+    -- it’s transitive closure by internally identifying every pkg with it’s index
+    -- in the package list and then using memoization.
+    keys = Map.keys depMap
+    pkgToIndexMap = Map.fromDistinctAscList (zip keys [0..])
+    intDeps = zip [0..] $ (\DepInfo{broken,deps} -> (broken,mapMaybe (`Map.lookup` pkgToIndexMap) $ Set.toList deps)) <$> Map.elems depMap
+    rdepMap onlyUnbroken = IntSet.size <$> resultList
+     where
+       resultList = go <$> [0..]
+       oneStepMap = IntMap.fromListWith IntSet.union $ (\(key,(_,deps)) -> (,IntSet.singleton key) <$> deps) <=< filter (\(_, (broken,_)) -> not (broken && onlyUnbroken)) $ intDeps
+       go pkg = IntSet.unions (oneStep:((resultList !!) <$> IntSet.toList oneStep))
+        where oneStep = IntMap.findWithDefault mempty pkg oneStepMap
+
+-- | Generate a mapping of Hydra job names to maintainer GitHub handles. Calls
+-- hydra-eval-jobs and the nix script ./maintainer-handles.nix.
 getMaintainerMap :: IO MaintainerMap
 getMaintainerMap = do
    hydraJobs :: HydraJobs <-
-      readJSONProcess hydraEvalCommand hydraEvalParams "" "Failed to decode hydra-eval-jobs output: "
+      readJSONProcess hydraEvalCommand hydraEvalParams "Failed to decode hydra-eval-jobs output: "
    handlesMap :: EmailToGitHubHandles <-
-      readJSONProcess handlesCommand handlesParams handlesExpression "Failed to decode nix output for lookup of github handles: "
+      readJSONProcess nixExprCommand ("maintainers/scripts/haskell/maintainer-handles.nix":nixExprParams) "Failed to decode nix output for lookup of github handles: "
    pure $ Map.mapMaybe (splitMaintainersToGitHubHandles handlesMap) hydraJobs
    where
    -- Split a comma-spearated string of Maintainers into a NonEmpty list of
···
    splitMaintainersToGitHubHandles handlesMap (Maintainers maint) =
       nonEmpty .  mapMaybe (`Map.lookup` handlesMap) .  Text.splitOn ", " $ fromMaybe "" maint
 
+-- | Get the a map of all dependencies of every package by calling the nix
+-- script ./dependencies.nix.
+getDependencyMap :: IO DependencyMap
+getDependencyMap =
+   readJSONProcess nixExprCommand ("maintainers/scripts/haskell/dependencies.nix":nixExprParams) "Failed to decode nix output for lookup of dependencies: "
+
 -- | Run a process that produces JSON on stdout and and decode the JSON to a
 -- data type.
 --
···
    :: FromJSON a
    => FilePath -- ^ Filename of executable.
    -> [String] -- ^ Arguments
-   -> String -- ^ stdin to pass to the process
    -> String -- ^ String to prefix to JSON-decode error.
    -> IO a
-readJSONProcess exe args input err = do
-   output <- readProcess exe args input
+readJSONProcess exe args err = do
+   output <- readProcess exe args ""
    let eitherDecodedOutput = eitherDecodeStrict' . encodeUtf8 . Text.pack $ output
    case eitherDecodedOutput of
      Left decodeErr -> error $ err <> decodeErr <> "\nRaw: '" <> take 1000 output <> "'"
···
 data BuildResult = BuildResult {state :: BuildState, id :: Int} deriving (Show, Eq, Ord)
 newtype Platform = Platform {platform :: Text} deriving (Show, Eq, Ord)
 newtype Table row col a = Table (Map (row, col) a)
-type StatusSummary = Map Text (Table Text Platform BuildResult, Set Text)
+data SummaryEntry = SummaryEntry {
+   summaryBuilds :: Table Text Platform BuildResult,
+   summaryMaintainers :: Set Text,
+   summaryReverseDeps :: Int,
+   summaryUnbrokenReverseDeps :: Int
+}
+type StatusSummary = Map Text SummaryEntry
 
 instance (Ord row, Ord col, Semigroup a) => Semigroup (Table row col a) where
    Table l <> Table r = Table (Map.unionWith (<>) l r)
···
 instance Foldable (Table row col) where
    foldMap f (Table a) = foldMap f a
 
-buildSummary :: MaintainerMap -> Seq Build -> StatusSummary
-buildSummary maintainerMap = foldl (Map.unionWith unionSummary) Map.empty . fmap toSummary
+buildSummary :: MaintainerMap -> ReverseDependencyMap -> Seq Build -> StatusSummary
+buildSummary maintainerMap reverseDependencyMap = foldl (Map.unionWith unionSummary) Map.empty . fmap toSummary
   where
-   unionSummary (Table l, l') (Table r, r') = (Table $ Map.union l r, l' <> r')
-   toSummary Build{finished, buildstatus, job, id, system} = Map.singleton name (Table (Map.singleton (set, Platform system) (BuildResult state id)), maintainers)
+   unionSummary (SummaryEntry (Table lb) lm lr lu) (SummaryEntry (Table rb) rm rr ru) = SummaryEntry (Table $ Map.union lb rb) (lm <> rm) (max lr rr) (max lu ru)
+   toSummary Build{finished, buildstatus, job, id, system} = Map.singleton name (SummaryEntry (Table (Map.singleton (set, Platform system) (BuildResult state id))) maintainers reverseDeps unbrokenReverseDeps)
      where
       state :: BuildState
       state = case (finished, buildstatus) of
···
       name = maybe packageName NonEmpty.last splitted
       set = maybe "" (Text.intercalate "." . NonEmpty.init) splitted
       maintainers = maybe mempty (Set.fromList . toList) (Map.lookup job maintainerMap)
+      (reverseDeps, unbrokenReverseDeps) = Map.findWithDefault (0,0) name reverseDependencyMap
 
 readBuildReports :: IO (Eval, UTCTime, Seq Build)
 readBuildReports = do
···
 statusToNumSummary :: StatusSummary -> NumSummary
 statusToNumSummary = fmap getSum . foldMap (fmap Sum . jobTotals)
 
-jobTotals :: (Table Text Platform BuildResult, a) -> Table Platform BuildState Int
-jobTotals (Table mapping, _) = getSum <$> Table (Map.foldMapWithKey (\(_, platform) (BuildResult buildstate _) -> Map.singleton (platform, buildstate) (Sum 1)) mapping)
+jobTotals :: SummaryEntry -> Table Platform BuildState Int
+jobTotals (summaryBuilds -> Table mapping) = getSum <$> Table (Map.foldMapWithKey (\(_, platform) (BuildResult buildstate _) -> Map.singleton (platform, buildstate) (Sum 1)) mapping)
 
 details :: Text -> [Text] -> [Text]
 details summary content = ["<details><summary>" <> summary <> " </summary>", ""] <> content <> ["</details>", ""]
 
-printBuildSummary :: Eval -> UTCTime -> StatusSummary -> Text
+printBuildSummary :: Eval -> UTCTime -> StatusSummary -> [(Text, Int)] -> Text
 printBuildSummary
    Eval{id, jobsetevalinputs = JobsetEvalInputs{nixpkgs = Nixpkgs{revision}}}
    fetchTime
-   summary =
+   summary
+   topBrokenRdeps =
       Text.unlines $
-         headline <> totals
+         headline <> [""] <> tldr <> (("  * "<>) <$> (errors <> warnings)) <> [""]
+            <> totals
             <> optionalList "#### Maintained packages with build failure" (maintainedList fails)
             <> optionalList "#### Maintained packages with failed dependency" (maintainedList failedDeps)
             <> optionalList "#### Maintained packages with unknown error" (maintainedList unknownErr)
             <> optionalHideableList "#### Unmaintained packages with build failure" (unmaintainedList fails)
             <> optionalHideableList "#### Unmaintained packages with failed dependency" (unmaintainedList failedDeps)
             <> optionalHideableList "#### Unmaintained packages with unknown error" (unmaintainedList unknownErr)
+            <> optionalHideableList "#### Top 50 broken packages, sorted by number of reverse dependencies" (brokenLine <$> topBrokenRdeps)
+            <> ["","*:arrow_heading_up:: The number of packages that depend (directly or indirectly) on this package (if any). If two numbers are shown the first (lower) number considers only packages which currently have enabled hydra jobs, i.e. are not marked broken. The second (higher) number considers all packages.*",""]
             <> footer
      where
       footer = ["*Report generated with [maintainers/scripts/haskell/hydra-report.hs](https://github.com/NixOS/nixpkgs/blob/haskell-updates/maintainers/scripts/haskell/hydra-report.sh)*"]
···
          [ "#### Build summary"
          , ""
          ]
-            <> printTable "Platform" (\x -> makeSearchLink id (platform x <> " " <> platformIcon x) ("." <> platform x)) (\x -> showT x <> " " <> icon x) showT (statusToNumSummary summary)
+            <> printTable "Platform" (\x -> makeSearchLink id (platform x <> " " <> platformIcon x) ("." <> platform x)) (\x -> showT x <> " " <> icon x) showT numSummary
       headline =
          [ "### [haskell-updates build report from hydra](https://hydra.nixos.org/jobset/nixpkgs/haskell-updates)"
          , "*evaluation ["
···
             <> Text.pack (formatTime defaultTimeLocale "%Y-%m-%d %H:%M UTC" fetchTime)
             <> "*"
          ]
-      jobsByState predicate = Map.filter (predicate . foldl' min Success . fmap state . fst) summary
+      brokenLine (name, rdeps) = "[" <> name <> "](https://search.nixos.org/packages?channel=unstable&show=haskellPackages." <> name <> "&query=haskellPackages." <> name <> ") :arrow_heading_up: " <> Text.pack (show rdeps)
+      numSummary = statusToNumSummary summary
+      jobsByState predicate = Map.filter (predicate . worstState) summary
+      worstState = foldl' min Success . fmap state . summaryBuilds
       fails = jobsByState (== Failed)
       failedDeps = jobsByState (== DependencyFailed)
       unknownErr = jobsByState (\x -> x > DependencyFailed && x < TimedOut)
-      withMaintainer = Map.mapMaybe (\(x, m) -> (x,) <$> nonEmpty (Set.toList m))
-      withoutMaintainer = Map.mapMaybe (\(x, m) -> if Set.null m then Just x else Nothing)
+      withMaintainer = Map.mapMaybe (\e -> (summaryBuilds e,) <$> nonEmpty (Set.toList (summaryMaintainers e)))
+      withoutMaintainer = Map.mapMaybe (\e -> if Set.null (summaryMaintainers e) then Just e else Nothing)
       optionalList heading list = if null list then mempty else [heading] <> list
       optionalHideableList heading list = if null list then mempty else [heading] <> details (showT (length list) <> " job(s)") list
       maintainedList = showMaintainedBuild <=< Map.toList . withMaintainer
-      unmaintainedList = showBuild <=< Map.toList . withoutMaintainer
-      showBuild (name, table) = printJob id name (table, "")
+      unmaintainedList = showBuild <=< sortOn (\(snd -> x) -> (negate (summaryUnbrokenReverseDeps x), negate (summaryReverseDeps x))) . Map.toList . withoutMaintainer
+      showBuild (name, entry) = printJob id name (summaryBuilds entry, Text.pack (if summaryReverseDeps entry > 0 then " :arrow_heading_up: " <> show (summaryUnbrokenReverseDeps entry) <>" | "<> show (summaryReverseDeps entry) else ""))
       showMaintainedBuild (name, (table, maintainers)) = printJob id name (table, Text.intercalate " " (fmap ("@" <>) (toList maintainers)))
+      tldr = case (errors, warnings) of
+               ([],[]) -> [":green_circle: **Ready to merge**"]
+               ([],_) -> [":yellow_circle: **Potential issues**"]
+               _ -> [":red_circle: **Branch not mergeable**"]
+      warnings =
+         if' (Unfinished > maybe Success worstState maintainedJob) "`maintained` jobset failed." <>
+         if' (Unfinished == maybe Success worstState mergeableJob) "`mergeable` jobset is not finished." <>
+         if' (Unfinished == maybe Success worstState maintainedJob) "`maintained` jobset is not finished."
+      errors =
+         if' (isNothing mergeableJob) "No `mergeable` job found." <>
+         if' (isNothing maintainedJob) "No `maintained` job found." <>
+         if' (Unfinished > maybe Success worstState mergeableJob) "`mergeable` jobset failed." <>
+         if' (outstandingJobs (Platform "x86_64-linux") > 100) "Too much outstanding jobs on x86_64-linux." <>
+         if' (outstandingJobs (Platform "aarch64-linux") > 100) "Too much outstanding jobs on aarch64-linux."
+      if' p e = if p then [e] else mempty
+      outstandingJobs platform | Table m <- numSummary = Map.findWithDefault 0 (platform, Unfinished) m
+      maintainedJob = Map.lookup "maintained" summary
+      mergeableJob = Map.lookup "mergeable" summary
 
 printMaintainerPing :: IO ()
 printMaintainerPing = do
-   maintainerMap <- getMaintainerMap
+   (maintainerMap, (reverseDependencyMap, topBrokenRdeps)) <- concurrently getMaintainerMap do
+      depMap <- getDependencyMap
+      rdepMap <- evaluate . calculateReverseDependencies $ depMap
+      let tops = take 50 . sortOn (negate . snd) . fmap (second fst) . filter (\x -> maybe False broken $ Map.lookup (fst x) depMap) . Map.toList $ rdepMap
+      pure (rdepMap, tops)
    (eval, fetchTime, buildReport) <- readBuildReports
-   putStrLn (Text.unpack (printBuildSummary eval fetchTime (buildSummary maintainerMap buildReport)))
+   putStrLn (Text.unpack (printBuildSummary eval fetchTime (buildSummary maintainerMap reverseDependencyMap buildReport) topBrokenRdeps))
 
 printMarkBrokenList :: IO ()
 printMarkBrokenList = do

maintainers/scripts/haskell/maintainer-handles.nix

···
+# Nix script to lookup maintainer github handles from their email address. Used by ./hydra-report.hs.
+let
+  pkgs = import ../../.. {};
+  maintainers = import ../../maintainer-list.nix;
+  inherit (pkgs) lib;
+  mkMailGithubPair = _: maintainer: if maintainer ? github then { "${maintainer.email}" = maintainer.github; } else {};
+in lib.zipAttrsWith (_: builtins.head) (lib.mapAttrsToList mkMailGithubPair maintainers)

maintainers/scripts/haskell/merge-and-open-pr.sh

···
+#! /usr/bin/env nix-shell
+#! nix-shell -i bash -p git gh -I nixpkgs=.
+#
+# Script to merge the currently open haskell-updates PR into master, bump the
+# Stackage version and Hackage versions, and open the next haskell-updates PR.
+
+set -eu -o pipefail
+
+# exit after printing first argument to this function
+function die {
+  # echo the first argument
+  echo "ERROR: $1"
+  echo "Aborting!"
+
+  exit 1
+}
+
+function help {
+  echo "Usage: $0 HASKELL_UPDATES_PR_NUM"
+  echo "Merge the currently open haskell-updates PR into master, and open the next one."
+  echo
+  echo "  -h, --help                print this help"
+  echo "  HASKELL_UPDATES_PR_NUM    number of the currently open PR on NixOS/nixpkgs"
+  echo "                            for the haskell-updates branch"
+  echo
+  echo "Example:"
+  echo "  \$ $0 137340"
+
+  exit 1
+}
+
+# Read in the current haskell-updates PR number from the command line.
+while [[ $# -gt 0 ]]; do
+  key="$1"
+
+  case $key in
+    -h|--help)
+      help
+      ;;
+    *)
+      curr_haskell_updates_pr_num="$1"
+      shift
+      ;;
+  esac
+done
+
+if [[ -z "${curr_haskell_updates_pr_num-}" ]] ; then
+  die "You must pass the current haskell-updates PR number as the first argument to this script."
+fi
+
+# Make sure you have gh authentication setup.
+if ! gh auth status 2>/dev/null ; then
+  die "You must setup the \`gh\` command.  Run \`gh auth login\`."
+fi
+
+# Fetch nixpkgs to get an up-to-date origin/haskell-updates branch.
+echo "Fetching origin..."
+git fetch origin >/dev/null
+
+# Make sure we are currently on a local haskell-updates branch.
+curr_branch="$(git rev-parse --abbrev-ref HEAD)"
+if [[ "$curr_branch" != "haskell-updates" ]]; then
+    die "Current branch is not called \"haskell-updates\"."
+fi
+
+# Make sure our local haskell-updates branch is on the same commit as
+# origin/haskell-updates.
+curr_branch_commit="$(git rev-parse haskell-updates)"
+origin_haskell_updates_commit="$(git rev-parse origin/haskell-updates)"
+if [[ "$curr_branch_commit" != "$origin_haskell_updates_commit" ]]; then
+    die "Current branch is not at the same commit as origin/haskell-updates"
+fi
+
+# Merge the current open haskell-updates PR.
+echo "Merging https://github.com/NixOS/nixpkgs/pull/${curr_haskell_updates_pr_num}..."
+gh pr merge --repo NixOS/nixpkgs --merge "$curr_haskell_updates_pr_num"
+
+# Update stackage, Hackage hashes, and regenerate Haskell package set
+echo "Updating Stackage..."
+./maintainers/scripts/haskell/update-stackage.sh --do-commit
+echo "Updating Hackage hashes..."
+./maintainers/scripts/haskell/update-hackage.sh --do-commit
+echo "Regenerating Hackage packages..."
+./maintainers/scripts/haskell/regenerate-hackage-packages.sh --do-commit
+
+# Push these new commits to the haskell-updates branch
+echo "Pushing commits just created to the haskell-updates branch"
+git push
+
+# Open new PR
+new_pr_body=$(cat <<EOF
+### This Merge
+
+This PR is the regular merge of the \`haskell-updates\` branch into \`master\`.
+
+This branch is being continually built and tested by hydra at https://hydra.nixos.org/jobset/nixpkgs/haskell-updates.
+
+We roughly aim to merge these \`haskell-updates\` PRs at least once every two weeks. See the @NixOS/haskell [team calendar](https://cloud.maralorn.de/apps/calendar/p/Mw5WLnzsP7fC4Zky) for who is currently in charge of this branch.
+
+### haskellPackages Workflow Summary
+
+Our workflow is currently described in [\`pkgs/development/haskell-modules/HACKING.md\`](https://github.com/NixOS/nixpkgs/blob/haskell-updates/pkgs/development/haskell-modules/HACKING.md).
+
+The short version is this:
+* We regularly update the Stackage and Hackage pins on \`haskell-updates\` (normally at the beginning of a merge window).
+* The community fixes builds of Haskell packages on that branch.
+* We aim at at least one merge of \`haskell-updates\` into \`master\` every two weeks.
+* We only do the merge if the [\`mergeable\`](https://hydra.nixos.org/job/nixpkgs/haskell-updates/mergeable) job is succeeding on hydra.
+* If a [\`maintained\`](https://hydra.nixos.org/job/nixpkgs/haskell-updates/maintained) package is still broken at the time of merge, we will only merge if the maintainer has been pinged 7 days in advance. (If you care about a Haskell package, become a maintainer!)
+
+---
+
+This is the follow-up to #${curr_haskell_updates_pr_num}. Come to [#haskell:nixos.org](https://matrix.to/#/#haskell:nixos.org) if you have any questions.
+EOF
+)
+
+echo "Opening a PR for the next haskell-updates merge cycle"
+gh pr create --repo NixOS/nixpkgs --base master --head haskell-updates --title "haskellPackages: update stackage and hackage" --body "$new_pr_body"

nixos/modules/services/search/elasticsearch.nix

···
 let
   cfg = config.services.elasticsearch;
 
+  es7 = builtins.compareVersions cfg.package.version "7" >= 0;
+
   esConfig = ''
     network.host: ${cfg.listenAddress}
     cluster.name: ${cfg.cluster_name}
-    ${lib.optionalString cfg.single_node ''
-      discovery.type: single-node
-      gateway.auto_import_dangling_indices: true
-    ''}
+    ${lib.optionalString cfg.single_node "discovery.type: single-node"}
+    ${lib.optionalString (cfg.single_node && es7) "gateway.auto_import_dangling_indices: true"}
 
     http.port: ${toString cfg.port}
     transport.port: ${toString cfg.tcp_port}

pkgs/applications/audio/libopenmpt/default.nix

···
 { config, lib, stdenv, fetchurl, zlib, pkg-config, mpg123, libogg, libvorbis, portaudio, libsndfile, flac
-, usePulseAudio ? config.pulseaudio or false, libpulseaudio }:
+, usePulseAudio ? config.pulseaudio or stdenv.isLinux, libpulseaudio }:
 
 stdenv.mkDerivation rec {
   pname = "libopenmpt";

pkgs/applications/blockchains/erigon.nix

···
 
 buildGoModule rec {
   pname = "erigon";
-  version = "2021.08.05";
+  version = "2021.09.02";
 
   src = fetchFromGitHub {
     owner = "ledgerwatch";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-bCREY3UbMgSTu1nVytrYFsGgdMEaMLy5ZGrLqDNu9YM=";
+    sha256 = "sha256-0rWyDlZjfsZMOqAXs+mgmgz0m4oIN6bZ6Z9U4jWgR0E=";
   };
 
-  vendorSha256 = "0a0d6n2c0anp36z7kvkadd6zvxzvsywfpk5qv6aq4ji4qd0hlq8q";
+  vendorSha256 = "sha256-ardr+6Tz9IzSJPo9/kk7XV+2pIu6ZK3YYlp1zC/7Bno=";
   runVend = true;
 
   # Build errors in mdbx when format hardening is enabled:

pkgs/applications/editors/vim/configurable.nix

···
     "--disable-nextaf_check"
     "--disable-carbon_check"
     "--disable-gtktest"
+  ] ++ lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [
+    "vim_cv_toupper_broken=no"
+    "--with-tlib=ncurses"
+    "vim_cv_terminfo=yes"
+    "vim_cv_tgetent=zero" # it does on native anyway
+    "vim_cv_tty_group=tty"
+    "vim_cv_tty_mode=0660"
+    "vim_cv_getcwd_broken=no"
+    "vim_cv_stat_ignores_slash=yes"
+    "vim_cv_memmove_handles_overlap=yes"
   ]
     ++ lib.optional (guiSupport == "gtk2" || guiSupport == "gtk3") "--enable-gui=${guiSupport}"
   ++ lib.optional stdenv.isDarwin

pkgs/applications/editors/vim/default.nix

···
     "vim_cv_tty_mode=0660"
     "vim_cv_getcwd_broken=no"
     "vim_cv_stat_ignores_slash=yes"
-    "ac_cv_sizeof_int=4"
-    "vim_cv_memmove_handles_overlap=yes"
     "vim_cv_memmove_handles_overlap=yes"
   ];
 

pkgs/applications/networking/cawbird/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  version = "1.4.1";
+  version = "1.4.2";
   pname = "cawbird";
 
   src = fetchFromGitHub {
     owner = "IBBoard";
     repo = "cawbird";
     rev = "v${version}";
-    sha256 = "0lmrgcj1ky1vhzynl36k6ba3ws089x4qdrnkjk3lbr334kicx9na";
+    sha256 = "17575cp5qcgsqf37y3xqg3vr6l2j8bbbkmy2c1l185rxghfacida";
   };
 
   nativeBuildInputs = [

pkgs/applications/networking/cluster/nerdctl/default.nix

···
 
 buildGoModule rec {
   pname = "nerdctl";
-  version = "0.11.1";
+  version = "0.11.2";
 
   src = fetchFromGitHub {
     owner = "containerd";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-r9VJQUmwe4UGCLmzxG2t9XHQ7KUeJxmEuAwxssPArcM=";
+    sha256 = "sha256-QkUE4oImP0eg5tofGEUonKzffICG4b3SuPJz9S2ZNfE=";
   };
 
-  vendorSha256 = "sha256-KnXxp/6L09a34cnv4h7vpPhNO6EGmeEC6c1ydyYXkxU=";
+  vendorSha256 = "sha256-mPOyF1S/g1FpUHHNc+cy0nxk6rK9txnZPYHOSvvfu70=";
 
   nativeBuildInputs = [ makeWrapper installShellFiles ];
 

pkgs/applications/networking/cluster/terragrunt/default.nix

···
 
 buildGoModule rec {
   pname = "terragrunt";
-  version = "0.31.11";
+  version = "0.32.2";
 
   src = fetchFromGitHub {
     owner = "gruntwork-io";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-TBglZb0DZoHYtAL+0I+9v/a7zQ915MoNGS0GXvhgVss=";
+    sha256 = "sha256-1s6/Xn/NsClG7YvRyzpvzMy8HmDITNCQUJxHaA84470=";
   };
 
   vendorSha256 = "sha256-y84EFmoJS4SeA5YFIVFU0iWa5NnjU5yvOj7OFE+jGN0=";

pkgs/applications/window-managers/mlvwm/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "mlvwm";
-  version = "0.9.3";
+  version = "0.9.4";
 
   src = fetchFromGitHub {
     owner = "morgant";
     repo = pname;
     rev = version;
-    sha256 = "sha256-Sps2+XyMTcNuhQTLrW/8vSZIcSzMejoi1m64SK129YI=";
+    sha256 = "sha256-ElKmi+ANuB3LPwZTMcr5HEMESjDwENbYnNIGdRP24d0=";
   };
 
   nativeBuildInputs = [ installShellFiles ];

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "aceceb24b5b4dc95017c3509add3f935d7289cd8",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/aceceb24b5b4dc95017c3509add3f935d7289cd8.tar.gz",
-  "sha256": "0bc4csxmm64qq3sxj22g4i0s2q5vpgkf2fgpby6zslhpa01pdlqq",
-  "msg": "Update from Hackage at 2021-09-10T22:56:58Z"
+  "commit": "6b93e40198f31ac2a9d52e4f3ce90f22f1e9e6f9",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/6b93e40198f31ac2a9d52e4f3ce90f22f1e9e6f9.tar.gz",
+  "sha256": "1zs9d0h55q6lj3v0d0n19yxl58lhn07lmnw2j5k2y8zbx3pcqi8l",
+  "msg": "Update from Hackage at 2021-09-17T18:08:40Z"
 }

pkgs/development/compilers/ghcjs/8.10/default.nix

···
 
     inherit passthru;
 
-    # The emscripten is broken on darwin
-    meta.platforms = lib.platforms.linux;
-    meta.maintainers = with lib.maintainers; [ obsidian-systems-maintenance ];
+    meta = {
+      # The emscripten is broken on darwin
+      platforms = lib.platforms.linux;
+
+      # Hydra limits jobs to only outputting 1 gigabyte worth of files.
+      # GHCJS outputs over 3 gigabytes.
+      # https://github.com/NixOS/nixpkgs/pull/137066#issuecomment-922335563
+      hydraPlatforms = lib.platforms.none;
+
+      maintainers = with lib.maintainers; [ obsidian-systems-maintenance ];
+    };
   }

pkgs/development/compilers/sjasmplus/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "sjasmplus";
-  version = "1.18.2";
+  version = "1.18.3";
 
   src = fetchFromGitHub {
     owner = "z00m128";
     repo = "sjasmplus";
     rev = "v${version}";
-    sha256 = "04348zcmc0b3crzwhvj1shx6f1n3x05vs8d5qdm7qhgdfki8r74v";
+    sha256 = "sha256-+FvNYfJ5I91RfuJTiOPhj5KW8HoOq8OgnnpFEgefSGc=";
   };
 
   buildFlags = [

pkgs/development/haskell-modules/HACKING.md

···
 
 Each of these steps is described in a separate section.
 
+There is a script that automates the workflow for merging the currently open
+`haskell-updates` PR into `master` and opening the next PR.  It is described
+at the end of this document.
+
 ## Initial `haskell-updates` PR
 
 In this section we create the PR for merging `haskell-updates` into `master`.
···
 
 1.  Push these commits to the `haskell-updates` branch of the NixOS/nixpkgs repository.
 
-1.  Open a PR on Nixpkgs merging `haskell-updates` into `master`.
-
-
-
-Use the title `haskellPackages: update stackage and hackage` and the following message body:
-
-```markdown
-### This Merge
-
-This PR is the regular merge of the `haskell-updates` branch into `master`.
-
-This branch is being continually built and tested by hydra at https://hydra.nixos.org/jobset/nixpkgs/haskell-updates.
-
-I will aim to merge this PR **by 2021-TODO-TODO**. If I can merge it earlier, there might be successor PRs in that time window. As part of our rotation @TODO will continue these merges from 2021-TODO-TODO to 2021-TODO-TODO.
-
-### haskellPackages Workflow Summary
-
-Our workflow is currently described in
-[`pkgs/development/haskell-modules/HACKING.md`](https://github.com/NixOS/nixpkgs/blob/haskell-updates/pkgs/development/haskell-modules/HACKING.md).
-
-The short version is this:
-* We regularly update the Stackage and Hackage pins on `haskell-updates` (normally at the beginning of a merge window).
-* The community fixes builds of Haskell packages on that branch.
-* We aim at at least one merge of `haskell-updates` into `master` every two weeks.
-* We only do the merge if the [`mergeable`](https://hydra.nixos.org/job/nixpkgs/haskell-updates/mergeable) job is succeeding on hydra.
-* If a [`maintained`](https://hydra.nixos.org/job/nixpkgs/haskell-updates/maintained) package is still broken at the time of merge, we will only merge if the maintainer has been pinged 7 days in advance. (If you care about a Haskell package, become a maintainer!)
-
----
-
-This is the follow-up to #TODO. Come to [#haskell:nixos.org](https://matrix.to/#/#haskell:nixos.org) if you have any questions.
-```
-
-Make sure to replace all TODO with the actual values.
+1.  Open a PR on Nixpkgs for merging `haskell-updates` into `master`.  The recommended
+    PR title and body text are described in the `merge-and-open-pr.sh` section.
 
 ## Notify Maintainers and Fix Broken Packages
 
···
 most recent build report.
 
 Maintainers should be given at least 7 days to fix up their packages when they
-break.  If maintainers don't fix up their packages with 7 days, then they
+break.  If maintainers don't fix up their packages within 7 days, then they
 may be marked broken before merging `haskell-updates` into `master`.
 
 ### Fix Broken Packages
···
 
 -   All updated files will be committed.
 
-### Merge `master` into `haskell-updates`
-
-You should occasionally merge the `master` branch into the `haskell-updates`
-branch.
-
-In an ideal world, when we merge `haskell-updates` into `master`, it would
-cause few Hydra rebuilds on `master`.  Ideally, the `nixos-unstable` channel
-would never be prevented from progressing because of needing to wait for
-rebuilding Haskell packages.
-
-In order to make sure that there are a minimal number of rebuilds after merging
-`haskell-updates` into `master`, `master` should occasionally be merged into
-the `haskell-updates` branch.
-
-This is especially important after `staging-next` is merged into `master`,
-since there is a high chance that this will cause all the Haskell packages to
-rebuild.
-
 ## Merge `haskell-updates` into `master`
 
 Now it is time to merge the `haskell-updates` PR you opened above.
···
 After merging, **make sure not to delete the `haskell-updates` branch**, since it
 causes all currently open Haskell-related pull-requests to be automatically closed on GitHub.
 
+## Script for Merging `haskell-updates` and Opening a New PR
+
+There is a script that automates merging the current `haskell-updates` PR and
+opening the next one.  When you want to merge the currently open
+`haskell-updates` PR, you can run the script with the following steps:
+
+1.  Make sure you have previously authenticated with the `gh` command.  The
+    script uses the `gh` command to merge the current PR and open a new one.
+    You should only need to do this once.
+
+    ```console
+    $ gh auth login
+    ```
+
+1.  Make sure you have correctly marked packages broken.  One of the previous
+    sections explains how to do this.
+
+1.  Merge `master` into `haskell-updates` and make sure to push to the
+    `haskell-updates` branch.  (This can be skipped if `master` has recently
+    been merged into `haskell-updates`.)
+
+1.  Go to https://hydra.nixos.org/jobset/nixpkgs/haskell-updates and force an
+    evaluation of the `haskell-updates` jobset.  See one of the following
+    sections for how to do this.  Make sure there are no evaluation errors.  If
+    there are remaining evaluation errors, fix them before continuing with this
+    merge.
+
+1.  Run the script to merge `haskell-updates`:
+
+    ```console
+    $ ./maintainers/scripts/haskell/merge-and-open-pr.sh PR_NUM_OF_CURRENT_HASKELL_UPDATES_PR
+    ```
+
+    This does the following things:
+
+    1.  Fetches `origin`, makes sure you currently have the `haskell-updates`
+        branch checked out, and makes sure your currently checked-out
+        `haskell-updates` branch is on the same commit as
+        `origin/haskell-updates`.
+
+    1.  Merges the currently open `haskell-updates` PR.
+
+    1.  Updates Stackage and Hackage snapshots.  Regenerates the Haskell package set.
+
+    1.  Pushes the commits updating Stackage and Hackage and opens a new
+        `haskell-updates` PR on Nixpkgs.  If you'd like to do this by hand,
+        look in the script for the recommended PR title and body text.
+
 ## Update Hackage Version Information
 
-After merging into `master` you can update what hackage displays as the current
-version in NixOS for every individual package.
-To do this you run `maintainers/scripts/haskell/upload-nixos-package-list-to-hackage.sh`.
-See the script for how to provide credentials. Once you have configured that
+After merging into `master` you can update what Hackage displays as the current
+version in NixOS for every individual package.  To do this you run
+`maintainers/scripts/haskell/upload-nixos-package-list-to-hackage.sh`.  See the
+script for how to provide credentials. Once you have configured credentials,
 running this takes only a few seconds.
 
 ## Additional Info

pkgs/development/haskell-modules/configuration-arm.nix

···
   xml-html-qq = dontCheck super.xml-html-qq;
   yaml-combinators = dontCheck super.yaml-combinators;
   yesod-paginator = dontCheck super.yesod-paginator;
+  hls-pragmas-plugin = dontCheck super.hls-pragmas-plugin;
+  hls-call-hierarchy-plugin = dontCheck super.hls-call-hierarchy-plugin;
+  hls-module-name-plugin = dontCheck super.hls-module-name-plugin;
 
   # https://github.com/ekmett/half/issues/35
   half = dontCheck super.half;

pkgs/development/haskell-modules/configuration-common.nix

···
   # 2021-09-14: Tests are flaky.
   hls-splice-plugin = dontCheck super.hls-splice-plugin;
 
+  # 2021-09-18: https://github.com/haskell/haskell-language-server/issues/2205
+  hls-stylish-haskell-plugin = doJailbreak super.hls-stylish-haskell-plugin;
+
 } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

pkgs/development/haskell-modules/configuration-ghc-9.0.x.nix

···
   # https://github.com/Soostone/retry/issues/71
   retry = dontCheck super.retry;
 
-  # hlint 3.3 needs a ghc-lib-parser newer than the one from stackage
-  hlint = super.hlint_3_3_4.overrideScope (self: super: {
-    ghc-lib-parser = overrideCabal self.ghc-lib-parser_9_0_1_20210324 {
-      doHaddock = false;
-    };
-    ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_0_0_4;
-  });
+  # Hlint needs >= 3.3.4 for ghc 9 support.
+  hlint = super.hlint_3_3_4;
 
-  # pick right version for compiler
+  # 2021-09-18: ghc-api-compat and ghc-lib-* need >= 9.0.x versions for hls and hlint
   ghc-api-compat = doDistribute super.ghc-api-compat_9_0_1;
+  ghc-lib-parser = self.ghc-lib-parser_9_0_1_20210324;
+  ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_0_0_4;
+  ghc-lib = self.ghc-lib_9_0_1_20210324;
+
+  # 2021-09-18: Need semialign >= 1.2 for correct bounds
+  semialign = super.semialign_1_2;
+
+  # Will probably be needed for brittany support
+  # https://github.com/lspitzner/czipwith/pull/2
+  #czipwith = appendPatch super.czipwith
+  #    (pkgs.fetchpatch {
+  #      url = "https://github.com/lspitzner/czipwith/commit/b6245884ae83e00dd2b5261762549b37390179f8.patch";
+  #      sha256 = "08rpppdldsdwzb09fmn0j55l23pwyls2dyzziw3yjc1cm0j5vic5";
+  #    });
+
+  # 2021-09-18: https://github.com/mokus0/th-extras/pull/8
+  # Release is missing, but asked for in the above PR.
+  th-extras = overrideCabal super.th-extras (old: {
+      version = assert old.version == "0.0.0.4"; "unstable-2021-09-18";
+      src = pkgs.fetchFromGitHub  {
+        owner = "mokus0";
+        repo = "th-extras";
+        rev = "0d050b24ec5ef37c825b6f28ebd46787191e2a2d";
+        sha256 = "045f36yagrigrggvyb96zqmw8y42qjsllhhx2h20q25sk5h44xsd";
+      };
+      libraryHaskellDepends = old.libraryHaskellDepends ++ [self.th-abstraction];
+    });
+
+  # 2021-09-18: GHC 9 compat release is missing
+  # Issue: https://github.com/obsidiansystems/dependent-sum/issues/65
+  dependent-sum-template = dontCheck (appendPatch super.dependent-sum-template
+      (pkgs.fetchpatch {
+        url = "https://github.com/obsidiansystems/dependent-sum/commit/8cf4c7fbc3bfa2be475a17bb7c94a1e1e9a830b5.patch";
+        sha256 = "02wyy0ciicq2x8lw4xxz3x5i4a550mxfidhm2ihh60ni6am498ff";
+        stripLen = 2;
+        extraPrefix = "";
+      }));
+
+  # 2021-09-18: cabal2nix does not detect the need for ghc-api-compat.
+  hiedb = overrideCabal super.hiedb (old: {
+    libraryHaskellDepends = old.libraryHaskellDepends ++ [self.ghc-api-compat];
+  });
+
+  # 2021-09-18: Need path >= 0.9.0 for ghc 9 compat
+  path = self.path_0_9_0;
+  # 2021-09-18: Need ormolu >= 0.3.0.0 for ghc 9 compat
+  ormolu = self.ormolu_0_3_0_0;
+  # 2021-09-18: https://github.com/haskell/haskell-language-server/issues/2206
+  # Restrictive upper bound on ormolu
+  hls-ormolu-plugin = doJailbreak super.hls-ormolu-plugin;
+
+  # 2021-09-18: The following plugins don‘t work yet on ghc9.
+  haskell-language-server = appendConfigureFlags (super.haskell-language-server.override {
+    hls-tactics-plugin = null; # No upstream support, generic-lens-core fail
+    hls-splice-plugin = null; # No upstream support in hls 1.4.0, should be fixed in 1.5
+    hls-refine-imports-plugin = null; # same issue es splice-plugin
+    hls-class-plugin = null; # No upstream support
+
+    hls-fourmolu-plugin = null; # No upstream support, needs new fourmolu release
+    hls-stylish-haskell-plugin = null; # No upstream support
+    hls-brittany-plugin = null; # No upstream support, needs new brittany release
+  }) [
+    "-f-tactic"
+    "-f-splice"
+    "-f-refineimports"
+    "-f-class"
+
+    "-f-fourmolu"
+    "-f-brittany"
+    "-f-stylishhaskell"
+  ];
 }

pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml

···
   - barrie
   - barrier
   - barrier-monad
+  - base62
   - base64-conduit
   - base-compat-migrate
   - base-encoding
···
   - capri
   - caramia
   - carbonara
+  - cardano-coin-selection
   - carettah
   - CarneadesDSL
   - carte
···
   - doctest-prop
   - docusign-example
   - docvim
+  - doi
   - dominion
   - domplate
   - dormouse-uri
···
   - why3
   - WikimediaParser
   - windns
+  - windowslive
   - winerror
   - Wired
   - wires

pkgs/development/haskell-modules/configuration-hackage2nix/stackage.yaml

···
-# Stackage LTS 18.9
+# Stackage LTS 18.10
 # This file is auto-generated by
 # maintainers/scripts/haskell/update-stackage.sh
 default-package-overrides:
···
   - approximate-equality ==1.1.0.2
   - app-settings ==0.2.0.12
   - arbor-lru-cache ==0.1.1.1
-  - arithmoi ==0.12.0.0
+  - arithmoi ==0.12.0.1
   - array-memoize ==0.6.0
   - arrow-extras ==0.1.0.1
   - arrows ==0.4.4.2
···
   - dbus ==1.2.17
   - dbus-hslogger ==0.1.0.1
   - debian ==4.0.2
-  - debian-build ==0.10.2.0
+  - debian-build ==0.10.2.1
   - debug-trace-var ==0.2.0
   - dec ==0.0.4
   - Decimal ==0.5.2
···
   - dependent-sum ==0.7.1.0
   - dependent-sum-template ==0.1.0.3
   - depq ==0.4.2
-  - deque ==0.4.3
+  - deque ==0.4.4
   - deriveJsonNoPrefix ==0.1.0.1
   - derive-topdown ==0.0.2.2
   - deriving-aeson ==0.2.7
···
   - fixed-length ==0.2.3
   - fixed-vector ==1.2.0.0
   - fixed-vector-hetero ==0.6.1.0
-  - fix-whitespace ==0.0.6
+  - fix-whitespace ==0.0.7
   - flac ==0.2.0
   - flac-picture ==0.1.2
   - flags-applicative ==0.1.0.3
···
   - flow ==1.0.22
   - flush-queue ==1.0.0
   - fmlist ==0.9.4
-  - fmt ==0.6.2.0
+  - fmt ==0.6.3.0
   - fn ==0.3.0.2
   - focus ==1.0.2
   - focuslist ==0.1.0.2
···
   - haskell-src-exts-util ==0.2.5
   - haskell-src-meta ==0.8.7
   - haskey-btree ==0.3.0.1
+  - hasktags ==0.72.0
   - hasql ==1.4.5.1
   - hasql-notifications ==0.2.0.0
   - hasql-optparse-applicative ==0.3.0.6
···
   - hspec-wai-json ==0.11.0
   - hs-php-session ==0.0.9.3
   - hsshellscript ==3.5.0
-  - hs-tags ==0.1.5.1
+  - hs-tags ==0.1.5.2
   - HStringTemplate ==0.8.8
   - HSvm ==0.1.1.3.22
   - HsYAML ==0.2.1.0
···
   - indexed-traversable-instances ==0.1
   - infer-license ==0.2.0
   - inflections ==0.4.0.6
-  - influxdb ==1.9.1.2
+  - influxdb ==1.9.2
   - ini ==0.4.1
   - inj ==1.0
   - inline-c ==0.9.1.5
···
   - js-dgtable ==0.5.2
   - js-flot ==0.8.3
   - js-jquery ==3.3.1
+  - json ==0.10
   - json-feed ==1.0.13
   - jsonifier ==0.1.1
   - jsonpath ==0.2.0.0
   - json-rpc ==1.0.3
-  - json-rpc-generic ==0.2.1.5
+  - json-rpc-generic ==0.2.1.6
   - JuicyPixels ==3.3.5
   - JuicyPixels-blurhash ==0.1.0.3
   - JuicyPixels-extra ==0.5.2
···
   - persistent-mtl ==0.2.2.0
   - persistent-mysql ==2.13.0.2
   - persistent-pagination ==0.1.1.2
-  - persistent-postgresql ==2.13.0.3
+  - persistent-postgresql ==2.13.1.0
   - persistent-qq ==2.12.0.1
   - persistent-sqlite ==2.13.0.3
   - persistent-template ==2.12.0.0
···
   - rev-state ==0.1.2
   - rfc1751 ==0.1.3
   - rfc5051 ==0.2
-  - rhbzquery ==0.4.3
+  - rhbzquery ==0.4.4
   - rhine ==0.7.0
   - rhine-gloss ==0.7.0
   - rigel-viz ==0.2.0.0
···
   - sample-frame ==0.0.3
   - sample-frame-np ==0.0.4.1
   - sampling ==0.3.5
-  - sandwich ==0.1.0.8
-  - sandwich-quickcheck ==0.1.0.5
-  - sandwich-slack ==0.1.0.4
+  - sandwich ==0.1.0.9
+  - sandwich-quickcheck ==0.1.0.6
+  - sandwich-slack ==0.1.0.6
   - sandwich-webdriver ==0.1.0.6
   - say ==0.1.0.1
   - sbp ==2.6.3
···
   - setlocale ==1.0.0.10
   - sexp-grammar ==2.3.1
   - SHA ==1.6.4.4
-  - shake ==0.19.5
+  - shake ==0.19.6
   - shake-language-c ==0.12.0
   - shake-plus ==0.3.4.0
   - shake-plus-extended ==0.4.1.0
···
   - streamt ==0.5.0.0
   - strict ==0.4.0.1
   - strict-concurrency ==0.2.4.3
-  - strict-list ==0.1.5
+  - strict-list ==0.1.6
   - strict-tuple ==0.1.4
   - strict-tuple-lens ==0.1.0.1
   - stringbuilder ==0.5.1
···
   - text-format ==0.3.2
   - text-icu ==0.7.1.0
   - text-latin1 ==0.3.1
-  - text-ldap ==0.1.1.13
+  - text-ldap ==0.1.1.14
   - textlocal ==0.1.0.5
   - text-manipulate ==0.3.0.0
   - text-metrics ==0.3.1
···
   - thread-supervisor ==0.2.0.0
   - threepenny-gui ==0.9.1.0
   - th-reify-compat ==0.0.1.5
-  - th-reify-many ==0.1.9
+  - th-reify-many ==0.1.10
   - throttle-io-stream ==0.2.0.1
   - through-text ==0.1.0.0
   - throwable-exceptions ==0.1.0.9
···
   - vector-circular ==0.1.3
   - vector-instances ==3.4
   - vector-mmap ==0.0.3
-  - vector-rotcev ==0.1.0.0
+  - vector-rotcev ==0.1.0.1
   - vector-sized ==1.4.4
   - vector-space ==0.16
   - vector-split ==1.0.0.2
···
   - wai-rate-limit-redis ==0.1.0.0
   - wai-saml2 ==0.2.1.2
   - wai-session ==0.3.3
-  - wai-session-redis ==0.1.0.2
+  - wai-session-redis ==0.1.0.3
   - wai-slack-middleware ==0.2.0
   - wai-websockets ==3.0.1.2
   - wakame ==0.1.0.0
···
   - wikicfp-scraper ==0.1.0.12
   - wild-bind ==0.1.2.7
   - wild-bind-x11 ==0.2.0.13
+  - Win32 ==2.6.2.1
   - Win32-notify ==0.3.0.3
   - windns ==0.1.0.1
   - witch ==0.3.4.0
···
   - yaml ==0.11.5.0
   - yamlparse-applicative ==0.2.0.0
   - yesod ==1.6.1.2
-  - yesod-auth ==1.6.10.3
+  - yesod-auth ==1.6.10.4
   - yesod-auth-hashdb ==1.7.1.7
   - yesod-auth-oauth2 ==0.6.3.4
   - yesod-bin ==1.6.1

pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml

···
  - boots-web
  - borel
  - bowntz
- - box
- - box-csv
- - box-socket
  - breakout
  - bricks
  - bricks-internal-test
···
  - call
  - camfort
  - campfire
- - candid
  - canteven-http
  - cao
  - cap
···
  - chr-core
  - chr-lang
  - chromatin
+ - chronos_1_1_3
  - chu2
  - chunks
  - ciphersaber2
···
  - wavy
  - web-mongrel2
  - web-page
- - web-rep
  - web-routes-regular
  - web-routing
  - web3

pkgs/development/haskell-modules/configuration-nix.nix

···
     testTarget = "unit-tests";
   };
 
-  haskell-language-server = enableCabalFlag (enableCabalFlag (overrideCabal super.haskell-language-server (drv: {
+  haskell-language-server = overrideCabal super.haskell-language-server (drv: {
     postInstall = let
       inherit (pkgs.lib) concatStringsSep take splitString;
       ghc_version = self.ghc.version;
···
       export PATH=$PATH:$PWD/dist/build/haskell-language-server:$PWD/dist/build/haskell-language-server-wrapper
       export HOME=$TMPDIR
     '';
-  })) "all-plugins") "all-formatters";
+  });
 
   # tests depend on a specific version of solc
   hevm = dontCheck (doJailbreak super.hevm);

pkgs/development/haskell-modules/hackage-packages.nix

···
      }:
      mkDerivation {
        pname = "ConClusion";
-       version = "0.0.2";
-       sha256 = "1n2wyvcyh950v67z4szvnr19vdh0fg2zvhxqyfqblpb1njayy92l";
+       version = "0.1.0";
+       sha256 = "1zi113zyf6fp133fplc3263683asxf0j038xsy51simwzw4rmxjc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "SVGFonts";
        version = "1.7.0.1";
        sha256 = "06vnpkkr19s9b1wjp7l2w29vr7fsghcrffd2knlxvdhjacrfpc9h";
-       revision = "1";
-       editedCabalFile = "110zlafis1rivba3za7in92fq6a7738hh57w5gkivi50d7pfbw24";
+       revision = "2";
+       editedCabalFile = "0q731cyrqq1csbid9nxh2bj6rf8yss017lz9j9zk22bw3bymzb0s";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          attoparsec base blaze-markup blaze-svg bytestring cereal
···
     ({ mkDerivation }:
      mkDerivation {
        pname = "Win32";
+       version = "2.6.2.1";
+       sha256 = "03lwm777sqv24hwyjjail8lk95jgaw7mns1g1hx2qhk29593432q";
+       description = "A binding to Windows Win32 API";
+       license = lib.licenses.bsd3;
+       platforms = lib.platforms.none;
+     }) {};
+
+  "Win32_2_13_0_0" = callPackage
+    ({ mkDerivation }:
+     mkDerivation {
+       pname = "Win32";
        version = "2.13.0.0";
        sha256 = "0i4ws3d7s94vv6gh3cjj9nr0l88rwx7bwjk9jk0grzvw734dd9a2";
        description = "A binding to Windows Win32 API";
···
     ({ mkDerivation, base, deepseq, random, simple-affine-space }:
      mkDerivation {
        pname = "Yampa";
-       version = "0.13.1";
-       sha256 = "0wx47awmijdrw4alcwd4icfip8702h3riq0nhs8sjfjqsihdz4fb";
+       version = "0.13.2";
+       sha256 = "0y0jmk9cbcnhwdrjcacx5j8gb64aj61a04nxizwbds0zvibcdzgb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      , deepseq, exact-pi, integer-gmp, integer-logarithms, integer-roots
      , mod, QuickCheck, quickcheck-classes, random, semirings
      , smallcheck, tasty, tasty-bench, tasty-hunit, tasty-quickcheck
-     , tasty-rerun, tasty-smallcheck, transformers, vector, vector-sized
-     }:
-     mkDerivation {
-       pname = "arithmoi";
-       version = "0.12.0.0";
-       sha256 = "1lghgr4z2vhafj8d8971pdghih6r5qq5xlc0b87jmazyhzz95w3f";
-       revision = "1";
-       editedCabalFile = "1b08p18k41sm298rn1z5ljs1l6s74nddm4fpdgix3npl8wsmmxgq";
-       configureFlags = [ "-f-llvm" ];
-       libraryHaskellDepends = [
-         array base chimera constraints containers deepseq exact-pi
-         integer-gmp integer-logarithms integer-roots mod random semirings
-         transformers vector
-       ];
-       testHaskellDepends = [
-         base containers exact-pi integer-gmp integer-roots mod QuickCheck
-         quickcheck-classes random semirings smallcheck tasty tasty-hunit
-         tasty-quickcheck tasty-rerun tasty-smallcheck transformers vector
-         vector-sized
-       ];
-       benchmarkHaskellDepends = [
-         array base constraints containers deepseq integer-logarithms mod
-         random semirings tasty-bench vector
-       ];
-       description = "Efficient basic number-theoretic functions";
-       license = lib.licenses.mit;
-     }) {};
-
-  "arithmoi_0_12_0_1" = callPackage
-    ({ mkDerivation, array, base, chimera, constraints, containers
-     , deepseq, exact-pi, integer-gmp, integer-logarithms, integer-roots
-     , mod, QuickCheck, quickcheck-classes, random, semirings
-     , smallcheck, tasty, tasty-bench, tasty-hunit, tasty-quickcheck
      , tasty-rerun, tasty-smallcheck, transformers, vector
      }:
      mkDerivation {
···
        ];
        description = "Efficient basic number-theoretic functions";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "arity-generic-liftA" = callPackage
···
        ];
        description = "Base62 encoding and decoding";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "base64" = callPackage
···
      }:
      mkDerivation {
        pname = "bencoding";
-       version = "0.4.5.3";
-       sha256 = "0sj69g4a68bv43vgmqdgp2nzi30gzp4lgz78hg1rdhind8lxrvp9";
+       version = "0.4.5.4";
+       sha256 = "01ncsvlay03h4cnj19mvrwbhmx0mksrvyq96qq8r5f7i8l0l9z8r";
        libraryHaskellDepends = [
          attoparsec base bytestring deepseq ghc-prim integer-gmp mtl pretty
          text
···
        broken = true;
      }) {};
 
+  "blockfrost-api" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, data-default
+     , data-default-class, deriving-aeson, hspec, lens, QuickCheck
+     , quickcheck-instances, raw-strings-qq, safe-money, servant
+     , servant-docs, servant-multipart-api, tasty, tasty-discover
+     , tasty-hspec, tasty-hunit, template-haskell, text, time, vector
+     }:
+     mkDerivation {
+       pname = "blockfrost-api";
+       version = "0.1.0.0";
+       sha256 = "0fc1s4ajx2l5s3csqz7q7r6kr985607cj3a2x2ypwv1q6x1f2amz";
+       libraryHaskellDepends = [
+         aeson base bytestring data-default-class deriving-aeson lens
+         QuickCheck quickcheck-instances safe-money servant servant-docs
+         servant-multipart-api template-haskell text time
+       ];
+       testHaskellDepends = [
+         aeson base bytestring data-default hspec raw-strings-qq safe-money
+         tasty tasty-hspec tasty-hunit text vector
+       ];
+       testToolDepends = [ tasty-discover ];
+       description = "API definitions for blockfrost.io";
+       license = lib.licenses.asl20;
+     }) {};
+
+  "blockfrost-client" = callPackage
+    ({ mkDerivation, base, blockfrost-api, blockfrost-client-core
+     , bytestring, data-default, directory, filepath, hspec, mtl
+     , servant, servant-client, servant-client-core, tasty
+     , tasty-discover, tasty-hspec, tasty-hunit, tasty-quickcheck, text
+     }:
+     mkDerivation {
+       pname = "blockfrost-client";
+       version = "0.1.0.0";
+       sha256 = "0n21zbmspjix1jnwym7xijaciyii85phb07ndr5dih12i9vsncp6";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base blockfrost-api blockfrost-client-core bytestring data-default
+         directory filepath mtl servant servant-client servant-client-core
+         text
+       ];
+       testHaskellDepends = [
+         base hspec tasty tasty-hspec tasty-hunit tasty-quickcheck
+       ];
+       testToolDepends = [ tasty-discover ];
+       description = "blockfrost.io basic client";
+       license = lib.licenses.asl20;
+     }) {};
+
+  "blockfrost-client-core" = callPackage
+    ({ mkDerivation, aeson, base, blockfrost-api, bytestring
+     , case-insensitive, containers, data-default, http-client
+     , http-client-tls, http-types, servant, servant-client
+     , servant-client-core, servant-multipart-api
+     , servant-multipart-client, text
+     }:
+     mkDerivation {
+       pname = "blockfrost-client-core";
+       version = "0.1.0.0";
+       sha256 = "0khybzvsy61zl4z02ccvh51gl4xj2cbi20i27xl4wxrhw6iqzc0i";
+       libraryHaskellDepends = [
+         aeson base blockfrost-api bytestring case-insensitive containers
+         data-default http-client http-client-tls http-types servant
+         servant-client servant-client-core servant-multipart-api
+         servant-multipart-client text
+       ];
+       description = "blockfrost.io common client definitions / instances";
+       license = lib.licenses.asl20;
+     }) {};
+
+  "blockfrost-pretty" = callPackage
+    ({ mkDerivation, base, blockfrost-api, data-default, lens
+     , prettyprinter, prettyprinter-ansi-terminal, safe-money, text
+     , time
+     }:
+     mkDerivation {
+       pname = "blockfrost-pretty";
+       version = "0.1.0.0";
+       sha256 = "1i25jcq45jf9x8idi9ipwfikq2pcnzpia8flcdgn8c9s6ap5bb1h";
+       libraryHaskellDepends = [
+         base blockfrost-api data-default lens prettyprinter
+         prettyprinter-ansi-terminal safe-money text time
+       ];
+       description = "blockfrost.io pretty-printing utilities";
+       license = lib.licenses.asl20;
+     }) {};
+
   "blockhash" = callPackage
     ({ mkDerivation, base, bytestring, JuicyPixels
      , optparse-applicative, primitive, vector, vector-algorithms
···
        ];
        description = "boxes";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "box-csv" = callPackage
···
        ];
        description = "CSV parsing in a box";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "box-socket" = callPackage
···
        ];
        description = "Box websockets";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "box-tuples" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "brick_0_64" = callPackage
+  "brick_0_64_1" = callPackage
     ({ mkDerivation, base, bytestring, config-ini, containers
      , contravariant, data-clist, deepseq, directory, dlist, exceptions
      , filepath, microlens, microlens-mtl, microlens-th, QuickCheck, stm
···
      }:
      mkDerivation {
        pname = "brick";
-       version = "0.64";
-       sha256 = "06l6vqxl2hd788pf465h7d4xicnd8zj6h1n73dg7s3mnhx177n2n";
+       version = "0.64.1";
+       sha256 = "13n4m4qfxbh8grqmp3ycl99xf8hszk9539qy73bzz785axgvhhbj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.gpl3Only;
      }) {};
 
+  "byte-count-reader_0_10_1_6" = callPackage
+    ({ mkDerivation, base, extra, hspec, parsec, parsec-numbers, text
+     }:
+     mkDerivation {
+       pname = "byte-count-reader";
+       version = "0.10.1.6";
+       sha256 = "182pc1fx74zfcrvp1g3ghqw3rhc9pcjkxy92n66pg0zm8yk8xqly";
+       libraryHaskellDepends = [ base extra parsec parsec-numbers text ];
+       testHaskellDepends = [
+         base extra hspec parsec parsec-numbers text
+       ];
+       description = "Read strings describing a number of bytes like 2Kb and 0.5 MiB";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "byte-order" = callPackage
     ({ mkDerivation, base, primitive, primitive-unaligned }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "byteslice";
-       version = "0.2.5.2";
-       sha256 = "0nva9w086g6d7g6bjwk4ad14jz8z17m0m9fvzfxv90cx6wkmvph3";
+       version = "0.2.6.0";
+       sha256 = "0kgrqf5v0crr44xm46fppkbqw5r738qspwyjdk9g4wavsm1bk20b";
        libraryHaskellDepends = [
          base bytestring primitive primitive-addr primitive-unlifted run-st
          tuples vector
···
 
   "call-alloy" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory
-     , file-embed, filepath, hashable, hspec, lens, mtl, process, split
+     , file-embed, filepath, hashable, hspec, mtl, process, split
      , trifecta, unix
      }:
      mkDerivation {
        pname = "call-alloy";
-       version = "0.2.1.1";
-       sha256 = "0vgn4rrpnhmjcn7wh01nr4q0mlmr4ja2dd1b9vysxfrmslfxnxda";
+       version = "0.2.2.0";
+       sha256 = "09xy823lxmp4siqxbv8f6v192a9bs0vmq36293cbiv7g7w65bnvi";
        libraryHaskellDepends = [
          base bytestring containers directory file-embed filepath hashable
-         lens mtl process split trifecta unix
+         mtl process split trifecta unix
        ];
        testHaskellDepends = [
          base bytestring containers directory file-embed filepath hashable
-         hspec lens mtl process split trifecta unix
+         hspec mtl process split trifecta unix
        ];
        description = "A simple library to call Alloy given a specification";
        license = lib.licenses.mit;
···
        ];
        description = "Candid integration";
        license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "canon" = callPackage
···
        ];
        description = "Algorithms for coin selection and fee balancing";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "cardano-transactions" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "circular_0_4_0_1" = callPackage
+    ({ mkDerivation, aeson, base, criterion, hspec, primitive
+     , QuickCheck, quickcheck-instances, vector
+     }:
+     mkDerivation {
+       pname = "circular";
+       version = "0.4.0.1";
+       sha256 = "03j06zf2fshcf59df088i47s4nx89arggv9h96izbpi0rz4m0fmk";
+       libraryHaskellDepends = [ aeson base primitive vector ];
+       testHaskellDepends = [
+         aeson base hspec primitive QuickCheck quickcheck-instances vector
+       ];
+       benchmarkHaskellDepends = [ base criterion vector ];
+       description = "Circular fixed-sized mutable vectors";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "circus" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, mtl, syb
      , text
···
     ({ mkDerivation, base, profunctors }:
      mkDerivation {
        pname = "coercible-subtypes";
-       version = "0.1.1.0";
-       sha256 = "1q6a38y49a31vl19i5c5kym36fjxspxj6vfi0b35j4gb9b7r642r";
+       version = "0.2.0.0";
+       sha256 = "0n8g69l3iwcy588yj29b7qsac8n8cl44ibb62a36x9n2jpgz5xif";
        libraryHaskellDepends = [ base profunctors ];
        description = "Coercible but only in one direction";
        license = lib.licenses.bsd3;
···
 
   "composite-dhall" = callPackage
     ({ mkDerivation, base, composite-base, dhall, tasty, tasty-hunit
-     , text
+     , text, vinyl
      }:
      mkDerivation {
        pname = "composite-dhall";
-       version = "0.0.4.1";
-       sha256 = "19lhw02my7dv6gx2zlvmsbc2w4g09j1yxpwg6s203bd5n4dp5v9v";
-       libraryHaskellDepends = [ base composite-base dhall text ];
+       version = "0.1.0.0";
+       sha256 = "05izp2zg6y4av8cc7lvvsy7ngk6aajqcm9x29faq36288dq1iim7";
+       libraryHaskellDepends = [ base composite-base dhall text vinyl ];
        testHaskellDepends = [
-         base composite-base dhall tasty tasty-hunit text
+         base composite-base dhall tasty tasty-hunit text vinyl
        ];
        description = "Dhall instances for composite records";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "connections";
-       version = "0.3.1";
-       sha256 = "0candwv3sv6qk76a4dn3m64957462da1pyvixl8jazf0gvq1pp23";
+       version = "0.3.2";
+       sha256 = "1j5vwg9ch37wkfa7sdyy97d6xlz4y70pfpcxp963cia9l28qpima";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers extended-reals time ];
···
        broken = true;
      }) {};
 
+  "covariance" = callPackage
+    ({ mkDerivation, base, glasso, hmatrix, statistics, tasty
+     , tasty-hunit, vector
+     }:
+     mkDerivation {
+       pname = "covariance";
+       version = "0.1.0.5";
+       sha256 = "0ahbr930imp1qf67zdalk67zykp1q6dm141wcrb6pkv6ldjavv2p";
+       libraryHaskellDepends = [ base glasso hmatrix statistics vector ];
+       testHaskellDepends = [ base hmatrix tasty tasty-hunit ];
+       description = "Well-conditioned estimation of large-dimensional covariance matrices";
+       license = lib.licenses.gpl3Plus;
+     }) {};
+
   "coverage" = callPackage
     ({ mkDerivation, base, hspec, HUnit, QuickCheck }:
      mkDerivation {
···
        broken = true;
      }) {};
 
+  "cropty" = callPackage
+    ({ mkDerivation, base, binary, bytestring, cryptonite, hedgehog
+     , unliftio
+     }:
+     mkDerivation {
+       pname = "cropty";
+       version = "0.2.0.0";
+       sha256 = "1skw80716qwsmdg1m55bl556xc8mmailzhz7m8psgaf2ggiys3jc";
+       libraryHaskellDepends = [ base binary bytestring cryptonite ];
+       testHaskellDepends = [ base hedgehog unliftio ];
+       description = "Encryption and decryption";
+       license = lib.licenses.mit;
+     }) {};
+
   "cruncher-types" = callPackage
     ({ mkDerivation, aeson, base, containers, hlint, lens, text }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "dear-imgui";
-       version = "1.1.0";
-       sha256 = "0vi9aqlp6pm1qmnihmx426fla3ffvnc2nc1s2i41180wfa6karbf";
+       version = "1.2.0";
+       sha256 = "0cnfm4wq8mfmqa4n5rvgl4y52850qgkk8kph6qihb5270xmxh8pi";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "debian-build";
-       version = "0.10.2.0";
-       sha256 = "1yqswr5cvv2yzl15nylvnf2x7cshz482fgfi1nnm22vq71zszn2x";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base directory filepath process split transformers
-       ];
-       executableHaskellDepends = [ base filepath transformers ];
-       description = "Debian package build sequence tools";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "debian-build_0_10_2_1" = callPackage
-    ({ mkDerivation, base, directory, filepath, process, split
-     , transformers
-     }:
-     mkDerivation {
-       pname = "debian-build";
        version = "0.10.2.1";
        sha256 = "1114xaqmhx74w0zqdksj6c1ggmfglcshhsxrw89gai5kzy47zp9d";
        isLibrary = true;
···
        executableHaskellDepends = [ base filepath transformers ];
        description = "Debian package build sequence tools";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "debug" = callPackage
···
      }) {};
 
   "deque" = callPackage
-    ({ mkDerivation, base, hashable, mtl, QuickCheck
-     , quickcheck-instances, rerebase, strict-list, tasty, tasty-hunit
-     , tasty-quickcheck
-     }:
-     mkDerivation {
-       pname = "deque";
-       version = "0.4.3";
-       sha256 = "19apwmcykprz3a91wszmc1w3qcz4x3rq79gmik514fszi9yhwsmp";
-       libraryHaskellDepends = [ base hashable mtl strict-list ];
-       testHaskellDepends = [
-         QuickCheck quickcheck-instances rerebase tasty tasty-hunit
-         tasty-quickcheck
-       ];
-       description = "Double-ended queues";
-       license = lib.licenses.mit;
-     }) {};
-
-  "deque_0_4_4" = callPackage
     ({ mkDerivation, base, deepseq, hashable, mtl, QuickCheck
      , quickcheck-instances, rerebase, strict-list, tasty, tasty-hunit
      , tasty-quickcheck
···
        ];
        description = "Double-ended queues";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "dequeue" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "dirichlet_0_1_0_5" = callPackage
+    ({ mkDerivation, base, hspec, log-domain, math-functions
+     , mwc-random, primitive, vector
+     }:
+     mkDerivation {
+       pname = "dirichlet";
+       version = "0.1.0.5";
+       sha256 = "1ibp7cvbi86m2m0kb1pzxmnb68awhbkayms7gffx3nqli6yb1fi9";
+       libraryHaskellDepends = [
+         base log-domain math-functions mwc-random primitive vector
+       ];
+       testHaskellDepends = [ base hspec log-domain mwc-random vector ];
+       description = "Multivariate Dirichlet distribution";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "dirstream" = callPackage
     ({ mkDerivation, base, directory, pipes, pipes-safe, system-fileio
      , system-filepath, unix
···
      }:
      mkDerivation {
        pname = "docopt";
-       version = "0.7.0.5";
-       sha256 = "1vh5kn13z0c6k2ir6nyr453flyn0cfmz7h61903vysw9lh40hy8m";
+       version = "0.7.0.6";
+       sha256 = "0gkj3bh74kbwk62zdr18lbd1544yi22w067xl8w35y8bdflkq7in";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base containers parsec template-haskell th-lift
···
        ];
        description = "Automatic Bibtex and fulltext of scientific articles";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "doldol" = callPackage
···
        license = lib.licenses.gpl3Plus;
      }) {};
 
-  "elynx_0_6_0_0" = callPackage
+  "elynx_0_6_1_0" = callPackage
     ({ mkDerivation, aeson, base, bytestring, elynx-tools
      , optparse-applicative, slynx, tlynx
      }:
      mkDerivation {
        pname = "elynx";
-       version = "0.6.0.0";
-       sha256 = "0ni33i5l82pyhsm2y2r5gpn736mnnd56086ma51s880lbr4qcizf";
+       version = "0.6.1.0";
+       sha256 = "0y6l3vcjjrsr3klzzcbckil36v12fyhy195fd43h8zabmlkrg897";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        license = lib.licenses.gpl3Plus;
      }) {};
 
-  "elynx-markov_0_6_0_0" = callPackage
+  "elynx-markov_0_6_1_0" = callPackage
     ({ mkDerivation, async, attoparsec, base, bytestring, containers
      , elynx-seq, elynx-tools, hmatrix, hspec, integration
      , math-functions, mwc-random, primitive, statistics, vector
      }:
      mkDerivation {
        pname = "elynx-markov";
-       version = "0.6.0.0";
-       sha256 = "12vbb7lrf7qw581pn0y5dpx1gkny74vib9f6sykg650izias8pl1";
+       version = "0.6.1.0";
+       sha256 = "1bk0hxwym1kgq97xdyzf4925y53gsb5figl5gamarwh6f3rxl6sw";
        libraryHaskellDepends = [
          async attoparsec base bytestring containers elynx-seq hmatrix
          integration math-functions mwc-random primitive statistics vector
···
        license = lib.licenses.gpl3Plus;
      }) {};
 
-  "elynx-nexus_0_6_0_0" = callPackage
+  "elynx-nexus_0_6_1_0" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, hspec }:
      mkDerivation {
        pname = "elynx-nexus";
-       version = "0.6.0.0";
-       sha256 = "0yhyacb04d9080rh030f082r64z72ma5g3sgpxy3vihp139gar34";
+       version = "0.6.1.0";
+       sha256 = "1dj8mn3ky0xzr94iar6bc82vsia3znq2fbr8ly0mlwph45x25czz";
        libraryHaskellDepends = [ attoparsec base bytestring ];
        testHaskellDepends = [ base hspec ];
        description = "Import and export Nexus files";
···
        license = lib.licenses.gpl3Plus;
      }) {};
 
-  "elynx-seq_0_6_0_0" = callPackage
+  "elynx-seq_0_6_1_0" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
      , elynx-tools, hspec, matrices, mwc-random, parallel, primitive
      , vector, vector-th-unbox, word8
      }:
      mkDerivation {
        pname = "elynx-seq";
-       version = "0.6.0.0";
-       sha256 = "1jyb8m400qcw7bkm1mdxqny59vk6bhfgp2fwsa1a9vxi1cdswk3l";
+       version = "0.6.1.0";
+       sha256 = "1bzcp6s1pxxwwg44yj0v1rh0k4saf52nr5m7mh6fpybcm3kpkww0";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring containers matrices mwc-random
          parallel primitive vector vector-th-unbox word8
···
        license = lib.licenses.gpl3Plus;
      }) {};
 
-  "elynx-tools_0_6_0_0" = callPackage
+  "elynx-tools_0_6_1_0" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
      , bytestring, cryptohash-sha256, directory, hmatrix, mwc-random
-     , optparse-applicative, primitive, template-haskell, text, time
-     , transformers, vector, zlib
+     , optparse-applicative, template-haskell, text, time, transformers
+     , vector, zlib
      }:
      mkDerivation {
        pname = "elynx-tools";
-       version = "0.6.0.0";
-       sha256 = "1jfxyf2f8wf1kzzg3wpw8fixzl6icx1729mpw98hp5wacvp1d4mk";
+       version = "0.6.1.0";
+       sha256 = "17vw9b9158mfna83xqkj8hnl02m8ngn2k22wsh2kvnhgiw9qc38m";
        libraryHaskellDepends = [
          aeson attoparsec base base16-bytestring bytestring
          cryptohash-sha256 directory hmatrix mwc-random optparse-applicative
-         primitive template-haskell text time transformers vector zlib
+         template-haskell text time transformers vector zlib
        ];
        description = "Tools for ELynx";
        license = lib.licenses.gpl3Plus;
···
        license = lib.licenses.gpl3Plus;
      }) {};
 
-  "elynx-tree_0_6_0_0" = callPackage
+  "elynx-tree_0_6_1_0" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, comonad
      , containers, criterion, data-default, data-default-class, deepseq
      , double-conversion, elynx-nexus, elynx-tools, hspec
···
      }:
      mkDerivation {
        pname = "elynx-tree";
-       version = "0.6.0.0";
-       sha256 = "1cywd10rky712yijpvq6cfrphmgks760y52gsdlfxwcn6jgych0r";
+       version = "0.6.1.0";
+       sha256 = "186f8qyp0k8jjc01wvpwlpxfkmr7043yyxajmh700jlxbz4p8j7i";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring comonad containers
          data-default-class deepseq double-conversion elynx-nexus
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "evm-opcodes" = callPackage
+    ({ mkDerivation, base, bytestring, cereal, containers, data-dword
+     , hedgehog, hspec, tasty, tasty-discover, tasty-hedgehog
+     , tasty-hspec, text
+     }:
+     mkDerivation {
+       pname = "evm-opcodes";
+       version = "0.1.0";
+       sha256 = "1bjn8i6d6vccms4xzs877cpmd75v0kgd349a024gig3rfsxqadn5";
+       libraryHaskellDepends = [
+         base bytestring cereal containers data-dword text
+       ];
+       testHaskellDepends = [
+         base bytestring cereal containers data-dword hedgehog hspec tasty
+         tasty-discover tasty-hedgehog tasty-hspec text
+       ];
+       testToolDepends = [ tasty-discover ];
+       description = "Opcode types for Ethereum Virtual Machine (EVM)";
+       license = lib.licenses.mit;
+     }) {};
+
   "evoke" = callPackage
     ({ mkDerivation, aeson, base, ghc, HUnit, insert-ordered-containers
-     , lens, QuickCheck, random, swagger2, text
+     , lens, QuickCheck, swagger2, text
      }:
      mkDerivation {
        pname = "evoke";
-       version = "0.2021.8.25";
-       sha256 = "14yq5izrlzyqwm3cf9lc26dgxix3yyfiafp5i4p9s6j4d1dspm1i";
-       libraryHaskellDepends = [ base ghc random ];
+       version = "0.2021.9.14";
+       sha256 = "1r31f54s37rqdka8szmiavgjr0nhnsbbzmsdakwv675s29cclh8f";
+       libraryHaskellDepends = [ base ghc ];
        testHaskellDepends = [
          aeson base HUnit insert-ordered-containers lens QuickCheck swagger2
          text
···
        pname = "fin-int";
        version = "0.1.0.0";
        sha256 = "0ksjc8jz3l5jh6xd7aam424vpcq1ah7dcq2r5vmh4c7hcd48fakv";
+       revision = "1";
+       editedCabalFile = "0fq6cliihr0dhks62nim33f0sxqs2rwn4yd7gdd67h07acimcrzf";
        libraryHaskellDepends = [
          attenuation base data-default-class deepseq portray portray-diff
          QuickCheck sint
···
      }:
      mkDerivation {
        pname = "finite-table";
-       version = "0.1.0.0";
-       sha256 = "1pc58c1wsk91an4fqlz41k3iww47iir96mmdk6g43xa61hwlqj37";
+       version = "0.1.0.1";
+       sha256 = "17bn5wmv5sz89yh3lh39i1armi168wxxnz6l9smcfmw334lidlv6";
        libraryHaskellDepends = [
          adjunctions base cereal data-default-class deepseq distributive
          fin-int indexed-traversable lens portray portray-diff short-vec
···
      }:
      mkDerivation {
        pname = "fix-whitespace";
-       version = "0.0.6";
-       sha256 = "087sp7bf7k4h9clmhqdzk8j1y12rc6lhd22p2w6kp7w1ppgg06aw";
-       isLibrary = false;
-       isExecutable = true;
-       executableHaskellDepends = [
-         base directory extra filepath filepattern text yaml
-       ];
-       description = "Fixes whitespace issues";
-       license = "unknown";
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
-  "fix-whitespace_0_0_7" = callPackage
-    ({ mkDerivation, base, directory, extra, filepath, filepattern
-     , text, yaml
-     }:
-     mkDerivation {
-       pname = "fix-whitespace";
        version = "0.0.7";
        sha256 = "1nx56dfgg0i75f007y0r5w0955y3x78drjkvdx278llalyfpc5bg";
        isLibrary = false;
···
      }:
      mkDerivation {
        pname = "fmt";
-       version = "0.6.2.0";
-       sha256 = "14h5f7nz9czfg1ar0ga9vry4ck2xf7h6rxiyk276w871yra01l9g";
-       libraryHaskellDepends = [
-         base base64-bytestring bytestring call-stack containers formatting
-         microlens text time time-locale-compat
-       ];
-       testHaskellDepends = [
-         base bytestring call-stack containers doctest hspec
-         neat-interpolation QuickCheck text vector
-       ];
-       testToolDepends = [ doctest-discover ];
-       benchmarkHaskellDepends = [
-         base bytestring containers criterion deepseq formatting interpolate
-         text vector
-       ];
-       description = "A new formatting library";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "fmt_0_6_3_0" = callPackage
-    ({ mkDerivation, base, base64-bytestring, bytestring, call-stack
-     , containers, criterion, deepseq, doctest, doctest-discover
-     , formatting, hspec, interpolate, microlens, neat-interpolation
-     , QuickCheck, text, time, time-locale-compat, vector
-     }:
-     mkDerivation {
-       pname = "fmt";
        version = "0.6.3.0";
        sha256 = "01mh0k69dv5x30hlmxi36dp1ylk0a6affr4jb3pvy8vjm4ypzvml";
        libraryHaskellDepends = [
···
        ];
        description = "A new formatting library";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "fmt-for-rio" = callPackage
···
      }:
      mkDerivation {
        pname = "fortran-src";
-       version = "0.6.0";
-       sha256 = "0g0wpcr9ddad59x58gknrw2y7w3h88i7s9br9qk423k48gq8qsla";
+       version = "0.6.1";
+       sha256 = "1d07ih8bcij71x4b5nwd4fk12cmmigpzcf98fixgayrkcvmnckzg";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "ghcide";
-       version = "1.4.1.0";
-       sha256 = "1m5h7v9wg6k3w8mq0x0izjf9x1lapwb6ccvsbgg11prl6il4hlck";
+       version = "1.4.2.0";
+       sha256 = "1hkh6j95rmsk2g9m2x7qr4w9ckhr7w1rg6di6h5dwqi9pryfbfny";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "gi-gtk-declarative";
-       version = "0.7.0";
-       sha256 = "0j6yk2qr88yrxs8vdwcqv6jzisjl0x1j932ssim8ay98z4r6y8gg";
+       version = "0.7.1";
+       sha256 = "0fc3y6p7adnwpz5zwv9sh0wy88nx1i3n7m8qx4awha9id59s0y1y";
        libraryHaskellDepends = [
          base containers data-default-class gi-glib gi-gobject gi-gtk
          haskell-gi haskell-gi-base haskell-gi-overloading mtl text
···
      }:
      mkDerivation {
        pname = "gi-gtk-declarative-app-simple";
-       version = "0.7.0";
-       sha256 = "0ygp70yfj530czfw6an3yp9y883q4lwky45rxdslyf1ifk8dn6rf";
+       version = "0.7.1";
+       sha256 = "0q5crb3jl8mlr474srqya3yqi90vklnldlb2qs167h60shzvf353";
        libraryHaskellDepends = [
          async base gi-gdk gi-glib gi-gobject gi-gtk gi-gtk-declarative
          haskell-gi haskell-gi-base haskell-gi-overloading pipes
···
      }:
      mkDerivation {
        pname = "haskell-language-server";
-       version = "1.3.0.0";
-       sha256 = "0hihaqvrq3rfvczzjxhcjyqwjx7chiv67hygl7qwqvj81y4r9rss";
+       version = "1.4.0.0";
+       sha256 = "1zyvfh9lmr97i221kqkjilq1di3l5h2qk2d46rcl3gyfrdpc2cil";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "haskoin-core";
-       version = "0.20.4";
-       sha256 = "0mbq4ixnnjln0qjippmv57qz5p4qx3s0fyr2xj43q5gmis89m4cg";
+       version = "0.20.5";
+       sha256 = "1nx0m51nxm6m2nq6cdcsd8xiap7x6rr2z5ckbzga33fh73ivmkmp";
        libraryHaskellDepends = [
          aeson array base base16 binary bytes bytestring cereal conduit
          containers cryptonite deepseq entropy hashable hspec memory mtl
···
      }:
      mkDerivation {
        pname = "haskoin-store";
-       version = "0.53.10";
-       sha256 = "0a20808l907wvgcdvbv7jvkpphpfj64x9cm7a07hpldsi2r3c26p";
+       version = "0.53.11";
+       sha256 = "0b6q74zk58chz1b9pv6rm1ipx2ss08ks4qwlyhzqgwfy5npn1x6p";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "haskoin-store-data";
-       version = "0.53.10";
-       sha256 = "0rnqa294j909s06nadg58vdblfvswb6si04m6gyf4k3ihmd1nj39";
+       version = "0.53.11";
+       sha256 = "0x75vm28j8gpwan2kdy3di14myhk6gfk8wa70iys8cj43c7ds83l";
        libraryHaskellDepends = [
          aeson base binary bytes bytestring cereal containers data-default
          deepseq hashable haskoin-core http-client http-types lens mtl
···
        benchmarkHaskellDepends = [ gauge rerebase ];
        description = "An efficient PostgreSQL driver with a flexible mapping API";
        license = lib.licenses.mit;
+     }) {};
+
+  "hasql_1_4_5_2" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring
+     , bytestring-strict-builder, contravariant, contravariant-extras
+     , dlist, gauge, hashable, hashtables, mtl, postgresql-binary
+     , postgresql-libpq, profunctors, QuickCheck, quickcheck-instances
+     , rerebase, tasty, tasty-hunit, tasty-quickcheck, text
+     , text-builder, transformers, vector
+     }:
+     mkDerivation {
+       pname = "hasql";
+       version = "1.4.5.2";
+       sha256 = "0kliby1gigmy1z856wnnlrn70hacqj2350yypdxkm7sfh717n4rj";
+       libraryHaskellDepends = [
+         attoparsec base bytestring bytestring-strict-builder contravariant
+         dlist hashable hashtables mtl postgresql-binary postgresql-libpq
+         profunctors text text-builder transformers vector
+       ];
+       testHaskellDepends = [
+         contravariant-extras QuickCheck quickcheck-instances rerebase tasty
+         tasty-hunit tasty-quickcheck
+       ];
+       benchmarkHaskellDepends = [ gauge rerebase ];
+       description = "An efficient PostgreSQL driver with a flexible mapping API";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hasql-backend" = callPackage
···
      }) {};
 
   "irc-ctcp" = callPackage
-  "irc-ctcp" = callPackage
-  "irc-ctcp" = callPackage
-     , transformers
+    ({ mkDerivation, base, brittany, czipwith, extra, filepath, ghc
+     , ghc-boot-th, ghc-exactprint, ghcide, hls-plugin-api
+     , hls-test-utils, lens, lsp-types, text, transformers
      }:
      mkDerivation {
   "irc-ctcp" = callPackage
-       version = "1.0.0.2";
-  "irc-ctcp" = callPackage
+       version = "1.0.1.0";
+       sha256 = "0wkarbbq3nq923d169k8g6z8svnqp8ghikh2q7nbrdg8anhrbgqz";
        libraryHaskellDepends = [
-  "irc-ctcp" = callPackage
-  "irc-ctcp" = callPackage
+         base brittany czipwith extra filepath ghc ghc-boot-th
+         ghc-exactprint ghcide hls-plugin-api lens lsp-types text
+         transformers
        ];
   "irc-ctcp" = callPackage
   "irc-ctcp" = callPackage
-       license = lib.licenses.asl20;
+       license = lib.licenses.agpl3Only;
      }) {};
 
   "irc-ctcp" = callPackage
···
      }:
      mkDerivation {
   "irc-ctcp" = callPackage
-       version = "1.0.0.0";
-  "irc-ctcp" = callPackage
+       version = "1.0.1.0";
+       sha256 = "1vzxiwxj14kmabcggp9dnq8jw9kcqknlg4xyv9cp69djz5ssrnzr";
        libraryHaskellDepends = [
   "irc-ctcp" = callPackage
   "irc-ctcp" = callPackage
···
      }:
      mkDerivation {
   "irc-ctcp" = callPackage
-       version = "1.0.0.3";
-  "irc-ctcp" = callPackage
+       version = "1.0.1.0";
+       sha256 = "0m1yifv7pfb4gll0zajdzxy0v0a7kwivfvbamvh9g3lf7iiy0vd0";
        libraryHaskellDepends = [
   "irc-ctcp" = callPackage
   "irc-ctcp" = callPackage
···
      }:
      mkDerivation {
   "irc-ctcp" = callPackage
-       version = "1.0.0.4";
-  "irc-ctcp" = callPackage
+       version = "1.0.1.0";
+       sha256 = "0frk2id6k3r58799qvppryapayvkim969xhh89i8ak5vs4a8ygpy";
        libraryHaskellDepends = [
   "irc-ctcp" = callPackage
   "irc-ctcp" = callPackage
···
      }:
      mkDerivation {
   "irc-ctcp" = callPackage
-       version = "1.0.0.1";
-  "irc-ctcp" = callPackage
+       version = "1.0.1.0";
+       sha256 = "0s7hynj50vldxgzii4gb0mml9gyizy3vaan1scpmhrj7kh44w746";
        libraryHaskellDepends = [
   "irc-ctcp" = callPackage
   "irc-ctcp" = callPackage
···
      }:
      mkDerivation {
   "irc-ctcp" = callPackage
-       version = "1.2.0.0";
-  "irc-ctcp" = callPackage
+       version = "1.2.0.1";
+       sha256 = "0hixalca3lznzgcdzk7aix0nkhdlwds83kvz7bxjgvfs3ml7gw01";
        libraryHaskellDepends = [
   "irc-ctcp" = callPackage
   "irc-ctcp" = callPackage
···
      }:
      mkDerivation {
   "irc-ctcp" = callPackage
-       version = "1.0.0.1";
-  "irc-ctcp" = callPackage
+       version = "1.0.1.0";
+       sha256 = "0w4q1mkpqbl27wqa06l7709y1qfdlfvavfcqvyjs1vwqf1c4q5ag";
        libraryHaskellDepends = [
   "irc-ctcp" = callPackage
          unordered-containers
        ];
        testHaskellDepends = [
-  "irc-ctcp" = callPackage
+         base filepath hls-test-utils lens lsp-types text
        ];
   "irc-ctcp" = callPackage
        license = lib.licenses.asl20;
···
      }:
      mkDerivation {
   "irc-ctcp" = callPackage
-       version = "1.0.1.1";
-  "irc-ctcp" = callPackage
+       version = "1.0.1.2";
+       sha256 = "0pvz8vgzpaljlpfpwzhsfj5yyd3m5hvhy8b17q87ripbffpb58dr";
        libraryHaskellDepends = [
   "irc-ctcp" = callPackage
   "irc-ctcp" = callPackage
···
   "irc-ctcp" = callPackage
   "irc-ctcp" = callPackage
   "irc-ctcp" = callPackage
-  "irc-ctcp" = callPackage
+     , syb, tasty-hspec, tasty-hunit, text, transformers, unagi-chan
      , unordered-containers
      }:
      mkDerivation {
   "irc-ctcp" = callPackage
-       version = "1.3.0.0";
-  "irc-ctcp" = callPackage
+       version = "1.4.0.0";
+       sha256 = "189d43vpf3sky9qh5mswmr4i0qxmjaayg20x21swaf7sglgw6lw8";
        libraryHaskellDepends = [
   "irc-ctcp" = callPackage
   "irc-ctcp" = callPackage
   "irc-ctcp" = callPackage
   "irc-ctcp" = callPackage
-         transformers unordered-containers
+         transformers unagi-chan unordered-containers
        ];
        testHaskellDepends = [
   "irc-ctcp" = callPackage
···
      }) {};
 
   "hs-tags" = callPackage
-    ({ mkDerivation, base, Cabal, containers, directory, filepath, ghc
-     , ghc-paths, mtl, process, strict
-     }:
-     mkDerivation {
-       pname = "hs-tags";
-       version = "0.1.5.1";
-       sha256 = "1yk1x24qar19hx47yjlr4f1qz3ld45hzpc74yxak73rsz08c08dx";
-       isLibrary = false;
-       isExecutable = true;
-       executableHaskellDepends = [
-         base Cabal containers directory filepath ghc ghc-paths mtl process
-         strict
-       ];
-       description = "Create tag files (ctags and etags) for Haskell code";
-       license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "hs-tags_0_1_5_2" = callPackage
     ({ mkDerivation, base, Cabal, containers, directory, filepath, ghc
      , ghc-paths, mtl, process, strict
      }:
···
     ({ mkDerivation, base, template-haskell }:
      mkDerivation {
        pname = "include-env";
-       version = "0.1.3.0";
-       sha256 = "0yj7gbsxdjihf243c0xym5yxdkyr1s8qs8dvxhf7xf5pw77y03qg";
+       version = "0.3.0.0";
+       sha256 = "00wgyka74w6i4w2k673cahp2nmsvhgdfdc3dp5nqb1hgks51n5lc";
        libraryHaskellDepends = [ base template-haskell ];
        description = "Include the value of an environment variable at compile time";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "influxdb";
-       version = "1.9.1.2";
-       sha256 = "0adrfaimjfrhfx2542wynjpd810yqxnjr3q4hhw8gz75v70f44nn";
-       isLibrary = true;
-       isExecutable = true;
-       setupHaskellDepends = [ base Cabal cabal-doctest ];
-       libraryHaskellDepends = [
-         aeson attoparsec base bytestring clock containers foldl http-client
-         http-types lens network optional-args scientific tagged text time
-         unordered-containers vector
-       ];
-       testHaskellDepends = [
-         base containers doctest lens raw-strings-qq tasty tasty-hunit
-         template-haskell time vector
-       ];
-       description = "InfluxDB client library for Haskell";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "influxdb_1_9_2" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, bytestring, Cabal
-     , cabal-doctest, clock, containers, doctest, foldl, http-client
-     , http-types, lens, network, optional-args, raw-strings-qq
-     , scientific, tagged, tasty, tasty-hunit, template-haskell, text
-     , time, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "influxdb";
        version = "1.9.2";
        sha256 = "1dmj2gg47wav9qk22a9p4pclxmxnw3czyfj19nbb09911vq1ng5n";
        isLibrary = true;
···
        ];
        description = "InfluxDB client library for Haskell";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "informative" = callPackage
···
      }:
      mkDerivation {
        pname = "interval-algebra";
-       version = "0.10.2";
-       sha256 = "13rglhfcjlwsvch4qcrsjfgcxv4rsxx63zhw3fjzvb5hrj7qvgb1";
+       version = "1.0.0";
+       sha256 = "1wd2z7ngw53krg3y5klrhlndm9dilmqpvmlipjda168gqisxsscp";
        libraryHaskellDepends = [
          base containers foldl QuickCheck safe time witherable
        ];
···
 
   "json-rpc-generic" = callPackage
     ({ mkDerivation, aeson, aeson-generic-compat, base, containers
-     , dlist, QuickCheck, quickcheck-simple, scientific, text
-     , transformers, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "json-rpc-generic";
-       version = "0.2.1.5";
-       sha256 = "1h1spyiq5xix3rbjdk37a28l6l46zygvxafdhaa466hyn2j7p4cz";
-       libraryHaskellDepends = [
-         aeson aeson-generic-compat base containers dlist scientific text
-         transformers unordered-containers vector
-       ];
-       testHaskellDepends = [
-         aeson base QuickCheck quickcheck-simple text
-       ];
-       description = "Generic encoder and decode for JSON-RPC";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "json-rpc-generic_0_2_1_6" = callPackage
-    ({ mkDerivation, aeson, aeson-generic-compat, base, containers
      , QuickCheck, quickcheck-simple, scientific, text, transformers
      , unordered-containers, vector
      }:
···
        ];
        description = "Generic encoder and decode for JSON-RPC";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "json-rpc-server" = callPackage
···
     ({ mkDerivation, base, pretty }:
      mkDerivation {
        pname = "language-c99";
-       version = "0.1.2";
-       sha256 = "0k4a1chca328sa3w7aghhi446kqfrbp6h5jaj2rddd8f8qjz5pag";
+       version = "0.1.3";
+       sha256 = "159cy0vrnzs8kdraclia3i693kkik33dnhx5279d7l685jf3a8fz";
        libraryHaskellDepends = [ base pretty ];
        description = "An implementation of the C99 AST that strictly follows the standard";
        license = lib.licenses.mit;
···
   "libmdbx" = callPackage
     ({ mkDerivation, base, binary, bytestring, c2hs, data-default
      , directory, hspec, HUnit, mtl, store, store-core, text
+     , transformers
      }:
      mkDerivation {
        pname = "libmdbx";
-       version = "0.2.0.0";
-       sha256 = "150wpckgjkdallpfql18wy8in1bk6k2alhri303j6i6fdi2f7y75";
+       version = "0.2.1.0";
+       sha256 = "1v5gjp1hr4c1r5nbf4r2j3pd2kxl36b9xpphmmxqin7jfmpj5fjj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          base binary bytestring data-default mtl store store-core text
+         transformers
        ];
        libraryToolDepends = [ c2hs ];
        executableHaskellDepends = [
          base binary bytestring data-default mtl store store-core text
+         transformers
        ];
        testHaskellDepends = [
          base binary bytestring data-default directory hspec HUnit mtl store
-         store-core text
+         store-core text transformers
        ];
        description = "Bindings for libmdbx, an embedded key/value store";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "lift-generics_0_2_1" = callPackage
+    ({ mkDerivation, base, base-compat, containers, generic-deriving
+     , ghc-prim, hspec, hspec-discover, mtl, template-haskell, th-compat
+     , th-lift-instances
+     }:
+     mkDerivation {
+       pname = "lift-generics";
+       version = "0.2.1";
+       sha256 = "1qkzq8hcb6j15cslv577bmhjcxmljzsrryysdgd7r99kr3q445b4";
+       libraryHaskellDepends = [
+         base generic-deriving ghc-prim template-haskell th-compat
+       ];
+       testHaskellDepends = [
+         base base-compat containers generic-deriving hspec mtl
+         template-haskell th-compat th-lift-instances
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "GHC.Generics-based Language.Haskell.TH.Syntax.lift implementation";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "lift-read-show" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        license = lib.licenses.mit;
      }) {};
 
+  "list-t_1_0_5" = callPackage
+    ({ mkDerivation, base, base-prelude, foldl, HTF, logict, mmorph
+     , monad-control, mtl, mtl-prelude, semigroups, transformers
+     , transformers-base
+     }:
+     mkDerivation {
+       pname = "list-t";
+       version = "1.0.5";
+       sha256 = "1gyn25ra5y8bv1hxlsjg6l1dmzp6wj9g81v1nxz1p545cbl3g9my";
+       libraryHaskellDepends = [
+         base foldl logict mmorph monad-control mtl semigroups transformers
+         transformers-base
+       ];
+       testHaskellDepends = [ base-prelude HTF mmorph mtl-prelude ];
+       description = "ListT done right";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "list-t-attoparsec" = callPackage
     ({ mkDerivation, attoparsec, base-prelude, either, hspec, list-t
      , list-t-text, text, transformers
···
        pname = "lsp";
        version = "1.2.0.1";
        sha256 = "1bdgbxakdyhkrddj58f0al2wrx1mckp6hia7hk2wqjix20my8v49";
+       revision = "1";
+       editedCabalFile = "193y4b3l6agm83ng2c0ngvd0j9a71q237g9i5v57p502lhzfaag2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.gpl3Plus;
      }) {};
 
-  "mcmc_0_6_0_0" = callPackage
+  "mcmc_0_6_1_0" = callPackage
     ({ mkDerivation, aeson, base, bytestring, circular, containers
-     , criterion, data-default, deepseq, directory, dirichlet
-     , double-conversion, hspec, log-domain, math-functions, matrices
-     , microlens, monad-parallel, mwc-random, pretty-show, primitive
-     , statistics, time, transformers, vector, zlib
+     , covariance, criterion, data-default, deepseq, directory
+     , dirichlet, double-conversion, hmatrix, hspec, log-domain
+     , math-functions, microlens, monad-parallel, mwc-random
+     , pretty-show, primitive, statistics, time, transformers, vector
+     , zlib
      }:
      mkDerivation {
        pname = "mcmc";
-       version = "0.6.0.0";
-       sha256 = "13m4rdgfwvwhw7nznxlq6af2w56pizgypxxyn8g2agzn2vl6nzfl";
+       version = "0.6.1.0";
+       sha256 = "0wln2fin522mg8ql4ypyxhm93rgq985bcqq61gsvzqrkwrp7n33a";
        libraryHaskellDepends = [
-         aeson base bytestring circular containers data-default deepseq
-         directory dirichlet double-conversion log-domain math-functions
-         matrices microlens monad-parallel mwc-random pretty-show primitive
-         statistics time transformers vector zlib
+         aeson base bytestring circular containers covariance data-default
+         deepseq directory dirichlet double-conversion hmatrix log-domain
+         math-functions microlens monad-parallel mwc-random pretty-show
+         primitive statistics time transformers vector zlib
        ];
        testHaskellDepends = [
          base hspec log-domain mwc-random statistics
···
          base bytestring directory HUnit optparse-applicative text
        ];
        description = "Haskell binding to Mercury API for ThingMagic RFID readers";
+       license = lib.licenses.mit;
+     }) {};
+
+  "merge" = callPackage
+    ({ mkDerivation, base, profunctors }:
+     mkDerivation {
+       pname = "merge";
+       version = "0.2.0.0";
+       sha256 = "193xvnm5ahms8pg8g8jscrcfp29mwni9rssy5hci11z3b126s6wv";
+       libraryHaskellDepends = [ base profunctors ];
+       testHaskellDepends = [ base ];
+       description = "A functor for consistent merging of information";
        license = lib.licenses.mit;
      }) {};
 
···
      }) {};
 
   "miso" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, http-api-data
-     , http-types, lucid, network-uri, servant, servant-lucid, text
-     , transformers, vector
+    ({ mkDerivation, aeson, base, bytestring, containers, file-embed
+     , http-api-data, http-types, jsaddle, lucid, network-uri, servant
+     , servant-lucid, tagsoup, text, transformers, vector
      }:
      mkDerivation {
        pname = "miso";
-       version = "1.7.1.0";
-       sha256 = "1hkfcinwymrff8mmvywhnlzbj5804hwkk4rhzxzhzsycdf4v7a41";
+       version = "1.8.0.0";
+       sha256 = "02j6z7l8016cccm9i699b0ggp3l6hxhk0j7m8kiw5d7ik4wciphv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson base bytestring containers http-api-data http-types lucid
-         network-uri servant servant-lucid text transformers vector
+         aeson base bytestring containers file-embed http-api-data
+         http-types jsaddle lucid network-uri servant servant-lucid tagsoup
+         text transformers vector
        ];
        description = "A tasty Haskell front-end framework";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation }:
      mkDerivation {
        pname = "miso-examples";
-       version = "1.7.1.0";
-       sha256 = "1z6zcydai6k9hj1phws1axdcbvdplhxv833is7pzfv8sq9mfyfsc";
+       version = "1.8.0.0";
+       sha256 = "1dr967y1ffp1lw6jiclrgqvfvfi68d88l5qbsyl8bidfzvm7sbk1";
        isLibrary = false;
        isExecutable = true;
        description = "A tasty Haskell front-end framework";
···
        benchmarkHaskellDepends = [ base gauge mwc-random vector ];
        description = "Type classes for mapping, folding, and traversing monomorphic containers";
        license = lib.licenses.mit;
+     }) {};
+
+  "mono-traversable_1_0_15_2" = callPackage
+    ({ mkDerivation, base, bytestring, containers, foldl, gauge
+     , hashable, hspec, HUnit, mwc-random, QuickCheck, split, text
+     , transformers, unordered-containers, vector, vector-algorithms
+     }:
+     mkDerivation {
+       pname = "mono-traversable";
+       version = "1.0.15.2";
+       sha256 = "1drh7nxfzlfmjr11hk2ijjsf3zsim18blaghhxmx6nxgy8i95876";
+       libraryHaskellDepends = [
+         base bytestring containers hashable split text transformers
+         unordered-containers vector vector-algorithms
+       ];
+       testHaskellDepends = [
+         base bytestring containers foldl hspec HUnit QuickCheck text
+         transformers unordered-containers vector
+       ];
+       benchmarkHaskellDepends = [ base gauge mwc-random vector ];
+       description = "Type classes for mapping, folding, and traversing monomorphic containers";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "mono-traversable-instances" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "ormolu_0_2_0_0" = callPackage
-    ({ mkDerivation, ansi-terminal, base, bytestring, containers, Diff
-     , dlist, exceptions, filepath, ghc-lib-parser, gitrev, hspec
-     , hspec-discover, mtl, optparse-applicative, path, path-io, syb
-     , text
+  "ormolu_0_3_0_0" = callPackage
+    ({ mkDerivation, ansi-terminal, base, bytestring, Cabal, containers
+     , Diff, directory, dlist, exceptions, filepath, ghc-lib-parser
+     , gitrev, hspec, hspec-discover, mtl, optparse-applicative, path
+     , path-io, syb, text
      }:
      mkDerivation {
        pname = "ormolu";
-       version = "0.2.0.0";
-       sha256 = "0zivz7vcl4m1rjay5md6cdqac9cnfwz9c844l20byiz5h49bwfhb";
+       version = "0.3.0.0";
+       sha256 = "073d8wkpciqadcv1vnim00c13n30ybqdraaxgyr96dcqvq71zvjv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         ansi-terminal base bytestring containers Diff dlist exceptions
-         ghc-lib-parser mtl syb text
+         ansi-terminal base bytestring Cabal containers Diff directory dlist
+         exceptions filepath ghc-lib-parser mtl syb text
        ];
        executableHaskellDepends = [
          base filepath ghc-lib-parser gitrev optparse-applicative text
···
        license = lib.licenses.gpl3Plus;
      }) {};
 
+  "pava_0_1_1_2" = callPackage
+    ({ mkDerivation, base, criterion, hspec, mwc-random, vector }:
+     mkDerivation {
+       pname = "pava";
+       version = "0.1.1.2";
+       sha256 = "0qvyia9iy8f9s16v2khgzm74z9r7mks98xz1g1qhrdkw950mjlga";
+       libraryHaskellDepends = [ base vector ];
+       testHaskellDepends = [ base hspec vector ];
+  "irc-ctcp" = callPackage
+       description = "Greatest convex majorants and least concave minorants";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "paymill" = callPackage
     ({ mkDerivation, base, hspec }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "persistent-postgresql";
-       version = "2.13.0.3";
-       sha256 = "06f5yyv8bj3m4zpjwr1k66hkmh1gfy624rnq2g12sjrpz8nrax6j";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson attoparsec base blaze-builder bytestring conduit containers
-         monad-logger mtl persistent postgresql-libpq postgresql-simple
-         resource-pool resourcet string-conversions text time transformers
-         unliftio-core
-       ];
-       testHaskellDepends = [
-         aeson base bytestring containers fast-logger hspec
-         hspec-expectations hspec-expectations-lifted http-api-data HUnit
-         monad-logger path-pieces persistent persistent-qq persistent-test
-         QuickCheck quickcheck-instances resourcet text time transformers
-         unliftio unliftio-core unordered-containers vector
-       ];
-       description = "Backend for the persistent library using postgresql";
-       license = lib.licenses.mit;
-     }) {};
-
-  "persistent-postgresql_2_13_1_0" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
-     , conduit, containers, fast-logger, hspec, hspec-expectations
-     , hspec-expectations-lifted, http-api-data, HUnit, monad-logger
-     , mtl, path-pieces, persistent, persistent-qq, persistent-test
-     , postgresql-libpq, postgresql-simple, QuickCheck
-     , quickcheck-instances, resource-pool, resourcet
-     , string-conversions, text, time, transformers, unliftio
-     , unliftio-core, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "persistent-postgresql";
        version = "2.13.1.0";
        sha256 = "05bj3b7kdwaba3szrrsmafxr6vcnvdhq20jk5xx348jnf2flkw0i";
        isLibrary = true;
···
        ];
        description = "Backend for the persistent library using postgresql";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "persistent-protobuf" = callPackage
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-examples-array";
-       version = "0.11.3.0";
-       sha256 = "0k7rczkfbgf2pgk5njb5dc8j27fag5b0fv1nrb97r6nnqb17fs6w";
+       version = "0.12.1.0";
+       sha256 = "1scjdf6k36vqd4cdnsqwwhbb97dsicarrc320w4ybikr1rk42phd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-generalized-examples-array";
-       version = "0.11.3.0";
-       sha256 = "0wcphr3n5l1zlpmihy187xkjssq1p5zgfxxq7063ps8x52zfghzi";
+       version = "0.12.1.0";
+       sha256 = "0wp5gpshmq5kr39glvfmc0b5jg8p1i146svjxh6flgkfn7yyr6rf";
        libraryHaskellDepends = [
          base heaps mmsyn2-array mmsyn3 parallel
          phonetic-languages-constraints-array
···
      }:
      mkDerivation {
        pname = "polysemy-conc";
-       version = "0.2.0.0";
-       sha256 = "16ywldx4p76s64qfwlm7swdzz8kcvzzrflz7cprlq2pc1fc6bf7x";
+       version = "0.3.0.0";
+       sha256 = "0lg68nwasak6yvzy1wgjlydmvbj5cwyadmgi14vw4df6wnh17wwq";
        libraryHaskellDepends = [
          async base containers polysemy polysemy-time relude stm stm-chans
          string-interpolate template-haskell text time unagi-chan unix
···
      }:
      mkDerivation {
        pname = "polysemy-log";
-       version = "0.2.2.3";
-       sha256 = "1a2l9zspg0ajbgq0vqbxz399fcbr53sydhk71j8ii8y79pm1b3z4";
+       version = "0.2.2.4";
+       sha256 = "17jzmiqqwq44zvg1m6w0m3ishkwfcz66gagijwkqbrk1rcn3bmc0";
        libraryHaskellDepends = [
          ansi-terminal base polysemy polysemy-conc polysemy-time relude
          string-interpolate template-haskell text time
···
      }:
      mkDerivation {
        pname = "polysemy-log-co";
-       version = "0.2.2.3";
-       sha256 = "04gx2irrj59rs0jm0mrc3mka3xk46qx9z5mwad4akh0kmpsl09rz";
+       version = "0.2.2.4";
+       sha256 = "0ph24p6b7m4icq65kc6ws8ih9p1arpq9zx3abwzsq2f4dcgmibhx";
        libraryHaskellDepends = [
          base co-log co-log-core co-log-polysemy polysemy polysemy-conc
          polysemy-log polysemy-time relude text time
···
      }:
      mkDerivation {
        pname = "polysemy-log-di";
-       version = "0.2.2.3";
-       sha256 = "050y12sgd4j3487q01bczsjsn1dask507gpz1i8fgl958vr0ywwj";
+       version = "0.2.2.4";
+       sha256 = "1m2zssg54lx0drc8vw0jjhdl74pks6752am8467xv3qawndm71kg";
        libraryHaskellDepends = [
          base di-polysemy polysemy polysemy-conc polysemy-log polysemy-time
          relude text time
···
      }:
      mkDerivation {
        pname = "portray";
-       version = "0.1.0.0";
-       sha256 = "06czmcf00rdhj7f5xyrllkjmbqsvgv7j9bxvr0jn4cipvnd8lq7c";
+       version = "0.2.0";
+       sha256 = "1kzzvwqphlg1dmd486ijkv6vsqmxnp8h05mwc8590yjxdln5vzdw";
        libraryHaskellDepends = [ base containers text wrapped ];
        testHaskellDepends = [
          base containers HUnit test-framework test-framework-hunit text
···
     ({ mkDerivation, base, containers, dlist, portray, text, wrapped }:
      mkDerivation {
        pname = "portray-diff";
-       version = "0.1.0.0";
-       sha256 = "16lb8gcvdqbnjz72znjcm5c8zrydnjwwmqr9hm4bq3vay4f2dapm";
+       version = "0.1.0.1";
+       sha256 = "1da884cj865q6g1bd1fhcazyl1nzxb0pk2nvhcpp4iqkjvhyd8hw";
        libraryHaskellDepends = [
          base containers dlist portray text wrapped
        ];
···
      }:
      mkDerivation {
        pname = "portray-pretty";
-       version = "0.1.0.0";
-       sha256 = "1pz42y8b0psks8p9yd18ns0149q9m41ym4ah28zcg1arl36b3bf4";
+       version = "0.1.0.2";
+       sha256 = "1gh50r77yz1l8qkhdz96bds2l0d5zi75fkir27x3si406h7sdic9";
        libraryHaskellDepends = [ base portray portray-diff pretty text ];
        testHaskellDepends = [
          base HUnit portray portray-diff pretty test-framework
          test-framework-hunit text
        ];
-       description = "\"pretty\" integration for \"portray\"";
+       description = "A portray backend using the pretty package";
+       license = lib.licenses.asl20;
+     }) {};
+
+  "portray-prettyprinter" = callPackage
+    ({ mkDerivation, base, HUnit, portray, portray-diff, prettyprinter
+     , prettyprinter-ansi-terminal, QuickCheck, test-framework
+     , test-framework-hunit, test-framework-quickcheck2, text
+     }:
+     mkDerivation {
+       pname = "portray-prettyprinter";
+       version = "0.2.0";
+       sha256 = "16g55vjcfawx1jxmgy3zgl6bqv67h831z00912fbfh878s1s24ic";
+       libraryHaskellDepends = [
+         base portray portray-diff prettyprinter prettyprinter-ansi-terminal
+         text
+       ];
+       testHaskellDepends = [
+         base HUnit portray portray-diff prettyprinter
+         prettyprinter-ansi-terminal QuickCheck test-framework
+         test-framework-hunit test-framework-quickcheck2 text
+       ];
+       description = "A portray backend using the prettyprinter package";
        license = lib.licenses.asl20;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "postgresql-query";
-       version = "3.8.2";
-       sha256 = "1vcfs5yg9ab0axdm661kjpsfxii7h3s8rrq38kgc68vhr280m110";
+       version = "3.9.0";
+       sha256 = "1520crprhdnan7w5qm9h42r6cxz4v6zffwwfvybzwpczj2g3laa6";
        libraryHaskellDepends = [
          aeson attoparsec base blaze-builder bytestring containers
          data-default exceptions file-embed haskell-src-meta hreader hset
···
        license = lib.licenses.bsd2;
      }) {};
 
+  "prettyprinter_1_7_1" = callPackage
+    ({ mkDerivation, ansi-wl-pprint, base, base-compat, bytestring
+     , containers, deepseq, doctest, gauge, mtl, pgp-wordlist
+     , QuickCheck, quickcheck-instances, random, tasty, tasty-hunit
+     , tasty-quickcheck, text, transformers
+     }:
+     mkDerivation {
+       pname = "prettyprinter";
+       version = "1.7.1";
+       sha256 = "0i8b3wjjpdvp5b857j065jwyrpgcnzgk75imrj7i3yhl668acvjy";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base text ];
+       testHaskellDepends = [
+         base bytestring doctest pgp-wordlist QuickCheck
+         quickcheck-instances tasty tasty-hunit tasty-quickcheck text
+       ];
+       benchmarkHaskellDepends = [
+         ansi-wl-pprint base base-compat containers deepseq gauge mtl
+         QuickCheck random text transformers
+       ];
+       description = "A modern, easy to use, well-documented, extensible pretty-printer";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "prettyprinter-ansi-terminal" = callPackage
     ({ mkDerivation, ansi-terminal, base, base-compat, containers
      , deepseq, doctest, gauge, prettyprinter, QuickCheck, text
···
        license = lib.licenses.bsd2;
      }) {};
 
+  "prettyprinter-ansi-terminal_1_1_3" = callPackage
+    ({ mkDerivation, ansi-terminal, base, base-compat, containers
+     , deepseq, doctest, gauge, prettyprinter, QuickCheck, text
+     }:
+     mkDerivation {
+       pname = "prettyprinter-ansi-terminal";
+       version = "1.1.3";
+       sha256 = "1cqxbcmy9ykk4pssq5hp6h51g2h547zfz549awh0c1fni8q3jdw1";
+       libraryHaskellDepends = [ ansi-terminal base prettyprinter text ];
+       testHaskellDepends = [ base doctest ];
+       benchmarkHaskellDepends = [
+         base base-compat containers deepseq gauge prettyprinter QuickCheck
+         text
+       ];
+       description = "ANSI terminal backend for the »prettyprinter« package";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "prettyprinter-compat-annotated-wl-pprint" = callPackage
     ({ mkDerivation, base, prettyprinter, text }:
      mkDerivation {
···
        license = lib.licenses.bsd2;
      }) {};
 
+  "prettyprinter-compat-ansi-wl-pprint_1_0_2" = callPackage
+    ({ mkDerivation, base, prettyprinter, prettyprinter-ansi-terminal
+     , text
+     }:
+     mkDerivation {
+       pname = "prettyprinter-compat-ansi-wl-pprint";
+       version = "1.0.2";
+       sha256 = "0mcy0621lx0zmc2csdq348r21f932f2w51y62jzyz4cby58p5ch5";
+       libraryHaskellDepends = [
+         base prettyprinter prettyprinter-ansi-terminal text
+       ];
+       description = "Drop-in compatibility package to migrate from »ansi-wl-pprint« to »prettyprinter«";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "prettyprinter-compat-wl-pprint" = callPackage
     ({ mkDerivation, base, prettyprinter, text }:
      mkDerivation {
···
        license = lib.licenses.bsd2;
      }) {};
 
+  "prettyprinter-compat-wl-pprint_1_0_1" = callPackage
+    ({ mkDerivation, base, prettyprinter, text }:
+     mkDerivation {
+       pname = "prettyprinter-compat-wl-pprint";
+       version = "1.0.1";
+       sha256 = "0ffrbh79da9ihn3lbk9vq9329sdhddf6ccnag1k148z3ividxc63";
+       libraryHaskellDepends = [ base prettyprinter text ];
+       description = "Drop-in compatibility package to migrate from »wl-pprint« to »prettyprinter«";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "prettyprinter-convert-ansi-wl-pprint" = callPackage
     ({ mkDerivation, ansi-terminal, ansi-wl-pprint, base, doctest
      , prettyprinter, prettyprinter-ansi-terminal, text
···
        testHaskellDepends = [ base doctest ];
        description = "Converter from »ansi-wl-pprint« documents to »prettyprinter«-based ones";
        license = lib.licenses.bsd2;
+     }) {};
+
+  "prettyprinter-convert-ansi-wl-pprint_1_1_2" = callPackage
+    ({ mkDerivation, ansi-terminal, ansi-wl-pprint, base, doctest
+     , prettyprinter, prettyprinter-ansi-terminal, text
+     }:
+     mkDerivation {
+       pname = "prettyprinter-convert-ansi-wl-pprint";
+       version = "1.1.2";
+       sha256 = "0kfrwnaldx0cyr3mwx3ys14bl58nfjpxkzrfi6152gvfh8ly44c6";
+       libraryHaskellDepends = [
+         ansi-terminal ansi-wl-pprint base prettyprinter
+         prettyprinter-ansi-terminal text
+       ];
+       testHaskellDepends = [ base doctest ];
+       description = "Converter from »ansi-wl-pprint« documents to »prettyprinter«-based ones";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "prettyprinter-graphviz" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "rank2classes_1_4_3" = callPackage
+    ({ mkDerivation, base, Cabal, cabal-doctest, distributive, doctest
+     , markdown-unlit, tasty, tasty-hunit, template-haskell
+     , transformers
+     }:
+     mkDerivation {
+       pname = "rank2classes";
+       version = "1.4.3";
+       sha256 = "03sla9gsg23ma8xxm3mndc9wrh715lsgksxc34rxkmjbp9vxlccj";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         base distributive template-haskell transformers
+       ];
+       testHaskellDepends = [
+         base distributive doctest tasty tasty-hunit
+       ];
+       testToolDepends = [ markdown-unlit ];
+       description = "standard type constructor class hierarchy, only with methods of rank 2 types";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "rapid" = callPackage
     ({ mkDerivation, async, base, containers, foreign-store, stm }:
      mkDerivation {
···
 
   "reactive-banana" = callPackage
     ({ mkDerivation, base, containers, hashable, HUnit, pqueue
-     , psqueues, semigroups, test-framework, test-framework-hunit
+     , psqueues, semigroups, test-framework, test-framework-hunit, these
      , transformers, unordered-containers, vault
      }:
      mkDerivation {
        pname = "reactive-banana";
-       version = "1.2.1.0";
-       sha256 = "18vm9zxr59s8n5bmqx3pg8jbaay6vlz1icnf9p1vnq8bvsb6svyc";
+       version = "1.2.2.0";
+       sha256 = "0zqvswqgisfj1hvwp9r53b91h4062d2afrw4ybcdr7d047ba9icp";
        libraryHaskellDepends = [
-         base containers hashable pqueue semigroups transformers
+         base containers hashable pqueue semigroups these transformers
          unordered-containers vault
        ];
        testHaskellDepends = [
          base containers hashable HUnit pqueue psqueues semigroups
-         test-framework test-framework-hunit transformers
+         test-framework test-framework-hunit these transformers
          unordered-containers vault
        ];
        description = "Library for functional reactive programming (FRP)";
···
     ({ mkDerivation, base, composition-prelude }:
      mkDerivation {
        pname = "recursion";
-       version = "2.2.4.4";
-       sha256 = "09zssx2yqz22hm678ik5zz2zkanzfazcyfqmwlxc9mk6gxxdy6ia";
+       version = "2.2.5.0";
+       sha256 = "08b72mbg187v27i5pq89zgn63ldnh47nq0hyg2xyh6j58d9f7g4v";
        libraryHaskellDepends = [ base composition-prelude ];
        description = "A recursion schemes library for Haskell";
        license = lib.licenses.bsd3;
···
 
   "reflex-vty" = callPackage
     ({ mkDerivation, base, bimap, containers, data-default
-     , dependent-map, dependent-sum, exception-transformers, mtl
-     , primitive, ref-tf, reflex, stm, text, text-icu, time
-     , transformers, vty
+     , dependent-map, dependent-sum, exception-transformers, extra
+     , hspec, mmorph, mtl, ordered-containers, primitive, ref-tf, reflex
+     , stm, text, time, transformers, vty
      }:
      mkDerivation {
        pname = "reflex-vty";
-       version = "0.1.4.2";
-       sha256 = "07fjw95w8ahllbs1zp215apck01abcrv4sshid8z6972g7n7392r";
+       version = "0.2.0.0";
+       sha256 = "1l7ksf11352llcy6fzap3hsq9vgv99gs948ha5i1vvz9bjvn2qwg";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          base bimap containers data-default dependent-map dependent-sum
-         exception-transformers mtl primitive ref-tf reflex stm text
-         text-icu time transformers vty
+         exception-transformers mmorph mtl ordered-containers primitive
+         ref-tf reflex stm text time transformers vty
        ];
        executableHaskellDepends = [
          base containers reflex text time transformers vty
        ];
+       testHaskellDepends = [ base containers extra hspec reflex text ];
        description = "Reflex FRP host and widgets for VTY applications";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
        ];
        description = "PCRE Backend for \"Text.Regex\" (regex-base)";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "regex-pcre-builtin_0_95_2_3_8_44" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers, regex-base
+     , text
+     }:
+     mkDerivation {
+       pname = "regex-pcre-builtin";
+       version = "0.95.2.3.8.44";
+       sha256 = "0pn55ssrwr05c9sa9jvp0knvzjksz04wn3pmzf5dz4xgbyjadkna";
+       libraryHaskellDepends = [
+         array base bytestring containers regex-base text
+       ];
+       description = "PCRE Backend for \"Text.Regex\" (regex-base)";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "regex-pcre-text" = callPackage
···
      }:
      mkDerivation {
        pname = "rhbzquery";
-       version = "0.4.3";
-       sha256 = "13brargymd1c9b0csaprj85qdqg98bzj3z2smbb0v66myj48v6fp";
-       isLibrary = false;
-       isExecutable = true;
-       executableHaskellDepends = [
-         base bytestring config-ini directory email-validate extra filepath
-         http-types optparse-applicative simple-cmd simple-cmd-args text
-       ];
-       testHaskellDepends = [ base simple-cmd ];
-       description = "Bugzilla query tool";
-       license = lib.licenses.gpl2Only;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "rhbzquery_0_4_4" = callPackage
-    ({ mkDerivation, base, bytestring, config-ini, directory
-     , email-validate, extra, filepath, http-types, optparse-applicative
-     , simple-cmd, simple-cmd-args, text
-     }:
-     mkDerivation {
-       pname = "rhbzquery";
        version = "0.4.4";
        sha256 = "00175smanmcr6k8b83kj7mif47jggxn0pvy64yjc4ikpbw822c2q";
        isLibrary = false;
···
      }:
      mkDerivation {
        pname = "rle";
-       version = "0.1.0.0";
-       sha256 = "0d1y0s38dh0bx16zd5gadlckx2k5wa6g8xn350gimihlpvwfc5m4";
+       version = "0.1.0.1";
+       sha256 = "05rbhm0lxrq7vdbq9s0q21m0f0hlzmknljmampcmdjnwbl4nvf3d";
        libraryHaskellDepends = [
          base cereal deepseq portray portray-diff wrapped
        ];
···
      }:
      mkDerivation {
        pname = "sajson";
-       version = "0.1.0.0";
-       sha256 = "0979skxh82s0q56smp8vlg0cj1k7qj1y37ivksl3spw9dspbpcs1";
+       version = "0.2.0.0";
+       sha256 = "0shqik98wnyfxb6qmqbbm6ap3108kbm3f4zrswg2nc6kkxc1dwkm";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "sandwich";
-       version = "0.1.0.8";
-       sha256 = "0b0k01r85wiaxn264ax3xva8a2gy7vv9qnig2fxyr42zdkm289jy";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson ansi-terminal async base brick bytestring colour containers
-         directory exceptions filepath free haskell-src-exts lens
-         lifted-async microlens microlens-th monad-control monad-logger mtl
-         optparse-applicative pretty-show process safe safe-exceptions stm
-         string-interpolate template-haskell text time transformers
-         transformers-base unix unliftio-core vector vty
-       ];
-       executableHaskellDepends = [
-         aeson ansi-terminal async base brick bytestring colour containers
-         directory exceptions filepath free haskell-src-exts lens
-         lifted-async microlens microlens-th monad-control monad-logger mtl
-         optparse-applicative pretty-show process safe safe-exceptions stm
-         string-interpolate template-haskell text time transformers
-         transformers-base unix unliftio-core vector vty
-       ];
-       testHaskellDepends = [
-         aeson ansi-terminal async base brick bytestring colour containers
-         directory exceptions filepath free haskell-src-exts lens
-         lifted-async microlens microlens-th monad-control monad-logger mtl
-         optparse-applicative pretty-show process safe safe-exceptions stm
-         string-interpolate template-haskell text time transformers
-         transformers-base unix unliftio-core vector vty
-       ];
-       description = "Yet another test framework for Haskell";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "sandwich_0_1_0_9" = callPackage
-    ({ mkDerivation, aeson, ansi-terminal, async, base, brick
-     , bytestring, colour, containers, directory, exceptions, filepath
-     , free, haskell-src-exts, lens, lifted-async, microlens
-     , microlens-th, monad-control, monad-logger, mtl
-     , optparse-applicative, pretty-show, process, safe, safe-exceptions
-     , stm, string-interpolate, template-haskell, text, time
-     , transformers, transformers-base, unix, unliftio-core, vector, vty
-     }:
-     mkDerivation {
-       pname = "sandwich";
        version = "0.1.0.9";
        sha256 = "07knl1kpbg85df08q07byjid26bkgk514pngkf58h9wy4y5l5il7";
        isLibrary = true;
···
        ];
        description = "Yet another test framework for Haskell";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sandwich-quickcheck" = callPackage
-    ({ mkDerivation, base, brick, free, monad-control, QuickCheck
-     , safe-exceptions, sandwich, string-interpolate, text, time
-     }:
-     mkDerivation {
-       pname = "sandwich-quickcheck";
-       version = "0.1.0.5";
-       sha256 = "03z8g5q3yxfpazbwi56ji9554z3l2ac776mzz06xsb7cha3kf7lw";
-       libraryHaskellDepends = [
-         base brick free monad-control QuickCheck safe-exceptions sandwich
-         string-interpolate text time
-       ];
-       testHaskellDepends = [
-         base brick free monad-control QuickCheck safe-exceptions sandwich
-         string-interpolate text time
-       ];
-       description = "Sandwich integration with QuickCheck";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "sandwich-quickcheck_0_1_0_6" = callPackage
     ({ mkDerivation, base, free, monad-control, mtl, QuickCheck
      , safe-exceptions, sandwich, text, time
      }:
···
        ];
        description = "Sandwich integration with QuickCheck";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sandwich-slack" = callPackage
···
      }:
      mkDerivation {
        pname = "sandwich-slack";
-       version = "0.1.0.4";
-       sha256 = "1l296q3lxafj3gd7pr6n6qrvcb4zdkncsj2z6ra6q0qfw465jaqk";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson base bytestring containers lens lens-aeson monad-logger mtl
-         safe safe-exceptions sandwich stm string-interpolate text time
-         vector wreq
-       ];
-       executableHaskellDepends = [
-         aeson base bytestring containers lens lens-aeson monad-logger mtl
-         safe safe-exceptions sandwich stm string-interpolate text time
-         vector wreq
-       ];
-       testHaskellDepends = [
-         aeson base bytestring containers lens lens-aeson monad-logger mtl
-         safe safe-exceptions sandwich stm string-interpolate text time
-         vector wreq
-       ];
-       description = "Sandwich integration with Slack";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "sandwich-slack_0_1_0_6" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, lens
-     , lens-aeson, monad-logger, mtl, safe, safe-exceptions, sandwich
-     , stm, string-interpolate, text, time, vector, wreq
-     }:
-     mkDerivation {
-       pname = "sandwich-slack";
        version = "0.1.0.6";
        sha256 = "1ck4amyxcf2qpgx3qpbg2f137bi6px83k72bspi2kfn0nnx8gja9";
        isLibrary = true;
···
        ];
        description = "Sandwich integration with Slack";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sandwich-webdriver" = callPackage
···
        license = lib.licenses.mit;
      }) {inherit (pkgs) SDL2; inherit (pkgs) SDL2_gfx;};
 
+  "sdl2-gfx_0_3_0_0" = callPackage
+    ({ mkDerivation, base, lifted-base, monad-control, SDL2, sdl2
+     , SDL2_gfx, template-haskell, vector
+     }:
+     mkDerivation {
+       pname = "sdl2-gfx";
+       version = "0.3.0.0";
+       sha256 = "0r9m54ffkp1dv2ffz9i9318qhvpinc76iih7vg1dwq3siwgpxaxw";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base lifted-base monad-control sdl2 template-haskell vector
+       ];
+       librarySystemDepends = [ SDL2_gfx ];
+       libraryPkgconfigDepends = [ SDL2 SDL2_gfx ];
+       executableHaskellDepends = [ base sdl2 vector ];
+       executableSystemDepends = [ SDL2_gfx ];
+       executablePkgconfigDepends = [ SDL2 SDL2_gfx ];
+       description = "Haskell bindings to SDL2_gfx";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) SDL2; inherit (pkgs) SDL2_gfx;};
+
   "sdl2-image" = callPackage
     ({ mkDerivation, base, bytestring, SDL2, sdl2, SDL2_image
      , template-haskell, text, transformers
···
        license = lib.licenses.mit;
      }) {inherit (pkgs) SDL2; inherit (pkgs) SDL2_image;};
 
+  "sdl2-image_2_1_0_0" = callPackage
+    ({ mkDerivation, base, bytestring, SDL2, sdl2, SDL2_image
+     , template-haskell, text
+     }:
+     mkDerivation {
+       pname = "sdl2-image";
+       version = "2.1.0.0";
+       sha256 = "03cjlmj844gmfxqn9mp8333hpsg227kaipgs6g68xwg0cvch696j";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring sdl2 template-haskell text
+       ];
+       librarySystemDepends = [ SDL2_image ];
+       libraryPkgconfigDepends = [ SDL2 SDL2_image ];
+       executableHaskellDepends = [ base sdl2 text ];
+       executableSystemDepends = [ SDL2_image ];
+       executablePkgconfigDepends = [ SDL2 SDL2_image ];
+       description = "Haskell bindings to SDL2_image";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) SDL2; inherit (pkgs) SDL2_image;};
+
   "sdl2-mixer" = callPackage
     ({ mkDerivation, base, bytestring, data-default-class, lifted-base
      , monad-control, sdl2, SDL2_mixer, template-haskell, vector
···
        platforms = [
          "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
        ];
+     }) {inherit (pkgs) SDL2_mixer;};
+
+  "sdl2-mixer_1_2_0_0" = callPackage
+    ({ mkDerivation, base, bytestring, data-default-class, lifted-base
+     , monad-control, sdl2, SDL2_mixer, template-haskell, vector
+     }:
+     mkDerivation {
+       pname = "sdl2-mixer";
+       version = "1.2.0.0";
+       sha256 = "16fgnxq2nmifbz3lrr7dn1qj57l5f2kzv124lya1fjaxmwk1h52q";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring data-default-class lifted-base monad-control sdl2
+         template-haskell vector
+       ];
+       librarySystemDepends = [ SDL2_mixer ];
+       libraryPkgconfigDepends = [ SDL2_mixer ];
+       executableHaskellDepends = [ base data-default-class sdl2 vector ];
+       executableSystemDepends = [ SDL2_mixer ];
+       executablePkgconfigDepends = [ SDL2_mixer ];
+       description = "Haskell bindings to SDL2_mixer";
+       license = lib.licenses.bsd3;
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
+       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) SDL2_mixer;};
 
   "sdl2-sprite" = callPackage
···
        pname = "servant-benchmark";
        version = "0.1.2.0";
        sha256 = "0lqqk410nx48g895pfxkbbk85b1ijs4bfl9zr2li2p7wwwc4gyi9";
-       revision = "1";
-       editedCabalFile = "1zzprj7pw7fzyscg4n9g023c47bb6fywq5b11krazz3vyynh53cc";
+       revision = "2";
+       editedCabalFile = "1xg1w1cy44a06sb1x2j5crid9splfgay8cj20bpjdnv5sj510gd2";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring case-insensitive http-media
          http-types QuickCheck servant text yaml
···
      }:
      mkDerivation {
        pname = "shake";
-       version = "0.19.5";
-       sha256 = "105agfvn75czyq3jbmppybv776njlsqc7k4m1xnx0n78qjmcnpb9";
-       isLibrary = true;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         base binary bytestring deepseq directory extra filepath filepattern
-         hashable heaps js-dgtable js-flot js-jquery primitive process
-         random time transformers unix unordered-containers utf8-string
-       ];
-       executableHaskellDepends = [
-         base binary bytestring deepseq directory extra filepath filepattern
-         hashable heaps js-dgtable js-flot js-jquery primitive process
-         random time transformers unix unordered-containers utf8-string
-       ];
-       testHaskellDepends = [
-         base binary bytestring deepseq directory extra filepath filepattern
-         hashable heaps js-dgtable js-flot js-jquery primitive process
-         QuickCheck random time transformers unix unordered-containers
-         utf8-string
-       ];
-       description = "Build system library, like Make, but more accurate dependencies";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "shake_0_19_6" = callPackage
-    ({ mkDerivation, base, binary, bytestring, deepseq, directory
-     , extra, filepath, filepattern, hashable, heaps, js-dgtable
-     , js-flot, js-jquery, primitive, process, QuickCheck, random, time
-     , transformers, unix, unordered-containers, utf8-string
-     }:
-     mkDerivation {
-       pname = "shake";
        version = "0.19.6";
        sha256 = "0hnm3h1ni4jq73a7b7yxhbg9wm8mrjda5kmkpnmclynnpwvvi7bx";
        isLibrary = true;
···
        ];
        description = "Build system library, like Make, but more accurate dependencies";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "shake-ats" = callPackage
···
      }:
      mkDerivation {
        pname = "shake-bench";
-       version = "0.1.0.1";
-       sha256 = "0sjxxkv6ji8zlgxx8mxsgwzphcl26g1syy8ky0m8kqahysaydfx7";
+       version = "0.1.0.2";
+       sha256 = "14p9887qa2i34pbwfg2v2zzvdsbcpzf1d0mr0y2rzjy703356xsm";
        libraryHaskellDepends = [
          aeson base Chart Chart-diagrams diagrams-contrib diagrams-core
          diagrams-lib diagrams-svg directory extra filepath shake text
···
        pname = "short-vec";
        version = "0.1.0.0";
        sha256 = "0w651jipwxh7k4ng5rvq507br4347hzy8x8c47c1g7haryj80gzq";
+       revision = "2";
+       editedCabalFile = "1w56zmw085509grvk5ddlrv12pqpzfpmdprjd44lv4sgzv09bzfk";
        libraryHaskellDepends = [
          adjunctions base data-default-class deepseq distributive fin-int
          indexed-traversable integer-gmp portray portray-diff QuickCheck
···
 
   "simplexmq" = callPackage
     ({ mkDerivation, ansi-terminal, asn1-encoding, asn1-types, async
-     , attoparsec, base, base64-bytestring, bytestring, containers
-     , cryptonite, cryptostore, directory, filepath, generic-random
-     , hspec, hspec-core, HUnit, ini, iso8601-time, memory, mtl, network
+     , attoparsec, base, base64-bytestring, bytestring, composition
+     , constraints, containers, cryptonite, cryptostore, direct-sqlite
+     , directory, file-embed, filepath, generic-random, hspec
+     , hspec-core, HUnit, ini, iso8601-time, memory, mtl, network
      , network-transport, optparse-applicative, QuickCheck, random
      , simple-logger, sqlite-simple, stm, template-haskell, text, time
      , timeit, transformers, unliftio, unliftio-core, websockets, x509
      }:
      mkDerivation {
        pname = "simplexmq";
-       version = "0.3.2";
-       sha256 = "1bxg91ycmpa8762v5vdviqvyzkfap4iv9plnr7gcibf8vsd39qxl";
+       version = "0.4.1";
+       sha256 = "0bqpjvcxk8fij0bvdp8abpaca17hwkjrya5fhiwzjsrs48c5w0by";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          ansi-terminal asn1-encoding asn1-types async attoparsec base
-         base64-bytestring bytestring containers cryptonite directory
-         filepath generic-random iso8601-time memory mtl network
-         network-transport QuickCheck random simple-logger sqlite-simple stm
-         template-haskell text time transformers unliftio unliftio-core
-         websockets x509
+         base64-bytestring bytestring composition constraints containers
+         cryptonite direct-sqlite directory file-embed filepath
+         generic-random iso8601-time memory mtl network network-transport
+         QuickCheck random simple-logger sqlite-simple stm template-haskell
+         text time transformers unliftio unliftio-core websockets x509
        ];
        executableHaskellDepends = [
          ansi-terminal asn1-encoding asn1-types async attoparsec base
-         base64-bytestring bytestring containers cryptonite cryptostore
-         directory filepath generic-random ini iso8601-time memory mtl
-         network network-transport optparse-applicative QuickCheck random
+         base64-bytestring bytestring composition constraints containers
+         cryptonite cryptostore direct-sqlite directory file-embed filepath
+         generic-random ini iso8601-time memory mtl network
+         network-transport optparse-applicative QuickCheck random
          simple-logger sqlite-simple stm template-haskell text time
          transformers unliftio unliftio-core websockets x509
        ];
        testHaskellDepends = [
          ansi-terminal asn1-encoding asn1-types async attoparsec base
-         base64-bytestring bytestring containers cryptonite directory
-         filepath generic-random hspec hspec-core HUnit iso8601-time memory
-         mtl network network-transport QuickCheck random simple-logger
+         base64-bytestring bytestring composition constraints containers
+         cryptonite direct-sqlite directory file-embed filepath
+         generic-random hspec hspec-core HUnit iso8601-time memory mtl
+         network network-transport QuickCheck random simple-logger
          sqlite-simple stm template-haskell text time timeit transformers
          unliftio unliftio-core websockets x509
        ];
···
        pname = "sint";
        version = "0.1.0.0";
        sha256 = "1gqd5m5r3i9qvszzb1ljjip5c7bnsp5nblmghg4lhbpfrs7r87gf";
+       revision = "1";
+       editedCabalFile = "0z0bm4hj5w0xpasvdlczabd6my5ms1xfzyg1yg9fwc5llbi2z34p";
        libraryHaskellDepends = [ base portray portray-diff ];
        testHaskellDepends = [
          base portray portray-diff QuickCheck test-framework
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "slick_1_1_2_2" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, directory, extra
+     , mustache, pandoc, shake, text, unordered-containers
+     }:
+     mkDerivation {
+       pname = "slick";
+       version = "1.1.2.2";
+       sha256 = "0q6q496cvrsc4gnksihib0dr80cjg0n9vy69h2ani2ax0g75fzqd";
+       libraryHaskellDepends = [
+         aeson base bytestring directory extra mustache pandoc shake text
+         unordered-containers
+       ];
+       description = "A quick & easy static site builder built with shake and pandoc";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "slidemews" = callPackage
     ({ mkDerivation, aeson, base, bytestring, MonadCatchIO-transformers
      , mtl, pandoc, snap-core, snap-server, utf8-string
···
        license = lib.licenses.gpl3Plus;
      }) {};
 
-  "slynx_0_6_0_0" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, containers
+  "slynx_0_6_1_0" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
      , elynx-markov, elynx-seq, elynx-tools, elynx-tree, hmatrix
      , mwc-random, optparse-applicative, statistics, text, transformers
      , vector
      }:
      mkDerivation {
        pname = "slynx";
-       version = "0.6.0.0";
-       sha256 = "0jk3l7nlz0s57x952qcn1yj6fdfds01flcz6xiykpjwbyjm0fq81";
+       version = "0.6.1.0";
+       sha256 = "15wjlxmhwrk3fj6hzmc9rpgc7qnkld028z79h9a5k6vs90hgcwlx";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         attoparsec base bytestring containers elynx-markov elynx-seq
+         aeson attoparsec base bytestring containers elynx-markov elynx-seq
          elynx-tools elynx-tree hmatrix mwc-random optparse-applicative
          statistics text transformers vector
        ];
···
      }:
      mkDerivation {
        pname = "snaplet-customauth";
-       version = "0.2";
-       sha256 = "10brxk6fpblbc58wjfhp3frx6r4d13iqz704v804r2hhsj35rkfz";
+       version = "0.2.1";
+       sha256 = "04bnkw268klv06w0hbgdcxmdcyyg7bjxfhqfx7ymbl41a887h2zb";
        libraryHaskellDepends = [
          aeson base base64-bytestring binary binary-instances bytestring
          bytestring-show configurator containers errors heist hoauth2
···
      }) {};
 
   "strict-list" = callPackage
-    ({ mkDerivation, base, hashable, QuickCheck, quickcheck-instances
-     , rerebase, semigroupoids, tasty, tasty-hunit, tasty-quickcheck
-     }:
-     mkDerivation {
-       pname = "strict-list";
-       version = "0.1.5";
-       sha256 = "06mv208bspfl2mh1razi6af3fri8w7f5p3klkc3b9yx5ddv3hwxs";
-       libraryHaskellDepends = [ base hashable semigroupoids ];
-       testHaskellDepends = [
-         QuickCheck quickcheck-instances rerebase tasty tasty-hunit
-         tasty-quickcheck
-       ];
-       description = "Strict linked list";
-       license = lib.licenses.mit;
-     }) {};
-
-  "strict-list_0_1_6" = callPackage
     ({ mkDerivation, base, deepseq, hashable, QuickCheck
      , quickcheck-instances, rerebase, semigroupoids, tasty, tasty-hunit
      , tasty-quickcheck
···
        ];
        description = "Strict linked list";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "strict-optics" = callPackage
···
      }:
      mkDerivation {
        pname = "stylish-haskell";
-       version = "0.12.2.0";
-       sha256 = "074nr4yg3yqjshnwxxrbs0shsjphbrmacz92ysyw8gnppq1z538c";
+       version = "0.13.0.0";
+       sha256 = "0x9w3zh1lzp6l5xj3mynnlr0fzb5mbv0wwpfxp8fr6bk0jcrzjwf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "suitable";
        version = "0.1.1";
        sha256 = "1pvw7zgvfr0z2gjy224gd92ayh20j3v97rdlqmq6k6g4yabdpgci";
+       revision = "1";
+       editedCabalFile = "10yinlpa6q6jvpsnazpbgqnpg0d8va7lkfqafpym9gsgcn9f6xf4";
        libraryHaskellDepends = [ base containers ];
        description = "Abstract over the constraints on the parameters to type constructors";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, base, generics-sop, profunctors, vector }:
      mkDerivation {
        pname = "summer";
-       version = "0.3.7.0";
-       sha256 = "13hcvr8rpl6ji76r52zk5dq60khf9rbks3iisj0y6b6lzz2jpf76";
+       version = "0.3.7.1";
+       sha256 = "0g745i3ms1i6qz428aln33hczvgn1zg79xd0n94h696x397d7zs5";
        libraryHaskellDepends = [ base generics-sop profunctors vector ];
        testHaskellDepends = [ base ];
        description = "An implementation of extensible products and sums";
···
        license = lib.licenses.mit;
      }) {};
 
+  "tasty-silver_3_2_3" = callPackage
+    ({ mkDerivation, ansi-terminal, async, base, bytestring, containers
+     , deepseq, directory, filepath, mtl, optparse-applicative, process
+     , process-extras, regex-tdfa, silently, stm, tagged, tasty
+     , tasty-hunit, temporary, text, transformers
+     }:
+     mkDerivation {
+       pname = "tasty-silver";
+       version = "3.2.3";
+       sha256 = "0nvh2k8iqqkanmp7lpwd3asimyarzisly8wavbdahcxryn0j4xb7";
+       libraryHaskellDepends = [
+         ansi-terminal async base bytestring containers deepseq directory
+         filepath mtl optparse-applicative process process-extras regex-tdfa
+         stm tagged tasty temporary text
+       ];
+       testHaskellDepends = [
+         base directory filepath process silently tasty tasty-hunit
+         temporary transformers
+       ];
+       description = "A fancy test runner, including support for golden tests";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "tasty-smallcheck" = callPackage
     ({ mkDerivation, base, optparse-applicative, smallcheck, tagged
      , tasty
···
      }:
      mkDerivation {
        pname = "ten";
-       version = "0.1.0.0";
-       sha256 = "0rgcwwc3rq1bk3dc1plqyhc8mzk429ghswl6ry4zs2n8ds57gnwj";
-       revision = "1";
-       editedCabalFile = "0dslnfn52q87sb2d9di80nirwmfk3bkhc2wbp2wh209k0b5va63w";
+       version = "0.1.0.2";
+       sha256 = "0djvcb2l9dnnjbhivchi6yyaj5i96jmy7yhr9x3paiz1l54brrqx";
        libraryHaskellDepends = [
          adjunctions base data-default-class deepseq distributive hashable
          portray portray-diff some text transformers wrapped
···
     ({ mkDerivation, base, lens, profunctors, some, ten }:
      mkDerivation {
        pname = "ten-lens";
-       version = "0.1.0.0";
-       sha256 = "1b27ds47395jnzqvhsp68807ffa6lmln37vzqkyp1l4r3bk2s7wb";
-       revision = "1";
-       editedCabalFile = "0ik4f5f4as087ync93znh90hw3fhqr2amk8mz5b10pqf6wfrm9pf";
+       version = "0.1.0.1";
+       sha256 = "0qckywzj1c1k8la2ya1vpgrpl9fnqhggx6m6ad0rgrhyal48522c";
        libraryHaskellDepends = [ base lens profunctors some ten ];
-       description = "Lenses for the types in the \"ten\" package";
+       description = "Lenses for the types in the ten package";
        license = lib.licenses.asl20;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "ten-unordered-containers";
-       version = "0.1.0.0";
-       sha256 = "1p399g5m3sbd5f11wksiz49hjd4jrs000jypav82dqw9qr2ys0xl";
-       revision = "1";
-       editedCabalFile = "0pn7xhissqw71xz00v01s9s81hbklyhsqrdqhwkz4b6h6paay5xz";
+       version = "0.1.0.2";
+       sha256 = "0y4aw77ix2ay43l8n17322hbmm1npcdr1bl7kdza377jd1ci20px";
        libraryHaskellDepends = [
          base hashable portray portray-diff some ten unordered-containers
          wrapped
···
        license = lib.licenses.mit;
      }) {};
 
+  "text-builder_0_6_6_3" = callPackage
+    ({ mkDerivation, base, bytestring, criterion, deferred-folds
+     , QuickCheck, quickcheck-instances, rerebase, tasty, tasty-hunit
+     , tasty-quickcheck, text, transformers
+     }:
+     mkDerivation {
+       pname = "text-builder";
+       version = "0.6.6.3";
+       sha256 = "0j2f9zbkk2lbvfb0f3c1i6376zbrr4p782ivbhgi8nv65rsp2ijy";
+       libraryHaskellDepends = [
+         base bytestring deferred-folds text transformers
+       ];
+       testHaskellDepends = [
+         QuickCheck quickcheck-instances rerebase tasty tasty-hunit
+         tasty-quickcheck
+       ];
+       benchmarkHaskellDepends = [ criterion rerebase ];
+       description = "An efficient strict text builder";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "text-containers" = callPackage
     ({ mkDerivation, base, bytestring, containers, deepseq, ghc-prim
      , hashable, QuickCheck, quickcheck-instances, tasty
···
      }) {};
 
   "text-ldap" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, containers, dlist
-     , memory, QuickCheck, quickcheck-simple, random, transformers
-     }:
-     mkDerivation {
-       pname = "text-ldap";
-       version = "0.1.1.13";
-       sha256 = "0d1a7932999yx98hjvnrap1lpm9jcfg34m2m0hdy4j1m6cq4q5zc";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         attoparsec base bytestring containers dlist memory transformers
-       ];
-       executableHaskellDepends = [ base bytestring ];
-       testHaskellDepends = [
-         base bytestring QuickCheck quickcheck-simple random
-       ];
-       description = "Parser and Printer for LDAP text data stream";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "text-ldap_0_1_1_14" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, containers, memory
      , QuickCheck, quickcheck-simple, random, transformers
      }:
···
        ];
        description = "Parser and Printer for LDAP text data stream";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "text-lens" = callPackage
···
      }:
      mkDerivation {
        pname = "th-reify-many";
-       version = "0.1.9";
-       sha256 = "0hxf56filzqnyrc8q7766vai80y6cgrrbrczx6n93caskl1dv2gq";
-       revision = "1";
-       editedCabalFile = "0y0gyh866i40a71732mbkzb1clxh4cq26kma4xnrq86kdd7s2rr8";
-       libraryHaskellDepends = [
-         base containers mtl safe template-haskell th-expand-syns
-       ];
-       testHaskellDepends = [ base template-haskell ];
-       description = "Recurseively reify template haskell datatype info";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "th-reify-many_0_1_10" = callPackage
-    ({ mkDerivation, base, containers, mtl, safe, template-haskell
-     , th-expand-syns
-     }:
-     mkDerivation {
-       pname = "th-reify-many";
        version = "0.1.10";
        sha256 = "19g4gc1q3zxbylmvrgk3dqjzychq2k02i7fwvs3vhbrg4ihhw9cx";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base template-haskell ];
        description = "Recurseively reify template haskell datatype info";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "th-sccs" = callPackage
···
        license = lib.licenses.gpl3Plus;
      }) {};
 
-  "tlynx_0_6_0_0" = callPackage
+  "tlynx_0_6_1_0" = callPackage
     ({ mkDerivation, aeson, async, attoparsec, base, bytestring
      , comonad, containers, data-default-class, elynx-tools, elynx-tree
-     , gnuplot, mwc-random, optparse-applicative, parallel, statistics
-     , text, transformers, vector
+     , gnuplot, mwc-random, optparse-applicative, parallel, primitive
+     , statistics, text, transformers, vector
      }:
      mkDerivation {
        pname = "tlynx";
-       version = "0.6.0.0";
-       sha256 = "1iz555rfq4wi5yc5bqfgkgwzmlxcksxmbpcfdwmcarcijazm9mpi";
+       version = "0.6.1.0";
+       sha256 = "0dwwpq0jj89g68scxrqy4zr6r3f93w8024icbblwx4ygv51xkxai";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson async attoparsec base bytestring comonad containers
          data-default-class elynx-tools elynx-tree gnuplot mwc-random
-         optparse-applicative parallel statistics text transformers vector
+         optparse-applicative parallel primitive statistics text
+         transformers vector
        ];
        executableHaskellDepends = [ base ];
        description = "Handle phylogenetic trees";
···
     ({ mkDerivation, base, tasty, tasty-quickcheck, vector }:
      mkDerivation {
        pname = "vector-rotcev";
-       version = "0.1.0.0";
-       sha256 = "1sl5jwmpmzzvknalgqrbpy3yhqclgqxf75wnpb24rn416kdscy6j";
-       revision = "1";
-       editedCabalFile = "1hn2g8wykmisaacw4w8iffcd8qn3dnkl9lkj3j9n0324xm1b3sp0";
-       libraryHaskellDepends = [ base vector ];
-       testHaskellDepends = [ base tasty tasty-quickcheck vector ];
-       description = "Vectors with O(1) reverse";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "vector-rotcev_0_1_0_1" = callPackage
-    ({ mkDerivation, base, tasty, tasty-quickcheck, vector }:
-     mkDerivation {
-       pname = "vector-rotcev";
        version = "0.1.0.1";
        sha256 = "1zrw1r6xspjncavd307xbbnjdmmhjq9w3dbvm0khnkxjgh47is8v";
        libraryHaskellDepends = [ base vector ];
        testHaskellDepends = [ base tasty tasty-quickcheck vector ];
        description = "Vectors with O(1) reverse";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "vector-shuffling" = callPackage
···
      }:
      mkDerivation {
        pname = "wai-session-redis";
-       version = "0.1.0.2";
-       sha256 = "15l0sq5y9lalprn3k7fcw37fnmzphhd00qkpwna3wxpr0vrlihzs";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base bytestring cereal data-default hedis vault wai wai-session
-       ];
-       executableHaskellDepends = [
-         base bytestring cereal data-default hedis http-types vault wai
-         wai-session warp
-       ];
-       testHaskellDepends = [
-         base bytestring cereal data-default hedis hspec vault wai
-         wai-session
-       ];
-       description = "Simple Redis backed wai-session backend";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "wai-session-redis_0_1_0_3" = callPackage
-    ({ mkDerivation, base, bytestring, cereal, data-default, hedis
-     , hspec, http-types, vault, wai, wai-session, warp
-     }:
-     mkDerivation {
-       pname = "wai-session-redis";
        version = "0.1.0.3";
        sha256 = "1ikm5i4cvx2wzlq5ij7aqk9c37jpnw9c0dl0xdw3c4hqsnjnb5yj";
        isLibrary = true;
···
        executableHaskellDepends = [ base optparse-generic ];
        description = "representations of a web page";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "web-routes" = callPackage
···
        ];
        description = "Implements Windows Live Web Authentication and Delegated Authentication";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "winerror" = callPackage
···
      }) {};
 
   "worldturtle" = callPackage
-    ({ mkDerivation, base, containers, gloss, lens, matrix, mtl }:
+    ({ mkDerivation, base, containers, gloss, lens, matrix
+     , transformers
+     }:
      mkDerivation {
        pname = "worldturtle";
-       version = "0.2.0.0";
-       sha256 = "0h5r74ba0wjhyp8yl3clxgq5yfdr51fdkfn2xz4ahizxycyrx14f";
-       libraryHaskellDepends = [ base containers gloss lens matrix mtl ];
-       description = "Turtle graphics";
+       version = "0.2.2.0";
+       sha256 = "0h7zhgpddhmsxmz1x7hmz785r4mx7i37ad16621wmnc1w84zcfaq";
+       revision = "1";
+       editedCabalFile = "1m8mivb0xsbbyrbc27r9kdkkfyd5wnasppjx8ywpsl2xknmxx918";
+       libraryHaskellDepends = [
+         base containers gloss lens matrix transformers
+       ];
+       description = "LOGO-like Turtle graphics with a monadic interface";
        license = lib.licenses.bsd3;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "yampa-test";
-       version = "0.2";
-       sha256 = "030dakxny9nh0spq04vbxs961y12i2xbr9g9g3q7lk78mhshwv5v";
+       version = "0.13.2";
+       sha256 = "004qly1sags94p7ks1j93xziixbpi3wsblbh2d2ws78gyywqdj9f";
        libraryHaskellDepends = [
          base normaldistribution QuickCheck Yampa
        ];
···
      }:
      mkDerivation {
        pname = "yeamer";
-       version = "0.1.1.0";
-       sha256 = "0i3ka3c4ci70kgrbmc7ynk587a4sihpqhyv6bjc1n9gwjbm9abxi";
+       version = "0.1.2.0";
+       sha256 = "07xl891fdy9cilzpfpirzqmz7f6jw2m151bdk8p16633fkhsmvc3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "yesod-auth";
-       version = "1.6.10.3";
-       sha256 = "00a7gbp2czg6ixxx62k2nmrj5g1la6cjh697y8vg9xhxq7vpyshg";
-       libraryHaskellDepends = [
-         aeson authenticate base base16-bytestring base64-bytestring binary
-         blaze-builder blaze-html blaze-markup bytestring conduit
-         conduit-extra containers cryptonite data-default email-validate
-         file-embed http-client http-client-tls http-conduit http-types
-         memory network-uri nonce persistent random safe shakespeare
-         template-haskell text time transformers unliftio unliftio-core
-         unordered-containers wai yesod-core yesod-form yesod-persistent
-       ];
-       description = "Authentication for Yesod";
-       license = lib.licenses.mit;
-     }) {};
-
-  "yesod-auth_1_6_10_4" = callPackage
-    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
-     , base64-bytestring, binary, blaze-builder, blaze-html
-     , blaze-markup, bytestring, conduit, conduit-extra, containers
-     , cryptonite, data-default, email-validate, file-embed, http-client
-     , http-client-tls, http-conduit, http-types, memory, network-uri
-     , nonce, persistent, random, safe, shakespeare, template-haskell
-     , text, time, transformers, unliftio, unliftio-core
-     , unordered-containers, wai, yesod-core, yesod-form
-     , yesod-persistent
-     }:
-     mkDerivation {
-       pname = "yesod-auth";
        version = "1.6.10.4";
        sha256 = "01s5svba45g0d12cz8kc8lvdw18jfhjxr7yk69cf5157qg0f2czv";
        libraryHaskellDepends = [
···
        ];
        description = "Authentication for Yesod";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "yesod-auth-account" = callPackage

pkgs/development/tools/haskell/haskell-language-server/withWrapper.nix

···
-{ lib, supportedGhcVersions ? [ "884" "8107" ], stdenv, haskellPackages
+{ lib, supportedGhcVersions ? [ "884" "8107" "901" ], stdenv, haskellPackages
 , haskell }:
 #
 # The recommended way to override this package is

pkgs/development/tools/py-spy/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "py-spy";
-  version = "0.3.8";
+  version = "0.3.9";
 
   src = fetchFromGitHub {
     owner = "benfred";
     repo = "py-spy";
     rev = "v${version}";
-    sha256 = "sha256-nb4ehJQGo6k4/gO2e54sBW1+eZ23jxgst142RPAn2jw=";
+    sha256 = "sha256-jGHTt3MMSNBVi9W3JRWxKrao1OXrV8mB1pXoiZcQ7SU=";
   };
 
   NIX_CFLAGS_COMPILE = "-L${libunwind}/lib";
···
 
   checkInputs = [ python3 ];
 
-  cargoSha256 = "sha256-qiK/LBRF6YCK1rhOlvK7g7BxF5G5zPgWJ3dM2Le0Yio=";
+  cargoSha256 = "sha256-UW8fqauuE2e6NPsJP2YtjU8bwi60UWJvGvZ7dglmPA0=";
 
   meta = with lib; {
     description = "Sampling profiler for Python programs";

pkgs/development/tools/rust/cargo-dephell/default.nix

···
+{ lib, rustPlatform, fetchFromGitHub, pkg-config, openssl, stdenv, Security }:
+
+rustPlatform.buildRustPackage rec {
+  pname = "cargo-dephell";
+  version = "0.5.1";
+
+  src = fetchFromGitHub {
+    owner = "mimoo";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "1v3psrkjhgbkq9lm3698ac77qgk090jbly4r187nryj0vcmf9s1l";
+  };
+
+  cargoSha256 = "0fwj782dbyj3ps16hxmq61drf8714863jb0d3mhivn3zlqawyyil";
+
+  nativeBuildInputs = [ pkg-config ];
+
+  buildInputs = [ openssl ] ++ lib.optional stdenv.isDarwin Security;
+
+  meta = with lib; {
+    description = "A tool to analyze the third-party dependencies imported by a rust crate or rust workspace";
+    homepage = "https://github.com/mimoo/cargo-dephell";
+    license = with licenses; [ mit /* or */ asl20 ];
+    maintainers = with maintainers; [ figsoda ];
+  };
+}

pkgs/development/tools/rust/cargo-tally/default.nix

···
+{ lib, rustPlatform, fetchCrate, stdenv, DiskArbitration, Foundation, IOKit }:
+
+rustPlatform.buildRustPackage rec {
+  pname = "cargo-tally";
+  version = "1.0.0";
+
+  src = fetchCrate {
+    inherit pname version;
+    sha256 = "16r60ddrqsss5nagfb5g49md8wwm4zbp9sffbm23bhlqhxh35y0i";
+  };
+
+  cargoSha256 = "0ffq67vy0pa7va8j93g03bralz7lck6ds1hidbpzzkp13pdcgf97";
+
+  buildInputs = lib.optionals stdenv.isDarwin [
+    DiskArbitration
+    Foundation
+    IOKit
+  ];
+
+  meta = with lib; {
+    description = "Graph the number of crates that depend on your crate over time";
+    homepage = "https://github.com/dtolnay/cargo-tally";
+    license = with licenses; [ asl20 /* or */ mit ];
+    maintainers = with maintainers; [ figsoda ];
+  };
+}

pkgs/development/tools/skaffold/default.nix

···
 
 buildGoModule rec {
   pname = "skaffold";
-  version = "1.31.0";
+  version = "1.32.0";
 
   src = fetchFromGitHub {
     owner = "GoogleContainerTools";
     repo = "skaffold";
     rev = "v${version}";
-    sha256 = "sha256-j7e+zwt6CxYndwhv1CsUU0qcLkzyBts+k8K0/CqbktQ=";
+    sha256 = "sha256-LvTAM3uYzSEhX7zz7Z+VcMYV5p80EnyaEIu0CmAUaSg=";
   };
 
-  vendorSha256 = "sha256-9/MlQ18c12Jp0f/pGPUAUY5aWY8tRZTHWZEMbaOl6mI=";
+  vendorSha256 = "sha256-TUpHg4yvZ0WKcUFXjWh4Q4/gRtJ93xNa/gLkj5PYo/w=";
 
   subPackages = ["cmd/skaffold"];
 

pkgs/development/web/flyctl/default.nix

···
 
 buildGoModule rec {
   pname = "flyctl";
-  version = "0.0.238";
+  version = "0.0.240";
 
   src = fetchFromGitHub {
     owner = "superfly";
     repo = "flyctl";
     rev = "v${version}";
-    sha256 = "sha256-dW5+Ga3/sfI33DUmJ3OwXvgbLqC1JkTXXauu0POc16s=";
+    sha256 = "sha256-bcpHrc5DfpkzDzqHlYUfrlQFjVC1j0uRQfAIOVWiV8g=";
   };
 
   preBuild = ''

pkgs/misc/emulators/ruffle/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "ruffle";
-  version = "nightly-2021-05-14";
+  version = "nightly-2021-09-17";
 
   src = fetchFromGitHub {
     owner = "ruffle-rs";
     repo = pname;
     rev = version;
-    sha256 = "15azv8y7a4sgxvvhl7z45jyxj91b4nn681vband5726c7znskhwl";
+    sha256 = "sha256-N4i13vx/hWzFf2DT3lToAAnbMgIaUL/B2C3WI1el3ps=";
   };
 
   nativeBuildInputs = [
···
     wrapProgram $out/bin/ruffle_desktop --prefix LD_LIBRARY_PATH ':' ${vulkan-loader}/lib
   '';
 
-  cargoSha256 = "0ihy4rgw9b4yqlqs87rx700h3a8wm02wpahhg7inic1lcag4bxif";
+  cargoSha256 = "sha256-6B6bSIU15Ca1/lLYij9YjpFykbJhOGZieydNXis/Cw8=";
 
   meta = with lib; {
     description = "An Adobe Flash Player emulator written in the Rust programming language.";

pkgs/misc/vim-plugins/build-vim-plugin.nix

···
       # dont move the doc folder since vim expects it
       forceShare= [ "man" "info" ];
 
-      nativeBuildInputs = attrs.nativeBuildInputs or [] ++ [ vimGenDocHook ];
+      nativeBuildInputs = attrs.nativeBuildInputs or []
+      ++ lib.optional (stdenv.hostPlatform == stdenv.buildPlatform) vimGenDocHook;
       inherit unpackPhase configurePhase buildPhase addonInfo preInstall postInstall;
 
       installPhase = ''

pkgs/servers/sabnzbd/default.nix

···
   ]);
   path = lib.makeBinPath [ par2cmdline unrar unzip p7zip ];
 in stdenv.mkDerivation rec {
-  version = "3.3.1";
+  version = "3.4.0";
   pname = "sabnzbd";
 
   src = fetchFromGitHub {
     owner = pname;
     repo = pname;
     rev = version;
-    sha256 = "sha256-OcasqRu6nh9hKepMbXVgZ49MeJTlWK+qPSkiBPgmYYo=";
+    sha256 = "sha256-zax+PuvCmYOlEhRmiCp7UOd9VI0i8dbgTPyTtqLuGUM=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/servers/teleport/default.nix

···
 in
 buildGoModule rec {
   pname = "teleport";
-  version = "7.1.0";
+  version = "7.1.2";
 
   # This repo has a private submodule "e" which fetchgit cannot handle without failing.
   src = fetchFromGitHub {
     owner = "gravitational";
     repo = "teleport";
     rev = "v${version}";
-    sha256 = "sha256-4kXI/eOrgJQYt4D/S709bUt+x5cGiFGAOP0VEoSgIsM=";
+    sha256 = "sha256-1/Dmh7jTlGg3CqNZDFNIT8/OvgzkHG2m6Qs0ya4IM18=";
   };
 
   vendorSha256 = null;

pkgs/tools/misc/calamares/default.nix

···
 
 mkDerivation rec {
   pname = "calamares";
-  version = "3.2.42";
+  version = "3.2.43";
 
   # release including submodule
   src = fetchurl {
     url = "https://github.com/${pname}/${pname}/releases/download/v${version}/${pname}-${version}.tar.gz";
-    sha256 = "sha256-NbtgtbhauEo7EGvNUNltUQRBpLlzBjAR0GLL9CadgsQ=";
+    sha256 = "sha256-68mt+bkdEBUODvyf3hh09snL+ecMfmSqNlVleOOJ2K8=";
   };
 
   nativeBuildInputs = [ cmake extra-cmake-modules ];

pkgs/tools/networking/smartdns/default.nix

···
 
   buildInputs = [ openssl ];
 
+  # Force the systemd service file to be regenerated from it's template.  This
+  # file is erroneously added in version 35 and it has already been deleted from
+  # upstream's git repository.  So this "postPatch" phase can be deleted in next
+  # release.
+  postPatch = ''
+    rm -f systemd/smartdns.service
+  '';
+
   makeFlags = [
     "PREFIX=${placeholder "out"}"
     "SYSTEMDSYSTEMUNITDIR=${placeholder "out"}/lib/systemd/system"

pkgs/top-level/all-packages.nix

···
   cargo-deny = callPackage ../development/tools/rust/cargo-deny {
     inherit (darwin.apple_sdk.frameworks) Security;
   };
+  cargo-dephell = callPackage ../development/tools/rust/cargo-dephell {
+    inherit (darwin.apple_sdk.frameworks) Security;
+  };
   cargo-diet = callPackage ../development/tools/rust/cargo-diet { };
   cargo-embed = callPackage ../development/tools/rust/cargo-embed {
     inherit (darwin.apple_sdk.frameworks) AppKit;
···
   cargo-spellcheck = callPackage ../development/tools/rust/cargo-spellcheck { };
   cargo-sweep = callPackage ../development/tools/rust/cargo-sweep { };
   cargo-sync-readme = callPackage ../development/tools/rust/cargo-sync-readme {};
+  cargo-tally = callPackage ../development/tools/rust/cargo-tally {
+    inherit (darwin.apple_sdk.frameworks) DiskArbitration Foundation IOKit;
+  };
   cargo-udeps = callPackage ../development/tools/rust/cargo-udeps {
     inherit (darwin.apple_sdk.frameworks) CoreServices Security SystemConfiguration;
   };

pkgs/top-level/release-haskell.nix

···
       Cabal_3_6_1_0 = with compilerNames; [ ghc884 ghc8107 ghc901 ghc921 ];
       cabal2nix-unstable = all;
       funcmp = all;
-      # Doesn't currently work on ghc-9.0:
-      # https://github.com/haskell/haskell-language-server/issues/297
-      haskell-language-server = with compilerNames; [ ghc884 ghc8107 ];
+      haskell-language-server = all;
       hoogle = all;
       hsdns = all;
       jailbreak-cabal = all;