Merge staging-next into staging

nixos/modules/services/misc/paperless-ng.nix

···
 
   defaultUser = "paperless";
 
+  hasCustomRedis = hasAttr "PAPERLESS_REDIS" cfg.extraConfig;
+
   env = {
     PAPERLESS_DATA_DIR = cfg.dataDir;
     PAPERLESS_MEDIA_ROOT = cfg.mediaDir;
     PAPERLESS_CONSUMPTION_DIR = cfg.consumptionDir;
     GUNICORN_CMD_ARGS = "--bind=${cfg.address}:${toString cfg.port}";
-  } // lib.mapAttrs (_: toString) cfg.extraConfig;
+  } // (
+    lib.mapAttrs (_: toString) cfg.extraConfig
+  ) // (optionalAttrs (!hasCustomRedis) {
+    PAPERLESS_REDIS = "unix://${config.services.redis.servers.paperless-ng.unixSocket}";
+  });
 
   manage = let
     setupEnv = lib.concatStringsSep "\n" (mapAttrsToList (name: val: "export ${name}=\"${val}\"") env);
···
       "-/etc/hosts"
       "-/etc/localtime"
       "-/run/postgresql"
-    ];
+    ] ++ (optional (!hasCustomRedis) config.services.redis.servers.paperless-ng.unixSocket);
     BindPaths = [
       cfg.consumptionDir
       cfg.dataDir
···
     NoNewPrivileges = true;
     PrivateDevices = true;
     PrivateMounts = true;
-    # Needs to connect to redis
-    # PrivateNetwork = true;
+    PrivateNetwork = true;
     PrivateTmp = true;
     PrivateUsers = true;
     ProcSubset = "pid";
···
     RestrictNamespaces = true;
     RestrictRealtime = true;
     RestrictSUIDSGID = true;
+    SupplementaryGroups = optional (!hasCustomRedis) config.services.redis.servers.paperless-ng.user;
     SystemCallArchitectures = "native";
     SystemCallFilter = [ "@system-service" "~@privileged @resources @setuid @keyring" ];
     # Does not work well with the temporary root
···
 
   config = mkIf cfg.enable {
     # Enable redis if no special url is set
-    services.redis.enable = mkIf (!hasAttr "PAPERLESS_REDIS" env) true;
+    services.redis.servers.paperless-ng.enable = mkIf (!hasCustomRedis) true;
 
     systemd.tmpfiles.rules = [
       "d '${cfg.dataDir}' - ${cfg.user} ${config.users.users.${cfg.user}.group} - -"
···
           echo "$superuserState" > "$superuserStateFile"
         fi
       '';
+    } // optionalAttrs (!hasCustomRedis) {
+      after = [ "redis-paperless-ng.service" ];
     };
 
     # Password copying can't be implemented as a privileged preStart script
···
             '${cfg.passwordFile}' '${cfg.dataDir}/superuser-password'
         '';
         Type = "oneshot";
+        # Needs to talk to mail server for automated import rules
+        PrivateNetwork = false;
       };
     };
 
···
         CapabilityBoundingSet = "CAP_NET_BIND_SERVICE";
         # gunicorn needs setuid
         SystemCallFilter = defaultServiceConfig.SystemCallFilter ++ [ "@setuid" ];
+        # Needs to serve web page
+        PrivateNetwork = false;
       };
       environment = env // {
         PATH = mkForce cfg.package.path;

pkgs/applications/editors/nano/default.nix

···
 
 in stdenv.mkDerivation rec {
   pname = "nano";
-  version = "6.0";
+  version = "6.1";
 
   src = fetchurl {
     url = "mirror://gnu/nano/${pname}-${version}.tar.xz";
-    sha256 = "k6yMtotK0Q4KrrgKLdFcW7ietmWkhE960Bxn78sWnqI=";
+    sha256 = "PVfsiT+/3tEmZbfw1WPXRDH8Q6vqzKzt6iO2avcE20A=";
   };
 
   nativeBuildInputs = [ texinfo ] ++ optional enableNls gettext;

pkgs/applications/graphics/vengi-tools/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "vengi-tools";
-  version = "0.0.17";
+  version = "0.0.18";
 
   src = fetchFromGitHub {
     owner = "mgerhardy";
     repo = "vengi";
     rev = "v${version}";
-    sha256 = "sha256-h+R9L0BBD3NSFWUh43g4V2LBcNyqVInBeJiOLY03nRk=";
+    sha256 = "sha256-Ur1X5FhOa87jbjWBXievBfCHW+qP/8bqLiyKAC8+KU4=";
   };
-
-  # Patch from the project's author for fixing an issue with AnimationShaders.h
-  # not being included when turning off some components
-  patches = [(writeText "vengi-tools-fix-build.patch" ''
-    diff --git a/src/modules/voxelworldrender/CMakeLists.txt b/src/modules/voxelworldrender/CMakeLists.txt
-    index aebe5f97b..903e62b37 100644
-    --- a/src/modules/voxelworldrender/CMakeLists.txt
-    +++ b/src/modules/voxelworldrender/CMakeLists.txt
-    @@ -27,7 +27,7 @@ set(FILES
-            voxel/models/plants/3.qb
-            voxel/models/plants/4.qb
-     )
-    -engine_add_module(TARGET ''${LIB} SRCS ''${SRCS} ''${SRCS_SHADERS} FILES ''${FILES} DEPENDENCIES frontend voxelrender)
-    +engine_add_module(TARGET ''${LIB} SRCS ''${SRCS} ''${SRCS_SHADERS} FILES ''${FILES} DEPENDENCIES animation frontend voxelrender)
-     generate_shaders(''${LIB} world water postprocess)
-
-     set(TEST_SRCS
-  '')];
 
   nativeBuildInputs = [
     cmake
···
   '';
 
   passthru.tests = {
-    # There used to be a roundtrip test here, but it started failing on 0.0.17
-    # Relevant upstream ticket:
-    # https://github.com/mgerhardy/vengi/issues/113
+    voxconvert-roundtrip = callPackage ./test-voxconvert-roundtrip.nix {};
     voxconvert-all-formats = callPackage ./test-voxconvert-all-formats.nix {};
     run-voxedit = nixosTests.vengi-tools;
   };

pkgs/applications/graphics/vengi-tools/test-voxconvert-roundtrip.nix

···
+{ stdenv
+, vengi-tools
+}:
+
+stdenv.mkDerivation {
+  name = "vengi-tools-test-voxconvert-roundtrip";
+  meta.timeout = 10;
+  buildCommand = ''
+    ${vengi-tools}/bin/vengi-voxconvert --input ${vengi-tools}/share/vengi-voxedit/chr_knight.qb --output chr_knight.vox
+    ${vengi-tools}/bin/vengi-voxconvert --input chr_knight.vox --output chr_knight.qb
+    ${vengi-tools}/bin/vengi-voxconvert --input chr_knight.qb --output chr_knight1.vox
+    diff chr_knight.vox chr_knight1.vox
+    touch $out
+  '';
+}

pkgs/applications/graphics/xournalpp/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "xournalpp";
-  version = "1.1.0";
+  version = "1.1.1";
 
   src = fetchFromGitHub {
     owner = "xournalpp";
     repo = pname;
-    rev = version;
-    sha256 = "sha256-FIIpWgWvq1uo/lIQXpOkUTZ6YJPtOtxKF8VjXSgqrlE=";
+    rev = "v${version}";
+    sha256 = "sha256-AzLkXGcTjtfBaPOZ/Tc+TwL63vm08G2tZw3pGzoo7po=";
   };
 
   nativeBuildInputs = [ cmake gettext pkg-config wrapGAppsHook ];
···
   meta = with lib; {
     description = "Xournal++ is a handwriting Notetaking software with PDF annotation support";
     homepage    = "https://xournalpp.github.io/";
+    changelog   = "https://github.com/xournalpp/xournalpp/blob/v${version}/CHANGELOG.md";
     license     = licenses.gpl2Plus;
     maintainers = with maintainers; [ andrew-d sikmir ];
     platforms   = platforms.linux;

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

···
 
 buildGoModule rec {
   pname = "kn";
-  version = "1.1.0";
+  version = "1.2.0";
 
   src = fetchFromGitHub {
     owner = "knative";
     repo = "client";
     rev = "knative-v${version}";
-    sha256 = "sha256-lRQ4IXV+q1idoTyhppJGlzjuUuRykP8DtQ3t/CsxhNw=";
+    sha256 = "sha256-yWzrMkkusRueHyWT4LwrflH4N7BNri2ycHIuAyvXceo=";
   };
 
   vendorSha256 = null;

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

···
 
 buildGoModule rec {
   pname = "kubelogin";
-  version = "0.0.10";
+  version = "0.0.11";
 
   src = fetchFromGitHub {
     owner = "Azure";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-YLYyU3k3I74ZuczFZBwcJoJSfCR4B9Z1EbFupA+xkiE=";
+    sha256 = "sha256-+u+75Z2Efaq16g7kGNq1GHavXwtKvNO6dytniUr8mlE=";
   };
 
   vendorSha256 = "sha256-vJfTf9gD/qrsPAfJeMYLjGa90mYLOshgDehv2Fcl6xM=";

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

···
-{ lib, buildGoModule, fetchFromGitHub }:
-
+{ lib, buildGoModule, fetchFromGitHub, installShellFiles }:
+let
+  # look for GO_LDFLAGS getting set in the Makefile
+  version = "0.14.2";
+  sha256 = "sha256-sQtry94T5cDO+836D/p/8ptQi3WYKDBLr1QZyEXdLQI=";
+  vendorSha256 = "sha256-cd2iNMxWmkSWqqkPLYocUG+fCUXoeUXEuGQxjUWQnXk=";
+  pkgsVersion = "0.9.0-4-gc875fbe";
+  extrasVersion = "0.7.0-2-gb4c9d21";
+in
 buildGoModule rec {
   pname = "talosctl";
-  version = "0.14.1";
+  inherit version vendorSha256;
+  # nixpkgs-update: no auto update
 
   src = fetchFromGitHub {
     owner = "talos-systems";
     repo = "talos";
     rev = "v${version}";
-    sha256 = "sha256-JeZ+Q6LTDJtoxfu4mJNc3wv3Y6OPcIUvgnozj9mWwLw=";
+    inherit sha256;
   };
 
-  vendorSha256 = "sha256-ujbEWvcNJJOUegVgAGEPwYF02TiqD1lZELvqc/Gmb4A=";
-
-  # look for GO_LDFLAGS getting set in the Makefile
   ldflags =
     let
       versionPkg = "github.com/talos-systems/talos/pkg/version"; # VERSION_PKG
···
       "-X ${versionPkg}.Name=Talos"
       "-X ${versionPkg}.SHA=${src.rev}" # should be the hash, but as we build from tags, this needs to do
       "-X ${versionPkg}.Tag=${src.rev}"
-      "-X ${versionPkg}.PkgsVersion=v0.9.0-2-g447ce75" # PKGS
-      "-X ${versionPkg}.ExtrasVersion=v0.7.0-1-gd6b73a7" # EXTRAS
+      "-X ${versionPkg}.PkgsVersion=v${pkgsVersion}" # PKGS
+      "-X ${versionPkg}.ExtrasVersion=v${extrasVersion}" # EXTRAS
       "-X ${imagesPkgs}.Username=talos-systems" # USERNAME
       "-X ${imagesPkgs}.Registry=ghcr.io" # REGISTRY
       "-X ${mgmtHelpersPkg}.ArtifactsPath=_out" # ARTIFACTS
     ];
 
   subPackages = [ "cmd/talosctl" ];
+
+  nativeBuildInputs = [ installShellFiles ];
+
+  postInstall = ''
+    installShellCompletion --cmd talosctl \
+      --bash <($out/bin/talosctl completion bash) \
+      --fish <($out/bin/talosctl completion fish) \
+      --zsh <($out/bin/talosctl completion zsh)
+  '';
 
   doCheck = false;
 

pkgs/applications/networking/hyprspace/default.nix

···
 
 buildGoModule rec {
   pname = "hyprspace";
-  version = "0.1.7";
+  version = "0.2.2";
 
   propagatedBuildInputs = lib.optional stdenv.isDarwin iproute2mac;
 
···
     owner = pname;
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-Ecdxs6see4uexY6DatZ/VSGgWR81zRjo3AeAsXSjJ4A=";
+    sha256 = "sha256-UlIQCy4moW58tQ1dqxrPsU5LN1Bs/Jy5X+2CEmXdYIk=";
   };
 
-  vendorSha256 = "sha256-nFiBHhtvTu9Ya6n1KUF+pOXrksHMOph7ABVtGSWVWlo=";
+  vendorSha256 = "sha256-EV59sXmjunWs+MC++CwyuBlbWzWZI1YXDLEsOaESgRU=";
 
   meta = with lib; {
     description = "A Lightweight VPN Built on top of Libp2p for Truly Distributed Networks.";

pkgs/applications/networking/instant-messengers/psi-plus/default.nix

···
 
 mkDerivation rec {
   pname = "psi-plus";
-  version = "1.5.1596";
+  version = "1.5.1600";
 
   src = fetchFromGitHub {
     owner = "psi-plus";
     repo = "psi-plus-snapshots";
     rev = version;
-    sha256 = "sha256-8GnENdoFgFa+pDN8C+W5qoFxsCE7tl3dUHf5TBipo5g=";
+    sha256 = "sha256-AZSxElEpYUYa92KdYxVyM+ppKHpXXwwlBFVOOKH/O7g=";
   };
 
   cmakeFlags = [

pkgs/applications/networking/n8n/node-packages.nix

···
         sha1 = "021e4d9c7705f21bbf37d03ceb58767402774c64";
       };
     };
-    "url-parse-1.5.5" = {
+    "url-parse-1.5.6" = {
       name = "url-parse";
       packageName = "url-parse";
-      version = "1.5.5";
+      version = "1.5.6";
       src = fetchurl {
-        url = "https://registry.npmjs.org/url-parse/-/url-parse-1.5.5.tgz";
-        sha512 = "LYNZ15yZDI+HPHUji/yJpj+MnWvQuPZIOJ+gDtHM6gJq33bbmXLfgODIic6SE8tLLes5KWPjZnI3dWlPG6JiTg==";
+        url = "https://registry.npmjs.org/url-parse/-/url-parse-1.5.6.tgz";
+        sha512 = "xj3QdUJ1DttD1LeSfvJlU1eiF1RvBSBfUu8GplFGdUzSO28y5yUtEl7wb//PI4Af6qh0o/K8545vUmucRrfWsw==";
       };
     };
     "utf7-1.0.2" = {
···
   n8n = nodeEnv.buildNodePackage {
     name = "n8n";
     packageName = "n8n";
-    version = "0.163.0";
+    version = "0.163.1";
     src = fetchurl {
-      url = "https://registry.npmjs.org/n8n/-/n8n-0.163.0.tgz";
-      sha512 = "7znPwaONZgCGJKfkjkHP/zTsPiSf7+Wun6TjQ9j/NmyMiPku99EiwDtH3lW5GFCcy+Doo4GUVMqXpEM8GOcNVw==";
+      url = "https://registry.npmjs.org/n8n/-/n8n-0.163.1.tgz";
+      sha512 = "lhup+qIy3cG0oWvBuOWi57Tn3F2k5NBD00KJ3ilKgnk4VsY+LmAca2xvyZNKvlRPa9i++3ukG6XioPTDuXylgw==";
     };
     dependencies = [
       (sources."@azure/abort-controller-1.0.5" // {
···
           sources."punycode-1.3.2"
         ];
       })
-      sources."url-parse-1.5.5"
+      sources."url-parse-1.5.6"
       (sources."utf7-1.0.2" // {
         dependencies = [
           sources."semver-5.3.0"

pkgs/applications/networking/wayback_machine_downloader/Gemfile

···
 # frozen_string_literal: true
 
-source 'https://rubygems.org' do
-  gem 'wayback_machine_downloader'
-end
+source 'https://rubygems.org'
+gem 'wayback_machine_downloader'

pkgs/applications/networking/wayback_machine_downloader/Gemfile.lock

···
 GEM
   remote: https://rubygems.org/
   specs:
-    wayback_machine_downloader (2.2.1)
+    wayback_machine_downloader (2.3.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  wayback_machine_downloader!
+  wayback_machine_downloader
 
 BUNDLED WITH
-   2.1.4
+   2.3.6

pkgs/applications/networking/wayback_machine_downloader/gemset.nix

···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "12kb1qmvmmsaihqab1prn6cmynkn6cgb4vf41mgv22wkcgv5wgk2";
+      sha256 = "170426sashqc2k2angg8d0bhs7spi1x1isv6cyk2hif0l6xxm3cm";
       type = "gem";
     };
-    version = "2.2.1";
+    version = "2.3.1";
   };
 }

pkgs/applications/radio/welle-io/default.nix

···
 
 mkDerivation rec {
   pname = "welle-io";
-  version = "2.3";
+  version = "2.4";
 
   src = fetchFromGitHub {
     owner = "AlbrechtL";
     repo = "welle.io";
     rev = "v${version}";
-    sha256 = "1xl1lanw0xgmgks67dbfb2h52jxnrd1i2zik56v0q8dwsr7f0daw";
+    sha256 = "sha256-xXiCL/A2SwCSr5SA4AQQEdieRzBksXx9Z78bHtlFiW4=";
   };
 
   nativeBuildInputs = [ cmake pkg-config ];

pkgs/applications/science/math/sage/patches/no-cython-sources-in-tracebacks-on-ipython8.patch

···
+diff --git a/src/sage/repl/interface_magic.py b/src/sage/repl/interface_magic.py
+index 8a455b69b0..a93e1c9e04 100644
+--- a/src/sage/repl/interface_magic.py
++++ b/src/sage/repl/interface_magic.py
+@@ -260,7 +260,7 @@ class InterfaceMagic(object):
+             2
+             120
+             sage: shell.run_cell('%%gap foo\n1+1;\n')
+-            ...File "<string>", line unknown
++            ...File...<string>...
+             SyntaxError: Interface magics have no options, got "foo"
+             <BLANKLINE>
+             sage: shell.run_cell('%%gap?')
+diff --git a/src/sage/repl/interpreter.py b/src/sage/repl/interpreter.py
+index 71dbe429fd..36b1d986d6 100644
+--- a/src/sage/repl/interpreter.py
++++ b/src/sage/repl/interpreter.py
+@@ -70,25 +70,6 @@ that shell.  The bulk of this functionality is provided through
+ 
+ TESTS:
+ 
+-Check that Cython source code appears in tracebacks::
+-
+-    sage: from sage.repl.interpreter import get_test_shell
+-    sage: shell = get_test_shell()
+-    sage: print("dummy line"); shell.run_cell('1/0') # see #25320 for the reason of the `...` and the dummy line in this test
+-    dummy line
+-    ...
+-    ZeroDivisionError...Traceback (most recent call last)
+-    <ipython-input-...> in <module>...
+-    ----> 1 Integer(1)/Integer(0)
+-    .../sage/rings/integer.pyx in sage.rings.integer.Integer...div...
+-    ...
+-    -> ...                  raise ZeroDivisionError("rational division by zero")
+-       ....:            x = <Rational> Rational.__new__(Rational)
+-       ....:            mpq_div_zz(x.value, ....value, (<Integer>right).value)
+-    <BLANKLINE>
+-    ZeroDivisionError: rational division by zero
+-    sage: shell.quit()
+-
+ Test prompt transformer::
+ 
+     sage: from sage.repl.interpreter import SagePromptTransformer
+@@ -423,7 +404,7 @@ def SagePreparseTransformer(lines):
+         sage: from sage.repl.interpreter import get_test_shell
+         sage: shell = get_test_shell()
+         sage: shell.run_cell(bad_syntax)
+-          File "<string>", line unknown
++          File...<string>...
+         SyntaxError: Mismatched ']'
+         <BLANKLINE>
+         sage: shell.quit()

pkgs/applications/science/math/sage/sage-src.nix

···
     # https://trac.sagemath.org/ticket/32959
     ./patches/linbox-1.7-upgrade.patch
 
+    # To emit better tracebacks, IPython 8 parses Python files using the ast
+    # module (via the stack_data package). Since Cython is a superset of Python,
+    # this results in no Cython code being printed in tracebacks. Fixing this
+    # properly is tracked in https://github.com/alexmojaki/stack_data/issues/21,
+    # but for now we just disable the corresponding test. An alternative would
+    # be to revert IPython's IPython/core/ultratb.py, but this would need to be
+    # Sage-specific (since it would worsen tracebacks for pure Python code).
+    # Sage tracks this at https://trac.sagemath.org/ticket/33170
+    ./patches/no-cython-sources-in-tracebacks-on-ipython8.patch
+
     # https://trac.sagemath.org/ticket/32968
     (fetchSageDiff {
       base = "9.5";

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "72a59574747346b3f9aa2cd91cb7469d4e168b53",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/72a59574747346b3f9aa2cd91cb7469d4e168b53.tar.gz",
-  "sha256": "0nspncjgh8lgr15zx8ss3fp289jl7gg21wchj0k821y3cz057ry3",
-  "msg": "Update from Hackage at 2022-01-31T19:23:21Z"
+  "commit": "a4422bb744c0b60e56ccbdd350df5c205caf0b20",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/a4422bb744c0b60e56ccbdd350df5c205caf0b20.tar.gz",
+  "sha256": "1ih77xavy81mjhf8d3nknbgvhpql14nbak01pddh7y195wv1dknd",
+  "msg": "Update from Hackage at 2022-02-06T15:34:38Z"
 }

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

···
   # works fine there.
   fakedata = dontCheck super.fakedata;
 
+  # The latest release on hackage has an upper bound on containers which
+  # breaks the build, though it works with the version of containers present
+  # and the upper bound doesn't exist in code anymore:
+  # > https://github.com/roelvandijk/numerals
+  numerals = doJailbreak (dontCheck super.numerals);
+
   # This test keeps being aborted because it runs too quietly for too long
   Lazy-Pbkdf2 = if pkgs.stdenv.isi686 then dontCheck super.Lazy-Pbkdf2 else super.Lazy-Pbkdf2;
 
···
   network-dbus = dontCheck super.network-dbus;
   notcpp = dontCheck super.notcpp;
   ntp-control = dontCheck super.ntp-control;
-  numerals = dontCheck super.numerals;
   odpic-raw = dontCheck super.odpic-raw; # needs a running oracle database server
   opaleye = dontCheck super.opaleye;
   openpgp = dontCheck super.openpgp;

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

···
   generic-lens_2_2_1_0 = dontCheck super.generic-lens_2_2_1_0;
 
   # Apply patches from head.hackage.
-  alex = appendPatch (pkgs.fetchpatch {
-    url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/fe192e12b88b09499d4aff0e562713e820544bd6/patches/alex-3.2.6.patch";
-    sha256 = "1rzs764a0nhx002v4fadbys98s6qblw4kx4g46galzjf5f7n2dn4";
-  }) (dontCheck super.alex);
   doctest = dontCheck (doJailbreak super.doctest_0_18_2);
   language-haskell-extract = appendPatch (pkgs.fetchpatch {
     url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/master/patches/language-haskell-extract-0.2.4.patch";

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

···
   - DigitalOcean
   - digitalocean-kzs
   - digits
+  - dijkstra-simple
   - DimensionalHash
   - dimensional-tf
   - diophantine
···
   - numbered-semigroups
   - NumberSieves
   - NumberTheory
-  - numerals
   - numerals-base
   - numeric-qq
   - numeric-ranges

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

···
   - path == 0.9.0                       # 2021-12-03: path version building with stackage genvalidity and GHC 9.0.2
   - ormolu == 0.3.*                     # 2021-12-03: for HLS with GHC 9.0.2
   - fourmolu == 0.4.*                   # 2022-02-05: for HLS with GHC 9.0.2
+  - ghc-exactprint == 1.4.*             # 2022-02-07: preserve for now, 1.5.0 has a breaking change without type changes
 
 package-maintainers:
   abbradar:
···
   - dialog
   - ghcjs-dom-webkit
   - gi-webkit
-  - hs-mesos
   - hsqml
   - hsqml-datamodel
   - hsqml-demo-manic
···
 
   # glade relies on system libglade which is deprecated
   - glade
+
+  # mesos was removed from nixpkgs
+  - hs-mesos

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

···
-# Stackage LTS 18.23
+# Stackage LTS 18.24
 # This file is auto-generated by
 # maintainers/scripts/haskell/update-stackage.sh
 default-package-overrides:
···
   - al ==0.1.4.2
   - alarmclock ==0.7.0.5
   - alerts ==0.1.2.0
-  - alex ==3.2.6
+  - alex ==3.2.7.1
   - alex-meta ==0.3.0.13
   - alg ==0.2.13.1
   - algebraic-graphs ==0.5
···
   - amazonka-waf ==1.6.1
   - amazonka-workspaces ==1.6.1
   - amazonka-xray ==1.6.1
-  - amqp ==0.22.0
+  - amqp ==0.22.1
   - amqp-utils ==0.6.3.2
   - annotated-wl-pprint ==0.7.0
   - ansi-terminal ==0.11.1
···
   - audacity ==0.0.2
   - aur ==7.0.7
   - aura ==3.2.5
-  - authenticate ==1.3.5
+  - authenticate ==1.3.5.1
   - authenticate-oauth ==1.6.0.1
   - autoexporter ==1.1.20
   - auto-update ==0.1.6
···
   - circle-packing ==0.1.0.6
   - circular ==0.4.0.1
   - citeproc ==0.4.0.1
-  - clash-ghc ==1.4.6
-  - clash-lib ==1.4.6
-  - clash-prelude ==1.4.6
+  - clash-ghc ==1.4.7
+  - clash-lib ==1.4.7
+  - clash-prelude ==1.4.7
   - classy-prelude ==1.5.0.2
   - classy-prelude-conduit ==1.5.0
   - clay ==0.13.3
···
   - connection-pool ==0.2.2
   - console-style ==0.0.2.1
   - constraint ==0.1.4.0
-  - constraints ==0.13.2
+  - constraints ==0.13.3
   - constraints-extras ==0.3.2.1
   - constraint-tuples ==0.1.2
   - construct ==0.3.0.2
···
   - crackNum ==3.1
   - crc32c ==0.0.0
   - credential-store ==0.1.2
-  - criterion ==1.5.12.0
+  - criterion ==1.5.13.0
   - criterion-measurement ==0.1.3.0
   - cron ==0.7.0
   - crypto-api ==0.13.3
···
   - filtrable ==0.1.4.0
   - fin ==0.2
   - FindBin ==0.0.5
-  - fingertree ==0.1.4.2
+  - fingertree ==0.1.5.0
   - finite-typelits ==0.1.4.2
   - first-class-families ==0.8.0.1
   - first-class-patterns ==0.3.2.5
···
   - ghc-parser ==0.2.3.0
   - ghc-paths ==0.1.0.12
   - ghc-prof ==1.4.1.9
-  - ghc-source-gen ==0.4.2.0
+  - ghc-source-gen ==0.4.3.0
   - ghc-syntax-highlighter ==0.0.6.0
   - ghc-tcplugins-extra ==0.4.2
   - ghc-trace-events ==0.1.2.4
···
   - hebrew-time ==0.1.2
   - hedgehog ==1.0.5
   - hedgehog-corpus ==0.2.0
-  - hedgehog-fakedata ==0.0.1.4
+  - hedgehog-fakedata ==0.0.1.5
   - hedgehog-fn ==1.0
   - hedgehog-quickcheck ==0.1.1
   - hedis ==0.14.4
···
   - monad-unlift ==0.2.0
   - monad-unlift-ref ==0.2.1
   - mongoDB ==2.7.1.1
-  - monoid-subclasses ==1.1.2
+  - monoid-subclasses ==1.1.3
   - monoid-transformer ==0.0.4
   - mono-traversable ==1.0.15.3
   - mono-traversable-instances ==0.1.1.0
···
   - multimap ==1.2.1
   - multipart ==0.2.1
   - multiset ==0.3.4.3
-  - multistate ==0.8.0.3
+  - multistate ==0.8.0.4
   - murmur3 ==1.0.5
   - murmur-hash ==0.1.0.10
   - MusicBrainz ==0.4.1
···
   - network-bsd ==2.8.1.0
   - network-byte-order ==0.1.6
   - network-conduit-tls ==1.3.2
-  - network-info ==0.2.0.10
+  - network-info ==0.2.1
   - network-ip ==0.3.0.3
   - network-messagepack-rpc ==0.1.2.0
   - network-messagepack-rpc-websocket ==0.1.1.1
···
   - persist ==0.1.1.5
   - persistable-record ==0.6.0.5
   - persistable-types-HDBC-pg ==0.0.3.5
-  - persistent ==2.13.2.2
+  - persistent ==2.13.3.0
   - persistent-mtl ==0.2.2.0
-  - persistent-mysql ==2.13.0.2
+  - persistent-mysql ==2.13.1.0
   - persistent-pagination ==0.1.1.2
-  - persistent-postgresql ==2.13.2.2
+  - persistent-postgresql ==2.13.4.0
   - persistent-qq ==2.12.0.2
-  - persistent-sqlite ==2.13.0.4
+  - persistent-sqlite ==2.13.1.0
   - persistent-template ==2.12.0.0
-  - persistent-test ==2.13.0.4
+  - persistent-test ==2.13.1.0
   - persistent-typed-db ==0.1.0.5
   - pg-harness-client ==0.6.0
   - pgp-wordlist ==0.1.0.3
···
   - readable ==0.3.1
   - read-editor ==0.1.0.2
   - read-env-var ==1.0.0.0
-  - reanimate ==1.1.4.0
+  - reanimate ==1.1.5.0
   - reanimate-svg ==0.13.0.1
   - rebase ==1.13.2
   - record-dot-preprocessor ==0.2.13
···
   - string-conversions ==0.4.0.1
   - string-interpolate ==0.3.1.1
   - string-qq ==0.0.4
-  - string-random ==0.1.4.1
+  - string-random ==0.1.4.2
   - stringsearch ==0.3.6.6
   - string-transform ==1.1.1
   - stripe-concepts ==1.0.3.1
···
   - type-operators ==0.2.0.0
   - typerep-map ==0.3.3.0
   - type-spec ==0.4.0.0
-  - tzdata ==0.2.20201021.0
+  - tzdata ==0.2.20211021.0
   - ua-parser ==0.7.6.0
   - uglymemo ==0.1.0.1
   - unagi-chan ==0.4.1.4
···
   - unix-bytestring ==0.3.7.6
   - unix-compat ==0.5.4
   - unix-time ==0.4.7
-  - unliftio ==0.2.20
+  - unliftio ==0.2.20.1
   - unliftio-core ==0.2.0.1
   - unliftio-pool ==0.2.1.1
   - unliftio-streams ==0.1.1.1
···
   - vector-buffer ==0.4.1
   - vector-builder ==0.3.8.3
   - vector-bytes-instances ==0.1.1
-  - vector-circular ==0.1.3
+  - vector-circular ==0.1.4
   - vector-instances ==3.4
   - vector-mmap ==0.0.3
   - vector-rotcev ==0.1.0.1

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

···
  - base64-bytes
  - baserock-schema
  - batchd
+ - batchd-core
+ - batchd-docker
+ - batchd-libvirt
  - batching
  - battlenet-yesod
  - battleships
···
  - claferwiki
  - clash
  - clash-ghc
- - clash-ghc_1_4_7
  - clash-lib
- - clash-lib_1_4_7
  - clash-multisignal
  - clash-prelude-quickcheck
  - clash-shake
···
  - comic
  - commsec-keyexchange
  - comonad-random
+ - compaREST
  - compact-mutable
  - complexity
  - computational-algebra
···
  - hasql-cursor-query
  - hasql-postgres
  - hasql-postgres-options
+ - hasql-streams-conduit
+ - hasql-streams-core
+ - hasql-streams-example
+ - hasql-streams-pipes
+ - hasql-streams-streaming
+ - hasql-streams-streamly
  - hasql-th
  - hastache-aeson
  - haste-app
···
  - reactor
  - readpyc
  - reanimate
- - reanimate_1_1_5_0
  - record-aeson
  - record-gl
  - record-preprocessor

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

···
   } super.nix-output-monitor;
 
   haskell-language-server = overrideCabal (drv: {
+    # starting with 1.6.1.1 haskell-language-server wants to be linked dynamically
+    # by default. Unless we reflect this in the generic builder, GHC is going to
+    # produce some illegal references to /build/.
+    enableSharedExecutables = true;
     postInstall = "ln -s $out/bin/haskell-language-server $out/bin/haskell-language-server-${self.ghc.version}";
     testToolDepends = [ self.cabal-install pkgs.git ];
     testTarget = "func-test"; # wrapper test accesses internet
···
 
   # based on https://github.com/gibiansky/IHaskell/blob/aafeabef786154d81ab7d9d1882bbcd06fc8c6c4/release.nix
   ihaskell = overrideCabal (drv: {
-    configureFlags = (drv.configureFlags or []) ++ [
-      # ihaskell's cabal file forces building a shared executable,
-      # but without passing --enable-executable-dynamic, the RPATH
-      # contains /build/ and leads to a build failure with nix
-      "--enable-executable-dynamic"
-    ];
+    # ihaskell's cabal file forces building a shared executable, which we need
+    # to reflect here or RPATH will contain a reference to /build/.
+    enableSharedExecutables = true;
     preCheck = ''
       export HOME=$TMPDIR/home
       export PATH=$PWD/dist/build/ihaskell:$PATH

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

···
        pname = "Agda";
        version = "2.6.2.1";
        sha256 = "03dw7jfqr3ffik6avigm525djqh2gn5c3qwnb2h6298zkr9lch9w";
-       revision = "2";
-       editedCabalFile = "1n037ql18gayqmdiaf592c4iw9cmwyjz12vvj6wbxrbcwylhc6ji";
+       revision = "4";
+       editedCabalFile = "0spsj8nk28lfvsv6063d1nif5hag8yal47iwicm7yln0626xsxcd";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "HaTeX_3_22_3_1" = callPackage
+    ({ mkDerivation, base, bibtex, bytestring, containers, hashable
+     , matrix, parsec, prettyprinter, QuickCheck, tasty
+     , tasty-quickcheck, text, transformers
+     }:
+     mkDerivation {
+       pname = "HaTeX";
+       version = "3.22.3.1";
+       sha256 = "0vgyixd8j3nzpy8s04cy3q7gj2gfblba2z0ppr58rdm8qgj16j5c";
+       libraryHaskellDepends = [
+         base bibtex bytestring containers hashable matrix parsec
+         prettyprinter QuickCheck text transformers
+       ];
+       testHaskellDepends = [
+         base parsec QuickCheck tasty tasty-quickcheck text
+       ];
+       description = "The Haskell LaTeX library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "HaTeX-meta" = callPackage
     ({ mkDerivation, base, Cabal, containers, directory, filepath, ghc
      , haddock, haskell-src-exts, mtl, parsec
···
        pname = "JuicyPixels-blurhash";
        version = "0.1.0.3";
        sha256 = "0kgl2j7990p8q5yrkn0wgaszc9fzva1pc3277j11k1lbjsymz360";
-       revision = "6";
-       editedCabalFile = "13zdfmj6p6awpy74h09czpcjs0y642aawqb7y87vsz6pfm6zqwjz";
+       revision = "7";
+       editedCabalFile = "0w6svmml3m1bfkycakkd8sib74nixwkr16z334w9v1cs8fjzfwjk";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "NanoID";
-       version = "3.1.1";
-       sha256 = "10zjp9675nxa7nx7qhr5cxw43fy06s5ggb39idlr87b90vm8wkw8";
+       version = "3.2.0";
+       sha256 = "16h4mhr16b2fkf37vpsalnzjmg06sghb86gh1n1w3z64dvad0849";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, bytestring, transformers, vector, vulkan }:
      mkDerivation {
        pname = "VulkanMemoryAllocator";
-       version = "0.8";
-       sha256 = "1cxgf1ly0hqlyn01jd7ipdvvw1mm5r4ifc7694a3dr2wv2pnq5c0";
+       version = "0.9";
+       sha256 = "1avq9njgqbvmqn5277q66bqq01jj6syyrnw82qy4477r5yln2wh2";
        libraryHaskellDepends = [
          base bytestring transformers vector vulkan
        ];
···
      }:
      mkDerivation {
        pname = "alex";
-       version = "3.2.6";
-       sha256 = "042lrkn0dbpjn5ivj6j26jzb1fwrj8c1aj18ykxja89isg0hiali";
-       isLibrary = false;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       executableHaskellDepends = [ array base containers directory ];
-       executableToolDepends = [ happy ];
-       testHaskellDepends = [ base process ];
-       description = "Alex is a tool for generating lexical analysers in Haskell";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "alex_3_2_7_1" = callPackage
-    ({ mkDerivation, array, base, containers, directory, happy, process
-     }:
-     mkDerivation {
-       pname = "alex";
        version = "3.2.7.1";
        sha256 = "1v0vm1l4xvybzwj1p6j5j58yiw5nhbnx7yxjnpyjy6wggsig3llv";
        isLibrary = false;
···
        testHaskellDepends = [ base process ];
        description = "Alex is a tool for generating lexical analysers in Haskell";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "alex-meta" = callPackage
···
        pname = "align-audio";
        version = "0.0";
        sha256 = "0sa7q5fzkc0z4vzibs5l21pvrkil0swdpbl27qn30vb6giy3yh7a";
+       revision = "1";
+       editedCabalFile = "1599vbnfalrnq0zgwmh47k62y9yq30agpjyyfwdzxzszhc0vfq6n";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "amqp";
-       version = "0.22.0";
-       sha256 = "1yr81pwmjnap5bir9nrmpwakg4rz4fwcjzbkdr8azqbp9x0hr9k2";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base binary bytestring clock connection containers
-         data-binary-ieee754 monad-control network network-uri split stm
-         text vector
-       ];
-       executableHaskellDepends = [ base containers xml ];
-       testHaskellDepends = [
-         base binary bytestring clock connection containers
-         data-binary-ieee754 hspec hspec-expectations network network-uri
-         split stm text vector
-       ];
-       description = "Client library for AMQP servers (currently only RabbitMQ)";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "amqp_0_22_1" = callPackage
-    ({ mkDerivation, base, binary, bytestring, clock, connection
-     , containers, data-binary-ieee754, hspec, hspec-expectations
-     , monad-control, network, network-uri, split, stm, text, vector
-     , xml
-     }:
-     mkDerivation {
-       pname = "amqp";
        version = "0.22.1";
        sha256 = "0z1w35ar0bswbjzgana52nh4ilxbidnfkvli29w2zr7cak9dgzg1";
        isLibrary = true;
···
        ];
        description = "Client library for AMQP servers (currently only RabbitMQ)";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "amqp-conduit" = callPackage
···
      }:
      mkDerivation {
        pname = "arch-hs";
-       version = "0.9.1.0";
-       sha256 = "0k9xi2k4ifrnnh6p80pf1xhf45cbhrs1zdwy0ayp08p0ajdlh74b";
+       version = "0.10.0.0";
+       sha256 = "1qpd1a5jv4g4chbc5rqbf067zgcxb222qx7gpj37i83sp2rys68m";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "arduino-copilot";
-       version = "1.5.6";
-       sha256 = "06aqavds6lh4iazrlz62dhdxim0q8xqdgafj7y3f8nnmv8w37g41";
+       version = "1.5.7";
+       sha256 = "06qhad2v4qc5izza3j7wnfafzsidz232qqlq1iy3l8sbmdc8kw37";
        libraryHaskellDepends = [
          base containers copilot copilot-c99 copilot-language directory
          filepath mtl optparse-applicative temporary
···
      }:
      mkDerivation {
        pname = "argo";
-       version = "0.2022.1.15";
-       sha256 = "0wqsrmisbgalf8p0f1zs1jfpf5iws0zb98r1krgg2adghbllg770";
+       version = "0.2022.2.2";
+       sha256 = "133k1jqx737y8bj92w7afvs5hxh28gcv6yyf7mdwlnvq1xphy7pa";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          tasty-quickcheck template-haskell text transformers
        ];
        benchmarkHaskellDepends = [
-         base bytestring containers deepseq tasty-bench template-haskell
-         text transformers
+         base bytestring containers deepseq tasty tasty-bench
+         template-haskell text transformers
        ];
        description = "Parse and render JSON";
        license = lib.licenses.mit;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "audacity_0_0_2_1" = callPackage
+    ({ mkDerivation, base, bytestring, deepseq, directory
+     , explicit-exception, filepath, non-empty, semigroups
+     , storable-record, storablevector, tagchup, transformers
+     , utility-ht, xml-basic
+     }:
+     mkDerivation {
+       pname = "audacity";
+       version = "0.0.2.1";
+       sha256 = "04r36gy8z0d2fz1l5px6yajp7izf3zpda9vci6q0wc273pxc8ck6";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring deepseq directory explicit-exception filepath
+         non-empty semigroups storable-record storablevector tagchup
+         transformers utility-ht xml-basic
+       ];
+       description = "Interchange with the Audacity sound signal editor";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "audiovisual" = callPackage
     ({ mkDerivation, base, boundingboxes, colors, deepseq, directory
      , filepath, free, freetype2, hashable, JuicyPixels
···
        pname = "aura";
        version = "3.2.7";
        sha256 = "07ya2vd94grh6fs7k5kq25yh95xfk5mdqcgqq84anjz0phprq5z3";
+       revision = "1";
+       editedCabalFile = "16z28nkj5ladbbrg2h5sc1qcl3335g3i37x02h0by8bpqbkld6xr";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "authenticate";
-       version = "1.3.5";
-       sha256 = "10df40ycd4r45p58xzdh0vcsa401909fa99nkgd18fx5alqh84sz";
-       revision = "1";
-       editedCabalFile = "0lmb1m5d1l2scnm2fqxfk348m8xqbc7f7kvk7zvpsvcdcpxinafz";
-       libraryHaskellDepends = [
-         aeson attoparsec base blaze-builder bytestring case-insensitive
-         conduit containers html-conduit http-conduit http-types network-uri
-         resourcet text transformers unordered-containers xml-conduit
-       ];
-       description = "Authentication methods for Haskell web applications";
-       license = lib.licenses.mit;
-     }) {};
-
-  "authenticate_1_3_5_1" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
-     , case-insensitive, conduit, containers, html-conduit, http-conduit
-     , http-types, network-uri, resourcet, text, transformers
-     , unordered-containers, xml-conduit
-     }:
-     mkDerivation {
-       pname = "authenticate";
        version = "1.3.5.1";
        sha256 = "1rhbvdgwdr68gp13p5piddfdqf3l9lmx4w7k249lc98y23780c3x";
        libraryHaskellDepends = [
···
        ];
        description = "Authentication methods for Haskell web applications";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "authenticate-kerberos" = callPackage
···
        pname = "aws-cloudfront-signed-cookies";
        version = "0.2.0.10";
        sha256 = "1mzsg6wfzgiippl8kw54m16i1m7zxwfqfwx3wbb3m372pg4h9sza";
+       revision = "3";
+       editedCabalFile = "0yswkjkx4xhmy11k3zcgcrmwr19dcaxw15vbl52nqsrhamw60fh3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "batchd" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, connection, containers
-     , cryptonite, data-default, dates, directory, esqueleto, filepath
-     , Glob, http-client, http-client-tls, http-types, libssh2
-     , monad-logger, monad-logger-syslog, mtl, optparse-applicative
-     , parsec, persistent, persistent-postgresql, persistent-sqlite
-     , persistent-template, process, readline, resourcet, scotty, syb
-     , template, template-haskell, text, th-lift, time, tls
-     , transformers, unix, unordered-containers, vault, wai, wai-cors
-     , wai-extra, wai-middleware-static, warp, x509-store, yaml
+    ({ mkDerivation, aeson, base, batchd-core, boxes, bytestring
+     , conduit, conduit-combinators, conduit-extra, connection
+     , containers, cryptonite, data-default, dates, directory, ekg-core
+     , ekg-json, esqueleto, exceptions, fast-logger, filepath, Glob
+     , haskeline, heavy-logger, heavy-logger-instances, hsyslog
+     , http-client, http-client-tls, http-types, libssh2
+     , libssh2-conduit, localize, microlens, monad-metrics, mtl
+     , optparse-applicative, parsec, persistent, persistent-postgresql
+     , persistent-sqlite, persistent-template, process, resourcet
+     , scotty, syb, text, text-format-heavy, th-lift, time, tls, unix
+     , unliftio-core, unordered-containers, vault, vector, wai, wai-cors
+     , wai-extra, wai-middleware-metrics, wai-middleware-static, warp
+     , x509-store, yaml
      }:
      mkDerivation {
        pname = "batchd";
-       version = "0.1.0.0";
-       sha256 = "1axj4w0g34fgnn89l6f2zxbx172z6yq98clksp2bqxmnswza7di2";
+       version = "0.1.1.0";
+       sha256 = "19ka8xgrnyg4pkrgl8qp9l74y7qizj9r370hlwldcj19gidp9lhb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         aeson base bytestring connection containers cryptonite data-default
-         dates directory esqueleto filepath Glob http-client http-client-tls
-         http-types libssh2 monad-logger monad-logger-syslog mtl
-         optparse-applicative parsec persistent persistent-postgresql
-         persistent-sqlite persistent-template process readline resourcet
-         scotty syb template template-haskell text th-lift time tls
-         transformers unix unordered-containers vault wai wai-cors wai-extra
-         wai-middleware-static warp x509-store yaml
+         aeson base batchd-core boxes bytestring conduit conduit-combinators
+         conduit-extra connection containers cryptonite data-default dates
+         directory ekg-core ekg-json esqueleto exceptions fast-logger
+         filepath Glob haskeline heavy-logger heavy-logger-instances hsyslog
+         http-client http-client-tls http-types libssh2 libssh2-conduit
+         localize microlens monad-metrics mtl optparse-applicative parsec
+         persistent persistent-postgresql persistent-sqlite
+         persistent-template process resourcet scotty syb text
+         text-format-heavy th-lift time tls unix unliftio-core
+         unordered-containers vault vector wai wai-cors wai-extra
+         wai-middleware-metrics wai-middleware-static warp x509-store yaml
        ];
        description = "Batch processing toolset for Linux / Unix";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "batchd-core" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, dates
+     , directory, filepath, heavy-logger, hsyslog, localize, mtl
+     , persistent, persistent-template, resourcet, scotty, syb
+     , template-haskell, text, text-format-heavy, th-lift, time
+     , unordered-containers, wai, yaml
+     }:
+     mkDerivation {
+       pname = "batchd-core";
+       version = "0.1.0.0";
+       sha256 = "0kk1crifbynpri8wkhnni3wms759fxc6jmdm0919xlzjfkxj5psr";
+       libraryHaskellDepends = [
+         aeson base bytestring containers dates directory filepath
+         heavy-logger hsyslog localize mtl persistent persistent-template
+         resourcet scotty syb template-haskell text text-format-heavy
+         th-lift time unordered-containers wai yaml
+       ];
+       description = "Core modules of batchd, to use in batchd extensions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "batchd-docker" = callPackage
+    ({ mkDerivation, aeson, base, batchd-core, docker, exceptions, mtl
+     , text, unliftio-core
+     }:
+     mkDerivation {
+       pname = "batchd-docker";
+       version = "0.1.0.0";
+       sha256 = "11kwj1c43kqrclvg5waj0n3lw9k8an7npz23jwsi3f8nwqi86rzv";
+       libraryHaskellDepends = [
+         aeson base batchd-core docker exceptions mtl text unliftio-core
+       ];
+       description = "docker containers host controller for batchd";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "batchd-libvirt" = callPackage
+    ({ mkDerivation, aeson, base, batchd-core, heavy-logger, libvirt-hs
+     , text, text-format-heavy, time
+     }:
+     mkDerivation {
+       pname = "batchd-libvirt";
+       version = "0.1.0.0";
+       sha256 = "1l9mw11pxda3w8lw6blk7b8q4220hfm9qnvr4v0rcaxrzjyrh9bb";
+       libraryHaskellDepends = [
+         aeson base batchd-core heavy-logger libvirt-hs text
+         text-format-heavy time
+       ];
+       description = "host controller for batchd, which controls virtual machines via libvirt library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "batching" = callPackage
     ({ mkDerivation, base, primitive, QuickCheck, short-vec, sint
      , test-framework, test-framework-quickcheck2
···
        pname = "bench";
        version = "1.0.12";
        sha256 = "1sy97qpv6paar2d5syppk6lc06wjx6qyz5aidsmh30jq853nydx6";
-       revision = "2";
-       editedCabalFile = "055482m81h7pijiszdkk2k65p208i3c3pxs955pv6h0gwrialcsh";
+       revision = "3";
+       editedCabalFile = "1lprgyc8jnfys70mxnpynrkgy1m4ss2dhf7mhj9kvxkahkkqdqm2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
   "bench-show" = callPackage
     ({ mkDerivation, ansi-wl-pprint, base, Chart, Chart-diagrams, csv
      , directory, filepath, mwc-random, optparse-applicative
-     , optparse-simple, semigroups, split, statistics, text
-     , transformers, vector
+     , optparse-simple, split, statistics, text, transformers, vector
      }:
      mkDerivation {
        pname = "bench-show";
-       version = "0.3.1";
-       sha256 = "0z1fdcdl9chwia9kd5pa9572mc5pmy5bld72axkzg20r7v53sr7k";
-       revision = "1";
-       editedCabalFile = "08a95i3xwy2yz549hqfwd3j0j6gbsbc62jjmpxnk43yk5dl8dk63";
+       version = "0.3.2";
+       sha256 = "1f0zx572d54dyyjifv4p550ci90gdr4mrifhwww4z6p87fbdi32j";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          mwc-random split statistics transformers vector
        ];
        executableHaskellDepends = [
-         ansi-wl-pprint base Chart Chart-diagrams csv directory filepath
-         mwc-random optparse-applicative optparse-simple semigroups split
-         statistics transformers vector
+         base optparse-applicative optparse-simple
        ];
        testHaskellDepends = [ base split text ];
        description = "Show, plot and compare benchmark results";
···
        pname = "blaze-markup";
        version = "0.8.2.8";
        sha256 = "0jd30wg5yz0a97b36zwqg4hv8faifza1n2gys3l1p3fwf9l3zz23";
-       revision = "1";
-       editedCabalFile = "1azqgw61l5zqjrjg176glx2m4nlyrmrz7a7vrpvbbkfqymwp7mfr";
+       revision = "2";
+       editedCabalFile = "074zslyx5dxzz242n5rzhgdw9i58akrkm2jd37wazbk3062a7mrq";
        libraryHaskellDepends = [ base blaze-builder bytestring text ];
        testHaskellDepends = [
          base blaze-builder bytestring containers HUnit QuickCheck tasty
···
        pname = "c2hs";
        version = "0.28.8";
        sha256 = "0k482wv94jbpwd96a2c2lc7qz9k8072slx7l7943472nzk7k41ir";
+       revision = "1";
+       editedCabalFile = "0hbv1j9b04gm617c5xqndr4iqidabwdpcn2dcrnaacc04ylchvl2";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "cabal-flatpak";
        version = "0.1.0.3";
        sha256 = "1k0fzhyvlcq1l09fnf3f3wig4g9l61wsm1dmsjd3nwsgh52xb37v";
+       revision = "1";
+       editedCabalFile = "1468f116hza0l9z4n4zqy1y65q322ypx5kh646fsfi78fimwj34a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "cgroup-rts-threads";
-       version = "0.2.0.0";
-       sha256 = "1anlrgjlkjdljxnj4a1y2f5wd3rzd1b9maz97dkg95djh20wcmig";
+       version = "0.2.1.0";
+       sha256 = "1fzv3bgfr7r1c8m02z887ml2mzh2j571zcjjp6al272iaax8ymx0";
        libraryHaskellDepends = [ base directory megaparsec path text ];
        testHaskellDepends = [
          base hspec-core hspec-expectations path path-io
···
      }) {};
 
   "chart-svg" = callPackage
-    ({ mkDerivation, attoparsec, base, Color, containers, cubicbezier
-     , foldl, generic-lens, JuicyPixels, lens, linear, lucid, mtl
-     , numhask, numhask-space, reanimate, reanimate-svg, scientific
-     , tagsoup, text, time, transformers, unordered-containers
+    ({ mkDerivation, adjunctions, attoparsec, base, Color, containers
+     , cubicbezier, foldl, formatn, lucid, mtl, neat-interpolation
+     , numhask, numhask-array, numhask-space, optics-core, random
+     , scientific, tagsoup, text, time, transformers
      }:
      mkDerivation {
        pname = "chart-svg";
-       version = "0.2.3";
-       sha256 = "1j96l71gi2nrvwrwsvww9x7whvv3vmnc0ywgiy6ak1yh71hmivm1";
-       revision = "1";
-       editedCabalFile = "1zanv288hlir51yv4zqkcf2b4wxqivwd5y6f1s1n9zdn9k6b7c64";
-       isLibrary = true;
-       isExecutable = true;
+       version = "0.3.0";
+       sha256 = "07k8r0njywbgb77mjzmsyfhmzv01spyjcdvlj6jd4h2fhjmqpmwb";
        libraryHaskellDepends = [
-         attoparsec base Color containers cubicbezier foldl generic-lens
-         JuicyPixels lens linear lucid mtl numhask numhask-space reanimate
-         reanimate-svg scientific tagsoup text time transformers
-         unordered-containers
+         adjunctions attoparsec base Color containers cubicbezier foldl
+         formatn lucid mtl neat-interpolation numhask numhask-array
+         numhask-space optics-core random scientific tagsoup text time
+         transformers
        ];
-       executableHaskellDepends = [ base lens reanimate ];
        description = "Charting library targetting SVGs";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
   "cimple" = callPackage
     ({ mkDerivation, aeson, alex, ansi-wl-pprint, array, base
      , bytestring, containers, data-fix, filepath, groom, happy, hspec
-     , hspec-discover, mtl, recursion-schemes, text, transformers-compat
+     , hspec-discover, monad-parallel, mtl, recursion-schemes, text
+     , transformers-compat
      }:
      mkDerivation {
        pname = "cimple";
-       version = "0.0.11";
-       sha256 = "1n7633c6w4n4996i3k9v60yhpiddd8b7600c7hpam2axm9cqb19i";
+       version = "0.0.13";
+       sha256 = "18c3x6mb93hj2zzq63p9wczi73wm1c3b24ksjmnksldkaakwv6wy";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson ansi-wl-pprint array base bytestring containers data-fix
-         filepath groom mtl recursion-schemes text transformers-compat
+         filepath groom monad-parallel mtl recursion-schemes text
+         transformers-compat
        ];
        libraryToolDepends = [ alex happy ];
        executableHaskellDepends = [ base bytestring groom text ];
···
      }:
      mkDerivation {
        pname = "clash-ghc";
-       version = "1.4.6";
-       sha256 = "0bxzfbpz0kz3f6jdq66vcv1h039ww90xdkivbadaz034ngzallfr";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         array base bifunctors bytestring Cabal clash-lib clash-prelude
-         concurrent-supply containers deepseq directory exceptions extra
-         filepath ghc ghc-boot ghc-prim ghc-typelits-extra
-         ghc-typelits-knownnat ghc-typelits-natnormalise ghci hashable
-         haskeline integer-gmp lens mtl primitive process reflection split
-         template-haskell text time transformers uniplate unix
-         unordered-containers utf8-string vector
-       ];
-       executableHaskellDepends = [ base ];
-       description = "Clash: a functional hardware description language - GHC frontend";
-       license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
-  "clash-ghc_1_4_7" = callPackage
-    ({ mkDerivation, array, base, bifunctors, bytestring, Cabal
-     , clash-lib, clash-prelude, concurrent-supply, containers, deepseq
-     , directory, exceptions, extra, filepath, ghc, ghc-boot, ghc-prim
-     , ghc-typelits-extra, ghc-typelits-knownnat
-     , ghc-typelits-natnormalise, ghci, hashable, haskeline, integer-gmp
-     , lens, mtl, primitive, process, reflection, split
-     , template-haskell, text, time, transformers, uniplate, unix
-     , unordered-containers, utf8-string, vector
-     }:
-     mkDerivation {
-       pname = "clash-ghc";
        version = "1.4.7";
        sha256 = "06r97diqy6px1pf06dbnvf6ns0kmqy5gc5mr6k9xam1d2pk37xwd";
        isLibrary = true;
···
      }:
      mkDerivation {
        pname = "clash-lib";
-       version = "1.4.6";
-       sha256 = "0lw0cx2in4qfr8h43qhbxfn5s0srbp2a90nfsrnjbhfsh37aza0b";
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         aeson aeson-pretty ansi-terminal array attoparsec base
-         base16-bytestring binary bytestring clash-prelude concurrent-supply
-         containers cryptohash-sha256 data-binary-ieee754 data-default
-         deepseq directory dlist errors exceptions extra filepath ghc
-         ghc-boot-th hashable haskell-src-meta hint integer-gmp interpolate
-         lens mtl ordered-containers parsers pretty-show prettyprinter
-         primitive process reducers template-haskell temporary terminal-size
-         text text-show time transformers trifecta unordered-containers
-         utf8-string vector vector-binary-instances
-       ];
-       testHaskellDepends = [
-         aeson aeson-pretty base base16-bytestring bytestring clash-prelude
-         concurrent-supply containers data-default deepseq ghc
-         ghc-typelits-knownnat haskell-src-exts lens pretty-show
-         quickcheck-text tasty tasty-hunit tasty-quickcheck template-haskell
-         text transformers unordered-containers
-       ];
-       description = "Clash: a functional hardware description language - As a library";
-       license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
-  "clash-lib_1_4_7" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, array
-     , attoparsec, base, base16-bytestring, binary, bytestring
-     , clash-prelude, concurrent-supply, containers, cryptohash-sha256
-     , data-binary-ieee754, data-default, deepseq, directory, dlist
-     , errors, exceptions, extra, filepath, ghc, ghc-boot-th
-     , ghc-typelits-knownnat, hashable, haskell-src-exts
-     , haskell-src-meta, hint, integer-gmp, interpolate, lens, mtl
-     , ordered-containers, parsers, pretty-show, prettyprinter
-     , primitive, process, quickcheck-text, reducers, tasty, tasty-hunit
-     , tasty-quickcheck, template-haskell, temporary, terminal-size
-     , text, text-show, time, transformers, trifecta
-     , unordered-containers, utf8-string, vector
-     , vector-binary-instances
-     }:
-     mkDerivation {
-       pname = "clash-lib";
        version = "1.4.7";
        sha256 = "03wj0i926x8lc09nwgwh48plqxc49i5zzwil88bgnxdcwv9ncv18";
        enableSeparateDataOutput = true;
···
      }) {};
 
   "clash-prelude" = callPackage
-    ({ mkDerivation, array, arrows, base, bifunctors, binary
-     , bytestring, Cabal, cabal-doctest, constraints, containers
-     , criterion, data-binary-ieee754, data-default-class, deepseq
-     , doctest, ghc-prim, ghc-typelits-extra, ghc-typelits-knownnat
-     , ghc-typelits-natnormalise, half, hashable, hedgehog, hint
-     , integer-gmp, interpolate, lens, QuickCheck
-     , quickcheck-classes-base, recursion-schemes, reflection
-     , singletons, tasty, tasty-hedgehog, tasty-hunit, tasty-quickcheck
-     , tasty-th, template-haskell, text, text-show, th-abstraction
-     , th-lift, th-orphans, time, transformers, type-errors, uniplate
-     , vector
-     }:
-     mkDerivation {
-       pname = "clash-prelude";
-       version = "1.4.6";
-       sha256 = "1m6sk0sss5hsh9x0614vr81pdv715wbdkdf119wnyy0sfjjnmbzi";
-       setupHaskellDepends = [ base Cabal cabal-doctest ];
-       libraryHaskellDepends = [
-         array arrows base bifunctors binary bytestring constraints
-         containers data-binary-ieee754 data-default-class deepseq ghc-prim
-         ghc-typelits-extra ghc-typelits-knownnat ghc-typelits-natnormalise
-         half hashable integer-gmp interpolate lens QuickCheck
-         recursion-schemes reflection singletons template-haskell text
-         text-show th-abstraction th-lift th-orphans time transformers
-         type-errors uniplate vector
-       ];
-       testHaskellDepends = [
-         base deepseq doctest ghc-typelits-extra ghc-typelits-knownnat
-         ghc-typelits-natnormalise hedgehog hint quickcheck-classes-base
-         tasty tasty-hedgehog tasty-hunit tasty-quickcheck tasty-th
-         template-haskell
-       ];
-       benchmarkHaskellDepends = [
-         base criterion deepseq template-haskell
-       ];
-       description = "Clash: a functional hardware description language - Prelude library";
-       license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "clash-prelude_1_4_7" = callPackage
     ({ mkDerivation, array, arrows, base, bifunctors, binary
      , bytestring, Cabal, cabal-doctest, constraints, containers
      , criterion, data-binary-ieee754, data-default-class, deepseq
···
      }:
      mkDerivation {
        pname = "clckwrks";
-       version = "0.26.4";
-       sha256 = "0gvfplid34idkfg5s7dvcwg22ij3fryn82hz958z2960a4jb7ngv";
+       version = "0.27.2";
+       sha256 = "088wx15f81h45ykhibq7ays5yn2ivwvgffaa459r6b6v53npkqkr";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          acid-state aeson aeson-qq attoparsec base blaze-html bytestring
···
      }:
      mkDerivation {
        pname = "clckwrks-cli";
-       version = "0.3.0.3";
-       sha256 = "03dyhfnmqhqjahd36cdhjvrqp68grzvdl69cqk2z2aa34z0agd4a";
+       version = "0.3.0.4";
+       sha256 = "17ifv0awgx7fylc1pbdcdq9l8wl2shr6fy65rgb0xjv3zxnwx4i8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "clckwrks-plugin-page";
-       version = "0.4.3.24";
-       sha256 = "0zsf8j8l99cxskjql8zh407ar7920ph6xn42j8nxnh6qir16wdar";
+       version = "0.4.3.25";
+       sha256 = "0ii9984y7792i7kiwnqmgn9mfyky2k9dkx3fnzkirypqbxyri92s";
        libraryHaskellDepends = [
          acid-state aeson attoparsec base clckwrks containers directory
          filepath happstack-hsp happstack-server hsp hsx2hs ixset mtl
···
      }:
      mkDerivation {
        pname = "clckwrks-plugin-redirect";
-       version = "0.0.1";
-       sha256 = "1946m4fxdj8kr7n1q39j2q9j6srdz97srq0fifnk7mil23lw2vyj";
+       version = "0.0.1.2";
+       sha256 = "1vb0knjy0qkbpzni10bgvznnjxc7bv7pbp1l9frdffdsrssgyx8w";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "clckwrks-theme-bootstrap";
-       version = "0.4.3";
-       sha256 = "01hs4rh89zp0y2gkfam27kdwywh5fqr10pzwf1d4c92kpnz9xd5d";
+       version = "0.4.3.2";
+       sha256 = "0ag94kc0csjnh88vw6ljifv6cqqwc8wizyizqk0mj4qpp73z6qd2";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base clckwrks happstack-authenticate hsp hsx-jmacro hsx2hs jmacro
···
   "cleff" = callPackage
     ({ mkDerivation, atomic-primops, base, containers, exceptions
      , extra, hspec, lifted-base, microlens, monad-control, primitive
-     , QuickCheck, template-haskell, th-abstraction, transformers
-     , transformers-base, unliftio
+     , QuickCheck, rec-smallarray, template-haskell, th-abstraction
+     , transformers, transformers-base, unliftio
      }:
      mkDerivation {
        pname = "cleff";
-       version = "0.1.0.0";
-       sha256 = "16fd1ly5299an0wlmnc3f6asikbr8n8b8vzkmvd2jq86sk0x5z1n";
+       version = "0.2.0.0";
+       sha256 = "0p9xmp9injfyy4d9p4cxqm103rwrwwwdghph4gawhjwsyp4611m8";
        libraryHaskellDepends = [
          atomic-primops base containers exceptions microlens monad-control
-         primitive template-haskell th-abstraction transformers
-         transformers-base unliftio
+         primitive rec-smallarray template-haskell th-abstraction
+         transformers transformers-base unliftio
        ];
        testHaskellDepends = [
          atomic-primops base containers exceptions extra hspec lifted-base
-         microlens monad-control primitive QuickCheck template-haskell
-         th-abstraction transformers transformers-base unliftio
+         microlens monad-control primitive QuickCheck rec-smallarray
+         template-haskell th-abstraction transformers transformers-base
+         unliftio
        ];
        description = "Fast and concise extensible effects";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "commonmark-simple" = callPackage
+    ({ mkDerivation, aeson, base, commonmark, commonmark-extensions
+     , commonmark-pandoc, containers, megaparsec, pandoc-types, parsec
+     , parser-combinators, relude, yaml
+     }:
+     mkDerivation {
+       pname = "commonmark-simple";
+       version = "0.1.0.0";
+       sha256 = "0fvpykqvqi12nsc95pv3xwd67sdamxc79r24w5xf30f87p0f9kna";
+       libraryHaskellDepends = [
+         aeson base commonmark commonmark-extensions commonmark-pandoc
+         containers megaparsec pandoc-types parsec parser-combinators relude
+         yaml
+       ];
+       description = "Simple interface to commonmark-hs";
+       license = lib.licenses.mit;
+     }) {};
+
   "commsec" = callPackage
     ({ mkDerivation, base, bytestring, cipher-aes128, crypto-api
      , network
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "compaREST" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, comonad
+     , containers, data-default, directory, doctemplates, envy
+     , file-embed, filepath, free, freer-simple, generic-data, github
+     , hashable, http-media, insert-ordered-containers, lattices, lens
+     , mtl, open-union, openapi3, optparse-applicative
+     , ordered-containers, pandoc, pandoc-types, pcre2, scientific
+     , tagged, tasty, tasty-golden, text, transformers, type-fun
+     , typerep-map, unordered-containers, vector, yaml
+     }:
+     mkDerivation {
+       pname = "compaREST";
+       version = "0.1.0.0";
+       sha256 = "06y2qxl0vgka4vby5vv1njzgwbaq3615qic15iqnnm9dqwg7cczx";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson attoparsec base bytestring comonad containers data-default
+         doctemplates file-embed free generic-data hashable http-media
+         insert-ordered-containers lattices mtl open-union openapi3
+         ordered-containers pandoc-types pcre2 scientific tagged text
+         transformers type-fun typerep-map unordered-containers vector
+       ];
+       executableHaskellDepends = [
+         aeson base bytestring containers data-default doctemplates envy
+         filepath freer-simple github mtl optparse-applicative pandoc
+         pandoc-types text vector yaml
+       ];
+       testHaskellDepends = [
+         base bytestring data-default directory filepath lens pandoc
+         pandoc-types tasty tasty-golden text yaml
+       ];
+       description = "Compatibility checker for OpenAPI";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "compact" = callPackage
     ({ mkDerivation, base, binary, bytestring, directory, ghc-compact
      }:
···
        ];
        description = "Ungarble output from several threads or commands";
        license = lib.licenses.bsd2;
+     }) {};
+
+  "concurrent-output_1_10_15" = callPackage
+    ({ mkDerivation, ansi-terminal, async, base, directory, exceptions
+     , process, stm, terminal-size, text, transformers, unix
+     }:
+     mkDerivation {
+       pname = "concurrent-output";
+       version = "1.10.15";
+       sha256 = "1n02ck0zci6y2w8dm03j2qypgbc176skapixrmnxrp9dnbwcprc0";
+       libraryHaskellDepends = [
+         ansi-terminal async base directory exceptions process stm
+         terminal-size text transformers unix
+       ];
+       description = "Ungarble output from several threads or commands";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "concurrent-resource-map" = callPackage
···
      }:
      mkDerivation {
        pname = "constraints";
-       version = "0.13.2";
-       sha256 = "1zfijh3jpdfrh8nwn5xv2z05jnxyf0ciqlfaja6g6ls654svrj70";
-       revision = "1";
-       editedCabalFile = "1h46cskb4ci2jigqlrd9x87n1i1d6q6w4r0in6i47ywmhjdv7xwg";
-       libraryHaskellDepends = [
-         base binary deepseq ghc-prim hashable mtl transformers
-         transformers-compat type-equality
-       ];
-       testHaskellDepends = [ base hspec ];
-       testToolDepends = [ hspec-discover ];
-       description = "Constraint manipulation";
-       license = lib.licenses.bsd2;
-     }) {};
-
-  "constraints_0_13_3" = callPackage
-    ({ mkDerivation, base, binary, deepseq, ghc-prim, hashable, hspec
-     , hspec-discover, mtl, transformers, transformers-compat
-     , type-equality
-     }:
-     mkDerivation {
-       pname = "constraints";
        version = "0.13.3";
        sha256 = "0jhdix263zxsiki0pmdpyrg7vcfxx2x9w7pjiypva3wsr9agdjzr";
        libraryHaskellDepends = [
···
        testToolDepends = [ hspec-discover ];
        description = "Constraint manipulation";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "constraints-deriving" = callPackage
···
      }:
      mkDerivation {
        pname = "cornea";
-       version = "0.4.0.0";
-       sha256 = "0hm17g350gnklvgi5nsx03lgbx2zs9h4q11y2gi9zjnm6gv6gjrn";
+       version = "0.4.0.1";
+       sha256 = "1i6c2j90rban9hq7hzhf0rcq6dgzrin9jalbx2pjvqy1i6m49kn4";
        libraryHaskellDepends = [
          base either lens lifted-base monad-control mtl relude
          template-haskell th-abstraction transformers
···
 
   "crdt-event-fold" = callPackage
     ({ mkDerivation, aeson, base, binary, containers
-     , data-default-class, data-dword, hspec, monad-logger, mtl
-     , transformers
+     , data-default-class, data-dword, exceptions, hspec, monad-logger
+     , mtl, transformers
      }:
      mkDerivation {
        pname = "crdt-event-fold";
-       version = "1.4.0.0";
-       sha256 = "0hagrbsgw58kchiifhq69s4hii7pv8zsvfzl3ijgxkb8iqp515gc";
+       version = "1.5.1.1";
+       sha256 = "1625x6zk6znfzz76pk1d1wkh2qvybdpwaxpm20kk88jsakhvg0br";
        libraryHaskellDepends = [
          aeson base binary containers data-default-class data-dword
-         monad-logger mtl transformers
+         exceptions monad-logger mtl transformers
+       ];
+       testHaskellDepends = [
+         aeson base binary containers data-default-class data-dword
+         exceptions hspec monad-logger mtl transformers
        ];
-       testHaskellDepends = [ base hspec ];
        description = "Garbage collected event folding CRDT";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "criterion";
-       version = "1.5.12.0";
-       sha256 = "0wrb48byp906f9wc9ii2mi2b2k008ycbi8ffrrj86plhp5rpvzz5";
+       version = "1.5.13.0";
+       sha256 = "19vrlldgw2kz5426j0iwsvvhxkbnrnan859vr6ryqh13nrg59a72";
        revision = "1";
-       editedCabalFile = "154jscaip9y081mvf70vcwqw0acynfb9hwxgqwmzqq9q6d8b1wfw";
+       editedCabalFile = "1xpbvax71yrnilq4iixjfi3by2n8wz5r5nb2r4v9wn85xz0r8dwh";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "curl-runnings";
-       version = "0.16.0";
-       sha256 = "1dghvwmwl9x7v7dn52kadp3i72k8cgyhir5adc6hw61bgk49qll0";
+       version = "0.16.4";
+       sha256 = "1900v9gs4mmap4xp0bypq0wz14mw2mmak9861z4rl954pz25v9pv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "d10";
        version = "1.0.0.2";
        sha256 = "10jc4sa986r194py1gg90mixvb2h4d1m12zwi6y5hffmrc910qva";
+       revision = "1";
+       editedCabalFile = "1ffwq8kfg90a5gfdm41fid7n4aszzl4j2mpnr4pp95ri174awqbz";
        libraryHaskellDepends = [ base template-haskell ];
        testHaskellDepends = [ base hedgehog template-haskell ];
        description = "Digits 0-9";
···
 
   "dates" = callPackage
     ({ mkDerivation, base, base-unicode-symbols, hspec, parsec, syb
-     , time
+    ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
      }:
      mkDerivation {
        pname = "dates";
-       version = "0.2.3.0";
-       sha256 = "1l9df5815gb8lxgl1kmsn4q58qrjqii5b957z5gn4hk5cjnr456k";
+       version = "0.2.3.2";
+       sha256 = "15x7nyzdzqqknxff4v08hij1gp8p1prwpzpl6ayva548xq70jz39";
        libraryHaskellDepends = [
-         base base-unicode-symbols parsec syb time
+         base base-unicode-symbols parsec syb template-haskell time
        ];
        testHaskellDepends = [ base hspec ];
        description = "Small library for parsing different dates formats";
···
      }:
      mkDerivation {
        pname = "deriving-trans";
-       version = "0.2.2.0";
-       sha256 = "1v2iamc375i6gqavb2s644mbb99wlnv0nk07dmbyaw522svp20y4";
+       version = "0.3.0.0";
+       sha256 = "07847l2iwnrgskldqnjx3312rw95fp3xsmdx5rc61746ghl76aq7";
        libraryHaskellDepends = [
          base monad-control mtl transformers transformers-base
        ];
···
        pname = "dhall";
        version = "1.40.2";
        sha256 = "14wh497fipvz01zc9s31gv144spg1iqfwp6x5mlk1hjk0v9qs5by";
-       revision = "1";
-       editedCabalFile = "1dfnyin9rcq7ily0dlm94s7xnrsjg8ix24zsp52hl7wg4fkfc46c";
+       revision = "2";
+       editedCabalFile = "0mxq3knz1wpvs6jcdw6p0mnwpyy7aqriy2qdyxqzmhcbw2yn3hc1";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "dhall-docs";
        version = "1.0.8";
        sha256 = "1rkwvk6vd8l52nxv186fw3qdmsjvi8098yccnnbysmf41rz80fi7";
-       revision = "1";
-       editedCabalFile = "0z2xrvbfprgq5zzd862s2g8w4zr4k5wrl3vmb9vzds72yk65h3sk";
+       revision = "2";
+       editedCabalFile = "12virkq759imppdzpx75fyka8kqfw01xfwb0lm9mir86gjb34n2q";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "dhall-json";
        version = "1.7.9";
        sha256 = "11rl46vn6lzcm9kznpfc43c3a2cbq2si2zba3k2x4j360kvg9fgn";
-       revision = "1";
-       editedCabalFile = "07izgs7x8ssmalv0m6r9clhx5gbs48f1bxxr3qsyxs26liqvppzq";
+       revision = "2";
+       editedCabalFile = "0f1jb37f5k214dzxbbhw2hij7j7srydkdp0hpkapgs5k73vjvqm4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "dhall-nixpkgs";
        version = "1.0.7";
        sha256 = "1s7md4b2jzgmf557clln9fc5lmdrd9xjs55dd97dv8q6krm8nabg";
-       revision = "2";
-       editedCabalFile = "06cz8iszdgxyy9v95ppcr5zjkrxw4mx01kvc68h88jdf8g5fgp6g";
+       revision = "3";
+       editedCabalFile = "135j5m3dgiyvjlw67rbx1jjnnzb5v777g6a8kkplpiv92swwslfd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "dhall-openapi";
        version = "1.0.3";
        sha256 = "0k7yq7g77ws7wjfzd35ydsjwaq2kc1y0rhwjwb6yvkyvljmr0ykz";
-       revision = "1";
-       editedCabalFile = "0jmbgjrinlsgdw4ksqmn0lr15m6r0kxw33c5g7slnqgbnimbjrgw";
+       revision = "2";
+       editedCabalFile = "0cqvwbpn3njl3xm4jxcsb2dvfi6y1nm6inxanqxda7pgbysqrn8j";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "dhall-yaml";
        version = "1.2.9";
        sha256 = "0gn9jrqihimjs8i9ksgmlkh8c64km52rmsgz2y6k3ab0igkv8dw6";
-       revision = "1";
-       editedCabalFile = "1mq7si8d9mkwnh6kw4041dhfppam507blr2ji3m6xw8f1pg70rcd";
+       revision = "2";
+       editedCabalFile = "18qshgn6vfry37sfmdwi1lijqdrhbrximbwcyi5zzz1b5nb7sa0v";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "diagrams-lib";
        version = "1.4.5.1";
        sha256 = "1hkxp549i99s45qk8zmhjvz1xyyv3i0ffl8155bifkic6fd8y2gz";
-       revision = "1";
-       editedCabalFile = "0yqpasggmdkzg2n67a6m20rbhzcgchnfhs66m95lnp5n9vl7v8mn";
+       revision = "2";
+       editedCabalFile = "12zif237fhf8r016225wsfkshwsxpqq0bm0h3k1ys5yjyk6m3x90";
        libraryHaskellDepends = [
          active adjunctions array base bytestring cereal colour containers
          data-default-class diagrams-core diagrams-solve directory
···
        pname = "diagrams-pgf";
        version = "1.4.2";
        sha256 = "1x7qz8683rsfi0gpmfmhicswmmxppil779d4mhfwkp537b6l2zmh";
+       revision = "1";
+       editedCabalFile = "14vfl9rihrpvdjvlndg86w1ap12lp98049jz741giy94rfbj3knp";
        libraryHaskellDepends = [
          base bytestring bytestring-builder colour containers diagrams-core
          diagrams-lib directory filepath hashable JuicyPixels mtl
···
        pname = "diagrams-rasterific";
        version = "1.4.2.2";
        sha256 = "1q0b3yh7wbi3yq0y8qswhvfmcz52f6njl4dawq9gl71jyfb2g8nq";
+       revision = "1";
+       editedCabalFile = "1cijmn8bc2j0v3a0qp7a7zl3hrn99gwmd7vl3lv9754f5s1l1m13";
        libraryHaskellDepends = [
          base bytestring containers data-default-class diagrams-core
          diagrams-lib file-embed filepath FontyFruity hashable JuicyPixels
···
        pname = "diagrams-svg";
        version = "1.4.3.1";
        sha256 = "002lgmq78c6rsvds9bgm6m4w8j6qpg260mc52hf97wj6m050l237";
-       revision = "2";
-       editedCabalFile = "056nfj2srbhh68jc5al8hffcfrqlr89173pjf6bhpmnzxhwlv55k";
+       revision = "3";
+       editedCabalFile = "03yh2nj88c91m8xq5gzcyxj55jr8sfypfgs361c90ncwn7jxz3ly";
        libraryHaskellDepends = [
          base base64-bytestring bytestring colour containers diagrams-core
          diagrams-lib filepath hashable JuicyPixels lens monoid-extras mtl
···
        testHaskellDepends = [ base containers fingertree hspec ];
        description = "A simpler Dijkstra shortest paths implementation";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "dimensional" = callPackage
···
      }:
      mkDerivation {
        pname = "diohsc";
-       version = "0.1.9";
-       sha256 = "1mxccj0fwj8n8zh8h997ljd4r179zyn6k63xgnhw7bgi1pjv4301";
+       version = "0.1.10";
+       sha256 = "1k6027dq5x156xw50pjjr8713ibqbycal653mfa8q59y6h8jvzjf";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }) {};
 
   "ema" = callPackage
-    ({ mkDerivation, aeson, async, base, blaze-html, blaze-markup
-     , commonmark, commonmark-extensions, commonmark-pandoc
-     , constraints-extras, containers, data-default, dependent-sum
-     , dependent-sum-template, directory, filepath, filepattern
-     , http-types, lvar, megaparsec, monad-logger, monad-logger-extras
-     , neat-interpolation, optparse-applicative, pandoc-types, parsec
-     , parser-combinators, relude, text, time, unicode-transforms
-     , unionmount, unliftio, uri-encode, wai, wai-middleware-static
-     , wai-websockets, warp, websockets, yaml
+    ({ mkDerivation, aeson, async, base, constraints-extras, containers
+     , data-default, dependent-sum, dependent-sum-template, directory
+     , filepath, filepattern, http-types, lvar, monad-logger
+     , monad-logger-extras, neat-interpolation, optparse-applicative
+     , relude, text, unliftio, url-slug, wai, wai-middleware-static
+     , wai-websockets, warp, websockets
      }:
      mkDerivation {
        pname = "ema";
-       version = "0.4.0.0";
-       sha256 = "1l44mmcghhgyyxxnannmqsabdbwdz5yka0vk3pbiziqjjlkjxpnj";
+       version = "0.6.0.0";
+       sha256 = "0xha83himdaj64pm09dpvl0lrjvs6alk6mxh73d7ah1dbfsm79h1";
        libraryHaskellDepends = [
-         aeson async base blaze-html blaze-markup commonmark
-         commonmark-extensions commonmark-pandoc constraints-extras
-         containers data-default dependent-sum dependent-sum-template
-         directory filepath filepattern http-types lvar megaparsec
-         monad-logger monad-logger-extras neat-interpolation
-         optparse-applicative pandoc-types parsec parser-combinators relude
-         text time unicode-transforms unionmount unliftio uri-encode wai
-         wai-middleware-static wai-websockets warp websockets yaml
+         aeson async base constraints-extras containers data-default
+         dependent-sum dependent-sum-template directory filepath filepattern
+         http-types lvar monad-logger monad-logger-extras neat-interpolation
+         optparse-applicative relude text unliftio url-slug wai
+         wai-middleware-static wai-websockets warp websockets
        ];
        description = "Static site generator library with hot reload";
        license = lib.licenses.agpl3Only;
···
        pname = "equivalence";
        version = "0.3.5";
        sha256 = "167njzd1cf32aa7br90rjafrxy6hw3fxkk8awifqbxjrcwm5maqp";
+       revision = "1";
+       editedCabalFile = "0rc68zqj518lmlp58kbgfb945gp0iszfjn6h3y777cjrbm1jp5k4";
        libraryHaskellDepends = [
          base containers fail mtl STMonadTrans transformers
          transformers-compat
···
        ];
        description = "Maintaining an equivalence relation implemented as union-find using STT";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "equivalence_0_4" = callPackage
+    ({ mkDerivation, base, containers, mtl, QuickCheck, STMonadTrans
+     , template-haskell, transformers, transformers-compat
+     }:
+     mkDerivation {
+       pname = "equivalence";
+       version = "0.4";
+       sha256 = "0xyj7knshfjknjd13cm7ym9hxllnbr4wvqnz8pgq8154hn7j2f1d";
+       libraryHaskellDepends = [
+         base containers mtl STMonadTrans transformers transformers-compat
+       ];
+       testHaskellDepends = [
+         base containers mtl QuickCheck STMonadTrans template-haskell
+         transformers transformers-compat
+       ];
+       description = "Maintaining an equivalence relation implemented as union-find using STT";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "erd" = callPackage
···
      }:
      mkDerivation {
        pname = "fingertree";
-       version = "0.1.4.2";
-       sha256 = "0zvandj8fysck7ygpn0dw5bhrhmj1s63i326nalxbfkh2ls4iacm";
-       libraryHaskellDepends = [ base ];
-       testHaskellDepends = [
-         base HUnit QuickCheck test-framework test-framework-hunit
-         test-framework-quickcheck2
-       ];
-       description = "Generic finger-tree structure, with example instances";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "fingertree_0_1_5_0" = callPackage
-    ({ mkDerivation, base, HUnit, QuickCheck, test-framework
-     , test-framework-hunit, test-framework-quickcheck2
-     }:
-     mkDerivation {
-       pname = "fingertree";
        version = "0.1.5.0";
        sha256 = "0wdzpli8bpgk8lrsp105zb0y5gn1r2029laclvhz264bza93q9pk";
        libraryHaskellDepends = [ base ];
···
        ];
        description = "Generic finger-tree structure, with example instances";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "fingertree-psqueue" = callPackage
···
      }) {};
 
   "formatn" = callPackage
-    ({ mkDerivation, base, containers, text }:
+    ({ mkDerivation, base, containers, QuickCheck, text }:
      mkDerivation {
        pname = "formatn";
-       version = "0.1.0";
-       sha256 = "1svixdvwzxmf5n6vx3pgx065z2gkabk563pp38bmp5z4mxvf67d9";
-       libraryHaskellDepends = [ base containers text ];
+       version = "0.2.0";
+       sha256 = "1hgrii092rlxhmf23ckj51rj53qkwljh3rahnm0rz4rpnrm6xxjq";
+       libraryHaskellDepends = [ base containers QuickCheck text ];
        description = "Formatting of doubles";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
        pname = "formatting";
        version = "7.1.3";
        sha256 = "1vrc2i1b6lxx2aq5hysfl3gl6miq2wbhxc384axvgrkqjbibnqc0";
-       revision = "1";
-       editedCabalFile = "046cm1jvxmsmpclrwmwc1pj90f2qdhd5ysya0ckzqrc3ls6fgcxz";
+       revision = "2";
+       editedCabalFile = "1i3qkhxqhvqd7mqfdc1mbizw1fin7vp4dwzayc2y0sqcbg7kkns7";
        libraryHaskellDepends = [
          base clock double-conversion ghc-prim old-locale scientific text
          time transformers
···
        pname = "fourmolu";
        version = "0.5.0.1";
        sha256 = "1dal9nl08g4c8pjkn8nbk5rxbdlnl9bbavybv52kzry7qhlg71px";
+       revision = "1";
+       editedCabalFile = "1jkam52bff82id2bhwmwxi52d3k85pami2530qp6xci1h488gqyh";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "freckle-app";
-       version = "1.0.2.3";
-       sha256 = "05khvp1gr3ngrcfz4ly9zjmxp8pdiyjmmbrc4pv2rrlpgmnj1zfk";
+       version = "1.0.2.6";
+       sha256 = "0fkvpc9glzp4xm21nqvn1hfv9704hxyqrvmhl6z5qn43dv97srvf";
        libraryHaskellDepends = [
          aeson ansi-terminal base bytestring case-insensitive conduit
          containers data-default datadog doctest ekg-core errors exceptions
···
      }:
      mkDerivation {
        pname = "futhark-server";
-       version = "1.1.2.0";
-       sha256 = "09kc04j5lajzc4k335sc9vcj0i0is939qvrkk10k4ib9a64nrli1";
+       version = "1.1.2.1";
+       sha256 = "0hbglw570j09r8f7cxcyn7dr99iykw94p6fglncw8l210jvcffbm";
        libraryHaskellDepends = [
          base binary bytestring directory futhark-data mtl process temporary
          text
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "ghc-exactprint_1_5_0" = callPackage
+    ({ mkDerivation }:
+     mkDerivation {
+       pname = "ghc-exactprint";
+       version = "1.5.0";
+       sha256 = "07m4cg47knrrvpyimnbc0nq9176vkzwwa64b2iqfj6azn6q2hagp";
+       isLibrary = true;
+       isExecutable = true;
+       description = "ExactPrint for GHC";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ghc-gc-tune" = callPackage
     ({ mkDerivation, base, directory, filepath, process }:
      mkDerivation {
···
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
        broken = true;
+     }) {};
+
+  "ghc-hs-meta" = callPackage
+    ({ mkDerivation, base, bytestring, ghc, ghc-boot, hspec
+     , template-haskell
+     }:
+     mkDerivation {
+       pname = "ghc-hs-meta";
+       version = "0.1.0.0";
+       sha256 = "0csbhd6agq3siwrlkjc063jynzxplpwi3x288kw3hhaz5nz1v3ck";
+       libraryHaskellDepends = [
+         base bytestring ghc ghc-boot template-haskell
+       ];
+       testHaskellDepends = [
+         base bytestring ghc ghc-boot hspec template-haskell
+       ];
+       description = "Translate Haskell source to Template Haskell expression";
+       license = lib.licenses.bsd3;
      }) {};
 
   "ghc-imported-from" = callPackage
···
      }:
      mkDerivation {
        pname = "ghc-source-gen";
-       version = "0.4.2.0";
-       sha256 = "1cb4yb48xzpdlrbw3gp6gf6nmjgyy0i9yzh63scl872allv8jfm3";
-       libraryHaskellDepends = [ base ghc ];
-       testHaskellDepends = [
-         base ghc ghc-paths QuickCheck tasty tasty-hunit tasty-quickcheck
-       ];
-       description = "Constructs Haskell syntax trees for the GHC API";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "ghc-source-gen_0_4_3_0" = callPackage
-    ({ mkDerivation, base, ghc, ghc-paths, QuickCheck, tasty
-     , tasty-hunit, tasty-quickcheck
-     }:
-     mkDerivation {
-       pname = "ghc-source-gen";
        version = "0.4.3.0";
        sha256 = "1lhqsklibgiv51hs8mnrkn784rc5sxf5z8cfv8hf9jqlny50720f";
        libraryHaskellDepends = [ base ghc ];
···
        ];
        description = "Constructs Haskell syntax trees for the GHC API";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ghc-srcspan-plugin" = callPackage
···
        pname = "goldplate";
        version = "0.2.0";
        sha256 = "1f2n981676ykrv08fgdj87mj5r4841a18ywvgpc2hgapsgwbgma1";
-       revision = "1";
-       editedCabalFile = "09lsr2pvdrlaik4icyd18yiwnm4p87831pl3bbljmdsdc4rbwkp0";
+       revision = "2";
+       editedCabalFile = "1wnpg7147k48nca58lp3xg8dv38jnj8k2hdbv0312d9ndqpiws8b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
     ({ mkDerivation, aeson, base, bytestring, containers, exceptions
      , filepath, generic-deriving, generic-random, HUnit, lens
      , lens-aeson, mtl, QuickCheck, quickcheck-instances, random
-     , raw-strings-qq, retry, tasty, tasty-hunit, tasty-quickcheck, text
-     , time, transformers, unix, unliftio, unordered-containers, vector
-     , wreq
+     , raw-strings-qq, retry, tasty, tasty-discover, tasty-hunit
+     , tasty-quickcheck, text, time, transformers, unix, unliftio
+     , unordered-containers, vector, wreq
      }:
      mkDerivation {
        pname = "gopro-plus";
-       version = "0.6.0.4";
-       sha256 = "0w0nbrbv7vb9i19wqn1za1prhj9bglqm1ac0sp1jpv8vbksiv21w";
+       version = "0.6.1.1";
+       sha256 = "1nip991jcv1pqa5zb83wdbf6pnimzp9d39az9zbvlvgkrrnkf522";
        libraryHaskellDepends = [
          aeson base bytestring containers exceptions filepath
          generic-deriving generic-random lens lens-aeson mtl QuickCheck
···
          aeson base bytestring containers exceptions filepath
          generic-deriving generic-random HUnit lens lens-aeson mtl
          QuickCheck quickcheck-instances random raw-strings-qq retry tasty
-         tasty-hunit tasty-quickcheck text time transformers unix unliftio
-         unordered-containers vector wreq
+         tasty-discover tasty-hunit tasty-quickcheck text time transformers
+         unix unliftio unordered-containers vector wreq
        ];
+       testToolDepends = [ tasty-discover ];
        description = "GoPro Plus Client API";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
        pname = "hakyll";
        version = "4.15.1.1";
        sha256 = "0b3bw275q1xbx8qs9a6gzzs3c9z3qdj7skqhpp09jkchi5kdvhvi";
+       revision = "1";
+       editedCabalFile = "020nb84lc4xl87zysy5v81f91aw494r5aa917z08vw2zsd3jdl9g";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "happstack-authenticate";
-       version = "2.4.1.1";
-       sha256 = "164pjybk054a3h3ydfakzibngpmp8a4cbzg0sip9slfb739nz25j";
+       version = "2.5.1";
+       sha256 = "13v128xcjdflzqiszal8iwbnp0ia02p2n52hwlhvb5ip2c4gipkm";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          acid-state aeson authenticate base base64-bytestring boomerang
···
      }:
      mkDerivation {
        pname = "haskell-language-server";
-       version = "1.6.1.0";
-       sha256 = "1dc711b46kilb7dqr19m63hc20q2nzy5c6p5dzg3a4g5ixkaimwl";
+       version = "1.6.1.1";
+       sha256 = "03z650zk7ma0gsmb7mirzarwg0535kwmwyf0h8a89s8bqfcd5mxf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "haskoin-store";
-       version = "0.64.18";
-       sha256 = "19prs0gz8klr52w0kiad7s26mpr352i4q98ixdn2409di4mzl42x";
+       version = "0.64.19";
+       sha256 = "1vbq7wq26lc1kknrfcrxlvfbadkxjrzbv6biqkvwylg3m7iwdd7d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "haskoin-store-data";
-       version = "0.64.18";
-       sha256 = "0kpzvl4xv4gxln9qcnlg658fakjr6j1yxxz8f6ixn8bsaqmaicrx";
+       version = "0.64.19";
+       sha256 = "1ik200gd6lzd86kcfksjs49025ym47byih1k4aghck6hc55dh3jf";
        libraryHaskellDepends = [
          aeson base binary bytes bytestring cereal containers data-default
          deepseq hashable haskoin-core http-client http-types lens mtl
···
        license = lib.licenses.mit;
      }) {};
 
+  "hasql-optparse-applicative_0_3_0_8" = callPackage
+    ({ mkDerivation, base-prelude, hasql, hasql-pool
+     , optparse-applicative
+     }:
+     mkDerivation {
+       pname = "hasql-optparse-applicative";
+       version = "0.3.0.8";
+       sha256 = "1yx56vi1dpymxk5c3rkk74bbghcxfp6x333xn2j4x2ls38676dvg";
+       libraryHaskellDepends = [
+         base-prelude hasql hasql-pool optparse-applicative
+       ];
+       description = "\"optparse-applicative\" parsers for \"hasql\"";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hasql-pipes" = callPackage
     ({ mkDerivation, base, bytestring-tree-builder, hasql, pipes
      , pipes-safe, protolude
···
        broken = true;
      }) {};
 
+  "hasql-streams-conduit" = callPackage
+    ({ mkDerivation, base, conduit, hasql, hasql-streams-core
+     , hasql-transaction-io, transformers
+     }:
+     mkDerivation {
+       pname = "hasql-streams-conduit";
+       version = "0.1.0.0";
+       sha256 = "0cv6lzn6pax98ch1qm5yjxdg3p4z6k4bjvmcz1srr9hqda2bv15b";
+       libraryHaskellDepends = [
+         base conduit hasql hasql-streams-core hasql-transaction-io
+         transformers
+       ];
+       description = "Stream Hasql queries with Conduit";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "hasql-streams-core" = callPackage
+    ({ mkDerivation, base, hasql, hasql-transaction-io }:
+     mkDerivation {
+       pname = "hasql-streams-core";
+       version = "0.1.0.0";
+       sha256 = "01dqqs0daknyz4zn6dq13zyw5fky8ahq2mwv9kra1zl30f6xd3kh";
+       libraryHaskellDepends = [ base hasql hasql-transaction-io ];
+       description = "Stream Hasql queries";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "hasql-streams-example" = callPackage
+    ({ mkDerivation, base, bytestring, conduit, hasql
+     , hasql-streams-conduit, hasql-streams-pipes
+     , hasql-streams-streaming, hasql-streams-streamly, hasql-th
+     , hasql-transaction, hasql-transaction-io, mtl, pipes, rel8
+     , resourcet, safe-exceptions, streaming, streamly, text
+     , unliftio-core
+     }:
+     mkDerivation {
+       pname = "hasql-streams-example";
+       version = "0.1.0.0";
+       sha256 = "1mj5jg1mjsn08yn1ndia1wyygbrn62dbj7fw6y2gkmqz5aysip86";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base bytestring conduit hasql hasql-streams-conduit
+         hasql-streams-pipes hasql-streams-streaming hasql-streams-streamly
+         hasql-th hasql-transaction hasql-transaction-io mtl pipes rel8
+         resourcet safe-exceptions streaming streamly text unliftio-core
+       ];
+       description = "An example program that shows how to use Hasql streams with Rel8";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "hasql-streams-pipes" = callPackage
+    ({ mkDerivation, base, hasql, hasql-streams-core
+     , hasql-transaction-io, pipes, transformers
+     }:
+     mkDerivation {
+       pname = "hasql-streams-pipes";
+       version = "0.1.0.0";
+       sha256 = "1gnlz8zq1k9gngg7qyxbiyvypmjfd1idykad8vq3q3rjwxjp4i0j";
+       libraryHaskellDepends = [
+         base hasql hasql-streams-core hasql-transaction-io pipes
+         transformers
+       ];
+       description = "Stream Hasql queries with Pipes";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "hasql-streams-streaming" = callPackage
+    ({ mkDerivation, base, hasql, hasql-streams-core
+     , hasql-transaction-io, streaming, transformers
+     }:
+     mkDerivation {
+       pname = "hasql-streams-streaming";
+       version = "0.1.0.0";
+       sha256 = "0qmwm6skp8llsj43rzkkl55if7qmgrg3lrc8nknil3z9282pbx9r";
+       libraryHaskellDepends = [
+         base hasql hasql-streams-core hasql-transaction-io streaming
+         transformers
+       ];
+       description = "Stream Hasql queries with Streaming";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "hasql-streams-streamly" = callPackage
+    ({ mkDerivation, base, hasql, hasql-streams-core
+     , hasql-transaction-io, streamly, transformers
+     }:
+     mkDerivation {
+       pname = "hasql-streams-streamly";
+       version = "0.1.0.0";
+       sha256 = "08afl6cb86q46cfr86y3zzdrh6rfvj5s6l91v3y2v9mr56yr1knl";
+       libraryHaskellDepends = [
+         base hasql hasql-streams-core hasql-transaction-io streamly
+         transformers
+       ];
+       description = "Stream Hasql queries with Streamly";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hasql-th" = callPackage
     ({ mkDerivation, base, bytestring, containers, contravariant, foldl
      , hasql, postgresql-syntax, template-haskell
···
      }:
      mkDerivation {
     ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
-       version = "0.3.2.1";
-    ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
+       version = "0.3.2.2";
+       sha256 = "0cav6m9h4wbawzy1kpbhlm3lqsgbvsl41znya1vpdmbgn0a416mf";
        libraryHaskellDepends = [
     ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
     ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
···
 
     ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
     ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
-    ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
+     , mtl, template-haskell, text, text-format-heavy, unliftio-core
      }:
      mkDerivation {
     ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
-       version = "0.2.0.0";
-    ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
+       version = "0.2.1.1";
+       sha256 = "18pcg16v0azjzvc9dsr46s3y7wx5sz4i4lmly3d1rk2hwxc29r2q";
        libraryHaskellDepends = [
     ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
-    ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
+         text text-format-heavy unliftio-core
        ];
        testHaskellDepends = [
     ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
-    ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
+         text text-format-heavy unliftio-core
        ];
     ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
      mkDerivation {
     ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
-       version = "0.0.1.4";
-    ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
-    ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
-    ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
-    ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
-       license = lib.licenses.bsd3;
-     }) {};
-
-    ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
-    ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
-     mkDerivation {
-    ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
        version = "0.0.1.5";
     ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
     ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
     ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
     ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
     ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
···
     ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
        version = "1.0";
     ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
+       revision = "1";
+       editedCabalFile = "1rl2mf182yrlpgcm2130lsnq5jwrcpp16x6p47i27kjrpbm55g54";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hs-opentelemetry-api";
-       version = "0.0.3.0";
-       sha256 = "03h84hks4g7nvkr38li5f59vcm48if7zjjcwcyx6kakk6hikmwx1";
+       version = "0.0.3.1";
+       sha256 = "04mhiqk8xbm07dfqc33vwzxd0kwb9jxqbfzd3pc4qvfpkkygmy7v";
        libraryHaskellDepends = [
          async attoparsec base binary bytestring charset clock containers
          ghc-prim hashable http-types memory mtl template-haskell text
···
      }:
      mkDerivation {
        pname = "hs-opentelemetry-instrumentation-http-client";
-       version = "0.0.1.1";
-       sha256 = "0rhskdibz7g87b04yr44yqxfjf28iavf2akp4m9104yp8vf099hb";
+       version = "0.0.2.0";
+       sha256 = "1miw1p8dzwsnmdl63jyrbw8lygb5gk1j76dix9pmpsjp2520977j";
        libraryHaskellDepends = [
          aeson base bytestring case-insensitive conduit hs-opentelemetry-api
          hs-opentelemetry-instrumentation-conduit http-client
···
      }:
      mkDerivation {
        pname = "hsaml2";
-       version = "0.1.1";
-       sha256 = "1jlsmsnrr3ya7az4mpb6f2spwcw3m45yzix2p3lkajbz8a6kfzac";
+       version = "0.1.2";
+       sha256 = "06vnnq5lvx3wrh6jl64vcm14fi4yj2yv9q424p2ixn55x0bsfk3i";
        libraryHaskellDepends = [
          asn1-encoding asn1-types base base64-bytestring bytestring
          cryptonite data-default http-types hxt hxt-charproperties
···
        ];
        libraryPkgconfigDepends = [ libxml2 ];
        testHaskellDepends = [
-         base base64-bytestring bytestring cryptonite HUnit hxt hxt-http
-         network-uri semigroups string-conversions time x509
+         base base64-bytestring bytestring cryptonite http-types HUnit hxt
+         hxt-http network-uri semigroups string-conversions time x509
        ];
        description = "OASIS Security Assertion Markup Language (SAML) V2.0";
        license = lib.licenses.asl20;
···
        license = lib.licenses.mit;
      }) {};
 
-  "hslua-module-doclayout_1_0_1" = callPackage
+  "hslua-module-doclayout_1_0_2" = callPackage
     ({ mkDerivation, base, doclayout, hslua, tasty, tasty-hunit
      , tasty-lua, text
      }:
      mkDerivation {
        pname = "hslua-module-doclayout";
-       version = "1.0.1";
-       sha256 = "05k4cpi3mpm9gialy0m8by808xl8nc6ccjwfqhh1sp4xm46zp0px";
+       version = "1.0.2";
+       sha256 = "06r1vz2xpvmwd6pghq0g38h3xzagy9043zjqx0ilnxhdx5v5fwcd";
        libraryHaskellDepends = [ base doclayout hslua text ];
        testHaskellDepends = [
          base doclayout hslua tasty tasty-hunit tasty-lua
···
        pname = "htoml-megaparsec";
        version = "2.1.0.4";
        sha256 = "08pka0z97b461bf45nvh9gymbvbwhn2dh70dy7x22xmzrigxnxw1";
+       revision = "1";
+       editedCabalFile = "0sziwadc2wlkfpip65d0v2wl6ldlcbn1fww4bwgw4rvmfhyrwbbc";
        libraryHaskellDepends = [
          base composition-prelude containers deepseq megaparsec mtl text
          time unordered-containers vector
···
        license = lib.licenses.mit;
      }) {};
 
-  "http-client_0_7_10" = callPackage
+  "http-client_0_7_11" = callPackage
     ({ mkDerivation, array, async, base, base64-bytestring
      , blaze-builder, bytestring, case-insensitive, containers, cookie
      , deepseq, directory, exceptions, filepath, ghc-prim, hspec
-     , http-types, iproute, mime-types, monad-control, network
-     , network-uri, random, stm, streaming-commons, text, time
+     , hspec-discover, http-types, iproute, mime-types, monad-control
+     , network, network-uri, random, stm, streaming-commons, text, time
      , transformers, zlib
      }:
      mkDerivation {
        pname = "http-client";
-       version = "0.7.10";
-       sha256 = "1rypq8hvnsb5g5hhhfhjym5lvvkz82z7yg5d8078scmhzb3r2ck2";
+       version = "0.7.11";
+       sha256 = "12j7vkpkm2djws6ny7vm2324c7916d0iaf1mbvf4mfjxzy2w7imv";
        libraryHaskellDepends = [
-         array base base64-bytestring blaze-builder bytestring
+         array async base base64-bytestring blaze-builder bytestring
          case-insensitive containers cookie deepseq exceptions filepath
          ghc-prim http-types iproute mime-types network network-uri random
          stm streaming-commons text time transformers
···
          cookie deepseq directory hspec http-types monad-control network
          network-uri streaming-commons text time transformers zlib
        ];
+       testToolDepends = [ hspec-discover ];
        doCheck = false;
        description = "An HTTP client engine";
        license = lib.licenses.mit;
···
        doCheck = false;
        description = "http-client backend using the connection package and tls library";
        license = lib.licenses.mit;
+     }) {};
+
+  "http-client-tls_0_3_6" = callPackage
+    ({ mkDerivation, base, bytestring, case-insensitive, connection
+     , containers, cryptonite, data-default-class, exceptions, gauge
+     , hspec, http-client, http-types, memory, network, network-uri
+     , text, tls, transformers
+     }:
+     mkDerivation {
+       pname = "http-client-tls";
+       version = "0.3.6";
+       sha256 = "0c6pbkvk25z7xnv88mkjysfqvqjs1vmbxrdcrblald44nbs2prvd";
+       libraryHaskellDepends = [
+         base bytestring case-insensitive connection containers cryptonite
+         data-default-class exceptions http-client http-types memory network
+         network-uri text tls transformers
+       ];
+       testHaskellDepends = [
+         base connection hspec http-client http-types
+       ];
+       benchmarkHaskellDepends = [ base gauge http-client ];
+       doCheck = false;
+       description = "http-client backend using the connection package and tls library";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "http-client-websockets" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "http-streams_0_8_9_6" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, attoparsec, base
+     , base64-bytestring, blaze-builder, bytestring, case-insensitive
+     , directory, filepath, ghc-prim, HsOpenSSL, hspec
+     , hspec-expectations, http-common, HUnit, io-streams, lifted-base
+     , mtl, network, network-uri, openssl-streams, random, snap-core
+     , snap-server, text, transformers, unordered-containers
+     }:
+     mkDerivation {
+       pname = "http-streams";
+       version = "0.8.9.6";
+       sha256 = "1h8nnp1y4ngv6mwr3fxv428kcvrd3ming179sza8fkn49pcwdlxs";
+       libraryHaskellDepends = [
+         aeson attoparsec base base64-bytestring blaze-builder bytestring
+         case-insensitive directory filepath HsOpenSSL http-common
+         io-streams mtl network network-uri openssl-streams text
+         transformers unordered-containers
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty attoparsec base base64-bytestring blaze-builder
+         bytestring case-insensitive directory ghc-prim HsOpenSSL hspec
+         hspec-expectations http-common HUnit io-streams lifted-base mtl
+         network network-uri openssl-streams random snap-core snap-server
+         text transformers unordered-containers
+       ];
+       description = "An HTTP client using io-streams";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "http-test" = callPackage
     ({ mkDerivation, aeson, base, bytestring, http-client, lens
      , lens-aeson, mtl, tasty, tasty-hunit, text, time, wreq
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "hypergeometric";
-       version = "0.1.0.0";
-       sha256 = "0fpwn13bmx750k6ch79aa2alh2dhc2sjdj95272knhc3khp9zxi9";
+       version = "0.1.1.0";
+       sha256 = "0wajl2wyxy7j44khx9bipwvz0z1dqazwym3bk5w997b8f87irpfk";
        libraryHaskellDepends = [ base ];
        description = "Hypergeometric functions";
        license = lib.licenses.agpl3Only;
···
      }:
      mkDerivation {
        pname = "katip-wai";
-       version = "0.1.0.0";
-       sha256 = "1y7f7a0pa9gdp9cvbdqd4xfrd5gazp2wy92hjmrf1fvp35xv1b2f";
+       version = "0.1.1.0";
+       sha256 = "0ajwa6ya0azbffcz2cpsd2kd8fy2s2hbklyj604f27pghl7fki06";
        libraryHaskellDepends = [
          aeson base bytestring clock http-types katip network text uuid wai
        ];
···
        pname = "language-c";
        version = "0.9.0.1";
        sha256 = "01yj353n85qcv9zvaf19f1260rip26h6gxqahplkx9fy7ybbnk6l";
+       revision = "1";
+       editedCabalFile = "0wvrvfphz5r2yqxgxfn0ki9vmqhxh49qx41xdidmibp5i826c2mn";
        libraryHaskellDepends = [
          array base bytestring containers deepseq directory filepath mtl
          pretty process
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "lapack-ffi-tools_0_1_3" = callPackage
+    ({ mkDerivation, base, bytestring, cassava, containers
+     , explicit-exception, filepath, non-empty, optparse-applicative
+     , parsec, pathtype, transformers, unordered-containers, utility-ht
+     , vector
+     }:
+     mkDerivation {
+       pname = "lapack-ffi-tools";
+       version = "0.1.3";
+       sha256 = "0qk5a43w8xn8pp9bhmjmjyvriiin2dyf4nvk13w858hsxyx6xqkx";
+       isLibrary = false;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       executableHaskellDepends = [
+         base bytestring cassava containers explicit-exception filepath
+         non-empty optparse-applicative parsec pathtype transformers
+         unordered-containers utility-ht vector
+       ];
+       description = "Generator for Haskell interface to Fortran LAPACK";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "lapack-hmatrix" = callPackage
     ({ mkDerivation, base, comfort-array, hmatrix, lapack, netlib-ffi
      , transformers, utility-ht, vector
···
        pname = "lentil";
        version = "1.5.3.2";
        sha256 = "0knc3g5n6h0yzr0kpgmgk44kbwh200qafjdvwpca92n3s0wf76py";
-       revision = "1";
-       editedCabalFile = "07f2bmplq73fvr2qylaz5w1p5ma20nrs32jwf1gbndp3cqklwjzi";
+       revision = "2";
+       editedCabalFile = "0n5wklh6f33c9yzblxwbx3mx04fxdx7mmqp551z9xfy6nnwg8hrp";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "lifx-lan";
-       version = "0.6.0.1";
-       sha256 = "0fld72ndissfkpqzkzxvqgqqpjvii8slb5vdz4h9w5s1fzpz8rvj";
+       version = "0.6.2";
+       sha256 = "1lshzfgx0cgjqpxlknbsqwvhkmn2jc30zgyzj7lsr3jqqr41zssn";
        libraryHaskellDepends = [
          base binary bytestring composition containers extra monad-loops mtl
          network random safe text time transformers
···
        license = lib.licenses.mit;
      }) {};
 
-  "literatex_0_2_0_1" = callPackage
+  "literatex_0_2_0_2" = callPackage
     ({ mkDerivation, ansi-wl-pprint, base, bytestring, conduit
      , filepath, optparse-applicative, tasty, tasty-hunit, text, ttc
      , unliftio
      }:
      mkDerivation {
        pname = "literatex";
-       version = "0.2.0.1";
-       sha256 = "0rc8ks4z9sb99ziv1ancdypsbfhb7qpyi4ha76rmq4jhs7kznkcq";
+       version = "0.2.0.2";
+       sha256 = "1j82z5q6dzgi7b8si0fzxa3zv8rgqdhwm82sxh3wqsb6z1jfwk37";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "loc";
        version = "0.1.3.16";
        sha256 = "0bizqfczhc5higdzrrhinr5q3s971a3klfl3gpffnq9gyzd16nrq";
+       revision = "1";
+       editedCabalFile = "1j3xgxyfqby8nca2xs0x5lvvq1pyhadkzkgrwzlkckxvhghv231h";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [ base containers doctest hedgehog ];
        description = "Types representing line and column positions and ranges in text files";
···
        pname = "loc-test";
        version = "0.1.3.10";
        sha256 = "0mppiz4nv86mfdk43w83jx3wn8c6w7g9k3m3jhgmwlgqpcpdrryd";
+       revision = "1";
+       editedCabalFile = "0cv2w939gdz5n8mip3d6rp7zs2s28synll1k3pbgp9w42mcw52lw";
        libraryHaskellDepends = [ base containers hedgehog loc ];
        description = "Test-related utilities related to the /loc/ package";
        license = lib.licenses.asl20;
···
      }:
      mkDerivation {
        pname = "localize";
-       version = "0.2.0.0";
-       sha256 = "1c0y3blyr36qrbqwnrb802h7nl6m3qzch4ivzajjan9xj5cbbswh";
+       version = "0.2.0.1";
+       sha256 = "1h1jarc6rg0ncb8grk0xf8jzjkxpiyc08jiz9qryh495v8fshdcm";
        libraryHaskellDepends = [
          base binary bytestring containers data-default directory filepath
          Glob haskell-gettext mtl setlocale text text-format-heavy time
···
   "matrix-client" = callPackage
     ({ mkDerivation, aeson, aeson-casing, aeson-pretty, base, base64
      , bytestring, containers, exceptions, hashable, hspec, http-client
-     , http-client-tls, http-types, profunctors, retry, SHA, text, time
-     , unordered-containers
+     , http-client-tls, http-types, network-uri, profunctors, retry, SHA
+     , text, time, unordered-containers
      }:
      mkDerivation {
        pname = "matrix-client";
-       version = "0.1.3.0";
-       sha256 = "14vsz507l93zdddr3k6rwvqwpwdmsansv5ryq87k58v04fyfmvz6";
+       version = "0.1.4.0";
+       sha256 = "1adcg3c3lar5c0cxhbgy8whlcm28xhnvbhk5qgfnss6b35bhsajk";
        libraryHaskellDepends = [
          aeson aeson-casing base base64 bytestring containers exceptions
-         hashable http-client http-client-tls http-types profunctors retry
-         SHA text time unordered-containers
+         hashable http-client http-client-tls http-types network-uri
+         profunctors retry SHA text time unordered-containers
        ];
        testHaskellDepends = [
          aeson aeson-casing aeson-pretty base base64 bytestring containers
          exceptions hashable hspec http-client http-client-tls http-types
-         profunctors retry SHA text time unordered-containers
+         network-uri profunctors retry SHA text time unordered-containers
        ];
        description = "A matrix client library";
        license = lib.licenses.asl20;
···
        license = lib.licenses.gpl3Only;
      }) {};
 
+  "med-module_0_1_2_2" = callPackage
+    ({ mkDerivation, base, bytestring, storable-endian, transformers
+     , utility-ht
+     }:
+     mkDerivation {
+       pname = "med-module";
+       version = "0.1.2.2";
+       sha256 = "0qvwz49xz4bbhkkh9c7zjqzvbdhmgnraxpj8a4fc5lf0yb1k79ba";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring storable-endian transformers utility-ht
+       ];
+       description = "Parse song module files from Amiga MED and OctaMED";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "medea" = callPackage
     ({ mkDerivation, aeson, algebraic-graphs, base, bytestring
      , containers, deepseq, directory, filepath, free, hashable, hspec
···
        pname = "midi-music-box";
        version = "0.0.1.2";
        sha256 = "0rnjwis6y0lnyfjxnxqk3zsh78ylccq5v21avb97vybmj0pld1l9";
-       revision = "1";
-       editedCabalFile = "1z8ahx8hkg1gciddin86w7x136y49i6ymwvkjmf28a397kkxmcb7";
+       revision = "2";
+       editedCabalFile = "1w595kidg493vnv871ga2xsh94g2f80yxn4k5mlrm0jip45xxi7m";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
 
   "midimory" = callPackage
     ({ mkDerivation, alsa-core, alsa-seq, array, base, containers
-     , optparse-applicative, random, transformers, utility-ht, wx
-     , wxcore
+     , optparse-applicative, random, shell-utility, transformers
+     , utility-ht, wx, wxcore
      }:
      mkDerivation {
        pname = "midimory";
-       version = "0.0.2.1";
-       sha256 = "07p0f7a0nm7h8li8rl6adrszrz7hhzn19mfy0vgkw8axdaira66r";
+       version = "0.0.2.2";
+       sha256 = "01zbwkx9aalxyqa7x59sqb3qagkabvsn6q57j8f7xavgch6cljiq";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
          alsa-core alsa-seq array base containers optparse-applicative
-         random transformers utility-ht wx wxcore
+         random shell-utility transformers utility-ht wx wxcore
        ];
        description = "A Memory-like (Concentration, Pairs, ...) game for tones";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "modern-uri_0_3_4_3" = callPackage
+    ({ mkDerivation, base, bytestring, containers, contravariant
+     , criterion, deepseq, exceptions, hspec, hspec-discover
+     , hspec-megaparsec, megaparsec, mtl, profunctors, QuickCheck
+     , reflection, tagged, template-haskell, text, weigh
+     }:
+     mkDerivation {
+       pname = "modern-uri";
+       version = "0.3.4.3";
+       sha256 = "0904ff8pzcbk1swp0s1v5js468qnf3ccyzfcvaa62nsaj4qb7shq";
+       libraryHaskellDepends = [
+         base bytestring containers contravariant deepseq exceptions
+         megaparsec mtl profunctors QuickCheck reflection tagged
+         template-haskell text
+       ];
+       testHaskellDepends = [
+         base bytestring hspec hspec-megaparsec megaparsec QuickCheck text
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         base bytestring criterion deepseq megaparsec text weigh
+       ];
+       description = "Modern library for working with URIs";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "modify-fasta" = callPackage
     ({ mkDerivation, base, containers, fasta, mtl, optparse-applicative
      , pipes, pipes-text, regex-tdfa, regex-tdfa-text, semigroups, split
···
      }:
      mkDerivation {
        pname = "monoid-subclasses";
-       version = "1.1.2";
-       sha256 = "0c9amb4yw6487kbpy3gslhpzjkzz3kiwhzz9qrmv8l7cvc2m1cb3";
-       libraryHaskellDepends = [
-         base bytestring containers primes text vector
-       ];
-       testHaskellDepends = [
-         base bytestring containers primes QuickCheck quickcheck-instances
-         tasty tasty-quickcheck text vector
-       ];
-       description = "Subclasses of Monoid";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "monoid-subclasses_1_1_3" = callPackage
-    ({ mkDerivation, base, bytestring, containers, primes, QuickCheck
-     , quickcheck-instances, tasty, tasty-quickcheck, text, vector
-     }:
-     mkDerivation {
-       pname = "monoid-subclasses";
        version = "1.1.3";
        sha256 = "1nglki10rlpi872p55pa8g809q5sna7yzh3zw4rqfhq89kb15wcv";
        libraryHaskellDepends = [
···
        ];
        description = "Subclasses of Monoid";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "monoid-transformer" = callPackage
···
      }:
      mkDerivation {
        pname = "multistate";
-       version = "0.8.0.3";
-       sha256 = "0sbrm28rjw4qgpn8p0974ljkgi30d4akbngjm58kf96x9zp7ln8g";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base monad-control mtl tagged transformers transformers-base
-       ];
-       testHaskellDepends = [ base hspec transformers ];
-       description = "like mtl's ReaderT / WriterT / StateT, but more than one contained value/type";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "multistate_0_8_0_4" = callPackage
-    ({ mkDerivation, base, hspec, monad-control, mtl, tagged
-     , transformers, transformers-base
-     }:
-     mkDerivation {
-       pname = "multistate";
        version = "0.8.0.4";
        sha256 = "0y42c21ha0chqhrn40a4bikdbirsw7aqg4i866frpagz1ivr915q";
        isLibrary = true;
···
        testHaskellDepends = [ base hspec transformers ];
        description = "like mtl's ReaderT / WriterT / StateT, but more than one contained value/type";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "multivariant" = callPackage
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "network-info";
-       version = "0.2.0.10";
-       sha256 = "0anmgzcpnz7nw3n6vq0r25m1s9l2svpwi83wza0lzkrlbnbzd02n";
-       revision = "1";
-       editedCabalFile = "07kiw56lhc56kqrnvpa11f5nnnid6by3aq00jrkcbbg7w0q71a6d";
-       libraryHaskellDepends = [ base ];
-       description = "Access the local computer's basic network configuration";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "network-info_0_2_1" = callPackage
-    ({ mkDerivation, base }:
-     mkDerivation {
-       pname = "network-info";
        version = "0.2.1";
        sha256 = "015lm3b8n8sb16qsffjxz1jvijyy0z600ch0sm8h6a685wqqhbcv";
        libraryHaskellDepends = [ base ];
        description = "Access the local computer's basic network configuration";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "network-interfacerequest" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "nri-env-parser_0_1_0_8" = callPackage
+    ({ mkDerivation, base, modern-uri, network-uri, nri-prelude, text
+     }:
+     mkDerivation {
+       pname = "nri-env-parser";
+       version = "0.1.0.8";
+       sha256 = "0hwl363iya38hi021an2l4cinclz1p96n4lck2x9yi9cf4yfqzk8";
+       libraryHaskellDepends = [
+         base modern-uri network-uri nri-prelude text
+       ];
+       description = "Read environment variables as settings to build 12-factor apps";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "nri-http" = callPackage
     ({ mkDerivation, aeson, base, bytestring, conduit, http-client
      , http-client-tls, http-types, mime-types, network-uri
···
      }:
      mkDerivation {
        pname = "nri-http";
-       version = "0.1.0.3";
-       sha256 = "1km4jv0g79455m3687cpihzz14pxg3wxw4r5b21mby7c8knzd1vl";
+       version = "0.1.0.4";
+       sha256 = "1zf55k4c4zlx2229xxs2hfl7y5c0fb3ab7vrms08imfp0hblj91x";
        libraryHaskellDepends = [
          aeson base bytestring conduit http-client http-client-tls
          http-types mime-types network-uri nri-observability nri-prelude
···
      }:
      mkDerivation {
        pname = "nri-kafka";
-       version = "0.1.0.2";
-       sha256 = "0bqpfcivp2hx5s2dmx2jwndia4pwfppslzr3krqwmph1qy3h2v9i";
+       version = "0.1.0.4";
+       sha256 = "1cmrssyr32ks7wy8ypk6wq5daljk26a7yx61jlq2m56p5b0nvam2";
        libraryHaskellDepends = [
          aeson async base bytestring conduit containers hw-kafka-client
          nri-env-parser nri-observability nri-prelude safe-exceptions stm
···
        ];
        description = "Report log spans collected by nri-prelude";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "nri-observability_0_1_1_4" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, async, base, bugsnag-hs
+     , bytestring, conduit, directory, hostname, http-client
+     , http-client-tls, nri-env-parser, nri-prelude, random
+     , safe-exceptions, stm, text, time, unordered-containers, uuid
+     }:
+     mkDerivation {
+       pname = "nri-observability";
+       version = "0.1.1.4";
+       sha256 = "077zj96iapjp6cn38z0g6didpwq866xz5m03d8kbp3pwdmfpr65c";
+       libraryHaskellDepends = [
+         aeson aeson-pretty async base bugsnag-hs bytestring conduit
+         directory hostname http-client http-client-tls nri-env-parser
+         nri-prelude random safe-exceptions stm text time
+         unordered-containers uuid
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty async base bugsnag-hs bytestring conduit
+         directory hostname http-client http-client-tls nri-env-parser
+         nri-prelude random safe-exceptions stm text time
+         unordered-containers uuid
+       ];
+       description = "Report log spans collected by nri-prelude";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "nri-postgresql" = callPackage
···
      }:
      mkDerivation {
        pname = "nri-postgresql";
-       version = "0.1.0.3";
-       sha256 = "0v07b6yq2i2pnfmiaks2vp3yj2ncfr9c3f2fx9sq6hr9z56q8hqd";
+       version = "0.1.0.4";
+       sha256 = "0g5wvpzd6p648hvqrwiadqfzlfsqh2fm2yxmi1ix76a2lsfhbnb9";
        libraryHaskellDepends = [
          attoparsec base bytestring filepath network nri-env-parser
          nri-observability nri-prelude postgresql-typed resource-pool
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "nri-prelude_0_6_0_6" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, async, auto-update, base
+     , bytestring, containers, directory, exceptions, filepath, ghc
+     , hedgehog, junit-xml, lens, pretty-diff, pretty-show
+     , safe-coloured-text, safe-coloured-text-terminfo, safe-exceptions
+     , terminal-size, text, time, unix, vector
+     }:
+     mkDerivation {
+       pname = "nri-prelude";
+       version = "0.6.0.6";
+       sha256 = "1i1y16pc8rph7ahj53jxrhr18qnw114zfb9z0fnd4k2cs0sryyqz";
+       libraryHaskellDepends = [
+         aeson aeson-pretty async auto-update base bytestring containers
+         directory exceptions filepath ghc hedgehog junit-xml lens
+         pretty-diff pretty-show safe-coloured-text
+         safe-coloured-text-terminfo safe-exceptions terminal-size text time
+         unix vector
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty async auto-update base bytestring containers
+         directory exceptions filepath ghc hedgehog junit-xml lens
+         pretty-diff pretty-show safe-coloured-text
+         safe-coloured-text-terminfo safe-exceptions terminal-size text time
+         unix vector
+       ];
+       description = "A Prelude inspired by the Elm programming language";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "nri-redis" = callPackage
     ({ mkDerivation, aeson, async, base, bytestring, conduit, hedis
      , nri-env-parser, nri-observability, nri-prelude, resourcet
···
      }:
      mkDerivation {
        pname = "nri-redis";
-       version = "0.1.0.3";
-       sha256 = "1mdzqvnx7gzr8j99c8nza40y518jg8ajxfrvdvf90gvbglknimb0";
+       version = "0.1.0.4";
+       sha256 = "1ws5j8r4ny8dhw2bf2zqvq42ab9h44ly562cjrl6ha5mlk78mvpq";
        libraryHaskellDepends = [
          aeson async base bytestring conduit hedis nri-env-parser
          nri-observability nri-prelude resourcet safe-exceptions text
···
      }:
      mkDerivation {
        pname = "nri-test-encoding";
-       version = "0.1.1.1";
-       sha256 = "07hrkjbyp07p0yryx92q0bjqkkjji4d952sxcm9j2w5mdvlc08mq";
+       version = "0.1.1.2";
+       sha256 = "1b2k4g1vm3mc72g4j979pk5y9jqn4y1aa394wfzwck7n1jhg8rzb";
        libraryHaskellDepends = [
          aeson aeson-pretty base bytestring filepath nri-prelude nri-redis
          servant servant-auth-server servant-server text
···
        benchmarkHaskellDepends = [ base criterion ];
        description = "Convert numbers to number words";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "numerals-base" = callPackage
···
        broken = true;
      }) {};
 
-  "numhask_0_8_1_0" = callPackage
-    ({ mkDerivation, base }:
+  "numhask_0_10_0_0" = callPackage
+    ({ mkDerivation, base, QuickCheck }:
      mkDerivation {
        pname = "numhask";
-       version = "0.8.1.0";
-       sha256 = "0qq9fr4nm5swarc266mnz5xly296db4nwzm7k5cwsn2pjijmyknk";
+       version = "0.10.0.0";
+       sha256 = "132s0yccg8fhigd6a463lrg2cqx032xfpdirvvfhrczdzirbm7xy";
        libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base QuickCheck ];
        description = "A numeric class hierarchy";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "numhask-array";
-       version = "0.9.1";
-       sha256 = "02xklvpk21h97005xs1ywll83qn3h6845zxp9baljk12b9j4ls1r";
+       version = "0.10.0";
+       sha256 = "0dsjh20y46774hih4ijmr1d50mgm7kz5imah6ynggxmdd595lp0x";
        libraryHaskellDepends = [
          adjunctions base distributive numhask vector
        ];
···
      }:
      mkDerivation {
        pname = "numhask-space";
-       version = "0.8.1.0";
-       sha256 = "1j117m1qfnl5h286x6c8kbm06xpm8rqqkipv1qbw0sp7a0cc022z";
+       version = "0.10.0.0";
+       sha256 = "09x53pmn2skbv1zhjmd4wq5wxhi7sshzg3ksjx1n0fy0x16d19lf";
        libraryHaskellDepends = [
          adjunctions base containers distributive numhask random
          semigroupoids tdigest text time vector
···
        license = lib.licenses.asl20;
      }) {};
 
-  "nvim-hs_2_2_0_0" = callPackage
+  "nvim-hs_2_2_0_1" = callPackage
     ({ mkDerivation, base, bytestring, cereal, cereal-conduit, conduit
      , containers, data-default, deepseq, foreign-store, hslogger, hspec
      , hspec-discover, HUnit, megaparsec, messagepack, mtl, network
···
      }:
      mkDerivation {
        pname = "nvim-hs";
-       version = "2.2.0.0";
-       sha256 = "196szwcd156029hsg0ql3m4zphz3hnz09yic3037hj12yp87fdzf";
+       version = "2.2.0.1";
+       sha256 = "1jj9n792cgv964rpgbbhc491wvyfyiplsg30n20x62gxclmjvir7";
        libraryHaskellDepends = [
          base bytestring cereal cereal-conduit conduit containers
          data-default deepseq foreign-store hslogger megaparsec messagepack
···
        license = lib.licenses.bsd3;
      }) {inherit (pkgs) unixODBC;};
 
+  "odbc_0_2_6" = callPackage
+    ({ mkDerivation, async, attoparsec, base, bytestring, containers
+     , deepseq, formatting, hashable, hspec, optparse-applicative
+     , parsec, QuickCheck, semigroups, template-haskell, text, time
+     , transformers, unixODBC, unliftio-core, weigh
+     }:
+     mkDerivation {
+       pname = "odbc";
+       version = "0.2.6";
+       sha256 = "0yyyjnnlnd3zpvnh55l5gsvakrciml91jaqy5hdgnlpqfslz330r";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         async attoparsec base bytestring containers deepseq formatting
+         hashable parsec semigroups template-haskell text time transformers
+         unliftio-core
+       ];
+       librarySystemDepends = [ unixODBC ];
+       executableHaskellDepends = [
+         base bytestring optparse-applicative text
+       ];
+       testHaskellDepends = [
+         base bytestring hspec parsec QuickCheck text time
+       ];
+       benchmarkHaskellDepends = [ async base text weigh ];
+       description = "Haskell binding to the ODBC API, aimed at SQL Server driver";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) unixODBC;};
+
   "odd-jobs" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers
      , direct-daemonize, directory, either, fast-logger, filepath
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "openapi3_3_2_0" = callPackage
+  "openapi3_3_2_1" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, base-compat-batteries
      , bytestring, Cabal, cabal-doctest, containers, cookie, doctest
      , generics-sop, Glob, hashable, hspec, hspec-discover, http-media
···
      }:
      mkDerivation {
        pname = "openapi3";
-       version = "3.2.0";
-       sha256 = "0xlfjpcl8l7xf8g65hqbiynhqh9yzsm11gm0qaax8mn7hc8k7jji";
-       revision = "1";
-       editedCabalFile = "0mhfsg1mgkanxy9rzhvsn3zibqhbqwsvqj6pawhsnbfn9fcyjmgb";
+       version = "3.2.1";
+       sha256 = "0xspxp5rma3mx5p0qy6mmq94540agl44vkc65sylp5k62x68588d";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal cabal-doctest ];
···
      }) {};
 
   "opencc" = callPackage
-    ({ mkDerivation, base, bytestring, mtl, text, transformers }:
+    ({ mkDerivation, base, bytestring, mtl, opencc, text, transformers
+     }:
      mkDerivation {
        pname = "opencc";
-       version = "0.1.0.0";
-       sha256 = "09gsd816xh0237m94bnysdpjzqngsva3rl29f171rvhdpashcjx2";
+       version = "0.1.1.0";
+       sha256 = "06jz04352bgqnfvzds75n65x352x07ffj8aan01q6m2mjs3xidfa";
        libraryHaskellDepends = [ base bytestring mtl text transformers ];
+       librarySystemDepends = [ opencc ];
        testHaskellDepends = [ base bytestring mtl text transformers ];
        description = "OpenCC bindings";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {};
+     }) {inherit (pkgs) opencc;};
 
   "opench-meteo" = callPackage
     ({ mkDerivation, aeson, base, data-default, text, time }:
···
      }:
      mkDerivation {
        pname = "optima";
-       version = "0.4.0.2";
-       sha256 = "05jpgf4lyq4pg4j98cl2jlax1jjy27knsgjqcbbg38p1n33m7gki";
+       version = "0.4.0.3";
+       sha256 = "0pah3p4f5j8ah2ccb5mpq1dcjrlzvwg6pf0yfqhnq4m7j1nqhzlj";
        libraryHaskellDepends = [
          attoparsec attoparsec-data base optparse-applicative text
          text-builder
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "optparse-applicative_0_17_0_0" = callPackage
+    ({ mkDerivation, ansi-wl-pprint, base, process, QuickCheck
+     , transformers, transformers-compat
+     }:
+     mkDerivation {
+       pname = "optparse-applicative";
+       version = "0.17.0.0";
+       sha256 = "097p1bkvw9r3rvcr65w53yw14drb0s46ldkkl1jbmq5g7m6jwnw2";
+       libraryHaskellDepends = [
+         ansi-wl-pprint base process transformers transformers-compat
+       ];
+       testHaskellDepends = [ base QuickCheck ];
+       description = "Utilities and combinators for parsing command line options";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "optparse-applicative-simple" = callPackage
     ({ mkDerivation, attoparsec, attoparsec-data, base-prelude
      , optparse-applicative, rerebase, text
···
        pname = "optparse-generic";
        version = "1.4.7";
        sha256 = "03s6iwfr2iiypnx3wmnrb37zz7kflk40dj38v8j4ccqxkkf9h0kk";
-       revision = "1";
-       editedCabalFile = "0q3nq4qnsnx875a9vp08hgzhrbq463cdjdc4xlswcalip2qjw4y2";
+       revision = "2";
+       editedCabalFile = "1qypq8841xym39kmlnm0608lghh258azr6d424is96kj340bwlwz";
        libraryHaskellDepends = [
          base bytestring Only optparse-applicative system-filepath text time
          transformers transformers-compat void
···
        license = lib.licenses.mit;
      }) {};
 
+  "padic" = callPackage
+    ({ mkDerivation, base, constraints, criterion, integer-gmp, mod
+     , QuickCheck, tasty, tasty-expected-failure, tasty-hunit
+     , tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "padic";
+       version = "0.1.0.0";
+       sha256 = "1r54aav4305sjp0wg4kkhvgqsgs9pxd3mn2l99iyabc3vd4wzmrr";
+       libraryHaskellDepends = [ base constraints integer-gmp mod ];
+       testHaskellDepends = [
+         base constraints integer-gmp mod QuickCheck tasty
+         tasty-expected-failure tasty-hunit tasty-quickcheck
+       ];
+       benchmarkHaskellDepends = [
+         base constraints criterion integer-gmp mod
+       ];
+       description = "Fast, type-safe p-adic arithmetic";
+       license = lib.licenses.mit;
+     }) {};
+
   "pads-haskell" = callPackage
     ({ mkDerivation, base, byteorder, bytestring, containers, ghc-prim
      , haskell-src-meta, HUnit, mainland-pretty, mtl, mwc-random, parsec
···
     ({ mkDerivation }:
      mkDerivation {
        pname = "pandora";
-       version = "0.5.0";
-       sha256 = "144k1cqb4gkwyh3w01cwsax58n9w3h1giggdb8b0dw64pnhsq8zd";
+       version = "0.5.1";
+       sha256 = "0xx3fjdkxrabwnqhz3bs3rai1q83zkkhq90z50pzam08nng34sw5";
        description = "A box of patterns and paradigms";
        license = lib.licenses.mit;
      }) {};
···
        pname = "park-bench";
        version = "0.1.0";
        sha256 = "0ygj4x3s0s53pwp256ypwarfiwccg3mr7drgjxp41bpc8hs66v4y";
+       revision = "1";
+       editedCabalFile = "07qczda4bmijbz5ci4bazikizbz4fy51c4gw1sqq7hkcfm4rz7ga";
        libraryHaskellDepends = [ base bytestring text ];
        description = "A quick-and-dirty, low-friction benchmark tool with immediate feedback";
        license = lib.licenses.bsd3;
···
      , monad-logger, mtl, path-pieces, QuickCheck, quickcheck-instances
      , resource-pool, resourcet, scientific, shakespeare, silently
      , template-haskell, text, th-lift-instances, time, transformers
-     , unliftio, unliftio-core, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "persistent";
-       version = "2.13.2.2";
-       sha256 = "1pj5svwf85b0yndixlcqzjpqwp50zfqra99qm7hf1hlwq5g4amy9";
-       libraryHaskellDepends = [
-         aeson attoparsec base base64-bytestring blaze-html bytestring
-         conduit containers fast-logger http-api-data lift-type monad-logger
-         mtl path-pieces resource-pool resourcet scientific silently
-         template-haskell text th-lift-instances time transformers unliftio
-         unliftio-core unordered-containers vector
-       ];
-       testHaskellDepends = [
-         aeson attoparsec base base64-bytestring blaze-html bytestring
-         conduit containers fast-logger hspec http-api-data monad-logger mtl
-         path-pieces QuickCheck quickcheck-instances resource-pool resourcet
-         scientific shakespeare silently template-haskell text
-         th-lift-instances time transformers unliftio unliftio-core
-         unordered-containers vector
-       ];
-       benchmarkHaskellDepends = [
-         base criterion deepseq file-embed template-haskell text
-       ];
-       description = "Type-safe, multi-backend data serialization";
-       license = lib.licenses.mit;
-       maintainers = with lib.maintainers; [ psibi ];
-     }) {};
-
-  "persistent_2_13_3_0" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
-     , blaze-html, bytestring, conduit, containers, criterion, deepseq
-     , fast-logger, file-embed, hspec, http-api-data, lift-type
-     , monad-logger, mtl, path-pieces, QuickCheck, quickcheck-instances
-     , resource-pool, resourcet, scientific, shakespeare, silently
-     , template-haskell, text, th-lift-instances, time, transformers
      , unliftio, unliftio-core, unordered-containers, vault, vector
      }:
      mkDerivation {
···
        ];
        description = "Type-safe, multi-backend data serialization";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ psibi ];
      }) {};
 
···
      }:
      mkDerivation {
        pname = "persistent-mysql";
-       version = "2.13.0.2";
-       sha256 = "18ji7a7lb1mjgqvi2mv2cg4vlgjkyzg2hgp09s7c9v071p3ll732";
-       libraryHaskellDepends = [
-         aeson base blaze-builder bytestring conduit containers monad-logger
-         mysql mysql-simple persistent resource-pool resourcet text
-         transformers unliftio-core
-       ];
-       testHaskellDepends = [
-         aeson base bytestring containers fast-logger hspec http-api-data
-         HUnit monad-logger mysql path-pieces persistent persistent-qq
-         persistent-test QuickCheck quickcheck-instances resourcet text time
-         transformers unliftio-core
-       ];
-       description = "Backend for the persistent library using MySQL database server";
-       license = lib.licenses.mit;
-     }) {};
-
-  "persistent-mysql_2_13_1_0" = callPackage
-    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
-     , containers, fast-logger, hspec, http-api-data, HUnit
-     , monad-logger, mysql, mysql-simple, path-pieces, persistent
-     , persistent-qq, persistent-test, QuickCheck, quickcheck-instances
-     , resource-pool, resourcet, text, time, transformers, unliftio-core
-     }:
-     mkDerivation {
-       pname = "persistent-mysql";
        version = "2.13.1.0";
        sha256 = "16balbklf4800pqivmvnamjhy3xvnr9939fz3qkicfs4ba68m62k";
        libraryHaskellDepends = [
···
        ];
        description = "Backend for the persistent library using MySQL database server";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "persistent-mysql-haskell" = callPackage
···
      , postgresql-libpq, postgresql-simple, QuickCheck
      , quickcheck-instances, resource-pool, resourcet
      , string-conversions, text, time, transformers, unliftio
-    ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
-     }:
-     mkDerivation {
-       pname = "persistent-postgresql";
-       version = "2.13.2.2";
-       sha256 = "0giwwndy8f6pr4xvqgkv939x93r3sj2a6rkz4v8xrrrvmgq9hbpi";
-       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_4_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, vault, vector
      }:
      mkDerivation {
···
        ];
        description = "Backend for the persistent library using postgresql";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "persistent-postgresql-streaming" = callPackage
···
      }:
      mkDerivation {
        pname = "persistent-sqlite";
-       version = "2.13.0.4";
-       sha256 = "1lvjdh2c4c7z8z8fsl8bz5rygnkph6ql01jnn53mp0v98crk2s9w";
-       configureFlags = [ "-fsystemlib" ];
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson base bytestring conduit containers microlens-th monad-logger
-         mtl persistent resource-pool resourcet text time transformers
-         unliftio-core unordered-containers
-       ];
-       librarySystemDepends = [ sqlite ];
-       testHaskellDepends = [
-         base bytestring conduit containers exceptions fast-logger hspec
-         HUnit microlens monad-logger mtl persistent persistent-test
-         QuickCheck resourcet system-fileio system-filepath temporary text
-         time transformers unliftio-core
-       ];
-       description = "Backend for the persistent library using sqlite3";
-       license = lib.licenses.mit;
-       maintainers = with lib.maintainers; [ psibi ];
-     }) {inherit (pkgs) sqlite;};
-
-  "persistent-sqlite_2_13_1_0" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, conduit, containers
-     , exceptions, fast-logger, hspec, HUnit, microlens, microlens-th
-     , monad-logger, mtl, persistent, persistent-test, QuickCheck
-     , resource-pool, resourcet, sqlite, system-fileio, system-filepath
-     , temporary, text, time, transformers, unliftio-core
-     , unordered-containers
-     }:
-     mkDerivation {
-       pname = "persistent-sqlite";
        version = "2.13.1.0";
        sha256 = "1z8650nv10f6yldn9sihk54c7mlcnkxwaj956igvs6q3x3s8aa1b";
        configureFlags = [ "-fsystemlib" ];
···
        ];
        description = "Backend for the persistent library using sqlite3";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ psibi ];
      }) {inherit (pkgs) sqlite;};
 
···
      }:
      mkDerivation {
        pname = "persistent-test";
-       version = "2.13.0.4";
-       sha256 = "0vcq5wg63py4k5nv5042lcdzz24wbpwzhd2ww02ijf5wmgqqg63p";
-       libraryHaskellDepends = [
-         aeson base blaze-html bytestring conduit containers exceptions
-         hspec hspec-expectations http-api-data HUnit monad-control
-         monad-logger mtl path-pieces persistent QuickCheck
-         quickcheck-instances random resourcet text time transformers
-         transformers-base unliftio unliftio-core unordered-containers
-       ];
-       description = "Tests for Persistent";
-       license = lib.licenses.mit;
-     }) {};
-
-  "persistent-test_2_13_1_0" = callPackage
-    ({ mkDerivation, aeson, base, blaze-html, bytestring, conduit
-     , containers, exceptions, hspec, hspec-expectations, http-api-data
-     , HUnit, monad-control, monad-logger, mtl, path-pieces, persistent
-     , QuickCheck, quickcheck-instances, random, resourcet, text, time
-     , transformers, transformers-base, unliftio, unliftio-core
-     , unordered-containers
-     }:
-     mkDerivation {
-       pname = "persistent-test";
        version = "2.13.1.0";
        sha256 = "1ccv9rrnjngwf8av3zyq28myd1iyb6831nnqjpllwlyrpgnmafvr";
        libraryHaskellDepends = [
···
        ];
        description = "Tests for Persistent";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "persistent-typed-db" = callPackage
···
        pname = "pipes";
        version = "4.3.16";
        sha256 = "163lx5sf68zx5kik5h1fjsyckwr9shdsn5k2dsjq3mhg077nxqgl";
-       revision = "1";
-       editedCabalFile = "1b2hkxrb3sv2jgxw3pwhzkskdbgwmli1ckmnycba4llajn9yczmh";
+       revision = "2";
+       editedCabalFile = "1djfzrqq5dz9gpljyf3kbrz7vhp4rvbrk5z7r3x9n3yhw00dwiwp";
        libraryHaskellDepends = [
          base exceptions mmorph mtl transformers void
        ];
···
 
   "powerdns" = callPackage
     ({ mkDerivation, aeson, base, base64-bytestring, bytestring
-     , case-insensitive, containers, deepseq, http-client, servant
-     , servant-client, servant-client-core, tasty, tasty-hunit, text
-     , time
+     , case-insensitive, containers, deepseq, hashable, http-client
+     , servant, servant-client, servant-client-core, tasty, tasty-hunit
+     , text, time
      }:
      mkDerivation {
        pname = "powerdns";
-       version = "0.2.2";
-       sha256 = "05znwk4s6b60rz4qf63b75y84a0yljyiynmkxj4sjafd810cbnwc";
+       version = "0.3.0";
+       sha256 = "1gm9rwxs6iyvwnyigxdihs3djq83z75w74rkbrmlwdrmz21pww13";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring case-insensitive containers
-         deepseq servant servant-client servant-client-core text time
+         deepseq hashable servant servant-client servant-client-core text
+         time
        ];
        testHaskellDepends = [
          base http-client servant-client servant-client-core tasty
···
        ];
        description = "Convert colors to different color spaces, interpolate colors, and transform colors";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "pro-source" = callPackage
+    ({ mkDerivation, base, deepseq, hashable, optics-core
+     , prettyprinter, tasty, tasty-hunit, tasty-quickcheck, text, vector
+     }:
+     mkDerivation {
+       pname = "pro-source";
+       version = "0.1.0.0";
+       sha256 = "0c3xhdggw6cw8h8jxlkh4vi2xmcaibvj1c5klm9mf8cfyr4f6722";
+       revision = "1";
+       editedCabalFile = "1mxc6lbwdhk1d5in711ma1vvd60nckfb17ss8xbj68b8irw160ng";
+       libraryHaskellDepends = [
+         base deepseq hashable optics-core prettyprinter text vector
+       ];
+       testHaskellDepends = [
+         base deepseq hashable optics-core prettyprinter tasty tasty-hunit
+         tasty-quickcheck text vector
+       ];
+       description = "Utilities for tracking source locations";
+       license = lib.licenses.mpl20;
      }) {};
 
   "probability" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "quickcheck-higherorder_0_1_0_1" = callPackage
+    ({ mkDerivation, base, QuickCheck, tasty, tasty-hunit
+     , tasty-quickcheck, test-fun
+     }:
+     mkDerivation {
+       pname = "quickcheck-higherorder";
+       version = "0.1.0.1";
+       sha256 = "17bnbq6hndlvfv2ryingw181vhv6ab5npkjxkxs0bijv654dca2h";
+       libraryHaskellDepends = [ base QuickCheck test-fun ];
+       testHaskellDepends = [ base tasty tasty-hunit tasty-quickcheck ];
+       description = "QuickCheck extension for higher-order properties";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "quickcheck-instances" = callPackage
     ({ mkDerivation, array, base, bytestring, case-insensitive
      , containers, data-fix, hashable, integer-logarithms, old-time
···
      }:
      mkDerivation {
        pname = "reanimate";
-       version = "1.1.4.0";
-       sha256 = "0gz651ipn5w6w7adxkvkcgi6nb1d2vs72l8glz5jdll44mchdk55";
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         aeson ansi-terminal array attoparsec base base64-bytestring
-         bytestring cassava cereal colour containers cryptohash-sha256
-         cubicbezier directory filelock filepath fingertree fsnotify geojson
-         hashable hgeometry hgeometry-combinatorial JuicyPixels lens linear
-         matrix mtl neat-interpolation network open-browser
-         optparse-applicative parallel process random random-shuffle
-         reanimate-svg split temporary text time unix unordered-containers
-         vector vector-space websockets xml
-       ];
-       testHaskellDepends = [
-         base bytestring directory filepath linear process QuickCheck tasty
-         tasty-expected-failure tasty-golden tasty-hunit tasty-quickcheck
-         tasty-rerun temporary text vector
-       ];
-       description = "Animation library based on SVGs";
-       license = lib.licenses.publicDomain;
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
-  "reanimate_1_1_5_0" = callPackage
-    ({ mkDerivation, aeson, ansi-terminal, array, attoparsec, base
-     , base64-bytestring, bytestring, cassava, cereal, colour
-     , containers, cryptohash-sha256, cubicbezier, directory, filelock
-     , filepath, fingertree, fsnotify, geojson, hashable, hgeometry
-     , hgeometry-combinatorial, JuicyPixels, lens, linear, matrix, mtl
-     , neat-interpolation, network, open-browser, optparse-applicative
-     , parallel, process, QuickCheck, random, random-shuffle
-     , reanimate-svg, split, tasty, tasty-expected-failure, tasty-golden
-     , tasty-hunit, tasty-quickcheck, tasty-rerun, temporary, text, time
-     , unix, unordered-containers, vector, vector-space, websockets, xml
-     }:
-     mkDerivation {
-       pname = "reanimate";
        version = "1.1.5.0";
        sha256 = "0gy5s68d00szs1ljfcyisp19g3vz4i1mlbxpym0mymzc5v723wfa";
        enableSeparateDataOutput = true;
···
        libraryHaskellDepends = [ base data-default-class indexed ];
        description = "A library to facilitate rebinding of Haskell syntax";
        license = lib.licenses.mit;
+     }) {};
+
+  "rec-smallarray" = callPackage
+    ({ mkDerivation, base, hspec, primitive }:
+     mkDerivation {
+       pname = "rec-smallarray";
+       version = "0.1.0.0";
+       sha256 = "1a4vsag2h955i2pgcwiy9rzs1dpvd3j2lc1drhyg6svpm7h82amk";
+       libraryHaskellDepends = [ base primitive ];
+       testHaskellDepends = [ base hspec primitive ];
+       description = "SmallArray-based extensible records for small-scale fast reads";
+       license = lib.licenses.bsd3;
      }) {};
 
   "recaptcha" = callPackage
···
      }:
      mkDerivation {
        pname = "reflex-dom-core";
-       version = "0.7.0.0";
-       sha256 = "0g96z0qd658g5zhcb01f7gzpk3kb016w6w67wcyrigvg4zxk2vyn";
+       version = "0.7.0.1";
+       sha256 = "0lhi04i5wfkgblcifah6znkwi6v7294pna48527ns74f0bjc7yy3";
        libraryHaskellDepends = [
          aeson base bifunctors bimap blaze-builder bytestring
          case-insensitive constraints containers contravariant data-default
···
        pname = "regex-pcre-builtin";
        version = "0.95.2.3.8.44";
        sha256 = "0pn55ssrwr05c9sa9jvp0knvzjksz04wn3pmzf5dz4xgbyjadkna";
+       revision = "1";
+       editedCabalFile = "1j7wcw3f8fmd0m1iqndliw2w4jrm4rr7lyydn3xi7wxyvy8a0kmf";
        libraryHaskellDepends = [
          array base bytestring containers regex-base text
        ];
···
        maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
-  "req_3_9_2" = callPackage
+  "req_3_10_0" = callPackage
     ({ mkDerivation, aeson, authenticate-oauth, base, blaze-builder
      , bytestring, case-insensitive, connection, exceptions, hspec
      , hspec-core, hspec-discover, http-api-data, http-client
···
      }:
      mkDerivation {
        pname = "req";
-       version = "3.9.2";
-       sha256 = "17xkj5pypn4k6ncsahjc0h827kg3cyx5iy5q6iv1gvk8dwdiim0g";
+       version = "3.10.0";
+       sha256 = "176zl3ihmp8iz4fwfi5dalmiz658dis0hxni6bqzqgnaxhd0230w";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson authenticate-oauth base blaze-builder bytestring
···
      }:
      mkDerivation {
        pname = "robots-txt";
-       version = "0.4.1.5";
-       sha256 = "025dm3rv4cpig8j02yzkr7xinzfcqmfiaaj8x5kzjw8mgcb1qpn3";
+       version = "0.4.1.7";
+       sha256 = "0krmqznkkrq16bf78hs98ck6793nl68sn6lb5dv6skn8f10pzyfg";
        libraryHaskellDepends = [
          attoparsec base bytestring old-locale time
        ];
···
        pname = "sdp";
        version = "0.2.1.1";
        sha256 = "19s78i5aaj24wbbqkfa6xjkj95fgl23gyqan57pkdjcnknwpymqq";
+       revision = "1";
+       editedCabalFile = "1bq7gnbdk5fvxd8zbfzqxwg3xxz9k42f7xxjxqrpd3rm2m4ciski";
        libraryHaskellDepends = [ base data-default-class fmr ghc-prim ];
        libraryToolDepends = [ cpphs ];
        description = "Simple Data Processing";
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "servant_0_19" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, base-compat, bifunctors
+     , bytestring, case-insensitive, constraints, deepseq, hspec
+     , hspec-discover, http-api-data, http-media, http-types, mmorph
+     , mtl, network-uri, QuickCheck, quickcheck-instances
+     , singleton-bool, sop-core, string-conversions, tagged, text
+     , transformers, vault
+     }:
+     mkDerivation {
+       pname = "servant";
+       version = "0.19";
+       sha256 = "1rahn436vc3xajn563ni25jqkg87fvhqkpswan1xy6qsfr0ikdjb";
+       libraryHaskellDepends = [
+         aeson attoparsec base base-compat bifunctors bytestring
+         case-insensitive constraints deepseq http-api-data http-media
+         http-types mmorph mtl network-uri QuickCheck singleton-bool
+         sop-core string-conversions tagged text transformers vault
+       ];
+       testHaskellDepends = [
+         aeson base base-compat bytestring hspec http-media mtl QuickCheck
+         quickcheck-instances string-conversions text transformers
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "A family of combinators for defining webservices APIs";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "servant-JuicyPixels" = callPackage
     ({ mkDerivation, base, bytestring, http-media, JuicyPixels, servant
      , servant-server, wai, warp
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "servant-auth_0_4_1_0" = callPackage
+    ({ mkDerivation, aeson, base, containers, jose, lens, servant, text
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "servant-auth";
+       version = "0.4.1.0";
+       sha256 = "08ggnlknhzdpf49zjm1qpzm12gckss7yr8chmzm6h6ycigz77ndd";
+       libraryHaskellDepends = [
+         aeson base containers jose lens servant text unordered-containers
+       ];
+       description = "Authentication combinators for servant";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "servant-auth-client" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, hspec
      , hspec-discover, http-client, http-types, jose, QuickCheck
···
        pname = "servant-auth-client";
        version = "0.4.1.0";
        sha256 = "16rmwdrx0qyqa821ipayczzl3gv8gvqgx8k9q8qaw19w87hwkh83";
-       revision = "2";
-       editedCabalFile = "0mq9nhrlh44jxkngj06pasrrjzv5193lj6d2szprnncgrk36zi31";
+       revision = "3";
+       editedCabalFile = "102p6mcafxsp41kzqzp59dm5d58r7mdhdijxnhhw25913qzi2pl3";
        libraryHaskellDepends = [
          base bytestring containers servant servant-auth servant-client-core
        ];
···
        pname = "servant-auth-docs";
        version = "0.2.10.0";
        sha256 = "0j1ynnrb6plrhpb2vzs2p7a9jb41llp0j1jwgap7hjhkwhyc7wxd";
-       revision = "8";
-       editedCabalFile = "01mb003lajxs1x82k20dbnxzdvxdla51vi4dh4f0a1xycvyhfpyi";
+       revision = "9";
+       editedCabalFile = "0bqs4l7iwzdx0ppyh7v4b4rmy8va3p3ijknp2dc2lwj5yclzfl32";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base lens servant servant-auth servant-docs text
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "servant-auth-server_0_4_7_0" = callPackage
+    ({ mkDerivation, aeson, base, base64-bytestring, blaze-builder
+     , bytestring, case-insensitive, cookie, data-default-class, entropy
+     , hspec, hspec-discover, http-client, http-types, jose, lens
+     , lens-aeson, markdown-unlit, memory, monad-time, mtl, QuickCheck
+     , servant, servant-auth, servant-server, tagged, text, time
+     , transformers, unordered-containers, wai, warp, wreq
+     }:
+     mkDerivation {
+       pname = "servant-auth-server";
+       version = "0.4.7.0";
+       sha256 = "1m145xxqg1xy7i1br9yfh3avwkb30zh808nr658ljl7j2imlknj2";
+       libraryHaskellDepends = [
+         aeson base base64-bytestring blaze-builder bytestring
+         case-insensitive cookie data-default-class entropy http-types jose
+         lens memory monad-time mtl servant servant-auth servant-server
+         tagged text time unordered-containers wai
+       ];
+       testHaskellDepends = [
+         aeson base bytestring case-insensitive hspec http-client http-types
+         jose lens lens-aeson mtl QuickCheck servant servant-auth
+         servant-server time transformers wai warp wreq
+       ];
+       testToolDepends = [ hspec-discover markdown-unlit ];
+       description = "servant-server/servant-auth compatibility";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "servant-auth-swagger" = callPackage
     ({ mkDerivation, base, hspec, hspec-discover, lens, QuickCheck
      , servant, servant-auth, servant-swagger, swagger2, text
···
        pname = "servant-auth-swagger";
        version = "0.2.10.1";
        sha256 = "029nvb4wxwl98ah26bgcq1b7izrnvssxwn1682liimvsh4a8bady";
-       revision = "3";
-       editedCabalFile = "1hkszdp7c7c34b2yp2gb7khzlzq8iw5ma066r30kq2nw5jj895k0";
+       revision = "4";
+       editedCabalFile = "1rwywxhiz7fl5gp90nvdlc0gw0f0lg3pnigj6cpah1fsay4arscf";
        libraryHaskellDepends = [
          base lens servant servant-auth servant-swagger swagger2 text
        ];
···
        pname = "servant-blaze";
        version = "0.9.1";
        sha256 = "08fvy904mz5xjqda702kq4ch25m3nda1yhpp4g7i62j0jmxs2ji6";
+       revision = "1";
+       editedCabalFile = "1y38lzmh5jr3bix0cqrcx9zkjdr1598hz7rvpnm827qw0ln3cmra";
        libraryHaskellDepends = [ base blaze-html http-media servant ];
        testHaskellDepends = [ base blaze-html servant-server wai warp ];
        description = "Blaze-html support for servant";
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "servant-client_0_19" = callPackage
+    ({ mkDerivation, aeson, base, base-compat, bytestring, containers
+     , deepseq, entropy, exceptions, hspec, hspec-discover
+     , http-api-data, http-client, http-media, http-types, HUnit
+     , kan-extensions, markdown-unlit, monad-control, mtl, network
+     , QuickCheck, semigroupoids, servant, servant-client-core
+     , servant-server, sop-core, stm, tdigest, text, time, transformers
+     , transformers-base, transformers-compat, wai, warp
+     }:
+     mkDerivation {
+       pname = "servant-client";
+       version = "0.19";
+       sha256 = "1bdapsr6il0f019ss8wsxndpc8cd5czj40xczay5qhl7fqnxg5pa";
+       libraryHaskellDepends = [
+         base base-compat bytestring containers deepseq exceptions
+         http-client http-media http-types kan-extensions monad-control mtl
+         semigroupoids servant servant-client-core stm text time
+         transformers transformers-base transformers-compat
+       ];
+       testHaskellDepends = [
+         aeson base base-compat bytestring entropy hspec http-api-data
+         http-client http-types HUnit kan-extensions markdown-unlit mtl
+         network QuickCheck servant servant-client-core servant-server
+         sop-core stm tdigest text transformers transformers-compat wai warp
+       ];
+       testToolDepends = [ hspec-discover markdown-unlit ];
+       description = "Automatic derivation of querying functions for servant";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "servant-client-core" = callPackage
     ({ mkDerivation, aeson, base, base-compat, base64-bytestring
      , bytestring, containers, deepseq, exceptions, free, hspec
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "servant-client-core_0_19" = callPackage
+    ({ mkDerivation, aeson, base, base-compat, base64-bytestring
+     , bytestring, constraints, containers, deepseq, exceptions, free
+     , hspec, hspec-discover, http-media, http-types, network-uri
+     , QuickCheck, safe, servant, sop-core, template-haskell, text
+     , transformers
+     }:
+     mkDerivation {
+       pname = "servant-client-core";
+       version = "0.19";
+       sha256 = "0cisc5cyl367cwrch1gr812aspd36a21hkwi6mwj708rpspwvrmc";
+       libraryHaskellDepends = [
+         aeson base base-compat base64-bytestring bytestring constraints
+         containers deepseq exceptions free http-media http-types
+         network-uri safe servant sop-core template-haskell text
+         transformers
+       ];
+       testHaskellDepends = [ base base-compat deepseq hspec QuickCheck ];
+       testToolDepends = [ hspec-discover ];
+       description = "Core functionality and class for client function generation for servant APIs";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "servant-client-js" = callPackage
     ({ mkDerivation, base, binary, bytestring, case-insensitive
      , containers, exceptions, http-media, http-types, jsaddle
···
        pname = "servant-conduit";
     ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
        sha256 = "1vy3ihypb0zm2yd16rq120qw3898i3c0mahh2jysssv65g0avdwp";
-       revision = "1";
-       editedCabalFile = "0j7jrwyj6vnfr8wyyzjjm6gakx401aylrq8shc2y9ciy0mhf8lrv";
+       revision = "3";
+       editedCabalFile = "1rcxn2m95zvxqvjbagk9gmwcyvx9wanhxmafwar4y4p15mvzd8d1";
        libraryHaskellDepends = [
          base bytestring conduit mtl resourcet servant unliftio-core
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "servant-docs_0_12" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, base-compat, bytestring
+     , case-insensitive, hashable, http-media, http-types, lens, servant
+     , string-conversions, tasty, tasty-golden, tasty-hunit, text
+     , transformers, universe-base, unordered-containers
+     }:
+     mkDerivation {
+       pname = "servant-docs";
+       version = "0.12";
+       sha256 = "0531jldq35sl1qlna0s1n8bakbsplg15611305dk48z80vcpa933";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson aeson-pretty base base-compat bytestring case-insensitive
+         hashable http-media http-types lens servant string-conversions text
+         universe-base unordered-containers
+       ];
+       executableHaskellDepends = [
+         aeson base lens servant string-conversions text
+       ];
+       testHaskellDepends = [
+         aeson base base-compat lens servant string-conversions tasty
+         tasty-golden tasty-hunit transformers
+       ];
+       description = "generate API docs for your servant webservice";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "servant-docs-simple" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, hspec
      , hspec-core, prettyprinter, raw-strings-qq, servant, text
···
        pname = "servant-foreign";
        version = "0.15.4";
        sha256 = "0bznb73rbgfgkg7n4pxghkqsfca0yw9vak73c6w8sqvc2mjnc7mz";
+       revision = "1";
+       editedCabalFile = "0lwz3cjbz072xpg6ak0q4grs2c6i7fvvpcsbmc4ngqm695vd9ff8";
        libraryHaskellDepends = [
          base base-compat http-types lens servant text
        ];
···
        broken = true;
      }) {};
 
+  "servant-http-streams_0_18_4" = callPackage
+    ({ mkDerivation, aeson, base, base-compat, bytestring
+     , case-insensitive, containers, deepseq, entropy, exceptions, hspec
+     , hspec-discover, http-api-data, http-common, http-media
+     , http-streams, http-types, HUnit, io-streams, kan-extensions
+     , markdown-unlit, monad-control, mtl, network, QuickCheck
+     , semigroupoids, servant, servant-client-core, servant-server, stm
+     , tdigest, text, time, transformers, transformers-base
+     , transformers-compat, wai, warp
+     }:
+     mkDerivation {
+       pname = "servant-http-streams";
+       version = "0.18.4";
+       sha256 = "15f24rcgz839cb38q4gs1liqrdyqjbazcqzjdxmv4307x072pv3a";
+       libraryHaskellDepends = [
+         base base-compat bytestring case-insensitive containers deepseq
+         exceptions http-common http-media http-streams http-types
+         io-streams kan-extensions monad-control mtl semigroupoids servant
+         servant-client-core text time transformers transformers-base
+         transformers-compat
+       ];
+       testHaskellDepends = [
+         aeson base base-compat bytestring deepseq entropy hspec
+         http-api-data http-streams http-types HUnit kan-extensions
+         markdown-unlit mtl network QuickCheck servant servant-client-core
+         servant-server stm tdigest text transformers transformers-compat
+         wai warp
+       ];
+       testToolDepends = [ hspec-discover markdown-unlit ];
+       description = "Automatic derivation of querying functions for servant";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "servant-http2-client" = callPackage
     ({ mkDerivation, aeson, async, base, binary, bytestring
      , case-insensitive, containers, data-default-class, exceptions
···
        pname = "servant-machines";
     ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
        sha256 = "0k8abcc72s5bzcf2vmjkxxjnhk45rww6hr3l93msm2510hi6gda4";
-       revision = "1";
-       editedCabalFile = "0zplgs1kqfmnnx8yv8ay594misiamgmvy41b8w1h3mr7n4vrgk8j";
+       revision = "2";
+       editedCabalFile = "0231278v3vs5ca3cx43711kzfbhqj2s7g67zcwrj39ly8i9kxm2n";
        libraryHaskellDepends = [ base bytestring machines mtl servant ];
        testHaskellDepends = [
          base base-compat bytestring http-client http-media machines servant
···
        pname = "servant-multipart";
        version = "0.12.1";
        sha256 = "1p55kb3zhq25ncp7wimhggssn68abfgsnlldk13rk1iajaj6y8y5";
+       revision = "1";
+       editedCabalFile = "1vjdly7n614gzzxyf2sdkgmhkfqxbdvaf0f2pyk9mr9fxlss1g2q";
        libraryHaskellDepends = [
          base bytestring directory lens resourcet servant servant-docs
          servant-foreign servant-multipart-api servant-server
···
        pname = "servant-multipart-api";
        version = "0.12.1";
        sha256 = "1gifa9g7ggs0plzffrd9a8j24dmqvgbkkdkfzyy7mpmwrjqw7mcj";
+       revision = "1";
+       editedCabalFile = "0nwk49xmzwxxlgcsqa62nwvyfqmxb0ab1ncnn96gpqyxkqbv2gxd";
        libraryHaskellDepends = [
          base bytestring servant text transformers
        ];
···
        pname = "servant-multipart-client";
        version = "0.12.1";
        sha256 = "07haaf9nq96lfv2dhqf4319vl321f53v0mypbbg3swzb6rrfkw9h";
+       revision = "1";
+       editedCabalFile = "1mzh1a37hmq4zl0annnk3xabgli2jndkvx80amhsn97111fiz7lz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "servant-openapi3";
        version = "2.0.1.3";
        sha256 = "1nvxaskizv5qgznvxdg4crdh4dra5rj7abiky5bd927gnwvbir6s";
-       revision = "1";
-       editedCabalFile = "08ajlbydnklqdv8gyrqihdn27h5hjvlvjv628xg05w7waa2c15vy";
+       revision = "2";
+       editedCabalFile = "08cfsqx530kyc90p83kf35pyyl90vx85kz1xvmd9lm54785d2znv";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          aeson aeson-pretty base base-compat bytestring hspec http-media
···
        pname = "servant-pipes";
        version = "0.15.3";
        sha256 = "1sd01f95rkraa0zdqqg2vwx91zsih0i0hqqkz55nnw9bsbsqhq1n";
+       revision = "2";
+       editedCabalFile = "1idjvfr8w5hr9dvhj9x08sfpy5xvjf0l7a5jhx9hdlfmrxk1cd8c";
        libraryHaskellDepends = [
          base bytestring monad-control mtl pipes pipes-safe servant
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "servant-server_0_19" = callPackage
+    ({ mkDerivation, aeson, base, base-compat, base64-bytestring
+     , bytestring, constraints, containers, directory, exceptions
+     , filepath, hspec, hspec-discover, hspec-wai, http-api-data
+     , http-media, http-types, monad-control, mtl, network, network-uri
+     , QuickCheck, resourcet, safe, servant, should-not-typecheck
+     , sop-core, string-conversions, tagged, temporary, text
+     , transformers, transformers-base, transformers-compat, wai
+     , wai-app-static, wai-extra, warp, word8
+     }:
+     mkDerivation {
+       pname = "servant-server";
+       version = "0.19";
+       sha256 = "0d7z1r9g86cshqqacnw1ls4h5ijpwznbprk2kvnc8j8drjcmnrf1";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base base-compat base64-bytestring bytestring constraints
+         containers exceptions filepath http-api-data http-media http-types
+         monad-control mtl network network-uri resourcet servant sop-core
+         string-conversions tagged text transformers transformers-base wai
+         wai-app-static word8
+       ];
+       executableHaskellDepends = [
+         aeson base base-compat servant text wai warp
+       ];
+       testHaskellDepends = [
+         aeson base base-compat base64-bytestring bytestring directory hspec
+         hspec-wai http-types mtl QuickCheck resourcet safe servant
+         should-not-typecheck sop-core string-conversions temporary text
+         transformers transformers-compat wai wai-extra
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "A family of combinators for defining webservices APIs and serving them";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "servant-server-namedargs" = callPackage
     ({ mkDerivation, base, bytestring, http-api-data, http-types, named
      , servant, servant-namedargs, servant-server, string-conversions
···
        pname = "servant-swagger";
        version = "1.1.10";
        sha256 = "0y6zylhs4z0nfz75d4i2azcq0yh2bd4inanwblx4035dgkk1q78a";
+       revision = "1";
+       editedCabalFile = "1x18nl7sriqwphdyy8v819vbcx27my5mcx9h9hnds2ph82p3zywc";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          aeson aeson-pretty base base-compat bytestring hspec http-media
···
        pname = "servant-swagger-ui";
        version = "0.3.5.3.52.5";
        sha256 = "1m7scy7fm19zk6xq5mb9l12ajdhm0ml9zl60rqr2m86x4q2i6gq0";
+       revision = "1";
+       editedCabalFile = "1hdwdhw8ipwf16asbpjgkbvchvc3ax1wqnpcdcjpagniay2x253r";
        libraryHaskellDepends = [
          aeson base bytestring file-embed-lzma servant servant-server
          servant-swagger-ui-core text
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "servant-swagger-ui_0_3_5_4_5_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, file-embed-lzma, servant
+     , servant-server, servant-swagger-ui-core, text
+     }:
+     mkDerivation {
+       pname = "servant-swagger-ui";
+       version = "0.3.5.4.5.0";
+       sha256 = "12w75z23bnygyr3ki9w3zfy9nhxyjawf9pyzhfg6rp2mq3nji9gg";
+       libraryHaskellDepends = [
+         aeson base bytestring file-embed-lzma servant servant-server
+         servant-swagger-ui-core text
+       ];
+       description = "Servant swagger ui";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "servant-swagger-ui-core" = callPackage
     ({ mkDerivation, aeson, base, blaze-markup, bytestring, http-media
      , servant, servant-blaze, servant-server, text, transformers
···
        pname = "servant-swagger-ui-core";
        version = "0.3.5";
        sha256 = "0ckvrwrb3x39hfl2hixcj3fhibh0vqsh6y7n1lsm25yvzfrg02zd";
-       revision = "1";
-       editedCabalFile = "0fk7bj8fndxf1aw8xhhacjp8rrvx10gj7kh9d2pvjavnz310ymxg";
+       revision = "2";
+       editedCabalFile = "02g98dy08wj7ryrrbk8547s6ad4a59d6z4pczmf6pc59kdjvjx3n";
        libraryHaskellDepends = [
          aeson base blaze-markup bytestring http-media servant servant-blaze
          servant-server text transformers transformers-compat wai-app-static
···
        pname = "servant-swagger-ui-jensoleg";
        version = "0.3.4";
        sha256 = "04s4syfmnjwa52xqm29x2sfi1ka6p7fpjff0pxry099rh0d59hkm";
-       revision = "1";
-       editedCabalFile = "0yvgbyqdkjp5qv88gm7wgcl5rb4haijc4jfmmfcq8g63ya7msx9x";
+       revision = "2";
+       editedCabalFile = "0a98f9xxy69741fj4cqx7qgh9cpbjk03bgga3h3yx2kjidps0cdm";
        libraryHaskellDepends = [
          aeson base bytestring file-embed-lzma servant servant-server
          servant-swagger-ui-core text
···
        pname = "servant-swagger-ui-redoc";
        version = "0.3.4.1.22.3";
        sha256 = "0ln2sz7ffhddk4dqvczpxb5g8f6bic7sandn5zifpz2jg7lgzy0f";
-       revision = "1";
-       editedCabalFile = "1w6h6g8hlsyv87xxxyrsjz5gdkphmxgc4y63g8mmv4hgdncrb1jk";
+       revision = "2";
+       editedCabalFile = "0pd85v4fbz6la90qll5mb9v2f2v8c5x1iwy4s3kk6mxcvzxih968";
        libraryHaskellDepends = [
          aeson base bytestring file-embed-lzma servant servant-server
          servant-swagger-ui-core text
···
        pname = "sound-collage";
        version = "0.2.1";
        sha256 = "09g63b3k0l30z3lxmcz0zpggqqhnr7m01wh2vpm5v561rbnl8rsi";
+       revision = "1";
+       editedCabalFile = "07zs924gils8nsb5b8q6lmh4g6iln6dkj3qic8p8cpwkrazjfwsx";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        description = "Computational combinatorial species";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "spectacle" = callPackage
+    ({ mkDerivation, base, comonad, containers, hashable, hedgehog
+     , logict, microlens, microlens-mtl, mtl, optparse-applicative
+     , prettyprinter, prettyprinter-ansi-terminal, tasty, tasty-hedgehog
+     , text, transformers
+     }:
+     mkDerivation {
+       pname = "spectacle";
+       version = "1.0.0";
+       sha256 = "0zbxbhjid1j44f31n9h8hsildfx2lf92p1s9dw62gr0xn30kf4gj";
+       libraryHaskellDepends = [
+         base comonad containers hashable logict microlens microlens-mtl mtl
+         optparse-applicative prettyprinter prettyprinter-ansi-terminal text
+         transformers
+       ];
+       testHaskellDepends = [
+         base comonad containers hashable hedgehog microlens tasty
+         tasty-hedgehog
+       ];
+       description = "Embedded specification language & model checker in Haskell";
+       license = lib.licenses.asl20;
      }) {};
 
   "spectral-clustering" = callPackage
···
      }:
      mkDerivation {
        pname = "stack-clean-old";
-       version = "0.4.5";
-       sha256 = "04qc3z7xgs8p814lnpwyqgwza7i6wz9mkmzzk0ggq6mv32zzz7kb";
+       version = "0.4.6";
+       sha256 = "0ymzri4pxs0dvqbs3nyrc6hq2lp6y6glva1kbjzpkzgk9r93x3kn";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
          base directory extra filemanip filepath simple-cmd simple-cmd-args
        ];
-       description = "Clean away old stack build artefacts";
+       description = "Clean away old stack build artifacts";
        license = lib.licenses.bsd3;
      }) {};
 
···
        license = lib.licenses.mit;
      }) {};
 
+  "streaming-commons_0_2_2_4" = callPackage
+    ({ mkDerivation, array, async, base, bytestring, deepseq, directory
+     , gauge, hspec, network, process, QuickCheck, random, stm, text
+     , transformers, unix, zlib
+     }:
+     mkDerivation {
+       pname = "streaming-commons";
+       version = "0.2.2.4";
+       sha256 = "1wnc2hi90djilj1m0la3h3xri723pbpmfdyp0kxxs33irs6418an";
+       libraryHaskellDepends = [
+         array async base bytestring directory network process random stm
+         text transformers unix zlib
+       ];
+       testHaskellDepends = [
+         array async base bytestring deepseq hspec network QuickCheck text
+         unix zlib
+       ];
+       benchmarkHaskellDepends = [ base bytestring deepseq gauge text ];
+       description = "Common lower-level functions needed by various streaming data libraries";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "streaming-concurrency" = callPackage
     ({ mkDerivation, base, exceptions, hspec, HUnit, lifted-async
      , monad-control, QuickCheck, quickcheck-instances, stm, streaming
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "strict-tuple_0_1_5" = callPackage
+    ({ mkDerivation, base, bifunctors, deepseq, hashable }:
+     mkDerivation {
+       pname = "strict-tuple";
+       version = "0.1.5";
+       sha256 = "1n0rw1vvvsgznx4i21480qzzs44iw35hcdiw0d160war7nf2pyp5";
+       libraryHaskellDepends = [ base bifunctors deepseq hashable ];
+       testHaskellDepends = [ base ];
+       description = "Strict tuples";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "strict-tuple-lens" = callPackage
     ({ mkDerivation, base, lens, strict-tuple }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "string-random";
-       version = "0.1.4.1";
-       sha256 = "1ggz48mzyzch3ga4682jd9y4g1j6px1anv7k8cczjlz9f4lh73nd";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         attoparsec base containers random text transformers
-       ];
-       executableHaskellDepends = [ base optparse-applicative text ];
-       testHaskellDepends = [
-         base bytestring pcre-heavy QuickCheck tasty tasty-hunit
-         tasty-quickcheck text
-       ];
-       description = "A library for generating random string from a regular experession";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "string-random_0_1_4_2" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, containers
-     , optparse-applicative, pcre-heavy, QuickCheck, random, tasty
-     , tasty-hunit, tasty-quickcheck, text, transformers
-     }:
-     mkDerivation {
-       pname = "string-random";
        version = "0.1.4.2";
        sha256 = "0rqh0cwywlzg4xyb1s80mghl3kq3sngg8xjbh4g9x4p8fc6maiw9";
        isLibrary = true;
···
        ];
        description = "A library for generating random string from a regular experession";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "string-similarity" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "swagger2_2_7" = callPackage
+  "swagger2_2_8_1" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, base-compat-batteries
      , bytestring, Cabal, cabal-doctest, containers, cookie, doctest
      , generics-sop, Glob, hashable, hspec, hspec-discover, http-media
···
      }:
      mkDerivation {
        pname = "swagger2";
-       version = "2.7";
-       sha256 = "1p3vi90siylgg94s7izmdvp2i36g017q2hnl90d1rpphi0nd1f6b";
+       version = "2.8.1";
+       sha256 = "19y7krvgx5vdrr0wx3jkkwvdncn3gzyn168sqs333dxs4l3jnxvx";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          aeson aeson-pretty base base-compat-batteries bytestring containers
···
        pname = "synthesizer-llvm";
        version = "0.9";
        sha256 = "0bqncysaq164235792657yyf1ngkr7gm9vkzkbiqy6f7g7a62shd";
+       revision = "1";
+       editedCabalFile = "04z0s3hkpdcmri4w34s2ssz9wwf60z1ccc0bc3bphs1caz8i61j2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "tailwind";
-       version = "0.1.0.0";
-       sha256 = "1wvmygaf8dmy9h0wzxb3623rpdmzvhzr879yc4sm94bzd42y8cy6";
+       version = "0.2.0.0";
+       sha256 = "08m4mkk3fsrzpna3747gc2ln981nd7x17p3kzzvirs7p6js513yh";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "telegram-bot-simple" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, cron
-     , filepath, hashable, http-api-data, http-client, http-client-tls
-     , monad-control, mtl, pretty-show, profunctors, servant
-     , servant-client, servant-multipart, servant-multipart-api
-     , servant-multipart-client, split, stm, template-haskell, text
-     , time, transformers, unordered-containers
+    ({ mkDerivation, aeson, aeson-pretty, base, blaze-html, bytestring
+     , cookie, cron, dhall, filepath, hashable, http-api-data
+     , http-client, http-client-tls, http-types, monad-control, mtl
+     , optparse-applicative, pretty-show, prettyprinter, profunctors
+     , QuickCheck, random, servant, servant-blaze, servant-client
+     , servant-multipart, servant-multipart-api
+     , servant-multipart-client, servant-server, split, stm
+     , template-haskell, text, time, transformers, unix
+     , unordered-containers, uuid, warp
      }:
      mkDerivation {
        pname = "telegram-bot-simple";
-       version = "0.3.8";
-       sha256 = "0nqzghd3apfic1idrx03g5a6xihghi35ha28mcksgji9zp42595q";
+       version = "0.4";
+       sha256 = "1c73vyhl8xlac0vjgyjh8rfszm9zri4absmxpdr79djs9rrfwk2s";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          template-haskell text time transformers unordered-containers
        ];
        executableHaskellDepends = [
-         aeson aeson-pretty base bytestring cron filepath hashable
-         http-api-data http-client http-client-tls monad-control mtl
-         pretty-show profunctors servant servant-client servant-multipart
-         servant-multipart-api servant-multipart-client split stm
-         template-haskell text time transformers unordered-containers
+         aeson aeson-pretty base blaze-html bytestring cookie cron dhall
+         filepath hashable http-api-data http-client http-client-tls
+         http-types monad-control mtl optparse-applicative pretty-show
+         prettyprinter profunctors QuickCheck random servant servant-blaze
+         servant-client servant-multipart servant-multipart-api
+         servant-multipart-client servant-server split stm template-haskell
+         text time transformers unix unordered-containers uuid warp
        ];
        description = "Easy to use library for building Telegram bots";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd3;
      }) {inherit (pkgs) icu;};
 
+  "text-icu_0_8_0" = callPackage
+    ({ mkDerivation, array, base, bytestring, deepseq, directory
+     , ghc-prim, HUnit, icu, icu-i18n, icu-uc, QuickCheck, random
+     , test-framework, test-framework-hunit, test-framework-quickcheck2
+     , text, time
+     }:
+     mkDerivation {
+       pname = "text-icu";
+       version = "0.8.0";
+       sha256 = "1dpnh5izvjma0i3diqjdyag389cbnsv9fysyla2jy1nrpfrf9z8m";
+       revision = "1";
+       editedCabalFile = "0mz894ykvyb9ziprnwx3s9lcda6lsy60s0dgrh5silgsym99r3s9";
+       libraryHaskellDepends = [ base bytestring deepseq text time ];
+       librarySystemDepends = [ icu ];
+       libraryPkgconfigDepends = [ icu-i18n icu-uc ];
+       testHaskellDepends = [
+         array base bytestring deepseq directory ghc-prim HUnit QuickCheck
+         random test-framework test-framework-hunit
+         test-framework-quickcheck2 text
+       ];
+       description = "Bindings to the ICU library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) icu; icu-i18n = null; icu-uc = null;};
+
   "text-icu-normalized" = callPackage
     ({ mkDerivation, base, base-unicode-symbols, bytestring, containers
      , exceptions, filepath, HUnit, lens, parsec, QuickCheck
···
 
   "thank-you-stars" = callPackage
     ({ mkDerivation, aeson, base, bytestring, Cabal, containers
-     , directory, filepath, hackage-db, hspec, req, split, text
+     , directory, filepath, hackage-db, hspec, hspec-discover, req
+     , split, text
      }:
      mkDerivation {
        pname = "thank-you-stars";
-       version = "0.3.0";
-       sha256 = "0cks475c8ivhikci7h8zkvxhxmp7n9w85b16wvx998q3bjrbkj04";
+       version = "1.0.1";
+       sha256 = "1nlmfpm05fsn18rygj33vf4sydn6zk4sx6sp72s1f73llvqrpvhs";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        testHaskellDepends = [
          base Cabal containers directory filepath hspec
        ];
+       testToolDepends = [ hspec-discover ];
        description = "Give your dependencies stars on GitHub!";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "transformers_0_6_0_2" = callPackage
+  "transformers_0_6_0_3" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "transformers";
-       version = "0.6.0.2";
-       sha256 = "1d907i06lgmis4s1mhjn6f4f3991vpycv9pl61h4xn2hwxasq3k2";
-       revision = "1";
-       editedCabalFile = "0g536mmdq72j72jy6437q64vsxj8yba0mamm15xirs67j551azn1";
+       version = "0.6.0.3";
+       sha256 = "070v6kwxinls0w48mfyjqz6rfz03sphyig2ar13lplqjr01kaa67";
        libraryHaskellDepends = [ base ];
        description = "Concrete functor and monad transformers";
        license = lib.licenses.bsd3;
···
        pname = "turtle";
        version = "1.5.23";
        sha256 = "02g0a6az01lfikrinx2027zqrp8wyivldwi36s2yqk9a5qm3ap5c";
-       revision = "2";
-       editedCabalFile = "0i8fnwzqc6j599d19rzcggk29ky45izy5wc9y9ii54lc95d8c7xg";
+       revision = "3";
+       editedCabalFile = "1zc1djz1xi5pmw58rjwmxb7kkzxssnkng9qx93wz9n6bdjiyc2gd";
        libraryHaskellDepends = [
          ansi-wl-pprint async base bytestring clock containers directory
          exceptions foldl hostname managed optional-args
···
 
   "tzdata" = callPackage
     ({ mkDerivation, base, bytestring, containers, deepseq, HUnit
-     , test-framework, test-framework-hunit, test-framework-th, unix
-     , vector
-     }:
-     mkDerivation {
-       pname = "tzdata";
-       version = "0.2.20201021.0";
-       sha256 = "0bkd7k0q8dflp21hzf71kbqyk0jq279z7sgwlq1pdzs2ggmnrwm9";
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         base bytestring containers deepseq vector
-       ];
-       testHaskellDepends = [
-         base bytestring HUnit test-framework test-framework-hunit
-         test-framework-th unix
-       ];
-       description = "Time zone database (as files and as a module)";
-       license = lib.licenses.asl20;
-     }) {};
-
-  "tzdata_0_2_20211021_0" = callPackage
-    ({ mkDerivation, base, bytestring, containers, deepseq, HUnit
      , tasty, tasty-hunit, tasty-th, unix, vector
      }:
      mkDerivation {
···
        ];
        description = "Time zone database (as files and as a module)";
        license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "u2f" = callPackage
···
      }:
      mkDerivation {
        pname = "unliftio";
-       version = "0.2.20";
-       sha256 = "0mbm57h7r16qd7kpglbm50qrnfjmazd70avbrl647n4jwhlrp7my";
-       libraryHaskellDepends = [
-         async base bytestring deepseq directory filepath process stm time
-         transformers unix unliftio-core
-       ];
-       testHaskellDepends = [
-         async base bytestring containers deepseq directory filepath hspec
-         process QuickCheck stm time transformers unix unliftio-core
-       ];
-       benchmarkHaskellDepends = [
-         async base bytestring deepseq directory filepath gauge process stm
-         time transformers unix unliftio-core
-       ];
-       description = "The MonadUnliftIO typeclass for unlifting monads to IO (batteries included)";
-       license = lib.licenses.mit;
-     }) {};
-
-  "unliftio_0_2_20_1" = callPackage
-    ({ mkDerivation, async, base, bytestring, containers, deepseq
-     , directory, filepath, gauge, hspec, process, QuickCheck, stm, time
-     , transformers, unix, unliftio-core
-     }:
-     mkDerivation {
-       pname = "unliftio";
        version = "0.2.20.1";
        sha256 = "13fv7wfq7g1pilpk1vprbf2mbdj7qfm2y9v8glwr6dqyswv8z9dn";
        libraryHaskellDepends = [
···
        ];
        description = "The MonadUnliftIO typeclass for unlifting monads to IO (batteries included)";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "unliftio-core" = callPackage
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
+     }) {};
+
+  "url-slug" = callPackage
+    ({ mkDerivation, aeson, base, relude, text, unicode-transforms
+     , uri-encode
+     }:
+     mkDerivation {
+       pname = "url-slug";
+       version = "0.1.0.0";
+       sha256 = "0x5xkfxzml1cnqcmmyvm3gj0ikw2371jbsqya6ng7pfjlcsmdfzn";
+       libraryHaskellDepends = [
+         aeson base relude text unicode-transforms uri-encode
+       ];
+       description = "Encoding and decoding of URL slugs";
+       license = lib.licenses.mit;
      }) {};
 
   "urlcheck" = callPackage
···
      }) {};
 
   "vector-circular" = callPackage
-    ({ mkDerivation, base, deepseq, doctest, hedgehog, hedgehog-classes
-     , nonempty-vector, primitive, semigroupoids, template-haskell
-     , vector
-     }:
-     mkDerivation {
-       pname = "vector-circular";
-       version = "0.1.3";
-       sha256 = "0xz2ih8x7a5731bbirhmkl7hyarzijnwgvj8zm9wxs1nky8yjyb7";
-       libraryHaskellDepends = [
-         base deepseq nonempty-vector primitive semigroupoids
-         template-haskell vector
-       ];
-       testHaskellDepends = [ base doctest hedgehog hedgehog-classes ];
-       description = "circular vectors";
-       license = lib.licenses.mit;
-     }) {};
-
-  "vector-circular_0_1_4" = callPackage
     ({ mkDerivation, base, deepseq, hedgehog, hedgehog-classes
      , nonempty-vector, primitive, semigroupoids, template-haskell
      , vector
···
        testHaskellDepends = [ base hedgehog hedgehog-classes ];
        description = "circular vectors";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "vector-clock" = callPackage
···
      }:
      mkDerivation {
        pname = "vulkan";
-       version = "3.15";
-       sha256 = "1b76crd9nib0pcgpwbrbwr88zij5wrc6hs240w3sg16zxhwpllh1";
+       version = "3.16.1";
+       sha256 = "1cm5ws9kp2dcrknj4vsw92xnl35gq33k9ijhf5aclpm95q1dw0hc";
        libraryHaskellDepends = [ base bytestring transformers vector ];
        libraryPkgconfigDepends = [ vulkan ];
        testHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "vulkan-utils";
-       version = "0.5.5";
-       sha256 = "0p5ciadgkamgkzmay5rwc1mjs2wq8pqv21rbbbxlnjwmfsayrb9j";
+       version = "0.5.6";
+       sha256 = "1d8nnv31f35k2qn232vx8g3w06vbvik0ih98g7m7lrv0bqi74i12";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base bytestring containers dependent-map dependent-sum extra
···
        license = lib.licenses.mit;
      }) {};
 
+  "warp_3_3_19" = callPackage
+    ({ mkDerivation, array, async, auto-update, base, bsb-http-chunked
+     , bytestring, case-insensitive, containers, directory, gauge
+     , ghc-prim, hashable, hspec, http-client, http-date, http-types
+     , http2, HUnit, iproute, network, process, QuickCheck
+     , simple-sendfile, stm, streaming-commons, text, time, time-manager
+     , unix, unix-compat, unliftio, vault, wai, word8, x509
+     }:
+     mkDerivation {
+       pname = "warp";
+       version = "3.3.19";
+       sha256 = "1wq63wrxk4p6ziig9qgqimmd1mx167868qiczd1avh8896p1f6rb";
+       libraryHaskellDepends = [
+         array auto-update base bsb-http-chunked bytestring case-insensitive
+         containers ghc-prim hashable http-date http-types http2 iproute
+         network simple-sendfile stm streaming-commons text time-manager
+         unix unix-compat unliftio vault wai word8 x509
+       ];
+       testHaskellDepends = [
+         array async auto-update base bsb-http-chunked bytestring
+         case-insensitive containers directory ghc-prim hashable hspec
+         http-client http-date http-types http2 HUnit iproute network
+         process QuickCheck simple-sendfile stm streaming-commons text time
+         time-manager unix unix-compat unliftio vault wai word8 x509
+       ];
+       benchmarkHaskellDepends = [
+         auto-update base bytestring containers gauge hashable http-date
+         http-types network time-manager unix unix-compat unliftio x509
+       ];
+       description = "A fast, light-weight web server for WAI applications";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "warp-dynamic" = callPackage
     ({ mkDerivation, base, data-default, dyre, http-types, wai, warp }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "webauthn";
-       version = "0.2.0.0";
-       sha256 = "0vdx1rlc2mb9nnxyzw94vw1kpjxd5qg9nqg1bh4wkdrxqqb3n7aj";
+       version = "0.3.0.0";
+       sha256 = "0nn6nx6f0wlbfipfhs4irkqhk4bknhcy83n3wxpml9lkgvf8m1kj";
        libraryHaskellDepends = [
          aeson asn1-encoding asn1-parse asn1-types base base16-bytestring
          base64-bytestring binary bytestring cborg containers cryptonite
···
        testHaskellDepends = [ base hspec uri-bytestring ];
        description = "OAuth 2.0 authentication plugins";
        license = lib.licenses.mit;
+     }) {};
+
+  "yesod-auth-oauth2_0_7_0_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, cryptonite, errors
+     , hoauth2, hspec, http-client, http-conduit, http-types, memory
+     , microlens, mtl, safe-exceptions, text, unliftio, uri-bytestring
+     , yesod-auth, yesod-core
+     }:
+     mkDerivation {
+       pname = "yesod-auth-oauth2";
+       version = "0.7.0.0";
+       sha256 = "183ck29b43nvvih2vcpavzvj0ajdwpcjsa6lq6f5labqqk929cww";
+       revision = "1";
+       editedCabalFile = "1vpcb40a3f5dblfdvqw0v55gzh97kp7d2b9pri153v5ri60pgvw5";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring cryptonite errors hoauth2 http-client
+         http-conduit http-types memory microlens mtl safe-exceptions text
+         unliftio uri-bytestring yesod-auth yesod-core
+       ];
+       testHaskellDepends = [ base hspec uri-bytestring ];
+       description = "OAuth 2.0 authentication plugins";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "yesod-auth-oidc" = callPackage

pkgs/development/ocaml-modules/camlimages/4.2.4.nix

···
 , ghostscript
 }:
 
-assert lib.versionOlder ocaml.version "4.06";
+lib.throwIfNot (lib.versionAtLeast ocaml.version "4.02" && lib.versionOlder ocaml.version "4.10")
+  "camlimages 4.2.4 is not available for OCaml ${ocaml.version}"
 
 stdenv.mkDerivation rec {
   name = "ocaml${ocaml.version}-${pname}-${version}";
···
   '';
 
   installPhase = ''
-    runHook preBuild
+    runHook preInstall
     omake install
-    runHook postBuild
+    runHook postInstall
   '';
 
   createFindlibDestdir = true;

pkgs/development/python-modules/flux-led/default.nix

···
 
 buildPythonPackage rec {
   pname = "flux-led";
-  version = "0.28.22";
+  version = "0.28.24";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
···
     owner = "Danielhiversen";
     repo = "flux_led";
     rev = version;
-    sha256 = "sha256-GNuc8WAiC0S4WFFUYgayU6c0treWCPfPhbyteZ68eWs=";
+    sha256 = "sha256-4VajN6w+W7WZzwnsqLAnR4IO2ODuolCEotbgxV9luYA=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/omnikinverter/default.nix

···
 
 buildPythonPackage rec {
   pname = "omnikinverter";
-  version = "0.6.2";
+  version = "0.7.0";
   format = "pyproject";
 
-  disabled = pythonOlder "3.7";
+  disabled = pythonOlder "3.9";
 
   src = fetchFromGitHub {
     owner = "klaasnicolaas";
     repo = "python-omnikinverter";
     rev = "v${version}";
-    sha256 = "sha256-NnwjiaFUi2vzORu8sndtfdVpZEAIMCvT+9VEr2ZOx3k=";
+    sha256 = "sha256-IiU7nhwH0Mc6s+g9WtJugpORuL0qGNJFKDY5hvxIZAU=";
   };
 
   nativeBuildInputs = [

pkgs/development/python-modules/pywlroots/default.nix

···
 
 buildPythonPackage rec {
   pname = "pywlroots";
-  version = "0.15.7";
+  version = "0.15.8";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "EJAqtzFKx9Zripspv3lXIDj54pqHV0in6RrOCgFUyU8=";
+    sha256 = "5oKeiNRO/5/6gWHPgatn0sHRtPL2B2Fa7S1A7LWr0qM=";
   };
 
   # The XWayland detection uses some hard-coded FHS paths. Since we

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

···
 , stdenv
 , supportedGhcVersions ? [ "884" "8107" "902" ]
     ++ lib.optionals (!stdenv.hostPlatform.isAarch64) [ "921" ]
+, dynamic ? false
 , haskellPackages
 , haskell
 }:
···
 # for example. Read more about this in the haskell-language-server section of the nixpkgs manual.
 #
 let
-  inherit (lib) concatStringsSep concatMapStringsSep take splitString;
+  inherit (lib) concatStringsSep concatMapStringsSep take splitString pipe optionals;
+  inherit (haskell.lib.compose) justStaticExecutables overrideCabal enableCabalFlag disableCabalFlag;
   getPackages = version: haskell.packages."ghc${version}";
   tunedHls = hsPkgs:
-    haskell.lib.compose.justStaticExecutables
-    (haskell.lib.compose.overrideCabal (old: {
-      postInstall = ''
-        remove-references-to -t ${hsPkgs.ghc} $out/bin/haskell-language-server
-        remove-references-to -t ${hsPkgs.shake.data} $out/bin/haskell-language-server
-        remove-references-to -t ${hsPkgs.js-jquery.data} $out/bin/haskell-language-server
-        remove-references-to -t ${hsPkgs.js-dgtable.data} $out/bin/haskell-language-server
-        remove-references-to -t ${hsPkgs.js-flot.data} $out/bin/haskell-language-server
-      '';
-    }) hsPkgs.haskell-language-server);
+    lib.pipe hsPkgs.haskell-language-server ([
+      (haskell.lib.compose.overrideCabal (old: {
+        enableSharedExecutables = dynamic;
+        ${if !dynamic then "postInstall" else null} = ''
+          ${old.postInstall or ""}
+
+          remove-references-to -t ${hsPkgs.ghc} $out/bin/haskell-language-server
+        '';
+      }))
+      ((if dynamic then enableCabalFlag else disableCabalFlag) "dynamic")
+    ] ++ optionals (!dynamic) [
+      justStaticExecutables
+    ]);
   targets = version:
     let packages = getPackages version;
     in [

pkgs/development/tools/rust/rust-script/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "rust-script";
-  version = "0.19.0";
+  version = "0.20.0";
 
   src = fetchFromGitHub {
     owner = "fornwall";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-CYeTt6PzVGu62/GJB+gUlOXG2bs4RV0LWECF4CN3Uic=";
+    sha256 = "sha256-WcvRkp57VyBB5gQgamFoR6wK1cRJ+3hQqixOBgeapJU=";
   };
 
-  cargoSha256 = "sha256-IUzaVeOTBAOo/jkDytk6qc7VatKX75l1yZy99iSIqyE=";
+  cargoSha256 = "sha256-qJIftByppOrT4g3sxmKRSLhxtpAW4eXWX0FhmMDJNu0=";
 
   # tests require network access
   doCheck = false;

pkgs/os-specific/linux/zenmonitor/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "zenmonitor";
-  version = "1.5.0";
+  version = "2.0.0";
 
   src = fetchFromGitHub {
     owner = "Ta180m";
     repo = "zenmonitor3";
     rev = "v${version}";
-    sha256 = "sha256-dbjLpfflIsEU+wTApghJYBPxBXqS/7MJqcMBcj50o6I=";
+    sha256 = "sha256-2EsuSMXnnMg0e0JD1TXJplsi7sOg9em0qqge2WlC6ro=";
   };
 
   buildInputs = [ gtk3 ];

pkgs/tools/backup/kopia/default.nix

···
 
 buildGoModule rec {
   pname = "kopia";
-  version = "0.10.4";
+  version = "0.10.5";
 
   src = fetchFromGitHub {
     owner = pname;
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-L6aAcIGNNts4rsJNCmuKSFtBWe/VUzhwiNmlpKCZ+B4=";
+    sha256 = "sha256-9H57NlvyEEOX2F3ooWWqDAo7MnS9J+XrYv/cIyNo6+Y=";
   };
 
-  vendorSha256 = "sha256-jswXHGjDnH3dVjpvdbr/sMYyWmGvTAZB77oKBMkBsnI=";
+  vendorSha256 = "sha256-c8WohMyaOicPq2q+DkgNBBulMEJCZFNFe+xECUEpelI=";
 
   doCheck = false;
 

pkgs/tools/misc/latex2html/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "latex2html";
-  version = "2021.2";
+  version = "2022";
 
   src = fetchFromGitHub {
     owner = pname;
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-WxMB70TeN53S6PNYDUVZ7lBKw7DvKnJDiHek9/GUYcA=";
+    sha256 = "sha256-a+OFBNMtP6mDqg1k9rjDLEJhZDM+zdRpPbn3aeC+Qks=";
   };
 
   buildInputs = [ ghostscript netpbm perl ];