Merge staging-next into staging

lib/options.nix

···
      Example:
        mkPackageOption pkgs "GHC" {
          default = [ "ghc" ];
-         example = "pkgs.haskell.package.ghc922.ghc.withPackages (hkgs: [ hkgs.primes ])";
+         example = "pkgs.haskell.package.ghc923.ghc.withPackages (hkgs: [ hkgs.primes ])";
        }
        => { _type = "option"; default = «derivation /nix/store/jxx55cxsjrf8kyh3fp2ya17q99w7541r-ghc-8.10.7.drv»; defaultText = { ... }; description = "The GHC package to use."; example = { ... }; type = { ... }; }
   */

nixos/doc/manual/development/option-declarations.section.md

···
 ```nix
 lib.mkPackageOption pkgs "GHC" {
   default = [ "ghc" ];
-  example = "pkgs.haskell.package.ghc922.ghc.withPackages (hkgs: [ hkgs.primes ])";
+  example = "pkgs.haskell.package.ghc923.ghc.withPackages (hkgs: [ hkgs.primes ])";
 }
 # is like
 lib.mkOption {
   type = lib.types.package;
   default = pkgs.ghc;
   defaultText = lib.literalExpression "pkgs.ghc";
-  example = lib.literalExpression "pkgs.haskell.package.ghc922.ghc.withPackages (hkgs: [ hkgs.primes ])";
+  example = lib.literalExpression "pkgs.haskell.package.ghc923.ghc.withPackages (hkgs: [ hkgs.primes ])";
   description = "The GHC package to use.";
 }
 ```

nixos/doc/manual/from_md/development/option-declarations.section.xml

···
         <programlisting language="bash">
 lib.mkPackageOption pkgs &quot;GHC&quot; {
   default = [ &quot;ghc&quot; ];
-  example = &quot;pkgs.haskell.package.ghc922.ghc.withPackages (hkgs: [ hkgs.primes ])&quot;;
+  example = &quot;pkgs.haskell.package.ghc923.ghc.withPackages (hkgs: [ hkgs.primes ])&quot;;
 }
 # is like
 lib.mkOption {
   type = lib.types.package;
   default = pkgs.ghc;
   defaultText = lib.literalExpression &quot;pkgs.ghc&quot;;
-  example = lib.literalExpression &quot;pkgs.haskell.package.ghc922.ghc.withPackages (hkgs: [ hkgs.primes ])&quot;;
+  example = lib.literalExpression &quot;pkgs.haskell.package.ghc923.ghc.withPackages (hkgs: [ hkgs.primes ])&quot;;
   description = &quot;The GHC package to use.&quot;;
 }
 </programlisting>

nixos/lib/test-driver/test_driver/machine.py

···
         with self.nested("waiting for {} to appear on tty {}".format(regexp, tty)):
             retry(tty_matches)
 
-    def send_chars(self, chars: List[str]) -> None:
+    def send_chars(self, chars: str) -> None:
         with self.nested("sending keys ‘{}‘".format(chars)):
             for char in chars:
                 self.send_key(char)

nixos/tests/ecryptfs.nix

···
 
   testScript = ''
     def login_as_alice():
-        machine.wait_until_tty_matches(1, "login: ")
+        machine.wait_until_tty_matches("1", "login: ")
         machine.send_chars("alice\n")
-        machine.wait_until_tty_matches(1, "Password: ")
+        machine.wait_until_tty_matches("1", "Password: ")
         machine.send_chars("foobar\n")
-        machine.wait_until_tty_matches(1, "alice\@machine")
+        machine.wait_until_tty_matches("1", "alice\@machine")
 
 
     def logout():
         machine.send_chars("logout\n")
-        machine.wait_until_tty_matches(1, "login: ")
+        machine.wait_until_tty_matches("1", "login: ")
 
 
     machine.wait_for_unit("default.target")
···
     with subtest("Log alice in (ecryptfs passwhrase is wrapped during first login)"):
         login_as_alice()
         machine.send_chars("logout\n")
-        machine.wait_until_tty_matches(1, "login: ")
+        machine.wait_until_tty_matches("1", "login: ")
 
     # Why do I need to do this??
     machine.succeed("su alice -c ecryptfs-umount-private || true")

nixos/tests/login.nix

···
           machine.wait_until_succeeds("pgrep -f 'agetty.*tty2'")
 
       with subtest("Log in as alice on a virtual console"):
-          machine.wait_until_tty_matches(2, "login: ")
+          machine.wait_until_tty_matches("2", "login: ")
           machine.send_chars("alice\n")
-          machine.wait_until_tty_matches(2, "login: alice")
+          machine.wait_until_tty_matches("2", "login: alice")
           machine.wait_until_succeeds("pgrep login")
-          machine.wait_until_tty_matches(2, "Password: ")
+          machine.wait_until_tty_matches("2", "Password: ")
           machine.send_chars("foobar\n")
           machine.wait_until_succeeds("pgrep -u alice bash")
           machine.send_chars("touch done\n")

nixos/tests/pam/pam-oath-login.nix

···
     machine.screenshot("postboot")
 
     with subtest("Invalid password"):
-        switch_to_tty(2)
-        enter_user_alice(2)
+        switch_to_tty("2")
+        enter_user_alice("2")
 
         machine.send_chars("${oathSnakeOilPassword1}\n")
-        machine.wait_until_tty_matches(2, "Password: ")
+        machine.wait_until_tty_matches("2", "Password: ")
         machine.send_chars("blorg\n")
-        machine.wait_until_tty_matches(2, "Login incorrect")
+        machine.wait_until_tty_matches("2", "Login incorrect")
 
     with subtest("Invalid oath token"):
-        switch_to_tty(3)
-        enter_user_alice(3)
+        switch_to_tty("3")
+        enter_user_alice("3")
 
         machine.send_chars("000000\n")
-        machine.wait_until_tty_matches(3, "Login incorrect")
-        machine.wait_until_tty_matches(3, "login:")
+        machine.wait_until_tty_matches("3", "Login incorrect")
+        machine.wait_until_tty_matches("3", "login:")
 
     with subtest("Happy path: Both passwords are mandatory to get us in"):
-        switch_to_tty(4)
-        enter_user_alice(4)
+        switch_to_tty("4")
+        enter_user_alice("4")
 
         machine.send_chars("${oathSnakeOilPassword2}\n")
-        machine.wait_until_tty_matches(4, "Password: ")
+        machine.wait_until_tty_matches("4", "Password: ")
         machine.send_chars("${alicePassword}\n")
 
         machine.wait_until_succeeds("pgrep -u alice bash")

nixos/tests/shadow.nix

···
         shadow.wait_until_succeeds("[ $(fgconsole) = 2 ]")
         shadow.wait_for_unit("[e-mail]")
         shadow.wait_until_succeeds("pgrep -f 'agetty.*tty2'")
-        shadow.wait_until_tty_matches(2, "login: ")
+        shadow.wait_until_tty_matches("2", "login: ")
         shadow.send_chars("emma\n")
-        shadow.wait_until_tty_matches(2, "login: emma")
+        shadow.wait_until_tty_matches("2", "login: emma")
         shadow.wait_until_succeeds("pgrep login")
         shadow.sleep(2)
         shadow.send_chars("${password1}\n")
···
         shadow.wait_until_succeeds("[ $(fgconsole) = 3 ]")
         shadow.wait_for_unit("[e-mail]")
         shadow.wait_until_succeeds("pgrep -f 'agetty.*tty3'")
-        shadow.wait_until_tty_matches(3, "login: ")
+        shadow.wait_until_tty_matches("3", "login: ")
         shadow.send_chars("emma\n")
-        shadow.wait_until_tty_matches(3, "login: emma")
+        shadow.wait_until_tty_matches("3", "login: emma")
         shadow.wait_until_succeeds("pgrep login")
         shadow.sleep(2)
         shadow.send_chars("${password1}\n")
···
         shadow.wait_until_succeeds("[ $(fgconsole) = 4 ]")
         shadow.wait_for_unit("[e-mail]")
         shadow.wait_until_succeeds("pgrep -f 'agetty.*tty4'")
-        shadow.wait_until_tty_matches(4, "login: ")
+        shadow.wait_until_tty_matches("4", "login: ")
         shadow.send_chars("emma\n")
-        shadow.wait_until_tty_matches(4, "login: emma")
+        shadow.wait_until_tty_matches("4", "login: emma")
         shadow.wait_until_succeeds("pgrep login")
         shadow.sleep(2)
         shadow.send_chars("${password1}\n")
-        shadow.wait_until_tty_matches(4, "Login incorrect")
-        shadow.wait_until_tty_matches(4, "login:")
+        shadow.wait_until_tty_matches("4", "Login incorrect")
+        shadow.wait_until_tty_matches("4", "login:")
         shadow.send_chars("emma\n")
-        shadow.wait_until_tty_matches(4, "login: emma")
+        shadow.wait_until_tty_matches("4", "login: emma")
         shadow.wait_until_succeeds("pgrep login")
         shadow.sleep(2)
         shadow.send_chars("${password3}\n")
···
         shadow.wait_until_succeeds("[ $(fgconsole) = 5 ]")
         shadow.wait_for_unit("[e-mail]")
         shadow.wait_until_succeeds("pgrep -f 'agetty.*tty5'")
-        shadow.wait_until_tty_matches(5, "login: ")
+        shadow.wait_until_tty_matches("5", "login: ")
         shadow.send_chars("layla\n")
-        shadow.wait_until_tty_matches(5, "login: layla")
+        shadow.wait_until_tty_matches("5", "login: layla")
         shadow.wait_until_succeeds("pgrep login")
         shadow.send_chars("${password2}\n")
-        shadow.wait_until_tty_matches(5, "login:")
+        shadow.wait_until_tty_matches("5", "login:")
   '';
 })

nixos/tests/sway.nix

···
     maintainers = with lib.maintainers; [ primeos synthetica ];
   };
 
+  # testScriptWithTypes:49: error: Cannot call function of unknown type
+  #           (machine.succeed if succeed else machine.execute)(
+  #           ^
+  # Found 1 error in 1 file (checked 1 source file)
+  skipTypeCheck = true;
+
   nodes.machine = { config, ... }: {
     # Automatically login on tty1 as a normal user:
     imports = [ ./common/user-account.nix ];

nixos/tests/uptermd.nix

···
 
     client1.wait_for_unit("multi-user.target")
     client1.wait_until_succeeds("pgrep -f 'agetty.*tty1'")
-    client1.wait_until_tty_matches(1, "login: ")
+    client1.wait_until_tty_matches("1", "login: ")
     client1.send_chars("root\n")
     client1.wait_until_succeeds("pgrep -u root bash")
 

nixos/tests/user-activation-scripts.nix

···
 
     machine.wait_for_unit("multi-user.target")
     machine.wait_for_unit("[e-mail]")
-    machine.wait_until_tty_matches(1, "login: ")
+    machine.wait_until_tty_matches("1", "login: ")
     machine.send_chars("alice\n")
-    machine.wait_until_tty_matches(1, "Password: ")
+    machine.wait_until_tty_matches("1", "Password: ")
     machine.send_chars("pass1\n")
     machine.send_chars("touch login-ok\n")
     machine.wait_for_file("/home/alice/login-ok")

nixos/tests/user-home-mode.nix

···
   testScript = ''
     machine.wait_for_unit("multi-user.target")
     machine.wait_for_unit("[e-mail]")
-    machine.wait_until_tty_matches(1, "login: ")
+    machine.wait_until_tty_matches("1", "login: ")
     machine.send_chars("alice\n")
-    machine.wait_until_tty_matches(1, "Password: ")
+    machine.wait_until_tty_matches("1", "Password: ")
     machine.send_chars("pass1\n")
     machine.succeed('[ "$(stat -c %a /home/alice)" == "700" ]')
     machine.succeed('[ "$(stat -c %a /home/bob)" == "750" ]')

nixos/tests/zsh-history.nix

···
     default.wait_until_succeeds("pgrep -f 'agetty.*tty1'")
 
     # Login
-    default.wait_until_tty_matches(1, "login: ")
+    default.wait_until_tty_matches("1", "login: ")
     default.send_chars("root\n")
-    default.wait_until_tty_matches(1, r"\nroot@default\b")
+    default.wait_until_tty_matches("1", r"\nroot@default\b")
 
     # Generate some history
     default.send_chars("echo foobar\n")
-    default.wait_until_tty_matches(1, "foobar")
+    default.wait_until_tty_matches("1", "foobar")
 
     # Ensure that command was recorded in history
     default.succeed("/run/current-system/sw/bin/history list | grep -q foobar")

pkgs/applications/networking/flexget/default.nix

···
 
 python3Packages.buildPythonApplication rec {
   pname = "flexget";
-  version = "3.3.14";
+  version = "3.3.15";
 
   # Fetch from GitHub in order to use `requirements.in`
   src = fetchFromGitHub {
     owner = "flexget";
     repo = "flexget";
     rev = "refs/tags/v${version}";
-    hash = "sha256-v52QVyd2Rl1nixKD1TY1YQaSPKRsbw4BCtfRly9aMrM=";
+    hash = "sha256-SNAhuiUO8f92LAdnV9q04xK4yT+AVAS+YAHPPtHdMYI=";
   };
 
   postPatch = ''

pkgs/applications/networking/mailreaders/evolution/evolution/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "evolution";
-  version = "3.44.1";
+  version = "3.44.2";
 
   src = fetchurl {
     url = "mirror://gnome/sources/evolution/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "dEx+CK0R4bYQPO60u/2Jo7Yo4SbOOGe7AI80F8wEnqk=";
+    sha256 = "+scGznpXP42WdzfxWtDr66Q6h/48p1f4VBID2ZG+BjM=";
   };
 
   nativeBuildInputs = [

pkgs/applications/science/astronomy/gravit/default.nix

···
-{ lib, stdenv, fetchFromGitHub, SDL, SDL_ttf, SDL_image, libSM, libICE, libGLU, libGL, libpng, lua5, autoconf, automake }:
+{ lib, stdenv, fetchFromGitHub, fetchpatch, SDL, SDL_ttf, SDL_image, libSM, libICE, libGLU, libGL, libpng, lua5, autoconf, automake }:
 
 stdenv.mkDerivation rec {
   pname = "gravit";
···
     rev = version;
     hash = "sha256-JuqnLLD5+Ec8kQI0SK98V1O6TTbGM6+yKn5KCHe85eM=";
   };
+
+  patches = [
+    # Pull fix pending upstream inclusion for -fno-common toolchains:
+    #   https://github.com/gak/gravit/pull/100
+    (fetchpatch {
+      name = "fno-common.patch";
+      url = "https://github.com/gak/gravit/commit/0f848834889212f16201fd404d2d5b9bb5b47d23.patch";
+      hash = "sha256-k1aMIg7idMt53o6dFgIKJflOMp0Jp5NwgWEijcIwXrQ=";
+    })
+  ];
 
   buildInputs = [ libGLU libGL SDL SDL_ttf SDL_image lua5 libpng libSM libICE ];
 

pkgs/applications/version-management/git-and-tools/git-absorb/default.nix

···
-{ lib, stdenv, fetchFromGitHub, rustPlatform, installShellFiles, libiconv, Security }:
+{ lib, stdenv, fetchFromGitHub, rustPlatform, installShellFiles, Security }:
 
 rustPlatform.buildRustPackage rec {
   pname = "git-absorb";
-  version = "0.6.6";
+  version = "0.6.7";
 
   src = fetchFromGitHub {
-    owner  = "tummychow";
-    repo   = pname;
-    rev    = "refs/tags/${version}";
-    sha256 = "04v10bn24acify34vh5ayymsr1flcyb05f3az9k1s2m6nlxy5gb9";
+    owner = "tummychow";
+    repo = pname;
+    rev = "refs/tags/${version}";
+    sha256 = "sha256-qhUw1wjXn1tyiH175+BadcoKoZ0wHxpMTKDIKOcJjQ0=";
   };
 
   nativeBuildInputs = [ installShellFiles ];
 
-  buildInputs = lib.optionals stdenv.isDarwin [ libiconv Security ];
+  buildInputs = lib.optionals stdenv.isDarwin [ Security ];
 
-  cargoSha256 = "0dax6wkbyk5p8p0mm406vfgmqfmfxzyzqps6yk8fachi61x12ja6";
+  cargoSha256 = "sha256-Wh2kA12CggbgdofWJwPAy+587qfMUPSy9nQmO11+keY=";
 
   postInstall = ''
     installManPage Documentation/git-absorb.1
-    for shell in bash zsh fish; do
-      $out/bin/git-absorb --gen-completions $shell > git-absorb.$shell
-      installShellCompletion git-absorb.$shell
-    done
+    installShellCompletion --cmd git-absorb \
+      --bash <($out/bin/git-absorb --gen-completions bash) \
+      --fish <($out/bin/git-absorb --gen-completions fish) \
+      --zsh <($out/bin/git-absorb --gen-completions zsh)
   '';
 
   meta = with lib; {

pkgs/applications/version-management/gitlab/data.json

···
 {
-  "version": "15.0.0",
-  "repo_hash": "sha256-+ZLHo35BhgWlopuwrVGiMvcWl8qUvHUV2kAEIXWazyY=",
+  "version": "15.0.1",
+  "repo_hash": "sha256-GMdR8drmnLR5KH/N0iyLmPi2sggeQX7PT2KP3QO5+/Y=",
   "yarn_hash": "1a8k3x3b9sirzicqkwmr10m27n593iljfh8awdc9700akbj155lr",
   "owner": "gitlab-org",
   "repo": "gitlab",
-  "rev": "v15.0.0-ee",
+  "rev": "v15.0.1-ee",
   "passthru": {
-    "GITALY_SERVER_VERSION": "15.0.0",
+    "GITALY_SERVER_VERSION": "15.0.1",
     "GITLAB_PAGES_VERSION": "1.58.0",
     "GITLAB_SHELL_VERSION": "14.3.0",
-    "GITLAB_WORKHORSE_VERSION": "15.0.0"
+    "GITLAB_WORKHORSE_VERSION": "15.0.1"
   }
 }

pkgs/applications/version-management/gitlab/gitaly/default.nix

···
     gemdir = ./.;
   };
 
-  version = "15.0.0";
+  version = "15.0.1";
   package_version = "v14";
   gitaly_package = "gitlab.com/gitlab-org/gitaly/${package_version}";
 in
···
     owner = "gitlab-org";
     repo = "gitaly";
     rev = "v${version}";
-    sha256 = "sha256-ib/gGkXo6W6LZ6j92oUMhJWdDYZRnA1p+tsOK6ewemk=";
+    sha256 = "sha256-pNVeXB2A8jYUVir6t8jz6ifBksWucZjUn6RIszXdwJY=";
   };
 
   vendorSha256 = "sha256-/tHKWo09ZV31TSIqlOk36V3y7gNikziUJHf+nS1gHEw=";

pkgs/applications/version-management/gitlab/gitlab-workhorse/default.nix

···
 buildGoModule rec {
   pname = "gitlab-workhorse";
 
-  version = "15.0.0";
+  version = "15.0.1";
 
   src = fetchFromGitLab {
     owner = data.owner;

pkgs/data/fonts/font-awesome/default.nix

···
     inherit rev;
 
     postFetch = ''
-      tar xf $downloadedFile --strip=1
-      install -m444 -Dt $out/share/fonts/opentype {fonts,otfs}/*.otf
+      install -m444 -Dt $out/share/fonts/opentype $out/{fonts,otfs}/*.otf
+      shopt -s extglob dotglob
+      rm -rf $out/!(share)
+      shopt -u extglob dotglob
     '';
 
     inherit sha256;
···
   v4 = font-awesome {
     version = "4.7.0";
     rev = "v4.7.0";
-    sha256 = "1j8i32dq6rrlv3kf2hnq81iqks06kczaxjks7nw3zyq1231winm9";
+    sha256 = "sha256-qdrIwxAB+z+4PXrKrj6bBuiJY0DYQuHm2DRng5sYEck=";
   };
   v5 = font-awesome {
     version = "5.15.3";
···
   };
   v6 = font-awesome {
     version = "6.1.1";
-    sha256 = "sha256-BjK1PJQFWtKDvfQ2Vh7BoOPqYucyvOG+2Pu/Kh+JpAA";
+    sha256 = "sha256-BjK1PJQFWtKDvfQ2Vh7BoOPqYucyvOG+2Pu/Kh+JpAA=";
   };
 }

pkgs/data/fonts/mplus-outline-fonts/default.nix

···
   osdnRelease = fetchzip {
     name = "${pname}-osdn";
     url = "mirror://osdn/mplus-fonts/62344/mplus-TESTFLIGHT-063a.tar.xz";
-    sha256 = "16jirhkjs46ac8cdk2w4xkpv989gmz7i8gnrq9bck13rbil7wlzr";
+    sha256 = "sha256-+VN+aFx5hMlWwtk+FM+vL6G07+yEi9kYYsoQLSfMUZo=";
     postFetch = ''
-      mkdir -p $out/share/fonts/truetype/${pname}
-      tar xvJf $downloadedFile
-      mv */*.ttf $out/share/fonts/truetype/${pname}
+      install -m444 -Dt $out/share/fonts/truetype/${pname} $out/*.ttf
+      shopt -s extglob dotglob
+      rm -rf $out/!(share)
+      shopt -u extglob dotglob
     '';
 
     meta = with lib; {
···
     owner = "coz-m";
     repo = "MPLUS_FONTS";
     rev = "336fec4e9e7c1e61bd22b82e6364686121cf3932";
-    sha256 = "1ha92hyzcfbbq682c50k8clbhigc09rcb9mxjzjwqfj9rfp348id";
+    sha256 = "sha256-LSIyrstJOszll72mxXIC7EW4KEMTFCaQwWs59j0UScE=";
     postFetch = ''
       mkdir -p $out/share/fonts/{truetype,opentype}/${pname}
-      tar xvzf $downloadedFile
-      mv */fonts/ttf/* $out/share/fonts/truetype/${pname}
-      mv */fonts/otf/* $out/share/fonts/opentype/${pname}
+      mv $out/fonts/ttf/* $out/share/fonts/truetype/${pname}
+      mv $out/fonts/otf/* $out/share/fonts/opentype/${pname}
+      shopt -s extglob dotglob
+      rm -rf $out/!(share)
+      shopt -u extglob dotglob
     '';
 
     meta = with lib; {

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "d69efcbdc39d5a7ae25039f9737ad04e34f38f68",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/d69efcbdc39d5a7ae25039f9737ad04e34f38f68.tar.gz",
-  "sha256": "1xlnp36h5r8q3nf1fbq472rkqp0wmgz51rylnd23kl0pba2fypkp",
-  "msg": "Update from Hackage at 2022-05-20T19:45:02Z"
+  "commit": "1da63d5bfb88cd1e920fefd1b55650c78edc5539",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/1da63d5bfb88cd1e920fefd1b55650c78edc5539.tar.gz",
+  "sha256": "1n8qv8ajfwrj73f81m2zj81jyjx1jxxhjljwp8gch2aq8piz74g6",
+  "msg": "Update from Hackage at 2022-05-29T17:05:02Z"
 }

pkgs/desktops/gnome/core/rygel/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "rygel";
-  version = "0.40.3";
+  version = "0.40.4";
 
   # TODO: split out lib
   outputs = [ "out" "dev" ];
 
   src = fetchurl {
     url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "zwvjUQnLVw5c8K/lltha7Lmw6TWYYVNTArt7YE2vUdc=";
+    sha256 = "c22K2+hhX2y8j8//mEXcmF/RDhZinaI2tLUtvt8KNIs=";
   };
 
   patches = [

pkgs/development/compilers/eli/default.nix

···
   # skip interactive browser check
   buildFlags = [ "nobrowsers" ];
 
+  # Workaround build failure on -fno-common toolchains:
+  #   ld: cexp.o:(.bss+0x40): multiple definition of `obstck'; cccp.o:(.bss+0x0): first defined here
+  NIX_CFLAGS_COMPILE = "-fcommon";
 
   preConfigure=''
     configureFlagsArray=(

pkgs/development/compilers/ghc/8.10.7.nix

···
     # GHC is a bit confused on its cross terminology, as these would normally be
     # the *host* tools.
     export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"
-    export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"
+    export CXX="${targetCC}/bin/${targetCC.targetPrefix}c++"
     # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177
     export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString useLdGold ".gold"}"
     export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"

pkgs/development/compilers/ghc/8.8.4.nix

···
     # GHC is a bit confused on its cross terminology, as these would normally be
     # the *host* tools.
     export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"
-    export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"
+    export CXX="${targetCC}/bin/${targetCC.targetPrefix}c++"
     # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177
     export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString useLdGold ".gold"}"
     export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"

pkgs/development/compilers/ghc/9.0.2.nix

···
     # GHC is a bit confused on its cross terminology, as these would normally be
     # the *host* tools.
     export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"
-    export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"
+    export CXX="${targetCC}/bin/${targetCC.targetPrefix}c++"
     # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177
     export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString useLdGold ".gold"}"
     export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"

pkgs/development/compilers/ghc/9.2.2.nix pkgs/development/compilers/ghc/9.2.3.nix

···
 , xattr, autoSignDarwinBinariesHook
 , bash
 
+, autoreconfHook # GHC 9.2.3 tarballs don't have autoconf run on them
+
 , libiconv ? null, ncurses
 , glibcLocales ? null
 
···
 assert stdenv.targetPlatform.isDarwin -> buildTargetLlvmPackages.clang == llvmPackages.clang;
 
 stdenv.mkDerivation (rec {
-  version = "9.2.2";
+  version = "9.2.3";
   pname = "${targetPrefix}ghc${variantSuffix}";
 
   src = fetchurl {
     url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz";
-    sha256 = "902463a4cc6ee479af9358b9f8b2ee3237b03e934a1ea65b6d1fcf3e0d749ea6";
+    sha256 = "50ecdc2bef013e518f9a62a15245d7db0e4409d737c43b1cea7306fd82e1669e";
   };
 
   enableParallelBuilding = true;
···
     # GHC is a bit confused on its cross terminology, as these would normally be
     # the *host* tools.
     export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"
-    export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"
+    export CXX="${targetCC}/bin/${targetCC.targetPrefix}c++"
     # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177
     export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString useLdGold ".gold"}"
     export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"
···
   '' + ''
 
     echo -n "${buildMK}" > mk/build.mk
+    # GHC 9.2.3 tarball is not properly prepared
+    ./boot
+
     sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure
   '' + lib.optionalString (stdenv.isLinux && hostPlatform.libc == "glibc") ''
     export LOCALE_ARCHIVE="${glibcLocales}/lib/locale/locale-archive"
···
   dontAddExtraLibs = true;
 
   nativeBuildInputs = [
+    autoreconfHook # GHC 9.2.3 tarball hasn't autoconf run on it
     perl autoconf automake m4 python3
     ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour
   ] ++ lib.optionals (stdenv.isDarwin && stdenv.isAarch64) [

pkgs/development/compilers/ghc/head.nix

···
     # GHC is a bit confused on its cross terminology, as these would normally be
     # the *host* tools.
     export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"
-    export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"
+    export CXX="${targetCC}/bin/${targetCC.targetPrefix}c++"
     # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177
     # and more generally have a faster linker.
     export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString useLdGold ".gold"}"

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

···
       name = "git-annex-${super.git-annex.version}-src";
       url = "git://git-annex.branchable.com/";
       rev = "refs/tags/" + super.git-annex.version;
-      sha256 = "sha256-NYe34bsq2v0rlmcSMgYvU9ec94meXFFJoWo0sIjX/bY=";
+      sha256 = "0a0jnahljd46vzjgcwlzjhrrjgn40s0zfjklh63aa9w9x0zkvbin";
       # delete android and Android directories which cause issues on
       # darwin (case insensitive directory). Since we don't need them
       # during the build process, we can delete it to prevent a hash
···
   #    else dontCheck super.doctest-discover);
   doctest-discover = dontCheck super.doctest-discover;
 
-  # Depends on itself for testing
   tasty-discover = overrideCabal (drv: {
-    # Compatibility with tasty-hspec >= 1.1.7 requires a patch and a dependency on hspec
-    patches = drv.patches or [] ++ [
-      # Intermediate patch so fix applies
-      (fetchpatch {
-        url = "https://github.com/haskell-works/tasty-discover/commit/67b022f5945abdfb71ca31fca7910abc7effe043.patch";
-        sha256 = "1x539qa2871fiahw9zjxyyqz86v4ib7k7fv9hdvvxcrrfw3zwl66";
-      })
-      # Actual fix
-      (fetchpatch {
-        name = "tasty-hspec-1.1.7-compat.patch";
-        url = "https://github.com/haskell-works/tasty-discover/commit/98d3c464f33129e38fa9c0fcdfb1847dfb0490b9.patch";
-        sha256 = "01a8ni3lyh1wql7aghl41nd2c9m6gcn1i77bh3pygh6r403x771p";
-      })
-    ];
-    testHaskellDepends = drv.testHaskellDepends or [] ++ [
-      self.hspec
-    ];
-    # https://github.com/haskell-works/tasty-discover/issues/17
-    jailbreak = true; # allow tasty-hspec >= 1.2
-
+    # Depends on itself for testing
     preBuild = ''
       export PATH="$PWD/dist/build/tasty-discover:$PATH"
     '' + (drv.preBuild or "");
···
   # https://github.com/diagrams/diagrams-braille/issues/1
   diagrams-braille = doJailbreak super.diagrams-braille;
 
-  # https://github.com/timbod7/haskell-chart/pull/231#issuecomment-953745932
-  Chart-diagrams = doJailbreak (super.Chart-diagrams.override {
-    SVGFonts = super.SVGFonts_1_7_0_1;
-  });
-
   # https://github.com/xu-hao/namespace/issues/1
   namespace = doJailbreak super.namespace;
 
···
   sensei = overrideCabal (drv: {
     testHaskellDepends = drv.testHaskellDepends or [] ++ [ self.hspec-meta_2_9_3 ];
     testToolDepends = drv.testToolDepends or [] ++ [ pkgs.git ];
-  }) (super.sensei.overrideScope (self: super: {
-    hspec-meta = self.hspec-meta_2_9_3;
+  }) (super.sensei.override {
     hspec = self.hspec_2_10_0;
-    hspec-core = dontCheck self.hspec-core_2_10_0;
-    hspec-discover = self.hspec-discover_2_10_0;
-    shelly = dontCheck super.shelly; # disable checks, because the newer hspec in this overrideScope doesn‘t work with newest hspec-contrib
-  }));
+    hspec-wai = super.hspec-wai.override {
+      hspec = self.hspec_2_10_0;
+    };
+  });
 
   # Depends on broken fluid.
   fluid-idl-http-client = markBroken super.fluid-idl-http-client;
···
   # https://github.com/haskell/hoopl/issues/50
   hoopl = dontCheck super.hoopl;
 
-  # The most recent version of purescript-cst (0.4.0.0) has version
-  # bounds for LTS-17, so we need to jailbreak it for LTS-18.
-  # doJailbreak can likely be removed when the next version of
-  # purescript-cst is released, since the version bounds have
-  # been updated for LTS-18.
-  purescript-cst = doJailbreak super.purescript-cst;
-
-  purescript =
-    lib.pipe
-      (super.purescript.override {
-        # The latest version of language-javascript is 0.7.1.0,
-        # but it seems to have a bug with async support:
-        # https://github.com/erikd/language-javascript/issues/131
-        language-javascript = self.language-javascript_0_7_0_0;
-      })
-      [ # This PR upgrades purescript from building with LTS-17 to building
-        # with LTS-18.  Aside from bumping dependency bounds, there is one
-        # minor change that needs to be made in app/Main.hs.
-        #
-        # This patch can likely be removed when purescript-0.14.6 is released.
-        (appendPatch
-          (fetchpatch {
-            url = "https://patch-diff.githubusercontent.com/raw/purescript/purescript/pull/4199.patch";
-            sha256 = "sha256-OeG30EfCHs7gttLME909WfKxkEZr7Ch3leYiw4lElGg=";
-            includes = [
-              "app/Main.hs"
-            ];
-          })
-        )
-        # PureScript uses nodejs to run tests, so the tests have been disabled
-        # for now.  If someone is interested in figuring out how to get this
-        # working, it seems like it might be possible.
-        dontCheck
-        # The current version of purescript (0.14.5) has version bounds for LTS-17,
-        # but it compiles cleanly using deps in LTS-18 as well.  This jailbreak can
-        # likely be removed when purescript-0.14.6 is released.
-        doJailbreak
-        # Generate shell completions
-        (generateOptparseApplicativeCompletion "purs")
-      ];
-
-  # purenix-1.0 has a strict version bound requiring purescript-0.14.4, but it
-  # works with later versions of purescript as well.
-  purenix = doJailbreak super.purenix;
-
   # Generate shell completion for spago
   spago = generateOptparseApplicativeCompletion "spago" super.spago;
 
···
   liquidhaskell = super.liquidhaskell.override { Diff = self.Diff_0_3_4; };
   Diff_0_3_4 = dontCheck super.Diff_0_3_4;
 
-  # jailbreaking pandoc-citeproc because it has not bumped upper bound on pandoc
-  pandoc-citeproc = doJailbreak super.pandoc-citeproc;
+  # jailbreaking pandoc-crossref because it has not bumped its upper bound on pandoc
+  # https://github.com/lierdakil/pandoc-crossref/issues/350
+  pandoc-crossref = doJailbreak super.pandoc-crossref;
 
   # The test suite attempts to read `/etc/resolv.conf`, which doesn't work in the sandbox.
   domain-auth = dontCheck super.domain-auth;
···
   reflex-dom-pandoc = super.reflex-dom-pandoc.override { clay = dontCheck self.clay_0_13_3; };
 
   # 2022-03-16: Pull request for ghc 9 compat: https://github.com/reflex-frp/reflex/pull/467
-  reflex = appendPatch (fetchpatch {
-    url = "https://github.com/reflex-frp/reflex/compare/823afd9424234cbe0134051f09a6710e54509cec...469b4ab4a755cad76b8d4d6c9ad482d02686b4ae.patch";
-    sha256 = "sha256-EwW7QBXHGlcJkKiLDmsXCZPwQz24+mg2Vuiu0Vb/T6w=";
-  }) (dontCheck super.reflex);
+  reflex = overrideCabal (drv: {
+    patches = drv.patches or [] ++ [
+      (fetchpatch {
+        url = "https://github.com/reflex-frp/reflex/compare/469b4ab4a755cad76b8d4d6c9ad482d02686b4ae.patch";
+        sha256 = "04sxzxpx7xhr6p4n76rg1ci8zjfzs19lr21ziwsfig8zmdg22i7q";
+      })
+    ];
+    doCheck = false;
+    # hackage revision seems to have DOS newlines
+    prePatch = drv.prePatch or "" + ''
+      ${pkgs.buildPackages.dos2unix}/bin/dos2unix reflex.cabal
+    '';
+  }) super.reflex;
 
   # 2020-11-19: jailbreaking because of pretty-simple bound out of date
   # https://github.com/kowainik/stan/issues/408
···
   # 2020-11-27: Tests broken
   # Upstream issue: https://github.com/haskell-servant/servant-swagger/issues/129
   servant-swagger = dontCheck super.servant-swagger;
+
+  # Strange doctest problems
+  # https://github.com/biocad/servant-openapi3/issues/30
+  servant-openapi3 = dontCheck super.servant-openapi3;
+
+  # Give hspec 2.10.* correct dependency versions without overrideScope
+  hspec_2_10_0 = doDistribute (super.hspec_2_10_0.override {
+    hspec-discover = self.hspec-discover_2_10_0;
+    hspec-core = self.hspec-core_2_10_0;
+  });
+  hspec-discover_2_10_0 = super.hspec-discover_2_10_0.override {
+    hspec-meta = self.hspec-meta_2_9_3;
+  };
+  hspec-core_2_10_0 = super.hspec-core_2_10_0.override {
+    hspec-meta = self.hspec-meta_2_9_3;
+  };
 
   # waiting for aeson bump
   servant-swagger-ui-core = doJailbreak super.servant-swagger-ui-core;
···
   # https://github.com/muesli4/table-layout/issues/16
   table-layout = doJailbreak super.table-layout;
 
-  # Bounds on profunctors are too strict
-  # https://github.com/ConferOpenSource/composite/issues/50
-  # Remove overrides when assert fails.
-  composite-base = assert super.composite-base.version == "0.7.5.0";
-    overrideCabal (drv: {
-      patches = drv.patches or [] ++ [
-        (fetchpatch {
-          name = "composite-base-template-haskell-2.17.patch";
-          url = "https://github.com/ConferOpenSource/composite/commit/4ca7562d46a0cdfae3afacf194134db768450a02.patch";
-          sha256 = "sha256-FG2t1BYfV09VENJDlh1PD88sXAGqaujhpss5DWFcbeE=";
-          relative = "composite-base";
-        })
-      ];
-      jailbreak = true;
-    }) super.composite-base;
-  composite-aeson = assert super.composite-aeson.version == "0.7.5.0";
-    doJailbreak super.composite-aeson;
-
   # 2021-06-20: Outdated upper bounds
   # https://github.com/Porges/email-validate-hs/issues/58
   email-validate = doJailbreak super.email-validate;
···
 
   # 2022-03-21: Newest stylish-haskell needs ghc-lib-parser-9_2
   stylish-haskell = (super.stylish-haskell.override {
-    ghc-lib-parser = super.ghc-lib-parser_9_2_2_20220307;
-    ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_2_0_3;
+    ghc-lib-parser = super.ghc-lib-parser_9_2_3_20220527;
+    ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_2_0_4;
   });
 
-  ghc-lib-parser-ex_9_2_0_3 = super.ghc-lib-parser-ex_9_2_0_3.override {
-    ghc-lib-parser = super.ghc-lib-parser_9_2_2_20220307;
+  ghc-lib-parser-ex_9_2_0_4 = super.ghc-lib-parser-ex_9_2_0_4.override {
+    ghc-lib-parser = super.ghc-lib-parser_9_2_3_20220527;
   };
 
   # To strict bound on hspec
···
   # attoparsec bump is on v2 branch, but not released yet
   irc-core = assert super.irc-core.version == "2.10"; doJailbreak super.irc-core;
   glirc = assert super.irc-core.version == "2.10"; doJailbreak super.glirc;
-  hookup = assert super.irc-core.version == "2.10"; doJailbreak super.hookup;
 
   # 2022-02-25: Unmaintained and to strict upper bounds
   paths = doJailbreak super.paths;
···
     })
   ] super.fast-tags;
 
-} // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super
+  # lucid-htmx has restrictive upper bounds on lucid and servant:
+  #
+  #   Setup: Encountered missing or private dependencies:
+  #   lucid >=2.9.12.1 && <=2.11, servant >=0.18.3 && <0.19
+  #
+  # Can be removed once
+  #
+  # > https://github.com/MonadicSystems/lucid-htmx/issues/6
+  #
+  # has been resolved.
+  lucid-htmx = doJailbreak super.lucid-htmx;
+
+} // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super // (let
+  # We need to build purescript with these dependencies and thus also its reverse
+  # dependencies to avoid version mismatches in their dependency closure.
+  # TODO(@cdepillabout): maybe unify with the spago overlay in configuration-nix.nix?
+  purescriptOverlay = self: super: {
+    # Purescript targets Stackage LTS 18, so we need to downgrade a few things
+    aeson = self.aeson_1_5_6_0;
+    bower-json = self.bower-json_1_0_0_1;
+    # As of 2021-11-08, the latest release of `language-javascript` is 0.7.1.0,
+    # but it has a problem with parsing the `async` keyword.  It doesn't allow
+    # `async` to be used as an object key:
+    # https://github.com/erikd/language-javascript/issues/131
+    language-javascript = self.language-javascript_0_7_0_0;
+  };
+
+  # Doesn't support GHC >= 9.0 (something related to instance resolution and TH)
+  purescriptBrokenFlag = drv:
+    if lib.versionAtLeast self.ghc.version "9.0"
+    then dontDistribute (markBroken drv)
+    else drv;
+in {
+  purescript =
+    lib.pipe
+      (super.purescript.overrideScope purescriptOverlay)
+      [
+        # PureScript uses nodejs to run tests, so the tests have been disabled
+        # for now.  If someone is interested in figuring out how to get this
+        # working, it seems like it might be possible.
+        dontCheck
+        # The current version of purescript (0.14.5) has version bounds for LTS-17,
+        # but it compiles cleanly using deps in LTS-18 as well.  This jailbreak can
+        # likely be removed when purescript-0.14.6 is released.
+        doJailbreak
+        # Generate shell completions
+        (generateOptparseApplicativeCompletion "purs")
+
+        purescriptBrokenFlag
+      ];
+
+  purescript-cst = purescriptBrokenFlag (super.purescript-cst.overrideScope purescriptOverlay);
+
+  purescript-ast = purescriptBrokenFlag (super.purescript-ast.overrideScope purescriptOverlay);
+
+  purenix = super.purenix.overrideScope purescriptOverlay;
+})

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

···
   inline-c-cpp =
     (if isDarwin then appendConfigureFlags ["--ghc-option=-fcompact-unwind"] else x: x)
     super.inline-c-cpp;
+
+  # 2022-05-31: weeder 2.3.0 requires GHC 9.2
+  weeder = doDistribute self.weeder_2_3_1;
 }

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

···
       self.data-default
     ] ++ drv.libraryHaskellDepends or [];
   }) super.ghc-exactprint;
-  ghc-lib = self.ghc-lib_9_2_2_20220307;
-  ghc-lib-parser = self.ghc-lib-parser_9_2_2_20220307;
-  ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_2_0_3;
+  ghc-lib = self.ghc-lib_9_2_3_20220527;
+  ghc-lib-parser = self.ghc-lib-parser_9_2_3_20220527;
+  ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_2_0_4;
   hackage-security = doJailbreak super.hackage-security;
   hashable = super.hashable_1_4_0_2;
   hashable-time = doJailbreak super.hashable-time;
···
   shelly = doJailbreak super.shelly;
   splitmix = doJailbreak super.splitmix;
   tasty-hspec = doJailbreak super.tasty-hspec;
-  th-desugar = self.th-desugar_1_13;
+  th-desugar = self.th-desugar_1_13_1;
   time-compat = doJailbreak super.time-compat;
   tomland = doJailbreak super.tomland;
   type-equality = doJailbreak super.type-equality;

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

···
   - compaREST
   - comparse
   - compdata
+  - compdoc
   - compendium-client
   - competition
   - compilation
   - complex-generic
   - composable-associations-aeson
   - compose-trans
-  - composite-aeson
+  - composite-aeson-path
+  - composite-cassava
+  - composite-dhall
+  - composite-ekg
+  - composite-lens-extra
   - composite-opaleye
   - composition-tree
   - comprehensions-ghc
···
   - gitson
   - gitter
   - git-vogue
+  - glade
   - glapp
   - glaze
   - Gleam
···
   - gli
   - glicko
   - glider-nlp
-  - glirc
   - GLMatrix
   - global-variables
   - glob-posix
···
   - lua-bc
   - luautils
   - lucid2
-  - lucid-htmx
   - lucid-hyperscript
   - luis-client
   - luka
···
   - Pup-Events-Server
   - purebred-email
   - pure-io
+  - purenix
   - pure-priority-queue
-  - purescript-ast
-  - purescript-cst
   - pure-zlib
   - pushbullet
   - pushbullet-types
···
   - signable-haskell-protoc
   - signed-multiset
   - simd
+  - simfin
   - simple-actors
   - simpleargs
   - simple-atom
···
   - text1
   - text-and-plots
   - text-ascii
+  - text-builder-linear
   - text-containers
   - text-format
   - text-format-heavy
···
   - webdriver
   - webdriver-snoy
   - web-encodings
+  - webkitgtk3
   - WeberLogic
   - webex-teams-pipes
   - webfinger-client

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

···
   - dhall-nix < 1.1.24
   # Temporarily forbid distribution-nixpkgs updates until cabal2nix supports the new version
   - distribution-nixpkgs < 1.7.0
+  # glirc 2.39 is broken: https://github.com/glguy/irc-core/issues/99
+  - glirc == 2.38
+  # glirc 2.38 requires hookup 0.6
+  - hookup == 0.6
 
 extra-packages:
   - aeson < 2                           # required by pantry-0.5.2
···
   - ormolu == 0.2.*                     # 2022-02-21: For ghc 8.8 and 8.10
   - ShellCheck == 0.7.2                 # 2022-02-20: haskell-ci 0.14 needs this
   - weeder == 2.2.*                     # 2022-02-21: preserve for GHC 8.10.7
+  - weeder == 2.3.*                     # 2022-05-31: preserve for GHC 9.0.2
   - attoparsec == 0.13.*                # 2022-02-23: Needed to compile elm for now
   - relude == 0.7.0.0                   # 2022-02-25: Needed for ema 0.6
-  - SVGFonts < 1.8                      # 2022-03-19: Needed for Chart-diagrams 1.9.3
   - clay < 0.14                         # 2022-03-20: Needed for neuron 1.0.0.0
   - hspec-golden == 0.1.*               # 2022-04-07: Needed for elm-format
   - tasty-hspec == 1.1.6                # 2022-04-07: Needed for elm-format
···
   - spike
   - web-browser-in-haskell
   - webkit
-  - webkitgtk3
   - webkitgtk3-javascriptcore
   - websnap
-
-  # 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 19.7
+# Stackage LTS 19.8
 # This file is auto-generated by
 # maintainers/scripts/haskell/update-stackage.sh
 default-package-overrides:
···
   - acid-state ==0.16.1
   - action-permutations ==0.0.0.1
   - active ==0.2.0.15
-  - ad ==4.5
+  - ad ==4.5.1
   - ad-delcont ==0.3.0.0
   - adjunctions ==4.4.1
   - adler32 ==0.1.2.0
···
   - brick ==0.68.1
   - brittany ==0.14.0.2
   - broadcast-chan ==0.2.1.2
+  - brotli ==0.0.0.0
+  - brotli-streams ==0.0.0.0
   - bsb-http-chunked ==0.0.0.4
   - bson ==0.4.0.1
   - bson-lens ==0.1.1
···
   - bytes ==0.17.2
   - byteset ==0.1.1.0
   - bytestring-builder ==0.10.8.2.0
-  - bytestring-conversion ==0.3.1
+  - bytestring-conversion ==0.3.2
   - bytestring-lexing ==0.5.0.8
   - bytestring-mmap ==0.2.2
   - bytestring-strict-builder ==0.4.5.5
···
   - character-cases ==0.1.0.6
   - charset ==0.3.9
   - charsetdetect-ae ==1.1.0.4
-  - Chart ==1.9.3
+  - Chart ==1.9.4
   - ChasingBottoms ==1.3.1.11
   - cheapskate ==0.1.1.2
   - cheapskate-highlight ==0.1.0.0
···
   - classy-prelude-conduit ==1.5.0
   - classy-prelude-yesod ==1.5.0
   - clay ==0.14.0
-  - cleff ==0.3.2.0
+  - cleff ==0.3.3.0
   - cleff-plugin ==0.1.0.0
   - clientsession ==0.9.1.2
   - climb ==0.3.3
···
   - concise ==0.1.0.1
   - concurrency ==1.11.0.2
   - concurrent-extra ==0.7.0.12
-  - concurrent-output ==1.10.15
+  - concurrent-output ==1.10.16
   - concurrent-split ==0.0.1.1
   - concurrent-supply ==0.1.8
   - cond ==0.4.1.1
···
   - connection ==0.3.1
   - connection-pool ==0.2.2
   - console-style ==0.0.2.1
-  - constraints ==0.13.3
+  - constraints ==0.13.4
   - constraints-extras ==0.3.2.1
   - constraint-tuples ==0.1.2
   - construct ==0.3.1
···
   - ctrie ==0.2
   - cubicbezier ==0.6.0.6
   - cubicspline ==0.1.2
-  - cublas ==0.6.0.0
-  - cuda ==0.11.0.0
-  - cue-sheet ==2.0.1
-  - cufft ==0.10.0.0
+  - cue-sheet ==2.0.2
   - curl ==1.3.8
   - curl-runnings ==0.17.0
   - currencies ==0.2.0.0
···
   - cursor-brick ==0.1.0.1
   - cursor-fuzzy-time ==0.0.0.0
   - cursor-gen ==0.4.0.0
-  - cusolver ==0.3.0.0
-  - cusparse ==0.3.0.0
   - cutter ==0.0
   - cyclotomic ==1.1.1
   - czipwith ==1.0.1.4
···
   - distributed-static ==0.3.9
   - distribution-opensuse ==1.1.3
   - distributive ==0.6.2.1
-  - djinn-lib ==0.0.1.3
+  - djinn-lib ==0.0.1.4
   - dlist ==1.0
   - dlist-instances ==0.1.1.1
   - dlist-nonempty ==0.1.1
···
   - error-or-utils ==0.2.0
   - errors ==2.3.0
   - errors-ext ==0.4.2
-  - ersatz ==0.4.10
+  - ersatz ==0.4.11
   - esqueleto ==3.5.4.1
   - essence-of-live-coding ==0.2.6
   - essence-of-live-coding-gloss ==0.2.6
···
   - fold-debounce ==0.2.0.9
   - fold-debounce-conduit ==0.2.0.6
   - foldl ==1.4.12
-  - folds ==0.7.7
+  - folds ==0.7.8
   - follow-file ==0.0.3
   - FontyFruity ==0.5.3.5
   - force-layout ==0.4.0.6
···
   - fuzzcheck ==0.1.1
   - fuzzy ==0.1.0.1
   - fuzzy-dates ==0.1.1.2
-  - fuzzyset ==0.2.2
+  - fuzzyset ==0.2.3
   - fuzzy-time ==0.2.0.0
   - gauge ==0.2.5
   - gd ==3000.7.3
···
   - ghc-lib-parser-ex ==9.0.0.6
   - ghc-parser ==0.2.3.0
   - ghc-paths ==0.1.0.12
-  - ghc-prof ==1.4.1.9
+  - ghc-prof ==1.4.1.11
   - ghc-source-gen ==0.4.3.0
   - ghc-syntax-highlighter ==0.0.7.0
   - ghc-tcplugins-extra ==0.4.2
···
   - gtk-sni-tray ==0.1.8.0
   - gtk-strut ==0.1.3.0
   - guarded-allocation ==0.0.1
+  - hackage-cli ==0.0.3.6
   - hackage-db ==2.1.2
   - hackage-security ==0.6.2.1
   - haddock-library ==1.10.0
···
   - haskell-src ==1.0.4
   - haskell-src-exts ==1.23.1
   - haskell-src-exts-util ==0.2.5
-  - haskell-src-meta ==0.8.9
+  - haskell-src-meta ==0.8.10
   - haskey-btree ==0.3.0.1
   - haskintex ==0.8.0.0
   - haskoin-core ==0.21.2
···
   - hpc-codecov ==0.3.0.0
   - HPDF ==1.6.0
   - hpp ==0.6.5
-  - hpqtypes ==1.9.3.1
+  - hpqtypes ==1.9.4.0
   - hprotoc ==2.4.17
   - hreader ==1.1.0
   - hreader-lens ==0.1.3.0
···
   - hsdns ==1.8
   - hsemail ==2.2.1
   - hset ==2.2.0
-  - hsexif ==0.6.1.8
+  - hsexif ==0.6.1.9
   - hs-GeoIP ==0.3
   - hsignal ==0.2.7.5
   - hsini ==0.5.1.2
···
   - http-directory ==0.1.9
   - http-download ==0.2.0.0
   - httpd-shed ==0.4.1.1
+  - http-io-streams ==0.1.6.1
   - http-link-header ==1.2.1
   - http-media ==0.8.0.0
   - http-query ==0.1.3
···
   - influxdb ==1.9.2.2
   - ini ==0.4.1
   - inj ==1.0
-  - inline-c ==0.9.1.5
+  - inline-c ==0.9.1.6
   - inline-c-cpp ==0.5.0.0
   - inliterate ==0.1.0
   - input-parsers ==0.2.3.2
   - insert-ordered-containers ==0.2.5.1
-  - inspection-testing ==0.4.6.0
+  - inspection-testing ==0.4.6.1
   - instance-control ==0.1.2.0
   - int-cast ==0.2.0.0
   - integer-logarithms ==1.0.3.1
···
   - jwt ==0.11.0
   - kan-extensions ==5.2.4
   - kanji ==3.5.0
-  - katip ==0.8.7.1
+  - katip ==0.8.7.2
   - katip-logstash ==0.1.0.2
   - katip-wai ==0.1.1.0
   - kazura-queue ==0.1.0.4
···
   - lift-generics ==0.2.1
   - lift-type ==0.1.0.1
   - line ==4.0.1
-  - linear ==1.21.8
+  - linear ==1.21.9
   - linear-base ==0.1.0
   - linear-circuit ==0.1.0.4
   - linebreak ==1.1.0.1
···
   - lzma ==0.0.0.3
   - lzma-clib ==5.2.2
   - lzma-conduit ==1.2.3
-  - machines ==0.7.2
+  - machines ==0.7.3
   - magic ==1.1
   - magico ==0.0.2.3
   - mainland-pretty ==0.7.1
···
   - microlens ==0.4.12.0
   - microlens-aeson ==2.4.1
   - microlens-contra ==0.1.0.2
-  - microlens-ghc ==0.4.13.1
-  - microlens-mtl ==0.2.0.1
+  - microlens-ghc ==0.4.13.2
+  - microlens-mtl ==0.2.0.2
   - microlens-platform ==0.4.2.1
   - microlens-process ==0.2.0.2
   - microlens-th ==0.4.3.10
   - microspec ==0.2.1.3
-  - microstache ==1.0.2
+  - microstache ==1.0.2.1
   - midair ==0.2.0.1
-  - midi ==0.2.2.2
+  - midi ==0.2.2.3
   - midi-alsa ==0.2.1
   - mighty-metropolis ==2.0.0
   - mime-mail ==0.5.1
···
   - model ==0.5
   - modern-uri ==0.3.4.4
   - modular ==0.1.0.8
-  - monad-chronicle ==1.0.0.1
+  - monad-chronicle ==1.0.1
   - monad-control ==1.0.3.1
   - monad-control-aligned ==0.0.1.1
   - monad-coroutine ==0.9.2
···
   - mono-traversable-keys ==0.2.0
   - more-containers ==0.2.2.2
   - morpheus-graphql-tests ==0.18.0
-  - moss ==0.2.0.0
+  - moss ==0.2.0.1
   - mountpoints ==1.0.2
   - mpi-hs ==0.7.2.0
   - mpi-hs-binary ==0.1.1.0
···
   - network-uri ==2.6.4.1
   - network-wait ==0.1.2.0
   - newtype ==0.2.2.0
-  - newtype-generics ==0.6.1
+  - newtype-generics ==0.6.2
   - nfc ==0.1.0
   - nicify-lib ==1.0.1
   - NineP ==0.0.2.1
···
   - not-gloss ==0.7.7.0
   - no-value ==1.0.0.0
   - nowdoc ==0.1.1.0
-  - nqe ==0.6.3
+  - nqe ==0.6.4
   - nsis ==0.3.3
   - numbers ==3000.2.0.2
   - numeric-extras ==0.1
···
   - numtype-dk ==0.5.0.3
   - nuxeo ==0.3.2
   - nvim-hs ==2.2.0.1
-  - nvvm ==0.10.0.0
   - ObjectName ==1.1.0.2
   - ochintin-daicho ==0.3.4.2
   - o-clock ==1.2.1.1
   - oeis ==0.3.10
-  - oeis2 ==1.0.7
   - ofx ==0.4.4.0
   - old-locale ==1.0.0.7
   - old-time ==1.1.0.3
···
   - operational ==0.2.4.1
   - operational-class ==0.3.0.0
   - opml-conduit ==0.9.0.0
-  - optics ==0.4.1
+  - optics ==0.4.2
   - optics-core ==0.4.1
-  - optics-extra ==0.4.1
+  - optics-extra ==0.4.2.1
   - optics-th ==0.4.1
   - optics-vl ==0.2.1
   - optima ==0.4.0.3
···
   - pattern-arrows ==0.0.2
   - pava ==0.1.1.3
   - pcg-random ==0.1.3.7
-  - pcre2 ==2.1.1
+  - pcre2 ==2.1.1.1
   - pcre-heavy ==1.0.0.2
   - pcre-light ==0.4.1.0
   - pcre-utils ==0.1.8.2
···
   - rawfilepath ==1.0.1
   - rawstring-qm ==0.2.3.0
   - raw-strings-qq ==1.1
-  - rcu ==0.2.5
+  - rcu ==0.2.6
   - rdtsc ==1.3.0.1
   - re2 ==0.3
   - readable ==0.3.1
···
   - repa-io ==3.4.1.2
   - replace-attoparsec ==1.4.5.0
   - replace-megaparsec ==1.4.5.0
-  - repline ==0.4.0.0
+  - repline ==0.4.2.0
   - req ==3.10.0
   - req-conduit ==1.0.1
   - require ==0.4.11
···
   - resource-pool ==0.2.3.2
   - resourcet ==1.2.5
   - result ==0.2.6.0
-  - retry ==0.9.2.0
+  - retry ==0.9.2.1
   - rev-state ==0.1.2
   - rfc1751 ==0.1.3
   - rfc5051 ==0.2
···
   - RSA ==2.4.1
   - rss-conduit ==0.6.0.1
   - runmemo ==1.0.0.1
-  - rvar ==0.3.0.0
+  - rvar ==0.3.0.1
   - s3-signer ==0.5.0.0
   - safe ==0.3.19
   - safe-coloured-text ==0.1.0.0
   - safe-coloured-text-terminfo ==0.0.0.0
   - safecopy ==0.10.4.2
   - safe-decimal ==0.2.1.0
-  - safe-exceptions ==0.1.7.2
+  - safe-exceptions ==0.1.7.3
   - safe-exceptions-checked ==0.1.0
   - safe-foldable ==0.1.0.0
   - safeio ==0.0.5.0
···
   - servant-multipart ==0.12.1
   - servant-multipart-api ==0.12.1
   - servant-multipart-client ==0.12.1
-  - servant-openapi3 ==2.0.1.4
+  - servant-openapi3 ==2.0.1.5
   - servant-pipes ==0.15.3
   - servant-rawm ==1.0.0.0
   - servant-ruby ==0.9.0.0
···
   - silently ==1.2.5.2
   - simple-affine-space ==0.1.1
   - simple-cabal ==0.1.3
-  - simple-cmd ==0.2.5
+  - simple-cmd ==0.2.6
   - simple-cmd-args ==0.1.7
   - simple-log ==0.9.12
   - simple-media-timestamp ==0.2.0.0
···
   - skein ==1.0.9.4
   - skews ==0.1.0.3
   - skip-var ==0.1.1.0
-  - skylighting ==0.12.3
-  - skylighting-core ==0.12.3
+  - skylighting ==0.12.3.1
+  - skylighting-core ==0.12.3.1
   - slack-progressbar ==0.1.0.1
   - slave-thread ==1.1.0.1
   - slist ==0.2.0.0
···
   - srt-attoparsec ==0.1.0.0
   - srt-dhall ==0.1.0.0
   - srt-formatting ==0.1.0.0
-  - stache ==2.3.1
+  - stache ==2.3.2
   - stack-all ==0.4.0.1
   - stack-clean-old ==0.4.6
   - stackcollapse-ghc ==0.0.1.4
···
   - Stream ==0.4.7.2
   - streaming ==0.2.3.1
   - streaming-attoparsec ==1.0.0.1
-  - streaming-bytestring ==0.2.1
+  - streaming-bytestring ==0.2.2
   - streaming-cassava ==0.2.0.0
   - streaming-commons ==0.2.2.4
   - streamly ==0.8.1.1
   - streamly-bytestring ==0.1.4
   - streams ==3.3
-  - streamt ==0.5.0.0
+  - streamt ==0.5.0.1
   - strict ==0.4.0.1
   - strict-concurrency ==0.2.4.3
   - strict-list ==0.1.7
···
   - string-combinators ==0.6.0.5
   - string-conv ==0.2.0
   - string-conversions ==0.4.0.1
-  - string-interpolate ==0.3.1.1
+  - string-interpolate ==0.3.1.2
   - string-qq ==0.0.4
   - string-random ==0.1.4.2
   - stringsearch ==0.3.6.6
···
   - tasty-ant-xml ==1.1.8
   - tasty-bench ==0.3.1
   - tasty-dejafu ==2.0.0.8
-  - tasty-discover ==4.2.2
+  - tasty-discover ==4.2.4
   - tasty-expected-failure ==0.12.3
   - tasty-fail-fast ==0.0.3
   - tasty-focus ==1.0.1
   - tasty-golden ==2.3.5
   - tasty-hedgehog ==1.1.0.0
   - tasty-hslua ==1.0.2
-  - tasty-hspec ==1.2
+  - tasty-hspec ==1.2.0.1
   - tasty-html ==0.4.1.4
   - tasty-hunit ==0.10.0.3
   - tasty-hunit-compat ==0.2.0.1
-  - tasty-inspection-testing ==0.1
+  - tasty-inspection-testing ==0.1.0.1
   - tasty-kat ==0.0.3
   - tasty-leancheck ==0.0.2
   - tasty-lua ==1.0.2
···
   - th-lift ==0.8.2
   - th-lift-instances ==0.1.19
   - th-nowq ==0.1.0.5
-  - th-orphans ==0.13.12
+  - th-orphans ==0.13.13
   - th-printf ==0.7
   - thread-hierarchy ==0.3.0.2
   - thread-local-storage ==0.2
···
   - uglymemo ==0.1.0.1
   - unagi-chan ==0.4.1.4
   - unbounded-delays ==0.1.1.1
-  - unbound-generics ==0.4.1
+  - unbound-generics ==0.4.2
   - unboxed-ref ==0.4.0.0
   - unboxing-vector ==0.2.0.0
   - uncaught-exception ==0.1.0
···
   - unexceptionalio ==0.5.1
   - unexceptionalio-trans ==0.5.1
   - unicode ==0.0.1.1
-  - unicode-collation ==0.1.3.1
+  - unicode-collation ==0.1.3.2
   - unicode-data ==0.3.0
   - unicode-show ==0.1.1.1
   - unicode-transforms ==0.4.0.1
···
   - xmonad ==0.17.0
   - xmonad-contrib ==0.17.0
   - xmonad-extras ==0.17.0
+  - xor ==0.0.1.1
   - xss-sanitize ==0.3.7
   - xxhash-ffi ==0.2.0.0
   - yaml ==0.11.8.0
···
   - yesod-gitrev ==0.2.2
   - yesod-markdown ==0.12.6.13
   - yesod-newsfeed ==1.7.0.0
-  - yesod-page-cursor ==2.0.0.10
+  - yesod-page-cursor ==2.0.1.0
   - yesod-paginator ==1.1.2.1
   - yesod-persistent ==1.6.0.8
   - yesod-recaptcha2 ==1.0.2

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

···
  - GrowlNotify
  - Gtk2hsGenerics
  - GtkGLTV
+ - GuiHaskell
  - GuiTV
  - H
  - HAppS-Data
···
  - HLearn-distributions
  - HNM
  - HPhone
+ - HPlot
  - HPong
  - HROOT
  - HROOT-core
···
  - blosum
  - bloxorz
  - blubber
+ - bluetile
  - blunt
  - bno055-haskell
  - bogre-banana
···
  - compdata-automata
  - compdata-dags
  - compdata-param
- - compdoc
  - compdoc-dhall-decoder
  - complexity
- - composite-aeson-cofree-list
- - composite-aeson-path
- - composite-aeson-refined
- - composite-aeson-throw
- - composite-aeson-writeonly
- - composite-swagger
  - compstrat
  - comptrans
  - computational-algebra
···
  - diagrams-pandoc
  - diagrams-reflex
  - diagrams-wx
+ - dialog
  - difference-monoid
  - differential
  - digestive-functors-hsp
···
  - doc-review
  - dom-parser
  - dormouse-client
+ - dotparse
  - doublezip
  - dovetail
  - dovetail-aeson
···
  - ghc-tags-plugin
  - ghci-pretty
  - ghcjs-dom-hello
+ - ghcjs-dom-webkit
  - ghcjs-fetch
  - ghcjs-hplay
  - ghcprofview
···
  - gitlib-cross
  - gitlib-s3
  - givegif
+ - gladexml-accessor
  - glazier
  - glazier-pipes
  - glazier-react
···
  - gstorable
  - gtfs
  - gtk-serialized-event
+ - gtk2hs-cast-glade
  - gtk2hs-cast-gnomevfs
  - gtk2hs-cast-gtk
  - gtk2hs-cast-gtkglext
···
  - hbb
  - hbcd
  - hbf
+ - hbro
+ - hbro-contrib
  - hcg-minus-cairo
  - hcheat
  - hcheckers
···
  - hstar
  - hstox
  - hstradeking
+ - hstzaar
  - hsubconvert
  - hswip
  - hsx-jmacro
···
  - lambdaFeed
  - lambdaLit
  - lambdabot-zulip
+ - lambdacat
  - lambdacms-media
  - lambdacube
  - lambdacube-bullet
···
  - list-witnesses
  - listenbrainz-client
  - liszt
- - little-rio_1_0_0
+ - little-rio_1_0_1
  - live-sequencer
  - llvm
  - llvm-analysis
···
  - migrant-postgresql-simple
  - migrant-sqlite-simple
  - minecraft-data
+ - minesweeper
  - mini-egison
  - minilight-lua
  - minimung
···
  - nyan
  - nyan-interpolation
  - nyan-interpolation-simple
+ - nymphaea
  - oanda-rest-api
  - oath
  - obd
···
  - peparser
  - perdure
  - perf-analysis
+ - perf_0_10_0
  - perfecthash
  - periodic-client
  - periodic-client-exe
···
  - prolude
  - prometheus-effect
  - propane
+ - proplang
  - prosidyc
  - proteome
  - proto-lens-descriptors
···
  - protobuf-native
  - protocol-buffers-descriptor-fork
  - proton
+ - psc-ide
  - psql
  - ptera
  - ptera-core
···
  - puppetresources
  - pure-cdb
  - pure-priority-queue-tests
- - purenix
  - purescript-iso
+ - purescript-tsd-gen
  - pursuit-client
  - push-notify
  - push-notify-apn
···
  - reduce-equations
  - refh
  - reflex-animation
- - reflex-backend-socket
  - reflex-backend-wai
  - reflex-dom-colonnade
  - reflex-dynamic-containers
···
  - shapefile
  - shapely-data
  - shapes-demo
+ - sheets
  - shelduck
  - shellmate-extras
  - shine-varying
  - short-vec-lens
+ - showdown
  - shpider
  - shuffle
  - si-clock
···
  - yuuko
  - z85
  - zasni-gerna
+ - zephyr
  - zephyr-copilot
  - zeromq3-conduit
  - zeromq3-haskell

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

···
      }:
      mkDerivation {
        pname = "AspectAG";
-       version = "0.7.0.0";
-       sha256 = "1w5zfx5vgvkys84vdrdd3rv39ly25wbn9izlir19irniqsbf6z6v";
+       version = "0.7.0.1";
+       sha256 = "00cprqks3lany16zbmm250p1qms4hampwck44m688z2xk388gakn";
+       revision = "2";
+       editedCabalFile = "0hlgkm8ph28x1dkjprjjajdwk8y7ghsb9i6vr5jbr046vzrziblp";
        libraryHaskellDepends = [
          base containers ghc-prim loch-th mtl poly-rec requirements
          template-haskell
···
   "BlogLiterately-diagrams" = callPackage
     ({ mkDerivation, base, BlogLiterately, containers, diagrams-builder
      , diagrams-lib, diagrams-rasterific, directory, filepath
-     , JuicyPixels, pandoc, safe, split
+     , JuicyPixels, pandoc, safe, split, text
      }:
      mkDerivation {
        pname = "BlogLiterately-diagrams";
-       version = "0.2.1";
-       sha256 = "0ki56kc51p1b9zkvs91adgj140pchnbdwfmhsvb4qzzf9sz90kjb";
+       version = "0.3";
+       sha256 = "0l9h8anjbvm49fg1niy4sg8cxr3fl1kvmqfb1lfdi5vypdgqqwms";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          base BlogLiterately containers diagrams-builder diagrams-lib
          diagrams-rasterific directory filepath JuicyPixels pandoc safe
-         split
+         split text
        ];
        executableHaskellDepends = [ base BlogLiterately ];
        description = "Include images in blog posts with inline diagrams code";
···
      }:
      mkDerivation {
        pname = "Chart";
-       version = "1.9.3";
-       sha256 = "0p69kq5kh40gd4y8wqabypmw67pqh42vaaw64zv9sf8j075g85ry";
-       revision = "3";
-       editedCabalFile = "0lgfq5cmhx0q9wqnplw1xr5ql88jjffzc0i72v1lfiqsp9w3lppf";
+       version = "1.9.4";
+       sha256 = "0ylxin419s35xq1j4hcnylrch3m252wqdkfjp5b323qhv4a8y1im";
        libraryHaskellDepends = [
          array base colour data-default-class lens mtl old-locale
          operational time vector
···
      }:
      mkDerivation {
        pname = "Chart-diagrams";
-       version = "1.9.3";
-       sha256 = "075yzq50jpakgq6lb3anr660jydm68ry0di33icdacbdymq8avwn";
-       revision = "4";
-       editedCabalFile = "0qsgg78plwr7wabc680x8qshv137vhplqqvs4730xb62z45r6kjl";
+       version = "1.9.4";
+       sha256 = "0rkkmyfszzpnbw1s6lqg2fadkbvgqrxrp1rvj9v45ihzwnpbg758";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base blaze-markup bytestring Chart colour containers
···
        ];
        description = "A graphical REPL and development environment for Haskell";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "GuiTV" = callPackage
···
        executablePkgconfigDepends = [ plplotd-gnome2 ];
        description = "A minimal monadic PLplot interface for Haskell";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {plplotd-gnome2 = null;};
 
   "HPong" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "ListLike_4_7_7" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers, deepseq
+     , dlist, fmlist, HUnit, QuickCheck, random, text, utf8-string
+     , vector
+     }:
+     mkDerivation {
+       pname = "ListLike";
+       version = "4.7.7";
+       sha256 = "0h4yfzrf3ljvzf3x75nx791bpxlmdi7f42ff0xyfk8d498iws08a";
+       libraryHaskellDepends = [
+         array base bytestring containers deepseq dlist fmlist text
+         utf8-string vector
+       ];
+       testHaskellDepends = [
+         array base bytestring containers dlist fmlist HUnit QuickCheck
+         random text utf8-string vector
+       ];
+       description = "Generalized support for list-like structures";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ListT" = callPackage
     ({ mkDerivation, base, smallcheck, tasty, tasty-smallcheck
      , transformers, util
···
        pname = "MissingH";
        version = "1.5.0.1";
        sha256 = "0c92fdv32nq51kfdizi3lpxmnvscsgk6marfzaycd7k05aka8byb";
+       revision = "1";
+       editedCabalFile = "18jigc9mis823dhlx14yd0r59618jwqw93hsdyzmdrgfaigd6qpn";
        libraryHaskellDepends = [
          array base containers directory filepath hslogger mtl network
          network-bsd old-locale old-time parsec process regex-compat time
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "SVGFonts_1_7_0_1" = callPackage
-    ({ mkDerivation, attoparsec, base, blaze-markup, blaze-svg
-     , bytestring, cereal, cereal-vector, containers, data-default-class
-     , diagrams-core, diagrams-lib, directory, parsec, split, text
-     , vector, xml
-     }:
-     mkDerivation {
-       pname = "SVGFonts";
-       version = "1.7.0.1";
-       sha256 = "06vnpkkr19s9b1wjp7l2w29vr7fsghcrffd2knlxvdhjacrfpc9h";
-       revision = "2";
-       editedCabalFile = "0q731cyrqq1csbid9nxh2bj6rf8yss017lz9j9zk22bw3bymzb0s";
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         attoparsec base blaze-markup blaze-svg bytestring cereal
-         cereal-vector containers data-default-class diagrams-core
-         diagrams-lib directory parsec split text vector xml
-       ];
-       description = "Fonts from the SVG-Font format";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
   "SVGFonts" = callPackage
     ({ mkDerivation, attoparsec, base, blaze-markup, blaze-svg
      , bytestring, cereal, cereal-vector, containers, data-default-class
···
      }) {};
 
   "TLT" = callPackage
-    ({ mkDerivation, ansi-terminal, base, either, free, HUnit, mtl
-     , resourcet, STMonadTrans, symbol, transformers
+    ({ mkDerivation, ansi-terminal, base, free, mtl, resourcet
+     , STMonadTrans, transformers
      }:
      mkDerivation {
        pname = "TLT";
-       version = "0.1.0.1";
-       sha256 = "1b91ax19dfgi50rlkfvjjywzz6w998d5jsq5c0yz620rcdl7jrki";
+       version = "0.3.0.0";
+       sha256 = "0pl9ga3vr9yj4f4k2pisq8yarhbsbfvj9q3n24f0db8csq363yc5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         ansi-terminal base either free HUnit mtl resourcet STMonadTrans
-         symbol transformers
+         ansi-terminal base free mtl resourcet STMonadTrans transformers
        ];
        executableHaskellDepends = [
-         ansi-terminal base either free HUnit mtl resourcet STMonadTrans
-         symbol transformers
+         ansi-terminal base free mtl resourcet STMonadTrans transformers
        ];
        testHaskellDepends = [
-         ansi-terminal base either free HUnit mtl resourcet STMonadTrans
-         symbol transformers
+         ansi-terminal base free mtl resourcet STMonadTrans transformers
        ];
        description = "Testing in monads and transformers without explicit specs";
        license = lib.licenses.lgpl3Only;
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
+     }) {};
+
+  "TastyTLT" = callPackage
+    ({ mkDerivation, ansi-terminal, base, free, mtl, resourcet
+     , STMonadTrans, tagged, tasty, TLT, transformers
+     }:
+     mkDerivation {
+       pname = "TastyTLT";
+       version = "0.0.0.0";
+       sha256 = "0xcwsgn5d8gsingxw6nq12gibxc3gn99bqr2pzbflysyygwf4gz1";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         ansi-terminal base free mtl resourcet STMonadTrans tagged tasty TLT
+         transformers
+       ];
+       executableHaskellDepends = [
+         ansi-terminal base free mtl resourcet STMonadTrans tagged tasty TLT
+         transformers
+       ];
+       testHaskellDepends = [
+         ansi-terminal base free mtl resourcet STMonadTrans tagged tasty TLT
+         transformers
+       ];
+       description = "Run TLT tests from Tasty";
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "Taxonomy" = callPackage
···
      }:
      mkDerivation {
        pname = "ad";
-       version = "4.5";
-       sha256 = "1v37ckxcav3aicv4vv7y77mmvinfwd8mxzcnm672mmxq1d29vpsc";
-       libraryHaskellDepends = [
-         adjunctions array base comonad containers data-reify erf free nats
-         reflection semigroups transformers
-       ];
-       benchmarkHaskellDepends = [ base criterion erf ];
-       description = "Automatic Differentiation";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "ad_4_5_1" = callPackage
-    ({ mkDerivation, adjunctions, array, base, comonad, containers
-     , criterion, data-reify, erf, free, nats, reflection, semigroups
-     , transformers
-     }:
-     mkDerivation {
-       pname = "ad";
        version = "4.5.1";
        sha256 = "08hx8ww93x2hg6qxfypd9hyqqcp7c70w17i6hs03qmk4i433h2b9";
        libraryHaskellDepends = [
···
        benchmarkHaskellDepends = [ base criterion erf ];
        description = "Automatic Differentiation";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ad-delcont" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "aeson-commit_1_5" = callPackage
+    ({ mkDerivation, aeson, aeson-qq, base, hspec, text, transformers
+     }:
+     mkDerivation {
+       pname = "aeson-commit";
+       version = "1.5";
+       sha256 = "1xblprnxnx7q1mf7qp47ilkd6i8s36ixdlb75dqr297izn0sxp39";
+       libraryHaskellDepends = [ aeson base text transformers ];
+       testHaskellDepends = [ aeson aeson-qq base hspec text ];
+       description = "Parse Aeson data with commitment";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "aeson-compat" = callPackage
     ({ mkDerivation, aeson, attoparsec, attoparsec-iso8601, base
      , base-compat, base-orphans, bytestring, containers, exceptions
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "aeson-diff_1_1_0_13" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, Cabal, cabal-doctest
+     , directory, doctest, edit-distance-vector, filepath, Glob
+     , optparse-applicative, QuickCheck, scientific, text, vector, yaml
+     }:
+     mkDerivation {
+       pname = "aeson-diff";
+       version = "1.1.0.13";
+       sha256 = "0sd13q0nj0k1sam5xfj6dcjcki18f375sa69hm6i4xc6snfhn3cb";
+       isLibrary = true;
+       isExecutable = true;
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         aeson base bytestring edit-distance-vector scientific text vector
+       ];
+       executableHaskellDepends = [
+         aeson base bytestring optparse-applicative yaml
+       ];
+       testHaskellDepends = [
+         aeson base bytestring directory doctest filepath Glob QuickCheck
+         vector
+       ];
+       description = "Extract and apply patches to JSON documents";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "aeson-diff-generic" = callPackage
     ({ mkDerivation, aeson, aeson-diff, base, base-compat, bytestring
      , containers, dlist, hashable, lens, scientific, tagged
···
      }:
      mkDerivation {
        pname = "aura";
-       version = "3.2.8";
-       sha256 = "1frvim9asp0849g7f5c1hcjkr82c9w27im479vmk6n4zzssvzach";
+       version = "3.2.9";
+       sha256 = "0hw96090gb4rf6n6mf9mn2y50sjgcvny2ipdd9720an33nhpsd3m";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "bloodhound";
-       version = "0.19.1.0";
-       sha256 = "0vflzwc90w69c78xpjldvgywl1ykn73wzq06501lnl6bwb07ahs0";
+       version = "0.20.0.0";
+       sha256 = "175w602jvjrf2j1jaygj4spznyq66ga5mkbpfi6nzrygv609dbrh";
        libraryHaskellDepends = [
          aeson base blaze-builder bytestring containers exceptions hashable
          http-client http-types mtl network-uri scientific semigroups semver
···
        executablePkgconfigDepends = [ gtk2 ];
        description = "full-featured tiling for the GNOME desktop environment";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) gtk2;};
 
   "bluetileutils" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "brick_0_69" = callPackage
+    ({ mkDerivation, base, bytestring, config-ini, containers
+     , contravariant, data-clist, deepseq, directory, dlist, exceptions
+     , filepath, microlens, microlens-mtl, microlens-th, QuickCheck, stm
+     , template-haskell, text, text-zipper, transformers, unix, vector
+     , vty, word-wrap
+     }:
+     mkDerivation {
+       pname = "brick";
+       version = "0.69";
+       sha256 = "1q963gpcjcrnsyrypkb238ay8lbkq8745pxkanmhy4m40gvk5j94";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring config-ini containers contravariant data-clist
+         deepseq directory dlist exceptions filepath microlens microlens-mtl
+         microlens-th stm template-haskell text text-zipper transformers
+         unix vector vty word-wrap
+       ];
+       testHaskellDepends = [
+         base containers microlens QuickCheck vector
+       ];
+       description = "A declarative terminal user interface library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "brick-dropdownmenu" = callPackage
     ({ mkDerivation, base, brick, containers, microlens, microlens-ghc
      , microlens-th, pointedlist, vector, vty
···
      }:
      mkDerivation {
        pname = "buffer-builder-aeson";
-       version = "0.2.0.4";
-       sha256 = "0kjwahpx35mabmwnwfi669p1gcr43zas2f5wpaxn98p45gjpp93s";
-       revision = "1";
-       editedCabalFile = "112b8ir16x2dla4vm6yrdjxsi6csi8wl0193iykrvmssrybpqr89";
+       version = "0.2.0.5";
+       sha256 = "19drq1rqg06czl9aswv432yl9kkdzgkxyzfy526kzy22ffpm4asr";
        libraryHaskellDepends = [
          aeson base buffer-builder bytestring integer-gmp scientific
          unordered-containers vector
···
      }:
      mkDerivation {
        pname = "bytestring-conversion";
-       version = "0.3.1";
-       sha256 = "1y2fhwz632sp7n0iw87lz2g8vks4jgxz2kw99kysgivxfd4fmdqk";
-       revision = "2";
-       editedCabalFile = "1x8c42cfzb6fdvgkxxdxcpdf16csimlzsgahb1axnplmr6b3ba63";
-       libraryHaskellDepends = [
-         attoparsec base bytestring case-insensitive double-conversion text
-       ];
-       testHaskellDepends = [
-         base bytestring QuickCheck tasty tasty-quickcheck
-       ];
-       benchmarkHaskellDepends = [
-         base bytestring criterion text transformers
-       ];
-       description = "Type-classes to convert values to and from ByteString";
-       license = lib.licenses.mpl20;
-     }) {};
-
-  "bytestring-conversion_0_3_2" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, case-insensitive
-     , criterion, double-conversion, QuickCheck, tasty, tasty-quickcheck
-     , text, transformers
-     }:
-     mkDerivation {
-       pname = "bytestring-conversion";
        version = "0.3.2";
        sha256 = "0ls1jqf4r2hk0mcxmlviw6vgs0cn1db99w2fggsg6x39pi31rk8c";
        libraryHaskellDepends = [
···
        ];
        description = "Type-classes to convert values to and from ByteString";
        license = lib.licenses.mpl20;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "bytestring-csv" = callPackage
···
        pname = "cabal-doctest";
        version = "1.0.9";
        sha256 = "0wxs0xkspc80h0g8ks792lrzldxvcnhc9rja1j0k678ijs20hmjm";
+       revision = "1";
+       editedCabalFile = "0dw9h3zqivzzisjz0g3ccb10fwz858dhvy6hvwm5i1sj80wm8imd";
        libraryHaskellDepends = [ base Cabal directory filepath ];
        description = "A Setup.hs helper for running doctests";
        license = lib.licenses.bsd3;
···
        pname = "cabal-info";
        version = "0.2.1";
        sha256 = "1gf4f80964l9mj53rn0anciz6p0035lrcc0lxbnh5dgh3iiap14l";
+       revision = "1";
+       editedCabalFile = "1cmwk131swxkzc9d7i2q4y833wi5vfppnw6178w5wmnxsjz1vgkk";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "cabal2nix";
        version = "2.18.0";
        sha256 = "11hzic1l7amd2hwqwgfmy2r855z9w0m2rvvx7r52x347q0nn142b";
+       revision = "1";
+       editedCabalFile = "0j682816qdxaqm56bqjigjg0c0nl4jf68fg01f73xhbr486lzvga";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "cborg";
        version = "0.2.7.0";
        sha256 = "076656vq2qabhdnwzifc5gsj20vwh69vhy19dh0qa1f2lqxrzfvq";
+       revision = "1";
+       editedCabalFile = "02n2d8i0yc5qk77r5b63hqvd79ygcdk1pnf445nmp4bfsjvv8jyj";
        libraryHaskellDepends = [
          array base bytestring containers deepseq ghc-bignum ghc-prim half
          primitive text
···
        pname = "cereal";
        version = "0.5.8.2";
        sha256 = "0kvnlm22qdmb7g2jz7imsvh799q4nvms1ni0cbba5vigp5ai64hp";
+       revision = "1";
+       editedCabalFile = "16hdvwa1qpwicn512mnsksi4zdnwmqnn9sdga4iy3jza4rj9lzgy";
        libraryHaskellDepends = [
          array base bytestring containers ghc-prim
        ];
···
      }:
      mkDerivation {
        pname = "cleff";
-       version = "0.3.2.0";
-       sha256 = "0ayvywkd88p5frr41405jz82zya31jslbzxzln2x01maibjyyf2h";
+       version = "0.3.3.0";
+       sha256 = "0fnpk28nhafypp7p1ay1760sin9hh06dz23r68gmm93i879ayl9b";
        libraryHaskellDepends = [
          atomic-primops base containers exceptions microlens monad-control
          primitive template-haskell th-abstraction transformers-base
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "comfort-array_0_5_1_1" = callPackage
+    ({ mkDerivation, base, ChasingBottoms, containers, deepseq
+     , doctest-exitcode-stdio, doctest-lib, guarded-allocation
+     , non-empty, prelude-compat, primitive, QuickCheck, semigroups
+     , storable-record, storablevector, tagged, transformers, utility-ht
+     }:
+     mkDerivation {
+       pname = "comfort-array";
+       version = "0.5.1.1";
+       sha256 = "07rajrpp495g17naywybkrydd67ixiav5g8rayavwabvyrybnmgy";
+       libraryHaskellDepends = [
+         base containers deepseq guarded-allocation non-empty prelude-compat
+         primitive QuickCheck semigroups storable-record storablevector
+         tagged transformers utility-ht
+       ];
+       testHaskellDepends = [
+         base ChasingBottoms containers doctest-exitcode-stdio doctest-lib
+         QuickCheck tagged
+       ];
+       description = "Arrays where the index type is a function of the shape type";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "comfort-array-shape" = callPackage
     ({ mkDerivation, base, ChasingBottoms, comfort-array, containers
      , doctest-exitcode-stdio, doctest-lib, fixed-length, non-empty
···
        description = "Parse a Pandoc to a composite value";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "compdoc-dhall-decoder" = callPackage
···
      }:
      mkDerivation {
        pname = "composite-aeson";
-       version = "0.7.5.0";
-       sha256 = "0cxsjk3zwkhwb3bgq2ji1mvvapcwxzg333z7zfdv9ba3xgw3ngq0";
+       version = "0.8.0.0";
+       sha256 = "0j74nz3ih5hyl8ljld9m9nd1zip9ibpm55bavgzpp2wknxsrkwzg";
        libraryHaskellDepends = [
          aeson aeson-better-errors base composite-base containers
          contravariant generic-deriving hashable lens mmorph mtl profunctors
···
        ];
        description = "JSON for Vinyl records";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "composite-aeson-cofree-list" = callPackage
···
        ];
        description = "Print a Cofree [] as a JSON value";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "composite-aeson-path" = callPackage
     ({ mkDerivation, base, composite-aeson, path }:
      mkDerivation {
        pname = "composite-aeson-path";
-       version = "0.7.5.0";
-       sha256 = "0b013jpdansx6fmxq1sf33975vvnajhs870a92i1lwd2k2wsj600";
+       version = "0.8.0.0";
+       sha256 = "05n7kcgxgwc06ja3yhspmidi5i4a5j5xj8ivlkh7g5plm4crrvlp";
        libraryHaskellDepends = [ base composite-aeson path ];
        description = "Formatting data for the path library";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "composite-aeson-refined" = callPackage
···
      }:
      mkDerivation {
        pname = "composite-aeson-refined";
-       version = "0.7.5.0";
-       sha256 = "05iakig5cqy4zkfl1kvjf9ck7gw5m7bdlcwwnv0kc5znyj66fbif";
+       version = "0.8.0.0";
+       sha256 = "109fd2y7c0jq620rdyghkk6f4ikx8ajxxw7zia6dq3zz5rkpqj16";
        libraryHaskellDepends = [
          aeson-better-errors base composite-aeson mtl refined
        ];
        description = "composite-aeson support for Refined from the refined package";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "composite-aeson-throw" = callPackage
···
        ];
        description = "MonadThrow behaviour for composite-aeson";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "composite-aeson-writeonly" = callPackage
···
        ];
        description = "WriteOnly indicators for composite-aeson";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "composite-base" = callPackage
···
      }:
      mkDerivation {
        pname = "composite-base";
-       version = "0.7.5.0";
-       sha256 = "12qaxm20kn2cf6d19xargxfg8jrvb5ix0glm3ba0641plxlssqrq";
+       version = "0.8.0.0";
+       sha256 = "1zl2jxgsa55zkzrji4cwfrf38ijm8qby66rk7wxl3nri69914d0i";
        libraryHaskellDepends = [
          base deepseq exceptions lens monad-control mtl profunctors
          template-haskell text transformers transformers-base unliftio-core
···
     ({ mkDerivation, base, binary, composite-base }:
      mkDerivation {
        pname = "composite-binary";
-       version = "0.7.5.0";
-       sha256 = "0pvmmb4m6ysgj468khmggvsgs5c0hjmcn46s0wam353abdw89i7m";
+       version = "0.8.0.0";
+       sha256 = "1qq8jslsr58kpvrbhhv27x5vn564y8fiq9djdvlqri10012v1bbm";
        libraryHaskellDepends = [ base binary composite-base ];
        description = "Orphan binary instances";
        license = lib.licenses.bsd3;
···
        ];
        description = "Csv parsing functionality for composite";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "composite-dhall" = callPackage
···
        ];
        description = "Dhall instances for composite records";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "composite-ekg" = callPackage
···
        ];
        description = "EKG Metrics for Vinyl records";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "composite-hashable" = callPackage
     ({ mkDerivation, base, composite-base, hashable }:
      mkDerivation {
        pname = "composite-hashable";
-       version = "0.7.5.0";
-       sha256 = "1s4bnlr08fb1sszys1frkxrjrsi61jpcldh126mcwzlf6wlvqvjn";
+       version = "0.8.0.0";
+       sha256 = "12rb0iaxlx1hci14pa98maw0pjghrnirxfn5z1mrn139938wdha6";
        libraryHaskellDepends = [ base composite-base hashable ];
        description = "Orphan hashable instances";
        license = lib.licenses.bsd3;
···
        pname = "composite-ix";
        version = "0.0.1.0";
        sha256 = "0kyy3fm1z9w2mwrhwn3gz5hpvykzsnij0rrsqi2fh3gd1dsxgc6c";
+       revision = "1";
+       editedCabalFile = "1ngh5b814hp64mh91h9h7qw29yz3ir7nli3nz6klpimnnddr6871";
        libraryHaskellDepends = [
          base composite-base containers lens nonempty-containers vector
          vinyl
···
        libraryHaskellDepends = [ base composite-base lens vinyl ];
        description = "Extra lens functions for composite";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "composite-opaleye" = callPackage
···
      }:
      mkDerivation {
        pname = "composite-opaleye";
-       version = "0.7.5.0";
-       sha256 = "1qmlhn1lj2l5qpykxdg23axvxwn8l2pvzvwqn261rj21qj90k093";
+       version = "0.8.0.0";
+       sha256 = "1h0xa0x038mgpmp9chycgf9bm8w4zfnsdcfzb4zxjw1hyv8csl8s";
        libraryHaskellDepends = [
          base bytestring composite-base lens opaleye postgresql-simple
          product-profunctors profunctors template-haskell text vinyl
···
      }:
      mkDerivation {
        pname = "composite-swagger";
-       version = "0.7.5.0";
-       sha256 = "1b6bcw7gq2smghp7mnkh9gymn3mh4b1xxkv97zhxjsb91wnmvyml";
+       version = "0.8.0.0";
+       sha256 = "1ikq68bnfgxa003y0q3g512h40and5l0k4qm3yb7bpbinbip9123";
        libraryHaskellDepends = [
          base composite-base insert-ordered-containers lens swagger2
          template-haskell text vinyl
···
        ];
        description = "Swagger for Vinyl records";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "composite-tuple" = callPackage
···
      }:
      mkDerivation {
        pname = "concurrent-output";
-       version = "1.10.15";
-       sha256 = "1n02ck0zci6y2w8dm03j2qypgbc176skapixrmnxrp9dnbwcprc0";
+       version = "1.10.16";
+       sha256 = "0l4k0bkq5bddqraf14g3ngyzwff17f3ngg4axlilcl3zf3c4bamh";
        libraryHaskellDepends = [
          ansi-terminal async base directory exceptions process stm
          terminal-size text transformers unix
···
        license = lib.licenses.mit;
      }) {};
 
+  "conduit-concurrent-map_0_1_3" = callPackage
+    ({ mkDerivation, base, conduit, containers, hspec, HUnit, mtl
+     , QuickCheck, resourcet, say, unliftio, unliftio-core, vector
+     }:
+     mkDerivation {
+       pname = "conduit-concurrent-map";
+       version = "0.1.3";
+       sha256 = "0mpbklyfqdc1wzx5z4dy2x2y5zi8bb7p83q04csybj5c5f4136yq";
+       libraryHaskellDepends = [
+         base conduit containers mtl resourcet unliftio unliftio-core vector
+       ];
+       testHaskellDepends = [ base conduit hspec HUnit QuickCheck say ];
+       description = "Concurrent, order-preserving mapping Conduit";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "conduit-connection" = callPackage
     ({ mkDerivation, base, bytestring, conduit, connection, HUnit
      , network, resourcet, test-framework, test-framework-hunit
···
      }:
      mkDerivation {
        pname = "configurator-pg";
-       version = "0.2.5";
-       sha256 = "1wmdg9zxfz8vhhsq5rraynhrhqc8fjrdhfrky2mfajzbp8dpaqsm";
+       version = "0.2.6";
+       sha256 = "0zlj733fyw0iiczjzzp9mlgywd175crp853wyp9b1gq1m2j6vxnm";
        libraryHaskellDepends = [
          base containers megaparsec protolude scientific text
        ];
···
      }:
      mkDerivation {
        pname = "constraints";
-       version = "0.13.3";
-       sha256 = "0jhdix263zxsiki0pmdpyrg7vcfxx2x9w7pjiypva3wsr9agdjzr";
-       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_4" = callPackage
-    ({ mkDerivation, base, binary, deepseq, ghc-prim, hashable, hspec
-     , hspec-discover, mtl, transformers, transformers-compat
-     , type-equality
-     }:
-     mkDerivation {
-       pname = "constraints";
        version = "0.13.4";
        sha256 = "0d248szyp70k1qlivsimk0j5vz9hdx1alhismry5v35qyinr91j1";
        libraryHaskellDepends = [
···
        testToolDepends = [ hspec-discover ];
        description = "Constraint manipulation";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "constraints-deriving" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "convertible_1_1_1_1" = callPackage
+    ({ mkDerivation, base, bytestring, containers, mtl, old-time
+     , QuickCheck, text, time
+     }:
+     mkDerivation {
+       pname = "convertible";
+       version = "1.1.1.1";
+       sha256 = "1vwc6h1z88xkw4bq3js8x9x86jnk3amdskyksca77p0kwiqbs7lr";
+       libraryHaskellDepends = [
+         base bytestring containers mtl old-time text time
+       ];
+       testHaskellDepends = [ base containers old-time QuickCheck time ];
+       description = "Typeclasses and instances for converting between types";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "convertible-ascii" = callPackage
     ({ mkDerivation, ascii, base, base-unicode-symbols, blaze-builder
      , bytestring, convertible-text, failure, text
···
      }:
      mkDerivation {
        pname = "core-telemetry";
-       version = "0.2.0.1";
-       sha256 = "1l302ncnv1w3p84v16acxvkyr6kvrr6385i7qdrmqi0a8yfwizb0";
+       version = "0.2.2.0";
+       sha256 = "1l2h14x375v5dfamjbmknx28kyi18l2anv46887807bd3yz84552";
        libraryHaskellDepends = [
          async base bytestring chronologique core-data core-program
          core-text exceptions http-streams io-streams mtl network-info
···
      }:
      mkDerivation {
        pname = "core-webserver-warp";
-       version = "0.1.1.4";
-       sha256 = "03jsb8x41v62l065lkdy2zr6cwk80l84ai6lnbwxf1472f5p7619";
+       version = "0.1.1.5";
+       sha256 = "0i8w0fga1x2hm3hhacyi7xmi86dhglw78786wijghwpqlfgayy9w";
        libraryHaskellDepends = [
          async base bytestring core-data core-program core-telemetry
          core-text http-types http2 mtl safe-exceptions vault wai warp
···
      }:
      mkDerivation {
        pname = "cue-sheet";
-       version = "2.0.1";
-       sha256 = "0papll3xcq2ipmya61jr71gf3zx2swmys829x5sbz7lv6abj9r3i";
-       revision = "3";
-       editedCabalFile = "1v8yvvb9sdpkg7m6z5a4sf0hcss7swb318700ap0qc79qn4ifdqb";
+       version = "2.0.2";
+       sha256 = "0n8a5m5qlz8dz03sphj9pybfjfkc0gngpmh56h6idj88frn1z947";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base bytestring containers exceptions megaparsec mtl QuickCheck
···
      }:
      mkDerivation {
        pname = "dino";
-       version = "0.1.2";
-       sha256 = "0sk7p89fmjynykk7djfn8cmmjrqyv5pml9ny2dycr1n86cnxr88x";
+       version = "0.1.3";
+       sha256 = "13p5bivvl5cicv61rnx268i4156vgxiz9cf20xfrwz4pdxffr3al";
        libraryHaskellDepends = [
          ansi-wl-pprint base containers errors exceptions hashable
          monad-loops mtl text transformers tree-view unordered-containers
···
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
+  "distribution-nixpkgs_1_7_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
+     , deepseq, directory, hspec, language-nix, lens, pretty, process
+     }:
+     mkDerivation {
+       pname = "distribution-nixpkgs";
+       version = "1.7.0";
+       sha256 = "007riyq6irmzzmf3gynaa5hpz8a4khg8wl4blyz78c59bqblpw69";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson base bytestring Cabal containers deepseq language-nix lens
+         pretty process
+       ];
+       testHaskellDepends = [
+         aeson base Cabal deepseq directory hspec language-nix lens
+       ];
+       description = "Types and functions to manipulate the Nixpkgs distribution";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ peti ];
+     }) {};
+
   "distribution-opensuse" = callPackage
     ({ mkDerivation, aeson, base, binary, bytestring, containers
      , deepseq, Diff, extra, foldl, hashable, hsemail, mtl, parsec-class
···
     ({ mkDerivation, base, containers, mtl, pretty }:
      mkDerivation {
        pname = "djinn-lib";
-       version = "0.0.1.3";
-       sha256 = "0r1kby67flpyizj117r5q0q3sj61csqxd44za5r9292hj3cacd9v";
-       revision = "1";
-       editedCabalFile = "0zz4q631wpxdm4h499j0m1kin4n1ahnwzb0x2jh6vd463i89xlbk";
+       version = "0.0.1.4";
+       sha256 = "1s4kx6h6vj0hi2v87q95jb2wpg6hgq5qiswv0lh5qhmnb367c8w8";
        libraryHaskellDepends = [ base containers mtl pretty ];
        description = "Generate Haskell code from a type. Library extracted from djinn package.";
        license = lib.licenses.bsd3;
···
        broken = true;
      }) {};
 
+  "doctest-parallel_0_2_3" = callPackage
+    ({ mkDerivation, base, base-compat, Cabal, code-page, containers
+     , deepseq, directory, exceptions, extra, filepath, ghc, ghc-paths
+     , Glob, hspec, hspec-core, hspec-discover, HUnit, mockery, pretty
+     , process, QuickCheck, random, setenv, silently, stringbuilder, syb
+     , template-haskell, transformers, unordered-containers
+     }:
+     mkDerivation {
+       pname = "doctest-parallel";
+       version = "0.2.3";
+       sha256 = "0sk1990ksqcgc13kppbh0xljakn3qsqaxi19990fixwakhzh229v";
+       libraryHaskellDepends = [
+         base base-compat Cabal code-page containers deepseq directory
+         exceptions extra filepath ghc ghc-paths Glob pretty process random
+         syb template-haskell transformers unordered-containers
+       ];
+       testHaskellDepends = [
+         base base-compat code-page containers deepseq directory exceptions
+         filepath ghc ghc-paths hspec hspec-core hspec-discover HUnit
+         mockery process QuickCheck setenv silently stringbuilder syb
+         transformers
+       ];
+       testToolDepends = [ hspec-discover ];
+       doHaddock = false;
+       description = "Test interactive Haskell examples";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "doctest-prop" = callPackage
     ({ mkDerivation, base, doctest, HUnit, QuickCheck }:
      mkDerivation {
···
        libraryHaskellDepends = [ base ];
        description = ".NET TimeSpan";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "dotparse" = callPackage
+    ({ mkDerivation, algebraic-graphs, base, bytestring, chart-svg
+     , containers, flatparse, neat-interpolation, numhask, numhask-space
+     , optics-core, process-extras, template-haskell, text, these
+     }:
+     mkDerivation {
+       pname = "dotparse";
+       version = "0.0.1";
+       sha256 = "1nwbyra3aksllxg5dymjlsy8ikd1rjj5lgfd9gs9s1sh746gakzx";
+       libraryHaskellDepends = [
+         algebraic-graphs base bytestring chart-svg containers flatparse
+         neat-interpolation numhask numhask-space optics-core process-extras
+         template-haskell text these
+       ];
+       description = "dot language parsing and printing";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "double-conversion" = callPackage
···
        pname = "ekg-core";
        version = "0.1.1.7";
        sha256 = "04nv6iwzrb63fs97ixb0amj8p6zhabg3ggbrg4nbkq7xjhmkz0a5";
-       revision = "1";
-       editedCabalFile = "17rfxsns0za7jqp3069mwp0lbd433gwb7lrnla02y7hfxbpnldf4";
+       revision = "2";
+       editedCabalFile = "05h0jz42s1d3bjcvzbp3dv5rvil4ar244mdqdvzbf60z848ppygl";
        libraryHaskellDepends = [
          base containers ghc-prim text unordered-containers
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "equivalence_0_4_0_1" = callPackage
+    ({ mkDerivation, base, containers, mtl, QuickCheck, STMonadTrans
+     , template-haskell, transformers, transformers-compat
+     }:
+     mkDerivation {
+       pname = "equivalence";
+       version = "0.4.0.1";
+       sha256 = "1pcv64dflv9kknz9smnq4a7pd8jmghi3g4kri1dw0cnb54g7rj7c";
+       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, base, bytestring, containers, directory, filepath
      , gitrev, graphviz, parsec, raw-strings-qq, tasty, tasty-hunit
···
        pname = "errors";
        version = "2.3.0";
        sha256 = "0x8znwn31qcx6kqx99wp7bc86kckfb39ncz3zxvj1s07kxlfawk7";
-       revision = "2";
-       editedCabalFile = "1x1bhmkx7zxwdfassc9ypl9d319p6f14rv6d3mjgvac7nxfbq245";
+       revision = "3";
+       editedCabalFile = "18siil7qihpjwimvidm9xqn38wmpcsnaybdkch7nmkgzn1jxl94n";
        libraryHaskellDepends = [
          base exceptions safe text transformers transformers-compat
        ];
···
      }:
      mkDerivation {
        pname = "ersatz";
-       version = "0.4.10";
-       sha256 = "1pklw9zhpxkm5yhkdlw78c2324ffk8n5pqkvicxh0x0ha852fs7y";
-       isLibrary = true;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         array attoparsec base bytestring containers data-default lens mtl
-         process semigroups streams temporary transformers
-         unordered-containers
-       ];
-       executableHaskellDepends = [
-         array base containers fail lens mtl parsec semigroups
-       ];
-       testHaskellDepends = [ array base ];
-       description = "A monad for expressing SAT or QSAT problems using observable sharing";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "ersatz_0_4_11" = callPackage
-    ({ mkDerivation, array, attoparsec, base, bytestring, containers
-     , data-default, fail, lens, mtl, parsec, process, semigroups
-     , streams, temporary, transformers, unordered-containers
-     }:
-     mkDerivation {
-       pname = "ersatz";
        version = "0.4.11";
        sha256 = "0zaw5a4za77xa1h8msg5v9hk6m215ykl3c258kgk519yvrfavyi3";
        isLibrary = true;
···
      }:
      mkDerivation {
        pname = "extensible";
-       version = "0.8.3";
-       sha256 = "1cwh7a6mipyh4a7vs1394wmmbm1ms5cs9snl5nd1mg1v455ykcmb";
+       version = "0.9";
+       sha256 = "06zmc71r4cqglkv3av38djbkakvw9zxc3901xi2h65fwxn4npvnc";
        libraryHaskellDepends = [
          aeson base bytestring cassava comonad constraints deepseq ghc-prim
          hashable incremental membership prettyprinter primitive profunctors
···
        license = lib.licenses.gpl3Only;
      }) {};
 
-  "fedora-dists_2_1_0" = callPackage
+  "fedora-dists_2_1_1" = callPackage
     ({ mkDerivation, aeson, base, cached-json-file, pdc, text }:
      mkDerivation {
        pname = "fedora-dists";
-       version = "2.1.0";
-       sha256 = "040qn1fbc3iss4p5svcsy5crpcs2x38y6ns3wf1zjx05lz40gb07";
+       version = "2.1.1";
+       sha256 = "0790akym2rrcch9jjky9v4qc6y22vg1w6ffi9nbx42zijkqmsm1f";
        libraryHaskellDepends = [ aeson base cached-json-file pdc text ];
        description = "Library for Fedora distribution versions";
        license = lib.licenses.gpl3Only;
···
        license = "unknown";
      }) {};
 
+  "fix-whitespace_0_0_8" = callPackage
+    ({ mkDerivation, base, directory, extra, filepath, filepattern
+     , text, yaml
+     }:
+     mkDerivation {
+       pname = "fix-whitespace";
+       version = "0.0.8";
+       sha256 = "1vjbh3jx67xdzxnpyh9k2c5qv5axw07wck5jmahg0kxrj1w2nhh6";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base directory extra filepath filepattern text yaml
+       ];
+       description = "Fixes whitespace issues";
+       license = "unknown";
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "fixed" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
   "flatparse" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, containers, gauge
      , hspec, HUnit, integer-gmp, megaparsec, parsec, primitive
-     , template-haskell
+     , QuickCheck, template-haskell
      }:
      mkDerivation {
        pname = "flatparse";
-       version = "0.3.2.0";
-       sha256 = "0jnf1sxd39xd2jry2p7d9sj29ym0bs4wb3yskl9sjwa6ssck4vdq";
+       version = "0.3.3.0";
+       sha256 = "00ggikjgyb5sivj5aff328gaamxi241y6kign8l9pvrr802xmc0c";
        libraryHaskellDepends = [
          base bytestring containers integer-gmp template-haskell
        ];
-       testHaskellDepends = [ base bytestring hspec HUnit ];
+       testHaskellDepends = [ base bytestring hspec HUnit QuickCheck ];
        benchmarkHaskellDepends = [
          attoparsec base bytestring gauge integer-gmp megaparsec parsec
          primitive
···
      }:
      mkDerivation {
        pname = "folds";
-       version = "0.7.7";
-       sha256 = "1hggk92i61f3nxcjdxvgs3b8am3jypig09s9wqwrwzaclx0mk5sh";
-       configureFlags = [ "-f-test-hlint" ];
-       libraryHaskellDepends = [
-         adjunctions base bifunctors comonad constraints contravariant
-         data-reify distributive lens mtl pointed profunctors reflection
-         semigroupoids transformers unordered-containers vector
-       ];
-       description = "Beautiful Folding";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "folds_0_7_8" = callPackage
-    ({ mkDerivation, adjunctions, base, bifunctors, comonad
-     , constraints, contravariant, data-reify, distributive, lens, mtl
-     , pointed, profunctors, reflection, semigroupoids, transformers
-     , unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "folds";
        version = "0.7.8";
        sha256 = "11278546mq05rhyjfmhg0iasqjsn898l44dhp5qgaw1zwzywir2i";
        configureFlags = [ "-f-test-hlint" ];
···
        ];
        description = "Beautiful Folding";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "folds-common" = callPackage
···
      }) {};
 
   "freckle-app" = callPackage
-    ({ mkDerivation, aeson, ansi-terminal, base, bytestring
+    ({ mkDerivation, aeson, ansi-terminal, base, bugsnag, bytestring
      , case-insensitive, conduit, containers, data-default, datadog
      , directory, doctest, ekg-core, errors, exceptions, fast-logger
      , filepath, Glob, hashable, hspec, hspec-core
      , hspec-expectations-lifted, hspec-junit-formatter, http-client
      , http-conduit, http-link-header, http-types, immortal, iproute
-     , lens, lens-aeson, load-env, monad-control, monad-logger
+     , lens, lens-aeson, load-env, memcache, monad-control, monad-logger
      , MonadRandom, mtl, network, network-uri, persistent
      , persistent-postgresql, postgresql-simple, primitive, process
-     , resource-pool, retry, rio, safe, semigroupoids, template-haskell
-     , temporary, text, time, transformers, transformers-base, unliftio
-     , unordered-containers, vector, wai, wai-extra, yaml, yesod
-     , yesod-core
+     , resource-pool, retry, rio, safe, scientist, semigroupoids
+     , template-haskell, temporary, text, time, transformers
+     , transformers-base, unliftio, unliftio-core, unordered-containers
+     , vector, wai, wai-extra, yaml, yesod, yesod-core
      }:
      mkDerivation {
        pname = "freckle-app";
-       version = "1.0.2.10";
-       sha256 = "05y2b4lfc0wxygjrvjlw3nfl9s1x9km095k2vzj57mb58zkr3kyv";
+       version = "1.0.4.0";
+       sha256 = "0snlgizlbi7izqv66izcf2s3ns5yj8h75jmh1f0ialkppzz1bh07";
        libraryHaskellDepends = [
-         aeson ansi-terminal base bytestring case-insensitive conduit
-         containers data-default datadog doctest ekg-core errors exceptions
-         fast-logger filepath Glob hashable hspec hspec-core
+         aeson ansi-terminal base bugsnag bytestring case-insensitive
+         conduit containers data-default datadog doctest ekg-core errors
+         exceptions fast-logger filepath Glob hashable hspec hspec-core
          hspec-expectations-lifted hspec-junit-formatter http-client
          http-conduit http-link-header http-types immortal iproute lens
-         load-env monad-control monad-logger MonadRandom mtl network
-         network-uri persistent persistent-postgresql postgresql-simple
-         primitive process resource-pool retry rio safe semigroupoids
-         template-haskell text time transformers transformers-base unliftio
-         unordered-containers vector wai wai-extra yaml yesod yesod-core
+         load-env memcache monad-control monad-logger MonadRandom mtl
+         network network-uri persistent persistent-postgresql
+         postgresql-simple primitive process resource-pool retry rio safe
+         scientist semigroupoids template-haskell text time transformers
+         transformers-base unliftio unordered-containers vector wai
+         wai-extra yaml yesod yesod-core
        ];
        testHaskellDepends = [
-         aeson base bytestring directory hspec http-types lens lens-aeson
-         process temporary text time wai wai-extra
+         aeson base bytestring directory errors hspec http-types lens
+         lens-aeson memcache monad-logger mtl postgresql-simple process
+         temporary text time unliftio-core wai wai-extra
        ];
        description = "Haskell application toolkit used at Freckle";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "fuzzyset";
-       version = "0.2.2";
-       sha256 = "1153xv53l6khw7yy36pfaf7pmmlwpg4ig7ywk4rxj375janlg1g8";
-       libraryHaskellDepends = [
-         base data-default text text-metrics unordered-containers vector
-       ];
-       testHaskellDepends = [
-         base data-default hspec ieee754 text text-metrics
-         unordered-containers vector
-       ];
-       description = "Fuzzy set for approximate string matching";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "fuzzyset_0_2_3" = callPackage
-    ({ mkDerivation, base, data-default, hspec, ieee754, text
-     , text-metrics, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "fuzzyset";
        version = "0.2.3";
        sha256 = "02rc846kfrkd0gd3j37gkmf87z09rzfa9bz2f0i2b83mh8ppk1sl";
        libraryHaskellDepends = [
···
        ];
        description = "Fuzzy set for approximate string matching";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "fuzzytime" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "ghc-lib_9_2_2_20220307" = callPackage
+  "ghc-lib_9_2_3_20220527" = callPackage
     ({ mkDerivation, alex, array, base, binary, bytestring, containers
      , deepseq, directory, exceptions, filepath, ghc-lib-parser
      , ghc-prim, happy, hpc, parsec, pretty, process, rts, time
···
      }:
      mkDerivation {
        pname = "ghc-lib";
-       version = "9.2.2.20220307";
-       sha256 = "0hcm4px40791rnfxaxmkwaydgsp43vnka02jj3bq57jylklvr0y4";
+       version = "9.2.3.20220527";
+       sha256 = "0ldafrp5j91cjqgh78vfqjmf1ywj1cjhjyxch9yqlj6yz4r6gqi4";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "ghc-lib-parser_9_2_2_20220307" = callPackage
+  "ghc-lib-parser_9_2_3_20220527" = callPackage
     ({ mkDerivation, alex, array, base, binary, bytestring, containers
      , deepseq, directory, exceptions, filepath, ghc-prim, happy, parsec
      , pretty, process, time, transformers, unix
      }:
      mkDerivation {
        pname = "ghc-lib-parser";
-       version = "9.2.2.20220307";
-       sha256 = "123bkxir6qrhyxjzlv3vm1p8wiah24i1r4ary79lhp14phyv5x46";
+       version = "9.2.3.20220527";
+       sha256 = "0w7rnpjyrl8h8rxplfwqdsj9g4q8y8fz9rs8mshil1f4wxnc6nmx";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "ghc-lib-parser-ex_9_2_0_3" = callPackage
+  "ghc-lib-parser-ex_9_2_0_4" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory, extra
      , filepath, ghc-lib-parser, tasty, tasty-hunit, uniplate
      }:
      mkDerivation {
        pname = "ghc-lib-parser-ex";
-       version = "9.2.0.3";
-       sha256 = "178cgr279716gpnlsky99qasmk9jma2jdsk8xfnhk6ibm1p5gfbv";
+       version = "9.2.0.4";
+       sha256 = "138wkpy7qpdkp07028flab3lwq4b3mns0qcrkfrhclixlz8pi74v";
        libraryHaskellDepends = [
          base bytestring containers ghc-lib-parser uniplate
        ];
···
      }:
      mkDerivation {
        pname = "ghc-prof";
-       version = "1.4.1.9";
-       sha256 = "1m7pwrwf45hc8nscl9kzzw9n0blnfpx7dl38kv8hvshaqbbg0v4q";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         attoparsec base containers scientific text time
-       ];
-       testHaskellDepends = [
-         attoparsec base containers directory filepath process tasty
-         tasty-hunit temporary text
-       ];
-       description = "Library for parsing GHC time and allocation profiling reports";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "ghc-prof_1_4_1_11" = callPackage
-    ({ mkDerivation, attoparsec, base, containers, directory, filepath
-     , process, scientific, tasty, tasty-hunit, temporary, text, time
-     }:
-     mkDerivation {
-       pname = "ghc-prof";
        version = "1.4.1.11";
        sha256 = "1i6a3dx9ml8r4q8rvap7rw3qhvksgaws1hzna34ldpkwh6b7kfxy";
        isLibrary = true;
···
      }:
      mkDerivation {
        pname = "git-annex";
-       version = "10.20220504";
-       sha256 = "10pp58b7glwi1yckrij49d1iq99pc4dpkkbkb1qqiif9dr9672f3";
+       version = "10.20220525";
+       sha256 = "1nrwa4qm3xkr11x0b0c1mx052zhd7lz9w97xf0ycdkhsyc6vbiy6";
        configureFlags = [
          "-fassistant" "-f-benchmark" "-fdbus" "-f-debuglocks" "-fmagicmime"
          "-fnetworkbsd" "-fpairing" "-fproduction" "-fs3" "-ftorrentparser"
···
        pname = "github";
        version = "0.28";
        sha256 = "142l0zff852606hkpvkhvagp6h3ziq2z2x7x2pa77q5ymyq48089";
+       revision = "3";
+       editedCabalFile = "03cn567jgkgd8a78ymm9zws8fp8881kmpj6jkb7cj3kbq05062jv";
        libraryHaskellDepends = [
          aeson base base-compat base16-bytestring binary binary-instances
          bytestring containers cryptohash-sha1 deepseq deepseq-generics
···
        description = "Binding to the glade library";
        license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs.gnome2) libglade;};
 
   "gladexml-accessor" = callPackage
···
        libraryHaskellDepends = [ base glade HaXml template-haskell ];
        description = "Automagically declares getters for widget handles in specified interface file";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "glambda" = callPackage
···
   "glirc" = callPackage
     ({ mkDerivation, async, attoparsec, base, base64-bytestring
      , bytestring, Cabal, config-schema, config-value, containers
+     , directory, filepath, free, gitrev, hashable, hookup, HsOpenSSL
+     , HUnit, irc-core, kan-extensions, lens, network, process, psqueues
+     , random, regex-tdfa, split, stm, template-haskell, text, time
+     , transformers, unix, unordered-containers, vector, vty
+     }:
+     mkDerivation {
+       pname = "glirc";
+       version = "2.38";
+       sha256 = "1azykkb9rc4q97v9xiqfjv0iys0wswa3nsy10smdkpp7yvv4mca7";
+       revision = "2";
+       editedCabalFile = "082ndcgp9z1w5pa3s5ss7kqhg66y01lbj57k14zq6zs6c54s4b5i";
+       isLibrary = true;
+       isExecutable = true;
+       setupHaskellDepends = [ base Cabal filepath ];
+       libraryHaskellDepends = [
+         async attoparsec base base64-bytestring bytestring config-schema
+         config-value containers directory filepath free gitrev hashable
+         hookup HsOpenSSL irc-core kan-extensions lens network process
+         psqueues random regex-tdfa split stm template-haskell text time
+         transformers unix unordered-containers vector vty
+       ];
+       executableHaskellDepends = [ base lens text vty ];
+       testHaskellDepends = [ base HUnit ];
+       description = "Console IRC client";
+       license = lib.licenses.isc;
+       maintainers = with lib.maintainers; [ kiwi ];
+     }) {};
+
+  "glirc_2_39" = callPackage
+    ({ mkDerivation, async, attoparsec, base, base64-bytestring
+     , bytestring, Cabal, config-schema, config-value, containers
      , curve25519, directory, filepath, free, githash, hashable, hookup
      , HsOpenSSL, HUnit, irc-core, kan-extensions, lens, network
      , process, psqueues, random, regex-tdfa, split, stm
···
        license = lib.licenses.isc;
        hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ kiwi ];
-       broken = true;
      }) {};
 
   "gll" = callPackage
···
      }) {};
 
   "grow-vector" = callPackage
-    ({ mkDerivation, base, primitive, quickcheck-instances, tasty
-     , tasty-discover, tasty-hspec, tasty-quickcheck, vector
+    ({ mkDerivation, base, hspec, primitive, quickcheck-instances
+     , tasty, tasty-discover, tasty-hspec, tasty-quickcheck, vector
      }:
      mkDerivation {
        pname = "grow-vector";
-       version = "0.1.3.0";
-       sha256 = "13b75yghy6nksga98wn8gc9b2198g4pqrm52hrldryyf4v83zadg";
+       version = "0.1.5.0";
+       sha256 = "1dn6gabmndhi56v3nsapxm9qbf54dp2blhgn8ibza0lnv8hwn15b";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [ base primitive vector ];
        testHaskellDepends = [
-         base primitive quickcheck-instances tasty tasty-discover
+         base hspec primitive quickcheck-instances tasty tasty-discover
          tasty-hspec tasty-quickcheck
        ];
        testToolDepends = [ tasty-discover ];
···
      }:
      mkDerivation {
        pname = "gsmenu";
-       version = "3.0";
-       sha256 = "15ddm69fmk0nkkrs5g80amdvld2mq59ah58nbnk83mwkffpi484f";
+       version = "3.1";
+       sha256 = "0pyz5rhkmdl002f80jc8zksv8jff8bv99hvwg7g6ijfy68yibwsh";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        ];
        description = "A type class for cast functions of Gtk2hs: glade package";
        license = "unknown";
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gtk2hs-cast-glib" = callPackage
···
        pname = "hackage-security";
        version = "0.6.2.1";
        sha256 = "1a349ma9ijypjzgj7xgkkr6rd8k49crdgx330h9vgmp7vlbcs8mz";
-       revision = "1";
-       editedCabalFile = "0vhwszqngng5vxf2dpn1fdai59s8c7jh6p04jf983y9rzbic6d7b";
+       revision = "2";
+       editedCabalFile = "1r7jaf7vq90xlcsdq9snlz3d52zqcpijlby7abpzfw09v4mjjjqx";
        libraryHaskellDepends = [
          base base16-bytestring base64-bytestring bytestring Cabal
          Cabal-syntax containers cryptohash-sha256 directory ed25519
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "hal_1_0_0" = callPackage
+    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
+     , case-insensitive, conduit, conduit-extra, containers, exceptions
+     , hashable, hedgehog, hspec, hspec-hedgehog, http-client
+     , http-types, mtl, raw-strings-qq, scientific, text, time
+     , transformers, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "hal";
+       version = "1.0.0";
+       sha256 = "0mfdxjlypb1sj2kcsqks6anh80xy1azcg9lvlpkgz7dgdpjfygaq";
+       revision = "1";
+       editedCabalFile = "0chjhs3vnzmlwhjlkg24vnpx4baavkj42ldbz25li1r24naw5bsd";
+       libraryHaskellDepends = [
+         aeson base base64-bytestring bytestring case-insensitive conduit
+         conduit-extra containers exceptions hashable http-client http-types
+         mtl scientific text time unordered-containers
+       ];
+       testHaskellDepends = [
+         aeson base base64-bytestring bytestring case-insensitive containers
+         hedgehog hspec hspec-hedgehog http-client http-types raw-strings-qq
+         scientific text time transformers unordered-containers vector
+       ];
+       description = "A runtime environment for Haskell applications running on AWS Lambda";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "halberd" = callPackage
     ({ mkDerivation, base, Cabal, containers, haskell-names
      , haskell-packages, haskell-src-exts, HUnit, mtl, safe, split, syb
···
        pname = "haskell-src";
        version = "1.0.4";
        sha256 = "1spkhv83hy5v1lxs44l3w53vk8zj7gnx42c40hrkj4fcz6apdiwb";
+       revision = "1";
+       editedCabalFile = "0dfjzq0sxxcalqxygp2svx4890qx8b4amad0xldwy1f4xrp3lsnb";
        libraryHaskellDepends = [ array base pretty syb ];
        libraryToolDepends = [ happy ];
        description = "Support for manipulating Haskell source code";
···
      }:
      mkDerivation {
        pname = "haskell-src-meta";
-       version = "0.8.9";
-       sha256 = "0y3hnqg33pqzc66nl58va8lvwvmb0mx5q0p9r55i6cc3xwjahiyx";
+       version = "0.8.10";
+       sha256 = "0hzwrmv9157wcym1qwy9pxkb8mz5b428nzqf455n6qlrjjjmqpi1";
        libraryHaskellDepends = [
          base haskell-src-exts pretty syb template-haskell th-orphans
        ];
···
      }:
      mkDerivation {
        pname = "haskell-xmpp";
-       version = "2.0.1";
-       sha256 = "0x06a43h930ad17shvc8iwibkpgbfk6lkkr9mnp0xnwaf6kzrf47";
+       version = "2.0.4";
+       sha256 = "1nj0n5qxp56vxg9npklkji63y627rypv3gz307785qpcin0vflpw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        platforms = [
          "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
        ];
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
          base bytestring containers data-accessor MissingH polyparse text
···
        platforms = [
          "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
        ];
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
          base bytestring containers data-accessor MissingH polyparse text
···
     ({ mkDerivation }:
      mkDerivation {
          base bytestring containers data-accessor MissingH polyparse text
-       version = "0.0.0.2";
-         base bytestring containers data-accessor MissingH polyparse text
+       version = "0.0.0.4";
+       sha256 = "1xvl0p58q8l7yq90hfydgy2h5644xxjai99frli719l2mg7s1ndm";
+       revision = "3";
+       editedCabalFile = "0dzyhd2gjpv7182s1pjvwxwnxa19pva1x94837my57hmnrs7iskh";
        doHaddock = false;
        description = "Haskell COM support library";
        license = lib.licenses.bsd3;
···
          base bytestring containers data-accessor MissingH polyparse text
        version = "1.1.1";
          base bytestring containers data-accessor MissingH polyparse text
-       revision = "1";
-         base bytestring containers data-accessor MissingH polyparse text
+       revision = "2";
+       editedCabalFile = "06i998jic83qpihcv7xhc2ny1z3b4k0p22ds79l5l9hfbf0la6rh";
        libraryHaskellDepends = [
          base bytestring containers data-accessor MissingH polyparse text
          base bytestring containers data-accessor MissingH polyparse text
···
          base bytestring containers data-accessor MissingH polyparse text
        version = "0.1.1";
          base bytestring containers data-accessor MissingH polyparse text
-       revision = "2";
-         base bytestring containers data-accessor MissingH polyparse text
+       revision = "3";
+       editedCabalFile = "0mfpgn46126y1y2k3i2r5nqxcrsa16il3vyf7ir0w471nmks7n54";
          base bytestring containers data-accessor MissingH polyparse text
          base bytestring containers data-accessor MissingH polyparse text
        license = lib.licenses.bsd3;
···
          base bytestring containers data-accessor MissingH polyparse text
          base bytestring containers data-accessor MissingH polyparse text
          base bytestring containers data-accessor MissingH polyparse text
-         base bytestring containers data-accessor MissingH polyparse text
-         base bytestring containers data-accessor MissingH polyparse text
-     , test-framework-hunit, test-framework-quickcheck2, text, time
-         base bytestring containers data-accessor MissingH polyparse text
-     , xmlhtml
+     , hashable, HUnit, indexed-traversable, lens, lifted-base
+     , map-syntax, monad-control, mtl, process, QuickCheck, random
+     , statistics, test-framework, test-framework-hunit
+     , test-framework-quickcheck2, text, time, transformers
+     , transformers-base, unordered-containers, vector, xmlhtml
      }:
      mkDerivation {
          base bytestring containers data-accessor MissingH polyparse text
-       version = "1.2.0.0";
-         base bytestring containers data-accessor MissingH polyparse text
+       version = "1.2.1.0";
+       sha256 = "0xrcgh9g0207zr60r0g5aqzjf0j240zwx6wlwl0jamwjzg45x3ka";
        libraryHaskellDepends = [
          base bytestring containers data-accessor MissingH polyparse text
          base bytestring containers data-accessor MissingH polyparse text
-         base bytestring containers data-accessor MissingH polyparse text
+         indexed-traversable lifted-base map-syntax monad-control mtl
+         process random text time transformers transformers-base
          base bytestring containers data-accessor MissingH polyparse text
        ];
        testHaskellDepends = [
          base bytestring containers data-accessor MissingH polyparse text
          base bytestring containers data-accessor MissingH polyparse text
-         base bytestring containers data-accessor MissingH polyparse text
-         base bytestring containers data-accessor MissingH polyparse text
-         test-framework-quickcheck2 text time transformers transformers-base
+         hashable HUnit indexed-traversable lens lifted-base map-syntax
+         monad-control mtl process QuickCheck random test-framework
+         test-framework-hunit test-framework-quickcheck2 text time
          base bytestring containers data-accessor MissingH polyparse text
        ];
        benchmarkHaskellDepends = [
          base bytestring containers data-accessor MissingH polyparse text
          base bytestring containers data-accessor MissingH polyparse text
-         base bytestring containers data-accessor MissingH polyparse text
-         base bytestring containers data-accessor MissingH polyparse text
-         text time transformers transformers-base unordered-containers
-         base bytestring containers data-accessor MissingH polyparse text
+         dlist filepath hashable HUnit indexed-traversable lifted-base
+         map-syntax monad-control mtl process random statistics
+         test-framework test-framework-hunit text time transformers
+         transformers-base unordered-containers vector xmlhtml
        ];
          base bytestring containers data-accessor MissingH polyparse text
        license = lib.licenses.bsd3;
···
        pname = "hi-file-parser";
        version = "0.1.2.0";
        sha256 = "1jm3gbibafkw3ninvsz7f1x89xdyk6wml45mq9zb85p6m9xqlpv9";
+       revision = "1";
+       editedCabalFile = "1q53g0h4xnq0fsjbwg1fclnw0kxpzz58p8jrczhmgb4z5wn8g292";
        libraryHaskellDepends = [ base binary bytestring mtl rio vector ];
        testHaskellDepends = [
          base binary bytestring hspec mtl rio vector
···
 
   "highlight" = callPackage
     ({ mkDerivation, ansi-terminal, base, base-compat, bytestring
-     , containers, criterion, directory, doctest, filepath, lens, mtl
-     , mtl-compat, optparse-applicative, pipes, pipes-bytestring
-     , pipes-group, pipes-safe, process, QuickCheck, regex
-     , regex-with-pcre, semigroups, system-filepath, tasty, tasty-golden
-     , text, transformers, transformers-compat, unix
+     , containers, criterion, directory, filepath, lens, mtl, mtl-compat
+     , optparse-applicative, pipes, pipes-bytestring, pipes-group
+     , pipes-safe, process, regex, regex-with-pcre, semigroups
+     , system-filepath, tasty, tasty-golden, text, transformers
+     , transformers-compat, unix
      }:
      mkDerivation {
        pname = "highlight";
-       version = "1.0.0.1";
-       sha256 = "0xklv4fnhi4dbz33hzw7l4ng5ap1jfhn4qmkshl2k6gn2pkyaikx";
+       version = "1.0.0.2";
+       sha256 = "019chfvi85cjcb6minkf5cgxdr6y9m8izw9rf37iq0swawc4icm9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [
-         base base-compat bytestring directory doctest lens pipes process
-         QuickCheck tasty tasty-golden transformers transformers-compat unix
+         base base-compat bytestring directory lens pipes process tasty
+         tasty-golden transformers transformers-compat unix
        ];
        benchmarkHaskellDepends = [ base criterion ];
        description = "Command line tool for highlighting parts of files matching a regex";
···
      }:
      mkDerivation {
        pname = "hookup";
+       version = "0.6";
+       sha256 = "09rhsq0j2m1j87qsbsd3l1q3dv2zs4wrhcz2jhn4a6dx273w5528";
+       revision = "1";
+       editedCabalFile = "0dm7i3g8hlrg0rzfhfcryypgqlil2p8ny12bn49yir2b1qfd47dc";
+       libraryHaskellDepends = [
+         async attoparsec base bytestring HsOpenSSL HsOpenSSL-x509-system
+         network stm
+       ];
+       description = "Abstraction over creating network connections with SOCKS5 and TLS";
+       license = lib.licenses.isc;
+     }) {};
+
+  "hookup_0_7" = callPackage
+    ({ mkDerivation, async, attoparsec, base, bytestring, HsOpenSSL
+     , HsOpenSSL-x509-system, network, stm
+     }:
+     mkDerivation {
+       pname = "hookup";
        version = "0.7";
        sha256 = "02prkwj4rj8g330z17bpjh7hpwfdvasaxsk74mcvbi03gjpydrib";
        libraryHaskellDepends = [
···
        ];
        description = "Abstraction over creating network connections with SOCKS5 and TLS";
        license = lib.licenses.isc;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hoop" = callPackage
···
      }:
      mkDerivation {
        pname = "hpqtypes";
-       version = "1.9.3.1";
-       sha256 = "02cinc29smiic2zc8z83h9bppsf60yp56a4cb9k4agkjqf5n2036";
-       setupHaskellDepends = [ base Cabal directory filepath ];
-       libraryHaskellDepends = [
-         aeson async base bytestring containers exceptions lifted-base
-         monad-control mtl resource-pool semigroups text text-show time
-         transformers transformers-base uuid-types vector
-       ];
-       librarySystemDepends = [ postgresql ];
-       testHaskellDepends = [
-         aeson base bytestring exceptions HUnit lifted-base monad-control
-         mtl QuickCheck random scientific test-framework
-         test-framework-hunit text text-show time transformers-base
-         unordered-containers uuid-types vector
-       ];
-       description = "Haskell bindings to libpqtypes";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {inherit (pkgs) postgresql;};
-
-  "hpqtypes_1_9_4_0" = callPackage
-    ({ mkDerivation, aeson, async, base, bytestring, Cabal, containers
-     , directory, exceptions, filepath, HUnit, lifted-base
-     , monad-control, mtl, postgresql, QuickCheck, random, resource-pool
-     , scientific, semigroups, test-framework, test-framework-hunit
-     , text, text-show, time, transformers, transformers-base
-     , unordered-containers, uuid-types, vector
-     }:
-     mkDerivation {
-       pname = "hpqtypes";
        version = "1.9.4.0";
        sha256 = "0m0jpv0d2zynhn53gbjb50sb91lxss71qnzhcy30agxvf29qpi0w";
        setupHaskellDepends = [ base Cabal directory filepath ];
···
      }:
      mkDerivation {
        pname = "hsexif";
-       version = "0.6.1.8";
-       sha256 = "1c44j9qnld5lg8zcw3pyh56fk0r62g76qmma790mcvy4sbrcz102";
+       version = "0.6.1.9";
+       sha256 = "1k6zq1jjzl7y38yh9cris096i5bba24rwwizdr8a2cyqqxz2g8jf";
        libraryHaskellDepends = [
          base binary bytestring containers iconv text time
        ];
···
        pname = "hsini";
        version = "0.5.1.2";
        sha256 = "1r6qksnrmk18ndxs5zaga8b7kvmk34kp0kh5hwqmq797qrlax9pa";
-       revision = "1";
-       editedCabalFile = "0wkvajjgs64l4wlw8s6sn3pbwx3ni41p1260chp67a16innr1qp6";
+       revision = "2";
+       editedCabalFile = "1b83g6jk9hcm2h17f1h9vyzm34bmr7w4j5888rbv9k8gpi97f8i7";
        libraryHaskellDepends = [ base bytestring containers mtl parsec ];
        testHaskellDepends = [
          base bytestring containers mtl parsec tasty tasty-hunit
···
        pname = "hspec-core";
        version = "2.7.10";
        sha256 = "12k9yp5gznrda449ir60d5wv3xl7nnyffkb5mhfc0svw9f8lxlv1";
+       revision = "1";
+       editedCabalFile = "0g6x70fqwblf2dzjgq6hp4nj5vqrbfvzphl3j8a73h1966zhrxy9";
        libraryHaskellDepends = [
          ansi-terminal array base call-stack clock deepseq directory
          filepath hspec-expectations HUnit QuickCheck quickcheck-io random
···
        pname = "hspec-core";
        version = "2.8.5";
        sha256 = "0hy3qw7qvix5899hkq96mqda2ridif2g3mwdn8sxg2wlhbcvzfjm";
+       revision = "1";
+       editedCabalFile = "1nwki2mb64akmc7585cmjhiizwm090j7gqx5js1h9rmvl7z2zfbx";
        libraryHaskellDepends = [
          ansi-terminal array base call-stack clock deepseq directory
          filepath hspec-expectations HUnit QuickCheck quickcheck-io random
···
        ];
        description = "A two player abstract strategy game";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hsubconvert" = callPackage
···
        pname = "imperative-edsl";
        version = "0.9";
        sha256 = "0qzk3kjmjv3357dlc4fa43k4xn7xhyavmbnni0cd86zrilgxha6h";
+       revision = "1";
+       editedCabalFile = "11spl74xarqx3pcag1j2i72m4k9gv5lkv6g7zy658yg4ibywwkdx";
        libraryHaskellDepends = [
          array base BoundedChan containers data-default-class deepseq
          directory exception-transformers ghc-prim language-c-quote
···
      }:
      mkDerivation {
        pname = "inline-c";
-       version = "0.9.1.5";
-       sha256 = "0a0m3bhh910c5g46cwkxgflsgw5ab7lzymwll9hijyvwgnsw3h7i";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         ansi-wl-pprint base bytestring containers hashable mtl parsec
-         parsers template-haskell transformers unordered-containers vector
-       ];
-       testHaskellDepends = [
-         ansi-wl-pprint base containers hashable hspec parsers QuickCheck
-         raw-strings-qq regex-posix split template-haskell transformers
-         unordered-containers vector
-       ];
-       description = "Write Haskell source files including C code inline. No FFI required.";
-       license = lib.licenses.mit;
-       maintainers = with lib.maintainers; [ roberth ];
-     }) {};
-
-  "inline-c_0_9_1_6" = callPackage
-    ({ mkDerivation, ansi-wl-pprint, base, bytestring, containers
-     , hashable, hspec, mtl, parsec, parsers, QuickCheck, raw-strings-qq
-     , regex-posix, split, template-haskell, transformers
-     , unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "inline-c";
        version = "0.9.1.6";
        sha256 = "06az494fp2nh6fnibq28yw8jsrpj4jq1swyx53a328qv04cbhrym";
        isLibrary = true;
···
        ];
        description = "Write Haskell source files including C code inline. No FFI required.";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ roberth ];
      }) {};
 
···
      }:
      mkDerivation {
        pname = "inspection-testing";
-       version = "0.4.6.0";
-       sha256 = "0qz1npyycj4bvyly9xmjbnhw569l52h38gx02rk0r7zhapw83aig";
-       libraryHaskellDepends = [
-         base containers ghc mtl template-haskell transformers
-       ];
-       testHaskellDepends = [ base ];
-       description = "GHC plugin to do inspection testing";
-       license = lib.licenses.mit;
-     }) {};
-
-  "inspection-testing_0_4_6_1" = callPackage
-    ({ mkDerivation, base, containers, ghc, mtl, template-haskell
-     , transformers
-     }:
-     mkDerivation {
-       pname = "inspection-testing";
        version = "0.4.6.1";
        sha256 = "0mxff0v3ciccbk4b8kxnh4752fzbwn7213qd8xji0csv6gi2w83y";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base ];
        description = "GHC plugin to do inspection testing";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "inspector-wrecker" = callPackage
···
      }:
      mkDerivation {
        pname = "interval-algebra";
-       version = "2.0.0";
-       sha256 = "0p6zgshfcf7gh1349hwxg2zfwvzi0w7ldi9p2pmm9xkqs6q4q8dz";
+       version = "2.0.2";
+       sha256 = "1fsz0grgk4iq457zqvhnsqbrphgg62d46h5rzxffmy5zlvpzhq8g";
        libraryHaskellDepends = [
          base binary containers deepseq foldl nonempty-containers
          prettyprinter QuickCheck safe text time witch witherable
···
        broken = true;
      }) {};
 
+  "json-stream_0_4_4_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, directory, hspec
+     , primitive, QuickCheck, quickcheck-unicode, scientific, text
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "json-stream";
+       version = "0.4.4.0";
+       sha256 = "1rjvrkrjmh5kvrajd6n2q3h68dkh1m5jhm7f6hq723zvxzl98wij";
+       libraryHaskellDepends = [
+         aeson base bytestring primitive scientific text
+         unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson base bytestring directory hspec primitive QuickCheck
+         quickcheck-unicode scientific text unordered-containers vector
+       ];
+       description = "Incremental applicative JSON parser";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "json-syntax" = callPackage
     ({ mkDerivation, aeson, array-builder, array-chunks, base
      , bytebuild, byteslice, bytesmith, bytestring, contiguous, gauge
···
      }:
      mkDerivation {
        pname = "katip";
-       version = "0.8.7.1";
-       sha256 = "157mc5w05j82020g0f65bdjz839fs6cd263xz5z7p00h0y576vg6";
-       revision = "1";
-       editedCabalFile = "0snkks2ng5bwnbm5zr615c5nlagh0vv46xfz5gb5vlx1gkgawd1r";
+       version = "0.8.7.2";
+       sha256 = "02h7mgprmqy219i4ph9qg5pwgdzrxkzkgckbcaizmny84c87b46r";
        libraryHaskellDepends = [
          aeson async auto-update base bytestring containers either hostname
          microlens microlens-th monad-control mtl old-locale resourcet
···
      }:
      mkDerivation {
        pname = "koji-tool";
-       version = "0.9";
-       sha256 = "0clj5nsjpjx5z2g7gbr8qmvajicrahy42b41d582zrq1117l9gmi";
+       version = "0.9.1";
+       sha256 = "0njjrxqycyl7vh46rmx2b3i0467nkppbx20xc3j1jxn7s3dc884x";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "kvitable";
-       version = "1.0.0.0";
-       sha256 = "1p8myw0f32gb1cxzp63l4i7m6gz1l423pl40yp2jl7vfdp4kzjwz";
+       version = "1.0.1.0";
+       sha256 = "0j0sl1bdx174w79xz80j89r3nmllics1h72mslsivnqv04l519l9";
+       revision = "1";
+       editedCabalFile = "0f801w2jgadc53nxxkgzdmfy90im0vvqh5i36r68cfx0ycywkcgn";
        libraryHaskellDepends = [
          base containers lucid microlens prettyprinter text
        ];
···
     ({ mkDerivation, base, pretty }:
      mkDerivation {
        pname = "language-c99";
-       version = "0.1.3";
-       sha256 = "159cy0vrnzs8kdraclia3i693kkik33dnhx5279d7l685jf3a8fz";
+       version = "0.2.0";
+       sha256 = "02fcgf5sqg35nkviqjl04f6dhkkbxy4shlkvfxpk220k73xx0qkh";
        libraryHaskellDepends = [ base pretty ];
        description = "An implementation of the C99 AST that strictly follows the standard";
        license = lib.licenses.mit;
···
     ({ mkDerivation, base, language-c99, language-c99-util, mtl }:
      mkDerivation {
        pname = "language-c99-simple";
-       version = "0.1.2";
-       sha256 = "0v0y50n2ks8jp91y37az6q46ax6dqx1igmlkb4b7c76qngak88xi";
+       version = "0.2.0";
+       sha256 = "0sm85abxp3ia9450mxwnqbz00hcmafdbzsj0ynp4l95rxw11j0q6";
        libraryHaskellDepends = [
          base language-c99 language-c99-util mtl
        ];
···
      }) {};
 
   "language-c99-util" = callPackage
-    ({ mkDerivation, base, language-c99 }:
+    ({ mkDerivation, base, ieee754, language-c99 }:
      mkDerivation {
        pname = "language-c99-util";
-       version = "0.1.1";
-       sha256 = "0rdwb29d2aa9mqkn5b4acwviymxy18sjfmzr01j7n3j4n3q4d2lz";
-       revision = "1";
-       editedCabalFile = "0wnrdcw05zmk1flycjavdb8188qy93p6m1b6k38799ngsm78qq7k";
-       libraryHaskellDepends = [ base language-c99 ];
+       version = "0.2.0";
+       sha256 = "0cs68wz6vimy5lbjy3ks8qvx3ih49n0j4bdrn3p495rkwzy4y6r4";
+       libraryHaskellDepends = [ base ieee754 language-c99 ];
        description = "Utilities for language-c99";
        license = lib.licenses.mit;
      }) {};
···
      }) {};
 
   "linear" = callPackage
-    ({ mkDerivation, adjunctions, base, base-orphans, binary, bytes
-     , bytestring, cereal, containers, deepseq, distributive, ghc-prim
-     , hashable, HUnit, indexed-traversable, lens, random, reflection
-     , semigroupoids, semigroups, simple-reflect, tagged
-     , template-haskell, test-framework, test-framework-hunit
-     , transformers, transformers-compat, unordered-containers, vector
-     , void
-     }:
-     mkDerivation {
-       pname = "linear";
-       version = "1.21.8";
-       sha256 = "0m2lr86l932rn2cnxaplaicfbg7makhrh8xbnj3m8jhhnyn3v88b";
-       libraryHaskellDepends = [
-         adjunctions base base-orphans binary bytes cereal containers
-         deepseq distributive ghc-prim hashable indexed-traversable lens
-         random reflection semigroupoids semigroups tagged template-haskell
-         transformers transformers-compat unordered-containers vector void
-       ];
-       testHaskellDepends = [
-         base binary bytestring deepseq HUnit reflection simple-reflect
-         test-framework test-framework-hunit vector
-       ];
-       description = "Linear Algebra";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "linear_1_21_9" = callPackage
     ({ mkDerivation, adjunctions, base, base-orphans, binary, bytes
      , bytestring, cereal, containers, deepseq, distributive, ghc-prim
      , hashable, HUnit, indexed-traversable, lens, random, reflection
···
        ];
        description = "Linear Algebra";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "linear-accelerate" = callPackage
···
      }:
      mkDerivation {
        pname = "little-logger";
-       version = "1.0.0";
-       sha256 = "1llf4x5yq1d4kn07qp3ay0lbr1sskw79ck69biwxwyv4l8d132lp";
+       version = "1.0.1";
+       sha256 = "110yk385dss8hyyzkf2hpaxvrd39hgfhyv6sjf0pxqbxa4bqv51f";
        libraryHaskellDepends = [
          base microlens monad-logger mtl text unliftio-core
        ];
···
          base directory microlens monad-logger mtl tasty tasty-hunit
          temporary text unliftio-core
        ];
-       description = "Basic logging based on co-log";
+       description = "Basic logging based on monad-logger";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "little-rio_1_0_0" = callPackage
+  "little-rio_1_0_1" = callPackage
     ({ mkDerivation, base, deepseq, exceptions, little-logger
      , microlens, microlens-mtl, mtl, primitive, resourcet
      , unliftio-core
      }:
      mkDerivation {
        pname = "little-rio";
-       version = "1.0.0";
-       sha256 = "179b5v53g55ihq84r5hka6bxivxj8hmqbg02spgddp5jmqaqbaw9";
+       version = "1.0.1";
+       sha256 = "0l505nimjwg9i8kkj2ndp5i4mh0mhxnhssxsvgmd5qnzxw4i0rd3";
        libraryHaskellDepends = [
          base deepseq exceptions little-logger microlens microlens-mtl mtl
          primitive resourcet unliftio-core
···
        testHaskellDepends = [ base lucid servant text ];
        description = "Use htmx in your lucid templates";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "lucid-hyperscript" = callPackage
···
      }:
      mkDerivation {
        pname = "lucid2";
-       version = "0.0.20220509";
-       sha256 = "0d38gic3xjqj5in97sbfzjb696011bl47sshzh0377md5j02yc85";
+       version = "0.0.20220526";
+       sha256 = "004bmzwzxfq2pmp7wn1mrdwkw9fnyfnmvzymnwn8fczkq17w4csd";
        libraryHaskellDepends = [
          base blaze-builder bytestring containers mtl text transformers
        ];
···
      }:
      mkDerivation {
        pname = "machines";
-       version = "0.7.2";
-       sha256 = "0pgsa67j9l1zmazlqdb5wg3cqsikyfvkq8yih7iwcqzkys5qssvr";
-       libraryHaskellDepends = [
-         adjunctions base comonad containers distributive mtl pointed
-         profunctors semigroupoids semigroups transformers
-         transformers-compat void
-       ];
-       benchmarkHaskellDepends = [
-         base conduit criterion mtl pipes streaming
-       ];
-       description = "Networked stream transducers";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "machines_0_7_3" = callPackage
-    ({ mkDerivation, adjunctions, base, comonad, conduit, containers
-     , criterion, distributive, mtl, pipes, pointed, profunctors
-     , semigroupoids, semigroups, streaming, transformers
-     , transformers-compat, void
-     }:
-     mkDerivation {
-       pname = "machines";
        version = "0.7.3";
        sha256 = "1cmflvd0xphs15ip61347ph9w4hnhmsa4nlp425i53x1ld99l23c";
        libraryHaskellDepends = [
···
        ];
        description = "Networked stream transducers";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "machines-amazonka" = callPackage
···
        maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
-  "mcmc_0_6_2_4" = callPackage
+  "mcmc_0_6_2_5" = callPackage
     ({ mkDerivation, aeson, async, base, bytestring, circular
      , containers, covariance, criterion, data-default, deepseq
      , directory, dirichlet, double-conversion, hmatrix, hspec
-     , log-domain, math-functions, microlens, mwc-random, pretty-show
-     , primitive, statistics, time, transformers, vector, zlib
+     , log-domain, math-functions, microlens, mwc-random, parallel
+     , pretty-show, primitive, statistics, time, transformers, vector
+     , zlib
      }:
      mkDerivation {
        pname = "mcmc";
-       version = "0.6.2.4";
-       sha256 = "01ramkpjxknjaj4qp78im1a24sqv35nm72afr6wiqlwj11dcs2mq";
+       version = "0.6.2.5";
+       sha256 = "1yx72if0411pxxxqipz7dpmmn8hwmhgh9vsmw0a0za0niq8lmsm0";
        libraryHaskellDepends = [
          aeson async base bytestring circular containers covariance
          data-default deepseq directory dirichlet double-conversion hmatrix
-         log-domain math-functions microlens mwc-random pretty-show
+         log-domain math-functions microlens mwc-random parallel pretty-show
          primitive statistics time transformers vector zlib
        ];
        testHaskellDepends = [ base hspec mwc-random statistics ];
···
 
   "microaeson" = callPackage
     ({ mkDerivation, aeson, alex, array, base, bytestring, containers
-     , deepseq, QuickCheck, quickcheck-instances, tasty
+     , deepseq, fail, QuickCheck, quickcheck-instances, tasty
      , tasty-quickcheck, text, unordered-containers, vector
      }:
      mkDerivation {
        pname = "microaeson";
-       version = "0.1.0.0";
-       sha256 = "1hbpyz6p9snnd85h2y0pdqp20svxrggavbv0q8z33sc5i4p8b7iz";
-       revision = "4";
-       editedCabalFile = "0rrdyk6clik8g3biv40rpg50qzfacb9yrd45ah85xpmk8flbzcfx";
+       version = "0.1.0.1";
+       sha256 = "0rx5gm7apazc0sm65v687ab5106ximka9khizxq1lbckd2x0cq3q";
        libraryHaskellDepends = [
-         array base bytestring containers deepseq text
+         array base bytestring containers deepseq fail text
        ];
        libraryToolDepends = [ alex ];
        testHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "microlens-ghc";
-       version = "0.4.13.1";
-       sha256 = "0q079kjqah8nbr4lll1w9i1wb1ayia07qi6g50hfcpsfvwsrh8s6";
+       version = "0.4.13.2";
+       sha256 = "1258p84jj4kv6l71ijwjzpvzvqxxsqbvs5vrksi24mlf29gaxqi0";
        libraryHaskellDepends = [
          array base bytestring containers microlens transformers
        ];
···
      }:
      mkDerivation {
        pname = "microlens-mtl";
-       version = "0.2.0.1";
-       sha256 = "0ijy7xyd5lbc3calhcrhy8czkf3fjcxrv68p7kd2a5b352rfi7fp";
-       libraryHaskellDepends = [
-         base microlens mtl transformers transformers-compat
-       ];
-       description = "microlens support for Reader/Writer/State from mtl";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "microlens-mtl_0_2_0_2" = callPackage
-    ({ mkDerivation, base, microlens, mtl, transformers
-     , transformers-compat
-     }:
-     mkDerivation {
-       pname = "microlens-mtl";
        version = "0.2.0.2";
        sha256 = "0y1jli9379l8sgv5a4xl8v3qkz9fkp4qlfsywzdpywbnydl1d5v6";
        libraryHaskellDepends = [
···
        ];
        description = "microlens support for Reader/Writer/State from mtl";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "microlens-platform" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "microlens-platform_0_4_3_0" = callPackage
+  "microlens-platform_0_4_3_1" = callPackage
     ({ mkDerivation, base, hashable, microlens, microlens-ghc
      , microlens-mtl, microlens-th, text, unordered-containers, vector
      }:
      mkDerivation {
        pname = "microlens-platform";
-       version = "0.4.3.0";
-       sha256 = "113xq10cr32mbbjy57zdafk5nww75c442fm5bz3h4vckawkc8n3p";
+       version = "0.4.3.1";
+       sha256 = "0kix9j6k1yp09102fsliqaynamgwbi31l4hwswcp90flw2v9ah35";
        libraryHaskellDepends = [
          base hashable microlens microlens-ghc microlens-mtl microlens-th
          text unordered-containers vector
···
      }:
      mkDerivation {
        pname = "microstache";
-       version = "1.0.2";
-       sha256 = "0pirywb9304j2ylasskwq20k6d2srk616sh41l4s37yajsjggx5i";
-       revision = "3";
-       editedCabalFile = "1bs7h4ffd1ckjjanqsshvw1z472d0lnq3bz7qmbnfmg73jji23pv";
-       libraryHaskellDepends = [
-         aeson base containers deepseq directory filepath parsec text
-         transformers unordered-containers vector
-       ];
-       testHaskellDepends = [
-         aeson base bytestring containers hspec parsec text
-       ];
-       description = "Mustache templates for Haskell";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "microstache_1_0_2_1" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, deepseq
-     , directory, filepath, hspec, parsec, text, transformers
-     , unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "microstache";
        version = "1.0.2.1";
        sha256 = "12i2sx2rv2ai77m95gvfm93jcjk6q5i4cgfyxjrhyx3ll94z775v";
        libraryHaskellDepends = [
···
        ];
        description = "Mustache templates for Haskell";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "microtimer" = callPackage
···
      }:
      mkDerivation {
        pname = "midi";
-       version = "0.2.2.2";
-       sha256 = "0fv9980k35qv9qk73g2mp88xvhchyq0lq37cl7i26gx4f64vaz6y";
-       revision = "1";
-       editedCabalFile = "0sa17aphsnk0lc42k1niisbd4jck7j4xij95mjjc5nlrcx1zd123";
-       libraryHaskellDepends = [
-         base binary bytestring event-list explicit-exception
-         monoid-transformer non-negative QuickCheck random semigroups
-         transformers utility-ht
-       ];
-       testHaskellDepends = [
-         base bytestring event-list explicit-exception non-negative
-         QuickCheck transformers utility-ht
-       ];
-       description = "Handling of MIDI messages and files";
-       license = "GPL";
-     }) {};
-
-  "midi_0_2_2_3" = callPackage
-    ({ mkDerivation, base, binary, bytestring, event-list
-     , explicit-exception, monoid-transformer, non-negative, QuickCheck
-     , random, semigroups, transformers, utility-ht
-     }:
-     mkDerivation {
-       pname = "midi";
        version = "0.2.2.3";
        sha256 = "12vj9h7vdklzn5dglypjsw1bs9rdacdg9fmxhnbd89jv89dyn4km";
        libraryHaskellDepends = [
···
        ];
        description = "Handling of MIDI messages and files";
        license = "GPL";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "midi-alsa" = callPackage
···
        ];
        description = "Minesweeper game which is always solvable without guessing";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "mini-egison" = callPackage
···
      , case-insensitive, conduit, conduit-extra, connection, cryptonite
      , cryptonite-conduit, digest, directory, exceptions, filepath
      , http-client, http-client-tls, http-conduit, http-types, ini
-     , memory, protolude, QuickCheck, raw-strings-qq, resourcet, retry
-     , tasty, tasty-hunit, tasty-quickcheck, tasty-smallcheck, text
-     , time, transformers, unliftio, unliftio-core, unordered-containers
-     , xml-conduit
+     , memory, network-uri, QuickCheck, raw-strings-qq, relude
+     , resourcet, retry, tasty, tasty-hunit, tasty-quickcheck
+     , tasty-smallcheck, text, time, transformers, unliftio
+     , unliftio-core, unordered-containers, xml-conduit
      }:
      mkDerivation {
        pname = "minio-hs";
-       version = "1.5.3";
-       sha256 = "0nbrvkj8dn9m2i60iqk2wmf7fnj8bv4n65r4wxpimwb06yrvrfj2";
+       version = "1.6.0";
+       sha256 = "1pf1m02iz7lw4k53dac2rqnv84fcwcvx690y65h1mh2ip31abkp7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson base base64-bytestring binary bytestring case-insensitive
          conduit conduit-extra connection cryptonite cryptonite-conduit
          digest directory exceptions filepath http-client http-client-tls
-         http-conduit http-types ini memory protolude raw-strings-qq
-         resourcet retry text time transformers unliftio unliftio-core
-         unordered-containers xml-conduit
+         http-conduit http-types ini memory network-uri raw-strings-qq
+         relude resourcet retry text time transformers unliftio
+         unliftio-core unordered-containers xml-conduit
        ];
        testHaskellDepends = [
          aeson base base64-bytestring binary bytestring case-insensitive
          conduit conduit-extra connection cryptonite cryptonite-conduit
          digest directory exceptions filepath http-client http-client-tls
-         http-conduit http-types ini memory protolude QuickCheck
-         raw-strings-qq resourcet retry tasty tasty-hunit tasty-quickcheck
-         tasty-smallcheck text time transformers unliftio unliftio-core
-         unordered-containers xml-conduit
+         http-conduit http-types ini memory network-uri QuickCheck
+         raw-strings-qq relude resourcet retry tasty tasty-hunit
+         tasty-quickcheck tasty-smallcheck text time transformers unliftio
+         unliftio-core unordered-containers xml-conduit
        ];
        description = "A MinIO Haskell Library for Amazon S3 compatible cloud storage";
        license = lib.licenses.asl20;
···
      }:
      mkDerivation {
        pname = "monad-chronicle";
-       version = "1.0.0.1";
-       sha256 = "1p9w9f5sw4adxxrgfba0vxs5kdhl82ibnwfqal7nrrhp3v86imbg";
-       revision = "2";
-       editedCabalFile = "1h3dk50wpbpi5qdxfwk8d5c22ad0ll1j647b4dbcjm4318l4ahkm";
-       libraryHaskellDepends = [
-         base data-default-class mtl semigroupoids these transformers
-         transformers-compat
-       ];
-       description = "These as a transformer, ChronicleT";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "monad-chronicle_1_0_1" = callPackage
-    ({ mkDerivation, base, data-default-class, mtl, semigroupoids
-     , these, transformers, transformers-compat
-     }:
-     mkDerivation {
-       pname = "monad-chronicle";
        version = "1.0.1";
        sha256 = "13f1qwylpj7wss2h5g69zlmn6k6qg5r3aqd9zhvjspg1a85m91kq";
        libraryHaskellDepends = [
···
        ];
        description = "These as a transformer, ChronicleT";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "monad-classes" = callPackage
···
      }:
      mkDerivation {
        pname = "monoid-statistics";
-       version = "1.1.0";
-       sha256 = "12q86bh057pn040wdr39wlq066mcffpgsx71jy5h8rj02qi4b78f";
+       version = "1.1.1";
+       sha256 = "13vncdylaazcyfsdylxxnfkywyzw7ydmacisjhx6qhq12c87375q";
        libraryHaskellDepends = [
          base exceptions math-functions vector vector-th-unbox
        ];
···
      }:
      mkDerivation {
        pname = "moss";
-       version = "0.2.0.0";
-       sha256 = "17ac31r26c8zddp3qdk573lyry2bz7c0y49q0adln3psd39czzw0";
-       libraryHaskellDepends = [
-         base bytestring conduit-extra mtl network network-simple
-         unix-compat
-       ];
-       description = "Haskell client for Moss";
-       license = lib.licenses.mit;
-     }) {};
-
-  "moss_0_2_0_1" = callPackage
-    ({ mkDerivation, base, bytestring, conduit-extra, mtl, network
-     , network-simple, unix-compat
-     }:
-     mkDerivation {
-       pname = "moss";
        version = "0.2.0.1";
        sha256 = "1az701j6gx6ra9j6yz4qib7g5irmd5pjcaj9xqmsc4pwljx8yrzs";
        libraryHaskellDepends = [
···
        ];
        description = "Haskell client for Moss";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "moto" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "mysql-simple_0_4_8" = callPackage
+    ({ mkDerivation, attoparsec, base, base16-bytestring, blaze-builder
+     , bytestring, containers, hspec, mysql, old-locale, pcre-light
+     , text, time, vector
+     }:
+     mkDerivation {
+       pname = "mysql-simple";
+       version = "0.4.8";
+       sha256 = "077psr65rszk06bxx67bhvfk8ajmsr56bwynx7d57lqdvzvm4691";
+       libraryHaskellDepends = [
+         attoparsec base base16-bytestring blaze-builder bytestring
+         containers mysql old-locale pcre-light text time vector
+       ];
+       testHaskellDepends = [
+         base blaze-builder bytestring hspec mysql text time
+       ];
+       description = "A mid-level MySQL client library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "mysql-simple-quasi" = callPackage
     ({ mkDerivation, base, haskell-src-meta, mysql-simple
      , template-haskell
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "natural-arithmetic_0_1_3_0" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "natural-arithmetic";
+       version = "0.1.3.0";
+       sha256 = "13ihizfvkl5bjy5rn966y22lgs8f1dgwyqky3k9gjsqxczlg44xa";
+       libraryHaskellDepends = [ base ];
+       description = "Arithmetic of natural numbers";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "natural-induction" = callPackage
     ({ mkDerivation, base, peano }:
      mkDerivation {
···
        pname = "newtype";
        version = "0.2.2.0";
        sha256 = "1b7bamnd0p8vmxvlg39g5d4a2av49kx10rdyz04ixa28pg8zy01s";
-       revision = "2";
-       editedCabalFile = "0zfrjyybccr5prjkfazh0bgybjfv5vr1zpyxi1nqkqia1rm7pjrn";
+       revision = "3";
+       editedCabalFile = "0yll88ydchd2gqcvdk28fchf2vygpd42ky2bigg4ga08jan2nacx";
        libraryHaskellDepends = [ base ];
        description = "A typeclass and set of functions for working with newtypes";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "newtype-generics" = callPackage
-    ({ mkDerivation, base, gauge, hspec, hspec-discover, semigroups
-     , transformers
-     }:
-     mkDerivation {
-       pname = "newtype-generics";
-       version = "0.6.1";
-       sha256 = "1aswwfz3lc65n56l3vqcp5ak002vd11kcfz2is0a3584p8pz1zpw";
-       libraryHaskellDepends = [ base transformers ];
-       testHaskellDepends = [ base hspec ];
-       testToolDepends = [ hspec-discover ];
-       benchmarkHaskellDepends = [ base gauge semigroups ];
-       description = "A typeclass and set of functions for working with newtypes";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "newtype-generics_0_6_2" = callPackage
     ({ mkDerivation, base, gauge, hspec, hspec-discover, semigroups }:
      mkDerivation {
        pname = "newtype-generics";
···
        benchmarkHaskellDepends = [ base gauge semigroups ];
        description = "A typeclass and set of functions for working with newtypes";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "newtype-th" = callPackage
···
        pname = "nix-graph";
        version = "1.0.2.0";
        sha256 = "0g6kay7j4klgpnd4qq1b0drfc17m4nkip3sks6fn4528r0i95xll";
+       revision = "1";
+       editedCabalFile = "1dy379gajvs3846csb9j560avvsdzrxzh9sg93rmbcwdyv72lj6h";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "nqe";
-       version = "0.6.3";
-       sha256 = "0wg9cfzgj36dj77m521pqcliqd43i3j6i1bvqgvb8npmzqijag7q";
-       libraryHaskellDepends = [
-         base conduit containers hashable mtl stm unique unliftio
-       ];
-       testHaskellDepends = [
-         async base bytestring conduit conduit-extra exceptions hspec stm
-         stm-conduit text unliftio
-       ];
-       description = "Concurrency library in the style of Erlang/OTP";
-       license = lib.licenses.mit;
-     }) {};
-
-  "nqe_0_6_4" = callPackage
-    ({ mkDerivation, async, base, bytestring, conduit, conduit-extra
-     , containers, exceptions, hashable, hspec, mtl, stm, stm-conduit
-     , text, unique, unliftio
-     }:
-     mkDerivation {
-       pname = "nqe";
        version = "0.6.4";
        sha256 = "17ymmb0sy95yf5abdgq60j9bi9pdr746ap7x0byakd3gi7kciijg";
        libraryHaskellDepends = [
···
        ];
        description = "Concurrency library in the style of Erlang/OTP";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "nri-env-parser" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "numeric-prelude_0_4_4" = callPackage
+    ({ mkDerivation, array, base, containers, deepseq
+     , doctest-exitcode-stdio, doctest-lib, non-negative, parsec
+     , QuickCheck, random, semigroups, storable-record, utility-ht
+     }:
+     mkDerivation {
+       pname = "numeric-prelude";
+       version = "0.4.4";
+       sha256 = "04x6ry2sxr5hsiz4098dn2gqyjqywiq2xk0anf6wc4xrvasgccjs";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         array base containers deepseq non-negative parsec QuickCheck random
+         semigroups storable-record utility-ht
+       ];
+       testHaskellDepends = [
+         base doctest-exitcode-stdio doctest-lib QuickCheck random
+         utility-ht
+       ];
+       description = "An experimental alternative hierarchy of numeric type classes";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "numeric-qq" = callPackage
     ({ mkDerivation, base, directory, doctest, filepath, loch-th
      , placeholders, template-haskell
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "numhask_0_10_1_0" = callPackage
+    ({ mkDerivation, base, QuickCheck }:
+     mkDerivation {
+       pname = "numhask";
+       version = "0.10.1.0";
+       sha256 = "1zxp98svs872qpc0d8pycdbnf47phw4xbrvpi4vrzwyri5wahsxb";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base QuickCheck ];
+       description = "A numeric class hierarchy";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "numhask-array" = callPackage
     ({ mkDerivation, adjunctions, base, distributive, numhask, vector
      }:
···
        ];
        description = "An interactive GUI for manipulating L-systems";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "nyx-game" = callPackage
···
        pname = "oeis2";
        version = "1.0.7";
        sha256 = "1nywxada76zqzraadwbmz3v6dpwbd997393ksrprci5n6myrakng";
+       revision = "1";
+       editedCabalFile = "1fxg13qd5rniidin08yjywgfk8dvwfc3y5n582z3x0x86b2ifxy6";
        libraryHaskellDepends = [
          aeson base containers http-conduit lens lens-aeson text vector
        ];
···
        pname = "one-liner";
        version = "2.0";
        sha256 = "0al9wavxx23xbalqw0cdlhq01kx8kyhg33fipwmn5617z3ddir6v";
+       revision = "1";
+       editedCabalFile = "19iwyb3jx7bwybmmmamyzf4lxiwik7wdl8k1crikzmxn016pnybz";
        libraryHaskellDepends = [
          base bifunctors contravariant ghc-prim linear-base profunctors
          tagged transformers
···
        testHaskellDepends = [ base contravariant HUnit ];
        description = "Constraint-based generics";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "one-liner_2_1" = callPackage
+    ({ mkDerivation, base, bifunctors, contravariant, ghc-prim, HUnit
+     , linear-base, profunctors, tagged, transformers
+     }:
+     mkDerivation {
+       pname = "one-liner";
+       version = "2.1";
+       sha256 = "09gdivd38disddxs42179vmgca0yzk5dfm6ygicgl5l25qbizrfh";
+       libraryHaskellDepends = [
+         base bifunctors contravariant ghc-prim linear-base profunctors
+         tagged transformers
+       ];
+       testHaskellDepends = [ base contravariant HUnit ];
+       description = "Constraint-based generics";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "one-liner-instances" = callPackage
···
      }) {};
 
   "openid-connect" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, case-insensitive, cookie
-     , cryptonite, http-client, http-types, jose, lens, memory, mtl
-     , network-uri, tasty, tasty-hunit, text, time, unordered-containers
+    ({ mkDerivation, aeson, base, bytestring, case-insensitive
+     , containers, cookie, cryptonite, http-client, http-types, jose
+     , lens, memory, mtl, network-uri, tasty, tasty-hunit, text, time
+     , unordered-containers
      }:
      mkDerivation {
        pname = "openid-connect";
-       version = "0.1.1";
-       sha256 = "16qqndcvbs30nraik0ida1dw40hk3k9mi318dnqnjx64x6wvcgmr";
+       version = "0.1.2";
+       sha256 = "1h14m0zs5smvl0fcn6anksj94qviy8k9zkhlvdnj7flk4bbi3q2b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson base bytestring case-insensitive cookie cryptonite
+         aeson base bytestring case-insensitive containers cookie cryptonite
          http-client http-types jose lens memory mtl network-uri text time
          unordered-containers
        ];
        testHaskellDepends = [
-         aeson base bytestring case-insensitive cookie cryptonite
+         aeson base bytestring case-insensitive containers cookie cryptonite
          http-client http-types jose lens memory mtl network-uri tasty
          tasty-hunit text time unordered-containers
        ];
···
        pname = "operational-alacarte";
        version = "0.3.1";
        sha256 = "0n4xjv0li4z5lvkx8z0y72dyv9aa0hc315cvpwqcfsh5wvp7fanm";
+       revision = "1";
+       editedCabalFile = "1ca9fms1gpqmw0q6d22smkif19avkdd629w2hgylp942f6icpmhq";
        libraryHaskellDepends = [ base mtl ];
        testHaskellDepends = [ base ];
        description = "A version of Operational suitable for extensible EDSLs";
···
      }:
      mkDerivation {
        pname = "optics";
-       version = "0.4.1";
-       sha256 = "068r2ldq5aysvs5gcd80xpvbmsw5vylc4x0rfsnm9k330q5vzlkx";
-       libraryHaskellDepends = [
-         array base containers mtl optics-core optics-extra optics-th
-         transformers
-       ];
-       testHaskellDepends = [
-         base containers indexed-profunctors inspection-testing mtl
-         optics-core QuickCheck random tasty tasty-hunit tasty-quickcheck
-         template-haskell
-       ];
-       benchmarkHaskellDepends = [
-         base bytestring containers lens tasty-bench transformers
-         unordered-containers vector
-       ];
-       description = "Optics as an abstract interface";
-       license = lib.licenses.bsd3;
-       maintainers = with lib.maintainers; [ maralorn ];
-     }) {};
-
-  "optics_0_4_2" = callPackage
-    ({ mkDerivation, array, base, bytestring, containers
-     , indexed-profunctors, inspection-testing, lens, mtl, optics-core
-     , optics-extra, optics-th, QuickCheck, random, tasty, tasty-bench
-     , tasty-hunit, tasty-quickcheck, template-haskell, transformers
-     , unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "optics";
        version = "0.4.2";
        sha256 = "1irk0m3194vmrqwm29p5gjwd8w7i5hmg1ikxfw11yjfk0hvmbrzb";
        libraryHaskellDepends = [
···
        ];
        description = "Optics as an abstract interface";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
···
      }:
      mkDerivation {
        pname = "optics-extra";
-       version = "0.4.1";
-       sha256 = "0xxsl4vkq77vnqi9s57d0kgsr4qj87zpad10ax0ywhvzzbvh98fg";
-       libraryHaskellDepends = [
-         array base bytestring containers hashable indexed-profunctors
-         indexed-traversable-instances mtl optics-core text transformers
-         unordered-containers vector
-       ];
-       description = "Extra utilities and instances for optics-core";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "optics-extra_0_4_2_1" = callPackage
-    ({ mkDerivation, array, base, bytestring, containers, hashable
-     , indexed-profunctors, indexed-traversable-instances, mtl
-     , optics-core, text, transformers, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "optics-extra";
        version = "0.4.2.1";
        sha256 = "0hfa5yb7l3l310lfxkii13fjzb69g619agadc5a86i734nisf8vy";
        libraryHaskellDepends = [
···
        ];
        description = "Extra utilities and instances for optics-core";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "optics-th" = callPackage
···
     ({ mkDerivation, base, containers, criterion, data-default, deepseq
      , directory, filepath, gitrev, hspec, microlens, microlens-mtl
      , microlens-th, mtl, open-browser, optparse-applicative, pandoc
-     , pandoc-types, roman-numerals, syb, template-haskell, temporary
-     , text, utility-ht
+     , pandoc-types, syb, template-haskell, temporary, text, utility-ht
      }:
      mkDerivation {
        pname = "pandoc-crossref";
-       version = "0.3.12.2";
-       sha256 = "1d2g4aggv47gv83p4382bcy1x97z0bs4nqww37ay92n9r4jh6m4l";
+       version = "0.3.13.0";
+       sha256 = "0fn5xrsh1x1rk74vd30yvg4ha9aicqbm7r1w0nrq9fkgcmz1q01x";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base containers data-default directory filepath microlens
-         microlens-mtl microlens-th mtl pandoc pandoc-types roman-numerals
-         syb template-haskell text utility-ht
+         microlens-mtl microlens-th mtl pandoc pandoc-types syb
+         template-haskell text utility-ht
        ];
        executableHaskellDepends = [
          base deepseq gitrev open-browser optparse-applicative pandoc
···
     ({ mkDerivation, base, containers, pandoc-types, relude, text }:
      mkDerivation {
        pname = "pandoc-link-context";
-       version = "1.2.0.0";
-       sha256 = "06yd4wp7v8p1z9jrg4rzcinkkdng94v2gpcs039brb7cb9qi4gpl";
+       version = "1.4.0.0";
+       sha256 = "002q0kdw3686s7yhsk1p8i6srz1wvs42pzvz7ajgnsdqcnyqh93g";
        libraryHaskellDepends = [
          base containers pandoc-types relude text
        ];
···
     ({ mkDerivation }:
      mkDerivation {
        pname = "pandora";
-       version = "0.5.5";
-       sha256 = "0kk9v6xl3ssfsnk0ng1ar9wm6qw7qln2qcilybldkp8dhy4fvmxq";
+       version = "0.5.6";
+       sha256 = "05x4ihcs6j380r9g5rh6afy9zadfnrlg9si8ia4aaa7kh2jc20p9";
        description = "A box of patterns and paradigms";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "pcre2";
-       version = "2.1.1";
-       sha256 = "07ls9vxj5l8wvrj75wvyrq6qsz7fz0pamx92ik50cpl71p76lc92";
+       version = "2.1.1.1";
+       sha256 = "1593grzraqpam646s08fi3wgwnaib3lcgyj5m7xqpbfrzyil8wsq";
+       libraryHaskellDepends = [
+         base containers microlens mtl template-haskell text
+       ];
+       testHaskellDepends = [
+         base containers hspec microlens microlens-platform mtl
+         template-haskell text
+       ];
+       benchmarkHaskellDepends = [
+         base containers criterion microlens microlens-platform mtl
+         pcre-light regex-pcre-builtin template-haskell text
+       ];
+       description = "Regular expressions via the PCRE2 C library (included)";
+       license = lib.licenses.asl20;
+     }) {};
+
+  "pcre2_2_2_1" = callPackage
+    ({ mkDerivation, base, containers, criterion, hspec, microlens
+     , microlens-platform, mtl, pcre-light, regex-pcre-builtin
+     , template-haskell, text
+     }:
+     mkDerivation {
+       pname = "pcre2";
+       version = "2.2.1";
+       sha256 = "0w08a4gzsll0wwwkn2abjvnrxd7y1irv627v4pc5ha4gsrlqd3fl";
        libraryHaskellDepends = [
          base containers microlens mtl template-haskell text
        ];
···
        ];
        description = "Regular expressions via the PCRE2 C library (included)";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "pdc" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "perf_0_10_0" = callPackage
+    ({ mkDerivation, attoparsec, base, box, box-csv, chart-svg
+     , containers, deepseq, formatn, gauge, mtl, numhask-space
+     , optics-core, optparse-applicative, rdtsc, recursion-schemes, text
+     , time, vector
+     }:
+     mkDerivation {
+       pname = "perf";
+       version = "0.10.0";
+       sha256 = "1igdghqn80dxgx182yb89zm685wi6xka7gjcwqws1bq8p36v7i5j";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         attoparsec base box box-csv chart-svg containers deepseq formatn
+         mtl numhask-space optics-core optparse-applicative rdtsc
+         recursion-schemes text time vector
+       ];
+       executableHaskellDepends = [
+         base containers deepseq formatn gauge mtl optparse-applicative text
+       ];
+       description = "Low-level run time measurement";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "perf-analysis" = callPackage
     ({ mkDerivation, base, containers, deepseq, optparse-generic, perf
      , protolude, readme-lhs, scientific, tdigest, text, text-format
···
        pname = "phatsort";
        version = "0.5.0.1";
        sha256 = "14czx4s3ywfcxbw8lr60i3cdk62rcfr7m1v98mx3qm1gjinll5js";
+       revision = "1";
+       editedCabalFile = "06s8xg07za1d23wai8pb7gvbcri2vmbv0jks7as8d8mf82giqvz8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "pipes-text";
-       version = "1.0.0";
-       sha256 = "0q01amm5813qpbkj9098mkd6h1a65vc864qjk2vgd4h80vx2a6mi";
+       version = "1.0.1";
+       sha256 = "1q91jsqlikrp2dj21nik5b3j8b1y996gy8rjkx8hlzrps11vrc2w";
        libraryHaskellDepends = [
          base bytestring pipes pipes-bytestring pipes-group pipes-parse
          pipes-safe streaming-commons text transformers
···
        pname = "poly-rec";
        version = "0.7.0.0";
        sha256 = "0ayaz87l2rgpm4ddc7bidss042xhfcwa3sk7685ypssqvp02k5r0";
+       revision = "2";
+       editedCabalFile = "12cgm587k27mmjkix58qs4ihdcx1axlkp17bq7f3fhw80j64imk7";
        libraryHaskellDepends = [ base requirements ];
        description = "Polykinded extensible records";
        license = lib.licenses.gpl3Only;
···
        libraryHaskellDepends = [ base glade glib gtk ];
        description = "A library for functional GUI development";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "props" = callPackage
···
        ];
        description = "Language support for the PureScript programming language";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "pseudo-boolean" = callPackage
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ cdepillabout ];
+       broken = true;
      }) {};
 
   "purescheme-wai-routing-core" = callPackage
···
        ];
        description = "PureScript Programming Language Abstract Syntax Tree";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "purescript-bridge" = callPackage
···
        libraryToolDepends = [ happy ];
        description = "PureScript Programming Language Concrete Syntax Tree";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "purescript-iso" = callPackage
···
        ];
        description = "TypeScript Declaration File (.d.ts) generator for PureScript";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "pursuit-client" = callPackage
···
 
   "radixtree" = callPackage
     ({ mkDerivation, attoparsec, base, containers, criterion, deepseq
-     , microlens, mtl, parsers, QuasiText, smallcheck, store, tasty
-     , tasty-smallcheck, text, vector
+     , ghc-compact, microlens, mtl, parsers, QuasiText, smallcheck
+     , tasty, tasty-smallcheck, text, vector
      }:
      mkDerivation {
        pname = "radixtree";
-       version = "0.4.0.0";
-       sha256 = "074s2gbprpq9qvipj8hayh906pdy1jfayph82hzamnwvz4199gmj";
+       version = "0.6.0.0";
+       sha256 = "0l6abb72r36ihzyjw5nsnf393qhaxsvi2732h4w4brs4jhqk85hz";
        libraryHaskellDepends = [
-         base containers deepseq microlens mtl parsers store text vector
+         base containers deepseq microlens mtl parsers text vector
        ];
        testHaskellDepends = [
          attoparsec base smallcheck tasty tasty-smallcheck text
        ];
        benchmarkHaskellDepends = [
-         attoparsec base criterion deepseq QuasiText text vector
+         attoparsec base criterion deepseq ghc-compact QuasiText text vector
        ];
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
   "rails-session" = callPackage
     ({ mkDerivation, base, base-compat, base16-bytestring
      , base64-bytestring, bytestring, containers, cryptonite, filepath
-     , http-types, pbkdf, ruby-marshal, semigroups, string-conv, tasty
-     , tasty-hspec, transformers, vector
+     , hspec, http-types, pbkdf, ruby-marshal, semigroups, string-conv
+     , tasty, tasty-hspec, transformers, vector
      }:
      mkDerivation {
        pname = "rails-session";
-       version = "0.1.2.0";
-       sha256 = "0r1jiy7x7497zk1gvg1zbpqx2vh2i0j9x7gzscgx6gylkjkkppir";
+       version = "0.1.3.0";
+       sha256 = "0fybpyg5si9rizifxdghilffvqmszm8h7w5v8b7xdmsw1i5gv56m";
        libraryHaskellDepends = [
          base base-compat base16-bytestring base64-bytestring bytestring
          containers cryptonite http-types pbkdf ruby-marshal string-conv
          vector
        ];
        testHaskellDepends = [
-         base bytestring filepath ruby-marshal semigroups tasty tasty-hspec
-         transformers vector
+         base bytestring filepath hspec ruby-marshal semigroups tasty
+         tasty-hspec transformers vector
        ];
        description = "Decrypt Ruby on Rails sessions in Haskell";
        license = lib.licenses.bsd3;
···
        pname = "random-source";
        version = "0.3.0.11";
        sha256 = "0lwqbd0h495srgi2p8fsmsfk5hv5m3f6cxm12j61xx94fdyn98sv";
-       revision = "1";
-       editedCabalFile = "1wh5acm2298bcp3r4zp7k77rrzynfgbs4s6jq6swml1p3p7yr7b9";
+       revision = "2";
+       editedCabalFile = "1bxw5mrrzyhd74jclgn1b6x78rsh301ys86m2jrkcy4zsxhaqr99";
        libraryHaskellDepends = [
          base flexible-defaults mersenne-random-pure64 mtl mwc-random
          primitive random stateref syb template-haskell th-extras
···
     ({ mkDerivation, base, doctest, typecheck-plugin-nat-simple }:
      mkDerivation {
        pname = "ranged-list";
-       version = "0.1.1.1";
-       sha256 = "0ky5jzp63565xc9qxq6717c5qbgcisgv9nadjfsqrcxwarp75i6y";
+       version = "0.1.2.0";
+       sha256 = "0ry2l6379g1q8y22hziqscsxv134k26a28aqvlxjyliqkx707b9i";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [ base typecheck-plugin-nat-simple ];
        testHaskellDepends = [ base doctest typecheck-plugin-nat-simple ];
···
        broken = true;
      }) {};
 
-  "rattletrap_11_2_9" = callPackage
+  "rattletrap_11_2_10" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, array, base, bytestring
      , containers, filepath, http-client, http-client-tls, text
      }:
      mkDerivation {
        pname = "rattletrap";
-       version = "11.2.9";
-       sha256 = "15afr7ncg7niwis44sr8pjlga08052gqz0bwg29zyy26kh8fll1l";
+       version = "11.2.10";
+       sha256 = "1iy0nkqpnwhscs98b277q6ykk7mph5a5ah8gqf4dxz58q7lwk47z";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "raw-feldspar";
-       version = "0.4";
-       sha256 = "1bx98zsykvfc72jaas3qzjm614dliij2bdvbm44fj0npd3zvbq0r";
+       version = "0.4.1";
+       sha256 = "04n6rhw6llgp4p53d8djwbs7qqk0yip5ml48sjx2ibswvz9ihdsb";
        libraryHaskellDepends = [
          array base constraints containers data-default-class data-hash
          imperative-edsl language-c-quote mtl operational-alacarte
···
      }:
      mkDerivation {
        pname = "rcu";
-       version = "0.2.5";
-       sha256 = "1p2cg6xy5cjdizqialv9y8qylwdri5fhby2xh04fnhpjapsrbc7l";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         atomic-primops base fail ghc-prim parallel primitive transformers
-       ];
-       executableHaskellDepends = [ base transformers ];
-       benchmarkHaskellDepends = [
-         base containers criterion deepseq ghc-prim optparse-applicative
-         primitive rdtsc time transformers
-       ];
-       description = "Read-Copy-Update for Haskell";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "rcu_0_2_6" = callPackage
-    ({ mkDerivation, atomic-primops, base, containers, criterion
-     , deepseq, fail, ghc-prim, optparse-applicative, parallel
-     , primitive, rdtsc, time, transformers
-     }:
-     mkDerivation {
-       pname = "rcu";
        version = "0.2.6";
        sha256 = "14kg45ycx5wa3k9xn7glp4kdy8xz119m4gs91114qx0rkbix2f5h";
        isLibrary = true;
···
        ];
        description = "Read-Copy-Update for Haskell";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "rdf" = callPackage
···
        pname = "reflex";
        version = "0.8.2.0";
        sha256 = "1hvagxcs413bqairxf77vp19484mxnbfckhd44wv22ncwfh5mq6d";
+       revision = "1";
+       editedCabalFile = "194c0y2asv8z64hxs6cppjrg0m1r3ipp9565aj6dac63dqf8j29l";
        libraryHaskellDepends = [
          base bifunctors comonad constraints constraints-extras containers
          data-default dependent-map dependent-sum exception-transformers
···
 
   "reflex-backend-socket" = callPackage
     ({ mkDerivation, base, bytestring, containers, lens, mtl, network
-     , reflex, reflex-basic-host, semialign, semigroupoids, stm, these
-     , witherable
+     , reflex, semialign, semigroupoids, stm, these, witherable
      }:
      mkDerivation {
        pname = "reflex-backend-socket";
-       version = "0.2.0.0";
-       sha256 = "111kmsvxb86aphw0ascjf7p7fd0bfxs3lmvqbnvxvj3rhh19bq6c";
-       revision = "1";
-       editedCabalFile = "11swzj7l0wmvdv72716rmlwcvcxkj44h3jbzwyhqn8q0f9ykfggx";
+       version = "0.2.0.1";
+       sha256 = "1p4rzhc4c8rk4c75hdxmzjpsmfvinnvmszqzmb9a4fpw55fdwy8z";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          these
        ];
        executableHaskellDepends = [
-         base bytestring containers lens network reflex reflex-basic-host
-         witherable
+         base bytestring containers lens network reflex witherable
        ];
        description = "Reflex bindings for TCP sockets";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "reflex-backend-wai" = callPackage
···
      }) {};
 
   "reflex-libtelnet" = callPackage
-    ({ mkDerivation, base, bytestring, data-default, dependent-map
-     , dependent-sum, dependent-sum-template, lens, libtelnet, reflex
+    ({ mkDerivation, base, bytestring, dependent-map, dependent-sum
+     , dependent-sum-template, libtelnet, reflex
      }:
      mkDerivation {
        pname = "reflex-libtelnet";
-       version = "0.1.0.0";
-       sha256 = "0abqbbbzgsq2sz1yx9cjl7cjfjaygcv4vc8hp6g4gk7744xdshz3";
+       version = "0.2.0.0";
+       sha256 = "0kwcd001lg9fadqf4zd6z9351qrlk74fk4i8cysgkmay59n2fy85";
        libraryHaskellDepends = [
-         base bytestring data-default dependent-map dependent-sum
-         dependent-sum-template lens libtelnet reflex
+         base bytestring dependent-map dependent-sum dependent-sum-template
+         libtelnet reflex
        ];
        description = "Reflex bindings for libtelnet";
        license = lib.licenses.gpl3Plus;
···
        pname = "regex-base";
        version = "0.94.0.2";
        sha256 = "1w9fxad1dwi040r3db9i2cjhhrl86p3hngj13ixbcnqgb27l16bv";
+       revision = "1";
+       editedCabalFile = "1k2gzjm7xz69f7zr08wh2wzb5dhb659cvimsvx0g9p8cf5f45x2g";
        libraryHaskellDepends = [ array base bytestring containers text ];
        description = "Common \"Text.Regex.*\" API for Regex matching";
        license = lib.licenses.bsd3;
···
        pname = "regex-compat";
        version = "0.95.2.1";
        sha256 = "0ivrdrcphrz3g6nr5wbsmfiv8i82caw0kf6z5qlmlq7xf9n3hywg";
-       revision = "1";
-       editedCabalFile = "1r9gvk0lifppydlns81zh8052941saaaahydvbcgnrz0jwn1di9j";
+       revision = "2";
+       editedCabalFile = "0ldqpdxikm17ydrkfmichflkdqdrkspv4r0qy3zbdgqf5033pj4n";
        libraryHaskellDepends = [ array base regex-base regex-posix ];
        description = "Replaces/enhances \"Text.Regex\"";
        license = lib.licenses.bsd3;
···
        pname = "regex-pcre";
        version = "0.95.0.0";
        sha256 = "0nn76q4bsjnxim0j0d01jifmh36as9jdpcvm001a851vvq86zb8n";
-       revision = "3";
-       editedCabalFile = "1mxy2y7dmv37hhsasm17x2mb9dhmzza13pc7jfrk77inpig78ib8";
+       revision = "4";
+       editedCabalFile = "07fqy6pj7zz2vqbj8y4s5npc7vk9ggzayiy31hy4ss91lys74d1j";
        libraryHaskellDepends = [
          array base bytestring containers regex-base
        ];
···
        pname = "regex-posix";
        version = "0.96.0.1";
        sha256 = "1715b57z67q4hg0jz44wkxrxi3v7n5iagw6gw48pf8hr34wpr0n7";
+       revision = "1";
+       editedCabalFile = "1x5xkfddn3llxk4fngqbd8njssrwb7jlp0a0jxfrgdivbava9fwx";
        libraryHaskellDepends = [
          array base bytestring containers regex-base
        ];
···
        pname = "regex-tdfa";
        version = "1.3.1.2";
        sha256 = "0qka53m4xirlb2cjzr68rhybm31i4x2f78b8724a0askvb4phyn4";
+       revision = "1";
+       editedCabalFile = "02hq7zymsybnmm9qmlsj7fdh02dch6001nm348ymabvlwjndxbwv";
        libraryHaskellDepends = [
          array base bytestring containers mtl parsec regex-base text
        ];
···
      }:
      mkDerivation {
        pname = "registry";
-       version = "0.3.0.3";
-       sha256 = "0bbpjy5rjlmgn2jpg4fdrl15p3149y2wp5ydzpi21mzp3w0clkrp";
+       version = "0.3.0.5";
+       sha256 = "0q2dk0hyq6rdnvvldic4xzp0c28ky5jv7p994qhfbra8a1qkr08z";
        libraryHaskellDepends = [
          base containers exceptions hashable mmorph mtl protolude resourcet
          semigroupoids semigroups template-haskell text transformers-base
···
      }:
      mkDerivation {
        pname = "registry-hedgehog";
-       version = "0.6.0.0";
-       sha256 = "12asg2cz72an1hgy7c853z7zz7zvw54z7wa4rvw0gzg0a2z3fh0m";
+       version = "0.7.0.0";
+       sha256 = "00k2qsiavi3l5ksgd9xh05lachvhhm7vp7z0cmsy6y5saz5l44hh";
        libraryHaskellDepends = [
          base containers hedgehog mmorph multimap protolude registry tasty
          tasty-discover tasty-hedgehog tasty-th template-haskell text
···
      }:
      mkDerivation {
        pname = "registry-messagepack";
-       version = "0.1.0.3";
-       sha256 = "0i49cic87jdkfalwbyry7c6f1828vd1n33nkdjmxa73w3vhjklf5";
+       version = "0.2.0.0";
+       sha256 = "0hkz80kbsmvlcvy4py1vwsr4z5blmkcp6b24ay9qzayqdjx03r2w";
        libraryHaskellDepends = [
          base containers msgpack protolude registry template-haskell text
          transformers vector
···
      }:
      mkDerivation {
        pname = "repline";
-       version = "0.4.0.0";
-       sha256 = "1dspwi28krinkxdd7waq4y6plz0dfmzz72885p9pcqp1r14qrhj3";
-       libraryHaskellDepends = [
-         base containers exceptions haskeline mtl process
-       ];
-       testHaskellDepends = [ base containers mtl process ];
-       description = "Haskeline wrapper for GHCi-like REPL interfaces";
-       license = lib.licenses.mit;
-     }) {};
-
-  "repline_0_4_2_0" = callPackage
-    ({ mkDerivation, base, containers, exceptions, haskeline, mtl
-     , process
-     }:
-     mkDerivation {
-       pname = "repline";
        version = "0.4.2.0";
        sha256 = "0nldn02yqqmrxkzwzrx3v6hkb4y2hch48jkcr2qrw1dl0vqv70b1";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base containers mtl process ];
        description = "Haskeline wrapper for GHCi-like REPL interfaces";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "repo-based-blog" = callPackage
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "requirements";
-       version = "0.7.0.0";
-       sha256 = "030vwfasxjdgdadcf5i68i3dc436dj6gi3ql4k8qh09yf8q1mm63";
+       version = "0.7.0.1";
+       sha256 = "0nikl4ga2jap95yf29z87wnazfhz7k272phjwajn1yk22shv308z";
        libraryHaskellDepends = [ base ];
        description = "Abstraction to manage user defined Type Errors";
        license = lib.licenses.gpl3Only;
···
     ({ mkDerivation, barbies, base, clash-ghc, clash-lib, clash-prelude
      , containers, ghc-typelits-extra, ghc-typelits-knownnat
      , ghc-typelits-natnormalise, lens, lift-type, monoidal-containers
-     , mtl, template-haskell, transformers
+     , mtl, template-haskell, th-orphans, transformers
      }:
      mkDerivation {
        pname = "retroclash-lib";
-       version = "0.1.2";
-       sha256 = "11f15nhxp8aaim6yrzlh33dilp2zywdfikgdii44q0mszmm9q0vr";
+       version = "0.1.2.1";
+       sha256 = "0xf1prvgh41iilghi5ilr5c490xxj9b0mk1xz9is6w0c34wcppr9";
        libraryHaskellDepends = [
          barbies base clash-ghc clash-lib clash-prelude containers
          ghc-typelits-extra ghc-typelits-knownnat ghc-typelits-natnormalise
-         lens lift-type monoidal-containers mtl template-haskell
+         lens lift-type monoidal-containers mtl template-haskell th-orphans
          transformers
        ];
        description = "Code shared across the code samples in the book \"Retrocomputing with Clash\"";
···
      }:
      mkDerivation {
        pname = "retry";
-       version = "0.9.2.0";
-       sha256 = "1w0mlv62hrx2bi25szycg180k3mz8r9rhy53ycq0kadb8h1sw5hy";
-       revision = "1";
-       editedCabalFile = "1ry3r4h7xfp9r0hc5wbxz4sy9vx46gyhfqpd0lnlsa8r2c4pvb79";
+       version = "0.9.2.1";
+       sha256 = "0x6aa0mrj7m68wrbnml6bv852xxy5992qc69c2v5ipbjli560ak5";
        libraryHaskellDepends = [
          base exceptions ghc-prim mtl mtl-compat random transformers
        ];
···
 
   "ruby-marshal" = callPackage
     ({ mkDerivation, base, bytestring, cereal, containers, fail, hspec
-     , mtl, string-conv, vector
+     , hspec-discover, mtl, string-conv, vector
      }:
      mkDerivation {
        pname = "ruby-marshal";
-       version = "0.2.0";
-       sha256 = "0cdw1m26hlpicd2wmk34zav4p4lxhnrj79s5vwqmqy9wkdj9ypdx";
+       version = "0.2.1";
+       sha256 = "18kdagf0lyghpaffzgw42ql1wrqkh13rfqjpj23i09i67pqrv3lk";
        libraryHaskellDepends = [
          base bytestring cereal containers fail mtl string-conv vector
        ];
        testHaskellDepends = [
          base bytestring cereal containers fail hspec mtl string-conv vector
        ];
+       testToolDepends = [ hspec-discover ];
        description = "Parse a subset of Ruby objects serialised with Marshal.dump.";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "rvar";
-       version = "0.3.0.0";
-       sha256 = "1lj30nl4a8fkjk88p3vdxcwwvgnqm14m8xikrx4lahh9xy6vybjn";
+       version = "0.3.0.1";
+       sha256 = "1wa5nxlsfm1la5s70xv3swrmidxy0h6kv9ilicwkls12gwdc2a95";
        libraryHaskellDepends = [
          base bytestring MonadPrompt mtl random transformers
        ];
···
      }:
      mkDerivation {
        pname = "safe-exceptions";
-       version = "0.1.7.2";
-       sha256 = "15a80s87f603w8l7fnaba2cyqx62042vvcidpjzyga2685wpyqv9";
+       version = "0.1.7.3";
+       sha256 = "1gxm61mccivrdz2qcfh5sim596nbrpapx0nli0bx7vx6z3c2ikli";
        libraryHaskellDepends = [ base deepseq exceptions transformers ];
        testHaskellDepends = [ base hspec transformers void ];
        description = "Safe, consistent, and easy exception handling";
···
        license = lib.licenses.mit;
      }) {};
 
-  "sbp_4_2_0" = callPackage
+  "sbp_4_3_0" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, array, base
      , base64-bytestring, basic-prelude, binary, binary-conduit
      , bytestring, cmdargs, conduit, conduit-extra, data-binary-ieee754
···
      }:
      mkDerivation {
        pname = "sbp";
-       version = "4.2.0";
-       sha256 = "1d9a9m41wfp3crsykdcmaki8kj1j7kdaq72l08wymkz3kqwakfr7";
+       version = "4.3.0";
+       sha256 = "0fr9pc4y5wmyvw3ybyl1r7ypqgz5ngki4i0qh8d6qdsqy1m0vckg";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "servant-openapi3";
-       version = "2.0.1.4";
-       sha256 = "1dlz5fsz7j5yrf6kps4j1mxlj4ww2q4szx5k6apawi06i8ibshh7";
-       revision = "2";
-       editedCabalFile = "1g8byg51brdpabn5kv1zpkzic84hg50w1dxs1hbkpxj5a26gbd07";
-       setupHaskellDepends = [ base Cabal cabal-doctest ];
-       libraryHaskellDepends = [
-         aeson aeson-pretty base base-compat bytestring hspec http-media
-         insert-ordered-containers lens openapi3 QuickCheck servant
-         singleton-bool text unordered-containers
-       ];
-       testHaskellDepends = [
-         aeson base base-compat directory doctest filepath hspec lens
-         lens-aeson openapi3 QuickCheck servant template-haskell text time
-         utf8-string vector
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "Generate a Swagger/OpenAPI/OAS 3.0 specification for your servant API.";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "servant-openapi3_2_0_1_5" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, base, base-compat, bytestring
-     , Cabal, cabal-doctest, directory, doctest, filepath, hspec
-     , hspec-discover, http-media, insert-ordered-containers, lens
-     , lens-aeson, openapi3, QuickCheck, servant, singleton-bool
-     , template-haskell, text, time, unordered-containers, utf8-string
-     , vector
-     }:
-     mkDerivation {
-       pname = "servant-openapi3";
        version = "2.0.1.5";
        sha256 = "0zcyqga4hbdyk34368108vv9vavzdhv26xphas7yppada2sshfay";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
···
        testToolDepends = [ hspec-discover ];
        description = "Generate a Swagger/OpenAPI/OAS 3.0 specification for your servant API.";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "servant-options" = callPackage
···
        maintainers = with lib.maintainers; [ psibi ];
      }) {};
 
+  "shakespeare_2_0_29" = callPackage
+    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
+     , containers, directory, exceptions, file-embed, ghc-prim, hspec
+     , HUnit, parsec, process, scientific, template-haskell, text
+     , th-lift, time, transformers, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "shakespeare";
+       version = "2.0.29";
+       sha256 = "016vkhn2g91cip5w06kh0z577s90sd768rmx044n4b5sa135c89j";
+       libraryHaskellDepends = [
+         aeson base blaze-html blaze-markup bytestring containers directory
+         exceptions file-embed ghc-prim parsec process scientific
+         template-haskell text th-lift time transformers
+         unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson base blaze-html blaze-markup bytestring containers directory
+         exceptions ghc-prim hspec HUnit parsec process template-haskell
+         text time transformers
+       ];
+       description = "A toolkit for making compile-time interpolated templates";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ psibi ];
+     }) {};
+
   "shakespeare-babel" = callPackage
     ({ mkDerivation, base, classy-prelude, data-default, directory
      , process, shakespeare, template-haskell
···
        ];
        description = "Spreadsheet type for composite";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "shelduck" = callPackage
···
        pname = "shelly";
        version = "1.10.0";
        sha256 = "0hgzh0rrhipir8378civ5mwvkvcsd063jm2pyx8dqngdynph0h65";
+       revision = "1";
+       editedCabalFile = "07c1rjwvg2ldam6yaksvrr9f703b7d1rcw0482ns5yi2f7y1kczp";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        executableHaskellDepends = [ base glade gtk random ];
        description = "A simple gtk based Russian Roulette game";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "shower" = callPackage
···
        broken = true;
      }) {};
 
+  "simfin" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, Chart, Chart-diagrams
+     , composition-extra, containers, exceptions, http-client
+     , http-client-tls, http-types, multi-containers, SVGFonts, tasty
+     , tasty-hunit, text, time, unordered-containers, utf8-string
+     }:
+     mkDerivation {
+       pname = "simfin";
+       version = "1.0.0";
+       sha256 = "1axrwkxa93igwr737xi98cni5s99kd29hxn3y7xbvh89wri7xcza";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring composition-extra exceptions http-client
+         http-client-tls http-types text time unordered-containers
+         utf8-string
+       ];
+       executableHaskellDepends = [
+         base Chart Chart-diagrams containers multi-containers SVGFonts text
+         time
+       ];
+       testHaskellDepends = [ aeson base tasty tasty-hunit text ];
+       description = "A library to fetch and parse financial data from the SimFin(+) API";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "simgi" = callPackage
     ({ mkDerivation, base, containers, haskell98
      , mersenne-random-pure64, mtl, parsec, random
···
      }:
      mkDerivation {
        pname = "simple-cmd";
-       version = "0.2.5";
-       sha256 = "151js143l6b5rg6llvmcy1hcg80cmbp50ydrjhyfjqj32a1ygrsz";
-       libraryHaskellDepends = [
-         base directory extra filepath process time unix
-       ];
-       testHaskellDepends = [ base hspec ];
-       description = "Simple String-based process commands";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "simple-cmd_0_2_6" = callPackage
-    ({ mkDerivation, base, directory, extra, filepath, hspec, process
-     , time, unix
-     }:
-     mkDerivation {
-       pname = "simple-cmd";
        version = "0.2.6";
        sha256 = "0x5r4i1ckswrs0060blr6zx1n8zbdqc977nq9n5gmwcfznsrhc67";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base hspec ];
        description = "Simple String-based process commands";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "simple-cmd-args" = callPackage
···
   "sindre" = callPackage
     ({ mkDerivation, array, attoparsec, base, bytestring, containers
      , libXft, mtl, parsec, permute, process, regex-pcre, setlocale
-     , text, unix, utf8-string, X11, X11-rm, x11-xim, X11-xshape
+     , text, unix, utf8-string, X11, X11-rm, x11-xim, X11-xshape, xext
      }:
      mkDerivation {
        pname = "sindre";
-       version = "0.4";
-       sha256 = "0p76rsk02p6rw51ppbr3j7ydk57k34684qf50nrz5qd0jrnapjm2";
+       version = "0.6";
+       sha256 = "0pp000cabdjphgb0panyg9nw0zgfzklkg4ink8swyxcix3r84mj9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          process regex-pcre setlocale text unix utf8-string X11 X11-rm
          x11-xim X11-xshape
        ];
-       libraryPkgconfigDepends = [ libXft ];
+       libraryPkgconfigDepends = [ libXft xext ];
        executableHaskellDepends = [
          array attoparsec base bytestring containers mtl parsec permute
          process regex-pcre setlocale text unix utf8-string X11 X11-rm
          x11-xim X11-xshape
        ];
-       executablePkgconfigDepends = [ libXft ];
+       executablePkgconfigDepends = [ libXft xext ];
        description = "A programming language for simple GUIs";
        license = lib.licenses.bsd3;
-     }) {inherit (pkgs.xorg) libXft;};
+     }) {inherit (pkgs.xorg) libXft; xext = null;};
 
   "single-tuple" = callPackage
     ({ mkDerivation, base, ghc-prim, hspec, hspec-discover, OneTuple
···
        pname = "singletons-th";
        version = "3.0";
        sha256 = "1c0w7sg0lbpizrzns4g55wxsk5jm8wlqw0w9rz4jzqwy15byb572";
+       revision = "1";
+       editedCabalFile = "11mmccdqxplqz7mp1brxpr9hqnkqkhbwnp32mihz4ird0k8gwqij";
        libraryHaskellDepends = [
          base containers ghc-boot-th mtl singletons syb template-haskell
          th-desugar th-orphans transformers
···
        pname = "singletons-th";
        version = "3.1";
        sha256 = "1mhx7sadw7zxaf7qhryrhi4fiyf9v3jcaplkh1syaa7b4725dm7a";
-       revision = "1";
-       editedCabalFile = "1mir0m8zpnq5ckkk073nxy32mghfkbdzncvxpjdpmv2yfxl9iwgi";
+       revision = "2";
+       editedCabalFile = "19ac6s4k6yv0lfrhkmgpf000k32rpm91lngs4955158792pa6fi6";
        libraryHaskellDepends = [
          base containers ghc-boot-th mtl singletons syb template-haskell
          th-desugar th-orphans transformers
···
      }:
      mkDerivation {
        pname = "skylighting";
-       version = "0.12.3";
-       sha256 = "04asis41pwr395246rnhg7xaxi0mwal14sv3x7rzhbs4cb9ycsqi";
-       configureFlags = [ "-fexecutable" ];
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base binary containers skylighting-core
-       ];
-       executableHaskellDepends = [
-         base blaze-html bytestring containers pretty-show text
-       ];
-       description = "syntax highlighting library";
-       license = lib.licenses.gpl2Only;
-     }) {};
-
-  "skylighting_0_12_3_1" = callPackage
-    ({ mkDerivation, base, binary, blaze-html, bytestring, containers
-     , pretty-show, skylighting-core, text
-     }:
-     mkDerivation {
-       pname = "skylighting";
        version = "0.12.3.1";
        sha256 = "08wml20cphj5idv5f20cz0jx7n8f037gy7x5axak83sbd98k71nw";
        configureFlags = [ "-fexecutable" ];
···
        ];
        description = "syntax highlighting library";
        license = lib.licenses.gpl2Only;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "skylighting-core" = callPackage
···
      }:
      mkDerivation {
        pname = "skylighting-core";
-       version = "0.12.3";
-       sha256 = "0pv84asvpvanxxalqsxij6hymd0nv5zcpdysj35880api5k28l0w";
-       revision = "1";
-       editedCabalFile = "0hc6w1bi9s4gxh5ypqhh6lgrcwv3c8xcmjsg8k9p47mmrdsa0ski";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson ansi-terminal attoparsec base base64-bytestring binary
-         blaze-html bytestring case-insensitive colour containers directory
-         filepath mtl safe text transformers utf8-string xml-conduit
-       ];
-       testHaskellDepends = [
-         aeson base bytestring containers Diff directory filepath
-         pretty-show QuickCheck tasty tasty-golden tasty-hunit
-         tasty-quickcheck text
-       ];
-       benchmarkHaskellDepends = [
-         base containers criterion directory filepath text
-       ];
-       description = "syntax highlighting library";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "skylighting-core_0_12_3_1" = callPackage
-    ({ mkDerivation, aeson, ansi-terminal, attoparsec, base
-     , base64-bytestring, binary, blaze-html, bytestring
-     , case-insensitive, colour, containers, criterion, Diff, directory
-     , filepath, mtl, pretty-show, QuickCheck, safe, tasty, tasty-golden
-     , tasty-hunit, tasty-quickcheck, text, transformers, utf8-string
-     , xml-conduit
-     }:
-     mkDerivation {
-       pname = "skylighting-core";
        version = "0.12.3.1";
        sha256 = "08svbbfw27zhlblglagxqvsppkdfibqjnx331jdbfrlj0a9pi5h8";
        isLibrary = true;
···
        ];
        description = "syntax highlighting library";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "skylighting-extensions" = callPackage
···
     ({ mkDerivation, base, containers, lucid, skylighting-core, text }:
      mkDerivation {
        pname = "skylighting-lucid";
-       version = "1.0.1";
-       sha256 = "0igimymq8pcizl4wdmyjafjgdw8xi2059jzmcw64ij18rn6bip8d";
+       version = "1.0.2";
+       sha256 = "06gvc5d23aiah5yq4b9gks7x26iz6xcx0k4mfsmjv5v2ic2zrbzb";
        libraryHaskellDepends = [
          base containers lucid skylighting-core text
        ];
···
        license = lib.licenses.gpl3Only;
      }) {};
 
+  "sparse-merkle-trees" = callPackage
+    ({ mkDerivation, base, bytestring, containers, criterion
+     , cryptonite, deepseq, memory, QuickCheck, smallcheck, tasty
+     , tasty-hunit, tasty-quickcheck, tasty-smallcheck
+     }:
+     mkDerivation {
+       pname = "sparse-merkle-trees";
+       version = "0.2.0.0";
+       sha256 = "0jcysnm95kv7xw36yi02n2jp3xrbyp1g3pr141hj5zkc90ng5ds7";
+       libraryHaskellDepends = [
+         base bytestring containers cryptonite memory
+       ];
+       testHaskellDepends = [
+         base bytestring containers cryptonite memory smallcheck tasty
+         tasty-hunit tasty-quickcheck tasty-smallcheck
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring containers criterion cryptonite deepseq memory
+         QuickCheck
+       ];
+       description = "Sparse Merkle trees with proofs of inclusion and exclusion";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "sparse-tensor" = callPackage
     ({ mkDerivation, ad, base, bytestring, Cabal, cereal, containers
      , deepseq, ghc-typelits-knownnat, ghc-typelits-natnormalise
···
      }:
      mkDerivation {
        pname = "stache";
-       version = "2.3.1";
-       sha256 = "1a26pwg6y90588yf9sp18w4b2ahr64fxdhy1c3zv0c9pw7bv6k6q";
-       revision = "3";
-       editedCabalFile = "1di10cbxg1xkj1fwimdfqhspk084xg2a1wvff3i2q336xa6jbqfl";
+       version = "2.3.2";
+       sha256 = "1ya9hnxvwqh1qhlci7aqpbj9abmsi2n13251b8nffmpvlpls6lk8";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "storable-offset" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "storable-offset";
+       version = "0.1.0.0";
+       sha256 = "0m0qmnnb07vhzs1ds7h4cfhba4rzb3abpijk8vjwncanfgg2g4pj";
+       libraryHaskellDepends = [ base ];
+       description = "Storable offsets for record fields";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "storable-record" = callPackage
     ({ mkDerivation, base, QuickCheck, semigroups, transformers
      , utility-ht
···
      }:
      mkDerivation {
        pname = "streaming-bytestring";
-       version = "0.2.1";
-       sha256 = "1yri2g0wx2fila25ang04nsv4i12b4yhwqwcfkkpx1sz8fhzibxy";
-       libraryHaskellDepends = [
-         base bytestring deepseq exceptions ghc-prim mmorph mtl resourcet
-         streaming transformers transformers-base
-       ];
-       testHaskellDepends = [
-         base bytestring resourcet smallcheck streaming tasty tasty-hunit
-         tasty-smallcheck transformers
-       ];
-       description = "Fast, effectful byte streams";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "streaming-bytestring_0_2_2" = callPackage
-    ({ mkDerivation, base, bytestring, deepseq, exceptions, ghc-prim
-     , mmorph, mtl, resourcet, smallcheck, streaming, tasty, tasty-hunit
-     , tasty-smallcheck, transformers, transformers-base
-     }:
-     mkDerivation {
-       pname = "streaming-bytestring";
        version = "0.2.2";
        sha256 = "01iw8d3lxb72cv6gp6k8w966g9q485zmd5akri2x1n5xdd26lv9h";
        libraryHaskellDepends = [
···
        ];
        description = "Fast, effectful byte streams";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "streaming-cassava" = callPackage
···
      }:
      mkDerivation {
        pname = "streamt";
-       version = "0.5.0.0";
-       sha256 = "0r2r6ribk85hwmzdn2imgajb28q5d5gbhysr62bw2jhmd5xy7985";
-       libraryHaskellDepends = [ base logict mtl ];
-       testHaskellDepends = [
-         async base criterion hspec mtl tasty tasty-hunit
-       ];
-       description = "Simple, Fair and Terminating Backtracking Monad Transformer";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "streamt_0_5_0_1" = callPackage
-    ({ mkDerivation, async, base, criterion, hspec, logict, mtl, tasty
-     , tasty-hunit
-     }:
-     mkDerivation {
-       pname = "streamt";
        version = "0.5.0.1";
        sha256 = "0adbn5kh2wqgvwzjgrhcd94abch7if6qz26ihpbm4igwbmwirzgw";
        libraryHaskellDepends = [ base logict mtl ];
···
        ];
        description = "Simple, Fair and Terminating Backtracking Monad Transformer";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "strelka" = callPackage
···
      }:
      mkDerivation {
        pname = "string-interpolate";
-       version = "0.3.1.1";
-       sha256 = "0hhzvrs9msyqsxwsqqm55lyxf85vhg4vcsszl735zsbs7431av69";
-       revision = "3";
-       editedCabalFile = "0kpk5mwmi7qzvx0hkiq6pwfyid99ic95zmxc36xxfpw4qxfc7024";
-       libraryHaskellDepends = [
-         base bytestring haskell-src-exts haskell-src-meta split
-         template-haskell text text-conversions utf8-string
-       ];
-       testHaskellDepends = [
-         base bytestring hspec hspec-core QuickCheck quickcheck-instances
-         quickcheck-text quickcheck-unicode template-haskell text
-         unordered-containers
-       ];
-       benchmarkHaskellDepends = [
-         base bytestring criterion deepseq formatting interpolate
-         neat-interpolation QuickCheck text
-       ];
-       description = "Haskell string/text/bytestring interpolation that just works";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "string-interpolate_0_3_1_2" = callPackage
-    ({ mkDerivation, base, bytestring, criterion, deepseq, formatting
-     , haskell-src-exts, haskell-src-meta, hspec, hspec-core
-     , interpolate, neat-interpolation, QuickCheck, quickcheck-instances
-     , quickcheck-text, quickcheck-unicode, split, template-haskell
-     , text, text-conversions, unordered-containers, utf8-string
-     }:
-     mkDerivation {
-       pname = "string-interpolate";
        version = "0.3.1.2";
        sha256 = "0gmph9mikqq8hch9wjyyx6dxfxwhmdfrwsrxkvbk7i24lvi19hhp";
        libraryHaskellDepends = [
···
        ];
        description = "Haskell string/text/bytestring interpolation that just works";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "string-interpreter" = callPackage
···
      }:
      mkDerivation {
        pname = "syntactic";
-       version = "3.8.3";
-       sha256 = "1ksznzw5g01xgbr2zs83m0lclbhvhs6lyaszhxykni10lxyxy7v8";
+       version = "3.8.4";
+       sha256 = "13hsv7yr35jaimag4v0c0l56clcdcny4b1m0q6h83qcidcrqxcfc";
        libraryHaskellDepends = [
          base constraints containers data-hash deepseq mtl syb
          template-haskell tree-view
···
        pname = "talash";
        version = "0.1.1.1";
        sha256 = "0sa4ay2dc4srh5wbk72iznjwr5bjjhggafhf27zyyxjhnjvfgsq1";
+       revision = "1";
+       editedCabalFile = "0p635l2dr0wdfmqpx85wd6x2wq7n50m2n59rjin9fk1jg9qd869m";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "taskwarrior";
        version = "0.6.0.2";
        sha256 = "16m4578ybwawiza4fg8gc6ndfc8hpvdkh5bv3ghamwpqyw0aq766";
+       revision = "1";
+       editedCabalFile = "10yyjis1crs60h00z0nlrq8p4hqzafjjn63fqnwf7wjq1yqmg5h5";
        libraryHaskellDepends = [
          aeson base bytestring containers process random text time uuid
        ];
···
      }) {};
 
   "tasty-discover" = callPackage
-    ({ mkDerivation, base, containers, directory, filepath, Glob
-     , hedgehog, tasty, tasty-hedgehog, tasty-hspec, tasty-hunit
-     , tasty-quickcheck, tasty-smallcheck
+    ({ mkDerivation, base, bytestring, containers, directory, filepath
+     , Glob, hedgehog, hspec, hspec-core, tasty, tasty-golden
+     , tasty-hedgehog, tasty-hspec, tasty-hunit, tasty-quickcheck
+     , tasty-smallcheck
      }:
      mkDerivation {
        pname = "tasty-discover";
-       version = "4.2.2";
-       sha256 = "1j95njl3ml7cfxnwv0i17ijca84fgyrjs2cfw4g5yh1m4x2zvg34";
+       version = "4.2.4";
+       sha256 = "1v6ndsvz9f04gv3m41a2yqprpa7xz8d00vkws25a9n7b7h3wvj4x";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base containers directory filepath Glob
+         base containers directory filepath Glob tasty
        ];
        executableHaskellDepends = [
          base containers directory filepath Glob
        ];
        testHaskellDepends = [
-         base containers directory filepath Glob hedgehog tasty
-         tasty-hedgehog tasty-hspec tasty-hunit tasty-quickcheck
-         tasty-smallcheck
+         base bytestring containers directory filepath Glob hedgehog hspec
+         hspec-core tasty tasty-golden tasty-hedgehog tasty-hspec
+         tasty-hunit tasty-quickcheck tasty-smallcheck
        ];
        description = "Test discovery for the tasty framework";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "tasty-hspec";
-       version = "1.2";
-       sha256 = "0hnq6q4mk2avirb8cgibaxj5m2c4rf5xsqry04zx4nc15la5xniw";
-       revision = "2";
-       editedCabalFile = "0a97zm7lxc7m0qw3i3grwzdmbpar5bf2cj31ip37mh9w1x2nzqvx";
-       libraryHaskellDepends = [
-         base hspec hspec-core QuickCheck tasty tasty-quickcheck
-         tasty-smallcheck
-       ];
-       description = "Hspec support for the Tasty test framework";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "tasty-hspec_1_2_0_1" = callPackage
-    ({ mkDerivation, base, hspec, hspec-core, QuickCheck, tasty
-     , tasty-quickcheck, tasty-smallcheck
-     }:
-     mkDerivation {
-       pname = "tasty-hspec";
        version = "1.2.0.1";
        sha256 = "0ibl2xi6mmqad2mriz67nb7pjwwvjik385amp24j9kc7a7zkx091";
        libraryHaskellDepends = [
···
        ];
        description = "Hspec support for the Tasty test framework";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "tasty-html" = callPackage
···
      }:
      mkDerivation {
        pname = "tasty-inspection-testing";
-       version = "0.1";
-       sha256 = "18awafrclxg8lfw8gg4ndzfwwpaz8qmad23fi24rhpdj9c7xdyhw";
+       version = "0.1.0.1";
+       sha256 = "0p46w44f19w7lvdzyg3vq6qzix0rjp8p23ilxz82dviq38lgmifp";
        libraryHaskellDepends = [
          base ghc inspection-testing tasty template-haskell
        ];
···
        pname = "tdigest";
        version = "0.2.1.1";
        sha256 = "1dvkf7cs8dcr13wza5iyq2qgvz75r33mzgfmhdihw62xzxsqb6d3";
-       revision = "2";
-       editedCabalFile = "0hcsjdd8km8dhydg4npc6mw6yy6bhv4f21zvm8is8h0ci4057asy";
+       revision = "3";
+       editedCabalFile = "0a39vwf37hkh06rn79blr3bw7ij05pgpxrkc9cldgdd5p4gvn1qn";
        libraryHaskellDepends = [
          base base-compat binary deepseq reducers semigroupoids transformers
          vector vector-algorithms
···
        license = lib.licenses.mit;
      }) {};
 
-  "text-builder-dev_0_3_1" = callPackage
+  "text-builder-dev_0_3_2" = callPackage
     ({ mkDerivation, base, bytestring, criterion, deferred-folds
      , QuickCheck, quickcheck-instances, rerebase, split, tasty
      , tasty-hunit, tasty-quickcheck, text, transformers
      }:
      mkDerivation {
        pname = "text-builder-dev";
-       version = "0.3.1";
-       sha256 = "18ipiiqrr0hz0yl7lqv2y730vl6mzqp0jg1yir097gp53ky6hzyw";
+       version = "0.3.2";
+       sha256 = "0x77y8vrsxdrmx2d6y8wxw7qmdnxdjh4rzbs3lwmharxvrqdwnxs";
        libraryHaskellDepends = [
          base bytestring deferred-folds split text transformers
        ];
···
        description = "Edge of developments for \"text-builder\"";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "text-builder-linear" = callPackage
+    ({ mkDerivation, base, bytestring, quote-quot, tasty, tasty-bench
+     , tasty-quickcheck, text
+     }:
+     mkDerivation {
+       pname = "text-builder-linear";
+       version = "0.1";
+       sha256 = "0smhph72l0wzri8rn30sq46f53ghs6srib34w8m7350rksdwm3fc";
+       libraryHaskellDepends = [ base bytestring quote-quot text ];
+       testHaskellDepends = [ base tasty tasty-quickcheck text ];
+       benchmarkHaskellDepends = [ base tasty tasty-bench text ];
+       description = "Builder for Text based on linear types";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "text-containers" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "text-rope_0_2" = callPackage
+    ({ mkDerivation, base, deepseq, random, tasty, tasty-bench
+     , tasty-quickcheck, text, vector
+     }:
+     mkDerivation {
+       pname = "text-rope";
+       version = "0.2";
+       sha256 = "12z7radm15mlfz5nrpii2dkjkiis05a88x923jipbhwwbs2j4i5i";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [ base deepseq text vector ];
+       testHaskellDepends = [ base tasty tasty-quickcheck text ];
+       benchmarkHaskellDepends = [ base random tasty-bench text ];
+       description = "Text lines and ropes";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "text-short" = callPackage
     ({ mkDerivation, base, binary, bytestring, deepseq, ghc-prim
      , hashable, tasty, tasty-hunit, tasty-quickcheck, template-haskell
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "text-show_3_9_7" = callPackage
+    ({ mkDerivation, array, base, base-compat-batteries, base-orphans
+     , bifunctors, bytestring, bytestring-builder, containers, criterion
+     , deepseq, deriving-compat, generic-deriving, ghc-boot-th, ghc-prim
+     , hspec, hspec-discover, QuickCheck, quickcheck-instances
+     , template-haskell, text, th-abstraction, th-lift, transformers
+     , transformers-compat
+     }:
+     mkDerivation {
+       pname = "text-show";
+       version = "3.9.7";
+       sha256 = "1zc47qh38jmg19fdki9isjcq4v115w2q61dnmxkypahhgiaqgkb3";
+       libraryHaskellDepends = [
+         array base base-compat-batteries bifunctors bytestring
+         bytestring-builder containers generic-deriving ghc-boot-th ghc-prim
+         template-haskell text th-abstraction th-lift transformers
+         transformers-compat
+       ];
+       testHaskellDepends = [
+         array base base-compat-batteries base-orphans bytestring
+         bytestring-builder deriving-compat generic-deriving ghc-prim hspec
+         QuickCheck quickcheck-instances template-haskell text transformers
+         transformers-compat
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [ base criterion deepseq ghc-prim text ];
+       description = "Efficient conversion of values into Text";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "text-show-instances" = callPackage
     ({ mkDerivation, base, base-compat-batteries, bifunctors, binary
      , containers, directory, generic-deriving, ghc-boot-th, ghc-prim
···
        testToolDepends = [ hspec-discover ];
        description = "Additional instances for text-show";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "text-show-instances_3_9" = callPackage
+    ({ mkDerivation, base, base-compat-batteries, bifunctors, binary
+     , containers, directory, generic-deriving, ghc-boot-th, ghc-prim
+     , haskeline, hpc, hspec, hspec-discover, old-locale, old-time
+     , pretty, QuickCheck, quickcheck-instances, random, scientific
+     , semigroups, tagged, template-haskell, terminfo, text, text-short
+     , text-show, th-orphans, time, transformers, transformers-compat
+     , unix, unordered-containers, vector, xhtml
+     }:
+     mkDerivation {
+       pname = "text-show-instances";
+       version = "3.9";
+       sha256 = "1bfangk4ys6pvhrv3j7i2c29xnhgin5lma2ndw051hnmmc7v2j7l";
+       libraryHaskellDepends = [
+         base base-compat-batteries bifunctors binary containers directory
+         ghc-boot-th haskeline hpc old-locale old-time pretty random
+         scientific semigroups tagged template-haskell terminfo text
+         text-short text-show time transformers transformers-compat unix
+         unordered-containers vector xhtml
+       ];
+       testHaskellDepends = [
+         base base-compat-batteries bifunctors binary containers directory
+         generic-deriving ghc-boot-th ghc-prim haskeline hpc hspec
+         old-locale old-time pretty QuickCheck quickcheck-instances random
+         scientific tagged template-haskell terminfo text-short text-show
+         th-orphans time transformers transformers-compat unix
+         unordered-containers vector xhtml
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Additional instances for text-show";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "text-stream-decode" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "th-desugar_1_13" = callPackage
+  "th-desugar_1_13_1" = callPackage
     ({ mkDerivation, base, containers, ghc-prim, hspec, HUnit, mtl
      , ordered-containers, syb, template-haskell, th-abstraction
      , th-lift, th-orphans, transformers-compat
      }:
      mkDerivation {
        pname = "th-desugar";
-       version = "1.13";
-       sha256 = "03jmvlgb7h7dn5dvlb0ryy7zjvdmyp5280cbkyrvfpjw0g5c9k24";
-       revision = "1";
-       editedCabalFile = "1xizqmh5zj85493bnfbd2m9vd6n5cp7hlcyddwap4h0jf2r06qk5";
+       version = "1.13.1";
+       sha256 = "03k2kfbzfc87kibzbpp3s1l5xb0ww2vvwj9ngh0qapxm28a01rz3";
        libraryHaskellDepends = [
          base containers ghc-prim mtl ordered-containers syb
          template-haskell th-abstraction th-lift th-orphans
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "th-env_0_1_1" = callPackage
+    ({ mkDerivation, base, markdown-unlit, template-haskell, th-compat
+     }:
+     mkDerivation {
+       pname = "th-env";
+       version = "0.1.1";
+       sha256 = "01gmycna12sg2f0zslhjnjx8s86shsvmw5jpw5n5z93bvxkb20gw";
+       libraryHaskellDepends = [ base template-haskell th-compat ];
+       testHaskellDepends = [ base markdown-unlit ];
+       testToolDepends = [ markdown-unlit ];
+       description = "Template Haskell splices that expand to an environment variable";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "th-expand-syns" = callPackage
     ({ mkDerivation, base, containers, syb, template-haskell
      , th-abstraction
···
 
   "th-orphans" = callPackage
     ({ mkDerivation, base, bytestring, ghc-prim, hspec, hspec-discover
-     , mtl, template-haskell, th-compat, th-expand-syns, th-lift
-     , th-lift-instances, th-reify-many
-     }:
-     mkDerivation {
-       pname = "th-orphans";
-       version = "0.13.12";
-       sha256 = "03n6qxnpxhbzyzbyrjq77d1y62dwgx39mmxfwmnc04l8pawgrxxz";
-       revision = "2";
-       editedCabalFile = "15660jac7m705jp6nm5lia51ifchbjrr6x3kj5sfij9dbj1f5dkj";
-       libraryHaskellDepends = [
-         base mtl template-haskell th-compat th-expand-syns th-lift
-         th-lift-instances th-reify-many
-       ];
-       testHaskellDepends = [
-         base bytestring ghc-prim hspec template-haskell th-lift
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "Orphan instances for TH datatypes";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "th-orphans_0_13_13" = callPackage
-    ({ mkDerivation, base, bytestring, ghc-prim, hspec, hspec-discover
      , mtl, template-haskell, th-compat, th-lift, th-lift-instances
      , th-reify-many
      }:
···
        testToolDepends = [ hspec-discover ];
        description = "Orphan instances for TH datatypes";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "th-pprint" = callPackage
···
        pname = "th-printf";
        version = "0.7";
        sha256 = "1f9lw0scm2bpnhmhgvywzphxn85ln3xcn8cjyvy8h4cn2ymw4aza";
+       revision = "1";
+       editedCabalFile = "0q9b8xv6qf8yg5c6rn1jgmgwr4ckf4yzd9qv9ysr3c363cgnccyv";
        libraryHaskellDepends = [
          base charset containers dlist integer-logarithms microlens-platform
          mtl parsec semigroups template-haskell text th-lift transformers
···
        pname = "trackit";
        version = "0.7.2";
        sha256 = "1ha28wdc4dabr9qxkbpg9fasfnplicb2pyrn9zmija204nigbcdj";
-       revision = "2";
-       editedCabalFile = "0dinhqmnm23rwg9xd056idbd7351bzbyik4k708h8xlw3pgq62i9";
+       revision = "3";
+       editedCabalFile = "07ak29br452qssj5kik8izmny24qw1icz84dq82b5g6xhy31vdrf";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "ulid";
-       version = "0.3.0.0";
-       sha256 = "1ghdh18cngwksr1vlqgdh04asm4gcivcpzhizaf6d4z9sl9qz5mp";
+       version = "0.3.2.0";
+       sha256 = "1zhw1n5pqmb74b4120vcg4bdpdl78qwmc3j0815c7h9s9q8kik87";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "unbound-generics";
-       version = "0.4.1";
-       sha256 = "02wwn78fccb37lx95jvr0v2n55kv35nilllb0gj75y8bplya5blb";
-       libraryHaskellDepends = [
-         ansi-wl-pprint base containers contravariant deepseq exceptions mtl
-         profunctors template-haskell transformers transformers-compat
-       ];
-       testHaskellDepends = [
-         base mtl QuickCheck tasty tasty-hunit tasty-quickcheck
-       ];
-       benchmarkHaskellDepends = [ base criterion deepseq ];
-       description = "Support for programming with names and binders using GHC Generics";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "unbound-generics_0_4_2" = callPackage
-    ({ mkDerivation, ansi-wl-pprint, base, containers, contravariant
-     , criterion, deepseq, exceptions, mtl, profunctors, QuickCheck
-     , tasty, tasty-hunit, tasty-quickcheck, template-haskell
-     , transformers, transformers-compat
-     }:
-     mkDerivation {
-       pname = "unbound-generics";
        version = "0.4.2";
        sha256 = "1pbpcvkkn360l0f5m7q5piyagvxznghknzjpxc7znb35i3xqywl1";
        libraryHaskellDepends = [
···
        benchmarkHaskellDepends = [ base criterion deepseq ];
        description = "Support for programming with names and binders using GHC Generics";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "unbound-kind-generics" = callPackage
···
      }:
      mkDerivation {
        pname = "unicode-collation";
-       version = "0.1.3.1";
-       sha256 = "1b04ml07ghfsh9cmp6b0l8c6ywxrn3c4xs7swvlmxx64asmicf3i";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base binary bytestring containers parsec template-haskell text
-         th-lift-instances
-       ];
-       testHaskellDepends = [
-         base bytestring tasty tasty-hunit tasty-quickcheck text
-         unicode-transforms
-       ];
-       benchmarkHaskellDepends = [
-         base QuickCheck quickcheck-instances tasty-bench text text-icu
-       ];
-       description = "Haskell implementation of the Unicode Collation Algorithm";
-       license = lib.licenses.bsd2;
-     }) {};
-
-  "unicode-collation_0_1_3_2" = callPackage
-    ({ mkDerivation, base, binary, bytestring, containers, parsec
-     , QuickCheck, quickcheck-instances, tasty, tasty-bench, tasty-hunit
-     , tasty-quickcheck, template-haskell, text, text-icu
-     , th-lift-instances, unicode-transforms
-     }:
-     mkDerivation {
-       pname = "unicode-collation";
        version = "0.1.3.2";
        sha256 = "0rnb22h8w42c74l0jl5ygzh4pkpw3x8d9ayrvgapkfx844i9am7c";
        isLibrary = true;
···
        ];
        description = "Haskell implementation of the Unicode Collation Algorithm";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "unicode-data" = callPackage
···
        libraryHaskellDepends = [ base containers logict mtl ];
        description = "Simple generic unification algorithms";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "unification-fd_0_11_2" = callPackage
+    ({ mkDerivation, base, containers, logict, mtl }:
+     mkDerivation {
+       pname = "unification-fd";
+       version = "0.11.2";
+       sha256 = "1lyx3g10llkr7vl7c2j15ddlqrkz2r684d1laza7nvq97amrqnqv";
+       libraryHaskellDepends = [ base containers logict mtl ];
+       description = "Simple generic unification algorithms";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "uniform-algebras" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "unix-bytestring_0_3_7_7" = callPackage
+    ({ mkDerivation, base, bytestring }:
+     mkDerivation {
+       pname = "unix-bytestring";
+       version = "0.3.7.7";
+       sha256 = "1fpv8f6x2z0qncdjxpg3v3qjjs747bf3vw319c9hlygrhg5pnkx6";
+       libraryHaskellDepends = [ base bytestring ];
+       description = "Unix/Posix-specific functions for ByteStrings";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "unix-compat" = callPackage
     ({ mkDerivation, base, unix }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "unix-compat_0_6" = callPackage
+    ({ mkDerivation, base, directory, extra, hspec, HUnit
+     , monad-parallel, temporary, unix
+     }:
+     mkDerivation {
+       pname = "unix-compat";
+       version = "0.6";
+       sha256 = "1y6m8ix8np6vambabdaj2h7ydgda8igwy3kliv53mba3clx85kdl";
+       libraryHaskellDepends = [ base unix ];
+       testHaskellDepends = [
+         base directory extra hspec HUnit monad-parallel temporary
+       ];
+       description = "Portable POSIX-compatibility layer";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "unix-fcntl" = callPackage
     ({ mkDerivation, base, foreign-var }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "unpacked-maybe-numeric";
-       version = "0.1.1.0";
-       sha256 = "1bhipjz20zajbkg6zjgw99w1bzdn6w6ixl34m6wnhvz8bms27lm1";
+       version = "0.1.2.0";
+       sha256 = "08cm7121c2ddj2fqfjhqjs3y1yskzcsxjq2q8pbq1ndicmlrw1b0";
        libraryHaskellDepends = [ base primitive wide-word ];
        testHaskellDepends = [ base QuickCheck quickcheck-classes ];
        description = "maybes of numeric values with fewer indirections";
···
        pname = "vector";
        version = "0.12.3.1";
        sha256 = "0dczbcisxhhix859dng5zhxkn3xvlnllsq60apqzvmyl5g056jpv";
-       revision = "1";
-       editedCabalFile = "02284cr5f5ghbz18shn8g6jvsgfs0dwgf81kxvf59r2wks8i00h4";
+       revision = "2";
+       editedCabalFile = "0gkzrqcx5fymkxm92gy47qj0spj79ygv1vn7kfzdg7nn284x1yzz";
        libraryHaskellDepends = [ base deepseq ghc-prim primitive ];
        testHaskellDepends = [
          base base-orphans doctest HUnit primitive QuickCheck random tasty
···
        broken = true;
      }) {};
 
+  "wai-middleware-bearer" = callPackage
+    ({ mkDerivation, base, bytestring, hspec, hspec-wai, http-types
+     , wai, word8
+     }:
+     mkDerivation {
+       pname = "wai-middleware-bearer";
+       version = "1.0.3";
+       sha256 = "17vqvr9f8n4zgxhhanndkpywjmzffm06f2nbsq1wxq79qpghc44j";
+       libraryHaskellDepends = [ base bytestring http-types wai word8 ];
+       testHaskellDepends = [
+         base bytestring hspec hspec-wai http-types wai word8
+       ];
+       description = "WAI Middleware for Bearer Token Authentication";
+       license = lib.licenses.mit;
+     }) {};
+
   "wai-middleware-brotli" = callPackage
     ({ mkDerivation, base, binary, bytestring, directory, filepath
      , hs-brotli, http-types, mtl, tasty, tasty-hspec, tasty-hunit, unix
···
        description = "Binding to the Webkit library";
        license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) webkitgtk;};
 
   "webkitgtk3-javascriptcore" = callPackage
···
        maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
+  "weeder_2_3_1" = callPackage
+    ({ mkDerivation, algebraic-graphs, base, bytestring, containers
+     , dhall, directory, filepath, generic-lens, ghc, lens, mtl
+     , optparse-applicative, regex-tdfa, text, transformers
+     }:
+     mkDerivation {
+       pname = "weeder";
+       version = "2.3.1";
+       sha256 = "16hgfhchmnp32wvcx9r464azycvdq1gsjmnjmnw995y9cp27ayy1";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         algebraic-graphs base bytestring containers dhall directory
+         filepath generic-lens ghc lens mtl optparse-applicative regex-tdfa
+         text transformers
+       ];
+       executableHaskellDepends = [
+         base bytestring containers directory filepath ghc
+         optparse-applicative transformers
+       ];
+       description = "Detect dead code";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ maralorn ];
+     }) {};
+
   "weeder" = callPackage
     ({ mkDerivation, algebraic-graphs, base, bytestring, containers
      , dhall, directory, filepath, generic-lens, ghc, lens, mtl
···
      }:
      mkDerivation {
        pname = "weeder";
-       version = "2.3.0";
-       sha256 = "1l3g0afb0k91qb64kpj18nb53njbv3s5w06rkjf58p7qk6ynk9ig";
+       version = "2.4.0";
+       sha256 = "1lwg1a4i7gb0l58bsyn1sg2q31ns79ldw4nv6hbnh4rqq1rv7vx4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "weigh";
        version = "0.0.16";
        sha256 = "13pbjr7fzqy3s9c1nd2jhfwzbpccmpfwdn7y46z9k2bfkch1jam9";
+       revision = "1";
+       editedCabalFile = "0y71p1fg2q9ig955b21fhfaipdamdrlzfl302prqz8g0sfcxvmfg";
        libraryHaskellDepends = [
          base deepseq ghc mtl process split temporary
        ];
···
        pname = "writer-cps-mtl";
        version = "0.1.1.6";
        sha256 = "0dnx2h4pqmvbkg2hh9c6vhayn6hyzyvs12c0s7rjdba1vihgpy86";
+       revision = "1";
+       editedCabalFile = "0j0qmb3r1xiva0q0vh8qi0l56py1n0cj1ikd44ivdmbadm5krs92";
        libraryHaskellDepends = [
          base mtl transformers writer-cps-transformers
        ];
···
        pname = "xeno";
        version = "0.5";
        sha256 = "1i7snivbl0xby5p1wgai1g44qphj91n8chhkfg6vajcf05fr964l";
+       revision = "1";
+       editedCabalFile = "1f3gkprlqddvkch2qylj02xwsjjhbpgnbiira0dpvgg9hv6qxkhm";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base bytestring deepseq mtl mutable-containers vector
···
        pname = "xml-conduit";
        version = "1.9.1.1";
        sha256 = "1zzh7xnmbm68dab1vqsjkr6ghxqgnla5nik4amrwlmhbdih1gcdx";
+       revision = "1";
+       editedCabalFile = "0x4is0956lfpxnxf2hqv5yvl1v8r1d41h3a22qqkvbqi13xz2hzv";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          attoparsec base blaze-html blaze-markup bytestring conduit
···
      }:
      mkDerivation {
        pname = "yesod-page-cursor";
-       version = "2.0.0.10";
-       sha256 = "0ygj3k86lxq59pf5z671kyzgkfvc8csgsg9wb6ds9wy0vym1jd13";
-       libraryHaskellDepends = [
-         aeson base bytestring containers http-link-header network-uri text
-         unliftio yesod-core
-       ];
-       testHaskellDepends = [
-         aeson base bytestring hspec hspec-expectations-lifted
-         http-link-header http-types lens lens-aeson monad-logger mtl
-         persistent persistent-sqlite persistent-template scientific text
-         time unliftio unliftio-core wai-extra yesod yesod-core yesod-test
-       ];
-       license = lib.licenses.mit;
-     }) {};
-
-  "yesod-page-cursor_2_0_1_0" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, hspec
-     , hspec-expectations-lifted, http-link-header, http-types, lens
-     , lens-aeson, monad-logger, mtl, network-uri, persistent
-     , persistent-sqlite, persistent-template, scientific, text, time
-     , unliftio, unliftio-core, wai-extra, yesod, yesod-core, yesod-test
-     }:
-     mkDerivation {
-       pname = "yesod-page-cursor";
        version = "2.0.1.0";
        sha256 = "1isgw7299nc656aqdk4blraz9kh1raki2nngz1jaddjbd6x56b40";
        libraryHaskellDepends = [
···
          time unliftio unliftio-core wai-extra yesod yesod-core yesod-test
        ];
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "yesod-paginate" = callPackage
···
        testToolDepends = [ purescript ];
        description = "Zephyr, tree-shaking for the PureScript language";
        license = lib.licenses.mpl20;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "zephyr-copilot" = callPackage
···
      }:
      mkDerivation {
        pname = "zxcvbn-hs";
-       version = "0.3.0.0";
-       sha256 = "13rz0bjvcj9hrxnxqbw7bl6529yz4aqawq6abssj4nmxbmgrj7xf";
+       version = "0.3.1";
+       sha256 = "1x32gzgv56l6l14b5k3wa1nzs5b4wgm8a0vn6y49ks6pgi7bdzim";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [

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

···
 }:
 
 buildPythonPackage rec {
-  version = "5.0.2";
+  version = "5.2.0";
   pname = "approvaltests";
   format = "setuptools";
 
···
     owner = "approvals";
     repo = "ApprovalTests.Python";
     rev = "refs/tags/v${version}";
-    sha256 = "sha256-yEzfDbYHGm3Za4+yIk5lIWM4I+5TnqfluZj8OLN9oK0=";
+    sha256 = "sha256-PrO6NC+ARv0o1KHv+ekPwkEi4VpBIj+YjWRrCSFMHI8=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/globus-sdk/default.nix

···
 
 buildPythonPackage rec {
   pname = "globus-sdk";
-  version = "3.8.0";
+  version = "3.9.0";
   format = "setuptools";
 
   disabled = pythonOlder "3.6";
···
     owner = "globus";
     repo = "globus-sdk-python";
     rev = "refs/tags/${version}";
-    hash = "sha256-JaAiAAf0zIJDXXl3zb4UE9XpmjZ8KQiEcZJm1ps+efA=";
+    hash = "sha256-Cz4BvtdncHnl53L+5U2gsm9wTNNmAj8ZXjGOk70yKlo=";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "hahomematic";
-  version = "1.8.0";
+  version = "1.8.3";
   format = "pyproject";
 
   disabled = pythonOlder "3.9";
···
     owner = "danielperna84";
     repo = pname;
     rev = "refs/tags/${version}";
-    sha256 = "sha256-5nW+IOjBkbgEn1VGHwny1iT771UqWA4BhDLamqS/xAM=";
+    sha256 = "sha256-TWXJGl0LAoQkqs49u2Z5a+sGV2QiDtbGPhQEn/qDqDQ=";
   };
 
   propagatedBuildInputs = [

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

···
+{ lib
+, buildPythonPackage
+, fetchFromGitHub
+, requests
+, pyjwt
+, mock
+, python-dateutil
+, pytestCheckHook
+, pythonOlder
+}:
+
+buildPythonPackage rec {
+  pname = "messagebird";
+  version = "2.1.0";
+  format = "setuptools";
+
+  disabled = pythonOlder "3.7";
+
+  src = fetchFromGitHub {
+    owner = "messagebird";
+    repo = "python-rest-api";
+    rev = version;
+    hash = "sha256-2KVAxdHT5+Ie3ZRxXZhU0hLOtHWjIiJi+ferkYTlSn0=";
+  };
+
+  propagatedBuildInputs = [
+    pyjwt
+    python-dateutil
+    requests
+  ];
+
+  checkInputs = [
+    mock
+    pytestCheckHook
+  ];
+
+  pythonImportsCheck = [
+    "messagebird"
+  ];
+
+  disabledTestPaths = [
+    # ValueError: not enough values to unpack (expected 6, got 0)
+    "tests/test_request_validator.py"
+  ];
+
+  meta = with lib; {
+    description = "Client for MessageBird's REST API";
+    homepage = "https://github.com/messagebird/python-rest-api";
+    license = with licenses; [ bsd2 ];
+    maintainers = with maintainers; [ fab ];
+  };
+}

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

···
+{ lib
+, buildPythonPackage
+, fetchPypi
+, pyserial
+, pythonOlder
+}:
+
+buildPythonPackage rec {
+  pname = "pykwb";
+  version = "0.0.10";
+  format = "setuptools";
+
+  disabled = pythonOlder "3.7";
+
+  src = fetchPypi {
+    inherit pname version;
+    hash = "sha256-mor2TKhq08w4HzaUaspWOMEFwJaAKjXKoNAaoZJqWPQ=";
+  };
+
+  propagatedBuildInputs = [
+    pyserial
+  ];
+
+  # Module has no tests
+  doCheck = false;
+
+  pythonImportsCheck = [
+    "pykwb"
+  ];
+
+  meta = with lib; {
+    description = "Library for interacting with KWB Easyfire Pellet Central Heating Units";
+    homepage = "https://github.com/bimbar/pykwb";
+    license = with licenses; [ mit ];
+    maintainers = with maintainers; [ fab ];
+  };
+}

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

···
+{ lib
+, buildPythonPackage
+, fetchFromGitHub
+, requests
+, pythonOlder
+}:
+
+buildPythonPackage rec {
+  pname = "pymailgunner";
+  version = "1.5";
+  format = "setuptools";
+
+  disabled = pythonOlder "3.7";
+
+  src = fetchFromGitHub {
+    owner = "pschmitt";
+    repo = pname;
+    rev = version;
+    hash = "sha256-QKwpW1aeN6OI76Kocow1Zhghq4/fl/cMPexny0MTwQs=";
+  };
+
+  propagatedBuildInputs = [
+    requests
+  ];
+
+  # Module has no tests
+  doCheck = false;
+
+  pythonImportsCheck = [
+    "pymailgunner"
+  ];
+
+  meta = with lib; {
+    description = "Library for interacting with Mailgun e-mail service";
+    homepage = "https://github.com/pschmitt/pymailgunner";
+    license = with licenses; [ asl20 ];
+    maintainers = with maintainers; [ fab ];
+  };
+}

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

···
 , aioshutil
 , buildPythonPackage
 , fetchFromGitHub
+, ipython
 , packaging
 , pillow
 , poetry-core
···
 , python-dotenv
 , pythonOlder
 , pytz
+, termcolor
 , typer
 }:
 
 buildPythonPackage rec {
   pname = "pyunifiprotect";
-  version = "3.7.0";
+  version = "3.8.0";
   format = "pyproject";
 
   disabled = pythonOlder "3.9";
···
   src = fetchFromGitHub {
     owner = "briis";
     repo = pname;
-    rev = "v${version}";
-    hash = "sha256-0adbUKTkbgA4pKrIVFGowD4Wf8brjfkLpfCT/+Mw6vs=";
+    rev = "refs/tags/v${version}";
+    hash = "sha256-YFdGWGm+DUi/0l9YBliQH1VgpYEVcHVgLirJTrNmNP4=";
   };
 
   propagatedBuildInputs = [
···
     pillow
     pydantic
     pyjwt
-    python-dotenv
     pytz
     typer
   ];
 
+  passthru.optional-dependencies = {
+    shell = [
+      ipython
+      python-dotenv
+      termcolor
+    ];
+  };
+
   checkInputs = [
     pytest-aiohttp
     pytest-asyncio
···
   ];
 
   postPatch = ''
-    # https://github.com/briis/pyunifiprotect/pull/176
-    substituteInPlace setup.cfg \
-      --replace "asyncio" "aiohttp"
     substituteInPlace pyproject.toml \
       --replace "--cov=pyunifiprotect --cov-append" ""
   '';

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

···
 
 buildPythonPackage rec {
   pname = "r2pipe";
-  version = "1.6.5";
+  version = "1.7.0";
 
   postPatch = let
     r2lib = "${lib.getOutput "lib" radare2}/lib";
···
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "512d2aca27c4515e55743852e0ab227190739d9595d2c4b6ae97b23d1a2bdd26";
+    sha256 = "sha256-VUYJm3tFyv/ws4nDHLuDgPQSGbB09hi8zrpAPDqoVbA=";
   };
 
   # Tiny sanity check to make sure r2pipe finds radare2 (since r2pipe doesn't

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

···
 
 buildPythonPackage rec {
   pname = "sagemaker";
-  version = "2.91.1";
+  version = "2.93.0";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-DP6bdakmOX2qiqbkz/D4Q/aexjy7dTDXlDKvnCf3SaA=";
+    hash = "sha256-rVEYiX0e7dP2CQK4ceEPZu395vas69aZkQzJCana53c=";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "skodaconnect";
-  version = "1.1.19";
+  version = "1.1.20";
   format = "setuptools";
 
   disabled = pythonOlder "3.8";
···
   src = fetchFromGitHub {
     owner = "lendy007";
     repo = pname;
-    rev = version;
-    hash = "sha256-IbCGveRcn6Kn0kGw+/kWTBTqCdWqsPTv6aPq71vc1mw=";
+    rev = "refs/tags/${version}";
+    hash = "sha256-VFbU4KbF/Z8/EiRYZIBXSIfByY5nc84y6YBSOuknqyg=";
   };
 
   SETUPTOOLS_SCM_PRETEND_VERSION = version;

pkgs/development/python-modules/skytemple-dtef/default.nix

···
-{ lib, buildPythonPackage, fetchFromGitHub, skytemple-files }:
+{ lib
+, buildPythonPackage
+, fetchFromGitHub
+, pillow
+, pytestCheckHook
+, pythonOlder
+, skytemple-files
+}:
 
 buildPythonPackage rec {
   pname = "skytemple-dtef";
-  version = "1.1.4";
+  version = "1.1.5";
+  format = "setuptools";
+
+  disabled = pythonOlder "3.7";
 
   src = fetchFromGitHub {
     owner = "SkyTemple";
     repo = pname;
     rev = version;
-    sha256 = "0l2b66z5ngyas3ijbzwz2wizw46kz47f8jr729pzbg4wbqbqjihr";
+    hash = "sha256-QL+nLmjz0wCED2RjidIDK0tB6mAPnoaSJWpyLFu0pP4=";
   };
 
-  propagatedBuildInputs = [ skytemple-files ];
+  propagatedBuildInputs = [
+    pillow
+    skytemple-files
+  ];
 
-  doCheck = false; # there are no tests
-  pythonImportsCheck = [ "skytemple_dtef" ];
+  checkInputs = [
+    pytestCheckHook
+  ];
+
+  pythonImportsCheck = [
+    "skytemple_dtef"
+  ];
 
   meta = with lib; {
-    homepage = "https://github.com/SkyTemple/skytemple-dtef";
     description = "A format for standardized rule-based tilesets with 256 adjacency combinations";
+    homepage = "https://github.com/SkyTemple/skytemple-dtef";
     license = licenses.gpl3Plus;
-    maintainers = with maintainers; [ xfix ];
+    maintainers = with maintainers; [ marius851000 xfix ];
   };
 }

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

···
 
 buildPythonPackage rec {
   pname = "sqlmap";
-  version = "1.6.5";
+  version = "1.6.6";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-EdiLTzjRigJLsslWSymLNajvUDimBt4d4EBugxVYueg=";
+    sha256 = "sha256-eXQ3sddIDHJ/pc6n5pmJoi3FvA8j2GMyWtToiKVIaVg=";
   };
 
   postPatch = ''

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

···
 
 buildPythonPackage rec {
   pname = "trytond";
-  version = "6.4.0";
+  version = "6.4.1";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "3c04d75c2a779b88b8c7ab6dd252cf4fc51f9546bf42760d10dbd1a17f61b288";
+    sha256 = "sha256-8Ah1zNQzcVgYSqCIGRN+6o8qzVPd3WzygGtVnyojHuk=";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "yte";
-  version = "1.4.0";
+  version = "1.5.1";
   format = "pyproject";
 
   disabled = pythonOlder "3.7";
···
     owner = "koesterlab";
     repo = pname;
     rev = "refs/tags/v${version}";
-    sha256 = "sha256-G3TjIs/EeCqpNuFdb/WZ7PaPtnUdTvbH41OtRypfptg=";
+    sha256 = "sha256-7erT5UpejPMIoyqhpYNEON3YWE2l5SdP2olOVpkbNkY=";
   };
 
   nativeBuildInputs = [

pkgs/development/tools/analysis/radare2/default.nix

···
 in
 stdenv.mkDerivation rec {
   pname = "radare2";
-  version = "5.6.8";
+  version = "5.7.0";
 
   src = fetchFromGitHub {
     owner = "radare";
     repo = "radare2";
     rev = version;
-    sha256 = "0fpz63dfac1i6wwf5wp3v1vs3r5yzh05g95m5vidx56h0g4dcp44";
+    sha256 = "sha256-tCFi1m3xyQlG+8FijjQh8PMwg6CIfIxvLkd5xCIZHHo=";
   };
 
   preBuild = ''

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

···
 { lib
 , stdenv
-, supportedGhcVersions ? [ "884" "8107" "902" "922" ]
+, supportedGhcVersions ? [ "884" "8107" "902" "923" ]
 , dynamic ? false
 , haskellPackages
 , haskell
···
 #
 # The recommended way to override this package is
 #
-# pkgs.haskell-language-server.override { supportedGhcVersions = [ "901" ]; }
+# pkgs.haskell-language-server.override { supportedGhcVersions = [ "902" ]; }
 #
 # for example. Read more about this in the haskell-language-server section of the nixpkgs manual.
 #

pkgs/misc/arm-trusted-firmware/default.nix

···
 { lib, stdenv, fetchFromGitHub, openssl, pkgsCross, buildPackages
 
-# Warning: this blob runs on the main CPU (not the GPU) at privilege
-# level EL3, which is above both the kernel and the hypervisor.
+# Warning: this blob (hdcp.bin) runs on the main CPU (not the GPU) at
+# privilege level EL3, which is above both the kernel and the
+# hypervisor.
+#
+# This parameter applies only to platforms which are believed to use
+# hdcp.bin. On all other platforms, or if unfreeIncludeHDCPBlob=false,
+# hdcp.bin will be deleted before building.
 , unfreeIncludeHDCPBlob ? true
 }:
 
···
   buildArmTrustedFirmware = { filesToInstall
             , installDir ? "$out"
             , platform ? null
+            , platformCanUseHDCPBlob ? false  # set this to true if the platform is able to use hdcp.bin
             , extraMakeFlags ? []
             , extraMeta ? {}
             , version ? "2.6"
             , ... } @ args:
+
+           # delete hdcp.bin if either: the platform is thought to
+           # not need it or unfreeIncludeHDCPBlob is false
+           let deleteHDCPBlobBeforeBuild = !platformCanUseHDCPBlob || !unfreeIncludeHDCPBlob; in
+
            stdenv.mkDerivation ({
 
     pname = "arm-trusted-firmware${lib.optionalString (platform != null) "-${platform}"}";
···
       sha256 = "sha256-qT9DdTvMcUrvRzgmVf2qmKB+Rb1WOB4p1rM+fsewGcg=";
     };
 
-    patches = lib.optionals (!unfreeIncludeHDCPBlob) [
+    patches = lib.optionals deleteHDCPBlobBeforeBuild [
       # this is a rebased version of https://gitlab.com/vicencb/kevinboot/-/blob/master/atf.patch
       ./remove-hdcp-blob.patch
     ];
 
+    postPatch = lib.optionalString deleteHDCPBlobBeforeBuild ''
+      rm plat/rockchip/rk3399/drivers/dp/hdcp.bin
+    '';
+
     depsBuildBuild = [ buildPackages.stdenv.cc ];
 
     # For Cortex-M0 firmware in RK3399
···
     meta = with lib; {
       homepage = "https://github.com/ARM-software/arm-trusted-firmware";
       description = "A reference implementation of secure world software for ARMv8-A";
-      license = (if unfreeIncludeHDCPBlob then [ licenses.unfreeRedistributable ] else []) ++ [ licenses.bsd3 ];
+      license = [ licenses.bsd3 ] ++ lib.optionals (!deleteHDCPBlobBeforeBuild) [ licenses.unfreeRedistributable ];
       maintainers = with maintainers; [ lopsided98 ];
     } // extraMeta;
   } // builtins.removeAttrs args [ "extraMeta" ]);
···
     platform = "rk3328";
     extraMeta.platforms = ["aarch64-linux"];
     filesToInstall = [ "build/${platform}/release/bl31/bl31.elf"];
+    platformCanUseHDCPBlob = true;
   };
 
   armTrustedFirmwareRK3399 = buildArmTrustedFirmware rec {
···
     platform = "rk3399";
     extraMeta.platforms = ["aarch64-linux"];
     filesToInstall = [ "build/${platform}/release/bl31/bl31.elf"];
+    platformCanUseHDCPBlob = true;
   };
 
   armTrustedFirmwareS905 = buildArmTrustedFirmware rec {

pkgs/servers/atlassian/confluence.nix

···
 
 stdenvNoCC.mkDerivation rec {
   pname = "atlassian-confluence";
-  version = "7.17.1";
+  version = "7.18.1";
 
   src = fetchurl {
     url = "https://product-downloads.atlassian.com/software/confluence/downloads/${pname}-${version}.tar.gz";
-    sha256 = "sha256-TFtWuJR/t3MMbs8Gd818ByOnMtiT4QxbcpgBxYXzFYY=";
+    sha256 = "sha256-MEq1ASnJUYWPvt7Z30+fUTv+QrDI+Xsb5e9K0c8ZtdQ=";
   };
 
   buildPhase = ''

pkgs/servers/home-assistant/component-packages.nix

···
       pykulersky
     ];
     "kwb" = ps: with ps; [
-    ]; # missing inputs: pykwb
+      pykwb
+    ];
     "lacrosse" = ps: with ps; [
       pylacrosse
     ];
···
     ];
     "mailgun" = ps: with ps; [
       aiohttp-cors
-    ]; # missing inputs: pymailgunner
+      pymailgunner
+    ];
     "manual" = ps: with ps; [
     ];
     "manual_mqtt" = ps: with ps; [
···
       aiohttp-cors
     ];
     "message_bird" = ps: with ps; [
-    ]; # missing inputs: messagebird
+      messagebird
+    ];
     "met" = ps: with ps; [
       pymetno
     ];
···
     "lutron_caseta"
     "lyric"
     "mailbox"
+    "mailgun"
     "manual"
     "manual_mqtt"
     "maxcube"

pkgs/shells/yash/default.nix

···
 
   src = fetchurl {
     url = "https://osdn.net/dl/yash/yash-${version}.tar.xz";
-    sha256 = "sha256:1jdmj4cyzwxxyyqf20y1zi578h7md860ryffp02qi143zpppn4sm";
+    hash = "sha256-VRN77/2DhIgFuM75DAxq9UB0SvzBA+Gw973z7xmRtck=";
   };
 
   strictDeps = true;
   buildInputs = [ gettext ncurses ];
 
   meta = with lib; {
-    description = "Yet another POSIX-compliant shell";
     homepage = "https://yash.osdn.jp/index.html.en";
+    description = "Yet another POSIX-compliant shell";
     license = licenses.gpl2Plus;
     maintainers = with maintainers; [ qbit ];
     platforms = platforms.all;

pkgs/test/cuda/cuda-samples/generic.nix

···
-{ addOpenGLRunpath
-, cudatoolkit
+{ lib
+, stdenv
 , fetchFromGitHub
 , fetchpatch
-, lib
+, addOpenGLRunpath
+, cudatoolkit
 , pkg-config
 , sha256
-, stdenv
 }:
 
-let
+stdenv.mkDerivation rec {
   pname = "cuda-samples";
   version = lib.versions.majorMinor cudatoolkit.version;
-in
-
-stdenv.mkDerivation {
-  inherit pname version;
 
   src = fetchFromGitHub {
     owner = "NVIDIA";
···
   patches = lib.optionals (version == "11.3") [
     (fetchpatch {
       url = "https://github.com/NVIDIA/cuda-samples/commit/5c3ec60faeb7a3c4ad9372c99114d7bb922fda8d.patch";
-      sha256 = "sha256:15bydf59scmfnldz5yawbjacdxafi50ahgpzq93zlc5xsac5sz6i";
+      sha256 = "sha256-0XxdmNK9MPpHwv8+qECJTvXGlFxc+fIbta4ynYprfpU=";
     })
   ];
 

pkgs/test/dhall/buildDhallUrl/default.nix

···
 dhallPackages.buildDhallUrl {
   url = "https://raw.githubusercontent.com/cdepillabout/example-dhall-nix/e6a675c72ecd4dd23d254a02aea8181fe875747f/mydhallfile.dhall";
   hash = "sha256-434x+QjHRzuprBdw0h6wmwB1Zj6yZqQb533me8XdO4c=";
-  dhallHash = "sha256:e37e31f908c7473ba9ac1770d21eb09b0075663eb266a41be77de67bc5dd3b87";
+  dhallHash = "sha256-434x+QjHRzuprBdw0h6wmwB1Zj6yZqQb533me8XdO4c=";
   source = true;
 }

pkgs/tools/graphics/asymptote/default.nix

···
     owner = "vectorgraphics";
     repo = pname;
     rev = version;
-    sha256 = "sha256:1lawj2gf0985clzbyym26s5mxxp2syl1dqqxfzk0sq9s30l2rj3l";
+    hash = "sha256-dMgsKBg6YQ3mdx3jFqjX4vZeizaier8+ZQUl4J6QXNE=";
   };
 
   patches =
     (lib.optional (lib.versionOlder version "2.68")
       (fetchpatch {
         url = "https://github.com/vectorgraphics/asymptote/commit/3361214340d58235f4dbb8f24017d0cd5d94da72.patch";
-        sha256 = "sha256:1z2b41x8v7683myd45lq6niixpdjy0b185x0xl61130vrijhq5nm";
+        hash = "sha256-1RYMZcwbjBAM7aAXFBbwst0eozWYFtJ8HcicjXogS/w=";
       }))
   ;
 

pkgs/tools/misc/flexoptix-app/default.nix

···
   src = fetchurl {
     name = "${name}.AppImage";
     url = "https://flexbox.reconfigure.me/download/electron/linux/x64/FLEXOPTIX%20App.${version}.AppImage";
-    sha256 = "sha256:1hzdb2fbkwpsf0d3ws4z32blk6549jwhf1lrlqmcxhzqfvkr4gin";
+    hash = "sha256-Nj6S53b4w84qppkGB7lMpJhJlxifaD4acPryuZxY7cM=";
   };
 
   udevRules = fetchurl {
     url = "https://www.flexoptix.net/skin/udev_rules/99-tprogrammer.rules";
-    sha256 = "0mr1bhgvavq1ax4206z1vr2y64s3r676w9jjl9ysziklbrsvk5rr";
+    hash = "sha256-OZe5dV50xq99olImbo7JQxPjRd7hGyBIVwFvtR9cIVc=";
   };
 
   appimageContents = (appimageTools.extract { inherit name src; }).overrideAttrs (oA: {

pkgs/tools/misc/octofetch/default.nix

···
 { lib
 , stdenv
 , fetchFromGitHub
-, rustPlatform
-, pkg-config
 , openssl
+, pkg-config
+, rustPlatform
 , Security
 }:
 
···
     sha256 = "sha256-/AXE1e02NfxQzJZd0QX6gJDjmFFmuUTOndulZElgIMI=";
   };
 
-  cargoSha256 = "sha256:1ddyzbpsiy54r13nb9yrm64cbbifixnhkskwg5fvhhzj4ri4ks4a";
+  cargoSha256 = "sha256-iuhJYibyQ7hdeXzqCW2PLq7FiKnZp2VHyKT4qO/6vrU=";
 
   nativeBuildInputs = [ pkg-config ];
+
   buildInputs = lib.optionals stdenv.isLinux [ openssl ]
     ++ lib.optionals stdenv.isDarwin [ Security ];
 
   meta = with lib; {
-    description = "Github user information on terminal";
     homepage = "https://github.com/azur1s/octofetch";
+    description = "Github user information on terminal";
     license = licenses.mit;
     maintainers = with maintainers; [ jyooru ];
   };

pkgs/tools/misc/precice-config-visualizer/default.nix

···
-{ lib, python3Packages, fetchFromGitHub}:
+{ lib
+, python3Packages
+, fetchFromGitHub
+}:
 
 python3Packages.buildPythonApplication rec {
   pname = "config-visualizer";
···
     owner = "precice";
     repo = pname;
     rev = "60f2165f25352c8261f370dc4ceb64a8b422d4ec";
-    sha256 = "sha256:0mqzp2qdvbqbxaczlvc9xxxdz6hclraznbmc08ldx11xwy8yknfr";
+    hash = "sha256-2dnpkec9hN4oAqwu+1WmDJrfeu+JbfqZ6guv3bC4H1c=";
   };
 
   propagatedBuildInputs = with python3Packages; [ lxml pydot ];
+
   doCheck = false;
 
   meta = with lib; {
-    description = "Small python tool for visualizing the preCICE xml configuration ";
     homepage = "https://github.com/precice/config-visualizer";
+    description = "Small python tool for visualizing the preCICE xml configuration ";
     license = licenses.gpl3Only;
     maintainers = with maintainers; [ Scriptkiddi ];
   };

pkgs/tools/networking/openapi-generator-cli/example.nix

···
   nativeBuildInputs = [ openapi-generator-cli ];
   petstore = fetchurl {
     url = "https://raw.githubusercontent.com/OAI/OpenAPI-Specification/14c0908becbccd78252be49bd92be8c53cd2b9e3/examples/v3.0/petstore.yaml";
-    sha256 = "sha256:1mgdbzv42alv0b1a18dqbabqyvyhrg3brynr5hqsrm3qljfzaq5b";
+    hash = "sha256-q2D1naR41KwxLNn6vMbL0G+Pl1q4oaDCApsqQfZf7dU=";
   };
   config = builtins.toJSON {
     elmVersion = "0.19";

pkgs/tools/networking/vpnc-scripts/default.nix

···
-{ lib, stdenv, fetchgit
+{ lib
+, stdenv
+, fetchgit
+, coreutils
+, gawk
+, gnugrep
+, iproute2
 , makeWrapper
-, nettools, gawk, systemd, openresolv, coreutils, gnugrep, iproute2
+, nettools
+, openresolv
+, systemd
 }:
 
 stdenv.mkDerivation {
   pname = "vpnc-scripts";
   version = "unstable-2021-09-24";
+
   src = fetchgit {
     url = "https://gitlab.com/openconnect/vpnc-scripts.git";
     rev = "b749c2cadc2f32e2efffa69302861f9a7d4a4e5f";
-    sha256 = "sha256:19aj6mfkclbkx6ycyd4xm7id1bq78ismw0y6z23f6s016k3sjc8c";
+    sha256 = "sha256-DDGpxzQBaOOG+MYDXnVEB6/Q4qmdNM+86XNRNl01UqU=";
   };
 
   nativeBuildInputs = [ makeWrapper ];
···
   '';
 
   meta = with lib; {
-    description = "script for vpnc to configure the network routing and name service";
     homepage = "https://www.infradead.org/openconnect/";
+    description = "Script for vpnc to configure the network routing and name service";
     license = licenses.gpl2Only;
     maintainers = with maintainers; [ jerith666 ];
     platforms = platforms.linux ++ platforms.darwin;

pkgs/tools/security/crackxls/default.nix

···
-{ lib, stdenv, fetchFromGitHub, pkg-config, autoconf, automake, openssl, libgsf, gmp }:
+{ lib, stdenv, fetchFromGitHub, fetchpatch, pkg-config, autoconf, automake, openssl, libgsf, gmp }:
 
 stdenv.mkDerivation rec {
 
···
     sha256 = "0q5jl7hcds3f0rhly3iy4fhhbyh9cdrfaw7zdrazzf1wswwhyssz";
   };
 
+  patches = [
+    # Pull patch pending upstream inclusion for -fno-common support:
+    #   https://github.com/GavinSmith0123/crackxls2003/pull/3
+    (fetchpatch {
+      name = "fno-common.patch";
+      url = "https://github.com/GavinSmith0123/crackxls2003/commit/613d6c1844f76c7b67671aaa265375fed56c2a56.patch";
+      sha256 = "1pk67x67d9wji576mc57z5bzqlf9ygvn9m1z47w12mad7qmj9h1n";
+    })
+  ];
+
   nativeBuildInputs = [ pkg-config autoconf automake ];
   buildInputs = [ openssl libgsf gmp ];
+
+  # Avoid "-O5 -march=native"
+  makeFlags = [ "OPTIM_FLAGS=" ];
 
   installPhase =
   ''

pkgs/tools/security/pcsclite/default.nix

···
 
   src = fetchurl {
     url = "https://pcsclite.apdu.fr/files/pcsc-lite-${version}.tar.bz2";
-    sha256 = "sha256:024x0hadn0kc0m9yz3l2pqzc5mdqyza9lmckg0bn4xak6frzkqwy";
+    hash = "sha256-nuP5szNTdWIXeJNVmtT3uNXCPr6Cju9TBWwC2xQEnQg=";
   };
 
   patches = [ ./no-dropdir-literals.patch ];

pkgs/tools/security/pomerium-cli/default.nix

···
 in
 buildGoModule rec {
   pname = "pomerium-cli";
-  version = pomerium.version;
+  inherit (pomerium) version;
+
   src = fetchFromGitHub {
     owner = "pomerium";
     repo = "cli";
     rev = "v${version}";
-    hash = "sha256:0230b22xjnpykj8bcdahzzlsvlrd63z2cmg6yb246c5ngjs835q1";
+    hash = "sha256-AZeBtHy2MEPE8uZVJv4wLdOt6f9QNbaQnP5a2YVYYAg=";
   };
 
-  vendorSha256 = "sha256:0xx22lmh6wip1d1bjrp4lgab3q9yilw54v4lg24lf3xhbsr5si9b";
+  vendorSha256 = "sha256-K0Vdsl6wD0eJeJRsUjiNPuGx1KPkZrlCCzdyAysVonc=";
+
   subPackages = [
     "cmd/pomerium-cli"
   ];
···
   ];
 
   installPhase = ''
+    runHook preInstall
+
     install -Dm0755 $GOPATH/bin/pomerium-cli $out/bin/pomerium-cli
+
+    runHook postInstall
   '';
 
   meta = with lib; {

pkgs/tools/security/softhsm/default.nix

···
 
   src = fetchurl {
     url = "https://dist.opendnssec.org/source/${pname}-${version}.tar.gz";
-    hash = "sha256:1wkmyi6n3z2pak1cj5yk6v6bv9w0m24skycya48iikab0mrr8931";
+    hash = "sha256-YSSUcwVLzRgRUZ75qYmogKe9zDbTF8nCVFf8YU30dfI=";
   };
 
   configureFlags = [

pkgs/tools/system/retry/default.nix

···
-{ lib, stdenv, fetchFromGitHub, autoreconfHook, which, txt2man }:
+{ lib
+, stdenv
+, fetchFromGitHub
+, autoreconfHook
+, txt2man
+, which
+}:
+
 stdenv.mkDerivation rec {
   pname = "retry";
   version = "1.0.4";
 
-  nativeBuildInputs = [ autoreconfHook which txt2man ];
-
   src = fetchFromGitHub {
     owner = "minfrin";
     repo = "retry";
     rev = "${pname}-${version}";
-    sha256 = "sha256:0jrx4yrwlf4fn3309kxraj7zgwk7gq6rz5ibswq3w3b3jfvxi8qb";
+    hash = "sha256-C6PYt5NjDT4w1yuWnw1+Z/L3j1S5zwTGsI44yrMnPUs=";
   };
 
+  nativeBuildInputs = [ autoreconfHook txt2man which ];
+
   meta = with lib; {
     homepage = "https://github.com/minfrin/retry";
     description = "Retry a command until the command succeeds";
-    platforms = platforms.all;
     license = licenses.asl20;
     maintainers = with maintainers; [ gfrascadorio ];
+    platforms = platforms.all;
   };
 }
 

pkgs/tools/text/cidrgrep/default.nix

···
     owner = "tomdoherty";
     repo = "cidrgrep";
     rev = "8ad5af533e8dc33ea18ff19b7c6a41550748fe0e";
-    sha256 = "sha256:0jvwm9jq5jd270b6l9nkvc5pr3rgf158sw83lrprmwmz7r4mr786";
+    hash = "sha256-Bp1cST6/8ppvpgNxjUpwL498C9vTJmoWOKLJgmWqfEs=";
   };
 
-  vendorSha256 = "sha256:0sjjj9z1dhilhpc8pq4154czrb79z9cm044jvn75kxcjv6v5l2m5";
+  vendorSha256 = "sha256-pQpattmS9VmO3ZIQUFn66az8GSmB4IvYhTTCFn6SUmo=";
 
   postInstall = ''
     mv $out/bin/cmd $out/bin/cidrgrep
···
 
   meta = {
     description = "Like grep but for IPv4 CIDRs";
-    maintainers = with lib.maintainers; [ das_j ];
     license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ das_j ];
   };
 }

pkgs/tools/typesetting/coq2html/default.nix

···
     owner = "xavierleroy";
     repo = "coq2html";
     rev = "v${version}";
-    sha256 = "sha256:1ad825yifn518wk1c2y2ji10q3m468r8ajjgw2nzzy7d608nx7yq";
+    hash = "sha256-2J9uETDt+P+t4E9KhTIypA4MQpTCCxYmR6FYF30RqKk=";
   };
 
   nativeBuildInputs = [ ocaml ];

pkgs/top-level/all-packages.nix

···
     stdenv = clangStdenv;
   };
 
-  jacinda = haskell.lib.compose.justStaticExecutables haskell.packages.ghc922.jacinda;
+  jacinda = haskell.lib.compose.justStaticExecutables haskell.packages.ghc923.jacinda;
 
   janet = callPackage ../development/interpreters/janet {};
 

pkgs/top-level/haskell-packages.nix

···
     "integer-simple"
     "native-bignum"
     "ghc902"
-    "ghc922"
+    "ghc923"
     "ghcHEAD"
   ];
 
   nativeBignumIncludes = [
     "ghc902"
-    "ghc922"
+    "ghc923"
     "ghcHEAD"
   ];
 
···
       buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_12;
       llvmPackages = pkgs.llvmPackages_12;
     };
-    ghc922 = callPackage ../development/compilers/ghc/9.2.2.nix {
+    ghc923 = callPackage ../development/compilers/ghc/9.2.3.nix {
       bootPkgs =
         # aarch64 ghc8107Binary exceeds max output size on hydra
         if stdenv.isAarch64 || stdenv.isAarch32 then
···
       ghc = bh.compiler.ghc902;
       compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.0.x.nix { };
     };
-    ghc922 = callPackage ../development/haskell-modules {
-      buildHaskellPackages = bh.packages.ghc922;
-      ghc = bh.compiler.ghc922;
+    ghc923 = callPackage ../development/haskell-modules {
+      buildHaskellPackages = bh.packages.ghc923;
+      ghc = bh.compiler.ghc923;
       compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.2.x.nix { };
     };
     ghcHEAD = callPackage ../development/haskell-modules {

pkgs/top-level/python-packages.nix

···
 
   mesonpep517 = callPackage ../development/python-modules/mesonpep517 { };
 
+  messagebird = callPackage ../development/python-modules/messagebird { };
+
   metakernel = callPackage ../development/python-modules/metakernel { };
 
   metar = callPackage ../development/python-modules/metar { };
···
 
   pykwalify = callPackage ../development/python-modules/pykwalify { };
 
+  pykwb = callPackage ../development/python-modules/pykwb { };
+
   pylacrosse = callPackage ../development/python-modules/pylacrosse { };
 
   pylama = callPackage ../development/python-modules/pylama { };
···
   pymaging = callPackage ../development/python-modules/pymaging { };
 
   pymaging_png = callPackage ../development/python-modules/pymaging_png { };
+
+  pymailgunner = callPackage ../development/python-modules/pymailgunner { };
 
   pymanopt = callPackage ../development/python-modules/pymanopt { };
 

pkgs/top-level/release-haskell.nix

···
     ghc884
     ghc8107
     ghc902
-    ghc922
+    ghc923
   ];
 
   # packagePlatforms applied to `haskell.packages.*`
···
               ;
             };
 
-            haskell.packages.native-bignum.ghc922 = {
-              inherit (packagePlatforms pkgs.pkgsStatic.haskell.packages.native-bignum.ghc922)
+            haskell.packages.native-bignum.ghc923 = {
+              inherit (packagePlatforms pkgs.pkgsStatic.haskell.packages.native-bignum.ghc923)
                 hello
                 lens
                 random
···
       spectacle = [
         compilerNames.ghc8107
       ];
+      weeder = [
+        compilerNames.ghc8107
+        compilerNames.ghc902
+        compilerNames.ghc923
+      ];
+      purescript = [
+        compilerNames.ghc8107
+      ];
+      purescript-cst = [
+        compilerNames.ghc8107
+      ];
+      purescript-ast = [
+        compilerNames.ghc8107
+      ];
     })
     {
       mergeable = pkgs.releaseTools.aggregate {
···
           jobs.pkgsMusl.haskell.compiler.ghc884
           jobs.pkgsMusl.haskell.compiler.ghc8107
           jobs.pkgsMusl.haskell.compiler.ghc902
-          jobs.pkgsMusl.haskell.compiler.ghc922
+          jobs.pkgsMusl.haskell.compiler.ghc923
           jobs.pkgsMusl.haskell.compiler.ghcHEAD
           jobs.pkgsMusl.haskell.compiler.integer-simple.ghc8107
           jobs.pkgsMusl.haskell.compiler.native-bignum.ghc902
-          jobs.pkgsMusl.haskell.compiler.native-bignum.ghc922
+          jobs.pkgsMusl.haskell.compiler.native-bignum.ghc923
           jobs.pkgsMusl.haskell.compiler.native-bignum.ghcHEAD
         ];
       };
···
         };
         constituents = accumulateDerivations [
           jobs.pkgsStatic.haskellPackages
-          jobs.pkgsStatic.haskell.packages.native-bignum.ghc922
+          jobs.pkgsStatic.haskell.packages.native-bignum.ghc923
         ];
       };
     }