Merge staging-next into staging

maintainers/maintainer-list.nix

···
     githubId = 13485450;
     name = "Emmanuel Rosa";
   };
+  emptyflask = {
+    email = "[e-mail]";
+    github = "emptyflask";
+    githubId = 28287;
+    name = "Jon Roberts";
+  };
   endgame = {
     email = "[e-mail]";
     github = "endgame";
···
     github = "ilikeavocadoes";
     githubId = 36193715;
     name = "Lassi Haasio";
+  };
+  ilkecan = {
+    email = "[e-mail]";
+    github = "ilkecan";
+    githubId = 40234257;
+    name = "ilkecan bozdogan";
   };
   illegalprime = {
     email = "[e-mail]";

maintainers/scripts/haskell/hydra-report.hs

···
             <> Text.pack (formatTime defaultTimeLocale "%Y-%m-%d %H:%M UTC" fetchTime)
             <> "*"
          ]
-      brokenLine (name, rdeps) = "[" <> name <> "](https://search.nixos.org/packages?channel=unstable&show=haskellPackages." <> name <> "&query=haskellPackages." <> name <> ") :arrow_heading_up: " <> Text.pack (show rdeps)
+      brokenLine (name, rdeps) = "[" <> name <> "](https://packdeps.haskellers.com/reverse/" <> name <> ") :arrow_heading_up: " <> Text.pack (show rdeps) <> "  "
       numSummary = statusToNumSummary summary
       jobsByState predicate = Map.filter (predicate . worstState) summary
       worstState = foldl' min Success . fmap state . summaryBuilds
···
          if' (isNothing mergeableJob) "No `mergeable` job found." <>
          if' (isNothing maintainedJob) "No `maintained` job found." <>
          if' (Unfinished > maybe Success worstState mergeableJob) "`mergeable` jobset failed." <>
-         if' (outstandingJobs (Platform "x86_64-linux") > 100) "Too much outstanding jobs on x86_64-linux." <>
-         if' (outstandingJobs (Platform "aarch64-linux") > 100) "Too much outstanding jobs on aarch64-linux."
+         if' (outstandingJobs (Platform "x86_64-linux") > 100) "Too many outstanding jobs on x86_64-linux." <>
+         if' (outstandingJobs (Platform "aarch64-linux") > 100) "Too many outstanding jobs on aarch64-linux."
       if' p e = if p then [e] else mempty
       outstandingJobs platform | Table m <- numSummary = Map.findWithDefault 0 (platform, Unfinished) m
       maintainedJob = Map.lookup "maintained" summary

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

···
 echo "Merging https://github.com/NixOS/nixpkgs/pull/${curr_haskell_updates_pr_num}..."
 gh pr merge --repo NixOS/nixpkgs --merge "$curr_haskell_updates_pr_num"
 
+# Update the list of Haskell package versions in NixOS on Hackage.
+echo "Updating list of Haskell package versions in NixOS on Hackage..."
+./maintainers/scripts/haskell/upload-nixos-package-list-to-hackage.sh
+
 # Update stackage, Hackage hashes, and regenerate Haskell package set
 echo "Updating Stackage..."
 ./maintainers/scripts/haskell/update-stackage.sh --do-commit
···
 ./maintainers/scripts/haskell/regenerate-hackage-packages.sh --do-commit
 
 # Push these new commits to the haskell-updates branch
-echo "Pushing commits just created to the haskell-updates branch"
+echo "Pushing commits just created to the remote haskell-updates branch..."
 git push
 
 # Open new PR
···
 
 This PR is the regular merge of the \`haskell-updates\` branch into \`master\`.
 
-This branch is being continually built and tested by hydra at https://hydra.nixos.org/jobset/nixpkgs/haskell-updates.
+This branch is being continually built and tested by hydra at https://hydra.nixos.org/jobset/nixpkgs/haskell-updates. You may be able to find an up-to-date Hydra build report at [cdepillabout/nix-haskell-updates-status](https://github.com/cdepillabout/nix-haskell-updates-status).
 
 We roughly aim to merge these \`haskell-updates\` PRs at least once every two weeks. See the @NixOS/haskell [team calendar](https://cloud.maralorn.de/apps/calendar/p/Mw5WLnzsP7fC4Zky) for who is currently in charge of this branch.
 
···
 EOF
 )
 
-echo "Opening a PR for the next haskell-updates merge cycle"
+echo "Opening a PR for the next haskell-updates merge cycle..."
 gh pr create --repo NixOS/nixpkgs --base master --head haskell-updates --title "haskellPackages: update stackage and hackage" --body "$new_pr_body"

maintainers/scripts/haskell/upload-nixos-package-list-to-hackage.sh

···
 username=$(grep "^username:" ~/.cabal/config | sed "s/^username: //")
 password_command=$(grep "^password-command:" ~/.cabal/config | sed "s/^password-command: //")
 curl -u "$username:$($password_command | head -n1)" --digest -H "Content-type: text/csv" -T "$package_list" http://hackage.haskell.org/distro/NixOS/packages.csv
+echo

nixos/modules/tasks/network-interfaces.nix

···
         source = "${pkgs.iputils.out}/bin/ping";
       };
     } else {
-      setuid = true;
-      owner = "root";
-      group = "root";
-      source = "${pkgs.iputils.out}/bin/ping";
+      ping = {
+        setuid = true;
+        owner = "root";
+        group = "root";
+        source = "${pkgs.iputils.out}/bin/ping";
+      };
     };
     security.apparmor.policies."bin.ping".profile = lib.mkIf config.security.apparmor.policies."bin.ping".enable (lib.mkAfter ''
       /run/wrappers/bin/ping {

pkgs/applications/misc/zola/default.nix

···
-{ lib, stdenv, fetchFromGitHub, rustPlatform, cmake, pkg-config, openssl, oniguruma, CoreServices, installShellFiles }:
+{ lib
+, stdenv
+, fetchFromGitHub
+, rustPlatform
+, cmake
+, pkg-config
+, openssl
+, oniguruma
+, CoreServices
+, installShellFiles
+, libsass
+}:
 
 rustPlatform.buildRustPackage rec {
   pname = "zola";
···
 
   cargoSha256 = "1hg8j9a8c6c3ap24jd96y07rlp4f0s2mkyx5034nlnkm3lj4q42n";
 
-  nativeBuildInputs = [ cmake pkg-config installShellFiles];
-  buildInputs = [ openssl oniguruma ]
-    ++ lib.optional stdenv.isDarwin CoreServices;
+  nativeBuildInputs = [
+    cmake
+    pkg-config
+    installShellFiles
+  ];
+  buildInputs = [
+    openssl
+    oniguruma
+    libsass
+  ] ++ lib.optionals stdenv.isDarwin [
+    CoreServices
+  ];
 
   RUSTONIG_SYSTEM_LIBONIG = true;
 

pkgs/applications/networking/instant-messengers/rambox/default.nix

···
 { stdenv, callPackage, fetchurl, lib }:
 
 let
-  mkRambox = opts: callPackage (import ./rambox.nix opts) { };
-in mkRambox rec {
+  mkRambox = opts: callPackage (import ./rambox.nix opts) {};
+in
+mkRambox rec {
   pname = "rambox";
-  version = "0.7.8";
+  version = "0.7.9";
 
   src = {
     x86_64-linux = fetchurl {
       url = "https://github.com/ramboxapp/community-edition/releases/download/${version}/Rambox-${version}-linux-x86_64.AppImage";
-      sha256 = "1y3c9xh8594ay95rj9vaqxxzibwpc38n7ixxi2wnsrdbrqrwlc63";
+      sha256 = "19y4cmrfp79dr4hgl698imp4f3l1nhgvhh76j5laxg46ld71knil";
     };
     i686-linux = fetchurl {
       url = "https://github.com/ramboxapp/community-edition/releases/download/${version}/Rambox-${version}-linux-i386.AppImage";
-      sha256 = "07sv384nd2i701fkjgsrlib8jfsa01bvj60gnqdwlnpphlknga3h";
+      sha256 = "13wiciyshyrabq2mvnssl2d6svia1kdvwx3dl26249iyif96xxvq";
     };
   }.${stdenv.system} or (throw "Unsupported system: ${stdenv.system}");
 
···
     description = "Free and Open Source messaging and emailing app that combines common web applications into one";
     homepage = "https://rambox.pro";
     license = licenses.mit;
-    maintainers = with maintainers; [ ];
-    platforms = ["i686-linux" "x86_64-linux"];
+    maintainers = with maintainers; [];
+    platforms = [ "i686-linux" "x86_64-linux" ];
     hydraPlatforms = [];
   };
 }

pkgs/applications/science/logic/symbiyosys/default.nix

···
 
 stdenv.mkDerivation {
   pname = "symbiyosys";
-  version = "2020.08.22";
+  version = "2021.09.13";
 
   src = fetchFromGitHub {
     owner  = "YosysHQ";
     repo   = "SymbiYosys";
-    rev    = "33b0bb7d836fe2a73dc7b10587222f2a718beef4";
-    sha256 = "03rbrbwsji1sqcp2yhgbc0fca04zsryv2g4izjhdzv64nqjzjyhn";
+    rev    = "15278f13467bea24a7300e23ebc5555b9261facf";
+    sha256 = "sha256-gp9F4MaGgD6XfD7AjuB/LmMVcxFurqWHEiXPeyzlQzk=";
   };
 
   buildInputs = [ ];

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

···
+{ lib, fetchFromGitHub
+, libiconv
+, openssl
+, pkg-config
+, rustPlatform
+, stdenv
+, Security
+, SystemConfiguration
+}:
+
+rustPlatform.buildRustPackage rec {
+  pname = "git-quickfix";
+  version = "0.0.4";
+
+  src = fetchFromGitHub {
+    owner = "siedentop";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "sha256-JdRlrNzWMPS3yG1UvKKtHVRix3buSm9jfSoAUxP35BY=";
+  };
+
+  nativeBuildInputs = [ pkg-config ];
+  buildInputs = [ openssl ] ++ lib.optionals stdenv.isDarwin [
+    Security
+    SystemConfiguration
+    libiconv
+  ];
+
+  cargoSha256 = "sha256-ENeHPhEBniR9L3J5el6QZrIS1Q4O0pNiSzJqP1aQS9Q=";
+
+  meta = with lib; {
+    description = "Quickfix allows you to commit changes in your git repository to a new branch without leaving the current branch";
+    homepage = "https://github.com/siedentop/git-quickfix";
+    license = licenses.gpl3;
+    platforms = platforms.all;
+    maintainers = with maintainers; [ msfjarvis ];
+  };
+}

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "6b93e40198f31ac2a9d52e4f3ce90f22f1e9e6f9",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/6b93e40198f31ac2a9d52e4f3ce90f22f1e9e6f9.tar.gz",
-  "sha256": "1zs9d0h55q6lj3v0d0n19yxl58lhn07lmnw2j5k2y8zbx3pcqi8l",
-  "msg": "Update from Hackage at 2021-09-17T18:08:40Z"
+  "commit": "e0bd041989865809059f6039125dfb93cb075f72",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/e0bd041989865809059f6039125dfb93cb075f72.tar.gz",
+  "sha256": "1fpm2kawxlias5xxmiara6224akgii0mnwnlyklc8szflv9cbs17",
+  "msg": "Update from Hackage at 2021-09-19T21:23:33Z"
 }

pkgs/desktops/lxqt/lxqt-config/default.nix

···
 , fetchFromGitHub
 , cmake
 , pkg-config
+, glib
 , lxqt-build-tools
 , qtbase
 , qtx11extras
···
   ];
 
   buildInputs = [
+    glib.bin
     qtbase
     qtx11extras
     qttools
···
     xorg.xf86inputlibinput
     xorg.xf86inputlibinput.dev
   ];
+
+  postPatch = ''
+    substituteInPlace lxqt-config-appearance/configothertoolkits.cpp \
+      --replace 'QStringLiteral("gsettings' \
+                'QStringLiteral("${glib.bin}/bin/gsettings'
+  '';
 
   passthru.updateScript = lxqtUpdateScript { inherit pname version src; };
 

pkgs/development/compilers/ghc/8.10.2-binary.nix

···
     # nixpkgs uses for the respective system.
     defaultLibc = {
       i686-linux = {
+        variantSuffix = "";
         src = {
           url = "${downloadsUrl}/${version}/ghc-${version}-i386-deb9-linux.tar.xz";
           sha256 = "0bvwisl4w0z5z8z0da10m9sv0mhm9na2qm43qxr8zl23mn32mblx";
         };
         exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2";
         archSpecificLibraries = [
+          { nixPackage = gmp; fileToCheckFor = null; }
           # The i686-linux bindist provided by GHC HQ is currently built on Debian 9,
           # which link it against `libtinfo.so.5` (ncurses 5).
           # Other bindists are linked `libtinfo.so.6` (ncurses 6).
···
         ];
       };
       x86_64-linux = {
+        variantSuffix = "";
         src = {
           url = "${downloadsUrl}/${version}/ghc-${version}-x86_64-deb10-linux.tar.xz";
           sha256 = "0chnzy9j23b2wa8clx5arwz8wnjfxyjmz9qkj548z14cqf13slcl";
         };
         exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2";
         archSpecificLibraries = [
+          { nixPackage = gmp; fileToCheckFor = null; }
           { nixPackage = ncurses6; fileToCheckFor = "libtinfo.so.6"; }
         ];
       };
       armv7l-linux = {
+        variantSuffix = "";
         src = {
           url = "${downloadsUrl}/${version}/ghc-${version}-armv7-deb10-linux.tar.xz";
           sha256 = "1j41cq5d3rmlgz7hzw8f908fs79gc5mn3q5wz277lk8zdf19g75v";
         };
         exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2";
         archSpecificLibraries = [
+          { nixPackage = gmp; fileToCheckFor = null; }
           { nixPackage = ncurses6; fileToCheckFor = "libtinfo.so.6"; }
         ];
       };
       aarch64-linux = {
+        variantSuffix = "";
         src = {
           url = "${downloadsUrl}/${version}/ghc-${version}-aarch64-deb10-linux.tar.xz";
           sha256 = "14smwl3741ixnbgi0l51a7kh7xjkiannfqx15b72svky0y4l3wjw";
         };
         exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2";
         archSpecificLibraries = [
+          { nixPackage = gmp; fileToCheckFor = null; }
           { nixPackage = ncurses6; fileToCheckFor = "libtinfo.so.6"; }
           { nixPackage = numactl; fileToCheckFor = null; }
         ];
       };
       x86_64-darwin = {
+        variantSuffix = "";
         src = {
           url = "${downloadsUrl}/${version}/ghc-${version}-x86_64-apple-darwin.tar.xz";
           sha256 = "1hngyq14l4f950hzhh2d204ca2gfc98pc9xdasxihzqd1jq75dzd";
         };
         exePathForLibraryCheck = null; # we don't have a library check for darwin yet
         archSpecificLibraries = [
+          { nixPackage = gmp; fileToCheckFor = null; }
           { nixPackage = ncurses6; fileToCheckFor = null; }
           { nixPackage = libiconv; fileToCheckFor = null; }
         ];
···
     # Binary distributions for the musl libc for the respective system.
     musl = {
       x86_64-linux = {
+        variantSuffix = "-musl";
         src = {
           url = "${downloadsUrl}/${version}/ghc-${version}-x86_64-alpine3.10-linux-integer-simple.tar.xz";
           sha256 = "0xpcbyaxqyhbl6f0i3s4rp2jm67nqpkfh2qlbj3i2fiaix89ml0l";
         };
         exePathForLibraryCheck = "bin/ghc";
         archSpecificLibraries = [
+          { nixPackage = gmp; fileToCheckFor = null; }
           # In contrast to glibc builds, the musl-bindist uses `libncursesw.so.*`
           # instead of `libtinfo.so.*.`
           { nixPackage = ncurses6; fileToCheckFor = "libncursesw.so.6"; }
···
 
   libPath =
     lib.makeLibraryPath (
-      [
-        gmp
-      ]
       # Add arch-specific libraries.
-      ++ map ({ nixPackage, ... }: nixPackage) binDistUsed.archSpecificLibraries
+      map ({ nixPackage, ... }: nixPackage) binDistUsed.archSpecificLibraries
     );
 
   libEnvVar = lib.optionalString stdenv.hostPlatform.isDarwin "DY"
···
 
 stdenv.mkDerivation rec {
   inherit version;
-
-  name = "ghc-${version}-binary";
+  pname = "ghc-binary${binDistUsed.variantSuffix}";
 
   src = fetchurl binDistUsed.src;
+
+  # Note that for GHC 8.10 versions <= 8.10.5, the GHC HQ musl bindist
+  # has a `gmp` dependency:
+  # https://gitlab.haskell.org/ghc/ghc/-/commit/8306501020cd66f683ad9c215fa8e16c2d62357d
+  # Related nixpkgs issues:
+  # * https://github.com/NixOS/nixpkgs/pull/130441#issuecomment-922452843
 
   nativeBuildInputs = [ perl ];
   propagatedBuildInputs =
···
     # libgmp is (see not [musl bindists have no .buildinfo]), we need
     # to propagate `gmp`, otherwise programs built by this ghc will
     # fail linking with `cannot find -lgmp` errors.
+    # Concrete cases are listed in:
+    #     https://github.com/NixOS/nixpkgs/pull/130441#issuecomment-922459988
+    #
     # Also, as of writing, the release pages of musl bindists claim
     # that they use `integer-simple` and do not require `gmp`; however
     # that is incorrect, so `gmp` is required until a release has been
···
     # (Note that for packaging the `-binary` compiler, nixpkgs does not care
     # about whether or not `gmp` is used; this comment is just here to explain
     # why the `gmp` dependency exists despite what the release page says.)
+    #
+    # For GHC >= 8.10.6, `gmp` was switched out for `integer-simple`
+    # (https://gitlab.haskell.org/ghc/ghc/-/commit/8306501020cd66f683ad9c215fa8e16c2d62357d),
+    # fixing the above-mentioned release issue,
+    # and for GHC >= 9.* it is not clear as of writing whether that switch
+    # will be made there too.
     ++ lib.optionals stdenv.hostPlatform.isMusl [ gmp ]; # musl bindist needs this
 
   # Set LD_LIBRARY_PATH or equivalent so that the programs running as part

pkgs/development/compilers/ghc/8.10.7-binary.nix

···
     # nixpkgs uses for the respective system.
     defaultLibc = {
       i686-linux = {
+        variantSuffix = "";
         src = {
           url = "${downloadsUrl}/${version}/ghc-${version}-i386-deb9-linux.tar.xz";
           sha256 = "fbfc1ef194f4e7a4c0da8c11cc69b17458a4b928b609b3622c97acc4acd5c5ab";
         };
         exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2";
         archSpecificLibraries = [
+          { nixPackage = gmp; fileToCheckFor = null; }
           # The i686-linux bindist provided by GHC HQ is currently built on Debian 9,
           # which link it against `libtinfo.so.5` (ncurses 5).
           # Other bindists are linked `libtinfo.so.6` (ncurses 6).
···
         ];
       };
       x86_64-linux = {
+        variantSuffix = "";
         src = {
           url = "${downloadsUrl}/${version}/ghc-${version}-x86_64-deb10-linux.tar.xz";
           sha256 = "a13719bca87a0d3ac0c7d4157a4e60887009a7f1a8dbe95c4759ec413e086d30";
         };
         exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2";
         archSpecificLibraries = [
+          { nixPackage = gmp; fileToCheckFor = null; }
           { nixPackage = ncurses6; fileToCheckFor = "libtinfo.so.6"; }
         ];
       };
       armv7l-linux = {
+        variantSuffix = "";
         src = {
           url = "${downloadsUrl}/${version}/ghc-${version}-armv7-deb10-linux.tar.xz";
           sha256 = "3949c31bdf7d3b4afb765ea8246bca4ca9707c5d988d9961a244f0da100956a2";
         };
         exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2";
         archSpecificLibraries = [
+          { nixPackage = gmp; fileToCheckFor = null; }
           { nixPackage = ncurses6; fileToCheckFor = "libtinfo.so.6"; }
         ];
       };
       aarch64-linux = {
+        variantSuffix = "";
         src = {
           url = "${downloadsUrl}/${version}/ghc-${version}-aarch64-deb10-linux.tar.xz";
           sha256 = "fad2417f9b295233bf8ade79c0e6140896359e87be46cb61cd1d35863d9d0e55";
         };
         exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2";
         archSpecificLibraries = [
+          { nixPackage = gmp; fileToCheckFor = null; }
           { nixPackage = ncurses6; fileToCheckFor = "libtinfo.so.6"; }
           { nixPackage = numactl; fileToCheckFor = null; }
         ];
       };
       x86_64-darwin = {
+        variantSuffix = "";
         src = {
           url = "${downloadsUrl}/${version}/ghc-${version}-x86_64-apple-darwin.tar.xz";
           sha256 = "287db0f9c338c9f53123bfa8731b0996803ee50f6ee847fe388092e5e5132047";
         };
         exePathForLibraryCheck = null; # we don't have a library check for darwin yet
         archSpecificLibraries = [
+          { nixPackage = gmp; fileToCheckFor = null; }
           { nixPackage = ncurses6; fileToCheckFor = null; }
           { nixPackage = libiconv; fileToCheckFor = null; }
         ];
       };
       aarch64-darwin = {
+        variantSuffix = "";
         src = {
           url = "${downloadsUrl}/${version}/ghc-${version}-aarch64-apple-darwin.tar.xz";
           sha256 = "dc469fc3c35fd2a33a5a575ffce87f13de7b98c2d349a41002e200a56d9bba1c";
         };
         exePathForLibraryCheck = null; # we don't have a library check for darwin yet
         archSpecificLibraries = [
+          { nixPackage = gmp; fileToCheckFor = null; }
           { nixPackage = ncurses6; fileToCheckFor = null; }
           { nixPackage = libiconv; fileToCheckFor = null; }
         ];
···
     # Binary distributions for the musl libc for the respective system.
     musl = {
       x86_64-linux = {
+        variantSuffix = "-musl-integer-simple";
         src = {
           url = "${downloadsUrl}/${version}/ghc-${version}-x86_64-alpine3.10-linux-integer-simple.tar.xz";
           sha256 = "16903df850ef73d5246f2ff169cbf57ecab76c2ac5acfa9928934282cfad575c";
         };
         exePathForLibraryCheck = "bin/ghc";
         archSpecificLibraries = [
+          # No `gmp` here, since this is an `integer-simple` bindist.
+
           # In contrast to glibc builds, the musl-bindist uses `libncursesw.so.*`
           # instead of `libtinfo.so.*.`
           { nixPackage = ncurses6; fileToCheckFor = "libncursesw.so.6"; }
···
 
   libPath =
     lib.makeLibraryPath (
-      [
-        gmp
-      ]
       # Add arch-specific libraries.
-      ++ map ({ nixPackage, ... }: nixPackage) binDistUsed.archSpecificLibraries
+      map ({ nixPackage, ... }: nixPackage) binDistUsed.archSpecificLibraries
     );
 
   libEnvVar = lib.optionalString stdenv.hostPlatform.isDarwin "DY"
···
 
 stdenv.mkDerivation rec {
   inherit version;
+  pname = "ghc-binary${binDistUsed.variantSuffix}";
 
-  name = "ghc-${version}-binary";
+  src = fetchurl binDistUsed.src;
 
-  src = fetchurl binDistUsed.src;
+  # Note that for GHC 8.10 versions >= 8.10.6, the GHC HQ musl bindist
+  # uses `integer-simple` and has no `gmp` dependency:
+  # https://gitlab.haskell.org/ghc/ghc/-/commit/8306501020cd66f683ad9c215fa8e16c2d62357d
+  # Related nixpkgs issues:
+  # * https://github.com/NixOS/nixpkgs/pull/130441#issuecomment-922452843
+  # TODO: When this file is copied to `ghc-9.*-binary.nix`, determine whether
+  #       the GHC 9 branch also switched from `gmp` to `integer-simple` via the
+  #       currently-open issue:
+  #           https://gitlab.haskell.org/ghc/ghc/-/issues/20059
+  #       and update this comment accordingly.
 
   nativeBuildInputs = [ perl ];
   propagatedBuildInputs =
     lib.optionals useLLVM [ llvmPackages.llvm ]
-    # Because musl bindists currently provide no way to tell where
-    # libgmp is (see not [musl bindists have no .buildinfo]), we need
-    # to propagate `gmp`, otherwise programs built by this ghc will
-    # fail linking with `cannot find -lgmp` errors.
-    # Also, as of writing, the release pages of musl bindists claim
-    # that they use `integer-simple` and do not require `gmp`; however
-    # that is incorrect, so `gmp` is required until a release has been
-    # made that includes https://gitlab.haskell.org/ghc/ghc/-/issues/20059.
-    # (Note that for packaging the `-binary` compiler, nixpkgs does not care
-    # about whether or not `gmp` is used; this comment is just here to explain
-    # why the `gmp` dependency exists despite what the release page says.)
-    ++ lib.optionals stdenv.hostPlatform.isMusl [ gmp ]; # musl bindist needs this
+    ;
 
   # Set LD_LIBRARY_PATH or equivalent so that the programs running as part
   # of the bindist installer can find the libraries they expect.
···
       patchShebangs ghc-${version}/configure
     '' +
     # We have to patch the GMP paths for the integer-gmp package.
-    # Note [musl bindists have no .buildinfo]
-    # Note that musl bindists do not contain them; unclear if that's intended;
+    # Note that musl bindists do not contain them,
     # see: https://gitlab.haskell.org/ghc/ghc/-/issues/20073#note_363231
+    # However, musl bindists >= 8.10.6 use `integer-simple`, not `gmp`.
     ''
       find . -name integer-gmp.buildinfo \
           -exec sed -i "s@extra-lib-dirs: @extra-lib-dirs: ${gmp.out}/lib@" {} \;

pkgs/development/compilers/ghc/8.10.7.nix

···
     targetPackages.stdenv.cc.bintools.bintools
   ];
 
+  # Makes debugging easier to see which variant is at play in `nix-store -q --tree`.
+  variantSuffix = lib.concatStrings [
+    (lib.optionalString stdenv.hostPlatform.isMusl "-musl")
+    (lib.optionalString enableIntegerSimple "-integer-simple")
+  ];
+
 in
 stdenv.mkDerivation (rec {
   version = "8.10.7";
-  name = "${targetPrefix}ghc-${version}";
+  pname = "${targetPrefix}ghc${variantSuffix}";
 
   src = fetchurl {
     url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz";
···
     ] ++ lib.teams.haskell.members;
     timeout = 24 * 3600;
     inherit (ghc.meta) license platforms;
-
-    # integer-simple builds are broken when GHC links against musl.
-    # See https://github.com/NixOS/nixpkgs/pull/129606#issuecomment-881323743.
-    broken = enableIntegerSimple && hostPlatform.isMusl;
   };
 
 } // lib.optionalAttrs targetPlatform.useAndroidPrebuilt {

pkgs/development/compilers/ghc/8.6.5-binary.nix

···
 
 stdenv.mkDerivation rec {
   version = "8.6.5";
-
-  name = "ghc-${version}-binary";
+  pname = "ghc-binary";
 
   # https://downloads.haskell.org/~ghc/8.6.5/
   src = fetchurl ({

pkgs/development/compilers/ghc/8.8.4.nix

···
     targetPackages.stdenv.cc.bintools.bintools
   ];
 
+  # Makes debugging easier to see which variant is at play in `nix-store -q --tree`.
+  variantSuffix = lib.concatStrings [
+    (lib.optionalString stdenv.hostPlatform.isMusl "-musl")
+    (lib.optionalString enableIntegerSimple "-integer-simple")
+  ];
+
 in
 stdenv.mkDerivation (rec {
   version = "8.8.4";
-  name = "${targetPrefix}ghc-${version}";
+  pname = "${targetPrefix}ghc${variantSuffix}";
 
   src = fetchurl {
     url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz";
···
     ] ++ lib.teams.haskell.members;
     timeout = 24 * 3600;
     inherit (ghc.meta) license platforms;
-
-    # integer-simple builds are broken when GHC links against musl.
-    # See https://github.com/NixOS/nixpkgs/pull/129606#issuecomment-881323743.
-    broken = enableIntegerSimple && hostPlatform.isMusl;
+    # integer-simple builds are broken with musl when bootstrapping using
+    # GHC 8.10.2 and below, however it is not possible to reverse bootstrap
+    # GHC 8.8.4 with GHC 8.10.7.
+    # See https://github.com/NixOS/nixpkgs/pull/138523#issuecomment-927339953
+    broken = hostPlatform.isMusl && enableIntegerSimple;
   };
 
   dontStrip = (targetPlatform.useAndroidPrebuilt || targetPlatform.isWasm);

pkgs/development/compilers/ghc/9.0.1.nix

···
     targetPackages.stdenv.cc.bintools.bintools
   ];
 
+  # Makes debugging easier to see which variant is at play in `nix-store -q --tree`.
+  variantSuffix = lib.concatStrings [
+    (lib.optionalString stdenv.hostPlatform.isMusl "-musl")
+    (lib.optionalString enableIntegerSimple "-integer-simple")
+  ];
+
 in
 stdenv.mkDerivation (rec {
   version = "9.0.1";
-  name = "${targetPrefix}ghc-${version}";
+  pname = "${targetPrefix}ghc${variantSuffix}";
 
   src = fetchurl {
     url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz";
···
     ] ++ lib.teams.haskell.members;
     timeout = 24 * 3600;
     inherit (ghc.meta) license platforms;
-
-    # integer-simple builds are broken when GHC links against musl.
-    # See https://github.com/NixOS/nixpkgs/pull/129606#issuecomment-881323743.
-    broken = enableIntegerSimple && hostPlatform.isMusl;
   };
 
 } // lib.optionalAttrs targetPlatform.useAndroidPrebuilt {

pkgs/development/compilers/ghc/9.2.1.nix

···
 
 # build-tools
 , bootPkgs
-, autoconf, automake, coreutils, fetchurl, perl, python3, m4, sphinx, xattr
+, autoconf, automake, coreutils, fetchurl, fetchpatch, perl, python3, m4, sphinx, xattr
 , bash
 
 , libiconv ? null, ncurses
···
     targetPackages.stdenv.cc.bintools.bintools
   ];
 
+  # Makes debugging easier to see which variant is at play in `nix-store -q --tree`.
+  variantSuffix = lib.concatStrings [
+    (lib.optionalString stdenv.hostPlatform.isMusl "-musl")
+    (lib.optionalString enableIntegerSimple "-integer-simple")
+  ];
+
 in
 stdenv.mkDerivation (rec {
   version = "9.2.0.20210821";
-  name = "${targetPrefix}ghc-${version}";
+  pname = "${targetPrefix}ghc${variantSuffix}";
 
   src = fetchurl {
     url = "https://downloads.haskell.org/ghc/9.2.1-rc1/ghc-${version}-src.tar.xz";
     sha256 = "1q2pppxv2avhykyxvyq72r5p97rkkiqp19b77yhp85ralbcp4ivw";
   };
+
+  patches = [
+    # picked from release branch, remove with the next release candidate,
+    # see https://gitlab.haskell.org/ghc/ghc/-/issues/19950#note_373726
+    (fetchpatch {
+      name = "fix-darwin-link-failure.patch";
+      url = "https://gitlab.haskell.org/ghc/ghc/-/commit/77456387025ca74299ecc70621cbdb62b1b6ffc9.patch";
+      sha256 = "1g8smrn7hj8cbp9fhrylvmrb15s0xd8lhdgxqnx0asnd4az82gj8";
+    })
+  ];
 
   enableParallelBuilding = true;
 
···
     ] ++ lib.teams.haskell.members;
     timeout = 24 * 3600;
     inherit (ghc.meta) license platforms;
-
-    # integer-simple builds are broken when GHC links against musl.
-    # See https://github.com/NixOS/nixpkgs/pull/129606#issuecomment-881323743.
-    # Linker failure on macOS:
-    # https://gitlab.haskell.org/ghc/ghc/-/issues/19950#note_373726
-    broken = (enableIntegerSimple && hostPlatform.isMusl)
-      || stdenv.hostPlatform.isDarwin;
-    hydraPlatforms = lib.remove "x86_64-darwin" ghc.meta.platforms;
   };
 
 } // lib.optionalAttrs targetPlatform.useAndroidPrebuilt {

pkgs/development/compilers/ghc/head.nix

···
     targetPackages.stdenv.cc.bintools.bintools
   ];
 
+  # Makes debugging easier to see which variant is at play in `nix-store -q --tree`.
+  variantSuffix = lib.concatStrings [
+    (lib.optionalString stdenv.hostPlatform.isMusl "-musl")
+    (lib.optionalString enableNativeBignum "-native-bignum")
+  ];
+
 in
 stdenv.mkDerivation (rec {
   inherit version;
   inherit (src) rev;
-  name = "${targetPrefix}ghc-${version}";
+  pname = "${targetPrefix}ghc${variantSuffix}";
 
   src = fetchgit {
     url = "https://gitlab.haskell.org/ghc/ghc.git/";

pkgs/development/compilers/nextpnr/default.nix

···
 in
 stdenv.mkDerivation rec {
   pname = "nextpnr";
-  version = "2021.08.16";
+  version = "2021.09.27";
 
   srcs = [
     (fetchFromGitHub {
       owner  = "YosysHQ";
       repo   = "nextpnr";
-      rev    = "b37d133c43c45862bd5c550b5d7fffaa8c49b968";
-      sha256 = "0qc9d8cay2j5ggn0mgjq484vv7a14na16s9dmp7bqz7r9cn4b98n";
+      rev    = "9d8d3bdbc48133ff7758c9c5293e5904bc6e5ba7";
+      sha256 = "sha256-5Axo8qX2+ATqQ170QqfhRwYfCRQLCKBW1kc89x9XljE=";
       name   = "nextpnr";
     })
     (fetchFromGitHub {
       owner  = "YosysHQ";
       repo   = "nextpnr-tests";
       rev    = "ccc61e5ec7cc04410462ec3196ad467354787afb";
-      sha256 = "09a0bhrphr3rsppryrfak4rhziyj8k3s17kgb0vgm0abjiz0jgam";
+      sha256 = "sha256-VT0JfpRLgfo2WG+eoMdE0scPM5nKZZ/v1XlkeDNcQCU=";
       name   = "nextpnr-tests";
     })
   ];
···
 
   patchPhase = with builtins; ''
     # use PyPy for icestorm if enabled
-    substituteInPlace ./ice40/family.cmake \
+    substituteInPlace ./ice40/CMakeLists.txt \
       --replace ''\'''${PYTHON_EXECUTABLE}' '${icestorm.pythonInterp}'
   '';
 

pkgs/development/compilers/yosys/default.nix

···
 
 stdenv.mkDerivation rec {
   pname   = "yosys";
-  version = "0.9+4276";
+  version = "0.10+1";
 
   src = fetchFromGitHub {
     owner  = "YosysHQ";
     repo   = "yosys";
-    rev    = "75a4cdfc8afc10fed80e43fb1ba31c7edaf6e361";
-    sha256 = "13xb7ny6i0kr6z6xkj9wmmcj551si7w05r3cghq8h8wkikyh6c8p";
+    rev    = "7a7df9a3b4996b17bb774377483b15de49aa3d9b";
+    sha256 = "sha256-gi/Q6loIQ75NTbS9b/Q8sdrl9NGBDae2+AAGHVYB0WI=";
   };
 
   enableParallelBuilding = true;

pkgs/development/haskell-modules/HACKING.md

···
     script uses the `gh` command to merge the current PR and open a new one.
     You should only need to do this once.
 
+    This command can be used to authenticate:
+
     ```console
     $ gh auth login
     ```
 
+    This command can be used to confirm that you have already authenticated:
+
+    ```console
+    $ gh auth status
+    ```
+
+1.  Make sure you have setup your `~/.cabal/config` file for authentication
+    for uploading the NixOS package versions to Hackage.  See the following
+    section for details on how to do this.
+
 1.  Make sure you have correctly marked packages broken.  One of the previous
     sections explains how to do this.
+
+    In short:
+
+    ```console
+    $ ./maintainers/scripts/haskell/hydra-report.hs get-report
+    $ ./maintainers/scripts/haskell/hydra-report.hs mark-broken-list
+    $ ./maintainers/scripts/haskell/mark-broken.sh --do-commit
+    ```
 
 1.  Merge `master` into `haskell-updates` and make sure to push to the
     `haskell-updates` branch.  (This can be skipped if `master` has recently
···
         `origin/haskell-updates`.
 
     1.  Merges the currently open `haskell-updates` PR.
+
+    1.  Updates the version of Haskell packages in NixOS on Hackage.
 
     1.  Updates Stackage and Hackage snapshots.  Regenerates the Haskell package set.
 

pkgs/development/haskell-modules/cabal2nix-unstable.nix

···
 }:
 mkDerivation {
   pname = "cabal2nix";
-  version = "unstable-2021-08-27";
+  version = "unstable-2021-09-28";
   src = fetchzip {
-    url = "https://github.com/NixOS/cabal2nix/archive/05b1b404e20eb6252f93c821d4d7974ab7277d90.tar.gz";
-    sha256 = "03zvp3wwqph9niadgbvkfcqabafgyhnw12r09cw23hm69hsb64d5";
+    url = "https://github.com/NixOS/cabal2nix/archive/b4d893ed1a7a66b0046dd8a48f62b81de670ab02.tar.gz";
+    sha256 = "0xl5a0gfxrqz8pkx43zrj84xvcg15723lgvirxdcvc4zqa732zjg";
   };
   isLibrary = true;
   isExecutable = true;

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

···
     '';
   });
 
+  d-bus = let
+    # The latest release on hackage is missing necessary patches for recent compilers
+    # https://github.com/Philonous/d-bus/issues/24
+    newer = overrideSrc super.d-bus {
+      version = "unstable-2021-01-08";
+      src = pkgs.fetchFromGitHub {
+        owner = "Philonous";
+        repo = "d-bus";
+        rev = "fb8a948a3b9d51db618454328dbe18fb1f313c70";
+        hash = "sha256-R7/+okb6t9DAkPVUV70QdYJW8vRcvBdz4zKJT13jb3A=";
+      };
+    };
+  # Add now required extension on recent compilers.
+  # https://github.com/Philonous/d-bus/pull/23
+  in appendPatch newer (pkgs.fetchpatch {
+    url = "https://github.com/Philonous/d-bus/commit/e5f37900a3a301c41d98bdaa134754894c705681.patch";
+    sha256 = "6rQ7H9t483sJe1x95yLPAZ0BKTaRjgqQvvrQv7HkJRE=";
+  });
+
   # * The standard libraries are compiled separately.
   # * We need multiple patches from master to fix compilation with
   #   updated dependencies (haskeline and megaparsec) which can be
···
 
   # https://github.com/haskell-hvr/cryptohash-sha256/issues/11
   # Jailbreak is necessary to break out of tasty < 1.x dependency.
-  cryptohash-sha256 = markUnbroken (doJailbreak super.cryptohash-sha256);
+  # hackage2nix generates this as a broken package due to the (fake) dependency
+  # missing from hackage, so we need to fix the meta attribute set.
+  cryptohash-sha256 = overrideCabal super.cryptohash-sha256 (drv: {
+    jailbreak = true;
+    broken = false;
+    hydraPlatforms = pkgs.lib.platforms.all;
+  });
 
   # The test suite has all kinds of out-dated dependencies, so it feels easier
   # to just disable it.
···
     sha256 = "097wqn8hxsr50b9mhndg5pjim5jma2ym4ylpibakmmb5m98n17zp";
   });
 
+  # Pick patch from 1.6.0 which allows compilation with doctest 0.18
+  polysemy = appendPatches super.polysemy [
+    (pkgs.fetchpatch {
+      name = "allow-doctest-0.18.patch";
+      url = "https://github.com/polysemy-research/polysemy/commit/dbcf851eb69395ce3143ecf2dd616dcad953a339.patch";
+      sha256 = "1qf5pghc8p1glwaadkr95x12d74vhb98mg8dqwilyxbc6gq763w2";
+    })
+  ];
+
   # polysemy-plugin 0.2.5.0 has constraint ghc-tcplugins-extra (==0.3.*)
   # This upstream issue is relevant:
   # https://github.com/polysemy-research/polysemy/issues/322
···
   gi-cairo-render = doJailbreak super.gi-cairo-render;
   gi-cairo-connector = doJailbreak super.gi-cairo-connector;
 
+  # Remove when https://github.com/gtk2hs/svgcairo/pull/10 gets merged.
+  svgcairo = appendPatch super.svgcairo (pkgs.fetchpatch {
+    url = "https://github.com/gtk2hs/svgcairo/commit/df6c6172b52ecbd32007529d86ba9913ba001306.patch";
+    sha256 = "128qrns56y139vfzg1rbyqfi2xn8gxsmpnxv3zqf4v5spsnprxwh";
+  });
+
   # Missing -Iinclude parameter to doc-tests (pull has been accepted, so should be resolved when 0.5.3 released)
   # https://github.com/lehins/massiv/pull/104
   massiv = dontCheck super.massiv;
···
   })) (drv: {
     patches = [ ./patches/graphql-engine-mapkeys.patch ];
     doHaddock = false;
-    version = "2.0.7";
+    version = "2.0.9";
   });
   hasura-ekg-core = super.hasura-ekg-core.overrideScope (self: super: {
     hspec = dontCheck self.hspec_2_8_3;
···
 
   # 2021-09-18: https://github.com/haskell/haskell-language-server/issues/2205
   hls-stylish-haskell-plugin = doJailbreak super.hls-stylish-haskell-plugin;
+
+  # 2021-09-29: unnecessary lower bound on generic-lens
+  hw-ip = assert pkgs.lib.versionOlder self.generic-lens.version "2.2.0.0";
+    doJailbreak super.hw-ip;
+  hw-eliasfano = assert pkgs.lib.versionOlder self.generic-lens.version "2.2.0.0";
+    doJailbreak super.hw-eliasfano;
+  hw-xml = assert pkgs.lib.versionOlder self.generic-lens.version "2.2.0.0";
+    doJailbreak super.hw-xml;
 
 } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

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

···
   dec = doJailbreak super.dec;
   ed25519 = doJailbreak super.ed25519;
   hackage-security = doJailbreak super.hackage-security;
-  hashable = overrideCabal (doJailbreak (dontCheck super.hashable)) (drv: { postPatch = "sed -i -e 's,integer-gmp .*<1.1,integer-gmp < 2,' hashable.cabal"; });
   hashable-time = doJailbreak super.hashable-time;
   HTTP = overrideCabal (doJailbreak super.HTTP) (drv: { postPatch = "sed -i -e 's,! Socket,!Socket,' Network/TCP.hs"; });
   integer-logarithms = overrideCabal (doJailbreak super.integer-logarithms) (drv: { postPatch = "sed -i -e 's,integer-gmp <1.1,integer-gmp < 2,' integer-logarithms.cabal"; });
···
   resolv = doJailbreak super.resolv;
   singleton-bool = doJailbreak super.singleton-bool;
   split = doJailbreak super.split;
+  splitmix = doJailbreak super.splitmix;
   tar = doJailbreak super.tar;
   time-compat = doJailbreak super.time-compat;
   vector = doJailbreak (dontCheck super.vector);
···
     sha256 = "0rgzrq0513nlc1vw7nw4km4bcwn4ivxcgi33jly4a7n3c1r32v1f";
   });
 
-  # The test suite depends on ChasingBottoms, which is broken with ghc-9.0.x.
+  # 1.3.0 (on stackage) defines instances for the Option-type, which has been removed from base in GHC 9.2.x
+  # Tests fail because random hasn't been updated for GHC 9.2.x
+  hashable = dontCheck super.hashable_1_3_3_0;
+
+  # Tests fail because random hasn't been updated for GHC 9.2.x
   unordered-containers = dontCheck super.unordered-containers;
 
   # The test suite seems pretty broken.

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

···
   - 3d-graphics-examples
   - 3dmodels
   - AAI
+  - abacate
   - abcnotation
   - abeson
   - abides
···
   - acme-hq9plus
   - acme-http
   - acme-inator
+  - acme-io
   - acme-kitchen-sink
   - acme-left-pad
   - acme-memorandom
···
   - aern2-mp
   - AERN-Basics
   - aeson-applicative
+  - aeson-bson
   - aeson-decode
   - aeson-diff-generic
   - aeson-filthy
···
   - affection
   - affine-invariant-ensemble-mcmc
   - Agata
+  - Agda-executable
   - agda-language-server
   - agda-snippets
   - agda-unused
···
   - align-text
   - ally-invest
   - alphachar
+  - alpino-tools
   - alsa
   - alsa-midi
   - altcomposition
   - alternative-extra
   - alternative-io
+  - altfloat
   - alto
   - alure
   - amazon-emailer
···
   - AttoBencode
   - atto-lisp
   - attomail
+  - attoparsec-csv
   - attoparsec-text
   - attoparsec-trans
   - attosplit
···
   - autonix-deps
   - autopack
   - avatar-generator
+  - aviation-cessna172-diagrams
   - avl-static
   - avr-shake
   - awesome-prelude
···
   - barchart
   - barcodes-code128
   - barecheck
+  - barley
   - barrie
   - barrier
   - barrier-monad
+  - base58address
   - base62
   - base64-conduit
   - base-compat-migrate
···
   - base-feature-macros
   - base-generics
   - base-io-access
+  - basen
   - basex-client
   - basic
   - basic-sop
···
   - bind-marshal
   - bindynamic
   - binembed
+  - binsm
   - bio
   - BiobaseNewick
   - biocore
···
   - blaze-json
   - blazeT
   - blaze-textual-native
+  - ble
   - bliplib
   - blockchain
   - blockhash
···
   - bottom
   - bounded-array
   - bound-extras
+  - box
   - braid
   - brain-bleep
   - Bravo
···
   - Cascade
   - cascading
   - caseof
+  - casr-logbook
+  - casr-logbook-types
   - Cassava
   - cassava-conduit
   - cassava-records
···
   - cautious-gen
   - cayene-lpp
   - cayley-client
+  - cblrepo
   - CCA
   - CC-delcont-cxe
   - CC-delcont-exc
···
   - composition-tree
   - comprehensions-ghc
   - compressed
+  - compression
   - compstrat
   - comptrans
   - computational-geometry
···
   - crc16
   - crdt-event-fold
   - creatur
+  - credentials
   - credential-store
   - critbit
   - criterion-compare
···
   - CurryDB
   - curryer-rpc
   - curry-frontend
+  - curryrs
   - curves
   - custom-prelude
   - CV
···
   - darcs-monitor
   - darkplaces-rcon
   - darkplaces-text
+  - data-accessor-monadLib
   - data-accessor-monads-tf
   - data-aviary
   - data-base
···
   - dbmigrations-mysql
   - dbmigrations-postgresql
   - dbmigrations-sqlite
-  - d-bus
   - DBus
   - dbus-core
   - dbus-qq
···
   - deepseq-magic
   - deepseq-th
   - deep-transformations
+  - definitive-base
   - deka
   - Delta-Lambda
   - delude
···
   - diffcabal
   - differential
   - DifferentialEvolution
+  - diff-gestalt
   - diffmap
   - difftodo
   - digestive-bootstrap
···
   - digits
   - DimensionalHash
   - dimensional-tf
-  - diohsc
   - diophantine
   - direct-binary-files
   - directed-cubical
···
   - dzen-dhall
   - dzen-utils
   - each
+  - eager-sockets
   - earclipper
   - early
   - easy-api
···
   - edit-lenses
   - editline
   - effect-handlers
+  - effective-aspects
   - effect-monad
   - effect-stack
   - effin
···
   - elision
   - elm-street
   - elm-websocket
+  - elocrypt
   - emacs-module
   - emailaddress
   - email-header
···
   - estimators
   - EstProgress
   - Etage
+  - etcd
   - eternal
   - ethereum-rlp
   - euphoria
···
   - fpco-api
   - FPretty
   - fptest
+  - fquery
   - Fractaler
   - fractals
   - fraction
···
   - GeocoderOpenCage
   - geodetics
   - geodetic-types
+  - GeoIp
   - geojson-types
   - geom2d
   - GeomPredicates-SSE
···
   - ghc-events-analyze
   - ghc-events-parallel
   - ghc-generic-instances
+  - ghc-hotswap
   - ghci-diagrams
   - ghci-haskeline
   - ghci-history-parser
···
   - ghc-tcplugin-api
   - ghc-time-alloc-prof
   - ghc-usage
+  - ghc-vis
   - gh-labeler
   - giak
   - Gifcurry
···
   - gochan
   - godot-haskell
   - gofer-prelude
+  - gogol-core
   - gooey
   - google-cloud
   - GoogleCodeJam
···
   - graql
   - grasp
   - gray-code
+  - graylog
   - greencard
   - greg-client
   - gremlin-haskell
   - Grempa
   - grenade
+  - greplicate
+  - gridfs
   - grm
   - groot
   - gross
···
   - gstreamer
   - GTALib
   - gtfs-realtime
+  - gtk2hs-cast-th
   - gtk2hs-hello
   - gtk2hs-rpn
   - gtk3-mac-integration
···
   - hakyll-contrib
   - hakyll-contrib-csv
   - hakyll-contrib-elm
+  - hakyll-contrib-i18n
   - hakyll-contrib-links
   - hakyll-dhall
   - hakyll-dir-list
···
   - HaPy
   - haquery
   - harchive
+  - HARM
   - haroonga
   - harpy
   - harvest-api
···
   - hashtables-plus
   - hasim
   - hask
+  - haskades
+  - haskanoid
   - haskbot-core
   - haskeline-class
   - haskelisp
···
   - hastache
   - haste
   - haste-prim
+  - hat
   - hatex-guide
   - hats
   - hatt
···
   - hfractal
   - HFrequencyQueue
   - hfusion
+  - HGamer3D
+  - HGamer3D-Data
   - hg-buildpackage
   - hgdbmi
   - HGE2D
···
   - hmumps
   - hnetcdf
   - hnn
+  - hnop
   - hoauth
   - hobbes
   - hocilib
···
   - hodatime
   - HODE
   - hoe
+  - hofix-mtl
   - hog
   - hogg
   - hois
···
   - ihaskell-parsec
   - ihaskell-widgets
   - illuminate
+  - imagemagick
   - imagepaste
   - imapget
   - imgur
···
   - integreat
   - intel-aes
   - intensional-datatys
+  - interleavableGen
+  - interleavableIO
   - interlude-l
   - internetmarke
   - intero
···
   - join-api
   - joinlist
   - jonathanscard
+  - jort
   - jpeg
   - jsaddle-hello
   - jsaddle-wkwebview
···
   - json-pointer-hasql
   - json-pointy
   - json-python
+  - json-qq
   - jsonresume
   - json-rpc-client
   - json-schema
···
   - kd-tree
   - keccak
   - keera-hails-reactivevalues
+  - keiretsu
   - kempe
   - kerry
   - Ketchup
···
   - kmonad
   - kmp-dfa
   - koellner-phonetic
+  - Konf
   - kontra-config
   - kparams
   - kraken
···
   - lambda2js
   - lambdaBase
   - lambdabot-utils
+  - lambdabot-xmpp
   - lambda-bridge
   - lambda-canvas
   - lambdacms-core
···
   - language-vhdl
   - language-webidl
   - lapack-ffi
+  - LargeCardinalHierarchy
   - Lastik
   - latest-npm-version
   - latex-formulae-image
···
   - lazyset
   - LazyVault
   - l-bfgs-b
+  - lcs
   - lda
   - ldif
   - ld-intervals
···
   - mega-sdist
   - mellon-core
   - melody
+  - memcached
   - memcached-binary
   - memcache-haskell
   - memis
···
   - miku
   - milena
   - mime-directory
+  - MiniAgda
   - miniforth
   - minilens
   - minilight
···
   - mtp
   - MuCheck
   - mud
+  - mudbath
   - muesli
   - mu-graphql
   - mulang
···
   - musicScroll
   - music-util
   - musicxml
+  - mustache2hs
   - mustache-haskell
   - mvar-lock
   - mvc
···
   - named-servant-server
   - named-sop
   - namelist
+  - nanoAgda
   - nanocurses
   - nano-hmac
   - nano-md5
···
   - nanovg-simple
   - nanq
   - naperian
+  - Naperian
   - naqsha
   - narc
   - nationstates
···
   - network-bitcoin
   - network-builder
   - network-bytestring
+  - network-dbus
   - network-dns
   - networked-game
   - network-house
···
   - nlp-scores
   - nm
   - NMap
+  - nme
   - nntp
   - noether
   - nofib-analyse
···
   - NonEmpty
   - nonempty-lift
   - non-empty-zipper
+  - noodle
   - no-role-annots
   - notcpp
   - not-gloss-examples
···
   - OGL
   - ogmarkup
   - oi
+  - old-version
   - om-actor
   - omaketex
   - ombra
···
   - OpenCL
   - OpenCLRaw
   - OpenCLWrappers
+  - opencog-atomspace
   - opencv-raw
   - opendatatable
+  - openexchangerates
+  - openflow
   - opengles
+  - OpenGLRaw21
   - open-haddock
   - openid-connect
   - open-pandoc
+  - openpgp
   - open-signals
   - opensoundcontrol-ht
   - openssh-protocol
···
   - pacman-memcache
   - pads-haskell
   - pagarme
+  - pagerduty
   - pagure-hook-receiver
   - Paillier
   - palette
···
   - phasechange
   - phaser
   - phoityne
+  - phone-metadata
   - phone-numbers
   - phone-push
   - phonetic-languages-plus
···
   - plex
   - plist
   - plist-buddy
+  - plivo
   - plot-gtk
   - plot-gtk3
   - plot-gtk-ui
···
   - poly-cont
   - poly-control
   - polydata-core
+  - polynom
   - polynomial
-  - polysemy
+  - polysemy-plugin
   - polysemy-zoo
   - polytypeable
   - pomaps
   - pomohoro
   - ponder
   - pong-server
+  - pontarius-xpmn
   - pool
   - pool-conduit
   - pop3-client
···
   - posplyu
   - postcodes
   - postgres-embedded
+  - PostgreSQL
   - postgresql-lo-stream
   - postgresql-named
   - postgresql-resilient
···
   - pqc
   - praglude
   - preamble
+  - precis
   - precursor
   - predicate-class
   - predicate-typed
···
   - pubsub
   - pugixml
   - pugs-DrIFT
+  - pugs-HsSyck
   - PUH-Project
   - Pup-Events-Server
   - pure-io
···
   - qnap-decrypt
   - qr-imager
   - qsem
+  - qt
   - QuadEdge
   - QuadTree
   - quantfin
···
   - quarantimer
   - qudb
   - quenya-verb
+  - querystring-pickle
   - questioner
   - QuickAnnotate
   - quickbooks
···
   - remote
   - remote-debugger
   - remote-monad
+  - reorderable
   - reorder-expression
   - repa-algorithms
   - repa-bytestring
···
   - resource-embed
   - restartable
   - restyle
+  - resumable-exceptions
   - rethinkdb
   - rethinkdb-client-driver
   - rethinkdb-wereHamster
···
   - rfc
   - rfc-prelude
   - rhbzquery
+  - riak
+  - riak-protobuf-lens
   - ribbit
   - ribosome
   - RichConditional
···
   - ScratchFs
   - script-monad
   - scrobble
+  - scrz
   - scythe
   - scyther-proof
   - sdl2-cairo-image
   - sdl2-compositor
   - sdl2-fps
   - sdr
+  - seacat
   - seakale
   - sec
   - secdh
···
   - setters
   - set-with
   - sexp
+  - sexpresso
   - sexpr-parser
   - sext
   - SFML
···
   - sh2md
   - shade
   - shadower
+  - shady-gen
   - shake-bindist
   - shakebook
   - shake-cabal
···
   - simple-css
   - simple-download
   - simple-eval
+  - simple-form
   - simple-genetic-algorithm
+  - SimpleH
   - simple-index
   - simpleirc
   - simple-logging
···
   - singnal
   - singular-factory
   - sink
+  - Sit
   - sitepipe
   - sixfiguregroup
   - sized-grid
···
   - snaplet-ses-html
   - snaplet-sqlite-simple
   - snaplet-typed-sessions
+  - snap-predicates
   - snappy-conduit
   - snap-routes
   - snap-stream
···
   - Strafunski-ATermLib
   - Strafunski-StrategyLib
   - StrappedTemplates
+  - StrategyLib
   - stratum-tool
   - stratux-types
   - stream
···
   - SVD2HS
   - svfactor
   - svg-builder-fork
-  - svgcairo
   - svgutils
   - svm-light-utils
   - svm-simple
···
   - syb-extras
   - SybWidget
   - syb-with-class-instances-text
+  - sydtest-aeson
+  - sydtest-hedis
+  - sydtest-mongo
+  - sydtest-persistent-postgresql
+  - sydtest-rabbitmq
+  - sydtest-yesod
   - syfco
   - sym
   - symantic
···
   - testpack
   - testpattern
   - test-pkg
+  - testPkg
   - testrunner
   - test-sandbox
   - test-shouldbe
···
   - tropical
   - tropical-geometry
   - true-name
+  - trust-chain
   - tsession
+  - tslib
   - tsparse
   - tsp-viz
   - tsuntsun
···
   - twilio
   - twine
   - twirp
+  - twisty
   - twitter
   - twitter-feed
   - tx
···
   - type-unary
   - typograffiti
   - tyro
+  - uAgda
   - uberlast
   - ucam-webauth-types
   - ucd
···
   - webshow
   - websockets-rpc
   - webwire
+  - wedged
   - WEditor
   - weekdaze
   - weighted-regexp
···
   - wol
   - word2vec-model
   - wordify
+  - Wordlint
   - wordlist
   - WordNet
   - WordNet-ghc74
···
   - xlsx-templater
   - xml2json
   - xml-conduit-decode
+  - xml-conduit-parse
   - xml-conduit-selectors
   - xml-conduit-stylist
   - xml-html-conduit-lens
···
   - yall
   - yam-app
   - yam-config
+  - yamlkeysdiff
   - yaml-pretty-extras
   - YamlReference
   - yaml-rpc
···
   - Yogurt
   - yst
   - yu-core
+  - yuiGrid
   - yu-tool
   - yxdb-utils
   - z3-encoding
···
   - zm
   - ZMachine
   - zmidi-score
+  - zmqat
   - zoneinfo
   - zoom
   - zoom-refs

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

···
 # pkgs/development/haskell-modules/configuration-hackage2nix.yaml
 
-compiler: ghc-8.10.4
+compiler: ghc-8.10.7
 
 core-packages:
   - array-0.5.4.0
···
   domenkozar:
     - cachix
     - cachix-api
+  dschrempf:
+    - circular
+    - covariance
+    - dirichlet
+    - elynx
+    - elynx-markov
+    - elynx-nexus
+    - elynx-seq
+    - elynx-tools
+    - elynx-tree
+    - glasso
+    - mcmc
+    - pava
+    - slynx
+    - tlynx
   expipiplus1:
     - VulkanMemoryAllocator
     - autoapply
···
     - mattermost-api-qc
     - Unique
   maralorn:
-    - arbtt
     - cabal-fmt
     - generic-optics
     - ghcup
+    - ghcid
     - ghcide
     - haskell-language-server
     - hedgehog
     - hlint
     - hmatrix
+    - hspec-discover
     - iCalendar
     - matrix-client
     - neuron
     - optics
+    - paths
+    - postgresql-simple
     - reflex-dom
     - releaser
+    - replace-megaparsec
     - req
     - shake-bench
     - shh
+    - shh-extras
     - snap
     - stm-containers
     - streamly
     - taskwarrior
+    - tz
+    - weeder
     - witch
   ncfavier:
     - lambdabot
···
   HQu:                                          [ aarch64-linux, armv7l-linux ] # unsupported by vendored C++ library, TODO: explicitly list supported platforms
   HSoM:                                         [ x86_64-darwin, aarch64-darwin ]
   iwlib:                                        [ x86_64-darwin, aarch64-darwin ]
+  Jazzkell:                                     [ x86_64-darwin, aarch64-darwin ] # depends on Euterpea
   jsaddle-webkit2gtk:                           [ x86_64-darwin, aarch64-darwin ]
   kqueue:                                       [ x86_64-linux, aarch64-linux, i686-linux, armv7l-linux ] # BSD / Darwin only API
+  Kulitta:                                      [ x86_64-darwin, aarch64-darwin ] # depends on Euterpea
   LambdaHack:                                   [ x86_64-darwin, aarch64-darwin ]
   large-hashable:                               [ aarch64-linux ] # https://github.com/factisresearch/large-hashable/issues/17
   libmodbus:                                    [ x86_64-darwin, aarch64-darwin ]

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

···
  - GrammarProducts
  - GraphHammer
  - GraphHammer-examples
+ - Grow
  - GrowlNotify
  - Gtk2hsGenerics
  - GtkGLTV
···
  - HAppS-Server
  - HAppS-State
  - HGamer3D-API
+ - HGamer3D-Audio
+ - HGamer3D-Bullet-Binding
  - HGamer3D-CAudio-Binding
+ - HGamer3D-CEGUI-Binding
+ - HGamer3D-Common
+ - HGamer3D-Enet-Binding
+ - HGamer3D-GUI
+ - HGamer3D-Graphics3D
+ - HGamer3D-InputSystem
+ - HGamer3D-Network
  - HGamer3D-OIS-Binding
+ - HGamer3D-Ogre-Binding
+ - HGamer3D-SDL2-Binding
+ - HGamer3D-SFML-Binding
+ - HGamer3D-WinEvent
+ - HGamer3D-Wire
  - HJScript
  - HLearn-algebra
  - HLearn-approximation
···
  - HLearn-datastructures
  - HLearn-distributions
  - HNM
+ - HPhone
  - HPlot
  - HPong
  - HROOT
···
  - apotiki
  - approx-rand-test
  - arbor-monad-metric-datadog
- - arch-hs
  - archlinux-web
  - arduino-copilot
  - arff
···
  - atuin
  - audiovisual
  - aura
+ - aura_3_2_6
  - authoring
  - autonix-deps-kf5
  - avers
···
  - blatex
  - blaze-builder-enumerator
  - blaze-colonnade
- - ble
  - blink1
  - blip
  - blogination
···
  - boots-web
  - borel
  - bowntz
+ - box-csv
+ - box-socket
  - breakout
  - bricks
  - bricks-internal-test
···
  - casadi-bindings-ipopt-interface
  - casadi-bindings-snopt-interface
  - cash
+ - casr-logbook-html
+ - casr-logbook-meta
+ - casr-logbook-meta-html
+ - casr-logbook-reports
+ - casr-logbook-reports-html
+ - casr-logbook-reports-meta
+ - casr-logbook-reports-meta-html
  - cassandra-cql
  - cassandra-thrift
  - cassy
···
  - chromatin
  - chronos_1_1_3
  - chu2
+ - chuchu
  - chunks
  - ciphersaber2
  - citation-resolve
···
  - craftwerk-cairo
  - craftwerk-gtk
  - craze
+ - credentials-cli
  - crf-chain1
  - crf-chain1-constrained
  - crf-chain2-generic
···
  - deeplearning-hs
  - deepzoom
  - defargs
+ - definitive-filesystem
  - definitive-graphics
+ - definitive-parser
+ - definitive-reactive
+ - definitive-sound
  - deka-tests
  - delaunay
  - delicious
···
  - dewdrop
  - dfinity-radix-tree
  - dhall-docs
- - di-polysemy
  - dia-functions
  - diagrams-haddock
  - diagrams-html5
···
  - ghc-instances
  - ghc-mod
  - ghc-tags-plugin
- - ghc-vis
  - ghci-pretty
  - ghcjs-hplay
  - ght
···
  - goal-probability
  - goal-simulation
  - goat
+ - gogol
+ - gogol-abusiveexperiencereport
+ - gogol-acceleratedmobilepageurl
+ - gogol-accessapproval
+ - gogol-accesscontextmanager
+ - gogol-adexchange-buyer
+ - gogol-adexchange-seller
+ - gogol-adexchangebuyer2
+ - gogol-adexperiencereport
+ - gogol-admin-datatransfer
+ - gogol-admin-directory
+ - gogol-admin-emailmigration
+ - gogol-admin-reports
+ - gogol-adsense
+ - gogol-adsense-host
+ - gogol-affiliates
+ - gogol-alertcenter
+ - gogol-analytics
+ - gogol-analyticsreporting
+ - gogol-android-enterprise
+ - gogol-android-publisher
+ - gogol-androiddeviceprovisioning
+ - gogol-androidmanagement
+ - gogol-appengine
+ - gogol-apps-activity
+ - gogol-apps-calendar
+ - gogol-apps-licensing
+ - gogol-apps-reseller
+ - gogol-apps-tasks
+ - gogol-appstate
+ - gogol-autoscaler
+ - gogol-bigquery
+ - gogol-bigquerydatatransfer
+ - gogol-bigtableadmin
+ - gogol-billing
+ - gogol-binaryauthorization
+ - gogol-blogger
+ - gogol-books
+ - gogol-chat
+ - gogol-civicinfo
+ - gogol-classroom
+ - gogol-cloudasset
+ - gogol-clouderrorreporting
+ - gogol-cloudfunctions
+ - gogol-cloudidentity
+ - gogol-cloudiot
+ - gogol-cloudkms
+ - gogol-cloudmonitoring
+ - gogol-cloudprivatecatalog
+ - gogol-cloudprivatecatalogproducer
+ - gogol-cloudprofiler
+ - gogol-cloudscheduler
+ - gogol-cloudsearch
+ - gogol-cloudshell
+ - gogol-cloudtasks
+ - gogol-cloudtrace
+ - gogol-commentanalyzer
+ - gogol-composer
+ - gogol-compute
+ - gogol-consumersurveys
+ - gogol-container
+ - gogol-containeranalysis
+ - gogol-containerbuilder
+ - gogol-customsearch
+ - gogol-dataflow
+ - gogol-datafusion
+ - gogol-dataproc
+ - gogol-datastore
+ - gogol-debugger
+ - gogol-deploymentmanager
+ - gogol-dfareporting
+ - gogol-dialogflow
+ - gogol-digitalassetlinks
+ - gogol-discovery
+ - gogol-dlp
+ - gogol-dns
+ - gogol-docs
+ - gogol-doubleclick-bids
+ - gogol-doubleclick-search
+ - gogol-drive
+ - gogol-driveactivity
+ - gogol-factchecktools
+ - gogol-file
+ - gogol-firebase-dynamiclinks
+ - gogol-firebase-rules
+ - gogol-firebasehosting
+ - gogol-firebaseremoteconfig
+ - gogol-firestore
+ - gogol-fitness
+ - gogol-fonts
+ - gogol-freebasesearch
+ - gogol-fusiontables
+ - gogol-games
+ - gogol-games-configuration
+ - gogol-games-management
+ - gogol-genomics
+ - gogol-gmail
+ - gogol-groups-migration
+ - gogol-groups-settings
+ - gogol-healthcare
+ - gogol-iam
+ - gogol-iamcredentials
+ - gogol-iap
+ - gogol-identity-toolkit
+ - gogol-indexing
+ - gogol-jobs
+ - gogol-kgsearch
+ - gogol-language
+ - gogol-latencytest
+ - gogol-libraryagent
+ - gogol-logging
+ - gogol-manufacturers
+ - gogol-maps-coordinate
+ - gogol-maps-engine
+ - gogol-mirror
+ - gogol-ml
+ - gogol-monitoring
+ - gogol-oauth2
+ - gogol-oslogin
+ - gogol-pagespeed
+ - gogol-partners
+ - gogol-people
+ - gogol-photoslibrary
+ - gogol-play-moviespartner
+ - gogol-playcustomapp
+ - gogol-plus
+ - gogol-plus-domains
+ - gogol-poly
+ - gogol-prediction
+ - gogol-proximitybeacon
+ - gogol-pubsub
+ - gogol-qpxexpress
+ - gogol-redis
+ - gogol-remotebuildexecution
+ - gogol-replicapool
+ - gogol-replicapool-updater
+ - gogol-resourcemanager
+ - gogol-resourceviews
+ - gogol-run
+ - gogol-runtimeconfig
+ - gogol-safebrowsing
+ - gogol-script
+ - gogol-searchconsole
+ - gogol-securitycenter
+ - gogol-servicebroker
+ - gogol-serviceconsumermanagement
+ - gogol-servicecontrol
+ - gogol-servicemanagement
+ - gogol-servicenetworking
+ - gogol-serviceusage
+ - gogol-serviceuser
+ - gogol-sheets
+ - gogol-shopping-content
+ - gogol-siteverification
+ - gogol-slides
+ - gogol-sourcerepo
+ - gogol-spanner
+ - gogol-spectrum
+ - gogol-speech
+ - gogol-sqladmin
+ - gogol-storage
+ - gogol-storage-transfer
+ - gogol-streetviewpublish
+ - gogol-surveys
+ - gogol-tagmanager
+ - gogol-taskqueue
+ - gogol-testing
+ - gogol-texttospeech
+ - gogol-toolresults
+ - gogol-tpu
+ - gogol-tracing
+ - gogol-translate
+ - gogol-urlshortener
+ - gogol-useraccounts
+ - gogol-vault
+ - gogol-videointelligence
+ - gogol-vision
+ - gogol-webmaster-tools
+ - gogol-websecurityscanner
+ - gogol-youtube
+ - gogol-youtube-analytics
+ - gogol-youtube-reporting
  - google-drive
  - google-mail-filters
  - google-maps-geocoding
···
  - gtk-serialized-event
  - gtk2hs-cast-glade
  - gtk2hs-cast-gnomevfs
+ - gtk2hs-cast-gtk
  - gtk2hs-cast-gtkglext
  - gtk2hs-cast-gtksourceview2
  - gtkimageview
···
  - hylotab
  - hyloutils
  - hyperpublic
+ - iException
  - ice40-prim
  - ide-backend
  - ide-backend-common
···
  - jobs-ui
  - join
  - jot
+ - jsc
  - jsmw
  - json-ast-json-encoder
  - json-autotype
···
  - lambdaFeed
  - lambdaLit
  - lambdabot-zulip
+ - lambdacat
  - lambdacms-media
  - lambdacube
  - lambdacube-bullet
···
  - majordomo
  - majority
  - manatee
+ - manatee-all
  - manatee-anything
+ - manatee-browser
  - manatee-core
  - manatee-curl
  - manatee-editor
···
  - manatee-mplayer
  - manatee-pdfviewer
  - manatee-processmanager
+ - manatee-reader
  - manatee-template
  - manatee-terminal
  - manatee-welcome
···
  - online-csv
  - open-adt-tutorial
  - open-union
+ - openpgp-Crypto
  - openpgp-crypto-api
  - openssh-github-keys
  - opentracing-jaeger
···
  - polh-lexicon
  - polydata
  - polysemy-RandomFu
- - polysemy-chronos
- - polysemy-conc
- - polysemy-extra
- - polysemy-fs
- - polysemy-fskvstore
  - polysemy-http
- - polysemy-keyed-state
- - polysemy-kvstore
- - polysemy-kvstore-jsonfile
- - polysemy-log
  - polysemy-log-co
- - polysemy-log-di
- - polysemy-methodology
  - polysemy-methodology-co-log
- - polysemy-methodology-composite
- - polysemy-mocks
  - polysemy-optics
- - polysemy-path
- - polysemy-plugin
- - polysemy-plugin_0_4_0_0
  - polysemy-readline
- - polysemy-req
  - polysemy-resume
- - polysemy-several
- - polysemy-socket
- - polysemy-test
- - polysemy-time
- - polysemy-uncontrolled
- - polysemy-video
- - polysemy-vinyl
  - polysemy-webserver
  - polyseq
  - polytypeable-utils
···
  - rio-process-pool
  - riot
  - ripple
+ - ripple-federation
  - risc-v
  - rivet
  - rlwe-challenges
···
  - sgf
  - sgrep
  - sha1
+ - shady-graphics
  - shake-ats
  - shake-minify-css
  - shaker
···
  - sphero
  - sphinx-cli
  - spice
+ - spike
  - spline3
  - splines
  - sprinkles
···
  - swapper
  - sweet-egison
  - switch
+ - sydtest-amqp
  - sylvia
  - sym-plot
  - symantic-atom
···
  - test-sandbox-quickcheck
  - test-simple
  - testbench
+ - text-json-qq
  - text-plus
  - text-trie
  - text-xml-generic
···
  - wavy
  - web-mongrel2
  - web-page
+ - web-rep
  - web-routes-regular
  - web-routing
  - web3

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

···
   # Add necessary reference to gtk3 package
   gi-dbusmenugtk3 = addPkgconfigDepend super.gi-dbusmenugtk3 pkgs.gtk3;
 
-  # Need WebkitGTK, not just webkit.
-  webkit = super.webkit.override { webkit = pkgs.webkitgtk24x-gtk2; };
-  websnap = super.websnap.override { webkit = pkgs.webkitgtk24x-gtk3; };
-
   hs-mesos = overrideCabal super.hs-mesos (drv: {
     # Pass _only_ mesos; the correct protobuf is propagated.
     extraLibraries = [ pkgs.mesos ];
···
   mime-mail = appendConfigureFlag super.mime-mail "--ghc-option=-DMIME_MAIL_SENDMAIL_PATH=\"sendmail\"";
 
   # Help the test suite find system timezone data.
-  tz = overrideCabal super.tz (drv: { preConfigure = "export TZDIR=${pkgs.tzdata}/share/zoneinfo"; });
+  tz = overrideCabal super.tz (drv: {
+    preConfigure = "export TZDIR=${pkgs.tzdata}/share/zoneinfo";
+    patches = [
+      # Fix tests failing with libSystem, musl etc. due to a lack of
+      # support for glibc's non-POSIX TZDIR environment variable.
+      # https://github.com/nilcons/haskell-tz/pull/29
+      (pkgs.fetchpatch {
+        name = "support-non-glibc-tzset.patch";
+        url = "https://github.com/sternenseemann/haskell-tz/commit/64928f1a50a1a276a718491ae3eeef63abcdb393.patch";
+        sha256 = "1f53w8k1vpy39hzalyykpvm946ykkarj2714w988jdp4c2c4l4cf";
+      })
+    ] ++ (drv.patches or []);
+  });
 
   # Nix-specific workaround
   xmonad = appendPatch (dontCheck super.xmonad) ./patches/xmonad-nix.patch;
···
     preCheck = ''
       export HOME=$TMPDIR/home
     '';
+  });
+  hls-rename-plugin = overrideCabal super.hls-rename-plugin (drv: {
+    testToolDepends = [ pkgs.git ];
+    preCheck = ''
+      export HOME=$TMPDIR/home
+    '' + (drv.preCheck or "");
   });
   hls-splice-plugin = overrideCabal super.hls-splice-plugin (drv: {
     testToolDepends = [ pkgs.git ];

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

···
        ];
        description = "Mapping between Aeson's JSON and Bson objects";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "Agata" = callPackage
···
        executableToolDepends = [ emacs ];
        description = "A dependently typed functional programming language and proof assistant";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ abbradar turion ];
      }) {inherit (pkgs) emacs;};
 
···
        description = "Command-line program for type-checking and compiling Agda programs";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "AhoCorasick" = callPackage
···
        libraryHaskellDepends = [ base mtl ];
        description = "Delimited continuations and dynamically scoped variables";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "CC-delcont-alt" = callPackage
···
        ];
        description = "Collects together existing Haskell cryptographic functions into a package";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "CurryDB" = callPackage
···
        description = "Pure bindings for the MaxMind IP database";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "GeocoderOpenCage" = callPackage
···
        description = "A simple ARM emulator in haskell";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "HAppS-Data" = callPackage
···
        description = "Toolset for the Haskell Game Programmer";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "HGamer3D-API" = callPackage
···
        description = "Toolset for the Haskell Game Programmer - Data Definitions";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "HGamer3D-Enet-Binding" = callPackage
···
        ];
        description = "Multiline strings, interpolation and templating";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "Interpolation-maxs" = callPackage
···
        libraryHaskellDepends = [ base syb template-haskell ];
        description = "Multiline strings, interpolation and templating";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "IntervalMap" = callPackage
···
        libraryHaskellDepends = [ base Euterpea random ];
        description = "Library for modeling jazz improvisation";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {};
 
   "Jdh" = callPackage
···
        description = "A configuration language and a parser";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "Kriens" = callPackage
···
        ];
        description = "Library for automated composition and musical learning";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {};
 
   "KyotoCabinet" = callPackage
···
        description = "A transfinite cardinal arithmetic library including all known large cardinals";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "Lastik" = callPackage
···
        description = "A toy dependently typed programming language with type-based termination";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "MissingH" = callPackage
···
        description = "Naperian Functors for APL-like programming";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "NaperianNetCDF" = callPackage
···
        ];
        description = "High-level abstraction over 9P protocol";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "NewBinary" = callPackage
···
        description = "The intersection of OpenGL 2.1 and OpenGL 3.1 Core";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "OpenSCAD" = callPackage
···
        description = "Thin wrapper over the C postgresql library";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "Prelude" = callPackage
···
        description = "A light, clean and powerful Haskell utility library";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "SimpleLog" = callPackage
···
        description = "Prototypical type checker for Type Theory with Sized Natural Numbers";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "SizeCompare" = callPackage
···
        libraryHaskellDepends = [ base mtl ];
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "Stream" = callPackage
···
        testToolDepends = [ c2hs ];
        description = "ViennaRNA v2 bindings";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ViennaRNA-extras" = callPackage
···
        description = "Plaintext prose redundancy linter";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "Workflow" = callPackage
···
        description = "Parser for a language similar to Cucumber's Gherkin";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "abc-puzzle" = callPackage
···
        description = "The only true way to do IO in Haskell!";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "acme-iot" = callPackage
···
        description = "Mapping between Aeson's JSON and Bson objects";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "aeson-casing" = callPackage
···
      }:
      mkDerivation {
        pname = "aeson-via";
-       version = "0.1.1";
-       sha256 = "18b1pxvkrva6531v8x38vhqmyj48iddi49vgc79s0jx8sgb39l8d";
+       version = "0.1.2";
+       sha256 = "1dm90xx57c5d7x55zdq57pm78v1phii8gkb92y9nzvjjq5y6galy";
        libraryHaskellDepends = [
          aeson aeson-casing base newtype-generics text
        ];
···
        description = "Alpino data manipulation tools";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "alsa" = callPackage
···
        description = "Alternative floating point support for GHC";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "alto" = callPackage
···
        ];
        description = "Automatic Rule-Based Time Tracker";
        license = lib.licenses.gpl2Only;
-       maintainers = with lib.maintainers; [ maralorn rvl ];
+       maintainers = with lib.maintainers; [ rvl ];
      }) {};
 
   "arcgrid" = callPackage
···
        ];
        description = "Distribute hackage packages to archlinux";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "arch-web" = callPackage
···
        description = "A parser for CSV files that uses Attoparsec";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "attoparsec-data" = callPackage
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "aura_3_2_6" = callPackage
+    ({ mkDerivation, aeson, algebraic-graphs, aur, base, bytestring
+     , containers, filepath, hashable, http-client, http-client-tls
+     , http-types, language-bash, megaparsec, network-uri
+     , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal
+     , rio, scheduler, stm, tasty, tasty-hunit, text, time, transformers
+     , typed-process, versions
+     }:
+     mkDerivation {
+       pname = "aura";
+       version = "3.2.6";
+       sha256 = "07sry2nf41f101ldcfcf2x5pp0w7qvlvl6m4j5bbkvxp3rmsjbx2";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson algebraic-graphs aur base bytestring containers filepath
+         hashable http-client http-types language-bash megaparsec
+         network-uri prettyprinter prettyprinter-ansi-terminal rio scheduler
+         stm text time transformers typed-process versions
+       ];
+       executableHaskellDepends = [
+         aeson aur base bytestring containers http-client http-client-tls
+         megaparsec optparse-applicative prettyprinter
+         prettyprinter-ansi-terminal rio scheduler text transformers
+         typed-process versions
+       ];
+       testHaskellDepends = [
+         base bytestring containers megaparsec rio tasty tasty-hunit text
+         versions
+       ];
+       description = "A secure package manager for Arch Linux and the AUR";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "authenticate" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
      , case-insensitive, conduit, containers, html-conduit, http-conduit
···
        description = "Diagrams for the Cessna 172 aircraft in aviation";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "aviation-cessna172-weight-balance" = callPackage
···
        pname = "avro";
        version = "0.5.2.1";
        sha256 = "0g10nbcxz5ff7rckbzwb4sxh1qqg6ay5zwakmlxrsfj9srg8dq2d";
+       revision = "1";
+       editedCabalFile = "14kq896191zvqnsl3hgfxlwi7ajvagrbsiv5l8hxckp5glh5825j";
        libraryHaskellDepends = [
          aeson array base base16-bytestring bifunctors binary bytestring
          containers data-binary-ieee754 deepseq fail HasBigDecimal hashable
···
        executableHaskellDepends = [ base gd X11 ];
        description = "braindead utility to compose Xinerama backgrounds";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "bag" = callPackage
···
        description = "A web based environment for learning and tinkering with Haskell";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "barrie" = callPackage
···
        description = "Parsing and serialization for Base58 addresses (Bitcoin and Ripple)";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "base58string" = callPackage
···
        libraryHaskellDepends = [ base ];
        description = "Base64 implementation for String's";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "base91" = callPackage
···
        testToolDepends = [ tasty-discover ];
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "basen-bytestring" = callPackage
···
        description = "binary files splitter and merger";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "bio" = callPackage
···
        description = "Bluetooth Low Energy (BLE) peripherals";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "blindpass" = callPackage
···
        ];
        description = "boxes";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "box-csv" = callPackage
···
        ];
        description = "CSV parsing in a box";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "box-socket" = callPackage
···
        ];
        description = "Box websockets";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "box-tuples" = callPackage
···
        ];
        description = "Mapping between BSON and algebraic data types";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "bspack" = callPackage
···
        ];
        description = "A type-class to convert values from ByteString";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "bytestring-handle" = callPackage
···
        pname = "cabal-cache";
        version = "1.0.3.0";
        sha256 = "0xx0a53z7wj75p8dqypr6ys63cpw8acl49358f42xi5lgblvqnca";
+       revision = "1";
+       editedCabalFile = "19dr9x78xfgb8jnbj1i23mhzqnvixgh1azyq5fvccm6h4pcbjfzz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        description = "CASR 61.345 Pilot Personal Logbook";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "casr-logbook-html" = callPackage
···
        description = "CASR 61.345 Pilot Personal Logbook";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "cassandra-cql" = callPackage
···
        description = "Tool to maintain a database of CABAL packages and their dependencies";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "cbor-tool" = callPackage
···
        benchmarkHaskellDepends = [ base criterion vector ];
        description = "Circular fixed-sized mutable vectors";
        license = lib.licenses.bsd3;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "circular_0_4_0_1" = callPackage
···
        description = "Circular fixed-sized mutable vectors";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "circus" = callPackage
···
        libraryHaskellDepends = [ base natural-induction peano ];
        description = "Counted list";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "clit" = callPackage
···
        ];
        description = "CMA-ES wrapper in Haskell";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "cmake-syntax" = callPackage
···
        testHaskellDepends = [ base QuickCheck text ];
        description = "CSV Parser & Producer";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "command" = callPackage
···
        description = "Common compression algorithms";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "compstrat" = callPackage
···
        testHaskellDepends = [ base hmatrix tasty tasty-hunit ];
        description = "Well-conditioned estimation of large-dimensional covariance matrices";
        license = lib.licenses.gpl3Plus;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "coverage" = callPackage
···
        ];
        description = "Cassandra CQL binary protocol";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "cql-io" = callPackage
···
        description = "Secure Credentials Storage and Distribution";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "credentials-cli" = callPackage
···
      }:
      mkDerivation {
        pname = "cropty";
-       version = "0.2.0.0";
-       sha256 = "1skw80716qwsmdg1m55bl556xc8mmailzhz7m8psgaf2ggiys3jc";
+       version = "0.3.1.0";
+       sha256 = "1syffvzak02j5rha2wc61yjw9g98g0mqq2j2smv1ri8y0p43gdii";
        libraryHaskellDepends = [ base binary bytestring cryptonite ];
-       testHaskellDepends = [ base hedgehog unliftio ];
+       testHaskellDepends = [ base binary hedgehog unliftio ];
        description = "Encryption and decryption";
        license = lib.licenses.mit;
      }) {};
···
        testHaskellDepends = [ base hspec ];
        description = "bindings to libcurl, the multiprotocol file transfer library";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "curly-expander" = callPackage
···
        ];
        description = "Types representing standard and non-standard currencies";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "currency-codes" = callPackage
···
        description = "Easy to use FFI Bridge for using Rust in Haskell";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "cursedcsv" = callPackage
···
        ];
        description = "Permissively licensed D-Bus client library";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "d10" = callPackage
···
        description = "Accessor functions for monadLib's monads";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "data-accessor-monads-fd" = callPackage
···
        libraryHaskellDepends = [ base directory filepath HSH ];
        description = "Utilities to work with debian binary packages";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "debian-build" = callPackage
···
        description = "The base modules of the Definitive framework";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "definitive-filesystem" = callPackage
···
        ];
        description = "Dependent finite maps (partial dependent products)";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "dependent-monoidal-map" = callPackage
···
        ];
        description = "DI logger wrapped for Polysemy";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "dia-base" = callPackage
···
        description = "A diff algorithm based on recursive longest common substrings";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "diff-parse" = callPackage
···
        ];
        description = "Gemini client";
        license = lib.licenses.gpl3Only;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "diophantine" = callPackage
···
        testHaskellDepends = [ base hspec log-domain mwc-random vector ];
        description = "Multivariate Dirichlet distribution";
        license = lib.licenses.bsd3;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "dirichlet_0_1_0_5" = callPackage
···
        description = "Multivariate Dirichlet distribution";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "dirstream" = callPackage
···
        description = "Socket operations with timeouts";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "eap" = callPackage
···
        description = "A monadic embedding of aspect oriented programming";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "effective-aspects-mzv" = callPackage
···
        libraryHaskellDepends = [ base elerea SDL ];
        description = "Elerea FRP wrapper for SDL";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "elevator" = callPackage
···
        ];
        description = "A library to generate Elm types from Haskell source";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "elm-export-persistent" = callPackage
···
        description = "Generate easy-to-remember, hard-to-guess passwords";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "elsa" = callPackage
···
        ];
        description = "Validate and (optionally) redo ELynx analyses";
        license = lib.licenses.gpl3Plus;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "elynx_0_6_1_0" = callPackage
···
        description = "Validate and (optionally) redo ELynx analyses";
        license = lib.licenses.gpl3Plus;
        hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "elynx-markov" = callPackage
···
        benchmarkHaskellDepends = [ base ];
        description = "Simulate molecular sequences along trees";
        license = lib.licenses.gpl3Plus;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "elynx-markov_0_6_1_0" = callPackage
···
        description = "Simulate molecular sequences along trees";
        license = lib.licenses.gpl3Plus;
        hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "elynx-nexus" = callPackage
···
        testHaskellDepends = [ base hspec ];
        description = "Import and export Nexus files";
        license = lib.licenses.gpl3Plus;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "elynx-nexus_0_6_1_0" = callPackage
···
        description = "Import and export Nexus files";
        license = lib.licenses.gpl3Plus;
        hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "elynx-seq" = callPackage
···
        ];
        description = "Handle molecular sequences";
        license = lib.licenses.gpl3Plus;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "elynx-seq_0_6_1_0" = callPackage
···
        description = "Handle molecular sequences";
        license = lib.licenses.gpl3Plus;
        hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "elynx-tools" = callPackage
···
        ];
        description = "Tools for ELynx";
        license = lib.licenses.gpl3Plus;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "elynx-tools_0_6_1_0" = callPackage
···
        description = "Tools for ELynx";
        license = lib.licenses.gpl3Plus;
        hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "elynx-tree" = callPackage
···
        ];
        description = "Handle phylogenetic trees";
        license = lib.licenses.gpl3Plus;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "elynx-tree_0_6_1_0" = callPackage
···
        description = "Handle phylogenetic trees";
        license = lib.licenses.gpl3Plus;
        hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "ema" = callPackage
···
        description = "Client for etcd, a highly-available key value store";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "eternal" = callPackage
···
        libraryToolDepends = [ c2hs ];
        description = "Compression and decompression in the exomizer format";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "exon" = callPackage
···
        broken = true;
      }) {};
 
+  "explainable-predicates" = callPackage
+    ({ mkDerivation, array, base, doctest-exitcode-stdio, doctest-lib
+     , hspec, mono-traversable, regex-tdfa, syb, template-haskell
+     }:
+     mkDerivation {
+       pname = "explainable-predicates";
+       version = "0.1.0.0";
+       sha256 = "18rw0vb61pvysywqhdl4rwpc38h37g2fgj11abd9gxm44cy04plg";
+       libraryHaskellDepends = [
+         array base mono-traversable regex-tdfa syb template-haskell
+       ];
+       testHaskellDepends = [
+         base doctest-exitcode-stdio doctest-lib hspec
+       ];
+       description = "Predicates that can explain themselves";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "explicit-constraint-lens" = callPackage
     ({ mkDerivation, base, tasty, tasty-hunit }:
      mkDerivation {
···
        ];
        description = "Fixes whitespace issues";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "fixed" = callPackage
···
        ];
        description = "Wrapper for flock(2)";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "floskell" = callPackage
···
        description = "Installed package query tool for Gentoo Linux";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "fractal" = callPackage
···
        ];
        description = "Fresco binding for Haskell";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "fresh" = callPackage
···
        preBuild = ''export LD_LIBRARY_PATH=`pwd`/dist/build''${LD_LIBRARY_PATH:+:}$LD_LIBRARY_PATH'';
        description = "Grammatical Framework";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ggtsTC" = callPackage
···
        description = "Library for hot-swapping shared objects in GHC";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "ghc-imported-from" = callPackage
···
        description = "Live visualization of data structures in GHCi";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "ghcflags" = callPackage
···
        ];
        description = "GHCi based bare bones IDE";
        license = lib.licenses.bsd3;
+       maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
   "ghcide" = callPackage
···
     ({ mkDerivation, base, bytestring, Cabal, containers, gi-atk
      , gi-cairo, gi-gdk, gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject
      , gi-gtk, gi-javascriptcore, gi-soup, haskell-gi, haskell-gi-base
-     , haskell-gi-overloading, text, transformers, webkitgtk24x-gtk3
+     , haskell-gi-overloading, text, transformers, webkitgtk
      }:
      mkDerivation {
        pname = "gi-webkit";
···
          gi-gio gi-glib gi-gobject gi-gtk gi-javascriptcore gi-soup
          haskell-gi haskell-gi-base haskell-gi-overloading text transformers
        ];
-       libraryPkgconfigDepends = [ webkitgtk24x-gtk3 ];
+       libraryPkgconfigDepends = [ webkitgtk ];
        doHaddock = false;
        description = "WebKit bindings";
        license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
-     }) {inherit (pkgs) webkitgtk24x-gtk3;};
+     }) {inherit (pkgs) webkitgtk;};
 
   "gi-webkit2" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, gi-atk
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "githash_0_1_6_2" = callPackage
+    ({ mkDerivation, base, bytestring, directory, filepath, hspec
+     , process, template-haskell, temporary, th-compat, unliftio
+     }:
+     mkDerivation {
+       pname = "githash";
+       version = "0.1.6.2";
+       sha256 = "1vkwc7j71vdrxy01vlm6xfp16kam7m9bnj9y3h217fzhq5mjywhz";
+       libraryHaskellDepends = [
+         base bytestring directory filepath process template-haskell
+         th-compat
+       ];
+       testHaskellDepends = [
+         base bytestring directory filepath hspec process template-haskell
+         temporary th-compat unliftio
+       ];
+       description = "Compile git revision info into Haskell projects";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "github" = callPackage
     ({ mkDerivation, aeson, base, base-compat, base16-bytestring
      , binary, binary-instances, bytestring, containers, cryptohash-sha1
···
        ];
        description = "Type definitions for objects used by the GitHub v3 API";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "github-utils" = callPackage
···
        libraryHaskellDepends = [ base vector ];
        description = "Graphical Lasso algorithm";
        license = lib.licenses.bsd3;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "glaze" = callPackage
···
        description = "Core data types and functionality for Gogol libraries";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "gogol-customsearch" = callPackage
···
        description = "Support for graylog output";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "greencard" = callPackage
···
        description = "Generalised replicate functions";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "greskell" = callPackage
···
        description = "GridFS (MongoDB file storage) implementation";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "gridland" = callPackage
···
        libraryHaskellDepends = [ base glib ];
        description = "A type class for cast functions of Gtk2hs: glib package";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gtk2hs-cast-gnomevfs" = callPackage
···
        description = "A type class for cast functions of Gtk2hs: TH package";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "gtk2hs-hello" = callPackage
···
        description = "A Hakyll library for internationalization";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "hakyll-contrib-links" = callPackage
···
      }:
      mkDerivation {
        pname = "hanspell";
-       version = "0.2.6.0";
-       sha256 = "0qk7zxq43mjcxyzhiidk0zm4sb2ii5wwr4zqihky538s6mqf5ccz";
+       version = "0.2.6.1";
+       sha256 = "06a2jakdyrdnb0m4mdbsg7zvichp3r5na8v4di18v9rwmq1fx0ih";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        description = "Utility to generate bindings for BlackBerry Cascades";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "haskakafka" = callPackage
···
        description = "A breakout game written in Yampa using SDL";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "haskarrow" = callPackage
···
        description = "The Haskell tracer, generating and viewing Haskell execution traces";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "hatex-guide" = callPackage
···
        executableHaskellDepends = [ base ];
        description = "Minimal extensible web-browser";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hbro-contrib" = callPackage
···
        ];
        description = "Third-party extensions to hbro";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hburg" = callPackage
···
          happstack-server-tls hdaemonize hsyslog iptables-helpers mtl
        version = "1.0.1.0";
          happstack-server-tls hdaemonize hsyslog iptables-helpers mtl
+       revision = "1";
+       editedCabalFile = "01g0csnjygylg0a0zmyz66rm7xvhnys40hgclm13g5rakh2jmfak";
        libraryHaskellDepends = [
          happstack-server-tls hdaemonize hsyslog iptables-helpers mtl
          happstack-server-tls hdaemonize hsyslog iptables-helpers mtl
···
        license = lib.licenses.asl20;
      }) {};
 
+  "hls-rename-plugin" = callPackage
+    ({ mkDerivation, base, containers, extra, filepath, ghc
+     , ghc-exactprint, ghcide, hiedb, hls-plugin-api, hls-retrie-plugin
+     , hls-test-utils, lsp, lsp-types, syb, text, transformers
+     }:
+     mkDerivation {
+       pname = "hls-rename-plugin";
+       version = "1.0.0.0";
+       sha256 = "0j13nh3fvvmj1sd11fiq9fccq23s6p7jz3m96b49kprkayx65zhh";
+       libraryHaskellDepends = [
+         base containers extra ghc ghc-exactprint ghcide hiedb
+         hls-plugin-api hls-retrie-plugin lsp lsp-types syb text
+         transformers
+       ];
+         happstack-server-tls hdaemonize hsyslog iptables-helpers mtl
+       description = "Rename plugin for Haskell Language Server";
+       license = lib.licenses.asl20;
+     }) {};
+
          happstack-server-tls hdaemonize hsyslog iptables-helpers mtl
          happstack-server-tls hdaemonize hsyslog iptables-helpers mtl
          happstack-server-tls hdaemonize hsyslog iptables-helpers mtl
···
          happstack-server-tls hdaemonize hsyslog iptables-helpers mtl
        version = "1.0.0.2";
          happstack-server-tls hdaemonize hsyslog iptables-helpers mtl
+       revision = "1";
+       editedCabalFile = "0hwjh5b71hj6gwr73r9imlggkzv4j3z116va3y4v3h7zcjs11c4k";
        libraryHaskellDepends = [
          happstack-server-tls hdaemonize hsyslog iptables-helpers mtl
          happstack-server-tls hdaemonize hsyslog iptables-helpers mtl
···
        executableHaskellDepends = [ base ];
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "hnormalise" = callPackage
···
        description = "defining @mtl@-ready monads as * -> * fixed-points";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "hog" = callPackage
···
        libraryToolDepends = [ c2hs ];
        description = "Haskell bindings for libpuz";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hpygments" = callPackage
···
        testToolDepends = [ hspec-meta ];
        description = "Automatically discover and run Hspec tests";
        license = lib.licenses.mit;
+       maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
   "hspec-discover_2_8_3" = callPackage
···
        description = "Automatically discover and run Hspec tests";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
   "hspec-expectations" = callPackage
···
        libraryHaskellDepends = [ base bytestring ];
        description = "Functions for working with HTTP Accept headers";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "http-api-data" = callPackage
···
        pname = "hw-balancedparens";
        version = "0.4.1.1";
        sha256 = "16v36fj5aawnx6glarzljl3yb93zkn06ij5cg40zba5rp8jhpg7z";
-       revision = "3";
-       editedCabalFile = "1myzy3wjwjaqlm31pa90msr8rl26vczd5yqd29mx0gy7p4x2dmgi";
+       revision = "4";
+       editedCabalFile = "0hw0qqkabv0i4zmr7436pl1xn9izxcm4p9flv2k697zyhqdaccik";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-dsv";
        version = "0.4.1.0";
        sha256 = "1wv0yg662c3bq4kpgfqfjks59v17i5h3v3mils1qpxn4c57jr3s8";
-       revision = "6";
-       editedCabalFile = "0w0w2ir8z1v4zpjxx36slkqcpvgl1s9520cnnbqg9i0fnvydb50v";
+       revision = "7";
+       editedCabalFile = "1x7f6k3ih3270xapfc9fnm4d51fhnha71fz0r3l2l6xx4mghcby2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-dump";
        version = "0.1.1.0";
        sha256 = "14ya18i3xvay5xn8j20b06msqyd49h34w526k1x1fxdp0i2l3rwr";
-       revision = "5";
-       editedCabalFile = "1rkz578hcn7s9i08n5jc557vph7k017m8vbk6ijf5psa189w1dkh";
+       revision = "6";
+       editedCabalFile = "0aizgpq9cxhhnzczi39nf6whcxnwqiszrbax0mzb3fqjwi1sida1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-eliasfano";
        version = "0.1.2.0";
        sha256 = "1wqpzznmz6bl88wzhrfcbgi49dw7w7i0p92hyc0m58nanqm1zgnj";
-       revision = "5";
-       editedCabalFile = "0w8kikrrkv8v1drnrjfabzflbgs768qbrfv8n17y4id76aqazml5";
+       revision = "6";
+       editedCabalFile = "0svym7gnvsd9aa2wabrpfqv5661s2fg1jsqibyyblcrjy0cicdrl";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-excess";
        version = "0.2.3.0";
        sha256 = "0xiyf3xyg6f4kgkils9ycx6q0qcsbd6rw4m9lizw9295mnp05s3g";
-       revision = "1";
-       editedCabalFile = "0qq8svkn9365vdbb0y3y4m2pdklsrf6z3a1m0kyfmbr0vphza369";
+       revision = "2";
+       editedCabalFile = "03xn63rydgflzpyqshi7kd18llkzd8ma15ml846mw95ww97d4i9i";
        libraryHaskellDepends = [
          base hw-bits hw-prim hw-rankselect-base safe vector
        ];
···
        pname = "hw-hspec-hedgehog";
        version = "0.1.1.0";
        sha256 = "04r30hb4664yciwfl3kyx0xn6sqc6abwhavb4wxiaas8b4px9kyn";
-       revision = "2";
-       editedCabalFile = "16v3dcpm51m8g2va85jfnbxqyc6dds2nazyd31080fa4804a90wz";
+       revision = "3";
+       editedCabalFile = "0byjlgisygdak9pf9dfnpbj576mrjd7knx4kyfm12l6l5qhcw8n1";
        libraryHaskellDepends = [
          base call-stack hedgehog hspec HUnit transformers
        ];
···
        pname = "hw-ip";
        version = "2.4.2.0";
        sha256 = "1bvh4fkg1ffr3y8wink62rgkynlcgjhmra7a4w01h1dmw1vb2vfx";
-       revision = "4";
-       editedCabalFile = "0pjry2xjnhfl3jii8j9dqmqz88hw7g8wkwy4fqnajnchrxb8f06w";
+       revision = "5";
+       editedCabalFile = "18fr2r6bhcz1a78di6g2vb7k74xaxamw4azxrjyb1bkx234laj2m";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-json";
        version = "1.3.2.2";
        sha256 = "03h5zv94ndsz4vh0jql8rg8pl95rbf8xkyzvr3r55i3kpmb85sbg";
-       revision = "4";
-       editedCabalFile = "0ys0xlmw2xdrrjjdjx1gwlh0qpig8b4ljqwrp2yhp3aihzsb5304";
+       revision = "5";
+       editedCabalFile = "0pln3fcdbsd2gzvpa29gc2krsqk5ndkgpygcskwakj25cw3irh76";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-json-lens";
        version = "0.2.1.0";
        sha256 = "1v3ws69pyrw5ja00r326kqlq6hd7r5np119fk2la7f74aqhajjf6";
-       revision = "3";
-       editedCabalFile = "0svnn3wdm8adcyw1phk0k9ddzlk3ni1dar681vpq61xwd1xmgjgb";
+       revision = "4";
+       editedCabalFile = "0ajl6xqy7wyvwidpv07842wslrw9yc6n48n8gm14b1l3iiwj2kiz";
        libraryHaskellDepends = [
          aeson base bytestring containers hw-json lens scientific text word8
        ];
···
        pname = "hw-json-simd";
        version = "0.1.1.0";
        sha256 = "0bpfyx2bd7pcr8y8bfahcdm30bznqixfawraq3xzy476vy9ppa9n";
-       revision = "3";
-       editedCabalFile = "0f7y8kaj2bv3l1fscwxdnqj7378mrls1mcnsm23cpb5dizy3p2nf";
+       revision = "4";
+       editedCabalFile = "0ragyq509nxy5ax58h84b6984lwnhklkk8nfafmxh5fxq66214cy";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring hw-prim lens vector ];
···
        pname = "hw-json-simple-cursor";
        version = "0.1.1.0";
        sha256 = "1kwxnqsa2mkw5sa8rc9rixjm6f75lyjdaz7f67yyhwls5v4315bl";
-       revision = "6";
-       editedCabalFile = "1ws3mcyvba05s0wvwzbig54wxkw37pp55c5jwbsc96inic8cfq3y";
+       revision = "7";
+       editedCabalFile = "169aqi2vjzg38cljfipxaw7kzav5z3n9b68f32mjsk1drh1c5hpd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-json-standard-cursor";
        version = "0.2.3.1";
        sha256 = "1mpsspp6ba2zqv38a0rcv93mbwb1rb8snmxklf32g02djj8b4vir";
-       revision = "4";
-       editedCabalFile = "18x3vinc6j5nnq3j5x7zdcy3ys6b2clmb7lhz6qg1wklnfcyjxsb";
+       revision = "5";
+       editedCabalFile = "029hrckhsm0g1j2zijs3ff14qsk2cdw9m57l3jhjy0cw3ynwisds";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-mquery";
        version = "0.2.1.0";
        sha256 = "1qhd8jcwffr57mjraw0g3xj9kb0jd75ybqaj1sbxw31lc2hr9w9j";
-       revision = "2";
-       editedCabalFile = "1996bn28l3s2bgjgll17gpryvp61vxjz0d3zi5py6kk40hsb4y6z";
+       revision = "3";
+       editedCabalFile = "0mnra701p169xzibag8mvb2mrk5gdp42dwlhqr07b6dz2cly88sn";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ ansi-wl-pprint base dlist lens ];
···
        pname = "hw-packed-vector";
        version = "0.2.1.0";
        sha256 = "13hly2yzx6kx4j56iksgj4i3wmvg7rmxq57d0g87lmybzhha9q38";
-       revision = "5";
-       editedCabalFile = "0pnrjx4sbbxpr1fvib5z95cxjgfif2iay1j6hk5ysavwn6i2qxqx";
+       revision = "6";
+       editedCabalFile = "1ryh9nmpg3925lrr5a4wfsdv3f4a6rshrqn5pzbkqchh4mx39cpf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-parser";
        version = "0.1.1.0";
        sha256 = "1zsbw725mw3fn4814qricqanbvx1kgbnqvgwijqgfv8jz7yf5gxa";
-       revision = "2";
-       editedCabalFile = "15r5ydza7dawa5b7y3xi80016pa3s5sb706hvsqvn82fhqp5dziw";
+       revision = "3";
+       editedCabalFile = "1rc0swmmnckp99qzmhl1acxykyhdyw1lvy73mn7c4dlv751gnlhk";
        libraryHaskellDepends = [
          attoparsec base bytestring hw-prim text
        ];
···
      }) {};
 
   "hw-prim-bits" = callPackage
-    ({ mkDerivation, base, criterion, hedgehog, hspec, hw-hedgehog
-     , hw-hspec-hedgehog, QuickCheck, vector
+    ({ mkDerivation, base, criterion, doctest, doctest-discover
+     , hedgehog, hspec, hspec-discover, hw-hedgehog, hw-hspec-hedgehog
+     , QuickCheck, vector
      }:
      mkDerivation {
        pname = "hw-prim-bits";
-       version = "0.1.0.4";
-       sha256 = "1k2fqsa4msd156ar5cx57r0gj5ppwp1929yv56spv6n7xar1ich4";
+       version = "0.1.0.5";
+       sha256 = "1km4gj6znva4yz99sg1imf1k820m4kdhpzn51alj6gv92x127kih";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [
-         base hedgehog hspec hw-hedgehog hw-hspec-hedgehog QuickCheck
+         base doctest doctest-discover hedgehog hspec hw-hedgehog
+         hw-hspec-hedgehog QuickCheck
        ];
+       testToolDepends = [ doctest-discover hspec-discover ];
        benchmarkHaskellDepends = [ base criterion vector ];
        description = "Primitive support for bit manipulation";
        license = lib.licenses.bsd3;
···
        pname = "hw-rankselect";
        version = "0.13.4.0";
        sha256 = "0chk3n4vb55px943w0l3q7pxhgbvqm64vn7lkhi7k0l2dpybycp7";
-       revision = "5";
-       editedCabalFile = "1jbfanh0028sxj0arx92w753dwgpazs8j2flqjq9svc91rpk82px";
+       revision = "6";
+       editedCabalFile = "1j287ynfgiz56bn0hqqppa03zn2gcllnmiz2azzvfx7xkq3nkdh1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-simd";
        version = "0.1.2.0";
        sha256 = "1r202xzqprb1v8ajd9n6ixckjfdy17mn8jibx4j2xgknx595v24f";
-       revision = "2";
-       editedCabalFile = "05rax91afykkmwnxnyi6bmmjh0n9ryw006k9k3klwnvy8h2yaf4m";
+       revision = "3";
+       editedCabalFile = "1dl2zqyc3rcrlda6apy5afgvax5cah37n44hzlm81y9p1nbpd205";
        libraryHaskellDepends = [
          base bits-extra bytestring deepseq hw-bits hw-prim hw-rankselect
          hw-rankselect-base transformers vector
···
        pname = "hw-simd-cli";
        version = "0.0.0.1";
        sha256 = "0fqkrhjrflkiacq1qfnfiy4rk6pg47j72d0ni0jwfdn6ajx22y90";
+       revision = "1";
+       editedCabalFile = "1djqcz745rwf6jx3r4gs6cnvnk5pacllral5yk85lixvl80dyb1b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-streams";
        version = "0.0.1.0";
        sha256 = "0hzpx1j06h98y0zcmysklzn3s3mvpbb1nkwg4zkbdxvzzqs5hnm5";
-       revision = "1";
-       editedCabalFile = "0fib78604y6cjchah7zhjsfli820ks51qq7yjv81wwbckjjkpw5v";
+       revision = "2";
+       editedCabalFile = "1c9vll8i0pl4x3b3xpy3zxc581f7n7m6mvpgz7pfhcpikw426s9y";
        libraryHaskellDepends = [
          base bytestring ghc-prim hw-bits hw-prim mmap primitive
          transformers vector
···
        pname = "hw-xml";
        version = "0.5.1.0";
        sha256 = "0g81kknllbc6v5wx7kgzhh78409njfzr3h7lfdx7ip0nkhhnpmw4";
-       revision = "7";
-       editedCabalFile = "1rikq6wxjg4h5pfg9miw14np7b1h2vf036gawyazq5c4d6l2wfzv";
+       revision = "8";
+       editedCabalFile = "049vaf01iw694kpgaaqk2wpg2bpd8s9f2xq39sc3wh7kz7c848fv";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        libraryHaskellDepends = [ base bytestring curl hxt parsec ];
        description = "LibCurl interface for HXT";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hxt-expat" = callPackage
···
        libraryHaskellDepends = [ base bytestring hexpat hxt ];
        description = "Expat parser for HXT";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hxt-extras" = callPackage
···
        ];
        description = "TagSoup parser for HXT";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hxt-unicode" = callPackage
···
        ];
        description = "The XPath modules for HXT";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hxt-xslt" = callPackage
···
        ];
        description = "The XSLT modules for HXT";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hxthelper" = callPackage
···
        description = "bindings to imagemagick library";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) imagemagick;};
 
   "imagepaste" = callPackage
···
        description = "Generates a version of a module using InterleavableIO";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "interleavableIO" = callPackage
···
        description = "Use other Monads in functions that asks for an IO Monad";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "interleave" = callPackage
···
        executableToolDepends = [ alex happy ];
        description = "Create immutable algebraic data structures for Java";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "java-bridge" = callPackage
···
        description = "JP's own ray tracer";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "jose" = callPackage
···
        description = "Json Quasiquatation library for Haskell";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "json-query" = callPackage
···
        description = "Multi-process orchestration for development and integration testing";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "kempe" = callPackage
···
      }:
      mkDerivation {
        pname = "kempe";
-       version = "0.2.0.4";
-       sha256 = "0rzpid5lnjnjgsip3fvm5d313hh8wb7gqla3dyf56l9q7y4r20js";
+       version = "0.2.0.5";
+       sha256 = "185kz7ssbh0zmac1n015chhdch41driqvm6f0l71flf70kh6183a";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        description = "Lambdabot plugin for XMPP (Jabber) protocol";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "lambdabot-zulip" = callPackage
···
        libraryHaskellDepends = [ array base vector ];
        description = "L-BFGS optimization";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "lca" = callPackage
···
        description = "Find longest common sublist of two lists";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "ld-intervals" = callPackage
···
        ];
        description = "mtl operations with Van Laarhoven lenses";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "lenz-template" = callPackage
···
        ];
        description = "Van Laarhoven lens templates";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "less-arbitrary" = callPackage
···
        libraryHaskellDepends = [ base bindings-DSL unix ];
        description = "Linux fbdev (framebuffer device, /dev/fbX) utility functions";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "linux-inotify" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "lzma-conduit_1_2_2" = callPackage
+    ({ mkDerivation, base, base-compat, bytestring, conduit, HUnit
+     , lzma, QuickCheck, resourcet, test-framework, test-framework-hunit
+     , test-framework-quickcheck2, transformers
+     }:
+     mkDerivation {
+       pname = "lzma-conduit";
+       version = "1.2.2";
+       sha256 = "1z6q16hzp2r5a4gdbg9akky5l9bfarzzhzswrgvh0v28ax400whb";
+       libraryHaskellDepends = [
+         base bytestring conduit lzma resourcet transformers
+       ];
+       testHaskellDepends = [
+         base base-compat bytestring conduit HUnit QuickCheck resourcet
+         test-framework test-framework-hunit test-framework-quickcheck2
+       ];
+       description = "Conduit interface for lzma/xz compression";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "lzma-enumerator" = callPackage
     ({ mkDerivation, base, bindings-DSL, bytestring, enumerator, HUnit
      , mtl, QuickCheck, test-framework, test-framework-hunit
···
        ];
        description = "Sample from a posterior using Markov chain Monte Carlo";
        license = lib.licenses.gpl3Plus;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "mcmc_0_6_1_0" = callPackage
···
        description = "Sample from a posterior using Markov chain Monte Carlo";
        license = lib.licenses.gpl3Plus;
        hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "mcmc-samplers" = callPackage
···
        description = "haskell bindings for memcached";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "memcached-binary" = callPackage
···
     ({ mkDerivation, base, profunctors }:
      mkDerivation {
        pname = "merge";
-       version = "0.2.0.0";
-       sha256 = "193xvnm5ahms8pg8g8jscrcfp29mwni9rssy5hci11z3b126s6wv";
+       version = "0.3.1.1";
+       sha256 = "1b03xp953d4kwz7n3p16djsmzzd935x111ngm53gzg1n5dfyqfn5";
        libraryHaskellDepends = [ base profunctors ];
        testHaskellDepends = [ base ];
        description = "A functor for consistent merging of information";
···
        libraryHaskellDepends = [ base ];
        description = "metamorphisms: ana . cata or understanding folds and unfolds";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "metaplug" = callPackage
···
        ];
        description = "MIME implementation for String's";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "mime-types" = callPackage
···
        executableHaskellDepends = [ base directory mtl random ];
        description = "Minesweeper simulation using neural networks";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "minesweeper" = callPackage
···
        libraryHaskellDepends = [ base containers directory filepath ];
        description = "Minimal ini like configuration library with a few extras";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "minimorph" = callPackage
···
        libraryHaskellDepends = [ base mtl transformers ];
        description = "Stateful supply monad";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "monad-task" = callPackage
···
        description = "Continuous deployment server for use with GitHub";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "muesli" = callPackage
···
        description = "Utility to generate Haskell code from Mustache templates";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "mutable" = callPackage
···
        executableHaskellDepends = [ base HSH mtl process ];
        description = "Utility to call iwconfig";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "n-tuple" = callPackage
···
        description = "A toy dependently-typed language";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "nanocurses" = callPackage
···
        description = "D-Bus";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "network-dns" = callPackage
···
        description = "Bindings to the Nyctergatis Markup Engine";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "nmis-parser" = callPackage
···
        testHaskellDepends = [ base doctest Glob hspec QuickCheck text ];
        description = "Non empty Data.Text type";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "non-empty-zipper" = callPackage
···
        description = "the noodle programming language";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "normaldistribution" = callPackage
···
        libraryHaskellDepends = [ base ];
        description = "Useful utility functions that only depend on base";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "not-prelude" = callPackage
···
        pname = "numeric-logarithms";
        version = "0.1.0.0";
        sha256 = "1izd7gc9xdrs7a1wbzmhhkv8s9rw2mcq77agvr351dc5jyzdnwiy";
+       revision = "1";
+       editedCabalFile = "0a37gmm0xgjzh05i7ix3nkgr5d2qa824nsh2wg78ikyksfq46vfv";
        libraryHaskellDepends = [ base integer-gmp ];
        testHaskellDepends = [
          base integer-gmp QuickCheck test-framework
···
        description = "Basic versioning library";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "olwrapper" = callPackage
···
        ];
        description = "Data encoding and decoding command line utilities";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "omnifmt" = callPackage
···
        description = "Haskell Bindings for the AtomSpace";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {atomspace-cwrapper = null;};
 
   "opencv" = callPackage
···
        description = "Fetch exchange rates from OpenExchangeRates.org";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "openexr-write" = callPackage
···
        description = "OpenFlow";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "opengl-dlp-stereo" = callPackage
···
        description = "Implementation of the OpenPGP message format";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "openpgp-Crypto" = callPackage
···
        description = "Client library for PagerDuty Integration and REST APIs";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "pagerduty-hs" = callPackage
···
        executableHaskellDepends = [ base ];
        description = "Colorization of text for command-line output";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "pairing" = callPackage
···
        ];
        description = "Parsec combinators for parsing Haskell numeric types";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "parsec-parsers" = callPackage
···
        libraryHaskellDepends = [ base network-uri ];
        description = "Datatype for passing around unresolved URIs";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "partly" = callPackage
···
        ];
        description = "Library for representing and manipulating type-safe file paths";
        license = lib.licenses.bsd3;
+       maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
   "pathtype" = callPackage
···
          happstack-server-tls hdaemonize hsyslog iptables-helpers mtl
        description = "Greatest convex majorants and least concave minorants";
        license = lib.licenses.gpl3Plus;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "pava_0_1_1_2" = callPackage
···
        description = "Greatest convex majorants and least concave minorants";
        license = lib.licenses.gpl3Plus;
        hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "paymill" = callPackage
···
        libraryHaskellDepends = [ base ];
        description = "Peano numbers";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "peano-inf" = callPackage
···
        description = "Phonenumber Metadata - NOTE: this is now deprecated!";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "phone-numbers" = callPackage
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-properties-array";
-       version = "0.8.1.0";
-       sha256 = "1v2kyb631kf71j71gz0gmvzmmdhzby769gax4fr8p5yng4nabmxg";
+       version = "0.9.0.0";
+       sha256 = "01km8jaagffrqlg22apnb90dx9sykpcmjdby9w9g4q8w935ppzw6";
        libraryHaskellDepends = [
          base phonetic-languages-rhythmicity
          phonetic-languages-simplified-base ukrainian-phonetics-basic-array
···
        libraryHaskellDepends = [ base containers ];
        description = "Implementation of the PKTree spatial index data structure";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "place-cursor-at" = callPackage
···
        description = "Plivo API wrapper for Haskell";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "plocketed" = callPackage
···
        ];
        description = "Tool for refactoring expressions into pointfree form";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "pointfree-fancy" = callPackage
···
        description = "Polynomial types and operations";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "polynomial" = callPackage
···
        ];
        description = "Higher-order, low-boilerplate free monads";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "polysemy_1_6_0_0" = callPackage
···
        description = "Higher-order, low-boilerplate free monads";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "polysemy-RandomFu" = callPackage
···
        ];
        description = "Polysemy-time Interpreters for Chronos";
        license = "BSD-2-Clause-Patent";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-conc" = callPackage
···
        ];
        description = "Polysemy Effects for Concurrency";
        license = "BSD-2-Clause-Patent";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-extra" = callPackage
···
        ];
        description = "Extra Input and Output functions for polysemy";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-fs" = callPackage
···
        ];
        description = "Low level filesystem operations for polysemy";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-fskvstore" = callPackage
···
        ];
        description = "Run a KVStore as a filesystem in polysemy";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-http" = callPackage
···
        ];
        description = "Effect for a set of stateful values indexed by a type of keys";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-kvstore" = callPackage
···
        libraryHaskellDepends = [ base containers polysemy ];
        description = "KVStore effect for polysemy";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-kvstore-jsonfile" = callPackage
···
        ];
        description = "Run a KVStore as a single json file in polysemy";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-log" = callPackage
···
        ];
        description = "Polysemy Effects for Logging";
        license = "BSD-2-Clause-Patent";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-log-co" = callPackage
···
        ];
        description = "Di Adapters for Polysemy-Log";
        license = "BSD-2-Clause-Patent";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-methodology" = callPackage
···
        ];
        description = "Domain modelling algebra for polysemy";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-methodology-co-log" = callPackage
···
        ];
        description = "Functions for using polysemy-methodology with composite";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-mocks" = callPackage
···
        testToolDepends = [ hspec-discover ];
        description = "Mocking framework for polysemy effects";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-optics" = callPackage
···
        libraryHaskellDepends = [ base path polysemy polysemy-extra ];
        description = "Polysemy versions of Path functions";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-plugin" = callPackage
···
        description = "Disambiguate obvious uses of effects";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "polysemy-plugin_0_4_0_0" = callPackage
···
        description = "Disambiguate obvious uses of effects";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "polysemy-readline" = callPackage
···
        libraryHaskellDepends = [ base polysemy req ];
        description = "Polysemy effect for req";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-resume" = callPackage
···
      }:
      mkDerivation {
        pname = "polysemy-resume";
-       version = "0.1.0.4";
-       sha256 = "0z7d40vimdl5dr05cxr9c88fayg6cx2km537z81c67sxdv79mgzp";
+       version = "0.2.0.0";
+       sha256 = "08m9h9yfi0wasyaxjs27km41q648p8qna8imc4dhcp75q6bwc65g";
        libraryHaskellDepends = [ base polysemy relude transformers ];
        testHaskellDepends = [
-         base hedgehog polysemy polysemy-plugin polysemy-test relude tasty
-         tasty-hedgehog text transformers
+         base hedgehog polysemy polysemy-plugin polysemy-test tasty
+         tasty-hedgehog text
        ];
        description = "Polysemy error tracking";
        license = "BSD-2-Clause-Patent";
···
        libraryHaskellDepends = [ base polysemy ];
        description = "Run several effects at once, taken from the polysemy-zoo";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-socket" = callPackage
···
        libraryHaskellDepends = [ base bytestring polysemy socket ];
        description = "Socket effect for polysemy";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-test" = callPackage
···
        ];
        description = "Polysemy effects for testing";
        license = "BSD-2-Clause-Patent";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-time" = callPackage
···
        ];
        description = "Polysemy Effect for Time";
        license = "BSD-2-Clause-Patent";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-uncontrolled" = callPackage
···
        libraryHaskellDepends = [ base polysemy polysemy-methodology ];
        description = "Uncontrolled toy effect for polysemy";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-video" = callPackage
···
        ];
        description = "Experimental video processing DSL for polysemy";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-vinyl" = callPackage
···
        ];
        description = "Functions for mapping vinyl records in polysemy";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-webserver" = callPackage
···
        ];
        description = "XEPs implementation on top of pontarius-xmpp";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "pontarius-xpmn" = callPackage
···
        description = "Extended Personal Media Network (XPMN) library";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "pony" = callPackage
···
        librarySystemDepends = [ portaudio ];
        description = "Haskell bindings for the PortAudio library";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) portaudio;};
 
   "porte" = callPackage
···
        libraryHaskellDepends = [ base directory process ];
        description = "Library to interact with port tools on FreeBSD";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "poseidon" = callPackage
···
        libraryHaskellDepends = [ base transformers unix ];
        description = "Nice wrapper around POSIX fcntl advisory locks";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "posix-paths" = callPackage
···
        benchmarkHaskellDepends = [ base vector ];
        description = "Mid-Level PostgreSQL client library";
        license = lib.licenses.bsd3;
+       maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
   "postgresql-simple-bind" = callPackage
···
        description = "Diff Cabal packages";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "precursor" = callPackage
···
        description = "Fast, lightweight YAML loader and dumper";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "pugs-compat" = callPackage
···
        description = "Qt bindings";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {qtc_core = null; qtc_gui = null; qtc_network = null; 
          qtc_opengl = null; qtc_script = null; qtc_tools = null;};
 
···
        description = "Picklers for de/serialising Generic data types to and from query strings";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "questioner" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "random_1_2_1" = callPackage
+    ({ mkDerivation, base, bytestring, containers, deepseq, doctest
+     , mtl, primitive, rdtsc, smallcheck, split, splitmix, stm, tasty
+     , tasty-bench, tasty-hunit, tasty-inspection-testing
+     , tasty-smallcheck, time, transformers
+     }:
+     mkDerivation {
+       pname = "random";
+       version = "1.2.1";
+       sha256 = "0mqlcr9l9wh3q4rykv6yqdsd9jj88imp0zm8wv6m7jpjqn7pcp16";
+       libraryHaskellDepends = [ base bytestring deepseq mtl splitmix ];
+       testHaskellDepends = [
+         base bytestring containers doctest smallcheck stm tasty tasty-hunit
+         tasty-inspection-testing tasty-smallcheck transformers
+       ];
+       benchmarkHaskellDepends = [
+         base mtl primitive rdtsc split splitmix tasty-bench time
+       ];
+       description = "Pseudo-random number generation";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "random-access-file" = callPackage
     ({ mkDerivation, base, bytestring, concurrent-extra, containers
      , criterion, directory, lrucaching, mwc-random, random, stm, unix
···
        pname = "relation";
        version = "0.5.2.0";
        sha256 = "1sinb0rw2jq1xjy80rsxnjf5va33n2i67km55hxfls9w15wsg2yw";
-       revision = "1";
-       editedCabalFile = "18nh56qp1cjpg28sagwiy4h44v5dvm5rhm3wqyyz4mw3k78x71kh";
+       revision = "2";
+       editedCabalFile = "1af9snfvk46h4gqxs688wyhlc85b753prfmbqyldfbhsjg61jap5";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [
          base containers doctest doctest-discover hedgehog hspec
···
        description = "Define compound types that do not depend on member order";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "repa" = callPackage
···
        testHaskellDepends = [ base bytestring Cabal megaparsec text ];
        description = "Find, replace, and split string patterns with Megaparsec parsers (instead of regex)";
        license = lib.licenses.bsd2;
+       maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
   "replica" = callPackage
···
        description = "A monad transformer for resumable exceptions";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "rethinkdb" = callPackage
···
        description = "A Haskell client for the Riak decentralized data store";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "riak-protobuf" = callPackage
···
        libraryHaskellDepends = [ base proto-lens proto-lens-runtime ];
        description = "Haskell types for the Riak protocol buffer API";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "riak-protobuf-lens" = callPackage
···
        description = "Lenses for riak-protobuf";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "rib" = callPackage
···
        ];
        description = "Sci-fi roguelike game. Client application.";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "roguestar-engine" = callPackage
···
        testHaskellDepends = [ base QuickCheck safe ];
        description = "Range set";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "rspp" = callPackage
···
        libraryHaskellDepends = [ base ];
        description = "dynamic linker tools for Haskell";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "rtlsdr" = callPackage
···
        description = "Process management and supervision daemon";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "scuttlebutt-types" = callPackage
···
        description = "Small web framework using Warp and WAI";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "seakale" = callPackage
···
      }:
      mkDerivation {
        pname = "sexpresso";
-       version = "1.1.0.0";
-       sha256 = "0y08m020bs1133b6jh6lb20bpa1kpd1ib0b51vdpf9n2pzpqy3jr";
+       version = "1.2.0.0";
+       sha256 = "1q1b1kzc4578drz92r666gl2l02pn4zdbbbnjcwwkklccslb3zcd";
        libraryHaskellDepends = [
          base bifunctors containers megaparsec recursion-schemes text
        ];
···
        description = "A flexible library for parsing and printing S-expression";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "sext" = callPackage
···
        librarySystemDepends = [ libsndfile openal ];
        description = "minimal bindings to the audio module of sfml";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) libsndfile; inherit (pkgs) openal;};
 
   "sfmt" = callPackage
···
        description = "Functional GPU programming - DSEL & compiler";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "shady-graphics" = callPackage
···
        testHaskellDepends = [ base tasty ];
        description = "Utility functions for using shh";
        license = lib.licenses.bsd3;
+       maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
   "shift" = callPackage
···
        description = "Forms that configure themselves based on type";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "simple-genetic-algorithm" = callPackage
···
        license = lib.licenses.gpl2Only;
      }) {};
 
-  "skylighting_0_11" = callPackage
+  "skylighting_0_12" = callPackage
     ({ mkDerivation, base, binary, blaze-html, bytestring, containers
      , pretty-show, skylighting-core, text
      }:
      mkDerivation {
        pname = "skylighting";
-       version = "0.11";
-       sha256 = "12m119j65yngryrx23jiz6c86wihqp47ysv0wnmqfgc6cbv0k97r";
+       version = "0.12";
+       sha256 = "1hd3ryv9g5cp0l9jrdmav7vkhx5hqdx830bx0xixfikqzigdsg3y";
        configureFlags = [ "-fexecutable" ];
        isLibrary = true;
        isExecutable = true;
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "skylighting-core_0_11" = callPackage
+  "skylighting-core_0_12" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, attoparsec, base
      , base64-bytestring, binary, blaze-html, bytestring
      , case-insensitive, colour, containers, criterion, Diff, directory
···
      }:
      mkDerivation {
        pname = "skylighting-core";
-       version = "0.11";
-       sha256 = "1pgi0xfwbvgpgdcka3z3zl1hg1y4n3s2r9561gzclydyldb2jxc3";
+       version = "0.12";
+       sha256 = "15ph640qrx4l31h8wa80yivgvsabm92clkk2fba4zr032dxg7d0f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        executableHaskellDepends = [ base ];
        description = "Handle molecular sequences";
        license = lib.licenses.gpl3Plus;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "slynx_0_6_1_0" = callPackage
···
        description = "Handle molecular sequences";
        license = lib.licenses.gpl3Plus;
        hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "small-bytearray-builder" = callPackage
···
        description = "Declarative routing for Snap";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "snap-routes" = callPackage
···
        libraryHaskellDepends = [ base ];
        description = "Numerical statistics for Foldable containers";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "staged-gg" = callPackage
···
        libraryHaskellDepends = [ base ];
        description = "the * -> * types, operators, and covariant instances";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "star-to-star-contra" = callPackage
···
        libraryHaskellDepends = [ base star-to-star ];
        description = "contravariant instances for * -> * types and operators";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "starling" = callPackage
···
        librarySystemDepends = [ libstatgrab ];
        description = "Collect system level metrics and statistics";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) libstatgrab;};
 
   "static" = callPackage
···
        libraryPkgconfigDepends = [ librsvg ];
        description = "Binding to the libsvg-cairo library";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs) librsvg;};
 
   "svgone" = callPackage
···
        testHaskellDepends = [ aeson base bytestring tasty tasty-hunit ];
        description = "Implementation of swagger data model";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "swagger-petstore" = callPackage
···
        testToolDepends = [ sydtest-discover ];
        description = "A modern testing framework for Haskell with good defaults and advanced testing features";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sydtest_0_4_0_0" = callPackage
···
        description = "An aeson companion library for sydtest";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "sydtest-amqp" = callPackage
···
        executableHaskellDepends = [ base ];
        description = "Automatic test suite discovery for sydtest";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sydtest-hedis" = callPackage
···
        description = "An hedis companion library for sydtest";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "sydtest-hspec" = callPackage
···
        testToolDepends = [ sydtest-discover ];
        description = "An Hspec companion library for sydtest";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sydtest-mongo" = callPackage
···
        description = "An mongoDB companion library for sydtest";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "sydtest-persistent" = callPackage
···
        testToolDepends = [ sydtest-discover ];
        description = "A persistent companion library for sydtest";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sydtest-persistent-postgresql" = callPackage
···
        description = "An persistent-postgresql companion library for sydtest";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "sydtest-persistent-sqlite" = callPackage
···
        testToolDepends = [ sydtest-discover ];
        description = "A persistent-sqlite companion library for sydtest";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sydtest-persistent-sqlite_0_2_0_0" = callPackage
···
        testToolDepends = [ sydtest-discover ];
        description = "A typed-process companion library for sydtest";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sydtest-rabbitmq" = callPackage
···
        description = "An rabbitmq companion library for sydtest";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "sydtest-servant" = callPackage
···
        testToolDepends = [ sydtest-discover ];
        description = "A servant companion library for sydtest";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sydtest-servant_0_2_0_0" = callPackage
···
        testToolDepends = [ sydtest-discover ];
        description = "A typed-process companion library for sydtest";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sydtest-wai" = callPackage
···
        testToolDepends = [ sydtest-discover ];
        description = "A wai companion library for sydtest";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sydtest-wai_0_2_0_0" = callPackage
···
        description = "A yesod companion library for sydtest";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "sydtest-yesod_0_3_0_0" = callPackage
···
        description = "A yesod companion library for sydtest";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "syfco" = callPackage
···
        libraryHaskellDepends = [ base safe text ];
        description = "Table layout";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "table" = callPackage
···
        ];
        description = "Pretty-printing of CSV files";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "tabloid" = callPackage
···
        description = "Small test package";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "testbench" = callPackage
···
        executableHaskellDepends = [ base ];
        description = "Handle phylogenetic trees";
        license = lib.licenses.gpl3Plus;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "tlynx_0_6_1_0" = callPackage
···
        description = "Handle phylogenetic trees";
        license = lib.licenses.gpl3Plus;
        hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
   "tmapchan" = callPackage
···
        libraryHaskellDepends = [ attoparsec base bytestring utf8-string ];
        description = "Library for encoding/decoding TNET strings for PGI";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "to" = callPackage
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "trust-chain" = callPackage
+    ({ mkDerivation, base, binary, bytestring, containers, cropty
+     , merge, network, text
+     }:
+     mkDerivation {
+       pname = "trust-chain";
+       version = "0.1.3.0";
+       sha256 = "0ff5ppmq3c5291y9ir3yybbsabpwcy3av7p7xl6mwzzzpw6zbknl";
+       libraryHaskellDepends = [
+         base binary bytestring containers cropty merge network text
+       ];
+       testHaskellDepends = [ base binary containers cropty merge text ];
+       description = "An implementation of a trust chain";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "truthful" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        description = "-";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "tslogger" = callPackage
···
        description = "Simulator of twisty puzzles à la Rubik's Cube";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "twitch" = callPackage
···
        preConfigure = "export TZDIR=${pkgs.tzdata}/share/zoneinfo";
        description = "Efficient time zone handling";
        license = lib.licenses.asl20;
+       maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
   "tzdata" = callPackage
···
        description = "A simplistic dependently-typed language with parametricity";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "ua-parser" = callPackage
···
        ];
        description = "IO without any non-error, synchronous exceptions";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "unexceptionalio-trans" = callPackage
···
        libraryHaskellDepends = [ base transformers unexceptionalio ];
        description = "A wrapper around UnexceptionalIO using monad transformers";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "unfix-binders" = callPackage
···
        executableHaskellDepends = [ base ports-tools process ];
        description = "Software management tool";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "update-monad" = callPackage
···
        executableHaskellDepends = [ base process ];
        description = "A debugger for the UUAG system";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "uuid" = callPackage
···
        ];
        description = "Helpers to bind digestive-functors onto wai requests";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "wai-dispatch" = callPackage
···
        ];
        description = "WAI request predicates";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "wai-rate-limit" = callPackage
···
        ];
        description = "Flexible session middleware for WAI";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "wai-session-alt" = callPackage
···
        ];
        description = "Session store based on clientsession";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "wai-session-mysql" = callPackage
···
        ];
        description = "Collection of utility functions for use with WAI";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "wai-websockets" = callPackage
···
        executableHaskellDepends = [ base optparse-generic ];
        description = "representations of a web page";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "web-routes" = callPackage
···
   "webkitgtk3" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, cairo, glib
      , gtk2hs-buildtools, gtk3, mtl, pango, text, transformers
-     , webkitgtk24x-gtk3
+     , webkitgtk
      }:
      mkDerivation {
        pname = "webkitgtk3";
···
        libraryHaskellDepends = [
          base bytestring cairo glib gtk3 mtl pango text transformers
        ];
-       libraryPkgconfigDepends = [ webkitgtk24x-gtk3 ];
+       libraryPkgconfigDepends = [ webkitgtk ];
        libraryToolDepends = [ gtk2hs-buildtools ];
        description = "Binding to the Webkit library";
        license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
-     }) {inherit (pkgs) webkitgtk24x-gtk3;};
+     }) {inherit (pkgs) webkitgtk;};
 
   "webkitgtk3-javascriptcore" = callPackage
-    ({ mkDerivation, base, Cabal, gtk2hs-buildtools, webkitgtk24x-gtk3
-     }:
+    ({ mkDerivation, base, Cabal, gtk2hs-buildtools, webkitgtk }:
      mkDerivation {
        pname = "webkitgtk3-javascriptcore";
        version = "0.14.2.1";
        sha256 = "0kcjrka0c9ifq3zfhmkv05wy3xb7v0cyznfxldp2gjcn1haq084j";
        setupHaskellDepends = [ base Cabal gtk2hs-buildtools ];
        libraryHaskellDepends = [ base ];
-       libraryPkgconfigDepends = [ webkitgtk24x-gtk3 ];
+       libraryPkgconfigDepends = [ webkitgtk ];
        description = "JavaScriptCore FFI from webkitgtk";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
-     }) {inherit (pkgs) webkitgtk24x-gtk3;};
+     }) {inherit (pkgs) webkitgtk;};
 
   "webmention" = callPackage
     ({ mkDerivation, base, bytestring, case-insensitive, either
···
        description = "Wedged postcard generator";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "weeder" = callPackage
···
        ];
        description = "Detect dead code";
        license = lib.licenses.bsd3;
+       maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
   "weekdaze" = callPackage
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "wrapped";
-       version = "0.1.0.0";
-       sha256 = "07xvml89ml36qx23114qr72sk1kqfpj3dassfs5mwhaw45016rk2";
+       version = "0.1.0.1";
+       sha256 = "00fvammhn4dlna5d1dc8lpwrdrigj9cnlyi8scwslibr6bjsjzfp";
        libraryHaskellDepends = [ base ];
        description = "Provides a single standardized place to hang DerivingVia instances";
        license = lib.licenses.asl20;
···
     ({ mkDerivation, base, data-default-class, wrapped }:
      mkDerivation {
        pname = "wrapped-generic-default";
-       version = "0.1.0.0";
-       sha256 = "0h1aay81l8b2nih08pli30ly0vcwvi8n2kdxck60ww2qb2b7wzzc";
-       revision = "1";
-       editedCabalFile = "03wvdf76ddn4xsyc94ya3hycl7isi18lbbn0lsigicas7nhbc2sl";
+       version = "0.1.0.1";
+       sha256 = "10hbz8m98cw8lr2xj0wkc017pnypagb11ss1ihpp6lnc4w1hpj3f";
        libraryHaskellDepends = [ base data-default-class wrapped ];
        description = "Provides an orphan instance Default (Wrapped Generic a)";
        license = lib.licenses.asl20;
···
        ];
        description = "A cffi-based python binding for X";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "xchat-plugin" = callPackage
···
        description = "Streaming XML parser based on conduits";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "xml-conduit-selectors" = callPackage
···
        license = lib.licenses.bsd2;
      }) {};
 
+  "xss-sanitize_0_3_7" = callPackage
+    ({ mkDerivation, attoparsec, base, containers, css-text, hspec
+     , HUnit, network-uri, tagsoup, text, utf8-string
+     }:
+     mkDerivation {
+       pname = "xss-sanitize";
+       version = "0.3.7";
+       sha256 = "1wnzx5nv8p4ppphcvjp6x8wna0kpw9jn85gn1qbhjqhrl5nqy1vw";
+       libraryHaskellDepends = [
+         attoparsec base containers css-text network-uri tagsoup text
+         utf8-string
+       ];
+       testHaskellDepends = [
+         attoparsec base containers css-text hspec HUnit network-uri tagsoup
+         text utf8-string
+       ];
+       description = "sanitize untrusted HTML to prevent XSS attacks";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "xtc" = callPackage
     ({ mkDerivation, base, wx, wxcore }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "yaml_0_11_6_0" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, base-compat, bytestring
+     , conduit, containers, directory, filepath, hspec, HUnit, libyaml
+     , mockery, mtl, raw-strings-qq, resourcet, scientific
+     , template-haskell, temporary, text, transformers
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "yaml";
+       version = "0.11.6.0";
+       sha256 = "0hxg9mfi1dn9a7kp3imzfvnk7jj4sdjdxi6xyqz9ra7lqg14np3r";
+       configureFlags = [ "-fsystem-libyaml" ];
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson attoparsec base bytestring conduit containers directory
+         filepath libyaml mtl resourcet scientific template-haskell text
+         transformers unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson attoparsec base base-compat bytestring conduit containers
+         directory filepath hspec HUnit libyaml mockery mtl raw-strings-qq
+         resourcet scientific template-haskell temporary text transformers
+         unordered-containers vector
+       ];
+       description = "Support for parsing and rendering YAML documents";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "yaml-combinators" = callPackage
     ({ mkDerivation, aeson, base, bytestring, doctest, generics-sop
      , scientific, tasty, tasty-hunit, text, transformers
···
        description = "Compares the keys from two yaml files";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "yamlparse-applicative" = callPackage
···
        description = "Grids defined by layout hints and implemented on top of Yahoo grids";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "yuuko" = callPackage
···
        description = "A socat-like tool for zeromq library";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "zoneinfo" = callPackage

pkgs/development/interpreters/clojure/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "clojure";
-  version = "1.10.3.943";
+  version = "1.10.3.986";
 
   src = fetchurl {
     # https://clojure.org/releases/tools
     url = "https://download.clojure.org/install/clojure-tools-${version}.tar.gz";
-    sha256 = "sha256-w3DRvZsie22uoJMrNQTxN5hW0pIFjH5zAw5Z41I1M/s=";
+    sha256 = "1xhfp186mk9h3jdl9bpkigqrrrgdhgij7ba65j6783nh11llpa3x";
   };
 
   nativeBuildInputs = [

pkgs/development/libraries/gdome2/default.nix

···
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [ glib libxml2 gtk-doc ];
   propagatedBuildInputs = [glib libxml2];
-  patches = [ ./xml-document.patch ];
+  patches = [
+    ./xml-document.patch
+    ./fno-common.patch
+  ];
 
   meta = with lib; {
     homepage = "http://gdome2.cs.unibo.it/";

pkgs/development/libraries/gdome2/fno-common.patch

···
+On gcc-10 -fno-common is the default which forbids miltiple definitions.
+--- a/libgdome/xpath/gdome-xpath-xpnsresolv.h
++++ b/libgdome/xpath/gdome-xpath-xpnsresolv.h
+@@ -42,6 +42,6 @@ void gdome_xpath_xpnsresolv_ref (GdomeXPathNSResolver *self, GdomeException *exc
+ void gdome_xpath_xpnsresolv_unref (GdomeXPathNSResolver *self, GdomeException *exc);
+ GdomeDOMString * gdome_xpath_xpnsresolv_lookupNamespaceURI( GdomeXPathNSResolver *self, GdomeDOMString *prefix, GdomeException *exc);
+ 
+-const GdomeXPathNSResolverVtab gdome_xpath_xpnsresolv_vtab;
++extern const GdomeXPathNSResolverVtab gdome_xpath_xpnsresolv_vtab;
+ 
+ #endif /* GDOME_XPNSRESOLV_FILE */

pkgs/development/libraries/hunspell/dictionaries.nix

···
     meta = with lib; {
       description = "Hunspell dictionary for Dutch (Netherlands) from OpenTaal";
       homepage = "https://www.opentaal.org/";
-      license = with licenses; [ bsd3 cc-by-nc-30 ];
+      license = with licenses; [ bsd3 ]; # and/or cc-by-nc-30
       maintainers = with maintainers; [ artturin ];
     };
   };

pkgs/development/libraries/libspng/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "libspng";
-  version = "0.7.0-rc3";
+  version = "0.7.0";
 
   src = fetchFromGitHub {
     owner = "randy408";
     repo = pname;
     rev = "v${version}";
-    sha256 = "0n91mr06sr34cqq91738251iaw21h5c4jgjpn0kqfx69ywxcl9fj";
+    sha256 = "0zk0w09is4g7gysax4h0f4xj5f40vm6ipc1wi98ymzban89cjjnz";
   };
 
   doCheck = true;

pkgs/development/libraries/qtstyleplugin-kvantum/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "qtstyleplugin-kvantum";
-  version = "0.20.1";
+  version = "0.20.2";
 
   src = fetchFromGitHub {
     owner = "tsujan";
     repo = "Kvantum";
     rev = "V${version}";
-    sha256 = "0rj7zfm2h6812ga1xypism8a48jj669nh10jmhpf2mjriyaar3di";
+    sha256 = "145wm8c5v56djmvgjhksmywx6ak81vhxyg6yy3jj7wlvcan4p238";
   };
 
   nativeBuildInputs = [

pkgs/development/misc/h3/default.nix

···
-{ lib, stdenv
+{ lib
+, stdenv
 , cmake
 , fetchFromGitHub
 }:
···
   ];
 
   meta = with lib; {
-    homepage = "https://github.com/uber/h3";
+    homepage = "https://h3geo.org/";
     description = "Hexagonal hierarchical geospatial indexing system";
     license = licenses.asl20;
+    changelog = "https://github.com/uber/h3/raw/v${version}/CHANGELOG.md";
+    platforms = platforms.all;
     maintainers = [ maintainers.kalbasit ];
   };
 }

pkgs/development/misc/haskell/hasura/graphql-engine.nix

···
 { mkDerivation, aeson, aeson-casing, ansi-wl-pprint, asn1-encoding
 , asn1-types, async, attoparsec, attoparsec-iso8601, auto-update
 , base, base16-bytestring, base64-bytestring, binary, byteorder
-, bytestring, case-insensitive, ci-info, containers, cron
-, cryptonite, data-has, deepseq, dependent-map, dependent-sum
-, directory, ekg-core, ekg-json, exceptions, fast-logger, fetchgit
-, file-embed, filepath, ghc-heap-view, graphql-parser, hashable
-, hashable-time, hspec, hspec-core, hspec-expectations
-, hspec-expectations-lifted, http-api-data, http-client
-, http-client-tls, http-conduit, http-types, immortal
-, insert-ordered-containers, jose, kan-extensions, lens, lens-aeson
-, lib, lifted-async, lifted-base, list-t, memory, mime-types
-, mmorph, monad-control, monad-loops, monad-validate, mtl, mustache
-, mysql, mysql-simple, natural-transformation, network, network-uri
-, odbc, optparse-applicative, pem, pg-client, postgresql-binary
+, bytestring, case-insensitive, ci-info, connection, containers
+, cron, cryptonite, data-default-class, data-has, deepseq
+, dependent-map, dependent-sum, directory, ekg-core, ekg-json
+, exceptions, fast-logger, fetchgit, file-embed, filepath
+, ghc-heap-view, graphql-parser, hashable, hashable-time, hspec
+, hspec-core, hspec-expectations, hspec-expectations-lifted
+, http-api-data, http-client, http-client-tls, http-conduit
+, http-types, immortal, insert-ordered-containers, jose
+, kan-extensions, lens, lens-aeson, lib, lifted-async, lifted-base
+, list-t, memory, mime-types, mmorph, monad-control, monad-loops
+, monad-validate, mtl, mustache, mysql, mysql-simple
+, natural-transformation, network, network-uri, odbc
+, optparse-applicative, pem, pg-client, postgresql-binary
 , postgresql-libpq, pretty-simple, process, profunctors, psqueues
 , QuickCheck, quickcheck-instances, random, regex-tdfa
 , resource-pool, retry, safe, safe-exceptions, scientific
 , semialign, semigroups, semver, shakespeare, some, split
 , Spock-core, stm, stm-containers, tagged, template-haskell, text
-, text-builder, text-conversions, these, time, transformers
+, text-builder, text-conversions, these, time, tls, transformers
 , transformers-base, unix, unordered-containers, uri-encode
 , utf8-string, uuid, validation, vector, vector-instances, wai
-, warp, websockets, wreq, x509, x509-store, yaml, zlib
+, warp, websockets, wreq, x509, x509-store, x509-system
+, x509-validation, yaml, zlib
 }:
 mkDerivation {
   pname = "graphql-engine";
   version = "1.0.0";
   src = fetchgit {
     url = "https://github.com/hasura/graphql-engine.git";
-    sha256 = "04s8rczvm0l5dbh14g2vav2wbqb4fg51471fncqf36s59img14b7";
-    rev = "cf6f3edc1f6df7843dfb91be6dcb0fd7cc94d133";
+    sha256 = "0ky23f700pmzb6anx44xzh6dixixmn7kq1ypj0yy4kqiqzqdb2dg";
+    rev = "7c35ffb36561214390d0d545d418746f29a29ba4";
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/server; echo source root reset to $sourceRoot";
···
     aeson aeson-casing ansi-wl-pprint asn1-encoding asn1-types async
     attoparsec attoparsec-iso8601 auto-update base base16-bytestring
     base64-bytestring binary byteorder bytestring case-insensitive
-    ci-info containers cron cryptonite data-has deepseq dependent-map
-    dependent-sum directory ekg-core ekg-json exceptions fast-logger
-    file-embed filepath ghc-heap-view graphql-parser hashable
-    hashable-time http-api-data http-client http-client-tls
-    http-conduit http-types immortal insert-ordered-containers jose
-    kan-extensions lens lens-aeson lifted-async lifted-base list-t
-    memory mime-types mmorph monad-control monad-loops monad-validate
-    mtl mustache mysql mysql-simple network network-uri odbc
-    optparse-applicative pem pg-client postgresql-binary
-    postgresql-libpq pretty-simple process profunctors psqueues
-    QuickCheck quickcheck-instances random regex-tdfa resource-pool
-    retry safe-exceptions scientific semialign semigroups semver
-    shakespeare some split Spock-core stm stm-containers tagged
-    template-haskell text text-builder text-conversions these time
-    transformers transformers-base unix unordered-containers uri-encode
-    utf8-string uuid validation vector vector-instances wai warp
-    websockets wreq x509 x509-store yaml zlib
+    ci-info connection containers cron cryptonite data-default-class
+    data-has deepseq dependent-map dependent-sum directory ekg-core
+    ekg-json exceptions fast-logger file-embed filepath ghc-heap-view
+    graphql-parser hashable hashable-time http-api-data http-client
+    http-client-tls http-conduit http-types immortal
+    insert-ordered-containers jose kan-extensions lens lens-aeson
+    lifted-async lifted-base list-t memory mime-types mmorph
+    monad-control monad-loops monad-validate mtl mustache mysql
+    mysql-simple network network-uri odbc optparse-applicative pem
+    pg-client postgresql-binary postgresql-libpq pretty-simple process
+    profunctors psqueues QuickCheck quickcheck-instances random
+    regex-tdfa resource-pool retry safe-exceptions scientific semialign
+    semigroups semver shakespeare some split Spock-core stm
+    stm-containers tagged template-haskell text text-builder
+    text-conversions these time tls transformers transformers-base unix
+    unordered-containers uri-encode utf8-string uuid validation vector
+    vector-instances wai warp websockets wreq x509 x509-store
+    x509-system x509-validation yaml zlib
   ];
   executableHaskellDepends = [
     base bytestring ekg-core kan-extensions pg-client text

pkgs/development/misc/haskell/hasura/graphql-parser.nix

···
   version = "0.2.0.0";
   src = fetchgit {
     url = "https://github.com/hasura/graphql-parser-hs.git";
-    sha256 = "015b1h475k8wmhm9hkrvyxr985x7d8yc0xgcdqj7vmziixvfwwwj";
-    rev = "79beb0e85e00422a8a15318c0bc573765fc7b246";
+    sha256 = "0zqrh7y0cjjrscsw2hmyhdcm4nzvb5pw394pcxk8q19xx13jp9xd";
+    rev = "43562a5b7b41d380e3e31732b48637702e5aa97d";
     fetchSubmodules = true;
   };
   libraryHaskellDepends = [

pkgs/development/misc/haskell/hasura/pg-client.nix

···
   version = "0.1.0";
   src = fetchgit {
     url = "https://github.com/hasura/pg-client-hs.git";
-    sha256 = "1y79s3ai4h82szpm1j5n5ygybqr7cza9l0raxf39vgn66jhy1jd2";
-    rev = "92975d0f8f933c8d06913dc97af259253bf7fb5f";
+    sha256 = "00h9hskv3p4mg35php5wsr2d2rjahcv29rqidb2lxl11r05psr4m";
+    rev = "5e8a2d7ebe8b96518e5a70f4d61be2550eaa4e70";
     fetchSubmodules = true;
   };
   setupHaskellDepends = [ base Cabal ];

pkgs/development/misc/haskell/hasura/pool.nix

···
   version = "0.2.3.2";
   src = fetchgit {
     url = "https://github.com/hasura/pool.git";
-    sha256 = "00q1fxh72fgjwl1pi3lnp4xg8f3kfm6q12gs9scinwbymfgzarms";
-    rev = "bc4c3f739a8fb8ec4444336a34662895831c9acf";
+    sha256 = "02wa32fl5wq5fk59id54xmxiqjl564r4rhsc79xsgf2j2spj0v94";
+    rev = "dc56753338e7b61220a09bed0469c6dcc5e9fb52";
     fetchSubmodules = true;
   };
   libraryHaskellDepends = [

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

···
 { lib
 , buildPythonPackage
 , fetchFromGitHub
+, cchardet
 , chardet
 , cleo
 , clikit
···
 
 buildPythonPackage rec {
   pname = "clevercsv";
-  version = "0.7.0";
+  version = "0.7.1";
   format = "setuptools";
 
   src = fetchFromGitHub {
     owner = "alan-turing-institute";
     repo = "CleverCSV";
     rev = "v${version}";
-    sha256 = "09ccgydnrfdgxjz6ph829l9q62jkzqrak0k6yjik2rvs33jn0dhc";
+    sha256 = "sha256-ynS3G2ZcEqVlC2d6n5ZQ1Em5lh/dWESj9jEO8C4WzZQ=";
   };
 
   propagatedBuildInputs = [
+    cchardet
     chardet
     cleo
     clikit

pkgs/development/python-modules/google-cloud-resource-manager/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-resource-manager";
-  version = "1.1.0";
+  version = "1.1.1";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "a88f21b7a110dc9b5fd8e5bc9c07330fafc9ef150921505250aec0f0b25cf5e8";
+    sha256 = "1d2c86cf6df12b5fc024b8035ca1130d93654ba984f3026eaa5854dd538d7841";
   };
 
   propagatedBuildInputs = [ google-api-core google-cloud-core grpc-google-iam-v1 proto-plus ];

pkgs/development/python-modules/google-cloud-secret-manager/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-secret-manager";
-  version = "2.7.1";
+  version = "2.7.2";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "84ae86a2320425df2e78d981d4ab26bff591ade1b978c18c929188b741a7b37d";
+    sha256 = "6508a260ea273de0ff17d0bf66a3f93009a9b02ace7736486f70a91789c3e34a";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/snowflake-connector-python/default.nix

···
 
 buildPythonPackage rec {
   pname = "snowflake-connector-python";
-  version = "2.6.1";
+  version = "2.6.2";
   disabled = pythonOlder "3.6";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "dbe6f7d84debd27b117e17fdb280be27695cf6ae54009c49495584d1b7776d1b";
+    sha256 = "ce131b1dd059a4d081e78595d618654bf9b9fc184d78352f24512375467257d1";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/transmission-rpc/default.nix

···
 
 buildPythonPackage rec {
   pname = "transmission-rpc";
-  version = "3.2.8";
+  version = "3.3.0";
   disabled = pythonOlder "3.6";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "821eda19809dca7ad50eaf42ed8debb72ec0e3b1f04f63b8b2414a05075c132e";
+    sha256 = "ef3a931fc1f1db74edf8660e475b9295e0904ee922030ef0e45b0c73f4be65ae";
   };
 
   propagatedBuildInputs = [

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

···
+{ lib
+, appdirs
+, buildPythonPackage
+, dnspython
+, fetchPypi
+, filelock
+, idna
+, pytestCheckHook
+, uritools
+}:
+
+buildPythonPackage rec {
+  pname = "urlextract";
+  version = "1.3.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "sha256-yxOuiswFOJnAvxwTT++Zhk8nZWK2f4ePsQpUYI7EYS4=";
+  };
+
+  propagatedBuildInputs = [
+    appdirs
+    filelock
+    idna
+    uritools
+  ];
+
+  checkInputs = [
+    dnspython
+    pytestCheckHook
+  ];
+
+  disabledTests = [
+    # fails with dns.resolver.NoResolverConfiguration due to network sandboxing
+    "test_check_dns_enabled"
+    "test_check_dns_find_urls"
+    "test_dns_cache_init"
+    "test_dns_cache_negative"
+    "test_dns_cache_reuse"
+  ];
+
+  pythonImportsCheck = [ "urlextract" ];
+
+  meta = with lib; {
+    description = "Collects and extracts URLs from given text";
+    homepage = "https://github.com/lipoja/URLExtract";
+    license = licenses.mit;
+    maintainers = with maintainers; [ ilkecan ];
+  };
+}

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

···
 
 buildPythonPackage rec {
   pname = "zodbpickle";
-  version = "2.0.0";
+  version = "2.2.0";
   disabled = isPyPy; # https://github.com/zopefoundation/zodbpickle/issues/10
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "0fb7c7pnz86pcs6qqwlyw72vnijc04ns2h1zfrm0h7yl8q7r7ng0";
+    sha256 = "584127173db0a2647af0fc8cb935130b1594398c611e94fb09a719e09e1ed4bd";
   };
 
   # fails..

pkgs/development/ruby-modules/bundled-common/default.nix

···
   filteredGemset = filterGemset { inherit ruby groups; } importedGemset;
 
   configuredGemset = lib.flip lib.mapAttrs filteredGemset (name: attrs:
-    applyGemConfigs (attrs // { inherit ruby; gemName = name; })
+    applyGemConfigs (attrs // { inherit ruby document; gemName = name; })
   );
 
   hasBundler = builtins.hasAttr "bundler" filteredGemset;

pkgs/development/tools/google-java-format/default.nix

···
+{ lib, stdenv, fetchurl, jre, makeWrapper }:
+
+stdenv.mkDerivation rec {
+  pname = "google-java-format";
+  version = "1.11.0";
+
+  src = fetchurl {
+    url = "https://github.com/google/google-java-format/releases/download/v${version}/google-java-format-${version}-all-deps.jar";
+    sha256 = "1ixpg8ljg819fq94mxyypknmslva3rkifphbnq3ic71b7iip6lia";
+  };
+
+  dontUnpack = true;
+
+  nativeBuildInputs = [ makeWrapper ];
+  buildInputs = [ jre ];
+
+  installPhase = ''
+    runHook preInstall
+
+    mkdir -p $out/{bin,share/google-java-format}
+    install -D ${src} $out/share/google-java-format/google-java-format.jar
+
+    makeWrapper ${jre}/bin/java $out/bin/google-java-format \
+      --add-flags "-jar $out/share/google-java-format/google-java-format.jar"
+
+    runHook postInstall
+  '';
+
+  meta = with lib; {
+    description = "Java source formatter by Google";
+    longDescription = ''
+      A program that reformats Java source code to comply with Google Java Style.
+    '';
+    homepage = "https://github.com/google/google-java-format";
+    license = licenses.asl20;
+    maintainers = [ maintainers.emptyflask ];
+    platforms = platforms.all;
+  };
+}

pkgs/development/tools/img/default.nix

···
+{ buildGoModule
+, fetchFromGitHub
+, lib
+, makeWrapper
+, runc
+, wrapperDir ? "/run/wrappers/bin" # Default for NixOS, other systems might need customization.
+}:
+
+buildGoModule rec {
+  pname = "img";
+  version = "0.5.11";
+
+  src = fetchFromGitHub {
+    owner = "genuinetools";
+    repo = "img";
+    rev = "v${version}";
+    sha256 = "0r5hihzp2679ki9hr3p0f085rafy2hc8kpkdhnd4m5k4iibqib08";
+  };
+
+  vendorSha256 = null;
+
+  postPatch = ''
+    V={newgidmap,newgidmap} \
+      substituteInPlace ./internal/unshare/unshare.c \
+        --replace "/usr/bin/$V" "${wrapperDir}/$V"
+  '';
+
+  nativeBuildInputs = [
+    makeWrapper
+  ];
+
+  tags = [
+    "seccomp"
+    "noembed" # disables embedded `runc`
+  ];
+
+  ldflags = [
+    "-X github.com/genuinetools/img/version.VERSION=v${version}"
+    "-s -w"
+  ];
+
+  postInstall = ''
+    wrapProgram "$out/bin/img" --prefix PATH : ${lib.makeBinPath [ runc ]}
+  '';
+
+  # Tests fail as: internal/binutils/install.go:57:15: undefined: Asset
+  doCheck = false;
+
+  meta = with lib; {
+    description = "Standalone, daemon-less, unprivileged Dockerfile and OCI compatible container image builder. ";
+    license = licenses.mit;
+    homepage = "https://github.com/genuinetools/img";
+    maintainers = with maintainers; [ superherointj ];
+  };
+}

pkgs/development/tools/qtcreator/default.nix

···
 { mkDerivation, lib, fetchurl, fetchgit, fetchpatch
-, qtbase, qtquickcontrols, qtscript, qtdeclarative, qmake, llvmPackages_8
+, qtbase, qtquickcontrols, qtscript, qtdeclarative, qmake, llvmPackages_8, elfutils, perf
 , withDocumentation ? false, withClangPlugins ? true
 }:
 
···
     sha256 = "07i045mzwbfhwj2jlijhz9xs6ay03qs5dgcw2kzlcr79a69i0h6j";
   };
 
-  buildInputs = [ qtbase qtscript qtquickcontrols qtdeclarative ] ++
+  buildInputs = [ qtbase qtscript qtquickcontrols qtdeclarative elfutils.dev ] ++
     optionals withClangPlugins [ llvmPackages_8.libclang
                                  clang_qt_vendor
                                  llvmPackages_8.llvm ];
···
   buildFlags = optional withDocumentation "docs";
 
   installFlags = [ "INSTALL_ROOT=$(out)" ] ++ optional withDocumentation "install_docs";
+
+  qtWrapperArgs = [ "--set-default PERFPROFILER_PARSER_FILEPATH ${lib.getBin perf}/bin" ];
 
   preConfigure = ''
     substituteInPlace src/plugins/plugins.pro \

pkgs/misc/emulators/desmume/default.nix

···
   ];
 
   meta = with lib; {
-    homepage = "http://www.desmume.com";
+    homepage = "https://www.github.com/TASVideos/desmume/";
     description = "An open-source Nintendo DS emulator";
     longDescription = ''
-      DeSmuME is a freeware emulator for the NDS roms & Nintendo DS
-      Lite games created by YopYop156. It supports many homebrew nds
-      rom demoes as well as a handful of Wireless Multiboot demo nds
-      roms. DeSmuME is also able to emulate nearly all of the
+      DeSmuME is a freeware emulator for the NDS roms & Nintendo DS Lite games
+      created by YopYop156 and now maintained by the TASvideos team. It supports
+      many homebrew nds rom demoes as well as a handful of Wireless Multiboot
+      demo nds roms. DeSmuME is also able to emulate nearly all of the
       commercial nds rom titles which other DS Emulators aren't.
     '';
     license = licenses.gpl2Plus;
···
   };
 }
 # TODO: investigate the patches
+# TODO: investigate other platforms

pkgs/servers/hasura/cli.nix

···
 
   subPackages = [ "cmd/hasura" ];
 
-  vendorSha256 = "1pkc9bh5s2vqnpkmnm91zaihh98b3drhiv4lcpi98rhln8r52b1k";
+  vendorSha256 = "0c0zn3a3bq3g13zj1b7hz1gfd9mcc5wlch80vjgp31vgm23vvd8d";
 
   doCheck = false;
 

pkgs/servers/sql/postgresql/ext/timescaledb.nix

···
 
 stdenv.mkDerivation rec {
   pname = "timescaledb";
-  version = "2.4.1";
+  version = "2.4.2";
 
   nativeBuildInputs = [ cmake ];
   buildInputs = [ postgresql openssl libkrb5 ];
···
     owner  = "timescale";
     repo   = "timescaledb";
     rev    = "refs/tags/${version}";
-    sha256 = "0nc6nvngp5skz8rasvb7pyi9nlw642iwk19p17lizmw8swdm5nji";
+    sha256 = "10c5qx8qq7gbs2pq56gn4nadbc8i6r28528hp2nqdg881yaiga3m";
   };
 
   cmakeFlags = [ "-DSEND_TELEMETRY_DEFAULT=OFF" "-DREGRESS_CHECKS=OFF" "-DTAP_CHECKS=OFF" ]

pkgs/servers/teleport/default.nix

···
   webassets = fetchFromGitHub {
     owner = "gravitational";
     repo = "webassets";
-    rev = "2891baa0de7283f61c08ff2fa4494e53f9d4afc1";
-    sha256 = "sha256-AvhCOLa+mgty9METlOCARlUOEDMAW6Kk1esSmBbVcok=";
+    rev = "07493a5e78677de448b0e35bd72bf1dc6498b5ea";
+    sha256 = "sha256-V1vGGC8Q257iQMhxCBEBkZntt0ckppCJMCEr2Nqxo/M=";
   };
 in
 buildGoModule rec {
   pname = "teleport";
-  version = "7.1.3";
+  version = "7.2.0";
 
   # This repo has a private submodule "e" which fetchgit cannot handle without failing.
   src = fetchFromGitHub {
     owner = "gravitational";
     repo = "teleport";
     rev = "v${version}";
-    sha256 = "sha256-upzEfImMuYU/6F5HSR3Jah3QiMXEt0XMpNAPzEYV1Nk=";
+    sha256 = "sha256-JLYma/LB/3xLWaFcIbe32pAz6P8hBiLlMuTUBVfqfsw=";
   };
 
   vendorSha256 = null;

pkgs/tools/archivers/rar/default.nix

···
+{ lib, stdenv, fetchurl, autoPatchelfHook, installShellFiles }:
+
+let
+  version = "6.0.2";
+  # TODO: add support for macOS
+  srcUrl =
+    if stdenv.isi686 then {
+      url = "https://www.rarlab.com/rar/rarlinux-${version}.tar.gz";
+      sha256 = "sha256-5iqK7eOo+hgLtGSCqUoB+wOFZHUqZ0M/8Jf7bxdf9qA=";
+    } else if stdenv.isx86_64 then {
+      url = "https://www.rarlab.com/rar/rarlinux-x64-${version}.tar.gz";
+      sha256 = "sha256-WAvrUGCgfwI51Mo/RYSSF0OLPPrTegUCuDEsnBeR9uQ=";
+    }
+    else throw "Unknown architecture";
+  manSrc = fetchurl {
+    url = "https://aur.archlinux.org/cgit/aur.git/plain/rar.1?h=rar&id=8e39a12e88d8a3b168c496c44c18d443c876dd10";
+    name = "rar.1";
+    sha256 = "sha256-93cSr9oAsi+xHUtMsUvICyHJe66vAImS2tLie7nt8Uw=";
+  };
+in
+stdenv.mkDerivation rec {
+  pname = "rar";
+  inherit version;
+
+  src = fetchurl srcUrl;
+
+  dontBuild = true;
+
+  buildInputs = [ stdenv.cc.cc.lib ];
+
+  nativeBuildInputs = [ autoPatchelfHook installShellFiles ];
+
+  installPhase = ''
+    runHook preInstall
+
+    install -Dm755 {rar,unrar} -t "$out/bin"
+    install -Dm755 default.sfx -t "$out/lib"
+    install -Dm644 {acknow.txt,license.txt} -t "$out/share/doc/rar"
+    install -Dm644 rarfiles.lst -t "$out/etc"
+
+    runHook postInstall
+  '';
+
+  postInstall = ''
+    installManPage ${manSrc}
+  '';
+
+  meta = with lib; {
+    description = "Utility for RAR archives";
+    homepage = "https://www.rarlab.com/";
+    license = licenses.unfree;
+    maintainers = with maintainers; [ thiagokokada ];
+    platforms = platforms.linux;
+  };
+}

pkgs/tools/misc/pspg/default.nix

···
-{ lib, stdenv, fetchFromGitHub, gnugrep, ncurses, pkg-config, readline, postgresql }:
+{ lib, stdenv, fetchFromGitHub, gnugrep, ncurses, pkg-config, installShellFiles, readline, postgresql }:
 
 stdenv.mkDerivation rec {
   pname = "pspg";
···
     sha256 = "sha256-xJ7kgEvIsTufAZa5x3YpElTc74nEs9C+baVjbheHySM=";
   };
 
-  nativeBuildInputs = [ pkg-config ];
+  nativeBuildInputs = [ pkg-config installShellFiles ];
   buildInputs = [ gnugrep ncurses readline postgresql ];
 
   makeFlags = [ "PREFIX=${placeholder "out"}" ];
+
+  postInstall = ''
+    installShellCompletion --bash --name pspg.bash bash-completion.sh
+  '';
 
   meta = with lib; {
     homepage = "https://github.com/okbob/pspg";

pkgs/tools/misc/zellij/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "zellij";
-  version = "0.17.0";
+  version = "0.18.0";
 
   src = fetchFromGitHub {
     owner = "zellij-org";
     repo = "zellij";
     rev = "v${version}";
-    sha256 = "sha256-ZV908Zrvx075TTbrYsw0JdQD+66XRfd7EW48lNZLNik=";
+    sha256 = "sha256-yWDXCEdESRI/ynaBSxHi0lk5SE3i8GC+8OKDc+kgO1U=";
   };
 
-  cargoSha256 = "sha256-Wpg75RU1ANEnxgx28oy1kp4xt3HwIThNjHwmN8CRkjA=";
+  cargoSha256 = "sha256-wmASt5+whRM9rAoy9/uykQJTnxEiVfpJwD4W8/ukdVk=";
 
-  nativeBuildInputs = [ installShellFiles pkg-config ];
+  nativeBuildInputs = [
+    installShellFiles
+    pkg-config
+  ];
 
-  buildInputs = [ openssl ] ++ lib.optionals stdenv.isDarwin [ libiconv ];
+  buildInputs = [
+    openssl
+  ] ++ lib.optionals stdenv.isDarwin [
+    libiconv
+  ];
 
   preCheck = ''
     HOME=$TMPDIR

pkgs/tools/system/btop/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "btop";
-  version = "1.0.9";
+  version = "1.0.10";
 
   src = fetchFromGitHub {
     owner = "aristocratos";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-nZd1ECs47WyVUwR08Lcz6xmVYZJ2Bc2QSzNkI68KUcs=";
+    sha256 = "14d41q9hfwmzhxqrnrz17rgbi03j0xga2jmw8n9y2v21rqxg73y0";
   };
 
   installFlags = [ "PREFIX=$(out)" ];

pkgs/tools/wayland/swayr/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "swayr";
-  version = "0.6.2";
+  version = "0.7.0";
 
   src = fetchFromSourcehut {
     owner = "~tsdh";
     repo = "swayr";
     rev = "v${version}";
-    sha256 = "sha256-ZnZ9g8o1+VfhpDqxqtknNJ7dcyt5yuQcH3txxA3HICU=";
+    sha256 = "sha256-B19cHdoiCbxhvRGi3NzKPKneKgOI4+l8+Qg9/YVgUV8=";
   };
 
-  cargoSha256 = "sha256-0EhHFxbQi3Jgu13pXIjYYFYDEOQjwN5h+jE+22gJG0s=";
+  cargoSha256 = "sha256-iO64K+d/wEyY/tVztIG8zYSha5X0iTHV7IDVthMJQGA=";
 
   patches = [
     ./icon-paths.patch

pkgs/tools/wayland/wshowkeys/default.nix

···
-{ lib, stdenv, fetchFromSourcehut
+{ lib, stdenv, fetchFromGitHub
 , meson, pkg-config, wayland-scanner, ninja
 , cairo, libinput, pango, wayland, wayland-protocols, libxkbcommon
 }:
 
-let
-  version = "2020-03-29";
-  commit = "6388a49e0f431d6d5fcbd152b8ae4fa8e87884ee";
-in stdenv.mkDerivation rec {
+stdenv.mkDerivation rec {
   pname = "wshowkeys-unstable";
-  inherit version;
+  version = "2021-08-01";
 
-  src = fetchFromSourcehut {
-    owner = "~sircmpwn";
+  src = fetchFromGitHub {
+    owner = "ammgws";
     repo = "wshowkeys";
-    rev = commit;
-    sha256 = "10kafdja5cwbypspwhvaxjz3hvf51vqjzbgdasl977193cvxgmbs";
+    rev = "e8bfc78f08ebdd1316daae59ecc77e62bba68b2b";
+    sha256 = "sha256-/HvNCQWsXOJZeCxHWmsLlbBDhBzF7XP/SPLdDiWMDC4=";
   };
 
   nativeBuildInputs = [ meson pkg-config wayland-scanner ninja ];
···
       permissions are dropped after startup. The NixOS module provides such a
       setuid binary (use "programs.wshowkeys.enable = true;").
     '';
-    homepage = "https://git.sr.ht/~sircmpwn/wshowkeys";
+    homepage = "https://github.com/ammgws/wshowkeys";
     license = with licenses; [ gpl3Only mit ];
     # Some portions of the code are taken from Sway which is MIT licensed.
     # TODO: gpl3Only or gpl3Plus (ask upstream)?
     platforms = platforms.unix;
     maintainers = with maintainers; [ primeos berbiche ];
-    broken = true; # Unmaintained and fails to run (Wayland protocol error)
-    # TODO (@primeos): Remove this package after the NixOS 21.11 branch-off
   };
 }

pkgs/top-level/all-packages.nix

···
 
   git-open = callPackage ../applications/version-management/git-and-tools/git-open { };
 
+  git-quickfix = callPackage ../applications/version-management/git-and-tools/git-quickfix {
+    inherit (darwin.apple_sdk.frameworks) Security SystemConfiguration;
+  };
+
   git-radar = callPackage ../applications/version-management/git-and-tools/git-radar { };
 
   git-recent = callPackage ../applications/version-management/git-and-tools/git-recent {
···
   google-compute-engine-oslogin = callPackage ../tools/virtualization/google-compute-engine-oslogin { };
 
   google-cloud-cpp = callPackage ../development/libraries/google-cloud-cpp { };
+
+  google-java-format = callPackage ../development/tools/google-java-format { };
 
   gdown = with python3Packages; toPythonApplication gdown;
 
···
   rambox-pro = callPackage ../applications/networking/instant-messengers/rambox/pro.nix { };
 
   ranger = callPackage ../applications/misc/ranger { };
+
+  rar = callPackage ../tools/archivers/rar { };
 
   rarcrack = callPackage ../tools/security/rarcrack { };
 
···
     inherit (llvmPackages_9) stdenv clang llvm;
   };
 
+  img = callPackage ../development/tools/img { };
+
   include-what-you-use = callPackage ../development/tools/analysis/include-what-you-use {
     llvmPackages = llvmPackages_12;
   };
···
 
   pycritty = with python3Packages; toPythonApplication pycritty;
 
-  qtcreator = libsForQt5.callPackage ../development/tools/qtcreator { };
+  qtcreator = libsForQt5.callPackage ../development/tools/qtcreator {
+    inherit (linuxPackages) perf;
+  };
 
   qxmledit = libsForQt5.callPackage ../applications/editors/qxmledit {} ;
 

pkgs/top-level/haskell-packages.nix

···
     };
 
     ghc884 = callPackage ../development/compilers/ghc/8.8.4.nix {
-      # the oldest ghc with aarch64-darwin support is 8.10.5
-      bootPkgs = if stdenv.isDarwin && stdenv.isAarch64 then
-          packages.ghc8107BinaryMinimal
+      bootPkgs =
         # aarch64 ghc865Binary gets SEGVs due to haskell#15449 or similar
         # Musl bindists do not exist for ghc 8.6.5, so we use 8.10.* for them
-        else if stdenv.isAarch64 || stdenv.targetPlatform.isMusl then
+        if stdenv.isAarch64 || stdenv.hostPlatform.isMusl then
           packages.ghc8102BinaryMinimal
         else
           packages.ghc865Binary;
···
       llvmPackages = pkgs.llvmPackages_7;
     };
     ghc8107 = callPackage ../development/compilers/ghc/8.10.7.nix {
-      # the oldest ghc with aarch64-darwin support is 8.10.5
-      bootPkgs = if stdenv.isDarwin && stdenv.isAarch64 then
-          packages.ghc8107BinaryMinimal
+      bootPkgs =
         # aarch64 ghc865Binary gets SEGVs due to haskell#15449 or similar
+        # the oldest ghc with aarch64-darwin support is 8.10.5
         # Musl bindists do not exist for ghc 8.6.5, so we use 8.10.* for them
-        else if stdenv.isAarch64 || stdenv.isAarch32 || stdenv.targetPlatform.isMusl then
-          packages.ghc8102BinaryMinimal
+        if stdenv.isAarch64 || stdenv.isAarch32 then
+          packages.ghc8107BinaryMinimal
         else
-          packages.ghc865Binary;
+          packages.ghc8107Binary;
       inherit (buildPackages.python3Packages) sphinx;
       # Need to use apple's patched xattr until
       # https://github.com/xattr/xattr/issues/44 and
···
       llvmPackages = pkgs.llvmPackages_9;
     };
     ghc901 = callPackage ../development/compilers/ghc/9.0.1.nix {
-      # the oldest ghc with aarch64-darwin support is 8.10.5
-      bootPkgs = if stdenv.isDarwin && stdenv.isAarch64 then
+      bootPkgs =
+        # aarch64 ghc8107Binary exceeds max output size on hydra
+        # the oldest ghc with aarch64-darwin support is 8.10.5
+        if stdenv.isAarch64 || stdenv.isAarch32 then
           packages.ghc8107BinaryMinimal
-        # aarch64 ghc8102Binary exceeds max output size on hydra
-        else if stdenv.isAarch64 || stdenv.isAarch32 then
-          packages.ghc8102BinaryMinimal
         else
-          packages.ghc8102Binary;
+          packages.ghc8107Binary;
       inherit (buildPackages.python3Packages) sphinx;
       buildLlvmPackages = buildPackages.llvmPackages_10;
       llvmPackages = pkgs.llvmPackages_10;
     };
     ghc921 = callPackage ../development/compilers/ghc/9.2.1.nix {
-      # aarch64 ghc8102Binary exceeds max output size on hydra
-      bootPkgs = if stdenv.isAarch64 || stdenv.isAarch32 then
-          packages.ghc8102BinaryMinimal
+      bootPkgs =
+        # aarch64 ghc8107Binary exceeds max output size on hydra
+        if stdenv.isAarch64 || stdenv.isAarch32 then
+          packages.ghc8107BinaryMinimal
         else
-          packages.ghc8102Binary;
+          packages.ghc8107Binary;
       inherit (buildPackages.python3Packages) sphinx;
       # Need to use apple's patched xattr until
       # https://github.com/xattr/xattr/issues/44 and

pkgs/top-level/python-packages.nix

···
 
   url-normalize = callPackage ../development/python-modules/url-normalize { };
 
+  urlextract = callPackage ../development/python-modules/urlextract { };
+
   urlgrabber = callPackage ../development/python-modules/urlgrabber { };
 
   urllib3 = callPackage ../development/python-modules/urllib3 { };

pkgs/top-level/release-haskell.nix

···
       elmPackages.elm = pkgsPlatforms.elmPackages.elm;
 
       # GHCs linked to musl.
-      pkgsMusl.haskell.compiler = packagePlatforms pkgs.pkgsMusl.haskell.compiler // {
-        # remove musl ghc865Binary since it is known to be broken and
-        # causes an evaluation error on darwin.
-        # TODO: remove ghc865Binary altogether and use ghc8102Binary
-        ghc865Binary = {};
+      pkgsMusl.haskell.compiler = lib.recursiveUpdate
+        (packagePlatforms pkgs.pkgsMusl.haskell.compiler)
+        {
+          # remove musl ghc865Binary since it is known to be broken and
+          # causes an evaluation error on darwin.
+          # TODO: remove ghc865Binary altogether and use ghc8102Binary
+          ghc865Binary = {};
 
-        # remove integer-simple because it appears to be broken with
-        # musl and non-static-linking.
-        integer-simple = {};
+          ghcjs = {};
+          ghcjs810 = {};
 
-        ghcjs = {};
-        ghcjs810 = {};
-      };
+          # Can't be built with musl, see meta.broken comment in the drv
+          integer-simple.ghc884 = {};
+        };
 
       # Get some cache going for MUSL-enabled GHC.
       pkgsMusl.haskellPackages =
···
         };
         constituents = accumulateDerivations [
           jobs.pkgsMusl.haskell.compiler.ghc8102Binary
+          jobs.pkgsMusl.haskell.compiler.ghc8107Binary
           jobs.pkgsMusl.haskell.compiler.ghc884
           jobs.pkgsMusl.haskell.compiler.ghc8107
           jobs.pkgsMusl.haskell.compiler.ghc901
+          jobs.pkgsMusl.haskell.compiler.ghc921
+          jobs.pkgsMusl.haskell.compiler.ghcHEAD
+          jobs.pkgsMusl.haskell.compiler.integer-simple.ghc8107
+          jobs.pkgsMusl.haskell.compiler.integer-simple.ghc901
+          jobs.pkgsMusl.haskell.compiler.integer-simple.ghc921
+          jobs.pkgsMusl.haskell.compiler.native-bignum.ghcHEAD
         ];
       };