Merge remote-tracking branch 'nixpkgs/master' into staging-next

Conflicts:
pkgs/development/compilers/ghc/8.10.7.nix
pkgs/development/compilers/ghc/8.8.4.nix

I've removed the isWindows check from useLdGold in ghc, since that should
be covered by the new hasGold check.

pkgs/applications/editors/vscode/vscodium.nix

···
   archive_fmt = if system == "x86_64-darwin" then "zip" else "tar.gz";
 
   sha256 = {
-    x86_64-linux = "1z8sxdzwbjip8csrili5l36v1kl3iq8fw19dhfnkjs3fl0sn360k";
-    x86_64-darwin = "0sp5k4pk9yjx16c79hqrwn64f2ab82iizm1cy93y9rr2r3px1yga";
-    aarch64-linux = "03qm5008knigsahs6zz5c614g1kid3k0ndg8vb0flfwmdrajrdw3";
-    armv7l-linux = "0sls3m5zwz6w01k7jym0vwbz006bkwv23yba7gf1gg84vbqgpb1x";
+    x86_64-linux = "1l3khnqb8icapnwk4pr4s639dqsvjy1k51km2p9ywnrjdg9byc12";
+    x86_64-darwin = "1lb63rz9mzcw5yg3cqi022m1ldvmbxz5z70axc9n6dci8aals663";
+    aarch64-linux = "0c0rxzhayklgnaf0r4hj6rwdh5qbb449vi5ja0asfyni4k2nalr5";
+    armv7l-linux = "0xs8wsad64cni8vpzfh2aqgdsnsy4hwc25msl79prvh17794k8jy";
   }.${system};
 
   sourceRoot = {
···
 
     # Please backport all compatible updates to the stable release.
     # This is important for the extension ecosystem.
-    version = "1.59.1";
+    version = "1.60.0";
     pname = "vscodium";
 
     executableName = "codium";

pkgs/applications/misc/gallery-dl/default.nix

···
 
 buildPythonApplication rec {
   pname = "gallery_dl";
-  version = "1.18.3";
+  version = "1.18.4";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "6e058dd25a8a54ead41479579fd73de71472abb980a6254765c5e538b591d162";
+    sha256 = "bdb84706fdde867fe2ee11c74c8c51af4e560399bd5fa562f19bfcaf8fc0dac9";
   };
 
   propagatedBuildInputs = [ requests ];
···
   meta = with lib; {
     description = "Command-line program to download image-galleries and -collections from several image hosting sites";
     homepage = "https://github.com/mikf/gallery-dl";
-    license = licenses.gpl2;
-    maintainers = with maintainers; [ dawidsowa ];
-    platforms = platforms.unix;
+    changelog = "https://github.com/mikf/gallery-dl/raw/v${version}/CHANGELOG.md";
+    license = licenses.gpl2Only;
+    maintainers = with maintainers; [ dawidsowa marsam ];
   };
 }

pkgs/applications/misc/masterpdfeditor/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "masterpdfeditor";
-  version = "5.7.20";
+  version = "5.7.90";
 
   src = fetchurl {
     url = "https://code-industry.net/public/master-pdf-editor-${version}-qt5.x86_64.tar.gz";
-    sha256 = "0lyfss0r0dc6skhdlkslcdagdp9k1mi0w8n5pbrskwcd09c9mxym";
+    sha256 = "sha256-wUHLesJ/YV3QyTJfGUr1lFD55JBnfSmjO2VvriaqlII=";
   };
 
   nativeBuildInputs = [ autoPatchelfHook wrapQtAppsHook ];
···
     homepage = "https://code-industry.net/free-pdf-editor/";
     license = licenses.unfreeRedistributable;
     platforms = with platforms; [ "x86_64-linux" ];
-    broken = true;
     maintainers = with maintainers; [ cmcdragonkai ];
   };
 }

pkgs/applications/misc/sqls/default.nix

···
+{ lib, buildGoModule, fetchFromGitHub }:
+
+buildGoModule rec {
+  pname = "sqls";
+  version = "0.2.19";
+
+  src = fetchFromGitHub {
+    owner = "lighttiger2505";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "1myypq9kdfbhl5h9h8d30a3pi89mix48wm1c38648ky9vhx0s4az";
+  };
+
+  vendorSha256 = "13c7nv0anj260z34bd7w1hz0rkmsj9r1zz55qiwcr1vdgmvy84cz";
+
+  ldflags = [ "-s" "-w" "-X main.version=${version}" "-X main.revision=${src.rev}" ];
+
+  meta = with lib; {
+    homepage = "https://github.com/lighttiger2505/sqls";
+    description = "SQL language server written in Go";
+    license = licenses.mit;
+    maintainers = [ maintainers.marsam ];
+  };
+}

pkgs/applications/misc/zk-shell/default.nix

···
-{ lib, fetchFromGitHub, pythonPackages }:
+{ lib, fetchFromGitHub, python3Packages }:
 
-pythonPackages.buildPythonApplication rec {
+python3Packages.buildPythonApplication rec {
+  pname = "zk-shell";
   version = "1.0.0";
-  name = "zk-shell-" + version;
 
   src = fetchFromGitHub {
     owner = "rgs1";
···
     sha256 = "0zisvvlclsf4sdh7dpqcl1149xbxw6pi1aqcwjbqblgf8m4nm0c7";
   };
 
-  propagatedBuildInputs = (with pythonPackages; [
-    ansi kazoo nose six tabulate twitter
-  ]);
+  propagatedBuildInputs = with python3Packages; [
+    ansi
+    kazoo
+    nose
+    six
+    tabulate
+    twitter
+  ];
 
-  #requires a running zookeeper, don't know how to fix that for the moment
+  # requires a running zookeeper, don't know how to fix that for the moment
   doCheck = false;
 
-  meta = {
+  meta = with lib; {
     description = "A powerful & scriptable shell for Apache ZooKeeper";
     homepage = "https://github.com/rgs1/zk_shell";
-    license = lib.licenses.asl20;
-    maintainers = [ lib.maintainers.mahe ];
-    platforms = lib.platforms.all;
+    license = licenses.asl20;
+    maintainers = [ maintainers.mahe ];
+    platforms = platforms.all;
   };
 }

pkgs/applications/networking/p2p/dht/default.nix

···
+{ stdenv, lib, fetchFromGitHub, cmake }:
+
+stdenv.mkDerivation rec {
+  pname = "dht";
+  version = "0.25";
+
+  src = fetchFromGitHub {
+    # Use transmission fork from post-0.25-transmission branch
+    owner = "transmission";
+    repo = pname;
+    rev = "25e12bb39eea3d433602de6390796fec8a8f3620";
+    sha256 = "fksi8WBQPydgSlISaZMMnxzt4xN7/Hh7aN6QQ+g/L7s=";
+  };
+
+  nativeBuildInputs = [ cmake ];
+
+  meta = with lib; {
+    description = "BitTorrent DHT library";
+    homepage = "https://github.com/transmission/dht";
+    license = licenses.mit;
+    maintainers = with maintainers; [ angustrau ];
+    platforms = platforms.unix;
+  };
+}

pkgs/applications/networking/p2p/fragments/default.nix

···
+{ lib
+, stdenv
+, fetchFromGitLab
+, meson
+, vala
+, ninja
+, pkg-config
+, wrapGAppsHook
+, desktop-file-utils
+, appstream-glib
+, python3
+, glib
+, gtk3
+, libhandy
+, libtransmission
+, libb64
+, libutp
+, miniupnpc
+, dht
+, libnatpmp
+, libevent
+, curl
+, openssl
+, zlib
+}:
+
+stdenv.mkDerivation rec {
+  pname = "fragments";
+  version = "1.5";
+
+  src = fetchFromGitLab {
+    domain = "gitlab.gnome.org";
+    owner = "World";
+    repo = "Fragments";
+    rev = version;
+    sha256 = "0x1kafhlgyi65l4w67c24r8mpvasg3q3c4wlgnjc9sxvp6ki7xbn";
+  };
+
+  patches = [
+    # Fix dependency resolution
+    ./dependency-resolution.patch
+  ];
+
+  nativeBuildInputs = [
+    meson
+    vala
+    ninja
+    pkg-config
+    wrapGAppsHook
+    desktop-file-utils
+    appstream-glib
+    python3
+  ];
+
+  buildInputs = [
+    glib
+    gtk3
+    libhandy
+    libtransmission
+    libb64
+    libutp
+    miniupnpc
+    dht
+    libnatpmp
+    libevent
+    curl
+    openssl
+    zlib
+  ];
+
+  meta = with lib; {
+    homepage = "https://gitlab.gnome.org/World/Fragments";
+    description = "A GTK3 BitTorrent Client";
+    maintainers = with maintainers; [ angustrau ];
+    license = licenses.gpl3Plus;
+    platforms = platforms.linux;
+  };
+}

pkgs/applications/networking/p2p/fragments/dependency-resolution.patch

···
+diff --git a/meson.build b/meson.build
+index 5030d0c..6de7a20 100644
+--- a/meson.build
++++ b/meson.build
+@@ -32,10 +32,11 @@ transmission_dep = declare_dependency(
+ 				meson.get_compiler('c').find_library('dht'),
+ 				meson.get_compiler('c').find_library('natpmp'),
+ 				meson.get_compiler('c').find_library('event'),
+-				meson.get_compiler('c').find_library('libcurl'),
+-				meson.get_compiler('c').find_library('libcrypto'),
++				meson.get_compiler('c').find_library('curl'),
++				meson.get_compiler('c').find_library('crypto'),
++				meson.get_compiler('c').find_library('ssl'),
+ 				meson.get_compiler('c').find_library('libpthread'),
+-				meson.get_compiler('c').find_library('libz'),
++				meson.get_compiler('c').find_library('z'),
+ 				transmission_vapi,
+ 				transmission_lib
+ 			])
+@@ -45,4 +46,4 @@ subdir('data')
+ subdir('po')
+ subdir('src')
+ 
+-meson.add_install_script('build-aux/postinstall.py')
++meson.add_install_script('python3', '../build-aux/postinstall.py')

pkgs/applications/networking/p2p/libutp/default.nix

···
+{ stdenv, lib, fetchFromGitHub, cmake }:
+
+stdenv.mkDerivation rec {
+  pname = "libutp";
+  version = "unstable-2017-01-02";
+
+  src = fetchFromGitHub {
+    # Use transmission fork from post-3.3-transmission branch
+    owner = "transmission";
+    repo = pname;
+    rev = "fda9f4b3db97ccb243fcbed2ce280eb4135d705b";
+    sha256 = "CvuZLOBksIl/lS6LaqOIuzNvX3ihlIPjI3Eqwo7YJH0=";
+  };
+
+  nativeBuildInputs = [ cmake ];
+
+  meta = with lib; {
+    description = "uTorrent Transport Protocol library";
+    homepage = "https://github.com/transmission/libutp";
+    license = licenses.mit;
+    maintainers = with maintainers; [ angustrau ];
+    platforms = platforms.unix;
+  };
+}

pkgs/applications/networking/p2p/transmission/default.nix

···
 , systemd
 , zlib
 , pcre
+, libb64
+, libutp
+, miniupnpc
+, dht
+, libnatpmp
   # Build options
 , enableGTK3 ? false
 , gtk3
···
     libevent
     zlib
     pcre
+    libb64
+    libutp
+    miniupnpc
+    dht
+    libnatpmp
   ]
   ++ lib.optionals enableQt [ qt5.qttools qt5.qtbase ]
   ++ lib.optionals enableGTK3 [ gtk3 xorg.libpthreadstubs ]
···
         * Full encryption, DHT, and PEX support
     '';
     homepage = "http://www.transmissionbt.com/";
-    license = lib.licenses.gpl2; # parts are under MIT
+    license = lib.licenses.gpl2Plus; # parts are under MIT
     maintainers = with lib.maintainers; [ astsmtl vcunat wizeman ];
     platforms = lib.platforms.unix;
   };

pkgs/build-support/rust/import-cargo-lock.nix

···
   # Parse a git source into different components.
   parseGit = src:
     let
-      parts = builtins.match ''git\+([^?]+)(\?rev=(.*))?#(.*)?'' src;
-      rev = builtins.elemAt parts 2;
+      parts = builtins.match ''git\+([^?]+)(\?(rev|tag|branch)=(.*))?#(.*)'' src;
+      type = builtins.elemAt parts 2; # rev, tag or branch
+      value = builtins.elemAt parts 3;
     in
       if parts == null then null
       else {
         url = builtins.elemAt parts 0;
-        sha = builtins.elemAt parts 3;
-      } // lib.optionalAttrs (rev != null) { inherit rev; };
+        sha = builtins.elemAt parts 4;
+      } // lib.optionalAttrs (type != null) { inherit type value; };
 
   packages = (builtins.fromTOML (builtins.readFile lockFile)).package;
 
···
         cat > $out/.cargo-config <<EOF
         [source."${gitParts.url}"]
         git = "${gitParts.url}"
-        ${lib.optionalString (gitParts ? rev) "rev = \"${gitParts.rev}\""}
+        ${lib.optionalString (gitParts ? type) "${gitParts.type} = \"${gitParts.value}\""}
         replace-with = "vendored-sources"
         EOF
       ''

pkgs/build-support/rust/test/import-cargo-lock/default.nix

···
 { callPackage }:
 
+# Build like this from nixpkgs root:
+# $ nix-build -A tests.importCargoLock
 {
   basic = callPackage ./basic { };
   gitDependency = callPackage ./git-dependency { };
-  gitDependencyNoRev = callPackage ./git-dependency-no-rev { };
+  gitDependencyRev = callPackage ./git-dependency-rev { };
+  gitDependencyTag = callPackage ./git-dependency-tag { };
+  gitDependencyBranch = callPackage ./git-dependency-branch { };
   maturin = callPackage ./maturin { };
 }

pkgs/build-support/rust/test/import-cargo-lock/git-dependency-branch/Cargo.lock

···
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "getrandom"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c9495705279e7140bf035dde1f6e750c162df8b625267cd52cc44e0b156732c8"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "git-dependency-branch"
+version = "0.1.0"
+dependencies = [
+ "rand",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.94"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18794a8ad5b29321f790b55d93dfba91e125cb1a9edbd4f8e3150acc771c1a5e"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac74c624d6b2d21f425f752262f42188365d7b8ff1aff74c82e45136510a4857"
+
+[[package]]
+name = "rand"
+version = "0.8.4"
+source = "git+https://github.com/rust-random/rand.git?branch=master#fcc5baf31565a94f63dce41c2e739e6f182475f4"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "git+https://github.com/rust-random/rand.git?branch=master#fcc5baf31565a94f63dce41c2e739e6f182475f4"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.3"
+source = "git+https://github.com/rust-random/rand.git?branch=master#fcc5baf31565a94f63dce41c2e739e6f182475f4"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "wasi"
+version = "0.10.2+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"

pkgs/build-support/rust/test/import-cargo-lock/git-dependency-branch/Cargo.toml

···
+[package]
+name = "git-dependency-branch"
+version = "0.1.0"
+authors = ["Daniël de Kok <[e-mail]>"]
+edition = "2018"
+
+[dependencies]
+rand = { git = "https://github.com/rust-random/rand.git", branch = "master" }

pkgs/build-support/rust/test/import-cargo-lock/git-dependency-branch/default.nix

···
+{ rustPlatform }:
+
+rustPlatform.buildRustPackage {
+  pname = "git-dependency-branch";
+  version = "0.1.0";
+
+  src = ./.;
+
+  cargoLock = {
+    lockFile = ./Cargo.lock;
+    outputHashes = {
+      "rand-0.8.4" = "1ilk9wvfw3mdm57g199ys8f5nrgdrh0n3a4c8b7nz6lgnqvfrv6z";
+    };
+  };
+
+  doInstallCheck = true;
+
+  installCheckPhase = ''
+    $out/bin/git-dependency-branch
+  '';
+}

pkgs/build-support/rust/test/import-cargo-lock/git-dependency-branch/src/main.rs

···
+use rand::Rng;
+
+fn main() {
+    let mut rng = rand::thread_rng();
+
+    // Always draw zero :).
+    let roll: u8 = rng.gen_range(0..1);
+    assert_eq!(roll, 0);
+}

pkgs/build-support/rust/test/import-cargo-lock/git-dependency-no-rev/Cargo.lock pkgs/build-support/rust/test/import-cargo-lock/git-dependency-rev/Cargo.lock

···
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
+version = 3
+
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
···
 ]
 
 [[package]]
-name = "git-dependency-no-rev"
+name = "git-dependency-rev"
 version = "0.1.0"
 dependencies = [
  "rand",
···
 [[package]]
 name = "rand"
 version = "0.8.3"
-source = "git+https://github.com/rust-random/rand.git#f0e01ee0a7257753cc51b291f62666f4765923ef"
+source = "git+https://github.com/rust-random/rand.git?rev=0.8.3#6ecbe2626b2cc6110a25c97b1702b347574febc7"
 dependencies = [
  "libc",
  "rand_chacha",
···
 [[package]]
 name = "rand_chacha"
 version = "0.3.0"
-source = "git+https://github.com/rust-random/rand.git#f0e01ee0a7257753cc51b291f62666f4765923ef"
+source = "git+https://github.com/rust-random/rand.git?rev=0.8.3#6ecbe2626b2cc6110a25c97b1702b347574febc7"
 dependencies = [
  "ppv-lite86",
  "rand_core",
···
 
 [[package]]
 name = "rand_core"
-version = "0.6.2"
-source = "git+https://github.com/rust-random/rand.git#f0e01ee0a7257753cc51b291f62666f4765923ef"
+version = "0.6.1"
+source = "git+https://github.com/rust-random/rand.git?rev=0.8.3#6ecbe2626b2cc6110a25c97b1702b347574febc7"
 dependencies = [
  "getrandom",
 ]
···
 [[package]]
 name = "rand_hc"
 version = "0.3.0"
-source = "git+https://github.com/rust-random/rand.git#f0e01ee0a7257753cc51b291f62666f4765923ef"
+source = "git+https://github.com/rust-random/rand.git?rev=0.8.3#6ecbe2626b2cc6110a25c97b1702b347574febc7"
 dependencies = [
  "rand_core",
 ]

pkgs/build-support/rust/test/import-cargo-lock/git-dependency-no-rev/Cargo.toml

···
-[package]
-name = "git-dependency-no-rev"
-version = "0.1.0"
-authors = ["Daniël de Kok <[e-mail]>"]
-edition = "2018"
-
-[dependencies]
-rand = { git = "https://github.com/rust-random/rand.git" }

pkgs/build-support/rust/test/import-cargo-lock/git-dependency-no-rev/default.nix pkgs/build-support/rust/test/import-cargo-lock/git-dependency-tag/default.nix

···
 { rustPlatform }:
 
 rustPlatform.buildRustPackage {
-  pname = "git-dependency-no-rev";
+  pname = "git-dependency-tag";
   version = "0.1.0";
 
   src = ./.;
···
   cargoLock = {
     lockFile = ./Cargo.lock;
     outputHashes = {
-      "rand-0.8.3" = "0ya2hia3cn31qa8894s3av2s8j5bjwb6yq92k0jsnlx7jid0jwqa";
+      "rand-0.8.3" = "0l3p174bpwia61vcvxz5mw65a13ri3wy94z04xrnyy5lzciykz4f";
     };
   };
 
   doInstallCheck = true;
 
   installCheckPhase = ''
-    $out/bin/git-dependency-no-rev
+    $out/bin/git-dependency-tag
   '';
 }

pkgs/build-support/rust/test/import-cargo-lock/git-dependency-rev/Cargo.toml

···
+[package]
+name = "git-dependency-rev"
+version = "0.1.0"
+authors = ["Daniël de Kok <[e-mail]>"]
+edition = "2018"
+
+[dependencies]
+rand = { git = "https://github.com/rust-random/rand.git", rev = "0.8.3" }

pkgs/build-support/rust/test/import-cargo-lock/git-dependency-rev/default.nix

···
+{ rustPlatform }:
+
+rustPlatform.buildRustPackage {
+  pname = "git-dependency-rev";
+  version = "0.1.0";
+
+  src = ./.;
+
+  cargoLock = {
+    lockFile = ./Cargo.lock;
+    outputHashes = {
+      "rand-0.8.3" = "0l3p174bpwia61vcvxz5mw65a13ri3wy94z04xrnyy5lzciykz4f";
+    };
+  };
+
+  doInstallCheck = true;
+
+  installCheckPhase = ''
+    $out/bin/git-dependency-rev
+  '';
+}

pkgs/build-support/rust/test/import-cargo-lock/git-dependency-tag/Cargo.lock

···
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "getrandom"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c9495705279e7140bf035dde1f6e750c162df8b625267cd52cc44e0b156732c8"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "git-dependency-tag"
+version = "0.1.0"
+dependencies = [
+ "rand",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.94"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18794a8ad5b29321f790b55d93dfba91e125cb1a9edbd4f8e3150acc771c1a5e"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac74c624d6b2d21f425f752262f42188365d7b8ff1aff74c82e45136510a4857"
+
+[[package]]
+name = "rand"
+version = "0.8.3"
+source = "git+https://github.com/rust-random/rand.git?tag=0.8.3#6ecbe2626b2cc6110a25c97b1702b347574febc7"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+ "rand_hc",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.0"
+source = "git+https://github.com/rust-random/rand.git?tag=0.8.3#6ecbe2626b2cc6110a25c97b1702b347574febc7"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.1"
+source = "git+https://github.com/rust-random/rand.git?tag=0.8.3#6ecbe2626b2cc6110a25c97b1702b347574febc7"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rand_hc"
+version = "0.3.0"
+source = "git+https://github.com/rust-random/rand.git?tag=0.8.3#6ecbe2626b2cc6110a25c97b1702b347574febc7"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "wasi"
+version = "0.10.2+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"

pkgs/build-support/rust/test/import-cargo-lock/git-dependency-tag/Cargo.toml

···
+[package]
+name = "git-dependency-tag"
+version = "0.1.0"
+authors = ["Daniël de Kok <[e-mail]>"]
+edition = "2018"
+
+[dependencies]
+rand = { git = "https://github.com/rust-random/rand.git", tag = "0.8.3" }

pkgs/build-support/rust/test/import-cargo-lock/git-dependency-tag/src/main.rs

···
+use rand::Rng;
+
+fn main() {
+    let mut rng = rand::thread_rng();
+
+    // Always draw zero :).
+    let roll: u8 = rng.gen_range(0..1);
+    assert_eq!(roll, 0);
+}

pkgs/build-support/rust/test/import-cargo-lock/git-dependency/Cargo.lock

···
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
+version = 3
+
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
···
 [[package]]
 name = "rand"
 version = "0.8.3"
-source = "git+https://github.com/rust-random/rand.git?rev=0.8.3#6ecbe2626b2cc6110a25c97b1702b347574febc7"
+source = "git+https://github.com/rust-random/rand.git#f0e01ee0a7257753cc51b291f62666f4765923ef"
 dependencies = [
  "libc",
  "rand_chacha",
···
 [[package]]
 name = "rand_chacha"
 version = "0.3.0"
-source = "git+https://github.com/rust-random/rand.git?rev=0.8.3#6ecbe2626b2cc6110a25c97b1702b347574febc7"
+source = "git+https://github.com/rust-random/rand.git#f0e01ee0a7257753cc51b291f62666f4765923ef"
 dependencies = [
  "ppv-lite86",
  "rand_core",
···
 
 [[package]]
 name = "rand_core"
-version = "0.6.1"
-source = "git+https://github.com/rust-random/rand.git?rev=0.8.3#6ecbe2626b2cc6110a25c97b1702b347574febc7"
+version = "0.6.2"
+source = "git+https://github.com/rust-random/rand.git#f0e01ee0a7257753cc51b291f62666f4765923ef"
 dependencies = [
  "getrandom",
 ]
···
 [[package]]
 name = "rand_hc"
 version = "0.3.0"
-source = "git+https://github.com/rust-random/rand.git?rev=0.8.3#6ecbe2626b2cc6110a25c97b1702b347574febc7"
+source = "git+https://github.com/rust-random/rand.git#f0e01ee0a7257753cc51b291f62666f4765923ef"
 dependencies = [
  "rand_core",
 ]

pkgs/build-support/rust/test/import-cargo-lock/git-dependency/Cargo.toml

···
 edition = "2018"
 
 [dependencies]
-rand = { git = "https://github.com/rust-random/rand.git", rev = "0.8.3" }
+rand = { git = "https://github.com/rust-random/rand.git" }

pkgs/build-support/rust/test/import-cargo-lock/git-dependency/default.nix

···
   cargoLock = {
     lockFile = ./Cargo.lock;
     outputHashes = {
-      "rand-0.8.3" = "0l3p174bpwia61vcvxz5mw65a13ri3wy94z04xrnyy5lzciykz4f";
+      "rand-0.8.3" = "0ya2hia3cn31qa8894s3av2s8j5bjwb6yq92k0jsnlx7jid0jwqa";
     };
   };
 

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "182ca4558e20c333fb3f4c659b2af4267d4d9b46",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/182ca4558e20c333fb3f4c659b2af4267d4d9b46.tar.gz",
-  "sha256": "123dr3lza56nj7s53m37zm2qfvwl2qvrr2prwl0q32wzidfc12w9",
-  "msg": "Update from Hackage at 2021-09-03T13:28:39Z"
+  "commit": "332975af73ba6dc258ab7e103f00619e9bebeea2",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/332975af73ba6dc258ab7e103f00619e9bebeea2.tar.gz",
+  "sha256": "1fkc19vqylyjbhqa414mnz5ny235vp1f0wz70a2lbf5cwzg6185f",
+  "msg": "Update from Hackage at 2021-09-06T23:06:06Z"
 }

pkgs/development/compilers/ghc/8.10.7.nix

···
     GhcRtsHcOpts += -fPIC
   '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
     EXTRA_CC_OPTS += -std=gnu99
+  ''
+  # While split sections are now enabled by default in ghc 8.8 for windows,
+  # they seem to lead to `too many sections` errors when building base for
+  # profiling.
+  + lib.optionalString targetPlatform.isWindows ''
+    SplitSections = NO
   '';
 
   # Splicer will pull out correct variations
···
     # upstream patch. Don't forget to check backport status of the upstream patch
     # when adding new GHC releases in nixpkgs.
     ./respect-ar-path.patch
+
+    # cabal passes incorrect --host= when cross-compiling
+    # https://github.com/haskell/cabal/issues/5887
+    (fetchpatch {
+            url = "https://raw.githubusercontent.com/input-output-hk/haskell.nix/122bd81150386867da07fdc9ad5096db6719545a/overlays/patches/ghc/cabal-host.patch";
+      sha256 = "sha256:0yd0sajgi24sc1w5m55lkg2lp6kfkgpp3lgija2c8y3cmkwfpdc1";
+    })
   ] ++ lib.optionals stdenv.isDarwin [
     # Make Block.h compile with c++ compilers. Remove with the next release
     (fetchpatch {

pkgs/development/compilers/ghc/8.8.4.nix

···
 
 # build-tools
 , bootPkgs
-, autoconf, automake, coreutils, fetchurl, perl, python3, m4, sphinx
+, autoconf, automake, coreutils, fetchpatch, fetchurl, perl, python3, m4, sphinx
 , bash
 
 , libiconv ? null, ncurses
···
     GhcRtsHcOpts += -fPIC
   '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
     EXTRA_CC_OPTS += -std=gnu99
+  ''
+  # While split sections are now enabled by default in ghc 8.8 for windows,
+  # they seem to lead to `too many sections` errors when building base for
+  # profiling.
+  + lib.optionalString targetPlatform.isWindows ''
+    SplitSections = NO
   '';
 
   # Splicer will pull out correct variations
···
     # Fix documentation configuration which causes a syntax error with sphinx 4.*
     # See also https://gitlab.haskell.org/ghc/ghc/-/issues/19962
     ./sphinx-4-configuration.patch
+    # cabal passes incorrect --host= when cross-compiling
+    # https://github.com/haskell/cabal/issues/5887
+    (fetchpatch {
+            url = "https://raw.githubusercontent.com/input-output-hk/haskell.nix/122bd81150386867da07fdc9ad5096db6719545a/overlays/patches/ghc/cabal-host.patch";
+      sha256 = "sha256:0yd0sajgi24sc1w5m55lkg2lp6kfkgpp3lgija2c8y3cmkwfpdc1";
+    })
+
+    # error: 'VirtualAllocExNuma' redeclared as different kind of symbol
+    # name conflict between rts/win32/OSMem.c and winbase.h from the mingw-w64 runtime package
+    # Renamed to match ghc8.8:
+    # https://gitlab.haskell.org/ghc/ghc/-/commit/4b431f334018eaef2cf36de3316025c68c922915#20d64c0bdc272817149d1d5cf20a73a8b5fd637f
+    ./rename-numa-api-call.patch
   ];
 
   postPatch = "patchShebangs .";

pkgs/development/compilers/ghc/rename-numa-api-call.patch

···
+diff --git a/rts/win32/OSMem.c b/rts/win32/OSMem.c
+--- a/rts/win32/OSMem.c
++++ b/rts/win32/OSMem.c
+@@ -41,7 +41,7 @@ static block_rec* free_blocks = NULL;
+ typedef LPVOID(WINAPI *VirtualAllocExNumaProc)(HANDLE, LPVOID, SIZE_T, DWORD, DWORD, DWORD);
+
+ /* Cache NUMA API call. */
+-VirtualAllocExNumaProc VirtualAllocExNuma;
++VirtualAllocExNumaProc _VirtualAllocExNuma;
+
+ void
+ osMemInit(void)
+@@ -52,8 +52,8 @@ osMemInit(void)
+     /* Resolve and cache VirtualAllocExNuma. */
+     if (osNumaAvailable() && RtsFlags.GcFlags.numa)
+     {
+-        VirtualAllocExNuma = (VirtualAllocExNumaProc)GetProcAddress(GetModuleHandleW(L"kernel32"), "VirtualAllocExNuma");
+-        if (!VirtualAllocExNuma)
++        _VirtualAllocExNuma = (VirtualAllocExNumaProc)(void*)GetProcAddress(GetModuleHandleW(L"kernel32"), "VirtualAllocExNuma");
++        if (!_VirtualAllocExNuma)
+         {
+             sysErrorBelch(
+                 "osBindMBlocksToNode: VirtualAllocExNuma does not exist. How did you get this far?");
+@@ -569,7 +569,7 @@ void osBindMBlocksToNode(
+                On windows also -xb is broken, it does nothing so that can't
+                be used to tweak it (see #12577). So for now, just let the OS decide.
+             */
+-            temp = VirtualAllocExNuma(
++            temp = _VirtualAllocExNuma(
+                           GetCurrentProcess(),
+                           NULL, // addr? See base memory
+                           size,

pkgs/development/compilers/go/1.17.nix

···
+{ lib
+, stdenv
+, fetchurl
+, tzdata
+, iana-etc
+, runCommand
+, perl
+, which
+, pkg-config
+, patch
+, procps
+, pcre
+, cacert
+, Security
+, Foundation
+, xcbuild
+, mailcap
+, runtimeShell
+, buildPackages
+, pkgsBuildTarget
+, callPackage
+}:
+
+let
+  go_bootstrap = buildPackages.callPackage ./bootstrap.nix { };
+
+  goBootstrap = runCommand "go-bootstrap" { } ''
+    mkdir $out
+    cp -rf ${go_bootstrap}/* $out/
+    chmod -R u+w $out
+    find $out -name "*.c" -delete
+    cp -rf $out/bin/* $out/share/go/bin/
+  '';
+
+  goarch = platform: {
+    "i686" = "386";
+    "x86_64" = "amd64";
+    "aarch64" = "arm64";
+    "arm" = "arm";
+    "armv5tel" = "arm";
+    "armv6l" = "arm";
+    "armv7l" = "arm";
+    "powerpc64le" = "ppc64le";
+  }.${platform.parsed.cpu.name} or (throw "Unsupported system");
+
+  # We need a target compiler which is still runnable at build time,
+  # to handle the cross-building case where build != host == target
+  targetCC = pkgsBuildTarget.targetPackages.stdenv.cc;
+in
+
+stdenv.mkDerivation rec {
+  pname = "go";
+  version = "1.17.1";
+
+  src = fetchurl {
+    url = "https://dl.google.com/go/go${version}.src.tar.gz";
+    sha256 = "sha256-SdwIM5dwrNVhMxLbjBQer2F3mZVXe4nZO1Qe+DBn5bE=";
+  };
+
+  # perl is used for testing go vet
+  nativeBuildInputs = [ perl which pkg-config patch procps ];
+  buildInputs = [ cacert pcre ]
+    ++ lib.optionals stdenv.isLinux [ stdenv.cc.libc.out ]
+    ++ lib.optionals (stdenv.hostPlatform.libc == "glibc") [ stdenv.cc.libc.static ];
+
+  propagatedBuildInputs = lib.optionals stdenv.isDarwin [ xcbuild ];
+
+  depsTargetTargetPropagated = lib.optionals stdenv.isDarwin [ Security Foundation ];
+
+  hardeningDisable = [ "all" ];
+
+  prePatch = ''
+    patchShebangs ./ # replace /bin/bash
+
+    # This source produces shell script at run time,
+    # and thus it is not corrected by patchShebangs.
+    substituteInPlace misc/cgo/testcarchive/carchive_test.go \
+      --replace '#!/usr/bin/env bash' '#!${runtimeShell}'
+
+    # Patch the mimetype database location which is missing on NixOS.
+    # but also allow static binaries built with NixOS to run outside nix
+    sed -i 's,\"/etc/mime.types,"${mailcap}/etc/mime.types\"\,\n\t&,' src/mime/type_unix.go
+
+    # Disabling the 'os/http/net' tests (they want files not available in
+    # chroot builds)
+    rm src/net/{listen,parse}_test.go
+    rm src/syscall/exec_linux_test.go
+
+    # !!! substituteInPlace does not seems to be effective.
+    # The os test wants to read files in an existing path. Just don't let it be /usr/bin.
+    sed -i 's,/usr/bin,'"`pwd`", src/os/os_test.go
+    sed -i 's,/bin/pwd,'"`type -P pwd`", src/os/os_test.go
+    # Fails on aarch64
+    sed -i '/TestFallocate/aif true \{ return\; \}' src/cmd/link/internal/ld/fallocate_test.go
+    # Skip this test since ssl patches mess it up.
+    sed -i '/TestLoadSystemCertsLoadColonSeparatedDirs/aif true \{ return\; \}' src/crypto/x509/root_unix_test.go
+    # Disable another PIE test which breaks.
+    sed -i '/TestTrivialPIE/aif true \{ return\; \}' misc/cgo/testshared/shared_test.go
+    # Disable the BuildModePie test
+    sed -i '/TestBuildmodePIE/aif true \{ return\; \}' src/cmd/go/go_test.go
+    # Disable the unix socket test
+    sed -i '/TestShutdownUnix/aif true \{ return\; \}' src/net/net_test.go
+    # Disable the hostname test
+    sed -i '/TestHostname/aif true \{ return\; \}' src/os/os_test.go
+    # ParseInLocation fails the test
+    sed -i '/TestParseInSydney/aif true \{ return\; \}' src/time/format_test.go
+    # Remove the api check as it never worked
+    sed -i '/src\/cmd\/api\/run.go/ireturn nil' src/cmd/dist/test.go
+    # Remove the coverage test as we have removed this utility
+    sed -i '/TestCoverageWithCgo/aif true \{ return\; \}' src/cmd/go/go_test.go
+    # Remove the timezone naming test
+    sed -i '/TestLoadFixed/aif true \{ return\; \}' src/time/time_test.go
+    # Remove disable setgid test
+    sed -i '/TestRespectSetgidDir/aif true \{ return\; \}' src/cmd/go/internal/work/build_test.go
+    # Remove cert tests that conflict with NixOS's cert resolution
+    sed -i '/TestEnvVars/aif true \{ return\; \}' src/crypto/x509/root_unix_test.go
+    # TestWritevError hangs sometimes
+    sed -i '/TestWritevError/aif true \{ return\; \}' src/net/writev_test.go
+    # TestVariousDeadlines fails sometimes
+    sed -i '/TestVariousDeadlines/aif true \{ return\; \}' src/net/timeout_test.go
+
+    sed -i 's,/etc/protocols,${iana-etc}/etc/protocols,' src/net/lookup_unix.go
+    sed -i 's,/etc/services,${iana-etc}/etc/services,' src/net/port_unix.go
+
+    # Disable cgo lookup tests not works, they depend on resolver
+    rm src/net/cgo_unix_test.go
+
+  '' + lib.optionalString stdenv.isLinux ''
+    # prepend the nix path to the zoneinfo files but also leave the original value for static binaries
+    # that run outside a nix server
+    sed -i 's,\"/usr/share/zoneinfo/,"${tzdata}/share/zoneinfo/\"\,\n\t&,' src/time/zoneinfo_unix.go
+
+  '' + lib.optionalString stdenv.isAarch32 ''
+    echo '#!${runtimeShell}' > misc/cgo/testplugin/test.bash
+  '' + lib.optionalString stdenv.isDarwin ''
+    substituteInPlace src/race.bash --replace \
+      "sysctl machdep.cpu.extfeatures | grep -qv EM64T" true
+    sed -i 's,strings.Contains(.*sysctl.*,true {,' src/cmd/dist/util.go
+    sed -i 's,"/etc","'"$TMPDIR"'",' src/os/os_test.go
+    sed -i 's,/_go_os_test,'"$TMPDIR"'/_go_os_test,' src/os/path_test.go
+
+    sed -i '/TestChdirAndGetwd/aif true \{ return\; \}' src/os/os_test.go
+    sed -i '/TestCredentialNoSetGroups/aif true \{ return\; \}' src/os/exec/exec_posix_test.go
+    sed -i '/TestRead0/aif true \{ return\; \}' src/os/os_test.go
+    sed -i '/TestSystemRoots/aif true \{ return\; \}' src/crypto/x509/root_darwin_test.go
+
+    sed -i '/TestGoInstallRebuildsStalePackagesInOtherGOPATH/aif true \{ return\; \}' src/cmd/go/go_test.go
+    sed -i '/TestBuildDashIInstallsDependencies/aif true \{ return\; \}' src/cmd/go/go_test.go
+
+    sed -i '/TestDisasmExtld/aif true \{ return\; \}' src/cmd/objdump/objdump_test.go
+
+    sed -i 's/unrecognized/unknown/' src/cmd/link/internal/ld/lib.go
+
+    # TestCurrent fails because Current is not implemented on Darwin
+    sed -i 's/TestCurrent/testCurrent/g' src/os/user/user_test.go
+    sed -i 's/TestLookup/testLookup/g' src/os/user/user_test.go
+
+    touch $TMPDIR/group $TMPDIR/hosts $TMPDIR/passwd
+  '';
+
+  patches = [
+    ./remove-tools-1.11.patch
+    ./ssl-cert-file-1.16.patch
+    ./remove-test-pie-1.15.patch
+    ./creds-test.patch
+    ./go-1.9-skip-flaky-19608.patch
+    ./go-1.9-skip-flaky-20072.patch
+    ./skip-external-network-tests-1.16.patch
+    ./skip-nohup-tests.patch
+    ./skip-cgo-tests-1.15.patch
+    ./go_no_vendor_checks-1.16.patch
+  ] ++ [
+    # breaks under load: https://github.com/golang/go/issues/25628
+    (if stdenv.isAarch32
+    then ./skip-test-extra-files-on-aarch32-1.14.patch
+    else ./skip-test-extra-files-on-386-1.14.patch)
+  ];
+
+  postPatch = ''
+    find . -name '*.orig' -exec rm {} ';'
+  '';
+
+  GOOS = stdenv.targetPlatform.parsed.kernel.name;
+  GOARCH = goarch stdenv.targetPlatform;
+  # GOHOSTOS/GOHOSTARCH must match the building system, not the host system.
+  # Go will nevertheless build a for host system that we will copy over in
+  # the install phase.
+  GOHOSTOS = stdenv.buildPlatform.parsed.kernel.name;
+  GOHOSTARCH = goarch stdenv.buildPlatform;
+
+  # {CC,CXX}_FOR_TARGET must be only set for cross compilation case as go expect those
+  # to be different from CC/CXX
+  CC_FOR_TARGET =
+    if (stdenv.buildPlatform != stdenv.targetPlatform) then
+      "${targetCC}/bin/${targetCC.targetPrefix}cc"
+    else
+      null;
+  CXX_FOR_TARGET =
+    if (stdenv.buildPlatform != stdenv.targetPlatform) then
+      "${targetCC}/bin/${targetCC.targetPrefix}c++"
+    else
+      null;
+
+  GOARM = toString (lib.intersectLists [ (stdenv.hostPlatform.parsed.cpu.version or "") ] [ "5" "6" "7" ]);
+  GO386 = "softfloat"; # from Arch: don't assume sse2 on i686
+  CGO_ENABLED = 1;
+  # Hopefully avoids test timeouts on Hydra
+  GO_TEST_TIMEOUT_SCALE = 3;
+
+  # Indicate that we are running on build infrastructure
+  # Some tests assume things like home directories and users exists
+  GO_BUILDER_NAME = "nix";
+
+  GOROOT_BOOTSTRAP = "${goBootstrap}/share/go";
+
+  postConfigure = ''
+    export GOCACHE=$TMPDIR/go-cache
+    # this is compiled into the binary
+    export GOROOT_FINAL=$out/share/go
+
+    export PATH=$(pwd)/bin:$PATH
+
+    ${lib.optionalString (stdenv.buildPlatform != stdenv.targetPlatform) ''
+    # Independent from host/target, CC should produce code for the building system.
+    # We only set it when cross-compiling.
+    export CC=${buildPackages.stdenv.cc}/bin/cc
+    ''}
+    ulimit -a
+  '';
+
+  postBuild = ''
+    (cd src && ./make.bash)
+  '';
+
+  doCheck = stdenv.hostPlatform == stdenv.targetPlatform && !stdenv.isDarwin;
+
+  checkPhase = ''
+    runHook preCheck
+    (cd src && HOME=$TMPDIR GOCACHE=$TMPDIR/go-cache ./run.bash --no-rebuild)
+    runHook postCheck
+  '';
+
+  preInstall = ''
+    rm -r pkg/obj
+    # Contains the wrong perl shebang when cross compiling,
+    # since it is not used for anything we can deleted as well.
+    rm src/regexp/syntax/make_perl_groups.pl
+  '' + (if (stdenv.buildPlatform != stdenv.hostPlatform) then ''
+    mv bin/*_*/* bin
+    rmdir bin/*_*
+    ${lib.optionalString (!(GOHOSTARCH == GOARCH && GOOS == GOHOSTOS)) ''
+      rm -rf pkg/${GOHOSTOS}_${GOHOSTARCH} pkg/tool/${GOHOSTOS}_${GOHOSTARCH}
+    ''}
+  '' else if (stdenv.hostPlatform != stdenv.targetPlatform) then ''
+    rm -rf bin/*_*
+    ${lib.optionalString (!(GOHOSTARCH == GOARCH && GOOS == GOHOSTOS)) ''
+      rm -rf pkg/${GOOS}_${GOARCH} pkg/tool/${GOOS}_${GOARCH}
+    ''}
+  '' else "");
+
+  installPhase = ''
+    runHook preInstall
+    mkdir -p $GOROOT_FINAL
+    cp -a bin pkg src lib misc api doc $GOROOT_FINAL
+    ln -s $GOROOT_FINAL/bin $out/bin
+    runHook postInstall
+  '';
+
+  disallowedReferences = [ goBootstrap ];
+
+  meta = with lib; {
+    homepage = "http://golang.org/";
+    description = "The Go Programming language";
+    license = licenses.bsd3;
+    maintainers = teams.golang.members;
+    platforms = platforms.linux ++ platforms.darwin;
+    # requires >=10.13 stdenv on x86_64-darwin
+    badPlatforms = [ "x86_64-darwin" ];
+  };
+}

pkgs/development/compilers/llvm/12/llvm/default.nix

···
   buildInputs = [ libxml2 libffi ]
     ++ optional enablePFM libpfm; # exegesis
 
-  propagatedBuildInputs = [ ncurses zlib ];
+  propagatedBuildInputs = optionals (stdenv.buildPlatform == stdenv.hostPlatform) [ ncurses ]
+    ++ [ zlib ];
 
   patches = [
     ./gnu-install-dirs.patch

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 = "0kcsb5kqyx256fp1bj3y0x6k3286j4cykrx0yr4k3vvb3maakf7k";
+      sha256 = "1022ff2x9jvi2a0820lbgmmh54cxh1vbn0qfdwr50w7ggvjp88i6";
       # 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
···
   chs-cabal = super.chs-cabal.override {
     Cabal = self.Cabal_3_6_0_0;
   };
-
-  # ghc-api-compat needlessly requires 8.10.5 exactly, but we have 8.10.6
-  ghc-api-compat = doJailbreak super.ghc-api-compat;
 
   # 2021-08-18: streamly-posix was released with hspec 2.8.2, but it works with older versions too.
   streamly-posix = doJailbreak super.streamly-posix;

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

···
   # vector 0.12.2 indroduced doctest checks that don‘t work on older compilers
   vector = dontCheck super.vector;
 
-  ghc-api-compat = super.ghc-api-compat_8_6;
+  ghc-api-compat = doDistribute super.ghc-api-compat_8_6;
 }

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

···
   retry = dontCheck super.retry;
 
   # hlint 3.3 needs a ghc-lib-parser newer than the one from stackage
-  hlint = super.hlint_3_3_1.overrideScope (self: super: {
+  hlint = super.hlint_3_3_4.overrideScope (self: super: {
     ghc-lib-parser = overrideCabal self.ghc-lib-parser_9_0_1_20210324 {
       doHaddock = false;
     };
     ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_0_0_4;
   });
+
+  # pick right version for compiler
+  ghc-api-compat = doDistribute super.ghc-api-compat_9_0_1;
 }

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

···
   retry = dontCheck super.retry;
 
   # hlint 3.3 needs a ghc-lib-parser newer than the one from stackage
-  hlint = super.hlint_3_3_1.overrideScope (self: super: {
+  hlint = super.hlint_3_3_4.overrideScope (self: super: {
     ghc-lib-parser = overrideCabal self.ghc-lib-parser_9_0_1_20210324 {
       doHaddock = false;
     };

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

···
   - docvim
   - dominion
   - domplate
+  - dormouse-uri
   - do-spaces
   - dotfs
   - dot-linker
···
   - servant-auth-hmac
   - servant-auth-token-api
   - servant-avro
+  - servant-benchmark
   - servant-client-js
   - servant-db
   - servant-dhall
···
   - urldecode
   - url-decoders
   - urldisp-happstack
-  - urlencoded
   - url-generic
   - urn
   - urn-random

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

···
   - dhall-nix < 1.1.22
   # reflex-dom-pandoc is only used by neuron which needs a version < 1.0.0.0
   - reflex-dom-pandoc < 1.0.0.0
+  # 2021-09-07: pin to our current GHC version
+  - ghc-api-compat == 8.10.7
 
 extra-packages:
   - base16-bytestring < 1               # required for cabal-install etc.
···
   - crackNum < 3.0                      # 2021-05-21: 3.0 removed the lib which sbv 7.13 uses
   - ShellCheck == 0.7.1                 # 2021-05-09: haskell-ci 0.12.1 pins this version
   - cabal-install-parsers == 0.4.2      # 2021-09-04: needed haskell-ci by until it upgrades to Cabal >= 3.6
-  - ghc-api-compat < 8.10.5             # 2021-08-18: ghc-api-compat 8.10.5 is only compatible with ghc 8.10.5
+  - ghc-api-compat == 8.6               # 2021-09-07: preserve for GHC 8.8.4
 
 package-maintainers:
   abbradar:

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

···
-# Stackage LTS 18.8
+# Stackage LTS 18.9
 # This file is auto-generated by
 # maintainers/scripts/haskell/update-stackage.sh
 default-package-overrides:
···
   - base-compat ==0.11.2
   - base-compat-batteries ==0.11.2
   - basement ==0.0.12
-  - base-orphans ==0.8.4
+  - base-orphans ==0.8.5
   - base-prelude ==1.4
   - base-unicode-symbols ==0.2.4.2
   - basic-prelude ==0.7.0
···
   - blaze-html ==0.9.1.2
   - blaze-markup ==0.8.2.8
   - blaze-svg ==0.3.6.1
-  - blaze-textual ==0.2.1.0
+  - blaze-textual ==0.2.2.1
   - bmp ==1.2.6.3
   - BNFC ==2.9.2
   - BNFC-meta ==0.6.1
···
   - convertible ==1.1.1.0
   - cookie ==0.4.5
   - core-data ==0.2.1.9
-  - core-program ==0.2.7.1
-  - core-text ==0.3.0.0
+  - core-program ==0.2.9.1
+  - core-text ==0.3.2.0
   - countable ==1.0
   - country ==0.2.1
   - cpphs ==1.20.9.1
···
   - distributed-closure ==0.4.2.0
   - distribution-opensuse ==1.1.1
   - distributive ==0.6.2.1
-  - dl-fedora ==0.9
+  - dl-fedora ==0.9.1
   - dlist ==1.0
   - dlist-instances ==0.1.1.1
   - dlist-nonempty ==0.1.1
···
   - errors ==2.3.0
   - errors-ext ==0.4.2
   - ersatz ==0.4.9
-  - esqueleto ==3.5.2.1
+  - esqueleto ==3.5.2.2
   - essence-of-live-coding ==0.2.5
   - essence-of-live-coding-gloss ==0.2.5
   - essence-of-live-coding-pulse ==0.2.5
···
   - FenwickTree ==0.1.2.1
   - fft ==0.1.8.7
   - fgl ==5.7.0.3
-  - file-embed ==0.0.14.0
+  - file-embed ==0.0.15.0
   - file-embed-lzma ==0
   - filelock ==0.1.1.5
   - filemanip ==0.3.6.3
···
   - generic-constraints ==1.1.1.1
   - generic-data ==0.9.2.0
   - generic-data-surgery ==0.3.0.0
-  - generic-deriving ==1.14
+  - generic-deriving ==1.14.1
   - generic-functor ==0.2.0.0
   - generic-lens ==2.1.0.0
   - generic-lens-core ==2.1.0.0
···
   - hgeometry-combinatorial ==0.12.0.3
   - hgrev ==0.2.6
   - hidapi ==0.1.7
-  - hie-bios ==0.7.5
+  - hie-bios ==0.7.6
   - hi-file-parser ==0.1.2.0
   - higher-leveldb ==0.6.0.0
   - highlighting-kate ==0.6.4
···
   - hmpfr ==0.4.4
   - hnock ==0.4.0
   - hoauth2 ==1.16.0
-  - hoogle ==5.0.18.1
+  - hoogle ==5.0.18.2
   - hOpenPGP ==2.9.5
   - hopenpgp-tools ==0.23.6
   - hopenssl ==2.2.4
···
   - linux-namespaces ==0.1.3.0
   - liquid-fixpoint ==0.8.10.2
   - List ==0.6.2
-  - ListLike ==4.7.4
+  - ListLike ==4.7.6
   - list-predicate ==0.1.0.1
   - listsafe ==0.1.0.1
   - list-singleton ==1.0.0.5
···
   - optional-args ==1.0.2
   - options ==1.2.1.1
   - optparse-applicative ==0.16.1.0
-  - optparse-generic ==1.4.4
+  - optparse-generic ==1.4.5
   - optparse-simple ==0.1.1.4
   - optparse-text ==0.1.1.0
   - ordered-containers ==0.2.2
···
   - persist ==0.1.1.5
   - persistable-record ==0.6.0.5
   - persistable-types-HDBC-pg ==0.0.3.5
-  - persistent ==2.13.1.1
+  - persistent ==2.13.1.2
   - persistent-mtl ==0.2.2.0
-  - persistent-mysql ==2.13.0.1
+  - persistent-mysql ==2.13.0.2
   - persistent-pagination ==0.1.1.2
   - persistent-postgresql ==2.13.0.3
   - persistent-qq ==2.12.0.1
···
   - reanimate ==1.1.4.0
   - reanimate-svg ==0.13.0.1
   - rebase ==1.13.0.1
-  - record-dot-preprocessor ==0.2.11
+  - record-dot-preprocessor ==0.2.12
   - record-hasfield ==1.0
   - records-sop ==0.1.1.0
   - record-wrangler ==0.1.1.0
···
   - semialign-optics ==1.1
   - semigroupoid-extras ==5
   - semigroupoids ==5.3.5
-  - semigroups ==0.19.1
+  - semigroups ==0.19.2
   - semirings ==0.6
   - semiring-simple ==1.0.0.1
   - semver ==0.4.0.1
···
   - text-regex-replace ==0.1.1.4
   - text-region ==0.3.1.0
   - text-short ==0.1.3
-  - text-show ==3.9
+  - text-show ==3.9.2
   - text-show-instances ==3.8.4
   - text-zipper ==0.11
   - tfp ==1.0.2
   - tf-random ==0.5
-  - th-abstraction ==0.4.2.0
+  - th-abstraction ==0.4.3.0
   - th-bang-compat ==0.0.1.0
-  - th-compat ==0.1.2
+  - th-compat ==0.1.3
   - th-constraint-compat ==0.0.1.0
   - th-data-compat ==0.1.0.0
   - th-desugar ==1.11
···
   - th-lift ==0.8.2
   - th-lift-instances ==0.1.18
   - th-nowq ==0.1.0.5
-  - th-orphans ==0.13.11
+  - th-orphans ==0.13.12
   - th-printf ==0.7
   - thread-hierarchy ==0.3.0.2
   - thread-local-storage ==0.2
···
   - unix-bytestring ==0.3.7.3
   - unix-compat ==0.5.3
   - unix-time ==0.4.7
-  - unliftio ==0.2.19
+  - unliftio ==0.2.20
   - unliftio-core ==0.2.0.1
   - unliftio-pool ==0.2.1.1
   - unliftio-streams ==0.1.1.1
···
   - wikicfp-scraper ==0.1.0.12
   - wild-bind ==0.1.2.7
   - wild-bind-x11 ==0.2.0.13
-  - Win32 ==2.6.1.0
   - Win32-notify ==0.3.0.3
   - windns ==0.1.0.1
   - witch ==0.3.4.0

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

···
  - distribution-plot
  - dixi
  - dl-fedora
- - dl-fedora_0_9_1
  - dmenu-pkill
  - dmenu-pmount
  - dmenu-search
  - doc-review
- - doi
  - domain
  - domain-core
  - domain-optics
+ - dormouse-client
  - dow
  - download-media-content
  - dph-examples
···
  - formlets-hsp
  - forth-hll
  - fortran-src-extras
+ - fortran-vars
  - foscam-directory
  - foscam-sort
  - fp-ieee
···
  - layouting
  - lazy-hash
  - lazy-hash-cache
+ - ldap-scim-bridge
  - ldapply
  - leaky
  - lean
···
  - wheb-strapped
  - whitespace
  - wikipedia4epub
- - windowslive
  - winio
  - wl-pprint-ansiterm
  - wl-pprint-terminfo

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

···
      }:
      mkDerivation {
        pname = "Jikka";
-       version = "5.4.0.0";
-       sha256 = "0qajwn7sxiz2smk0d2fjy81ni5pzmv6nv05ln7j3cgh6dkx20jxz";
+       version = "5.5.0.0";
+       sha256 = "0z1000arwm0m6kl4nhwwq0iy1xwk1aml5q1lxrdsrhqq840q3x65";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "ListLike";
-       version = "4.7.4";
-       sha256 = "170yrz008ya4haj0i8z1c7ydjg8hcw3i9cqs6abainh8zxvc1lqi";
-       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;
-     }) {};
-
-  "ListLike_4_7_6" = callPackage
-    ({ mkDerivation, array, base, bytestring, containers, deepseq
-     , dlist, fmlist, HUnit, QuickCheck, random, text, utf8-string
-     , vector
-     }:
-     mkDerivation {
-       pname = "ListLike";
        version = "4.7.6";
        sha256 = "08jip0q2f9qc95wcqka2lrqpf8r7sswsi5104w73kyrbmfirqnrd";
        libraryHaskellDepends = [
···
        ];
        description = "Generalized support for list-like structures";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ListT" = callPackage
···
      }) {};
 
   "Win32" = callPackage
-    ({ mkDerivation }:
-     mkDerivation {
-       pname = "Win32";
-       version = "2.6.1.0";
-       sha256 = "1qwwznnnqnr6zqvjzwr35bkvzrvjf7v90j4qkhinzs8p0yx4b97b";
-       revision = "1";
-       editedCabalFile = "1ia6dk2fvxg3gzqdmcypdka6fcnnrza23hq1rhslj53jy3qzs3kn";
-       description = "A binding to part of the Win32 library";
-       license = lib.licenses.bsd3;
-       platforms = lib.platforms.none;
-     }) {};
-
-  "Win32_2_12_0_1" = callPackage
     ({ mkDerivation }:
      mkDerivation {
        pname = "Win32";
···
        pname = "arithmoi";
        version = "0.12.0.0";
        sha256 = "1lghgr4z2vhafj8d8971pdghih6r5qq5xlc0b87jmazyhzz95w3f";
+       revision = "1";
+       editedCabalFile = "1b08p18k41sm298rn1z5ljs1l6s74nddm4fpdgix3npl8wsmmxgq";
        configureFlags = [ "-f-llvm" ];
        libraryHaskellDepends = [
          array base chimera constraints containers deepseq exact-pi
···
        license = lib.licenses.mit;
      }) {};
 
+  "arithmoi_0_12_0_1" = callPackage
+    ({ mkDerivation, array, base, chimera, constraints, containers
+     , deepseq, exact-pi, integer-gmp, integer-logarithms, integer-roots
+     , mod, QuickCheck, quickcheck-classes, random, semirings
+     , smallcheck, tasty, tasty-bench, tasty-hunit, tasty-quickcheck
+     , tasty-rerun, tasty-smallcheck, transformers, vector
+     }:
+     mkDerivation {
+       pname = "arithmoi";
+       version = "0.12.0.1";
+       sha256 = "1dsa0fw6z6b6gcsw23j08qayqyh2icya7gmb4v4r0adszr2p7ziz";
+       configureFlags = [ "-f-llvm" ];
+       libraryHaskellDepends = [
+         array base chimera constraints containers deepseq exact-pi
+         integer-gmp integer-logarithms integer-roots mod random semirings
+         transformers vector
+       ];
+       testHaskellDepends = [
+         base containers exact-pi integer-gmp integer-roots mod QuickCheck
+         quickcheck-classes random semirings smallcheck tasty tasty-hunit
+         tasty-quickcheck tasty-rerun tasty-smallcheck transformers vector
+       ];
+       benchmarkHaskellDepends = [
+         array base constraints containers deepseq integer-logarithms mod
+         random semirings tasty-bench vector
+       ];
+       description = "Efficient basic number-theoretic functions";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "arity-generic-liftA" = callPackage
     ({ mkDerivation, base, doctest }:
      mkDerivation {
···
        pname = "attenuation";
        version = "0.1.0.0";
        sha256 = "0swiqnh34654rljydbd91nbkpgi1x816b7y3f57i4qnync29nsd0";
+       revision = "1";
+       editedCabalFile = "1bh0ydj5fywx8zcgvfb40092jb09njj2kk09kg7gfvq2fvpz5whr";
        libraryHaskellDepends = [ base profunctors ];
        description = "Representational subtyping relations and variance roles";
        license = lib.licenses.asl20;
···
      }:
      mkDerivation {
        pname = "base-orphans";
-       version = "0.8.4";
-       sha256 = "1cxvjcyy0vsg21n85gxal03gfprw75vjd1h9sni00d60as9vbcip";
-       libraryHaskellDepends = [ base ghc-prim ];
-       testHaskellDepends = [ base hspec QuickCheck ];
-       testToolDepends = [ hspec-discover ];
-       description = "Backwards-compatible orphan instances for base";
-       license = lib.licenses.mit;
-     }) {};
-
-  "base-orphans_0_8_5" = callPackage
-    ({ mkDerivation, base, ghc-prim, hspec, hspec-discover, QuickCheck
-     }:
-     mkDerivation {
-       pname = "base-orphans";
        version = "0.8.5";
        sha256 = "1lw1jhrrsdq7x9wr2bwkxq9mscidcad0n30kh9gfk8kgifl5xh9k";
        libraryHaskellDepends = [ base ghc-prim ];
···
        testToolDepends = [ hspec-discover ];
        description = "Backwards-compatible orphan instances for base";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "base-prelude" = callPackage
···
      }:
      mkDerivation {
        pname = "bearriver";
-       version = "0.13.1.2";
-       sha256 = "0jqb1jn6jdrg6pm80zhd86rwsa05rxn0675lxv0m8c2z07g5601c";
+       version = "0.13.1.3";
+       sha256 = "1qycifi7gnfky4pxy3dr7az0iv2s2xykjy4mccy8gki05fsy0lg5";
        libraryHaskellDepends = [
          base dunai MonadRandom mtl simple-affine-space transformers
        ];
···
      }:
      mkDerivation {
        pname = "bisc";
-       version = "0.3.0.0";
-       sha256 = "097b25pp6pi7rq4xhk19g1i5v7v9hyx7ldyq0y3aj1cm50s2356m";
+       version = "0.3.1.0";
+       sha256 = "0d0n3dmdfh4dxnxa8pdvdh4fhlhpdal4fixbjk2ignmf6ghm54qk";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "blaze-textual";
-       version = "0.2.1.0";
-       sha256 = "0bbcykkrlgdb6jaz72njriq9if6bzsx52jn26k093f5sn1d7jhhh";
-       libraryHaskellDepends = [
-         base blaze-builder bytestring ghc-prim integer-gmp old-locale text
-         time vector
-       ];
-       testHaskellDepends = [
-         base blaze-builder bytestring double-conversion QuickCheck
-         test-framework test-framework-quickcheck2
-       ];
-       description = "Fast rendering of common datatypes";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "blaze-textual_0_2_2_1" = callPackage
-    ({ mkDerivation, base, blaze-builder, bytestring, double-conversion
-     , ghc-prim, integer-gmp, old-locale, QuickCheck, test-framework
-     , test-framework-quickcheck2, text, time, vector
-     }:
-     mkDerivation {
-       pname = "blaze-textual";
        version = "0.2.2.1";
        sha256 = "0zjnwnjpcpnnm0815h9ngr3a3iy0szsnb3nrcavkbx4905s9k4bs";
        libraryHaskellDepends = [
···
        ];
        description = "Fast rendering of common datatypes";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "blaze-textual-native" = callPackage
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
+     }) {};
+
+  "blizzard-html" = callPackage
+    ({ mkDerivation, base, blaze-html, clay, text }:
+     mkDerivation {
+       pname = "blizzard-html";
+       version = "0.1.0.0";
+       sha256 = "0q77g1apkjy6vfks1734cx6y11v5l7qksfs1g2axp2lmsymkd28v";
+       libraryHaskellDepends = [ base blaze-html clay text ];
+       description = "An HTML and CSS renderer for Haskell";
+       license = lib.licenses.mit;
      }) {};
 
   "blockchain" = callPackage
···
      }:
      mkDerivation {
        pname = "core-program";
-       version = "0.2.7.1";
-       sha256 = "1bm75bdmcrjizmrspl52qqs4vq9hlyh7fjv5y5lfpkmqrs45045b";
-       libraryHaskellDepends = [
-         async base bytestring chronologique core-data core-text directory
-         exceptions filepath fsnotify hashable hourglass mtl prettyprinter
-         safe-exceptions stm template-haskell terminal-size text text-short
-         transformers unix
-       ];
-       description = "Opinionated Haskell Interoperability";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "core-program_0_2_9_1" = callPackage
-    ({ mkDerivation, async, base, bytestring, chronologique, core-data
-     , core-text, directory, exceptions, filepath, fsnotify, hashable
-     , hourglass, mtl, prettyprinter, safe-exceptions, stm
-     , template-haskell, terminal-size, text, text-short, transformers
-     , unix
-     }:
-     mkDerivation {
-       pname = "core-program";
        version = "0.2.9.1";
        sha256 = "1r604zbr0ds2g29rp1470x2m25yv8j2iw1jglf3ppf7j30dsv8qj";
        libraryHaskellDepends = [
···
        ];
        description = "Opinionated Haskell Interoperability";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "core-text" = callPackage
···
      }:
      mkDerivation {
        pname = "core-text";
-       version = "0.3.0.0";
-       sha256 = "103fd1bbhkh1l9di0f88yxl9mdaxjh31pgg49bk6yhx9cmdhgn1x";
-       libraryHaskellDepends = [
-         ansi-terminal base bytestring colour deepseq fingertree hashable
-         prettyprinter template-haskell text text-short
-       ];
-       description = "A rope type based on a finger tree over UTF-8 fragments";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "core-text_0_3_2_0" = callPackage
-    ({ mkDerivation, ansi-terminal, base, bytestring, colour, deepseq
-     , fingertree, hashable, prettyprinter, template-haskell, text
-     , text-short
-     }:
-     mkDerivation {
-       pname = "core-text";
        version = "0.3.2.0";
        sha256 = "1dxxw75xdb1r9vcxfg52z7fg7a1050n8a9c8ndakgxqh5c9j6xqq";
        libraryHaskellDepends = [
···
        ];
        description = "A rope type based on a finger tree over UTF-8 fragments";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "corebot-bliki" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "debian-build_0_10_2_1" = callPackage
+    ({ mkDerivation, base, directory, filepath, process, split
+     , transformers
+     }:
+     mkDerivation {
+       pname = "debian-build";
+       version = "0.10.2.1";
+       sha256 = "1114xaqmhx74w0zqdksj6c1ggmfglcshhsxrw89gai5kzy47zp9d";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base directory filepath process split transformers
+       ];
+       executableHaskellDepends = [ base filepath transformers ];
+       description = "Debian package build sequence tools";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "debug" = callPackage
     ({ mkDerivation, aeson, base, bytestring, clock, containers
      , deepseq, directory, extra, filepath, ghc-prim, hashable, Hoed
···
        pname = "diagrams-core";
        version = "1.5.0";
        sha256 = "0y3smp3hiyfdirdak3j4048cgqv7a5q9p2jb6z8na2llys5mrmdn";
-       revision = "1";
-       editedCabalFile = "1718pkifs74nq8bdwcm6firahy8riiinwarcxkk087brmm2rbfli";
+       revision = "2";
+       editedCabalFile = "1wbvmarr8vaki80x19lwahsvyknw2047l1kmk3ybppg5s8mfiqpa";
        libraryHaskellDepends = [
          adjunctions base containers distributive dual-tree lens linear
          monoid-extras mtl profunctors semigroups unordered-containers
···
        broken = true;
      }) {};
 
-  "directory_1_3_6_2" = callPackage
+  "directory_1_3_7_0" = callPackage
     ({ mkDerivation, base, filepath, time, unix }:
      mkDerivation {
        pname = "directory";
-       version = "1.3.6.2";
-       sha256 = "0zgwx7bwhw0s5xc17hfn1ps3fxn9ihv174b2s7rz63flm8lsm0y3";
+       version = "1.3.7.0";
+       sha256 = "041dnqqnc1dadasqyhivpa7rnhw3i08gq5bwj1kfz7lhlihbv1lz";
        libraryHaskellDepends = [ base filepath time unix ];
        testHaskellDepends = [ base filepath time unix ];
        description = "Platform-agnostic library for filesystem operations";
···
      }:
      mkDerivation {
        pname = "dl-fedora";
-       version = "0.9";
-       sha256 = "17khlv65irp1bdr7j0njlh1sgvr1nhi5xfvdiklhjr7vm6vhmipd";
-       isLibrary = false;
-       isExecutable = true;
-       executableHaskellDepends = [
-         base bytestring directory extra filepath http-client
-         http-client-tls http-directory http-types optparse-applicative
-         regex-posix simple-cmd simple-cmd-args text time unix xdg-userdirs
-       ];
-       testHaskellDepends = [ base simple-cmd ];
-       description = "Fedora image download tool";
-       license = lib.licenses.gpl3Only;
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
-  "dl-fedora_0_9_1" = callPackage
-    ({ mkDerivation, base, bytestring, directory, extra, filepath
-     , http-client, http-client-tls, http-directory, http-types
-     , optparse-applicative, regex-posix, simple-cmd, simple-cmd-args
-     , text, time, unix, xdg-userdirs
-     }:
-     mkDerivation {
-       pname = "dl-fedora";
        version = "0.9.1";
        sha256 = "1ryvgccwfs8yzhywcvgd5s9imr4w3sxdif79npfw3zk1rcnl23v4";
        isLibrary = false;
···
        ];
        description = "Automatic Bibtex and fulltext of scientific articles";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "doldol" = callPackage
···
        testToolDepends = [ hspec-discover ];
        description = "Simple, type-safe and testable HTTP client";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "dormouse-uri" = callPackage
···
        testToolDepends = [ hspec-discover ];
        description = "Library for type-safe representations of Uri/Urls";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "dot" = callPackage
···
        maintainers = with lib.maintainers; [ turion ];
      }) {};
 
+  "dunai_0_8_0" = callPackage
+    ({ mkDerivation, base, MonadRandom, simple-affine-space, tasty
+     , tasty-hunit, transformers, transformers-base
+     }:
+     mkDerivation {
+       pname = "dunai";
+       version = "0.8.0";
+       sha256 = "06xdn1fqfbpffdcpf9mmkl56797bdh9ijwg7nm98fqhwq0d4jnkv";
+       libraryHaskellDepends = [
+         base MonadRandom simple-affine-space transformers transformers-base
+       ];
+       testHaskellDepends = [ base tasty tasty-hunit transformers ];
+       description = "Generalised reactive framework supporting classic, arrowized and monadic FRP";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ turion ];
+     }) {};
+
   "dunai-core" = callPackage
     ({ mkDerivation, base, MonadRandom, transformers, transformers-base
      }:
···
     ({ mkDerivation, base, dunai, normaldistribution, QuickCheck }:
      mkDerivation {
        pname = "dunai-test";
-       version = "0.7.0";
-       sha256 = "08pbfw10dkds8dwr913p0rikvs7vxfwyj5rdsr7njzh39fz9lqli";
+       version = "0.8.0";
+       sha256 = "1n5a30iw0pr94fl1jparlmf0lnw4md4l3r9aq56247cz1npnfaqh";
        libraryHaskellDepends = [
          base dunai normaldistribution QuickCheck
        ];
···
        license = lib.licenses.gpl3Plus;
      }) {};
 
+  "elynx_0_6_0_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, elynx-tools
+     , optparse-applicative, slynx, tlynx
+     }:
+     mkDerivation {
+       pname = "elynx";
+       version = "0.6.0.0";
+       sha256 = "0ni33i5l82pyhsm2y2r5gpn736mnnd56086ma51s880lbr4qcizf";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         aeson base bytestring elynx-tools optparse-applicative slynx tlynx
+       ];
+       description = "Validate and (optionally) redo ELynx analyses";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "elynx-markov" = callPackage
     ({ mkDerivation, async, attoparsec, base, bytestring, containers
      , elynx-seq, elynx-tools, hmatrix, hspec, integration
···
        license = lib.licenses.gpl3Plus;
      }) {};
 
+  "elynx-markov_0_6_0_0" = callPackage
+    ({ mkDerivation, async, attoparsec, base, bytestring, containers
+     , elynx-seq, elynx-tools, hmatrix, hspec, integration
+     , math-functions, mwc-random, primitive, statistics, vector
+     }:
+     mkDerivation {
+       pname = "elynx-markov";
+       version = "0.6.0.0";
+       sha256 = "12vbb7lrf7qw581pn0y5dpx1gkny74vib9f6sykg650izias8pl1";
+       libraryHaskellDepends = [
+         async attoparsec base bytestring containers elynx-seq hmatrix
+         integration math-functions mwc-random primitive statistics vector
+       ];
+       testHaskellDepends = [
+         base containers elynx-tools hmatrix hspec mwc-random vector
+       ];
+       benchmarkHaskellDepends = [ base ];
+       description = "Simulate molecular sequences along trees";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "elynx-nexus" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, hspec }:
      mkDerivation {
···
        testHaskellDepends = [ base hspec ];
        description = "Import and export Nexus files";
        license = lib.licenses.gpl3Plus;
+     }) {};
+
+  "elynx-nexus_0_6_0_0" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, hspec }:
+     mkDerivation {
+       pname = "elynx-nexus";
+       version = "0.6.0.0";
+       sha256 = "0yhyacb04d9080rh030f082r64z72ma5g3sgpxy3vihp139gar34";
+       libraryHaskellDepends = [ attoparsec base bytestring ];
+       testHaskellDepends = [ base hspec ];
+       description = "Import and export Nexus files";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "elynx-seq" = callPackage
···
        license = lib.licenses.gpl3Plus;
      }) {};
 
+  "elynx-seq_0_6_0_0" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
+     , elynx-tools, hspec, matrices, mwc-random, parallel, primitive
+     , vector, vector-th-unbox, word8
+     }:
+     mkDerivation {
+       pname = "elynx-seq";
+       version = "0.6.0.0";
+       sha256 = "1jyb8m400qcw7bkm1mdxqny59vk6bhfgp2fwsa1a9vxi1cdswk3l";
+       libraryHaskellDepends = [
+         aeson attoparsec base bytestring containers matrices mwc-random
+         parallel primitive vector vector-th-unbox word8
+       ];
+       testHaskellDepends = [
+         base bytestring elynx-tools hspec matrices vector
+       ];
+       description = "Handle molecular sequences";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "elynx-tools" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
      , bytestring, cryptohash-sha256, deepseq, directory, hmatrix
···
        license = lib.licenses.gpl3Plus;
      }) {};
 
+  "elynx-tools_0_6_0_0" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
+     , bytestring, cryptohash-sha256, directory, hmatrix, mwc-random
+     , optparse-applicative, primitive, template-haskell, text, time
+     , transformers, vector, zlib
+     }:
+     mkDerivation {
+       pname = "elynx-tools";
+       version = "0.6.0.0";
+       sha256 = "1jfxyf2f8wf1kzzg3wpw8fixzl6icx1729mpw98hp5wacvp1d4mk";
+       libraryHaskellDepends = [
+         aeson attoparsec base base16-bytestring bytestring
+         cryptohash-sha256 directory hmatrix mwc-random optparse-applicative
+         primitive template-haskell text time transformers vector zlib
+       ];
+       description = "Tools for ELynx";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "elynx-tree" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, comonad
      , containers, criterion, deepseq, double-conversion, elynx-nexus
···
        ];
        description = "Handle phylogenetic trees";
        license = lib.licenses.gpl3Plus;
+     }) {};
+
+  "elynx-tree_0_6_0_0" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, comonad
+     , containers, criterion, data-default, data-default-class, deepseq
+     , double-conversion, elynx-nexus, elynx-tools, hspec
+     , math-functions, microlens, mwc-random, parallel, primitive
+     , QuickCheck, quickcheck-classes, statistics
+     }:
+     mkDerivation {
+       pname = "elynx-tree";
+       version = "0.6.0.0";
+       sha256 = "1cywd10rky712yijpvq6cfrphmgks760y52gsdlfxwcn6jgych0r";
+       libraryHaskellDepends = [
+         aeson attoparsec base bytestring comonad containers
+         data-default-class deepseq double-conversion elynx-nexus
+         math-functions mwc-random parallel primitive statistics
+       ];
+       testHaskellDepends = [
+         attoparsec base bytestring containers data-default elynx-tools
+         hspec QuickCheck quickcheck-classes
+       ];
+       benchmarkHaskellDepends = [
+         base criterion elynx-tools microlens mwc-random parallel
+       ];
+       description = "Handle phylogenetic trees";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ema" = callPackage
···
      }:
      mkDerivation {
        pname = "esqueleto";
-       version = "3.5.2.1";
-       sha256 = "1hx3v9cb5w0zckgi83qa1ibfs44172syj89p36xsiphxqhlgaa0s";
-       libraryHaskellDepends = [
-         aeson attoparsec base blaze-html bytestring conduit containers
-         monad-logger persistent resourcet tagged text time transformers
-         unliftio unordered-containers
-       ];
-       testHaskellDepends = [
-         aeson attoparsec base blaze-html bytestring conduit containers
-         exceptions hspec hspec-core monad-logger mtl mysql mysql-simple
-         persistent persistent-mysql persistent-postgresql persistent-sqlite
-         postgresql-simple QuickCheck resourcet tagged text time
-         transformers unliftio unordered-containers
-       ];
-       description = "Type-safe EDSL for SQL queries on persistent backends";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "esqueleto_3_5_2_2" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, blaze-html, bytestring
-     , conduit, containers, exceptions, hspec, hspec-core, monad-logger
-     , mtl, mysql, mysql-simple, persistent, persistent-mysql
-     , persistent-postgresql, persistent-sqlite, postgresql-simple
-     , QuickCheck, resourcet, tagged, text, time, transformers, unliftio
-     , unordered-containers
-     }:
-     mkDerivation {
-       pname = "esqueleto";
        version = "3.5.2.2";
        sha256 = "19m4lzxhjakf1zbsvwa0xmhcln1wb8ydbsnfyhiwhgvryrhvw9ga";
        libraryHaskellDepends = [
···
        ];
        description = "Type-safe EDSL for SQL queries on persistent backends";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ess" = callPackage
···
        pname = "feed";
        version = "1.3.2.0";
        sha256 = "0kv3vx3njqlhwvkmf12m1gmwl8jj97kfa60da2362vwdavhcf4dk";
-       revision = "1";
-       editedCabalFile = "0lg9yphl07hbknzx0nvdxvcw05bpxc5ac9sqb26lv4d9nkb72blg";
+       revision = "2";
+       editedCabalFile = "12kl1bsgv6jdbvm1dblxjkvc2n8p83wgcpalp8vyf414lhxrjnpx";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base base-compat bytestring old-locale old-time safe text time
···
      }:
      mkDerivation {
        pname = "file-embed";
-       version = "0.0.14.0";
-       sha256 = "1b45yk17339zw53zgp8zb5sjg5xn76kryrb6dkqk747vnbdnf0h5";
-       libraryHaskellDepends = [
-         base bytestring directory filepath template-haskell
-       ];
-       testHaskellDepends = [ base bytestring filepath ];
-       description = "Use Template Haskell to embed file contents directly";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "file-embed_0_0_15_0" = callPackage
-    ({ mkDerivation, base, bytestring, directory, filepath
-     , template-haskell
-     }:
-     mkDerivation {
-       pname = "file-embed";
        version = "0.0.15.0";
        sha256 = "1pavxj642phrkq67620g10wqykjfhmm9yj2rm8pja83sadfvhrph";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base bytestring filepath ];
        description = "Use Template Haskell to embed file contents directly";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "file-embed-lzma" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "fmt_0_6_3_0" = callPackage
+    ({ mkDerivation, base, base64-bytestring, bytestring, call-stack
+     , containers, criterion, deepseq, doctest, doctest-discover
+     , formatting, hspec, interpolate, microlens, neat-interpolation
+     , QuickCheck, text, time, time-locale-compat, vector
+     }:
+     mkDerivation {
+       pname = "fmt";
+       version = "0.6.3.0";
+       sha256 = "01mh0k69dv5x30hlmxi36dp1ylk0a6affr4jb3pvy8vjm4ypzvml";
+       libraryHaskellDepends = [
+         base base64-bytestring bytestring call-stack containers formatting
+         microlens text time time-locale-compat
+       ];
+       testHaskellDepends = [
+         base bytestring call-stack containers doctest hspec
+         neat-interpolation QuickCheck text vector
+       ];
+       testToolDepends = [ doctest-discover ];
+       benchmarkHaskellDepends = [
+         base bytestring containers criterion deepseq formatting interpolate
+         text vector
+       ];
+       description = "A new formatting library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "fmt-for-rio" = callPackage
     ({ mkDerivation, base, enum-text-rio }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "fortran-src";
-       version = "0.5.0";
-       sha256 = "1bza9aav1yy4yzv7lwwi1x466i9h7ar4xvwva1r7992msqp05pxb";
+       version = "0.6.0";
+       sha256 = "0g0wpcr9ddad59x58gknrw2y7w3h88i7s9br9qk423k48gq8qsla";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "fortran-vars" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, deepseq, fgl
+     , fortran-src, fortran-src-extras, hspec, hspec-discover, HUnit
+     , text, uniplate
+     }:
+     mkDerivation {
+       pname = "fortran-vars";
+       version = "0.1.0";
+       sha256 = "1j1k4paca1g6w38kd7fl1h4vzf6rb8ypdfilhkn2fk5llxkkw226";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring containers deepseq fgl fortran-src
+         fortran-src-extras text uniplate
+       ];
+       executableHaskellDepends = [
+         aeson base bytestring containers deepseq fgl fortran-src
+         fortran-src-extras text uniplate
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers deepseq fgl fortran-src
+         fortran-src-extras hspec HUnit text uniplate
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Fortran memory model and other static analysis tools";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "fortytwo" = callPackage
     ({ mkDerivation, ansi-terminal, base, doctest, hspec, text }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "freckle-app";
-       version = "1.0.0.2";
-       sha256 = "1mrydqmwzwa391cb6pzxmjd5yl04f5xggz0wha7rm2a0pksgxphy";
+       version = "1.0.0.3";
+       sha256 = "13iw0fj3n409mjbc6kkxcy1jx2zg8dwd55qp150qrkbmmjvrw54q";
        libraryHaskellDepends = [
          aeson ansi-terminal base bytestring case-insensitive conduit
          data-default datadog doctest errors exceptions fast-logger filepath
···
        broken = true;
      }) {};
 
+  "functor-combinators_0_4_0_0" = callPackage
+    ({ mkDerivation, assoc, base, bifunctors, comonad, constraints
+     , containers, contravariant, dependent-sum, deriving-compat, free
+     , hedgehog, invariant, kan-extensions, mmorph, mtl
+     , natural-transformation, nonempty-containers, pointed, profunctors
+     , semigroupoids, sop-core, tagged, tasty, tasty-hedgehog, these
+     , transformers, trivial-constraint, vinyl
+     }:
+     mkDerivation {
+       pname = "functor-combinators";
+       version = "0.4.0.0";
+       sha256 = "1kikldm7ih7r5ydyq26fkp01025dnwrafipsw9qv897k887b8gvg";
+       libraryHaskellDepends = [
+         assoc base bifunctors comonad constraints containers contravariant
+         deriving-compat free invariant kan-extensions mmorph mtl
+         natural-transformation nonempty-containers pointed profunctors
+         semigroupoids sop-core tagged these transformers trivial-constraint
+         vinyl
+       ];
+       testHaskellDepends = [
+         base bifunctors dependent-sum free hedgehog nonempty-containers
+         semigroupoids tasty tasty-hedgehog transformers trivial-constraint
+       ];
+       description = "Tools for functor combinator-based program design";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "functor-combo" = callPackage
     ({ mkDerivation, base, base-orphans, containers, data-inttrie, lub
      , type-unary, TypeCompose
···
      }:
      mkDerivation {
        pname = "generic-deriving";
-       version = "1.14";
-       sha256 = "00nbnxxkxyjfzj3zf6sxh3im24qv485w4jb1gj36c2wn4gjdbayh";
-       revision = "1";
-       editedCabalFile = "0g17hk01sxv5lmrlnmwqhkk73y3dy3xhy7l9myyg5qnw7hm7iin9";
-       libraryHaskellDepends = [
-         base containers ghc-prim template-haskell th-abstraction
-       ];
-       testHaskellDepends = [ base hspec template-haskell ];
-       testToolDepends = [ hspec-discover ];
-       description = "Generic programming library for generalised deriving";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "generic-deriving_1_14_1" = callPackage
-    ({ mkDerivation, base, containers, ghc-prim, hspec, hspec-discover
-     , template-haskell, th-abstraction
-     }:
-     mkDerivation {
-       pname = "generic-deriving";
        version = "1.14.1";
        sha256 = "19qpahcfhs9nqqv6na8znybrvpw885cajbdnrfylxbsmm0sys4s7";
        libraryHaskellDepends = [
···
        testToolDepends = [ hspec-discover ];
        description = "Generic programming library for generalised deriving";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "generic-enum" = callPackage
···
      }:
      mkDerivation {
        pname = "geos";
-       version = "0.4.1";
-       sha256 = "1b6dp3vzp8jpgdzkqzfyjk8n26w8jb06adp77qzfbjmik0lw8b03";
+       version = "0.5.0";
+       sha256 = "1s4zjwhqcxxxb32hva4h93kkmzlvghmj11jvzvkwga9qm4wd9n3a";
        libraryHaskellDepends = [
          base bytestring mtl transformers vector
        ];
···
     ({ mkDerivation, base, ghc }:
      mkDerivation {
        pname = "ghc-api-compat";
-       version = "8.10.6";
-       sha256 = "1zrwa266v776w8rvcjggdpnyhs8kk36w5wrh63l16kxh58yc2vjz";
+       version = "8.10.7";
+       sha256 = "1swsly340pj4inmk1l57q4s0dpw8iibl192y1zayvkgc43zky62a";
        libraryHaskellDepends = [ base ghc ];
        doHaddock = false;
        description = "GHC-API compatibility helpers";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "ghc-api-compat_9_0_1" = callPackage
+    ({ mkDerivation, base, containers, ghc }:
+     mkDerivation {
+       pname = "ghc-api-compat";
+       version = "9.0.1";
+       sha256 = "05jb1sck9cjpsd1j6qlpr7apqv6g2vw3xac36kcsyf0qxw8sq9dk";
+       libraryHaskellDepends = [ base containers ghc ];
+       description = "GHC-API compatibility helpers";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ghc-bignum" = callPackage
···
        broken = true;
      }) {};
 
+  "gibbon" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "gibbon";
+       version = "0.1.1";
+       sha256 = "1fvb7fg4dh26xszbfcrjyd7h8pl0nxpxkls6lb1ibyw9z76h0shh";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [ base ];
+       description = "A compiler for operating on serialized trees";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "gimlh" = callPackage
     ({ mkDerivation, base, split }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "git-annex";
-       version = "8.20210803";
-       sha256 = "0777q454bgkzr930wacn48xm6ygi4i6rxsizvxjm3a0dlffnv3b2";
+       version = "8.20210903";
+       sha256 = "1p6zgk98jmxvqdin5xsdxhgq276bjdr2spi0wabj8x0ziry97rvl";
        configureFlags = [
          "-fassistant" "-f-benchmark" "-fdbus" "-f-debuglocks" "-fmagicmime"
          "-fnetworkbsd" "-fpairing" "-fproduction" "-fs3" "-ftorrentparser"
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "gitlab-haskell_0_3_0_2" = callPackage
+  "gitlab-haskell_0_3_1_1" = callPackage
     ({ mkDerivation, aeson, base, bytestring, connection, http-client
      , http-conduit, http-types, tasty, tasty-hunit, temporary, text
-     , time, transformers, unix, unliftio, unliftio-core
+     , time, transformers, unix
      }:
      mkDerivation {
        pname = "gitlab-haskell";
-       version = "0.3.0.2";
-       sha256 = "0ndwff0rk1b7vkggymb0ca0h0hg69kym7npcckv2x2pnw55lb5yz";
+       version = "0.3.1.1";
+       sha256 = "146azh83v963njnkbcf6lacj95qx89wcvi294s3nc89bp72z8igz";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring connection http-client http-conduit
-         http-types temporary text time transformers unix unliftio
-         unliftio-core
+         http-types temporary text time transformers unix
        ];
        testHaskellDepends = [ aeson base bytestring tasty tasty-hunit ];
        description = "A Haskell library for the GitLab web API";
···
        pname = "hasktags";
        version = "0.72.0";
        sha256 = "09p79w16fgpqi6bwq162769xdrnyb7wnmz56k00nz6dj1a0bbbdd";
+       revision = "1";
+       editedCabalFile = "0q39ssdgm6lcmqj92frjvr53i34divx53zli0qar39mx8ka1l8ml";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hasqlator-mysql";
-       version = "0.0.9";
-       sha256 = "0cqvykjwdqi96dqz75xsgn9698ygvjrdcw7gi8v892gxsvjdk8cp";
+       version = "0.1.0";
+       sha256 = "0pkgnx54f4487rc9i5286g3xm9kb6g8fhgbqn4p2yddl8mwzpdby";
        libraryHaskellDepends = [
          aeson base binary bytestring containers dlist io-streams megaparsec
          mtl mysql-haskell optics-core pretty-simple prettyprinter
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "hedis_0_15_0" = callPackage
+    ({ mkDerivation, async, base, bytestring, bytestring-lexing
+     , containers, deepseq, doctest, errors, exceptions, HTTP, HUnit
+     , mtl, network, network-uri, resource-pool, scanner, stm
+     , test-framework, test-framework-hunit, text, time, tls
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "hedis";
+       version = "0.15.0";
+       sha256 = "1wcsjvya9hnvgjl9vnimi3928fx2gy0glgdc30slfwnjpijs97n0";
+       libraryHaskellDepends = [
+         async base bytestring bytestring-lexing containers deepseq errors
+         exceptions HTTP mtl network network-uri resource-pool scanner stm
+         text time tls unordered-containers vector
+       ];
+       testHaskellDepends = [
+         async base bytestring doctest HUnit mtl stm test-framework
+         test-framework-hunit text time
+       ];
+       benchmarkHaskellDepends = [ base mtl time ];
+       description = "Client library for the Redis datastore: supports full command set, pipelining";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hedis-config" = callPackage
     ({ mkDerivation, aeson, base, bytestring, hedis, scientific, text
      , time
···
      }:
      mkDerivation {
        pname = "hercules-ci-agent";
-       version = "0.8.2";
-       sha256 = "0zz0s9xpi5gdma1ljfbspfysn8vw05859k159nx8lxqbivpf6bxn";
+       version = "0.8.3";
+       sha256 = "0gwbks6yrjjrys39043wdyx1v0fg8ailv3149b2xi4d49p4jin40";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hercules-ci-api";
-       version = "0.7.0.0";
-       sha256 = "0c8mhmhz89fw0s65a669cpcldqv0g01z9s2343ksv2ykaqz5whi9";
+       version = "0.7.1.0";
+       sha256 = "1vlkfxkd7arb4qaqyvk4cc2w3b37xzhiqmz6smmpjdddpa39lh8c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hercules-ci-api-agent";
-       version = "0.4.0.0";
-       sha256 = "05jdxlr5afr9chayc6frbi9hhagb9qknfdnd2k25cimd7h2syi7r";
+       version = "0.4.1.0";
+       sha256 = "0cv4cd74049b7j2hy1p3fdr94p0f4fnjzwj78hf1f4lw7migi2vi";
        libraryHaskellDepends = [
          aeson base base64-bytestring-type bytestring containers cookie
          deepseq exceptions hashable hercules-ci-api-core http-api-data
···
      , hercules-ci-api-core, hercules-ci-cnix-expr
      , hercules-ci-cnix-store, hercules-ci-optparse-applicative
      , hostname, hspec, http-client, http-client-tls, http-types, katip
-     , lifted-base, monad-control, network-uri, process, protolude
-     , QuickCheck, rio, safe-exceptions, servant, servant-auth-client
-     , servant-client, servant-client-core, servant-conduit, temporary
-     , text, transformers-base, unix, unliftio, unordered-containers
+     , lens, lens-aeson, lifted-base, monad-control, network-uri
+     , process, protolude, QuickCheck, retry, rio, safe-exceptions
+     , servant, servant-auth-client, servant-client, servant-client-core
+     , servant-conduit, temporary, text, transformers, transformers-base
+     , unix, unliftio, unliftio-core, unordered-containers, uuid
      }:
      mkDerivation {
        pname = "hercules-ci-cli";
-       version = "0.2.1";
-       sha256 = "1lbvc2n1mjrnvnpnqvgjd1zbsa96zdpvjhbawfd8rw63ih8l451z";
+       version = "0.2.2";
+       sha256 = "1n0dxpvjxi38whqh37d930rbic96gq13g7x8mi8skw164n9vha4g";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          containers data-has directory exceptions filepath hercules-ci-agent
          hercules-ci-api hercules-ci-api-core hercules-ci-cnix-expr
          hercules-ci-cnix-store hercules-ci-optparse-applicative hostname
-         http-client http-client-tls http-types katip lifted-base
-         monad-control network-uri process protolude rio safe-exceptions
-         servant servant-auth-client servant-client servant-client-core
-         servant-conduit temporary text transformers-base unix unliftio
-         unordered-containers
+         http-client http-client-tls http-types katip lens lens-aeson
+         lifted-base monad-control network-uri process protolude retry rio
+         safe-exceptions servant servant-auth-client servant-client
+         servant-client-core servant-conduit temporary text transformers
+         transformers-base unix unliftio unliftio-core unordered-containers
+         uuid
        ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [
···
   "hercules-ci-cnix-store" = callPackage
     ({ mkDerivation, base, boost, bytestring, conduit, containers
      , exceptions, hspec, hspec-discover, inline-c, inline-c-cpp, nix
-     , protolude, template-haskell, temporary, text, unliftio-core
+     , protolude, template-haskell, temporary, text, unix, unliftio-core
      , vector
      }:
      mkDerivation {
        pname = "hercules-ci-cnix-store";
-       version = "0.2.0.1";
-       sha256 = "1vd7wy23glgxs823c8c1754miwpmrfscsfdn74nyx31gci4jhqgx";
+       version = "0.2.1.0";
+       sha256 = "18165kwcklp6hg9sh5rmqprnc0ixiq8l9w4y87c9m54dbpwdp4na";
        libraryHaskellDepends = [
          base bytestring conduit containers inline-c inline-c-cpp protolude
-         template-haskell unliftio-core vector
+         template-haskell unix unliftio-core vector
        ];
        librarySystemDepends = [ boost ];
        libraryPkgconfigDepends = [ nix ];
···
   "iso-deriving" = callPackage
     ({ mkDerivation, aeson, base, base16-bytestring, bytestring
   "iso-deriving" = callPackage
-  "iso-deriving" = callPackage
-  "iso-deriving" = callPackage
-  "iso-deriving" = callPackage
-  "iso-deriving" = callPackage
-     }:
-     mkDerivation {
-  "iso-deriving" = callPackage
-       version = "0.7.5";
-  "iso-deriving" = callPackage
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-  "iso-deriving" = callPackage
-  "iso-deriving" = callPackage
-  "iso-deriving" = callPackage
-  "iso-deriving" = callPackage
-       ];
-       executableHaskellDepends = [
-  "iso-deriving" = callPackage
-       ];
-       testHaskellDepends = [
-  "iso-deriving" = callPackage
-  "iso-deriving" = callPackage
-         unordered-containers yaml
-       ];
-  "iso-deriving" = callPackage
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "iso-deriving" = callPackage
-    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
-  "iso-deriving" = callPackage
   "iso-deriving" = callPackage
   "iso-deriving" = callPackage
   "iso-deriving" = callPackage
···
        ];
   "iso-deriving" = callPackage
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "iso-deriving" = callPackage
···
      }:
      mkDerivation {
        pname = "hoogle";
-       version = "5.0.18.1";
-       sha256 = "15ia0l96yjdnam5vljcsslcavsjwfq0kxldwdcr3zq9c0w6q6i3w";
-       revision = "1";
-       editedCabalFile = "1m92rpf0rhcbyana2v6ggxl16mi87dlnmq1bllhb3dm5z5hlha8i";
-       isLibrary = true;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         aeson base binary blaze-html blaze-markup bytestring cmdargs
-         conduit conduit-extra connection containers deepseq directory extra
-         filepath foundation hashable haskell-src-exts http-conduit
-         http-types js-flot js-jquery mmap old-locale process-extras
-         QuickCheck resourcet storable-tuple tar template-haskell text time
-         transformers uniplate utf8-string vector wai wai-logger warp
-         warp-tls zlib
-       ];
-       executableHaskellDepends = [ base ];
-       testTarget = "--test-option=--no-net";
-       description = "Haskell API Search";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "hoogle_5_0_18_2" = callPackage
-    ({ mkDerivation, aeson, base, binary, blaze-html, blaze-markup
-     , bytestring, cmdargs, conduit, conduit-extra, connection
-     , containers, deepseq, directory, extra, filepath, foundation
-     , hashable, haskell-src-exts, http-conduit, http-types, js-flot
-     , js-jquery, mmap, old-locale, process-extras, QuickCheck
-     , resourcet, storable-tuple, tar, template-haskell, text, time
-     , transformers, uniplate, utf8-string, vector, wai, wai-logger
-     , warp, warp-tls, zlib
-     }:
-     mkDerivation {
-       pname = "hoogle";
        version = "5.0.18.2";
        sha256 = "1xacx2f33x1a4qlv25f8rlmb4wi0cjfzrj22nlnkrd0knghik3m7";
        isLibrary = true;
···
        testTarget = "--test-option=--no-net";
        description = "Haskell API Search";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hoogle-index" = callPackage
···
     ({ mkDerivation, base, bytestring, text }:
      mkDerivation {
        pname = "isocline";
-       version = "1.0.4";
-       sha256 = "0p985fbr19sqgrxzxywkshyl0ca5f2kpl4pkmqgl6ya2alvwymzl";
+       version = "1.0.5";
+       sha256 = "05amznscn43vscz3b9rnb2scryriq0gccjx5z5fk1wn47i3dz6vg";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring text ];
···
   "keid-core" = callPackage
     ({ mkDerivation, adjunctions, base, binary, bytestring
      , cryptohash-md5, derive-storable, derive-storable-plugin
-     , distributive, foldl, geomancy, GLFW-b, ktx-codec
+     , distributive, file-embed, foldl, geomancy, GLFW-b, ktx-codec
      , neat-interpolation, optparse-applicative, optparse-simple
      , resourcet, rio, rio-app, StateVar, tagged, template-haskell, text
      , transformers, unagi-chan, unliftio, vector, vulkan, vulkan-utils
···
      }:
      mkDerivation {
        pname = "keid-core";
-       version = "0.1.1.1";
-       sha256 = "03pfn145ggpd44qq4r7fgx8nk02vhd2jd9f70gwmfsivs9ykg94x";
+       version = "0.1.2.0";
+       sha256 = "07l493nn691bn6b2c4z684cjfj589vkip6068szc8j2j9pwqgr23";
        libraryHaskellDepends = [
          adjunctions base binary bytestring cryptohash-md5 derive-storable
-         derive-storable-plugin distributive foldl geomancy GLFW-b ktx-codec
-         neat-interpolation optparse-applicative optparse-simple resourcet
-         rio rio-app StateVar tagged template-haskell text transformers
-         unagi-chan unliftio vector vulkan vulkan-utils
-         VulkanMemoryAllocator zstd
+         derive-storable-plugin distributive file-embed foldl geomancy
+         GLFW-b ktx-codec neat-interpolation optparse-applicative
+         optparse-simple resourcet rio rio-app StateVar tagged
+         template-haskell text transformers unagi-chan unliftio vector
+         vulkan vulkan-utils VulkanMemoryAllocator zstd
        ];
        description = "Core parts of Keid engine";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "keid-geometry" = callPackage
-    ({ mkDerivation, base, geomancy, keid-core, mtl, rio, rio-app
-     , vector, vulkan
+    ({ mkDerivation, base, geomancy, keid-core, mtl, rio, vector
+     , vulkan
      }:
      mkDerivation {
        pname = "keid-geometry";
-       version = "0.1.0.1";
-       sha256 = "0cnvgkqcc4nqvsbm9h6kn1l3sgs7dlhcb7iq6z18ynwry8z510w0";
+       version = "0.1.1.1";
+       sha256 = "1jicgdkxwmi16a7bqc3qh9qr2a691nlxk87b5kh674jnhsr59db2";
        libraryHaskellDepends = [
-         base geomancy keid-core mtl rio rio-app vector vulkan
+         base geomancy keid-core mtl rio vector vulkan
        ];
        description = "Geometry primitives for Keid engine";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "keid-render-basic" = callPackage
-    ({ mkDerivation, aeson, base, binary, bytestring, cryptohash-md5
-     , derive-storable, derive-storable-plugin, foldl, geomancy, GLFW-b
-     , keid-core, keid-geometry, neat-interpolation, resourcet, rio
-     , rio-app, tagged, text, unliftio, vector, vulkan, vulkan-utils
-     , VulkanMemoryAllocator, zstd
+    ({ mkDerivation, adjunctions, aeson, base, bytestring
+     , derive-storable, derive-storable-plugin, distributive, file-embed
+     , geomancy, keid-core, keid-geometry, neat-interpolation, resourcet
+     , rio, tagged, text, unliftio, vector, vulkan, vulkan-utils
      }:
      mkDerivation {
        pname = "keid-render-basic";
-       version = "0.1.1.2";
-       sha256 = "1plp5mq1vqslrcnlnlsfy8fphzlijwk2q9a6qw6q5njfpf3g9hcv";
+       version = "0.1.2.1";
+       sha256 = "0dij5rnzzcbggc1mvsg123aynx1s337vv1a4px965aj0ny3lfn0k";
+       enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         aeson base binary bytestring cryptohash-md5 derive-storable
-         derive-storable-plugin foldl geomancy GLFW-b keid-core
-         keid-geometry neat-interpolation resourcet rio rio-app tagged text
-         unliftio vector vulkan vulkan-utils VulkanMemoryAllocator zstd
+         adjunctions aeson base bytestring derive-storable
+         derive-storable-plugin distributive file-embed geomancy keid-core
+         keid-geometry neat-interpolation resourcet rio tagged text unliftio
+         vector vulkan vulkan-utils
        ];
        description = "Basic rendering programs for Keid engine";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "keid-sound-openal" = callPackage
-    ({ mkDerivation, base, geomancy, keid-core, OpenAL, opusfile
-     , resourcet, rio, unliftio
+    ({ mkDerivation, base, keid-core, OpenAL, opusfile, resourcet, rio
      }:
      mkDerivation {
        pname = "keid-sound-openal";
-       version = "0.1.0.0";
-       sha256 = "17ml9xh8qrvyrcsi1ai6br286bf9c6j29wbmp5sp65spp2kwlyng";
+       version = "0.1.1.0";
+       sha256 = "1bzx73wm8xf9nbw0771dl6fsq31lg1nxqg20sr14cglbvmpjiscb";
        libraryHaskellDepends = [
-         base geomancy keid-core OpenAL opusfile resourcet rio unliftio
+         base keid-core OpenAL opusfile resourcet rio
        ];
        description = "OpenAL sound system for Keid engine";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "keid-ui-dearimgui" = callPackage
-    ({ mkDerivation, base, binary, bytestring, cryptohash-md5
-     , dear-imgui, derive-storable, derive-storable-plugin, foldl
-     , geomancy, GLFW-b, keid-core, neat-interpolation, resourcet, rio
-     , rio-app, tagged, unliftio, vector, vulkan, vulkan-utils
-     , VulkanMemoryAllocator, zstd
+    ({ mkDerivation, base, binary, bytestring, dear-imgui, GLFW-b
+     , keid-core, resourcet, rio, rio-app, unliftio, vector, vulkan
+     , vulkan-utils, VulkanMemoryAllocator
      }:
      mkDerivation {
        pname = "keid-ui-dearimgui";
-       version = "0.1.0.0";
-       sha256 = "1650h7mbzmkpzs2wjvjh3zwmjkvbcg1h36yk6frlvvf80fhhihjc";
+       version = "0.1.0.1";
+       sha256 = "1b731r5q8bjpiy84kfzy30pn4wppak1m1zx2ssicdl86181wva1l";
        libraryHaskellDepends = [
-         base binary bytestring cryptohash-md5 dear-imgui derive-storable
-         derive-storable-plugin foldl geomancy GLFW-b keid-core
-         neat-interpolation resourcet rio rio-app tagged unliftio vector
-         vulkan vulkan-utils VulkanMemoryAllocator zstd
+         base binary bytestring dear-imgui GLFW-b keid-core resourcet rio
+         rio-app unliftio vector vulkan vulkan-utils VulkanMemoryAllocator
        ];
        description = "DearImGui elements for Keid engine";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd2;
      }) {};
 
+  "ldap-scim-bridge" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
+     , email-validate, hscim, http-client, http-client-tls, http-types
+     , ldap-client, network, relude, servant, servant-client
+     , servant-client-core, string-conversions, text, tinylog, yaml
+     }:
+     mkDerivation {
+       pname = "ldap-scim-bridge";
+       version = "0.2";
+       sha256 = "16z878iq7b2spa6mhppm1bjj2hi73f9rm6pl9yw6yz7zbqphi9sd";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson aeson-pretty base bytestring containers email-validate hscim
+         http-client http-client-tls http-types ldap-client network relude
+         servant servant-client servant-client-core string-conversions text
+         tinylog yaml
+       ];
+       executableHaskellDepends = [
+         aeson aeson-pretty base bytestring containers email-validate hscim
+         http-client http-client-tls http-types ldap-client network relude
+         servant servant-client servant-client-core string-conversions text
+         tinylog yaml
+       ];
+       description = "See README for synopsis";
+       license = lib.licenses.agpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ldapply" = callPackage
     ({ mkDerivation, base, bytestring, docopt, interpolatedstring-perl6
      , LDAP, ldif, unordered-containers
···
          base fclabels generics-sop transformers
        ];
        description = "Computing lenses generically using generics-sop";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "lens-tell" = callPackage
+    ({ mkDerivation, base, lens, tell }:
+     mkDerivation {
+       pname = "lens-tell";
+       version = "0.1";
+       sha256 = "1d0rjlvai6gsavbfw7zxn8m79vxn61pa9fq9d8v5l707mlm9hsz6";
+       libraryHaskellDepends = [ base lens tell ];
+       description = "MonadTell-based lens combinators";
        license = lib.licenses.bsd3;
      }) {};
 
···
        ];
        description = "Sample from a posterior using Markov chain Monte Carlo";
        license = lib.licenses.gpl3Plus;
+     }) {};
+
+  "mcmc_0_6_0_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, circular, containers
+     , criterion, data-default, deepseq, directory, dirichlet
+     , double-conversion, hspec, log-domain, math-functions, matrices
+     , microlens, monad-parallel, mwc-random, pretty-show, primitive
+     , statistics, time, transformers, vector, zlib
+     }:
+     mkDerivation {
+       pname = "mcmc";
+       version = "0.6.0.0";
+       sha256 = "13m4rdgfwvwhw7nznxlq6af2w56pizgypxxyn8g2agzn2vl6nzfl";
+       libraryHaskellDepends = [
+         aeson base bytestring circular containers data-default deepseq
+         directory dirichlet double-conversion log-domain math-functions
+         matrices microlens monad-parallel mwc-random pretty-show primitive
+         statistics time transformers vector zlib
+       ];
+       testHaskellDepends = [
+         base hspec log-domain mwc-random statistics
+       ];
+       benchmarkHaskellDepends = [ base criterion microlens mwc-random ];
+       description = "Sample from a posterior using Markov chain Monte Carlo";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "mcmc-samplers" = callPackage
···
      }) {};
 
   "nix-tree" = callPackage
-    ({ mkDerivation, aeson, base, brick, bytestring, clock, containers
-     , deepseq, directory, filepath, hashable, hedgehog, hrfsize, relude
-     , text, transformers, typed-process, unordered-containers, vty
+    ({ mkDerivation, aeson, async, base, brick, bytestring, clock
+     , containers, deepseq, directory, filepath, hashable, hedgehog
+     , hrfsize, relude, terminal-progress-bar, text, transformers
+     , typed-process, unordered-containers, vty
      }:
      mkDerivation {
        pname = "nix-tree";
-       version = "0.1.7";
-       sha256 = "17w0lcfr2rxyfzrdhbw9lci9k5xs1566jypip910r78373c72nbj";
+       version = "0.1.8";
+       sha256 = "0bbisb0n7jg5ng17qyh92rbx1qphvd8w4gr6v773j8m72j24vj0c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         aeson base brick bytestring clock containers deepseq directory
-         filepath hashable hrfsize relude text transformers typed-process
-         unordered-containers vty
+         aeson async base brick bytestring clock containers deepseq
+         directory filepath hashable hrfsize relude terminal-progress-bar
+         text transformers typed-process unordered-containers vty
        ];
        testHaskellDepends = [
          aeson base brick bytestring clock containers deepseq directory
···
      }:
      mkDerivation {
        pname = "nri-redis";
-       version = "0.1.0.1";
-       sha256 = "0nvkq4h7fdc9jifk3dd2sac6bwk4ks4bda8slln8dqwgxbh31ln2";
+       version = "0.1.0.2";
+       sha256 = "12z515bs17ig8ps1kq2pp1c80r6cn0rldvqa6rzfgc1nrd0p8hc9";
        libraryHaskellDepends = [
          aeson async base bytestring conduit hedis nri-env-parser
          nri-observability nri-prelude resourcet safe-exceptions text
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "numeric-logarithms" = callPackage
+    ({ mkDerivation, base, integer-gmp, QuickCheck, test-framework
+     , test-framework-quickcheck2
+     }:
+     mkDerivation {
+       pname = "numeric-logarithms";
+       version = "0.1.0.0";
+       sha256 = "1izd7gc9xdrs7a1wbzmhhkv8s9rw2mcq77agvr351dc5jyzdnwiy";
+       libraryHaskellDepends = [ base integer-gmp ];
+       testHaskellDepends = [
+         base integer-gmp QuickCheck test-framework
+         test-framework-quickcheck2
+       ];
+       description = "Efficient rounded log2 algorithms on integral and rational types";
+       license = lib.licenses.asl20;
+     }) {};
+
   "numeric-ode" = callPackage
     ({ mkDerivation, ad, base, Chart, Chart-cairo, colour
      , data-accessor, data-default-class, diagrams-cairo, diagrams-lib
···
        broken = true;
      }) {};
 
-  "numhask_0_8_0_0" = callPackage
-    ({ mkDerivation, base, doctest, QuickCheck }:
+  "numhask_0_8_1_0" = callPackage
+    ({ mkDerivation, base }:
      mkDerivation {
        pname = "numhask";
-       version = "0.8.0.0";
-       sha256 = "104vc3b43lbck6r39kv5rscvqx3hxxf8nyvzsw8shb9xifmnijkh";
+       version = "0.8.1.0";
+       sha256 = "0qq9fr4nm5swarc266mnz5xly296db4nwzm7k5cwsn2pjijmyknk";
        libraryHaskellDepends = [ base ];
-       testHaskellDepends = [ base doctest QuickCheck ];
        description = "A numeric class hierarchy";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
      }) {};
 
   "numhask-array" = callPackage
-    ({ mkDerivation, adjunctions, base, distributive, doctest, numhask
-     , vector
+    ({ mkDerivation, adjunctions, base, distributive, numhask, vector
      }:
      mkDerivation {
        pname = "numhask-array";
-       version = "0.9.0";
-       sha256 = "09l0cm2f66c5bagrwby8bj22b6lklbi8mbsgxxh0gw5zvb9bhgmr";
+       version = "0.9.1";
+       sha256 = "02xklvpk21h97005xs1ywll83qn3h6845zxp9baljk12b9j4ls1r";
        libraryHaskellDepends = [
          adjunctions base distributive numhask vector
        ];
-       testHaskellDepends = [ base doctest ];
-       description = "Multi-dimensional array interface for numhask";
+       description = "Multi-dimensional arrays";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
···
 
   "numhask-space" = callPackage
     ({ mkDerivation, adjunctions, base, containers, distributive
-     , doctest, numhask, random, semigroupoids, tdigest, text, time
-     , vector
+     , numhask, random, semigroupoids, tdigest, text, time, vector
      }:
      mkDerivation {
        pname = "numhask-space";
-       version = "0.8.0.0";
-       sha256 = "1ya4fcr0mxj4blijl2k2sdfkkywjmr616qcaddl7zqphjvrc4gd0";
+       version = "0.8.1.0";
+       sha256 = "1j117m1qfnl5h286x6c8kbm06xpm8rqqkipv1qbw0sp7a0cc022z";
        libraryHaskellDepends = [
          adjunctions base containers distributive numhask random
          semigroupoids tdigest text time vector
        ];
-       testHaskellDepends = [ base doctest ];
        description = "Numerical spaces";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "optparse-generic";
-       version = "1.4.4";
-       sha256 = "0xy0kc8qximsiqpnc1fmh5zlsh6n26s7scrixin5bwnylg056j74";
-       revision = "3";
-       editedCabalFile = "1y5m84d72z2fhnzznlyq4hj4hfg04hgszng3ps4dz4s1wd565m1s";
-       libraryHaskellDepends = [
-         base bytestring Only optparse-applicative system-filepath text time
-         transformers void
-       ];
-       description = "Auto-generate a command-line parser for your datatype";
-       license = lib.licenses.bsd3;
-       maintainers = with lib.maintainers; [ Gabriel439 ];
-     }) {};
-
-  "optparse-generic_1_4_5" = callPackage
-    ({ mkDerivation, base, bytestring, Only, optparse-applicative
-     , system-filepath, text, time, transformers, void
-     }:
-     mkDerivation {
-       pname = "optparse-generic";
        version = "1.4.5";
        sha256 = "06lyx1im1a5sxj2i6v3lzc16q8pk6lafqzqvdzg9aiximm3idy1a";
        libraryHaskellDepends = [
···
        ];
        description = "Auto-generate a command-line parser for your datatype";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ Gabriel439 ];
      }) {};
 
···
     ({ mkDerivation, base, bytestring, opusfile }:
      mkDerivation {
        pname = "opusfile";
-       version = "0.1.0.0";
-       sha256 = "12mjkmsffnid48sjc6j1wrikw4pl1yz5jk6bgnarv86wcs30w54a";
+       version = "0.1.0.1";
+       sha256 = "159qx2z2q56f42yi3smj9fx7gbpqxxnsyap09hdnpy8rzv4gl904";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "partial-isomorphisms_0_2_3_0" = callPackage
+    ({ mkDerivation, base, template-haskell }:
+     mkDerivation {
+       pname = "partial-isomorphisms";
+       version = "0.2.3.0";
+       sha256 = "08390b7vj02kbx0s5q3irxljr1p8w4rvm6kf33ivv04cal3r2q39";
+       libraryHaskellDepends = [ base template-haskell ];
+       description = "Partial isomorphisms";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "partial-lens" = callPackage
     ({ mkDerivation, base, comonad-transformers, data-lens
      , transformers
···
      }) {};
 
   "perf" = callPackage
-    ({ mkDerivation, base, containers, deepseq, doctest, foldl, rdtsc
-     , text, time, transformers
+    ({ mkDerivation, base, containers, deepseq, foldl, mtl, rdtsc, text
+     , time, transformers
      }:
      mkDerivation {
        pname = "perf";
-       version = "0.7.0";
-       sha256 = "140fy74sq3b1k6px008yz2pr9ikikd68llzc411qs3nclwzasxgx";
+       version = "0.8.0";
+       sha256 = "1wgl5nwvip2mxicskqqj6c0c53rp1x4ls31j5i5njd324kvxp8ql";
        libraryHaskellDepends = [
-         base containers deepseq foldl rdtsc text time transformers
+         base containers deepseq foldl mtl rdtsc text time transformers
        ];
-       testHaskellDepends = [ base deepseq doctest rdtsc ];
        description = "Low-level run time measurement";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "persistent";
-       version = "2.13.1.1";
-       sha256 = "0sg51psmpjsz9hiva0gn3xcnd74a6dwbzx1bzi918idcfkpbn496";
-       libraryHaskellDepends = [
-         aeson attoparsec base base64-bytestring blaze-html bytestring
-         conduit containers fast-logger http-api-data lift-type monad-logger
-         mtl path-pieces resource-pool resourcet scientific silently
-         template-haskell text th-lift-instances time transformers unliftio
-         unliftio-core unordered-containers vector
-       ];
-       testHaskellDepends = [
-         aeson attoparsec base base64-bytestring blaze-html bytestring
-         conduit containers fast-logger hspec http-api-data monad-logger mtl
-         path-pieces QuickCheck quickcheck-instances resource-pool resourcet
-         scientific shakespeare silently template-haskell text
-         th-lift-instances time transformers unliftio unliftio-core
-         unordered-containers vector
-       ];
-       benchmarkHaskellDepends = [
-         base criterion deepseq file-embed template-haskell text
-       ];
-       description = "Type-safe, multi-backend data serialization";
-       license = lib.licenses.mit;
-       maintainers = with lib.maintainers; [ psibi ];
-     }) {};
-
-  "persistent_2_13_1_2" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
-     , blaze-html, bytestring, conduit, containers, criterion, deepseq
-     , fast-logger, file-embed, hspec, http-api-data, lift-type
-     , monad-logger, mtl, path-pieces, QuickCheck, quickcheck-instances
-     , resource-pool, resourcet, scientific, shakespeare, silently
-     , template-haskell, text, th-lift-instances, time, transformers
-     , unliftio, unliftio-core, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "persistent";
        version = "2.13.1.2";
        sha256 = "09si4h64i9drqr80a2sxpxhmsinacqx9bvsc3jah5zlm915q092y";
        libraryHaskellDepends = [
···
        ];
        description = "Type-safe, multi-backend data serialization";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ psibi ];
      }) {};
 
···
      }:
      mkDerivation {
        pname = "persistent-mysql";
-       version = "2.13.0.1";
-       sha256 = "1gl48xcsczpzipg9v107x970rzi66vr26772ml9z8szxygamgsdb";
-       libraryHaskellDepends = [
-         aeson base blaze-builder bytestring conduit containers monad-logger
-         mysql mysql-simple persistent resource-pool resourcet text
-         transformers unliftio-core
-       ];
-       testHaskellDepends = [
-         aeson base bytestring containers fast-logger hspec http-api-data
-         HUnit monad-logger mysql path-pieces persistent persistent-qq
-         persistent-test QuickCheck quickcheck-instances resourcet text time
-         transformers unliftio-core
-       ];
-       description = "Backend for the persistent library using MySQL database server";
-       license = lib.licenses.mit;
-     }) {};
-
-  "persistent-mysql_2_13_0_2" = callPackage
-    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
-     , containers, fast-logger, hspec, http-api-data, HUnit
-     , monad-logger, mysql, mysql-simple, path-pieces, persistent
-     , persistent-qq, persistent-test, QuickCheck, quickcheck-instances
-     , resource-pool, resourcet, text, time, transformers, unliftio-core
-     }:
-     mkDerivation {
-       pname = "persistent-mysql";
        version = "2.13.0.2";
        sha256 = "18ji7a7lb1mjgqvi2mv2cg4vlgjkyzg2hgp09s7c9v071p3ll732";
        libraryHaskellDepends = [
···
        ];
        description = "Backend for the persistent library using MySQL database server";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "persistent-mysql-haskell" = callPackage
···
        ];
        description = "Backend for the persistent library using postgresql";
        license = lib.licenses.mit;
+     }) {};
+
+  "persistent-postgresql_2_13_1_0" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
+     , conduit, containers, fast-logger, hspec, hspec-expectations
+     , hspec-expectations-lifted, http-api-data, HUnit, monad-logger
+     , mtl, path-pieces, persistent, persistent-qq, persistent-test
+     , postgresql-libpq, postgresql-simple, QuickCheck
+     , quickcheck-instances, resource-pool, resourcet
+     , string-conversions, text, time, transformers, unliftio
+     , unliftio-core, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "persistent-postgresql";
+       version = "2.13.1.0";
+       sha256 = "05bj3b7kdwaba3szrrsmafxr6vcnvdhq20jk5xx348jnf2flkw0i";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson attoparsec base blaze-builder bytestring conduit containers
+         monad-logger mtl persistent postgresql-libpq postgresql-simple
+         resource-pool resourcet string-conversions text time transformers
+         unliftio-core
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers fast-logger hspec
+         hspec-expectations hspec-expectations-lifted http-api-data HUnit
+         monad-logger path-pieces persistent persistent-qq persistent-test
+         QuickCheck quickcheck-instances resourcet text time transformers
+         unliftio unliftio-core unordered-containers vector
+       ];
+       description = "Backend for the persistent library using postgresql";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "persistent-protobuf" = callPackage
···
      }:
      mkDerivation {
        pname = "phonetic-languages-phonetics-basics";
-       version = "0.8.3.0";
-       sha256 = "11pdp7myhc70h4vv84z9n246nrs33jq42vh4rnbc4j2lf1vlfwxg";
+       version = "0.8.4.0";
+       sha256 = "1sxc7qsp93qdf11lp09www1ynrzpnxnc0k00pidz1bpka2hqcjh1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-examples-array";
-       version = "0.10.1.0";
-       sha256 = "0js0rbm401b7yipf7kbngzam44lrxjv9nnicdf5y3dk684n7xkyv";
+       version = "0.11.0.1";
+       sha256 = "0mr1pckay3i72yh1b1dbbm68cbf4jx2vw1w0h86ykvamc1vjy7lp";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, heaps, mmsyn2-array
      , phonetic-languages-constraints-array
      , phonetic-languages-ukrainian-array
-     , ukrainian-phonetics-basic-array
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-examples-common";
-       version = "0.1.2.0";
-       sha256 = "0px34h2j6b1vjsldjg3mvm1spprkd3k31y1lli7wm6r0pgk33b86";
+       version = "0.1.3.0";
+       sha256 = "09jl0zjpny5xh7f9igglfdl36lazrrr131khi625ay48283g2wpc";
        libraryHaskellDepends = [
          base heaps mmsyn2-array phonetic-languages-constraints-array
-         phonetic-languages-ukrainian-array ukrainian-phonetics-basic-array
+         phonetic-languages-ukrainian-array
        ];
        description = "Some commonly used by phonetic-languages-simplified* series functions";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-generalized-examples-array";
-       version = "0.10.1.0";
-       sha256 = "1h78v236mw43gs424pc0ilyaa4yrld9fwh64p6rmc3jvkgkp1ry1";
+       version = "0.11.0.0";
+       sha256 = "0qxvfn4ii0v722r11hgcwb68d19ji1xchdkgr5n4dsbdkzqlvjrf";
        libraryHaskellDepends = [
          base heaps mmsyn2-array mmsyn3 parallel
          phonetic-languages-constraints-array
···
     ({ mkDerivation, base, mmsyn2-array, mmsyn5 }:
      mkDerivation {
        pname = "phonetic-languages-ukrainian-array";
-       version = "0.5.0.0";
-       sha256 = "034xkl4q4n0gdvacymsgbhwyqfj42d06swldn3q8q1i9ka6d4nxv";
+       version = "0.6.0.0";
+       sha256 = "01wsdcnl9vidwbmxv1jlvchad477l5kdkz6jnfm6rnfkyrfwrcrn";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mmsyn2-array mmsyn5 ];
···
      }:
      mkDerivation {
        pname = "record-dot-preprocessor";
-       version = "0.2.11";
-       sha256 = "1hsk7n8hrskj30wcil4rvjhng3zcj7f9a0dn69371iay4x8d75md";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [ base extra ghc uniplate ];
-       executableHaskellDepends = [ base extra ];
-       testHaskellDepends = [ base extra filepath record-hasfield ];
-       description = "Preprocessor to allow record.field syntax";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "record-dot-preprocessor_0_2_12" = callPackage
-    ({ mkDerivation, base, extra, filepath, ghc, record-hasfield
-     , uniplate
-     }:
-     mkDerivation {
-       pname = "record-dot-preprocessor";
        version = "0.2.12";
        sha256 = "02vyfcfanf09nd33q37jmnq0wbncvkfjn4hx4yzr62dkmh47bkkf";
        isLibrary = true;
···
        testHaskellDepends = [ base extra filepath record-hasfield ];
        description = "Preprocessor to allow record.field syntax";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "record-encode" = callPackage
···
     ({ 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.0";
-       sha256 = "062pjqhba41d4bb9gb8wxpd87mpsmzj3np8y9ymagjrnv5iyaf5w";
-       revision = "1";
-       editedCabalFile = "1h38k4nxpz80j9sax7s0c7spvrmr90n1wig55id22ba361y980zh";
+       version = "0.1.0.1";
+       sha256 = "1wcnr6hk05xj3qyq6wdwyn5qv820wi6djlcllyv8nc2cz8zgc3v7";
        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\"";
···
        pname = "rhbzquery";
        version = "0.4.3";
        sha256 = "13brargymd1c9b0csaprj85qdqg98bzj3z2smbb0v66myj48v6fp";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base bytestring config-ini directory email-validate extra filepath
+         http-types optparse-applicative simple-cmd simple-cmd-args text
+       ];
+       testHaskellDepends = [ base simple-cmd ];
+       description = "Bugzilla query tool";
+       license = lib.licenses.gpl2Only;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "rhbzquery_0_4_4" = callPackage
+    ({ mkDerivation, base, bytestring, config-ini, directory
+     , email-validate, extra, filepath, http-types, optparse-applicative
+     , simple-cmd, simple-cmd-args, text
+     }:
+     mkDerivation {
+       pname = "rhbzquery";
+       version = "0.4.4";
+       sha256 = "00175smanmcr6k8b83kj7mif47jggxn0pvy64yjc4ikpbw822c2q";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "semigroups";
-       version = "0.19.1";
-       sha256 = "0j36cha1wb9vxnd8axfna92b2q5hnrn3ap8d8yin89c69gk63rvr";
-       revision = "1";
-       editedCabalFile = "10hp5ij4zivkgh1paxiwnwclgwf5xv3zrkfyvqkpgdf2l2mpm0nd";
-       libraryHaskellDepends = [ base ];
-       description = "Anything that associates";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "semigroups_0_19_2" = callPackage
-    ({ mkDerivation, base }:
-     mkDerivation {
-       pname = "semigroups";
        version = "0.19.2";
        sha256 = "0h1sl3i6k8csy5zkkpy65rxzds9wg577z83aaakybr3n1gcv4855";
        libraryHaskellDepends = [ base ];
        description = "Anything that associates";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "semigroups-actions" = callPackage
···
        pname = "servant-benchmark";
        version = "0.1.2.0";
        sha256 = "0lqqk410nx48g895pfxkbbk85b1ijs4bfl9zr2li2p7wwwc4gyi9";
+       revision = "1";
+       editedCabalFile = "1zzprj7pw7fzyscg4n9g023c47bb6fywq5b11krazz3vyynh53cc";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring case-insensitive http-media
          http-types QuickCheck servant text yaml
···
        ];
        description = "Generate benchmark files from a Servant API";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "servant-blaze" = callPackage
···
        license = lib.licenses.gpl3Plus;
      }) {};
 
+  "slynx_0_6_0_0" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, containers
+     , elynx-markov, elynx-seq, elynx-tools, elynx-tree, hmatrix
+     , mwc-random, optparse-applicative, statistics, text, transformers
+     , vector
+     }:
+     mkDerivation {
+       pname = "slynx";
+       version = "0.6.0.0";
+       sha256 = "0jk3l7nlz0s57x952qcn1yj6fdfds01flcz6xiykpjwbyjm0fq81";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         attoparsec base bytestring containers elynx-markov elynx-seq
+         elynx-tools elynx-tree hmatrix mwc-random optparse-applicative
+         statistics text transformers vector
+       ];
+       executableHaskellDepends = [ base ];
+       description = "Handle molecular sequences";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "small-bytearray-builder" = callPackage
     ({ mkDerivation, base, bytebuild, byteslice }:
      mkDerivation {
···
      }) {};
 
   "stack-all" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, config-ini, directory
-     , extra, filepath, http-query, process, simple-cmd, simple-cmd-args
-     , text, time, unordered-containers, xdg-basedir
+    ({ mkDerivation, aeson, base, cached-json-file, config-ini
+     , directory, extra, filepath, http-query, process, simple-cmd
+     , simple-cmd-args, text, unordered-containers
      }:
      mkDerivation {
        pname = "stack-all";
-       version = "0.3";
-       sha256 = "0bxrchryn0r02bbkxwwyi9rlkknjqwbiypbfj47q9fzyb2rv9gk1";
+       version = "0.3.1";
+       sha256 = "0jsz28p1xpzh77r3mhjh98jsz3lnzirfvh9w64rcgxpacdyajwhf";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         aeson base bytestring config-ini directory extra filepath
-         http-query process simple-cmd simple-cmd-args text time
-         unordered-containers xdg-basedir
+         aeson base cached-json-file config-ini directory extra filepath
+         http-query process simple-cmd simple-cmd-args text
+         unordered-containers
        ];
        description = "CLI tool for building across Stackage major versions";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "string-interpreter";
-       version = "0.4.0.0";
-       sha256 = "08d200kjwh0sjj75sv9ckkfkvr254233bjsisd7aaj81kiig4vnn";
+       version = "0.5.2.0";
+       sha256 = "1i6y41kyhbarwsppm55rlb1ddqihnpcc89yfgsd8mjgmbrmpsr3l";
        libraryHaskellDepends = [ base ];
-       description = "Is used in the recursive mode for phonetic languages approach";
+       description = "Is used in the phonetic languages approach (e. g. in the recursive mode).";
        license = lib.licenses.mit;
      }) {};
 
···
        pname = "tar";
        version = "0.5.1.1";
        sha256 = "1ppim7cgmn7ng8zbdrwkxhhizc30h15h1c9cdlzamc5jcagl915k";
-       revision = "3";
-       editedCabalFile = "0qjhii1lhvqav3pnm6z5ly40d9gwp7p3y4g7k26bhxgy31bx1pll";
+       revision = "4";
+       editedCabalFile = "03a33nj9k62f318qgmp5pgk7i99c8cyqy5f7m7p0bwc5ni39ysfq";
        libraryHaskellDepends = [
          array base bytestring containers deepseq directory filepath time
        ];
···
        pname = "tasty-rerun";
        version = "1.1.18";
        sha256 = "0sccp5zx9v2rx741nbmgd8mzjhy5m4v74hk26d23xz93ph8aqx7s";
-       revision = "1";
-       editedCabalFile = "17w6kxdd9zw87lh1bmh24c7dp59df8dshygx88j2i5nhbn7lfn50";
+       revision = "2";
+       editedCabalFile = "1fis4l7rlzmkw4135q3dikx9v22yhyqin3snlm1l7hsv8s33jpyl";
        libraryHaskellDepends = [
          base containers mtl optparse-applicative split stm tagged tasty
          transformers
···
        broken = true;
      }) {};
 
+  "tell" = callPackage
+    ({ mkDerivation, base, mtl, transformers }:
+     mkDerivation {
+       pname = "tell";
+       version = "0.1";
+       sha256 = "0l56mvgj543xp9cgafqycch6f9pgwjsnahy3zcpi1dxbmlwwy6gr";
+       libraryHaskellDepends = [ base mtl transformers ];
+       description = "The MonadTell class and related monad transformers";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "tellbot" = callPackage
     ({ mkDerivation, base, bifunctors, bytestring, containers
      , http-conduit, mtl, network, regex-pcre, split, tagsoup, text
···
        pname = "ten";
        version = "0.1.0.0";
        sha256 = "0rgcwwc3rq1bk3dc1plqyhc8mzk429ghswl6ry4zs2n8ds57gnwj";
+       revision = "1";
+       editedCabalFile = "0dslnfn52q87sb2d9di80nirwmfk3bkhc2wbp2wh209k0b5va63w";
        libraryHaskellDepends = [
          adjunctions base data-default-class deepseq distributive hashable
          portray portray-diff some text transformers wrapped
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "text-ldap_0_1_1_14" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, containers, memory
+     , QuickCheck, quickcheck-simple, random, transformers
+     }:
+     mkDerivation {
+       pname = "text-ldap";
+       version = "0.1.1.14";
+       sha256 = "0wb5x5q099i1phgwzhi4rs3qrrimsrfg6cnxah33sdzszax7dqnn";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         attoparsec base bytestring containers memory transformers
+       ];
+       executableHaskellDepends = [ base bytestring ];
+       testHaskellDepends = [
+         base bytestring QuickCheck quickcheck-simple random
+       ];
+       description = "Parser and Printer for LDAP text data stream";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "text-lens" = callPackage
     ({ mkDerivation, base, extra, hspec, lens, text }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "text-show";
-       version = "3.9";
-       sha256 = "1cj6w77lgh9cydg1jz3wfhll0bvzrmhgk37dgm7s33qbkpq9mf90";
-       revision = "1";
-       editedCabalFile = "1jwsp8g7c7wywxvhb7ns7xw0h7mbr33c3kyhba8ybw0rn43ynjki";
-       libraryHaskellDepends = [
-         array base base-compat-batteries bifunctors bytestring
-         bytestring-builder containers generic-deriving ghc-boot-th ghc-prim
-         integer-gmp 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;
-     }) {};
-
-  "text-show_3_9_2" = 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, integer-gmp, QuickCheck
-     , quickcheck-instances, template-haskell, text, th-abstraction
-     , th-lift, transformers, transformers-compat
-     }:
-     mkDerivation {
-       pname = "text-show";
        version = "3.9.2";
        sha256 = "0srm3qj7z0c1zxpzp7n0frjdh0hxb76mz43d1ry30nrg0k4lj8lh";
        libraryHaskellDepends = [
···
        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, containers, ghc-prim, template-haskell }:
      mkDerivation {
        pname = "th-abstraction";
-       version = "0.4.2.0";
-       sha256 = "0h0wl442a82llpjsxv45i7grgyanlzjj7k28mhnvbi2zlb6v41pa";
-       revision = "1";
-       editedCabalFile = "1yc17r29vkwi4qzbrxy1d3gra87hk3ghy1jzfmrl2q8zjc0v59vb";
-       libraryHaskellDepends = [
-         base containers ghc-prim template-haskell
-       ];
-       testHaskellDepends = [ base containers template-haskell ];
-       description = "Nicer interface for reified information about data types";
-       license = lib.licenses.isc;
-     }) {};
-
-  "th-abstraction_0_4_3_0" = callPackage
-    ({ mkDerivation, base, containers, ghc-prim, template-haskell }:
-     mkDerivation {
-       pname = "th-abstraction";
        version = "0.4.3.0";
        sha256 = "01nyscmjriga4fh4362b4zjad48hdv33asjkd28sj8hx3pii7fy8";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base containers template-haskell ];
        description = "Nicer interface for reified information about data types";
        license = lib.licenses.isc;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "th-alpha" = callPackage
···
      }:
      mkDerivation {
        pname = "th-compat";
-       version = "0.1.2";
-       sha256 = "009qc0yy5iq61kgnp9n6vdlqh8zmk4bjawcvpigccgfyk40mvi1b";
-       libraryHaskellDepends = [ base template-haskell ];
-       testHaskellDepends = [
-         base base-compat hspec mtl template-haskell
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "Backward- (and forward-)compatible Quote and Code types";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "th-compat_0_1_3" = callPackage
-    ({ mkDerivation, base, base-compat, hspec, hspec-discover, mtl
-     , template-haskell
-     }:
-     mkDerivation {
-       pname = "th-compat";
        version = "0.1.3";
        sha256 = "1il1hs5yjfkb417c224pw1vrh4anyprasfwmjbd4fkviyv55jl3b";
        libraryHaskellDepends = [ base template-haskell ];
···
        testToolDepends = [ hspec-discover ];
        description = "Backward- (and forward-)compatible Quote and Code types";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "th-constraint-compat" = callPackage
···
 
   "th-orphans" = callPackage
     ({ mkDerivation, base, bytestring, ghc-prim, hspec, hspec-discover
-     , mtl, template-haskell, th-compat, th-lift, th-lift-instances
-     , th-reify-many
-     }:
-     mkDerivation {
-       pname = "th-orphans";
-       version = "0.13.11";
-       sha256 = "1m7mysjhdmfc642dqbxq6sz5fir00kzq54w4n1pcn5d64ip5njkf";
-       libraryHaskellDepends = [
-         base mtl template-haskell th-compat 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_12" = 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
      }:
···
        testToolDepends = [ hspec-discover ];
        description = "Orphan instances for TH datatypes";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "th-pprint" = callPackage
···
        testHaskellDepends = [ base template-haskell ];
        description = "Recurseively reify template haskell datatype info";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "th-reify-many_0_1_10" = callPackage
+    ({ mkDerivation, base, containers, mtl, safe, template-haskell
+     , th-expand-syns
+     }:
+     mkDerivation {
+       pname = "th-reify-many";
+       version = "0.1.10";
+       sha256 = "19g4gc1q3zxbylmvrgk3dqjzychq2k02i7fwvs3vhbrg4ihhw9cx";
+       libraryHaskellDepends = [
+         base containers mtl safe template-haskell th-expand-syns
+       ];
+       testHaskellDepends = [ base template-haskell ];
+       description = "Recurseively reify template haskell datatype info";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "th-sccs" = callPackage
···
      }) {};
 
   "thread-utils-context" = callPackage
-    ({ mkDerivation, base, containers, ghc-prim
+    ({ mkDerivation, base, containers, criterion, ghc-prim, mtl
      , thread-utils-finalizers
      }:
      mkDerivation {
        pname = "thread-utils-context";
-       version = "0.1.0.0";
-       sha256 = "0zq24w0cgyvzs7nafas92jwkakf34bmj1099ysqkfv10nlwgkf5q";
+       version = "0.2.0.0";
+       sha256 = "0bxr9bpm3zr29nd2ymblijr2ikbhgxvx3vj7yn6bwx8s6cgc4mr9";
        libraryHaskellDepends = [
          base containers ghc-prim thread-utils-finalizers
        ];
        testHaskellDepends = [
          base containers ghc-prim thread-utils-finalizers
+       ];
+       benchmarkHaskellDepends = [
+         base containers criterion ghc-prim mtl thread-utils-finalizers
        ];
        description = "Garbage-collected thread local storage";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.gpl3Plus;
      }) {};
 
+  "tlynx_0_6_0_0" = callPackage
+    ({ mkDerivation, aeson, async, attoparsec, base, bytestring
+     , comonad, containers, data-default-class, elynx-tools, elynx-tree
+     , gnuplot, mwc-random, optparse-applicative, parallel, statistics
+     , text, transformers, vector
+     }:
+     mkDerivation {
+       pname = "tlynx";
+       version = "0.6.0.0";
+       sha256 = "1iz555rfq4wi5yc5bqfgkgwzmlxcksxmbpcfdwmcarcijazm9mpi";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson async attoparsec base bytestring comonad containers
+         data-default-class elynx-tools elynx-tree gnuplot mwc-random
+         optparse-applicative parallel statistics text transformers vector
+       ];
+       executableHaskellDepends = [ base ];
+       description = "Handle phylogenetic trees";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "tmapchan" = callPackage
     ({ mkDerivation, base, containers, hashable, stm
      , unordered-containers
···
        pname = "unix";
        version = "2.7.2.2";
        sha256 = "1b6ygkasn5bvmdci8g3zjkahl34kfqhf5jrayibvnrcdnaqlxpcq";
-       revision = "7";
-       editedCabalFile = "1hkmb19m2mm8h2v69awip25i7cpg0967yih89q5npqsxknix4hkw";
+       revision = "8";
+       editedCabalFile = "1ydydm9i82pn5sy7drl404qlll318x8bjwhpvr2lwqwmb5f3dx8m";
        libraryHaskellDepends = [ base bytestring time ];
        description = "POSIX functionality";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "unliftio";
-       version = "0.2.19";
-       sha256 = "052m0vr6444r5adzyzr3aqj07p9ay5y2sqfsczwj52bc66qqyy36";
-       libraryHaskellDepends = [
-         async base bytestring deepseq directory filepath process stm time
-         transformers unix unliftio-core
-       ];
-       testHaskellDepends = [
-         async base bytestring containers deepseq directory filepath hspec
-         process QuickCheck stm time transformers unix unliftio-core
-       ];
-       benchmarkHaskellDepends = [
-         async base bytestring deepseq directory filepath gauge process stm
-         time transformers unix unliftio-core
-       ];
-       description = "The MonadUnliftIO typeclass for unlifting monads to IO (batteries included)";
-       license = lib.licenses.mit;
-     }) {};
-
-  "unliftio_0_2_20" = callPackage
-    ({ mkDerivation, async, base, bytestring, containers, deepseq
-     , directory, filepath, gauge, hspec, process, QuickCheck, stm, time
-     , transformers, unix, unliftio-core
-     }:
-     mkDerivation {
-       pname = "unliftio";
        version = "0.2.20";
        sha256 = "0mbm57h7r16qd7kpglbm50qrnfjmazd70avbrl647n4jwhlrp7my";
        libraryHaskellDepends = [
···
        ];
        description = "The MonadUnliftIO typeclass for unlifting monads to IO (batteries included)";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "unliftio-core" = callPackage
···
        testHaskellDepends = [ base network network-uri QuickCheck ];
        description = "Generate or process x-www-urlencoded data";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "urlpath" = callPackage
···
        pname = "vector";
        version = "0.12.3.0";
        sha256 = "00xp86yad3yv4ja4q07gkmmcf7iwpcnzkkaf91zkx9nxb981iy0m";
+       revision = "2";
+       editedCabalFile = "18nlva9z2s37ikcl4msadynl7glipsx9cfpcdi8pzy8k5gvdm5hm";
        libraryHaskellDepends = [ base deepseq ghc-prim primitive ];
        testHaskellDepends = [
          base base-orphans HUnit primitive QuickCheck random tasty
···
        pname = "vector-rotcev";
        version = "0.1.0.0";
        sha256 = "1sl5jwmpmzzvknalgqrbpy3yhqclgqxf75wnpb24rn416kdscy6j";
+       revision = "1";
+       editedCabalFile = "1hn2g8wykmisaacw4w8iffcd8qn3dnkl9lkj3j9n0324xm1b3sp0";
        libraryHaskellDepends = [ base vector ];
        testHaskellDepends = [ base tasty tasty-quickcheck vector ];
        description = "Vectors with O(1) reverse";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "vector-rotcev_0_1_0_1" = callPackage
+    ({ mkDerivation, base, tasty, tasty-quickcheck, vector }:
+     mkDerivation {
+       pname = "vector-rotcev";
+       version = "0.1.0.1";
+       sha256 = "1zrw1r6xspjncavd307xbbnjdmmhjq9w3dbvm0khnkxjgh47is8v";
+       libraryHaskellDepends = [ base vector ];
+       testHaskellDepends = [ base tasty tasty-quickcheck vector ];
+       description = "Vectors with O(1) reverse";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "vector-shuffling" = callPackage
···
        broken = true;
      }) {};
 
+  "wai-session-redis_0_1_0_3" = callPackage
+    ({ mkDerivation, base, bytestring, cereal, data-default, hedis
+     , hspec, http-types, vault, wai, wai-session, warp
+     }:
+     mkDerivation {
+       pname = "wai-session-redis";
+       version = "0.1.0.3";
+       sha256 = "1ikm5i4cvx2wzlq5ij7aqk9c37jpnw9c0dl0xdw3c4hqsnjnb5yj";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring cereal data-default hedis vault wai wai-session
+       ];
+       executableHaskellDepends = [
+         base bytestring cereal data-default hedis http-types vault wai
+         wai-session warp
+       ];
+       testHaskellDepends = [
+         base bytestring cereal data-default hedis hspec vault wai
+         wai-session
+       ];
+       description = "Simple Redis backed wai-session backend";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "wai-session-tokyocabinet" = callPackage
     ({ mkDerivation, base, bytestring, cereal, errors
      , tokyocabinet-haskell, transformers, wai-session
···
        ];
        description = "Implements Windows Live Web Authentication and Delegated Authentication";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "winerror" = callPackage
···
        pname = "zlib";
        version = "0.6.2.3";
        sha256 = "125wbayk8ifp0gp8cb52afck2ziwvqfrjzbmwmy52g6bz7fnnzw0";
+       revision = "1";
+       editedCabalFile = "1r6sc6p648jgq4vslzbr171w52rk3fjv3wspxvs5kgkhygdr6ai6";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ zlib ];
        testHaskellDepends = [

pkgs/development/libraries/gvm-libs/default.nix

···
+{ lib
+, stdenv
+, cmake
+, fetchFromGitHub
+, glib
+, glib-networking
+, gnutls
+, gpgme
+, hiredis
+, libgcrypt
+, libnet
+, libpcap
+, libssh
+, libuuid
+, libxml2
+, pkg-config
+, zlib
+, freeradius
+}:
+
+stdenv.mkDerivation rec {
+  pname = "gvm-libs";
+  version = "21.4.1";
+
+  src = fetchFromGitHub {
+    owner = "greenbone";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "1ap3m7f1gyv9p96czi8mzryhjijgaqcbdyr8lwvnw8ynzskx8s3y";
+  };
+
+  nativeBuildInputs = [
+    cmake
+    pkg-config
+  ];
+
+  buildInputs = [
+    glib
+    glib-networking
+    gnutls
+    gpgme
+    hiredis
+    libgcrypt
+    freeradius
+    libnet
+    libpcap
+    libssh
+    libuuid
+    libxml2
+    zlib
+  ];
+
+  meta = with lib; {
+    description = "Libraries module for the Greenbone Vulnerability Management Solution";
+    homepage = "https://github.com/greenbone/gvm-libs";
+    license = with licenses; [ gpl2Plus ];
+    maintainers = with maintainers; [ fab ];
+    platforms = platforms.linux;
+  };
+}

pkgs/development/mobile/cocoapods/Gemfile-beta.lock

···
   remote: https://rubygems.org/
   specs:
     CFPropertyList (3.0.3)
-    activesupport (6.1.4)
+    activesupport (6.1.4.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
···
       json (>= 1.5.1)
     atomos (0.1.3)
     claide (1.0.3)
-    cocoapods (1.11.0.beta.2)
+    cocoapods (1.11.0)
       addressable (~> 2.8)
       claide (>= 1.0.2, < 2.0)
-      cocoapods-core (= 1.11.0.beta.2)
+      cocoapods-core (= 1.11.0)
       cocoapods-deintegrate (>= 1.0.3, < 2.0)
       cocoapods-downloader (>= 1.4.0, < 2.0)
       cocoapods-plugins (>= 1.0.0, < 2.0)
···
       nap (~> 1.0)
       ruby-macho (>= 1.0, < 3.0)
       xcodeproj (>= 1.21.0, < 2.0)
-    cocoapods-core (1.11.0.beta.2)
+    cocoapods-core (1.11.0)
       activesupport (>= 5.0, < 7)
       addressable (~> 2.8)
       algoliasearch (~> 1.0)
···
       public_suffix (~> 4.0)
       typhoeus (~> 1.0)
     cocoapods-deintegrate (1.0.5)
-    cocoapods-downloader (1.4.0)
+    cocoapods-downloader (1.5.1)
     cocoapods-plugins (1.0.0)
       nap
     cocoapods-search (1.0.1)
-    cocoapods-trunk (1.5.0)
+    cocoapods-trunk (1.6.0)
       nap (>= 0.8, < 2.0)
       netrc (~> 0.11)
     cocoapods-try (1.2.0)
···
     escape (0.0.4)
     ethon (0.14.0)
       ffi (>= 1.15.0)
-    ffi (1.15.3)
+    ffi (1.15.4)
     fourflusher (2.3.1)
     fuzzy_match (2.0.4)
     gh_inspector (1.1.3)
···
     zeitwerk (2.4.2)
 
 PLATFORMS
-  arm64-darwin-20
+  ruby
 
 DEPENDENCIES
   cocoapods (>= 1.7.0.beta.1)!

pkgs/development/mobile/cocoapods/Gemfile.lock

···
   remote: https://rubygems.org/
   specs:
     CFPropertyList (3.0.3)
-    activesupport (5.2.6)
+    activesupport (6.1.4.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
     addressable (2.8.0)
       public_suffix (>= 2.0.2, < 5.0)
     algoliasearch (1.27.5)
···
       json (>= 1.5.1)
     atomos (0.1.3)
     claide (1.0.3)
-    cocoapods (1.10.2)
-      addressable (~> 2.6)
+    cocoapods (1.11.0)
+      addressable (~> 2.8)
       claide (>= 1.0.2, < 2.0)
-      cocoapods-core (= 1.10.2)
+      cocoapods-core (= 1.11.0)
       cocoapods-deintegrate (>= 1.0.3, < 2.0)
       cocoapods-downloader (>= 1.4.0, < 2.0)
       cocoapods-plugins (>= 1.0.0, < 2.0)
···
       escape (~> 0.0.4)
       fourflusher (>= 2.3.0, < 3.0)
       gh_inspector (~> 1.0)
-      molinillo (~> 0.6.6)
+      molinillo (~> 0.8.0)
       nap (~> 1.0)
-      ruby-macho (~> 1.4)
-      xcodeproj (>= 1.19.0, < 2.0)
-    cocoapods-core (1.10.2)
-      activesupport (> 5.0, < 6)
-      addressable (~> 2.6)
+      ruby-macho (>= 1.0, < 3.0)
+      xcodeproj (>= 1.21.0, < 2.0)
+    cocoapods-core (1.11.0)
+      activesupport (>= 5.0, < 7)
+      addressable (~> 2.8)
       algoliasearch (~> 1.0)
       concurrent-ruby (~> 1.1)
       fuzzy_match (~> 2.0.4)
       nap (~> 1.0)
       netrc (~> 0.11)
-      public_suffix
+      public_suffix (~> 4.0)
       typhoeus (~> 1.0)
     cocoapods-deintegrate (1.0.5)
-    cocoapods-downloader (1.4.0)
+    cocoapods-downloader (1.5.1)
     cocoapods-plugins (1.0.0)
       nap
     cocoapods-search (1.0.1)
-    cocoapods-trunk (1.5.0)
+    cocoapods-trunk (1.6.0)
       nap (>= 0.8, < 2.0)
       netrc (~> 0.11)
     cocoapods-try (1.2.0)
···
     escape (0.0.4)
     ethon (0.14.0)
       ffi (>= 1.15.0)
-    ffi (1.15.3)
+    ffi (1.15.4)
     fourflusher (2.3.1)
     fuzzy_match (2.0.4)
     gh_inspector (1.1.3)
···
       concurrent-ruby (~> 1.0)
     json (2.5.1)
     minitest (5.14.4)
-    molinillo (0.6.6)
+    molinillo (0.8.0)
     nanaimo (0.3.0)
     nap (1.1.0)
     netrc (0.11.0)
     public_suffix (4.0.6)
     rexml (3.2.5)
-    ruby-macho (1.4.0)
-    thread_safe (0.3.6)
+    ruby-macho (2.5.1)
     typhoeus (1.4.0)
       ethon (>= 0.9.0)
-    tzinfo (1.2.9)
-      thread_safe (~> 0.1)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
     xcodeproj (1.21.0)
       CFPropertyList (>= 2.3.3, < 4.0)
       atomos (~> 0.1.3)
···
       colored2 (~> 3.1)
       nanaimo (~> 0.3.0)
       rexml (~> 3.2.4)
+    zeitwerk (2.4.2)
 
 PLATFORMS
-  arm64-darwin-20
+  ruby
 
 DEPENDENCIES
   cocoapods!

pkgs/development/mobile/cocoapods/gemset-beta.nix

···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0kqgywy4cj3h5142dh7pl0xx5nybp25jn0ykk0znziivzks68xdk";
+      sha256 = "19gx1jcq46x9d1pi1w8xq0bgvvfw239y4lalr8asm291gj3q3ds4";
       type = "gem";
     };
-    version = "6.1.4";
+    version = "6.1.4.1";
   };
   addressable = {
     dependencies = ["public_suffix"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1rvmvxday0fg1p1ardmqc62xam212c6iaaf1djahvz70631grprq";
+      sha256 = "1b8773v98vkcr55yx5ydc28wq8ya53ya1v51cj7fxg5n3aa5h0cz";
       type = "gem";
     };
-    version = "1.11.0.beta.2";
+    version = "1.11.0";
   };
   cocoapods-core = {
     dependencies = ["activesupport" "addressable" "algoliasearch" "concurrent-ruby" "fuzzy_match" "nap" "netrc" "public_suffix" "typhoeus"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0cnnmbajllp3mw2w2b2bs2y42cnh1y1zbq63m3asg097z4d1a9h1";
+      sha256 = "19bik6yj125vhq0vxb6fsb41b3i2bi4437l7dkhgrw317gx3wf9b";
       type = "gem";
     };
-    version = "1.11.0.beta.2";
+    version = "1.11.0";
   };
   cocoapods-deintegrate = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1j03hxvz3m82fwgx3jayw0y2iqm7zpacn88r6nfj2arkbjxmvjwz";
+      sha256 = "161sjpyxipnbhwcr5kyfbcdbzs9zq20sigsazjm782cn3s466p0z";
       type = "gem";
     };
-    version = "1.4.0";
+    version = "1.5.1";
   };
   cocoapods-plugins = {
     dependencies = ["nap"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "12c6028bmdwrbqcb49mr5qj1p3vcijnjqbsbzywfx1isp44j9mv5";
+      sha256 = "0cgdx7z9psxxrsa13fk7qc9i6jskrwcafhrdz94avzia2y6dlnsz";
       type = "gem";
     };
-    version = "1.5.0";
+    version = "1.6.0";
   };
   cocoapods-try = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1wgvaclp4h9y8zkrgz8p2hqkrgr4j7kz0366mik0970w532cbmcq";
+      sha256 = "0ssxcywmb3flxsjdg13is6k01807zgzasdhj4j48dm7ac59cmksn";
       type = "gem";
     };
-    version = "1.15.3";
+    version = "1.15.4";
   };
   fourflusher = {
     groups = ["default"];

pkgs/development/mobile/cocoapods/gemset.nix

···
 {
   activesupport = {
-    dependencies = ["concurrent-ruby" "i18n" "minitest" "tzinfo"];
+    dependencies = ["concurrent-ruby" "i18n" "minitest" "tzinfo" "zeitwerk"];
     groups = ["default"];
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1vybx4cj42hr6m8cdwbrqq2idh98zms8c11kr399xjczhl9ywjbj";
+      sha256 = "19gx1jcq46x9d1pi1w8xq0bgvvfw239y4lalr8asm291gj3q3ds4";
       type = "gem";
     };
-    version = "5.2.6";
+    version = "6.1.4.1";
   };
   addressable = {
     dependencies = ["public_suffix"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0d0vlzjizqkw2m6am9gcnjkxy73zl74ill28v17v0s2v8fzd7nbg";
+      sha256 = "1b8773v98vkcr55yx5ydc28wq8ya53ya1v51cj7fxg5n3aa5h0cz";
       type = "gem";
     };
-    version = "1.10.2";
+    version = "1.11.0";
   };
   cocoapods-core = {
     dependencies = ["activesupport" "addressable" "algoliasearch" "concurrent-ruby" "fuzzy_match" "nap" "netrc" "public_suffix" "typhoeus"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1j1sapw5l3xc5d8mli09az1bbmfdynlx7xv8lbghvm9i1md14dl5";
+      sha256 = "19bik6yj125vhq0vxb6fsb41b3i2bi4437l7dkhgrw317gx3wf9b";
       type = "gem";
     };
-    version = "1.10.2";
+    version = "1.11.0";
   };
   cocoapods-deintegrate = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1j03hxvz3m82fwgx3jayw0y2iqm7zpacn88r6nfj2arkbjxmvjwz";
+      sha256 = "161sjpyxipnbhwcr5kyfbcdbzs9zq20sigsazjm782cn3s466p0z";
       type = "gem";
     };
-    version = "1.4.0";
+    version = "1.5.1";
   };
   cocoapods-plugins = {
     dependencies = ["nap"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "12c6028bmdwrbqcb49mr5qj1p3vcijnjqbsbzywfx1isp44j9mv5";
+      sha256 = "0cgdx7z9psxxrsa13fk7qc9i6jskrwcafhrdz94avzia2y6dlnsz";
       type = "gem";
     };
-    version = "1.5.0";
+    version = "1.6.0";
   };
   cocoapods-try = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1wgvaclp4h9y8zkrgz8p2hqkrgr4j7kz0366mik0970w532cbmcq";
+      sha256 = "0ssxcywmb3flxsjdg13is6k01807zgzasdhj4j48dm7ac59cmksn";
       type = "gem";
     };
-    version = "1.15.3";
+    version = "1.15.4";
   };
   fourflusher = {
     groups = ["default"];
···
     version = "5.14.4";
   };
   molinillo = {
+    groups = ["default"];
+    platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1hh40z1adl4lw16dj4hxgabx4rr28mgqycih1y1d91bwww0jjdg6";
+      sha256 = "0p846facmh1j5xmbrpgzadflspvk7bzs3sykrh5s7qi4cdqz5gzg";
       type = "gem";
     };
-    version = "0.6.6";
+    version = "0.8.0";
   };
   nanaimo = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0lhdjn91jkifsy2hzq2hgcm0pp8pbik87m58zmw1ifh6hkp9adjb";
-      type = "gem";
-    };
-    version = "1.4.0";
-  };
-  thread_safe = {
-    source = {
-      remotes = ["https://rubygems.org"];
-      sha256 = "0nmhcgq6cgz44srylra07bmaw99f5271l0dpsvl5f75m44l0gmwy";
+      sha256 = "1jgmhj4srl7cck1ipbjys6q4klcs473gq90bm59baw4j1wpfaxch";
       type = "gem";
     };
-    version = "0.3.6";
+    version = "2.5.1";
   };
   typhoeus = {
     dependencies = ["ethon"];
···
     version = "1.4.0";
   };
   tzinfo = {
-    dependencies = ["thread_safe"];
+    dependencies = ["concurrent-ruby"];
     groups = ["default"];
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0zwqqh6138s8b321fwvfbywxy00lw1azw4ql3zr0xh1aqxf8cnvj";
+      sha256 = "10qp5x7f9hvlc0psv9gsfbxg4a7s0485wsbq1kljkxq94in91l4z";
       type = "gem";
     };
-    version = "1.2.9";
+    version = "2.0.4";
   };
   xcodeproj = {
     dependencies = ["CFPropertyList" "atomos" "claide" "colored2" "nanaimo" "rexml"];
···
       type = "gem";
     };
     version = "1.21.0";
+  };
+  zeitwerk = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1746czsjarixq0x05f7p3hpzi38ldg6wxnxxw74kbjzh1sdjgmpl";
+      type = "gem";
+    };
+    version = "2.4.2";
   };
 }

pkgs/development/mobile/cocoapods/update

···
 cd "$(dirname "${BASH_SOURCE[0]}")"
 
 rm -f Gemfile.lock Gemfile-beta.lock
+
+export BUNDLE_FORCE_RUBY_PLATFORM=1
 bundler lock
 BUNDLE_GEMFILE=Gemfile-beta bundler lock --lockfile=Gemfile-beta.lock
+
 bundix --gemfile=Gemfile --lockfile=Gemfile.lock --gemset=gemset.nix
 bundix --gemfile=Gemfile-beta --lockfile=Gemfile-beta.lock --gemset=gemset-beta.nix

pkgs/development/python-modules/aiohttp-swagger/default.nix

···
 , buildPythonPackage
 , fetchFromGitHub
 , aiohttp
-, flake8
 , jinja2
+, markupsafe
+, pytest-aiohttp
 , pytestCheckHook
-, pytest-aiohttp
+, pythonOlder
 , pyyaml
 }:
 
 buildPythonPackage rec {
   pname = "aiohttp-swagger";
-  version = "1.0.5";
+  version = "1.0.15";
+
+  disabled = pythonOlder "3.6";
 
   src = fetchFromGitHub {
     owner = "cr0hn";
     repo = pname;
-    rev = "5a59e86f8c5672d2cc97dd35dc730c2f809d95ce"; # corresponds to 1.0.5 on PyPi, no tag on GitHub
-    sha256 = "1vpfk5b3f7s9qzr2q48g776f39xzqppjwm57scfzqqmbldkk5nv7";
+    rev = version;
+    sha256 = "sha256-M43sNpbXWXFRTd549cZhvhO35nBB6OH+ki36BzSk87Q=";
   };
 
-  propagatedBuildInputs = [ aiohttp jinja2 pyyaml ];
+  propagatedBuildInputs = [
+    aiohttp
+    jinja2
+    markupsafe
+    pyyaml
+  ];
 
-  checkInputs = [ flake8 pytestCheckHook pytest-aiohttp ];
+  checkInputs = [
+    pytestCheckHook
+    pytest-aiohttp
+  ];
+
+  postPatch = ''
+    substituteInPlace requirements.txt \
+      --replace "markupsafe~=1.1.1" "markupsafe>=1.1.1" \
+      --replace "jinja2~=2.11.2" "jinja2>=2.11.2"
+  '';
+
+  pythonImportsCheck = [ "aiohttp_swagger" ];
 
   meta = with lib; {
     description = "Swagger API Documentation builder for aiohttp";

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

···
 
 buildPythonPackage rec {
   pname = "aiomusiccast";
-  version = "0.9.1";
+  version = "0.9.2";
 
   format = "pyproject";
 
···
     owner = "vigonotion";
     repo = "aiomusiccast";
     rev = version;
-    sha256 = "sha256-+BmymfRKwNPlksYcAUb/5cZYeOD5h85YhobmsNFJVE8=";
+    sha256 = "sha256-xZPNEynj0kbeika15ZDEIRUe519V6Asaw+CEiBu7VL4=";
   };
 
   nativeBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "amcrest";
-  version = "1.8.0";
+  version = "1.8.1";
   disabled = pythonOlder "3.6";
 
   src = fetchFromGitHub {
     owner = "tchellomello";
     repo = "python-amcrest";
     rev = version;
-    sha256 = "180c0g840vh8dg4f08j0r29pdnhisav93d3axfvicd8fsb2cn36g";
+    sha256 = "sha256-a23AjLRNghu5CT3GHvnti0BHnku9CxLP1EkE0GrwB3w=";
   };
 
   propagatedBuildInputs = [

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

···
 , monotonic
 , six
 , nose
+, pyopenssl
+, iana-etc
+, libredirect
 }:
 
 buildPythonPackage rec {
···
   propagatedBuildInputs = [ dnspython greenlet monotonic six ]
     ++ lib.optional (pythonOlder "3.4") enum34;
 
-  prePatch = ''
-    substituteInPlace setup.py \
-      --replace "dnspython >= 1.15.0, < 2.0.0" "dnspython"
+  checkInputs = [ nose pyopenssl ];
+
+  preCheck = ''
+    echo "nameserver 127.0.0.1" > resolv.conf
+    export NIX_REDIRECTS=/etc/protocols=${iana-etc}/etc/protocols:/etc/resolv.conf=$(realpath resolv.conf)
+    export LD_PRELOAD=${libredirect}/lib/libredirect.so
+
+    export EVENTLET_IMPORT_VERSION_ONLY=0
   '';
 
-  checkInputs = [ nose ];
+  checkPhase = ''
+    runHook preCheck
+
+    nosetests --exclude test_getaddrinfo --exclude test_hosts_no_network
 
-  doCheck = false;  # too much transient errors to bother
+    runHook postCheck
+  '';
 
   # unfortunately, it needs /etc/protocol to be present to not fail
-  #pythonImportsCheck = [ "eventlet" ];
+  # pythonImportsCheck = [ "eventlet" ];
 
   meta = with lib; {
     homepage = "https://pypi.python.org/pypi/eventlet/";
     description = "A concurrent networking library for Python";
+    maintainers = with maintainers; [ SuperSandro2000 ];
     license = licenses.mit;
   };
-
 }

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

···
 
 buildPythonPackage rec {
   pname = "osmpythontools";
-  version = "0.3.0";
+  version = "0.3.2";
 
   src = fetchFromGitHub {
     owner = "mocnik-science";
     repo = "osm-python-tools";
     rev = "v${version}";
-    sha256 = "0r72z7f7kmvvbd9zvgci8rwmfj85xj34mb3x5dj3jcv5ij5j72yh";
+    sha256 = "1m5ai9h1zbp79x0vb138fmyh2hg8lqp859s7j33lra9hds6wb40a";
   };
 
   # Upstream setup.py has test dependencies in `install_requires` argument.

pkgs/development/tools/build-managers/rebar3/default.nix

···
-{ lib, stdenv, fetchFromGitHub, fetchpatch,
+{ lib, stdenv, fetchFromGitHub, fetchgit,
   fetchHex, erlang, makeWrapper,
   writeScript, common-updater-scripts, coreutils, git, gnused, nix, rebar3-nix }:
 
 let
-  version = "3.16.1";
+  version = "3.17.0";
   owner = "erlang";
-  deps = import ./rebar-deps.nix { inherit fetchFromGitHub fetchHex; };
+  deps = import ./rebar-deps.nix { inherit fetchFromGitHub fetchgit fetchHex; };
   rebar3 = stdenv.mkDerivation rec {
     pname = "rebar3";
     inherit version erlang;
···
       inherit owner;
       repo = pname;
       rev = version;
-      sha256 = "0dhwlx7zykf9y3znk2k8fxrq5j43jy3c3gd76k74q34p1xbajgzr";
+      sha256 = "02sk3whrbprzlih4pgcsd6ngmassfjfmkz21gwvb7mq64pib40k6";
     };
 
     buildInputs = [ erlang ];
···
       HOME=. escript bootstrap
     '';
 
-
-    patches = [
-      # TODO: remove this on next rebar3 release
-      (fetchpatch {
-        name = "escriptize-erl-libs";
-        url = "https://github.com/erlang/rebar3/commit/11055384dbd5bf7d181bca83a33b0e100275ff21.patch";
-        sha256 = "01xjaqnhmjlxqdgb8ph15wssjq5crdhjslxnndbs5f0kscqpq14c";
-      })
-    ];
-
     checkPhase = ''
       HOME=. escript ./rebar3 ct
     '';
···
         update-source-version rebar3 "$latest" --version-key=version --print-changes --file="$nix_path/default.nix"
         tmpdir=$(mktemp -d)
         cp -R $(nix-build $nixpkgs --no-out-link -A rebar3.src)/* "$tmpdir"
-        (cd "$tmpdir" && rebar3 nix lock -o "$nix_path/rebar-deps.nix")
+        (cd "$tmpdir" && rebar3 as test nix lock -o "$nix_path/rebar-deps.nix")
       else
         echo "rebar3 is already up-to-date"
       fi

pkgs/development/tools/build-managers/rebar3/rebar-deps.nix

···
 # Generated by rebar3_nix
 let fetchOnly = { src, ... }: src;
-in { builder ? fetchOnly, fetchHex, fetchFromGitHub, overrides ? (x: y: { }) }:
+in { builder ? fetchOnly, fetchHex, fetchgit, fetchFromGitHub, overrides ? (x: y: { }) }:
 let
   self = packages // (overrides self packages);
   packages = with self; {
···
     };
     relx = builder {
       name = "relx";
-      version = "4.4.0";
+      version = "4.5.0";
       src = fetchHex {
         pkg = "relx";
-        version = "4.4.0";
-        sha256 = "sha256-VcDtY7tdVeuYOhnrlNfzB1320Sbb3/QxAqZmCpH86SU=";
+        version = "4.5.0";
+        sha256 = "sha256-3bWPIMzmymP1onJeklgW3XITR2aYo/PDy0+ownIgLFI=";
       };
       beamDeps = [ bbmustache ];
     };

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

···
 , rustPlatform
 , perl
 , pkg-config
+, SystemConfiguration
 , Security
 , curl
 , libiconv
 , openssl
+, git
 }:
 
 rustPlatform.buildRustPackage rec {
   pname = "cargo-crev";
-  version = "0.19.4";
+  version = "0.20.1";
 
   src = fetchFromGitHub {
     owner = "crev-dev";
     repo = "cargo-crev";
-    rev = "v${version}";
-    sha256 = "sha256-XwwzMo06TdyOtGE9Z48mkEr6DnB/89wtMrW+UWr0G/Q=";
+    rev = version;
+    sha256 = "sha256-j2dafXUI6rDEYboSAciMeNma/YaBYKuQZgMUGVU+oBQ=";
   };
 
-  cargoSha256 = "sha256-gA2Fg4CCi0W+GqJoNPZWw/OjNYh2U2UsC6eMZ9W1QN8=";
+  cargoSha256 = "sha256-khrpS6QFpweKbTbR0YhAJTTrgDoZl9fzYPDs+JE1mtA=";
+
+  preCheck = ''
+    export HOME=$(mktemp -d)
+    git config --global user.name "Nixpkgs Test"
+    git config --global user.email "[e-mail]"
+  '';
 
   nativeBuildInputs = [ perl pkg-config ];
 
-  buildInputs = [ openssl ] ++ lib.optionals stdenv.isDarwin [ Security libiconv curl ];
+  buildInputs = [ openssl ] ++ lib.optionals stdenv.isDarwin [ SystemConfiguration Security libiconv curl ];
+
+  checkInputs = [ git ];
 
   meta = with lib; {
     description = "A cryptographically verifiable code review system for the cargo (Rust) package manager";

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

···
       --replace "/lib/modules" "${kernel.dev}/lib/modules"
   '';
 
+  makeFlags = kernel.makeFlags;
+
   installPhase = ''
     mkdir -p $out/lib/modules/${kernel.modDirVersion}/misc
     cp bbswitch.ko $out/lib/modules/${kernel.modDirVersion}/misc

pkgs/tools/nix/nix-query-tree-viewer/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "nix-query-tree-viewer";
-  version = "0.2.0";
+  version = "0.2.1";
 
   src = fetchFromGitHub {
     owner = "cdepillabout";
-    repo  = "nix-query-tree-viewer";
+    repo  = pname;
     rev = "v${version}";
-    sha256 = "0vjcllhgq64n7mwxvyhmbqd6fpa9lwrpsnggc1kdlgd14ggq6jj6";
+    sha256 = "sha256-Lc9hfjybnRrkd7PZMa2ojxOM04bP4GJyagkZUX2nVwY=";
   };
 
   nativeBuildInputs = [
···
     gtk3
   ];
 
-  cargoSha256 = "1i9sjs77v1c3lch93pzjgr1zl0k1mlwkdpf3zfp13hyjn6zpldnj";
+  cargoSha256 = "sha256-NSLBIvgo5EdCvZq52d+UbAa7K4uOST++2zbhO9DW38E=";
 
   meta = with lib; {
     description = "GTK viewer for the output of `nix store --query --tree`";

pkgs/tools/security/exploitdb/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "exploitdb";
-  version = "2021-09-08";
+  version = "2021-09-10";
 
   src = fetchFromGitHub {
     owner = "offensive-security";
     repo = pname;
     rev = version;
-    sha256 = "sha256-q6XALX0sGzgUm2PRwlDfcQHZFH+8ExageMahXJ+EYdM=";
+    sha256 = "sha256-OU9IchkouABYw0k4O4WBLu1aklLCH/S90IPMPLOZWY0=";
   };
 
   installPhase = ''

pkgs/tools/security/gitleaks/default.nix

···
 
 buildGoModule rec {
   pname = "gitleaks";
-  version = "7.6.0";
+  version = "7.6.1";
 
   src = fetchFromGitHub {
     owner = "zricethezav";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-XRpbbtQiF9EnGMICjyXXm2XjuR0jGC7UiY+UHIAMODM=";
+    sha256 = "sha256-52Wi3bQvKdHoJ1nVb4OVJ9wd8hDVF+6zlVSpsEai0Jw=";
   };
 
   vendorSha256 = "sha256-86PspExE+T/IuCvpf6LAkWcCRlHPqP5VUbHAckEzALc=";

pkgs/tools/security/sn0int/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "sn0int";
-  version = "0.21.2";
+  version = "0.22.0";
 
   src = fetchFromGitHub {
     owner = "kpcyrd";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-BKdi/o/A0fJBlcKTDTCX7uGkK6QR0S9hIn0DI3CN5Gg=";
+    sha256 = "sha256-0BadgWZhP73WOVO18jtcdhsM0L7AM0TQ3PF7MNJM7M0=";
   };
 
-  cargoSha256 = "sha256-MeMTXwb5v4iUJQSViOraXAck7n6VlIW2Qa0qNUZWu1g=";
+  cargoSha256 = "sha256-KYrJIOaFX2wTDj4KeHn3d8wBHfVevCKQK/bDglfLWAU=";
 
   nativeBuildInputs = [
     pkg-config

pkgs/top-level/all-packages.nix

···
 
   sqliteman = callPackage ../applications/misc/sqliteman { };
 
+  sqls = callPackage ../applications/misc/sqls { };
+
   stdman = callPackage ../data/documentation/stdman { };
 
   steck = callPackage ../servers/pinnwand/steck.nix { };
···
     buildPackages = buildPackages // { stdenv = buildPackages.gcc8Stdenv; };
   });
 
+  go_1_17 = callPackage ../development/compilers/go/1.17.nix ({
+    inherit (darwin.apple_sdk.frameworks) Security Foundation;
+  } // lib.optionalAttrs (stdenv.cc.isGNU && stdenv.isAarch64) {
+    stdenv = gcc8Stdenv;
+    buildPackages = buildPackages // { stdenv = buildPackages.gcc8Stdenv; };
+  });
+
   go_2-dev = callPackage ../development/compilers/go/2-dev.nix ({
     inherit (darwin.apple_sdk.frameworks) Security Foundation;
   } // lib.optionalAttrs (stdenv.cc.isGNU && stdenv.isAarch64) {
···
     inherit (darwin.apple_sdk.frameworks) Security;
   };
   cargo-crev = callPackage ../development/tools/rust/cargo-crev {
-    inherit (darwin.apple_sdk.frameworks) Security;
+    inherit (darwin.apple_sdk.frameworks) Security SystemConfiguration;
   };
   cargo-cross = callPackage ../development/tools/rust/cargo-cross { };
   cargo-deny = callPackage ../development/tools/rust/cargo-deny {
···
 
   gvfs = callPackage ../development/libraries/gvfs { };
 
+  gvm-libs = callPackage ../development/libraries/gvm-libs { };
+
   gwenhywfar = callPackage ../development/libraries/aqbanking/gwenhywfar.nix { };
 
   hamlib = hamlib_3;
···
   buildGo116Package = callPackage ../development/go-packages/generic {
     go = buildPackages.go_1_16;
   };
+  # go_1_17 has go module changes which may not be portable
+  # across different go versions and/or platforms,
+  # it also requires >=10.13 stdenv on darwin which
+  # is not currently available for x86_64-darwin
+  #
+  # do not uncomment this without approval from the go CODEOWNERS
+  #buildGo117Package = callPackage ../development/go-packages/generic {
+  #  go = buildPackages.go_1_17;
+  #};
 
   buildGoPackage = buildGo116Package;
 
···
   buildGo116Module = callPackage ../development/go-modules/generic {
     go = buildPackages.go_1_16;
   };
+  # go_1_17 has go module changes which may not be portable
+  # across different go versions and/or platforms,
+  # it also requires >=10.13 stdenv on darwin which
+  # is not currently available for x86_64-darwin
+  #
+  # do not uncomment this without approval from the go CODEOWNERS
+  #buildGo117Module = callPackage ../development/go-modules/generic {
+  #  go = buildPackages.go_1_17;
+  #};
 
   buildGoModule = buildGo116Module;
 
···
 
   dfilemanager = libsForQt5.callPackage ../applications/misc/dfilemanager { };
 
+  dht = callPackage ../applications/networking/p2p/dht { };
+
   dia = callPackage ../applications/graphics/dia {
     inherit (gnome2) libart_lgpl libgnomeui;
   };
···
   foxtrotgps = callPackage ../applications/misc/foxtrotgps { };
 
   fractal = callPackage ../applications/networking/instant-messengers/fractal { };
+
+  fragments = callPackage ../applications/networking/p2p/fragments { };
 
   freecad = libsForQt5.callPackage ../applications/graphics/freecad {
     inherit (python3Packages)
···
   libreoffice-still-unwrapped = libreoffice-still.libreoffice;
 
   libvmi = callPackage ../development/libraries/libvmi { };
+
+  libutp = callPackage ../applications/networking/p2p/libutp { };
 
   lifelines = callPackage ../applications/misc/lifelines { };
 

pkgs/top-level/release-haskell.nix

···
       language-nix = all;
       nix-paths = all;
       titlecase = all;
+      ghc-api-compat = all;
     })
     {
       mergeable = pkgs.releaseTools.aggregate {