Merge staging-next into staging

maintainers/scripts/haskell/mark-broken.sh

···
 git add pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml
 git add pkgs/development/haskell-modules/hackage-packages.nix
 git commit -F - << EOF
-hackage2nix: Mark failing builds broken
+haskellPackages: mark builds failing on hydra as broken
 
 This commit has been generated by maintainers/scripts/haskell/mark-broken.sh
 EOF

maintainers/scripts/haskell/regenerate-hackage-packages.sh

···
 if [[ "${1:-}" == "--do-commit" ]]; then
 git add pkgs/development/haskell-modules/hackage-packages.nix
 git commit -F - << EOF
-hackage-packages.nix: Regenerate based on current config
+haskellPackages: regenerate package set based on current config
 
 This commit has been generated by maintainers/scripts/haskell/regenerate-hackage-packages.sh
 EOF

maintainers/scripts/haskell/update-stackage.sh

···
 if [[ "${1:-}" == "--do-commit" ]]; then
 git add $stackage_config
 git commit -F - << EOF
-Stackage Nightly: $old_version -> $version
+haskellPackages: stackage-nightly $old_version -> $version
 
 This commit has been generated by maintainers/scripts/haskell/update-stackage.sh
 EOF

nixos/modules/config/console.nix

···
 
   options.console  = {
     font = mkOption {
-      type = types.str;
+      type = with types; either str path;
       default = "Lat2-Terminus16";
       example = "LatArCyrHeb-16";
       description = ''
         The font used for the virtual consoles.  Leave empty to use
         whatever the <command>setfont</command> program considers the
         default font.
+        Can be either a font name or a path to a PSF font file.
       '';
     };
 

pkgs/applications/editors/mindforger/default.nix

···
-{ mkDerivation
+{ lib
+, stdenv
 , cmark-gfm
 , fetchurl
+, fetchpatch
 , qmake
 , qtbase
-, qtwebkit
-, lib
+, qtwebengine
 , wrapGAppsHook
+, wrapQtAppsHook
 }:
 
-mkDerivation rec {
+stdenv.mkDerivation rec {
   pname = "mindforger";
   version = "1.52.0";
 
···
     sha256 = "1pghsw8kwvjhg3jpmjs0n892h2l0pm0cs6ymi8b23fwk0kfj67rd";
   };
 
-  nativeBuildInputs = [ qmake wrapGAppsHook ] ;
-  buildInputs = [ qtbase qtwebkit cmark-gfm ] ;
+  nativeBuildInputs = [ qmake wrapGAppsHook wrapQtAppsHook ];
+  buildInputs = [ qtbase qtwebengine cmark-gfm ];
 
   doCheck = true;
 
-  patches = [ ./build.patch ] ;
+  patches = [
+    # this makes the package relocatable - removes hardcoded references to /usr
+    ./paths.patch
+    #  this fixes compilation with QtWebEngine - referencing a commit trying to upstream the change - see https://github.com/dvorka/mindforger/pull/1357
+    (fetchpatch {
+      url = "https://github.com/dvorka/mindforger/commit/d28e2bade0278af1b5249953202810540969026a.diff";
+      sha256 = "sha256-qHKQQNGSc3F9seaOHV0gzBQFFqcTXk91LpKrojjpAUw=";
+    })
+  ];
 
   postPatch = ''
     substituteInPlace lib/src/install/installer.cpp --replace /usr "$out"
     substituteInPlace app/resources/gnome-shell/mindforger.desktop --replace /usr "$out"
+    for f in app/app.pro lib/lib.pro; do
+      substituteInPlace "$f" --replace "QMAKE_CXX = g++" ""
+    done
   '';
 
-  qmakeFlags = [ "-r mindforger.pro" "CONFIG+=mfnoccache" ] ;
+  qmakeFlags = [
+    "-r"
+    "mindforger.pro"
+    "CONFIG+=mfnoccache"
+    "CONFIG+=mfwebengine"
+  ];
+
+  postInstall = lib.optionalString stdenv.isDarwin ''
+    mkdir "$out"/Applications
+    mv app/mindforger.app "$out"/Applications/
+    wrapQtApp "$out"/Applications/mindforger.app/Contents/MacOS/mindforger
+  '';
 
   meta = with lib; {
     description = "Thinking Notebook & Markdown IDE";

pkgs/applications/kde/kdenlive/default.nix

···
 
   meta = {
     license = with lib.licenses; [ gpl2Plus ];
+    maintainers = with lib.maintainers; [ turion ];
   };
 }

pkgs/applications/networking/feedreaders/newsflash/default.nix

···
 , glib-networking
 , librsvg
 , gst_all_1
+, xdg-utils
 }:
 
 stdenv.mkDerivation rec {
···
     openssl
     sqlite
     webkitgtk
+
+    # open link in browser
+    xdg-utils
 
     # TLS support for loading external content in webkitgtk WebView
     glib-networking

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

···
 
 mkDerivation rec {
   pname = "kdeltachat";
-  version = "unstable-2021-05-31";
+  version = "unstable-2021-06-06";
 
   src = fetchFromSourcehut {
     owner = "~link2xt";
     repo = "kdeltachat";
-    rev = "318ae67c17f3e64532bad23c2a61a93446db553d";
-    sha256 = "1qy0hlp0r91sqn26ai9isxw4rl8kcmmb10a2p9yqynhm8py3dfn4";
+    rev = "321c19b7415e837acc4e66d535e82518618bc096";
+    sha256 = "19py9mxpjz09fhyyvxf75s77nq0jwwfiljq9289192p61grk6625";
   };
 
   nativeBuildInputs = [

pkgs/applications/networking/sync/rsync/default.nix

···
 { lib, stdenv, fetchurl, perl, libiconv, zlib, popt
-, enableACLs ? !(stdenv.isDarwin || stdenv.isSunOS || stdenv.isFreeBSD), acl ? null
+, enableACLs ? lib.meta.availableOn stdenv.hostPlatform acl, acl ? null
 , enableLZ4 ? true, lz4 ? null
 , enableOpenSSL ? true, openssl ? null
 , enableXXHash ? true, xxHash ? null

pkgs/applications/terminal-emulators/kitty/default.nix

···
 with python3Packages;
 buildPythonApplication rec {
   pname = "kitty";
-  version = "0.20.3";
+  version = "0.21.0";
   format = "other";
 
   src = fetchFromGitHub {
     owner = "kovidgoyal";
     repo = "kitty";
     rev = "v${version}";
-    sha256 = "sha256-rORIrbUqtQZuU6TjjYP7IZHfCPeLnrNy6wInnAwhG48=";
+    sha256 = "sha256-n8ipIQAfKPVApJhuTrlSSsd6dlPeCUvk7rdiVmL9i+4=";
   };
 
   buildInputs = [
···
   propagatedBuildInputs = lib.optional stdenv.isLinux libGL;
 
   outputs = [ "out" "terminfo" ];
-
-  patches = [
-    ./fix-paths.patch
-  ];
 
   # Causes build failure due to warning
   hardeningDisable = lib.optional stdenv.cc.isClang "strictoverflow";

pkgs/applications/terminal-emulators/kitty/fix-paths.patch

···
---- a/docs/Makefile
-+++ b/docs/Makefile
-@@ -3,7 +3,7 @@
-# Patching is needed here for the following reason:
-# * importing the `constants` package from Kitty has a side effect that it
-#   creates the user configuration directory. This package gets imported
-#   while sphinx scans the code for documentation strings.
-#
- 
- # You can set these variables from the command line.
- SPHINXOPTS    = -j auto -T $(FAIL_WARN)
--SPHINXBUILD   = sphinx-build
-+SPHINXBUILD   = PYTHONPATH=${PYTHONPATH}:.. HOME=${TMPDIR}/kitty-build-home sphinx-build
- SPHINXPROJ    = kitty
- SOURCEDIR     = .
- BUILDDIR      = _build

pkgs/applications/terminal-emulators/rxvt-unicode-plugins/urxvt-font-size/default.nix

···
 { lib, stdenv, fetchFromGitHub, xrdb, xlsfonts }:
 
-stdenv.mkDerivation {
-  name = "urxvt-font-size-2015-05-22";
-  dontPatchShebangs = true;
+stdenv.mkDerivation rec {
+  name = "urxvt-font-size";
+  version = "1.3";
 
   src = fetchFromGitHub {
     owner = "majutsushi";
     repo = "urxvt-font-size";
-    rev = "fd5b09c10798c6723bbf771d4d8881cf6563bc69";
-    sha256 = "16m3kkypg3y00x597zx05zy167a0kaqpawz0l591wzb2bv1dz55z";
+    rev = "v${version}";
+    sha256 = "1526ap161cp3378f4ijd09nmsh71ld7bkxxhp8p6razdi2v8r16h";
   };
 
   installPhase = ''

pkgs/applications/version-management/fossil/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "fossil";
-  version = "2.14";
+  version = "2.15.1";
 
   src = fetchurl {
     urls =
···
         "https://www.fossil-scm.org/index.html/uv/fossil-src-${version}.tar.gz"
       ];
     name = "${pname}-${version}.tar.gz";
-    sha256 = "sha256-uNDJIBlt2K4pFS+nRI5ROh+nxYiHG3heP7/Ae0KgX7k=";
+    sha256 = "sha256-gNJ5I8ZjsqLHEPiujNVJhi4E+MBChXBidMNK48jKF9E=";
   };
 
   nativeBuildInputs = [ installShellFiles tcl tcllib ];
 
   buildInputs = [ zlib openssl readline sqlite which ed ]
     ++ lib.optional stdenv.isDarwin libiconv;
+
+  enableParallelBuilding = true;
 
   doCheck = stdenv.hostPlatform == stdenv.buildPlatform;
 
···
       many such systems in use today. Fossil strives to distinguish itself
       from the others by being extremely simple to setup and operate.
     '';
-    homepage = "http://www.fossil-scm.org/";
+    homepage = "https://www.fossil-scm.org/";
     license = licenses.bsd2;
     maintainers = with maintainers; [ maggesi viric ];
+    platforms = platforms.all;
   };
 }

pkgs/applications/video/plex-media-player/default.nix

···
   depSrcs = import ./deps.nix { inherit fetchurl; };
 in mkDerivation rec {
   pname = "plex-media-player";
-  version = "2.58.0.1076";
-  vsnHash = "38e019da";
+  version = "2.58.1";
+  vsnHash = "ae73e074";
 
   src = fetchFromGitHub {
     owner = "plexinc";
     repo = "plex-media-player";
     rev = "v${version}-${vsnHash}";
-    sha256 = "XFwcSHn9wG30bDMGFITBmhp6/VI1RLmxMxFFxjntTmw=";
+    sha256 = "1q20fdp5d0blb0q6p2357bwdc2g65cadkgdp4w533ij2nyaxydjd";
   };
 
   nativeBuildInputs = [ pkg-config cmake python3 ];

pkgs/applications/video/plex-media-player/deps.nix

···
 
   webClient = fetchurl {
     url = "https://artifacts.plex.tv/web-client-pmp/${webClientBuildId}/buildid.cmake";
-    sha256 = "AzHlO7Z8SxQoT6++OphwDDQ47Ombnpaby0mh1YNnSvc=";
+    sha256 = "1xsacy1xb8a9rfdrd7lvx7n3hd0cf2c3mgmg9wl18jvwnqxyac83";
   };
   webClientDesktopHash = fetchurl {
     url = "https://artifacts.plex.tv/web-client-pmp/${webClientBuildId}/web-client-desktop-${webClientDesktopBuildId}.tar.xz.sha1";
-    sha256 = "7vUcTuN5ypFFIrBygyutEZu4MYl5WPmFureQl6HvVx8=";
+    sha256 = "07spxyhrg45ppa2zjn3ri4qvi6qimlmq6wmh492r3jkrwd71rxgf";
   };
   webClientDesktop = fetchurl {
     url = "https://artifacts.plex.tv/web-client-pmp/${webClientBuildId}/web-client-desktop-${webClientDesktopBuildId}.tar.xz";
-    sha256 = "xWwXhN2N4Pvalxtm5PwZprkcFU6RIiE6fA71d2E6lP4=";
+    sha256 = "1zll79hpgx8fghx228li9qairfd637yf8rhvjzdgpq4dvn21fv65";
   };
   webClientTvHash = fetchurl {
     url = "https://artifacts.plex.tv/web-client-pmp/${webClientBuildId}/web-client-tv-${webClientTvBuildId}.tar.xz.sha1";
-    sha256 = "U8u5SOxPpz8HOJKrYXlIHx0X08Flspl67hlzc57g7v8=";
+    sha256 = "1zzfw2g76wqrxrx9kck5q79if78z91wn3awj703kz9sgxi4bkjsk";
   };
   webClientTv = fetchurl {
     url = "https://artifacts.plex.tv/web-client-pmp/${webClientBuildId}/web-client-tv-${webClientTvBuildId}.tar.xz";
-    sha256 = "4Et9d4BO+4UParvsSJglJvb+cnp0oUP3O4MDNnLeP7g=";
+    sha256 = "1f1zvrr3c0w37gvl78blg9rgxxi64nc4iv5vd87qbysfh1vpsjz0";
   };
 }

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "9be76e8f01853e5a2f0600107c9b50d12a17581b",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/9be76e8f01853e5a2f0600107c9b50d12a17581b.tar.gz",
-  "sha256": "0sy8lx04yb9lk9liscqr44z7lzzq67w3zmkq78a0yv37jadb557k",
-  "msg": "Update from Hackage at 2021-06-02T14:32:36Z"
+  "commit": "d1a32be92531e75b1acae3126313cdc013951965",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/d1a32be92531e75b1acae3126313cdc013951965.tar.gz",
+  "sha256": "190m9drzg7rgkjpimlgvl8hsv2g1jg0m0fdgy8xkrh7xr1vjxxgz",
+  "msg": "Update from Hackage at 2021-06-06T15:18:11Z"
 }

pkgs/desktops/xfce/core/thunar/default.nix

···
 , libxfce4ui
 , libxfce4util
 , libxslt
+, pcre
 , xfconf
 , gobject-introspection
 , makeWrapper
···
     libnotify
     libxfce4ui
     libxfce4util
+    pcre
     xfconf
   ];
 

pkgs/development/compilers/ghc/8.10.4.nix

···
 
   targetCC = builtins.head toolsForTarget;
 
-  # ld.gold is disabled for musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856
+  # Use gold either following the default, or to avoid the BFD linker due to some bugs / perf issues.
+  # But we cannot avoid BFD when using musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856
   # see #84670 and #49071 for more background.
-  useLdGold = targetPlatform.isLinux && !(targetPlatform.useLLVM or false) && !targetPlatform.isMusl;
+  useLdGold = targetPlatform.linker == "gold" || (targetPlatform.linker == "bfd" && !targetPlatform.isMusl);
+
+  runtimeDeps = [
+    targetPackages.stdenv.cc.bintools
+    coreutils
+  ]
+  # On darwin, we need unwrapped bintools as well (for otool)
+  ++ lib.optionals (stdenv.targetPlatform.linker == "cctools") [
+    targetPackages.stdenv.cc.bintools.bintools
+  ];
 
 in
 stdenv.mkDerivation (rec {
···
     for i in "$out/bin/"*; do
       test ! -h $i || continue
       egrep --quiet '^#!' <(head -n 1 $i) || continue
-      sed -i -e '2i export PATH="$PATH:${lib.makeBinPath [ targetPackages.stdenv.cc.bintools coreutils ]}"' $i
+      sed -i -e '2i export PATH="$PATH:${lib.makeBinPath runtimeDeps}"' $i
     done
   '';
 

pkgs/development/compilers/ghc/8.8.4.nix

···
 
   targetCC = builtins.head toolsForTarget;
 
-  # ld.gold is disabled for musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856
+  # Use gold either following the default, or to avoid the BFD linker due to some bugs / perf issues.
+  # But we cannot avoid BFD when using musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856
   # see #84670 and #49071 for more background.
-  useLdGold = targetPlatform.isLinux && !(targetPlatform.useLLVM or false) && !targetPlatform.isMusl;
+  useLdGold = targetPlatform.linker == "gold" || (targetPlatform.linker == "bfd" && !targetPlatform.isMusl);
+
+  runtimeDeps = [
+    targetPackages.stdenv.cc.bintools
+    coreutils
+  ]
+  # On darwin, we need unwrapped bintools as well (for otool)
+  ++ lib.optionals (stdenv.targetPlatform.linker == "cctools") [
+    targetPackages.stdenv.cc.bintools.bintools
+  ];
 
 in
 stdenv.mkDerivation (rec {
···
     for i in "$out/bin/"*; do
       test ! -h $i || continue
       egrep --quiet '^#!' <(head -n 1 $i) || continue
-      sed -i -e '2i export PATH="$PATH:${lib.makeBinPath [ targetPackages.stdenv.cc.bintools coreutils ]}"' $i
+      sed -i -e '2i export PATH="$PATH:${lib.makeBinPath runtimeDeps}"' $i
     done
   '';
 

pkgs/development/compilers/ghc/9.0.1.nix

···
 
   targetCC = builtins.head toolsForTarget;
 
-  # ld.gold is disabled for musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856
+  # Use gold either following the default, or to avoid the BFD linker due to some bugs / perf issues.
+  # But we cannot avoid BFD when using musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856
   # see #84670 and #49071 for more background.
-  useLdGold = targetPlatform.isLinux && !(targetPlatform.useLLVM or false) && !targetPlatform.isMusl;
+  useLdGold = targetPlatform.linker == "gold" || (targetPlatform.linker == "bfd" && !targetPlatform.isMusl);
+
+  runtimeDeps = [
+    targetPackages.stdenv.cc.bintools
+    coreutils
+  ]
+  # On darwin, we need unwrapped bintools as well (for otool)
+  ++ lib.optionals (stdenv.targetPlatform.linker == "cctools") [
+    targetPackages.stdenv.cc.bintools.bintools
+  ];
 
 in
 stdenv.mkDerivation (rec {
···
     for i in "$out/bin/"*; do
       test ! -h $i || continue
       egrep --quiet '^#!' <(head -n 1 $i) || continue
-      sed -i -e '2i export PATH="$PATH:${lib.makeBinPath [ targetPackages.stdenv.cc.bintools coreutils ]}"' $i
+      sed -i -e '2i export PATH="$PATH:${lib.makeBinPath runtimeDeps}"' $i
     done
   '';
 

pkgs/development/compilers/ghc/head.nix

···
 
   targetCC = builtins.head toolsForTarget;
 
-  # ld.gold is disabled for musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856
+  # Use gold either following the default, or to avoid the BFD linker due to some bugs / perf issues.
+  # But we cannot avoid BFD when using musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856
   # see #84670 and #49071 for more background.
-  useLdGold = targetPlatform.isLinux && !(targetPlatform.useLLVM or false) && !targetPlatform.isMusl;
+  useLdGold = targetPlatform.linker == "gold" || (targetPlatform.linker == "bfd" && !targetPlatform.isMusl);
+
+  runtimeDeps = [
+    targetPackages.stdenv.cc.bintools
+    coreutils
+  ]
+  # On darwin, we need unwrapped bintools as well (for otool)
+  ++ lib.optionals (stdenv.targetPlatform.linker == "cctools") [
+    targetPackages.stdenv.cc.bintools.bintools
+  ];
 
 in
 stdenv.mkDerivation (rec {
···
     for i in "$out/bin/"*; do
       test ! -h $i || continue
       egrep --quiet '^#!' <(head -n 1 $i) || continue
-      sed -i -e '2i export PATH="$PATH:${lib.makeBinPath [ targetPackages.stdenv.cc.bintools coreutils ]}"' $i
+      sed -i -e '2i export PATH="$PATH:${lib.makeBinPath runtimeDeps}"' $i
     done
   '';
 

pkgs/development/guile-modules/guile-git/default.nix

···
+{ lib
+, stdenv
+, fetchFromGitLab
+, guile
+, libgit2
+, scheme-bytestructures
+, autoreconfHook
+, pkg-config
+, texinfo
+}:
+
+stdenv.mkDerivation rec {
+  pname = "guile-git";
+  version = "0.3.0";
+
+  src = fetchFromGitLab {
+    owner = "guile-git";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "1s77s70gzfj6h7bglq431kw8l4iknhsfpc0mnvcp4lkhwdcgyn1n";
+  };
+
+  postConfigure = ''
+    sed -i '/moddir\s*=/s%=.*%=''${out}/share/guile/site%' Makefile;
+    sed -i '/godir\s*=/s%=.*%=''${out}/share/guile/ccache%' Makefile;
+  '';
+
+  nativeBuildInputs = [
+    autoreconfHook pkg-config texinfo
+  ];
+  buildInputs = [
+    guile
+  ];
+  propagatedBuildInputs = [
+    libgit2 scheme-bytestructures
+  ];
+
+  enableParallelBuilding = true;
+
+  meta = with lib; {
+    description = "Bindings to Libgit2 for GNU Guile";
+    homepage = "https://gitlab.com/guile-git/guile-git";
+    license = licenses.gpl3Plus;
+    maintainers = with maintainers; [ ethancedwards8 ];
+    platforms = platforms.linux;
+  };
+}
+

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

···
 }:
 mkDerivation {
   pname = "cabal2nix";
-  version = "unstable-2021-05-28";
+  version = "unstable-2021-06-12";
   src = fetchzip {
-    url = "https://github.com/NixOS/cabal2nix/archive/5fb325e094af91328e02cc2ecfd211feaeb135a7.tar.gz";
-    sha256 = "1zbd336s99rgk24yjqlp012d0f66s5nf190sjmsl7mfhqx9j2y4l";
+    url = "https://github.com/NixOS/cabal2nix/archive/01feffa0aeee835504e0c0ccf4bca2e33a698252.tar.gz";
+    sha256 = "0clckh0qqvjcb8szy1d6qqlxj6sqp28jc2p3vhzhkf95cv491si9";
   };
   isLibrary = true;
   isExecutable = true;

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

···
   # Similar to https://ghc.haskell.org/trac/ghc/ticket/13062
   happy = dontCheck super.happy;
 
+  # Disable GClosure based signals implementation on aarch64 as it causes linker issues
+  # https://github.com/gtk2hs/gtk2hs/issues/305
+  gtk2hs-buildtools = appendConfigureFlag super.gtk2hs-buildtools "-f-ClosureSignals";
+
 } // lib.optionalAttrs pkgs.stdenv.hostPlatform.isAarch64 {
   # AARCH64-SPECIFIC OVERRIDES
 

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

···
   # https://github.com/haskell-hvr/missingh/issues/56
   MissingH = doJailbreak super.MissingH;
 
-  # Too strict bound on containers
-  # https://github.com/batterseapower/parallel-io/issues/14#issuecomment-853441933
-  parallel-io = doJailbreak super.parallel-io;
-
   # Disable flaky tests
   # https://github.com/DavidEichmann/alpaca-netcode/issues/2
   alpaca-netcode = overrideCabal super.alpaca-netcode {
···
   # unrestrict bounds for hashable and semigroups
   # https://github.com/HeinrichApfelmus/reactive-banana/issues/215
   reactive-banana = doJailbreak super.reactive-banana;
+
+  # Too strict version bounds on QuickCheck and semirings
+  # https://github.com/erikd/wide-word/issues/57
+  wide-word = doJailbreak super.wide-word;
+
+  hackage-db_2_1_0 = doDistribute super.hackage-db_2_1_0;
 
 } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

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

···
   # Break out of "Cabal < 3.2" constraint.
   stylish-haskell = doJailbreak super.stylish-haskell;
 
+  # hackage-db 2.1.1 is incompatible with Cabal < 3.4
+  # See https://github.com/NixOS/cabal2nix/issues/501
+  hackage-db = self.hackage-db_2_1_0;
+
 }

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

···
   # https://github.com/haskellari/time-compat/issues/23
   time-compat = dontCheck super.time-compat;
 
+  # hackage-db 2.1.1 is incompatible with Cabal < 3.4
+  # See https://github.com/NixOS/cabal2nix/issues/501
+  hackage-db = super.hackage-db_2_1_0;
+
 }

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

···
 
   # vector 0.12.2 indroduced doctest checks that don‘t work on older compilers
   vector = dontCheck super.vector;
+
+  # hackage-db 2.1.1 is incompatible with Cabal < 3.4
+  # See https://github.com/NixOS/cabal2nix/issues/501
+  hackage-db = super.hackage-db_2_1_0;
 }

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

···
   # 5 introduced support for GHC 9.0.x, but hasn't landed in stackage yet
   lens = super.lens_5_0_1;
 
+  # 0.16.0 introduced support for GHC 9.0.x, stackage has 0.15.0
+  memory = super.memory_0_16_0;
+
+  # 0.29 introduced support for GHC 9.0.x, stackage has 0.28
+  cryptonite = super.cryptonite_0_29;
+
+  # GHC 9.0.x doesn't like `import Spec (main)` in Main.hs
+  # https://github.com/snoyberg/mono-traversable/issues/192
+  mono-traversable = dontCheck super.mono-traversable;
+
+  # Disable tests pending resolution of
+  # https://github.com/Soostone/retry/issues/71
+  retry = dontCheck super.retry;
+
 }

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

···
   - biohazard
   - bio-sequence
   - birds-of-paradise
+  - biscuit-haskell
   - bisect-binary
   - bishbosh
   - bitcoin-hs
···
   - dhall-fly
   - dhall-text
   - dhall-to-cabal
+  - dhcp-lease-parser
   - dhrun
   - dia-base
   - diagrams-boolean
···
   - hs-carbon-examples
   - hscd
   - hs-cdb
+  - hscdio
   - hsclock
   - hScraper
   - hscuid
···
   - Irc
   - irc-dcc
   - irc-fun-types
+  - iri
   - iridium
   - iron-mq
   - irt
···
   - json-schema
   - jsonschema-gen
   - jsonsql
+  - json-syntax
   - json-tools
   - json-tracer
   - jsontsv
···
   - movie-monad
   - mpppc
   - mpris
+  - mptcp-pm
   - mpvguihs
   - mqtt
   - mqtt-hs
···
   - pandoc-utils
   - pang-a-lambda
   - pangraph
+  - pan-os-syslog
   - panpipe
   - pansite
   - pantry-tmp
···
   - shorten-strings
   - show-prettyprint
   - Shpadoinkle-backend-snabbdom
+  - Shpadoinkle-isreal
   - Shpadoinkle-streaming
   - shwifty
   - sifflet
···
   - slug
   - slugify
   - smallarray
+  - small-bytearray-builder
   - smallcheck-kind-generics
   - smallcheck-laws
   - smallcheck-lens
···
   - thank-you-stars
   - th-build
   - th-dict-discovery
+  - themoviedb
   - thentos-cookie-session
   - Theora
   - theoremquest
···
   - unordered-intmap
   - unpacked-either
   - unpacked-maybe
+  - unpacked-maybe-numeric
   - unpack-funcs
   - unroll-ghc-plugin
   - unsafely
···
   - whiskers
   - whois
   - why3
-  - wide-word
   - WikimediaParser
   - windns
   - winerror

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

···
   - futhark < 0.19.5
   # 2021-06-05: remove once pandoc 2.14 is in stackage
   - pandoc-crossref < 0.3.11.0
+  # 2021-06-07: stackage still has dhall < 1.39
+  - dhall-nix < 1.1.21
+  - dhall-openapi < 1.0.1
 
 extra-packages:
   - base16-bytestring < 1               # required for cabal-install etc.
···
   - gi-gtk < 4.0                        # 2021-05-07: For haskell-gi 0.25 without gtk4
   - gi-gdkx11 == 3.0.11                 # 2021-05-07: For haskell-gi 0.25 without gtk4
   - ShellCheck == 0.7.1                 # 2021-05-09: haskell-ci 0.12.1 pins this version
+  - hackage-db < 2.1.1                  # 2021-06-10: Need older hackage-db as long as Cabal < 3.4, see https://github.com/NixOS/cabal2nix/issues/501
 
 package-maintainers:
   abbradar:
···
   mpi-hs-cereal:                                [ aarch64-linux, x86_64-darwin ]
   mpi-hs-store:                                 [ aarch64-linux, x86_64-darwin ]
   mplayer-spot:                                 [ aarch64-linux ]
+  mptcp-pm:                                     [ x86_64-darwin ]
   netlink:                                      [ x86_64-darwin ]
   oculus:                                       [ x86_64-darwin ]
   pam:                                          [ x86_64-darwin ]

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

···
  - activehs
  - actor
  - AC-Vector-Fancy
- - addy
  - adhoc-network
  - adict
  - ADPfusionForest
···
  - atp
  - AttoJson
  - attoparsec-enumerator
- - attoparsec-ip
  - attoparsec-iteratee
  - attoparsec-text-enumerator
- - attoparsec-uri
  - atuin
  - audiovisual
  - aura
···
  - Barracuda
  - base16-lens
  - base32-bytestring
- - base62
  - base64-bytes
  - baserock-schema
  - BASIC
···
  - buster-network
  - butterflies
  - bv-sized-lens
- - bytebuild
  - bytehash
  - bytelog
- - bytesmith
  - bytestring-read
  - c0check
  - cabal2arch
···
  - dewdrop
  - dfinity-radix-tree
  - dhall-docs
- - dhcp-lease-parser
  - dia-functions
  - diagrams-haddock
  - diagrams-html5
···
  - invertible-hlist
  - ion
  - IORefCAS
- - ip
  - ipatch
  - ipc
  - ipld-cid
···
  - irc-fun-client
  - irc-fun-color
  - irc-fun-messages
- - iri
  - ironforge
  - isevaluated
  - ismtp
···
  - json-incremental-decoder
  - json-query
  - jsons-to-schema
- - json-syntax
  - json-togo
  - json-tokens
  - jspath
···
  - markdown2svg
  - markdown-pap
  - markov-processes
- - markup
  - marmalade-upload
  - marquise
  - marvin
···
  - mpretty
  - mprover
  - mps
- - mptcp-pm
  - msgpack-aeson
  - msgpack-idl
  - msgpack-rpc
···
  - openpgp-crypto-api
  - OpenSCAD
  - openssh-github-keys
+ - opentelemetry-extra_0_7_0
  - opentracing-jaeger
  - opentracing-zipkin-v1
  - open-union
···
  - pairing
  - panda
  - pandoc-japanese-filters
- - pan-os-syslog
  - papa
  - papa-base
  - papa-base-implement
···
  - runtime-arbitrary
  - S3
  - safe-coloured-text-layout-gen
- - safe-numeric
  - safer-file-handles
  - safer-file-handles-bytestring
  - safer-file-handles-text
···
  - scholdoc
  - scholdoc-citeproc
  - scholdoc-texmath
- - scientific-notation
  - SciFlow
  - SciFlow-drmaa
  - scion
···
  - skylark-client
  - slidemews
  - slip32
- - small-bytearray-builder
  - smallstring
  - smartword
  - smcdel
- - smith
  - smith-cli
  - smith-client
  - Smooth
···
  - swearjure
  - sweet-egison
  - switch
+ - sydtest_0_2_0_0
+ - sydtest-persistent-postgresql
  - sylvia
  - symantic-atom
  - symantic-lib
···
  - universe-th
  - unix-fcntl
  - unix-simple
- - unpacked-maybe-numeric
  - unpacked-these
  - unpacked-validation
  - unparse-attoparsec
···
  - urembed
  - uri-enumerator
  - uri-enumerator-file
- - url-bytes
  - UrlDisp
- - urlpath
  - URLT
  - usb
  - usb-enumerator
···
  - uu-cco-examples
  - uu-cco-hut-parsing
  - uu-cco-uu-parsinglib
- - uuid-bytes
  - uuid-crypto
  - uvector-algorithms
  - v4l2
···
  - vfr-waypoints
  - ViennaRNA-extras
  - vigilance
+ - vimeta
  - vinyl-operational
  - vision
  - visual-graphrewrite
···
  - wai-middleware-cache
  - wai-middleware-cache-redis
  - wai-middleware-consul
- - wai-middleware-content-type
  - wai-middleware-rollbar
  - wai-middleware-route
  - wai-session-tokyocabinet
···
  - wheb-redis
  - wheb-strapped
  - whitespace
- - wide-word-instances
  - wikipedia4epub
  - windowslive
  - winio
···
  - wrecker-ui
  - wright
  - writer-cps-full
- - ws
  - wss-client
  - wtk-gtk
  - wumpus-basic
···
  - yesod-colonnade
  - yesod-continuations
  - yesod-examples
- - yesod-ip
  - yesod-mangopay
  - yesod-paypal-rest
  - yesod-platform

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

···
 
   # Use the default version of mysql to build this package (which is actually mariadb).
   # test phase requires networking
-  mysql = dontCheck (super.mysql.override { mysql = pkgs.libmysqlclient; });
+  mysql = dontCheck super.mysql;
 
   # CUDA needs help finding the SDK headers and libraries.
   cuda = overrideCabal super.cuda (drv: {
···
       sed -i 's|"tophat"|"./dist/build/tophat/tophat"|' app-test-bin/*.hs
     '' + (drv.postPatch or "");
   });
+
+  # Runtime dependencies and CLI completion
+  nvfetcher = generateOptparseApplicativeCompletion "nvfetcher" (overrideCabal
+    super.nvfetcher (drv: {
+      buildTools = drv.buildTools or [ ] ++ [ pkgs.makeWrapper ];
+      postInstall = drv.postInstall or "" + ''
+        wrapProgram "$out/bin/nvfetcher" --prefix 'PATH' ':' "${
+          pkgs.lib.makeBinPath [ pkgs.nvchecker pkgs.nix-prefetch-git ]
+        }"
+      '';
+    }));
+
 }

pkgs/development/haskell-modules/generic-builder.nix

···
       # ^^ if the project is not a library, and we have a build target, then use "copy" to install
       # just the target specified; "install" will error here, since not all targets have been built.
     else ''
-      ${setupCommand} copy
+      ${setupCommand} copy ${buildTarget}
       local packageConfDir="$out/lib/${ghc.name}/package.conf.d"
       local packageConfFile="$packageConfDir/${pname}-${version}.conf"
       mkdir -p "$packageConfDir"

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

···
      }:
      mkDerivation {
        pname = "BiobaseBlast";
-       version = "0.3.1.0";
-       sha256 = "153bxf221jga58ibxgd660465klbqj49qr3rk6ni77v7sb4qgrg0";
+       version = "0.3.3.0";
+       sha256 = "11xxm3s6pyy68as6pd3iwfq2dmbgvj2w238jg969fza8vj22xcdb";
        libraryHaskellDepends = [
          aeson attoparsec base binary BiobaseENA BiobaseTypes BiobaseXNA
          bytestring cereal containers deepseq directory file-embed lens
···
      }:
      mkDerivation {
        pname = "BiobaseENA";
-       version = "0.0.0.1";
-       sha256 = "0wkfaxrv4s34amjjl02q0si5nvs18f74z9dxp5r024fd42g3fdka";
+       version = "0.0.0.2";
+       sha256 = "0v999rs3bj4mkbrxsgz0nnqh1pzf7pgxm94519hqjfph5r6yw7nd";
        libraryHaskellDepends = [
          base BiobaseTypes bytestring containers directory file-embed lens
          megaparsec mtl text vector vector-th-unbox
···
 
   "BiobaseFasta" = callPackage
     ({ mkDerivation, base, BiobaseTypes, bytestring, DPutils, filepath
-     , lens, QuickCheck, resourcet, streaming, streaming-bytestring
-     , string-conversions, tasty, tasty-golden, tasty-hunit
-     , tasty-quickcheck, tasty-silver, tasty-th, text
+     , lens, optparse-applicative, QuickCheck, resourcet, streaming
+     , streaming-bytestring, string-conversions, tasty, tasty-golden
+     , tasty-hunit, tasty-quickcheck, tasty-silver, tasty-th, text
      }:
      mkDerivation {
        pname = "BiobaseFasta";
-       version = "0.3.0.1";
-       sha256 = "11vwvqln5jv4k97miyjgqs3yckm8fhyclclhfxq473i4g22amjyh";
+       version = "0.4.0.1";
+       sha256 = "1l5185nsq59jgnpx1r0j5r07a5fqz8f5q2xyxvhwbqan51w51ph6";
+       isLibrary = true;
+       isExecutable = true;
        libraryHaskellDepends = [
          base BiobaseTypes bytestring DPutils lens resourcet streaming
          streaming-bytestring string-conversions
+       ];
+       executableHaskellDepends = [
+         base BiobaseTypes bytestring DPutils lens optparse-applicative
+         resourcet streaming streaming-bytestring string-conversions
        ];
        testHaskellDepends = [
          base BiobaseTypes bytestring DPutils filepath lens QuickCheck
···
   "BiobaseTypes" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bimaps, binary
      , bytestring, cereal, cereal-text, cereal-vector, containers
-     , data-default, deepseq, ForestStructures, hashable, intern, lens
-     , mtl, primitive, PrimitiveArray, QuickCheck, SciBaseTypes
-     , streaming, string-conversions, tasty, tasty-quickcheck, tasty-th
-     , text, text-binary, utf8-string, vector, vector-binary-instances
-     , vector-th-unbox
+     , data-default, deepseq, DPutils, ForestStructures, hashable
+     , intern, lens, mtl, primitive, PrimitiveArray, QuickCheck
+     , SciBaseTypes, streaming, string-conversions, tasty, tasty-hunit
+     , tasty-quickcheck, tasty-th, text, text-binary, utf8-string
+     , vector, vector-binary-instances, vector-th-unbox
      }:
      mkDerivation {
        pname = "BiobaseTypes";
-       version = "0.2.0.1";
-       sha256 = "1ygyq169dcz1bswppljkskvqamvvs61n8fwyyplyf4348i1v938i";
+       version = "0.2.1.0";
+       sha256 = "0gm5nlh8xbww614386vhm2lz118w9c6lcj3pbx5k256mzm7j5yba";
        libraryHaskellDepends = [
          aeson attoparsec base bimaps binary bytestring cereal cereal-text
-         cereal-vector containers data-default deepseq ForestStructures
-         hashable intern lens mtl primitive PrimitiveArray QuickCheck
-         SciBaseTypes streaming string-conversions text text-binary
-         utf8-string vector vector-binary-instances vector-th-unbox
+         cereal-vector containers data-default deepseq DPutils
+         ForestStructures hashable intern lens mtl primitive PrimitiveArray
+         QuickCheck SciBaseTypes streaming string-conversions text
+         text-binary utf8-string vector vector-binary-instances
+         vector-th-unbox
        ];
        testHaskellDepends = [
          aeson attoparsec base bimaps binary bytestring cereal cereal-text
-         cereal-vector containers data-default deepseq ForestStructures
-         hashable intern lens mtl primitive PrimitiveArray QuickCheck
-         SciBaseTypes streaming string-conversions tasty tasty-quickcheck
-         tasty-th text text-binary utf8-string vector
-         vector-binary-instances vector-th-unbox
+         cereal-vector containers data-default deepseq DPutils
+         ForestStructures hashable intern lens mtl primitive PrimitiveArray
+         QuickCheck SciBaseTypes streaming string-conversions tasty
+         tasty-hunit tasty-quickcheck tasty-th text text-binary utf8-string
+         vector vector-binary-instances vector-th-unbox
        ];
        description = "Collection of types for bioinformatics";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, aeson, attoparsec, base, bimaps, binary
      , BiobaseENA, BiobaseTypes, bytes, bytestring, cereal
      , cereal-vector, cmdargs, containers, csv, data-default, deepseq
-     , file-embed, ForestStructures, hashable, lens, mtl, primitive
-     , PrimitiveArray, QuickCheck, split, tasty, tasty-quickcheck
-     , tasty-th, text, tuple, vector, vector-binary-instances
-     , vector-th-unbox
+     , DPutils, file-embed, ForestStructures, hashable, lens, mtl
+     , primitive, PrimitiveArray, QuickCheck, split, tasty
+     , tasty-quickcheck, tasty-th, text, tuple, vector
+     , vector-binary-instances, vector-th-unbox
      }:
      mkDerivation {
        pname = "BiobaseXNA";
-       version = "0.11.0.0";
-       sha256 = "1yrq14mv5bbw6drlpk2cf6incdg2wqw3i0zgdd0vpfmxbwr3wjl4";
+       version = "0.11.1.1";
+       sha256 = "0ws9x3z5ljgm7hnz290yhzm3ijksd6dr4m0drj1lxhchdfmwfy1m";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson attoparsec base bimaps binary BiobaseENA BiobaseTypes bytes
          bytestring cereal cereal-vector containers csv data-default deepseq
-         file-embed ForestStructures hashable lens mtl primitive
+         DPutils file-embed ForestStructures hashable lens mtl primitive
          PrimitiveArray QuickCheck split text tuple vector
          vector-binary-instances vector-th-unbox
        ];
        executableHaskellDepends = [
          aeson attoparsec base bimaps binary BiobaseENA BiobaseTypes bytes
          bytestring cereal cereal-vector cmdargs containers csv data-default
-         deepseq file-embed ForestStructures hashable lens mtl primitive
-         PrimitiveArray QuickCheck split text tuple vector
+         deepseq DPutils file-embed ForestStructures hashable lens mtl
+         primitive PrimitiveArray QuickCheck split text tuple vector
          vector-binary-instances vector-th-unbox
        ];
        testHaskellDepends = [
          aeson attoparsec base bimaps binary BiobaseENA BiobaseTypes bytes
          bytestring cereal cereal-vector containers csv data-default deepseq
-         file-embed ForestStructures hashable lens mtl primitive
+         DPutils file-embed ForestStructures hashable lens mtl primitive
          PrimitiveArray QuickCheck split tasty tasty-quickcheck tasty-th
          text tuple vector vector-binary-instances vector-th-unbox
        ];
···
      }:
      mkDerivation {
        pname = "BlastHTTP";
-       version = "1.4.1";
-       sha256 = "1h7bj9a6qfzwlclr39dvbcz4r8l8s7n53z6ir8wff5ssq2wvq4qd";
+       version = "1.4.2";
+       sha256 = "1ndg24w4qcs7f6ak8qcgfp04mippz2vxpcxwpnsaghyxvpbxqbw6";
        libraryHaskellDepends = [
          base BiobaseBlast BiobaseFasta bytestring conduit either-unwrap
          HTTP http-conduit hxt mtl network transformers zip-archive
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "Color_0_3_2" = callPackage
+    ({ mkDerivation, base, colour, criterion, data-default-class
+     , deepseq, doctest, hspec, HUnit, JuicyPixels, massiv, massiv-test
+     , QuickCheck, random, vector
+     }:
+     mkDerivation {
+       pname = "Color";
+       version = "0.3.2";
+       sha256 = "1v5x32jas70sfqy90brjqlfsy816ar9mcbr3i1lviqivzq7agshk";
+       libraryHaskellDepends = [ base data-default-class deepseq vector ];
+       testHaskellDepends = [
+         base colour doctest hspec HUnit JuicyPixels massiv massiv-test
+         QuickCheck random vector
+       ];
+       benchmarkHaskellDepends = [ base colour criterion deepseq random ];
+       description = "Color spaces and conversions between them";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "Combinatorrent" = callPackage
     ({ mkDerivation, array, attoparsec, base, bytestring, cereal
      , containers, deepseq, directory, filepath, hopenssl, hslogger
···
      }:
      mkDerivation {
        pname = "DPutils";
-       version = "0.1.0.0";
-       sha256 = "153g1rr13jjwqkvfj85nwjhaa0zq8khn24n3dib80nyk0scd4w62";
+       version = "0.1.1.0";
+       sha256 = "1kvj6zkj8r7qp1zvqz68fflxcal3w4qi1y8a70bm6qq5d83ivnd4";
        libraryHaskellDepends = [
-         attoparsec base bytestring containers criterion kan-extensions lens
-         mtl parallel pipes pipes-bytestring pipes-parse primitive
-         QuickCheck smallcheck streaming streaming-bytestring stringsearch
-         tasty tasty-quickcheck tasty-smallcheck tasty-th transformers
+         attoparsec base bytestring containers kan-extensions lens mtl
+         parallel pipes pipes-bytestring pipes-parse primitive QuickCheck
+         smallcheck streaming streaming-bytestring stringsearch transformers
          vector
        ];
        testHaskellDepends = [
-         attoparsec base bytestring containers criterion kan-extensions lens
-         mtl parallel pipes pipes-bytestring pipes-parse primitive
-         QuickCheck smallcheck streaming streaming-bytestring stringsearch
-         tasty tasty-quickcheck tasty-smallcheck tasty-th transformers
-         vector
+         attoparsec base bytestring containers kan-extensions lens mtl
+         parallel pipes pipes-bytestring pipes-parse primitive QuickCheck
+         smallcheck streaming streaming-bytestring stringsearch tasty
+         tasty-quickcheck tasty-smallcheck tasty-th transformers vector
        ];
        benchmarkHaskellDepends = [
          attoparsec base bytestring containers criterion kan-extensions lens
          mtl parallel pipes pipes-bytestring pipes-parse primitive
          QuickCheck smallcheck streaming streaming-bytestring stringsearch
-         tasty tasty-quickcheck tasty-smallcheck tasty-th timeit
-         transformers vector
+         timeit transformers vector
        ];
        description = "utilities for DP";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "JuicyPixels-extra_0_5_1" = callPackage
+    ({ mkDerivation, base, criterion, hspec, hspec-discover
+     , JuicyPixels
+     }:
+     mkDerivation {
+       pname = "JuicyPixels-extra";
+       version = "0.5.1";
+       sha256 = "1kgb2l6ymhjr7wq93jpdhxy3k4i7jz0rz256phz10ycdpyvdbjpq";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [ base JuicyPixels ];
+       testHaskellDepends = [ base hspec JuicyPixels ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [ base criterion JuicyPixels ];
+       description = "Efficiently scale, crop, flip images with JuicyPixels";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "JuicyPixels-repa" = callPackage
     ({ mkDerivation, base, bytestring, JuicyPixels, repa, vector }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "NanoID";
-       version = "1.2.0";
-       sha256 = "1fwbzdj7cn96fbq4vsp4582p317qw3piy237vxf79d0wmdp006zn";
+       version = "2.1.0";
+       sha256 = "0ila2yrdva18y20wm533hkqmmb2mrh1j212jp2ck6p6yiwam687j";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring extra mwc-random ];
···
      }:
      mkDerivation {
        pname = "PrimitiveArray";
-       version = "0.10.1.0";
-       sha256 = "1qjld82q0fdaav6y9ky0bkmqjxvv48502zd3s9i1b72wn436zhib";
+       version = "0.10.1.1";
+       sha256 = "114d41g28i8iah5gpb1377rzfmbcsfay9gr9dhhyyj4dqrpdn1df";
        libraryHaskellDepends = [
          aeson base binary bits cereal cereal-vector containers deepseq
          DPutils hashable hashtables lens log-domain mtl OrderedBits
···
      }) {};
 
   "SciBaseTypes" = callPackage
-    ({ mkDerivation, aeson, base, binary, cereal, deepseq, hashable
-     , lens, log-domain, mtl, QuickCheck, semirings, tasty
+    ({ mkDerivation, aeson, base, binary, cereal, deepseq, DPutils
+     , hashable, lens, log-domain, mtl, QuickCheck, semirings, tasty
      , tasty-quickcheck, tasty-th, vector, vector-th-unbox
      }:
      mkDerivation {
        pname = "SciBaseTypes";
-       version = "0.1.0.0";
-       sha256 = "1c0cgzxhamgswn1zhrarbx5vrmzl160nk8dadzi6mphwd2rv6lfr";
-       revision = "1";
-       editedCabalFile = "025v2s4097mzqyf5bzzz2xnxcc4nckcvaz72pnrxs3d8bbszd26i";
+       version = "0.1.1.0";
+       sha256 = "12k2arn3qbgfa8bc344vv02smqj3yd6rqhnpfib3yi43nkbaazqa";
        libraryHaskellDepends = [
-         aeson base binary cereal deepseq hashable lens log-domain mtl
-         semirings vector vector-th-unbox
+         aeson base binary cereal deepseq DPutils hashable lens log-domain
+         mtl semirings vector vector-th-unbox
        ];
        testHaskellDepends = [
-         aeson base binary cereal deepseq hashable lens log-domain mtl
-         QuickCheck semirings tasty tasty-quickcheck tasty-th vector
+         aeson base binary cereal deepseq DPutils hashable lens log-domain
+         mtl QuickCheck semirings tasty tasty-quickcheck tasty-th vector
          vector-th-unbox
        ];
        benchmarkHaskellDepends = [
-         aeson base binary cereal deepseq hashable lens log-domain mtl
-         semirings vector vector-th-unbox
+         aeson base binary cereal deepseq DPutils hashable lens log-domain
+         mtl semirings vector vector-th-unbox
        ];
        description = "Base types and classes for statistics, sciences and humanities";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "Shpadoinkle" = callPackage
-    ({ mkDerivation, base, category, containers, ghcjs-dom, jsaddle
-     , jsaddle-warp, text, transformers, unliftio, wai, wai-app-static
-     , warp
+    ({ mkDerivation, base, containers, deepseq, ghcjs-dom, jsaddle
+     , jsaddle-warp, mtl, text, transformers, unliftio, wai
+     , wai-app-static, warp
      }:
      mkDerivation {
        pname = "Shpadoinkle";
-       version = "0.3.0.0";
-       sha256 = "083ly6xpdcf7wgrb3shcw26zk0d8rm8issyvki1rwvd29rwj0k41";
+       version = "0.3.2.0";
+       sha256 = "1an13ybgayp532vx040bhjccg3kb429zrcrhc38bkvbs6475y3bz";
        libraryHaskellDepends = [
-         base category containers ghcjs-dom jsaddle jsaddle-warp text
+         base containers deepseq ghcjs-dom jsaddle jsaddle-warp mtl text
          transformers unliftio wai wai-app-static warp
        ];
        description = "A programming model for declarative, high performance user interface";
···
 
   "Shpadoinkle-backend-pardiff" = callPackage
     ({ mkDerivation, base, compactable, containers, exceptions
-     , file-embed, ghcjs-dom, jsaddle, lens, monad-control, mtl, random
-     , semialign, Shpadoinkle, text, these, transformers-base, unliftio
+     , file-embed, ghcjs-dom, jsaddle, monad-control, mtl, random
+     , Shpadoinkle, text, transformers-base, unliftio
      }:
      mkDerivation {
        pname = "Shpadoinkle-backend-pardiff";
-       version = "0.3.0.0";
-       sha256 = "1m12m4qbivh0srdzwzcqr8s6s1hi1blk3x15ljv5c9viriznfy6z";
+       version = "0.3.0.1";
+       sha256 = "1ghj2464pq36paf3z56hc7q0p2nkfgwqjvfa3yymwfr2xdachqwd";
        libraryHaskellDepends = [
          base compactable containers exceptions file-embed ghcjs-dom jsaddle
-         lens monad-control mtl random semialign Shpadoinkle text these
-         transformers-base unliftio
+         monad-control mtl random Shpadoinkle text transformers-base
+         unliftio
        ];
        description = "A Virtual Dom in pure Haskell, based on Html as an Alignable Functor";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "Shpadoinkle-backend-snabbdom" = callPackage
-    ({ mkDerivation, base, exceptions, file-embed, ghcjs-dom, jsaddle
-     , monad-control, mtl, Shpadoinkle, text, transformers-base
-     , unliftio
+    ({ mkDerivation, base, containers, exceptions, file-embed
+     , ghcjs-dom, jsaddle, monad-control, mtl, Shpadoinkle, text
+     , transformers-base, unliftio
      }:
      mkDerivation {
        pname = "Shpadoinkle-backend-snabbdom";
-       version = "0.3.0.1";
-       sha256 = "0452znn1q558n1dy52j493y7f9lml57cnqbmdmqv28zq12sxpypm";
+       version = "0.3.0.2";
+       sha256 = "1hqbfsjlvrkfjf16r5f1jr7fxbki559mbxksqviba80b94wn34ld";
        libraryHaskellDepends = [
-         base exceptions file-embed ghcjs-dom jsaddle monad-control mtl
-         Shpadoinkle text transformers-base unliftio
+         base containers exceptions file-embed ghcjs-dom jsaddle
+         monad-control mtl Shpadoinkle text transformers-base unliftio
        ];
        description = "Use the high-performance Snabbdom virtual dom library written in JavaScript";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, base, compactable, Shpadoinkle, text }:
      mkDerivation {
        pname = "Shpadoinkle-backend-static";
-       version = "0.2.0.0";
-       sha256 = "0kxfsm4g6mwwcrpq8bm83v32jpp97bsvl6ay0ynnmss0yf70ymmi";
+       version = "0.2.0.1";
+       sha256 = "1lcly4kb6im7m1y25209s7wxdvisc0nyfa33a3fjf078ambqpai1";
        libraryHaskellDepends = [ base compactable Shpadoinkle text ];
        description = "A backend for rendering Shpadoinkle as Text";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, aeson, base, jsaddle, lens, text, unliftio }:
      mkDerivation {
        pname = "Shpadoinkle-console";
-       version = "0.0.1.3";
-       sha256 = "0zkiv0h37a3x3569xfvfzdy0dywxhcfx12jddqf9bpfyqsxmf42a";
+       version = "0.0.1.4";
+       sha256 = "1agvyr8785y9dmhdcm36mhvg3lq2ksqly38asb7pb8xynhlvllbk";
        libraryHaskellDepends = [ aeson base jsaddle lens text unliftio ];
        description = "Support for the native browser console";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "Shpadoinkle-developer-tools";
-       version = "0.0.0.1";
-       sha256 = "14lcmxkaxsa42dcyn13cb83lfw48n7139gvppsngzrbn1w9lwrl0";
+       version = "0.0.0.2";
+       sha256 = "1lcz9xlqxzzv8gq31jcd1lw5l8dw14ixkcg14kq73p0418lwm06z";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "Shpadoinkle-disembodied";
-       version = "0.0.0.1";
-       sha256 = "0hiwiv4l1k1al0d9fjk48fay6c33shf213yc9blwm15mfj5kh77c";
+       version = "0.0.0.2";
+       sha256 = "1r96j6lx5k28m0wc4x0pdf81zzml6ppdaw5ywdlv85yxcmv1wxsd";
        libraryHaskellDepends = [
          base directory filepath servant Shpadoinkle
          Shpadoinkle-backend-static Shpadoinkle-html Shpadoinkle-router text
···
 
   "Shpadoinkle-html" = callPackage
     ({ mkDerivation, base, bytestring, compactable, containers
-     , ghcjs-dom, jsaddle, lens, raw-strings-qq, regex-pcre, Shpadoinkle
-     , stm, template-haskell, text, time, transformers, unliftio
+     , directory, ghcjs-dom, jsaddle, lens, process, raw-strings-qq
+     , regex-pcre, Shpadoinkle, stm, template-haskell, text, time
+     , transformers, unliftio
      }:
      mkDerivation {
        pname = "Shpadoinkle-html";
-       version = "0.3.0.0";
-       sha256 = "17n675m9gqfhi2rd8c60bcbljd4nknfrwb02zlw9jwgj1kv7l06k";
+       version = "0.3.0.2";
+       sha256 = "1wi1b4vnag530iz8xzqih1phwgpr96yv3brizmn6yj9j8d0bf5qz";
        libraryHaskellDepends = [
-         base bytestring compactable containers ghcjs-dom jsaddle lens
-         raw-strings-qq regex-pcre Shpadoinkle stm template-haskell text
-         time transformers unliftio
+         base bytestring compactable containers directory ghcjs-dom jsaddle
+         lens process raw-strings-qq regex-pcre Shpadoinkle stm
+         template-haskell text time transformers unliftio
        ];
        description = "A typed, template generated Html DSL, and helpers";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "Shpadoinkle-isreal" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, deepseq
+     , directory, filepath, process, random, servant, servant-server
+     , text, time, warp
+     }:
+     mkDerivation {
+       pname = "Shpadoinkle-isreal";
+       version = "0.0.0.2";
+       sha256 = "1mvc5q5rvsgvgind9pv7389908ikb80qa704vwrzqb2wg2ir5g78";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring containers deepseq random servant
+         servant-server text time
+       ];
+       executableHaskellDepends = [
+         aeson base bytestring containers deepseq directory filepath process
+         random servant servant-server text time warp
+       ];
+       description = "Isreal Swan will make a snowman for you!";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "Shpadoinkle-lens" = callPackage
     ({ mkDerivation, base, lens, Shpadoinkle, text }:
      mkDerivation {
        pname = "Shpadoinkle-lens";
-       version = "0.0.0.3";
-       sha256 = "1310ipmw2z8gdnvaqx1bydvc4p1iyhc7xv31vwbx2aszhmi873kq";
+       version = "0.0.0.4";
+       sha256 = "16lkkyjlxczdcdb8wwj4jvkhi9wsr9d9h5ih6kjdxd9r2qn4zi84";
        libraryHaskellDepends = [ base lens Shpadoinkle text ];
        description = "Lens combinators for Shpadoinkle applications";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "Shpadoinkle-router";
-       version = "0.3.0.0";
-       sha256 = "1wdr71khi7nmyz4ksf7hy6ya470687wmv4x7bvv7qq2z2dsy5ns2";
+       version = "0.3.0.1";
+       sha256 = "0xy09nklsjypaw2dmzl4dzdkrhdlzip2jw41mj1vm7xdvas7i7f1";
        libraryHaskellDepends = [
          aeson base bytestring compactable exceptions ghcjs-dom
          http-api-data http-media http-types jsaddle jsaddle-warp lens
···
     ({ mkDerivation, base, lens, Shpadoinkle, streaming, text }:
      mkDerivation {
        pname = "Shpadoinkle-streaming";
-       version = "0.0.0.1";
-       sha256 = "1bvrkyj9l8asczfamw26x1hwj8bcxr7812zjm1m91jg4xzipayv2";
+       version = "0.0.0.2";
+       sha256 = "1i86299ss25xd1swxd4rz9k5mvxqzhnafiylaawan2fbp2xwqkq2";
        libraryHaskellDepends = [ base lens Shpadoinkle streaming text ];
        description = "Integration of the streaming library with Shpadoinkle continuations";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "Shpadoinkle-template" = callPackage
-    ({ mkDerivation, base, file-embed, html-parse, Shpadoinkle
-     , Shpadoinkle-backend-static, template-haskell, text
+    ({ mkDerivation, base, directory, file-embed, html-entities
+     , html-parse, process, Shpadoinkle, Shpadoinkle-backend-static
+     , template-haskell, text
      }:
      mkDerivation {
        pname = "Shpadoinkle-template";
-       version = "0.0.0.1";
-       sha256 = "1iyxb0hnyfcb4fipwrvzr03g3rai5lc5k7sysrd691l0dsh2jill";
+       version = "0.0.0.2";
+       sha256 = "1alhlc4w9xcyzan0sbsanip3q0yw9pjg094linwwavb211wbcdkj";
        libraryHaskellDepends = [
-         base html-parse Shpadoinkle Shpadoinkle-backend-static
-         template-haskell text
+         base directory html-entities html-parse process Shpadoinkle
+         Shpadoinkle-backend-static template-haskell text
        ];
        testHaskellDepends = [
-         base file-embed html-parse Shpadoinkle Shpadoinkle-backend-static
-         template-haskell text
+         base directory file-embed html-entities html-parse process
+         Shpadoinkle Shpadoinkle-backend-static template-haskell text
        ];
        description = "Read standard file formats into Shpadoinkle with Template Haskell";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "Shpadoinkle-widgets" = callPackage
-    ({ mkDerivation, aeson, base, compactable, containers
-     , edit-distance, email-validate, hspec, jsaddle, mtl, QuickCheck
-     , quickcheck-classes, quickcheck-classes-base, Shpadoinkle
-     , Shpadoinkle-html, stm, template-haskell, text, unliftio
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, compactable
+     , containers, edit-distance, either, email-validate, hspec, jsaddle
+     , mtl, QuickCheck, quickcheck-classes, quickcheck-classes-base
+     , servant, Shpadoinkle, Shpadoinkle-html, stm, template-haskell
+     , text, transformers, unliftio
      }:
      mkDerivation {
        pname = "Shpadoinkle-widgets";
-       version = "0.2.0.0";
-       sha256 = "0q82m3gffcw89xyl0h9ayp2v4k9l1zwpnlpq7kvirl1ahhp2iypy";
+       version = "0.2.0.1";
+       sha256 = "11ncdip5f01d8ng1rgpprl0adrgca19mww86hybckg8v9lxvyfgc";
        libraryHaskellDepends = [
-         aeson base compactable containers edit-distance email-validate
-         jsaddle mtl Shpadoinkle Shpadoinkle-html stm template-haskell text
-         unliftio
+         aeson attoparsec base bytestring compactable containers
+         edit-distance either email-validate jsaddle mtl servant Shpadoinkle
+         Shpadoinkle-html stm template-haskell text transformers unliftio
        ];
        testHaskellDepends = [
          base containers hspec QuickCheck quickcheck-classes
···
     ({ mkDerivation, base, bytestring, transformers, vector, vulkan }:
      mkDerivation {
        pname = "VulkanMemoryAllocator";
-       version = "0.5";
-       sha256 = "1gar1xb7hbc452ck8351wikvryradna9bpphzd9kqwk0kx76nl3n";
+       version = "0.5.1";
+       sha256 = "13savwlcdpvskir5v8yb019cxszrsjrkyisws0w8ddc94a3c9x2c";
        libraryHaskellDepends = [
          base bytestring transformers vector vulkan
        ];
···
 
   "Z-Botan" = callPackage
     ({ mkDerivation, base, Cabal, directory, filepath, ghc-prim, hspec
-     , hspec-discover, HUnit, integer-gmp, QuickCheck
+     , hspec-discover, HUnit, integer-gmp, primitive, QuickCheck
      , quickcheck-instances, scientific, stm, time, Z-Data, Z-IO
      }:
      mkDerivation {
        pname = "Z-Botan";
-       version = "0.3.1.0";
-       sha256 = "0920pzs9q105h32d7yp83bblhq0id5vzzw3d2pysg4dd127933xc";
+       version = "0.4.0.0";
+       sha256 = "0jlw9wk8yhgsqjn3grzkq2a1p90dil1ayx30cvg85c2y96j5x8jn";
        enableSeparateDataOutput = true;
        setupHaskellDepends = [ base Cabal directory filepath ];
        libraryHaskellDepends = [
-         base ghc-prim integer-gmp scientific stm time Z-Data Z-IO
+         base ghc-prim integer-gmp primitive scientific stm time Z-Data Z-IO
        ];
        libraryToolDepends = [ hspec-discover ];
        testHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "Z-Data";
-       version = "0.8.3.0";
-       sha256 = "1y8vgz3jps2vsg5ay9s792knfyk5cvc6549q5li51jaqibsrw99m";
+       version = "0.8.5.0";
+       sha256 = "1ib9lhhjymr4020yqrc318xqp7swr17iiczpb18d061ngcw8xi90";
        setupHaskellDepends = [ base Cabal ];
        libraryHaskellDepends = [
          base bytestring case-insensitive containers deepseq ghc-prim
···
        ];
        description = "A full-featured library for parsing, validating, and rendering email addresses";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "adhoc-network" = callPackage
···
      }:
      mkDerivation {
        pname = "arion-compose";
-       version = "0.1.2.0";
-       sha256 = "1vginzc90xl8fs1pr9qvw7fjj207vjb1k3rxa341hq7q5pri2y3d";
+       version = "0.1.3.0";
+       sha256 = "1pw0vqx1y3zgq303gdgd3vkz95mqrv8hl0pfkw6kyc49hj7l864y";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        ];
        description = "Parse IP data types with attoparsec";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "attoparsec-iso8601" = callPackage
···
        ];
        description = "URI parser / printer using attoparsec";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "attoparsec-varword" = callPackage
···
        ];
        description = "Base62 encoding and decoding";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "base64" = callPackage
···
        license = lib.licenses.gpl3Only;
      }) {inherit (pkgs) snappy;};
 
+  "biscuit-haskell" = callPackage
+    ({ mkDerivation, async, attoparsec, base, base16-bytestring, base64
+     , bytestring, cereal, containers, libsodium, mtl
+     , parser-combinators, primitive, protobuf, random, regex-tdfa
+     , tasty, tasty-hunit, template-haskell, text, th-lift-instances
+     , time, validation-selective
+     }:
+     mkDerivation {
+       pname = "biscuit-haskell";
+       version = "0.1.0.0";
+       sha256 = "0h37sl493ribsvqw98xy4g9vii3xc3ap6vvjffn7xg29b62s0lrx";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         async attoparsec base base16-bytestring base64 bytestring cereal
+         containers libsodium mtl parser-combinators primitive protobuf
+         random regex-tdfa template-haskell text th-lift-instances time
+         validation-selective
+       ];
+       executableHaskellDepends = [
+         async attoparsec base base16-bytestring base64 bytestring cereal
+         containers libsodium mtl parser-combinators primitive protobuf
+         random template-haskell text th-lift-instances time
+         validation-selective
+       ];
+       testHaskellDepends = [
+         async attoparsec base base16-bytestring base64 bytestring cereal
+         containers libsodium mtl parser-combinators primitive protobuf
+         random tasty tasty-hunit template-haskell text th-lift-instances
+         time validation-selective
+       ];
+       description = "Library support for the Biscuit security token";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "bisect-binary" = callPackage
     ({ mkDerivation, base, bytestring, directory, filepath, hashable
      , haskeline, integer-logarithms, optparse-applicative, process
···
      }:
      mkDerivation {
        pname = "blucontrol";
-       version = "0.3.1.0";
-       sha256 = "035lrn1j6hrvl5vs5k0q1hb3zwbqh5bvxmfxvjvv9lncv8iy2nd9";
+       version = "0.3.2.0";
+       sha256 = "1rg9gsrkwnpabrpgl0xh0z9wa1gkqi5vgxpfg7lfz6jcb72qsas6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "byline";
-       version = "1.1.0.1";
-       sha256 = "1vj17x2czfks5bdns8181iw7rbfghk9pgx5f75xwzn9p6xycg9hy";
+       version = "1.1.1";
+       sha256 = "0yy9hd8yhpi175fgnp8cd4h0bifx2zvy82jmbkd28kpbgw6b49vi";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Serialize to a small byte arrays";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "bytedump" = callPackage
···
        ];
        description = "Nonresumable byte parser";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "bytestring_0_11_1_0" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "cdar-mBound_0_1_0_4" = callPackage
+    ({ mkDerivation, base, containers, criterion, deepseq, integer-gmp
+     , smallcheck, tasty, tasty-hunit, tasty-quickcheck
+     , tasty-smallcheck
+     }:
+     mkDerivation {
+       pname = "cdar-mBound";
+       version = "0.1.0.4";
+       sha256 = "1p7ri7vfvj3ym0038aq12szs6jgdkq8a4730i67appv9lmxgycfn";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base containers deepseq integer-gmp ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base smallcheck tasty tasty-hunit tasty-quickcheck tasty-smallcheck
+       ];
+       benchmarkHaskellDepends = [ base criterion ];
+       description = "Exact real arithmetic using Centred Dyadic Approximations";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "cdeps" = callPackage
     ({ mkDerivation, alex, array, base, bytestring, criterion
      , directory, filepath, hspec, optparse-applicative, text
···
        license = lib.licenses.bsd2;
      }) {};
 
-  "citeproc_0_4" = callPackage
+  "citeproc_0_4_0_1" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring
      , case-insensitive, containers, data-default, Diff, directory
      , file-embed, filepath, mtl, pandoc-types, pretty, safe, scientific
···
      }:
      mkDerivation {
        pname = "citeproc";
-       version = "0.4";
-       sha256 = "0ca6xyv0pa0w10pzn7zmpvg6583xjs8ffj16ykkrw9gjd4nlginh";
+       version = "0.4.0.1";
+       sha256 = "13hgbcbr7jbyfbxp8fsc43c2wq4fhlbxzqwh1plfkdi5n9bif1lv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "compact";
        version = "0.2.0.0";
        sha256 = "0xv24vd2h76928355rr8gzdbkyn2j17yf6wjyghnzw7qyhsbb9h3";
+       revision = "1";
+       editedCabalFile = "1013dkawaw3c6hvlfn9x584pq8z65fvbnp79dl6ll6r0a75rivvm";
        libraryHaskellDepends = [ base binary bytestring ghc-compact ];
        testHaskellDepends = [ base directory ];
        description = "Non-GC'd, contiguous storage for immutable data structures";
···
        sha256 = "0l9d7hj66fygpsbjw6wy4l11c9cw739lvkrypapwihav7jzva541";
        libraryHaskellDepends = [ base containers deepseq ];
        description = "Provide orphan NFData instances for containers as needed. (deprecated)";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "containers-good-graph" = callPackage
+    ({ mkDerivation, array, base, containers, deepseq }:
+     mkDerivation {
+       pname = "containers-good-graph";
+       version = "0.6.4.1";
+       sha256 = "1bv4v8q9gi1fa46c3pqj0kyl28kbyn55i038d0fxqbi225pdhhan";
+       libraryHaskellDepends = [ array base containers deepseq ];
+       testHaskellDepends = [ array base containers deepseq ];
+       description = "Data.Graph, but it doesn't suck!";
        license = lib.licenses.bsd3;
      }) {};
 
···
        maintainers = with lib.maintainers; [ Gabriel439 ];
      }) {};
 
+  "dhall_1_39_0" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, atomic-write
+     , base, bytestring, case-insensitive, cborg, cborg-json, containers
+     , contravariant, cryptonite, data-fix, deepseq, Diff, directory
+     , doctest, dotgen, either, exceptions, filepath, foldl, gauge
+     , generic-random, half, hashable, haskeline, http-client
+     , http-client-tls, http-types, lens-family-core, megaparsec, memory
+     , mmorph, mockery, mtl, network-uri, optparse-applicative
+     , parser-combinators, parsers, pretty-simple, prettyprinter
+     , prettyprinter-ansi-terminal, profunctors, QuickCheck
+     , quickcheck-instances, repline, scientific, serialise
+     , special-values, spoon, tasty, tasty-expected-failure, tasty-hunit
+     , tasty-quickcheck, tasty-silver, template-haskell, text
+     , text-manipulate, th-lift-instances, transformers
+     , transformers-compat, turtle, unordered-containers, uri-encode
+     , vector
+     }:
+     mkDerivation {
+       pname = "dhall";
+       version = "1.39.0";
+       sha256 = "1by2d84fbckspczddl4npfsf89q6nprmbg0i5g8yr1psp0fpl4ab";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson aeson-pretty ansi-terminal atomic-write base bytestring
+         case-insensitive cborg cborg-json containers contravariant
+         cryptonite data-fix deepseq Diff directory dotgen either exceptions
+         filepath half hashable haskeline http-client http-client-tls
+         http-types lens-family-core megaparsec memory mmorph mtl
+         network-uri optparse-applicative parser-combinators parsers
+         pretty-simple prettyprinter prettyprinter-ansi-terminal profunctors
+         repline scientific serialise template-haskell text text-manipulate
+         th-lift-instances transformers transformers-compat
+         unordered-containers uri-encode vector
+       ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base bytestring cborg containers data-fix deepseq directory doctest
+         either filepath foldl generic-random http-client http-client-tls
+         lens-family-core megaparsec mockery prettyprinter QuickCheck
+         quickcheck-instances scientific serialise special-values spoon
+         tasty tasty-expected-failure tasty-hunit tasty-quickcheck
+         tasty-silver template-haskell text transformers turtle
+         unordered-containers vector
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring containers directory gauge text
+       ];
+       doCheck = false;
+       description = "A configuration language guaranteed to terminate";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ Gabriel439 ];
+     }) {};
+
   "dhall-bash" = callPackage
     ({ mkDerivation, base, bytestring, containers, dhall
      , neat-interpolation, optparse-generic, shell-escape, text
···
        maintainers = with lib.maintainers; [ Gabriel439 ];
      }) {};
 
+  "dhall-bash_1_0_37" = callPackage
+    ({ mkDerivation, base, bytestring, containers, dhall
+     , neat-interpolation, optparse-generic, shell-escape, text
+     }:
+     mkDerivation {
+       pname = "dhall-bash";
+       version = "1.0.37";
+       sha256 = "0gm6zamh8kgrc2d00cjf2ijb49ic3z6rlk0ngmig8hckmsy63w1d";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring containers dhall neat-interpolation shell-escape
+         text
+       ];
+       executableHaskellDepends = [
+         base bytestring dhall optparse-generic text
+       ];
+       description = "Compile Dhall to Bash";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ Gabriel439 ];
+     }) {};
+
   "dhall-check" = callPackage
     ({ mkDerivation, base, containers, dhall, directory, filepath
      , fsnotify, text, trifecta
···
 
   "dhall-docs" = callPackage
     ({ mkDerivation, base, bytestring, containers, cryptonite, dhall
-     , directory, doctest, file-embed, filepath, foldl, lens-family-core
-     , lucid, megaparsec, memory, mmark, mtl, optparse-applicative, path
-     , path-io, pretty, prettyprinter, tasty, tasty-hunit, tasty-silver
-     , text, transformers, turtle
+     , directory, doctest, file-embed, filepath, foldl, hashable
+     , lens-family-core, lucid, megaparsec, memory, mmark, mtl
+     , optparse-applicative, path, path-io, pretty, prettyprinter, tasty
+     , tasty-hunit, tasty-silver, text, transformers, turtle
      }:
      mkDerivation {
        pname = "dhall-docs";
-       version = "1.0.5";
-       sha256 = "00s1vhwilnr6hvv56w98kc1md08lw6v80v8a7yhwrmg9qggwdc12";
-       revision = "1";
-       editedCabalFile = "0y8a02jxz5cap0q4b2106ck4av7haxqlv5vjhm0nmrsq10cl4nss";
+       version = "1.0.6";
+       sha256 = "004n8kh8riw67aqwp6z9199jwv2c9r1dbkg92s71vd9zc04wxljv";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        executableHaskellDepends = [ base dhall ];
        testHaskellDepends = [
          base bytestring containers dhall directory doctest filepath foldl
-         path path-io pretty tasty tasty-hunit tasty-silver text turtle
+         hashable path path-io pretty tasty tasty-hunit tasty-silver text
+         turtle
        ];
        description = "Generate HTML docs from a dhall package";
        license = lib.licenses.bsd3;
···
        maintainers = with lib.maintainers; [ Gabriel439 ];
      }) {};
 
+  "dhall-json_1_7_7" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, aeson-yaml, ansi-terminal
+     , base, bytestring, containers, dhall, exceptions, filepath
+     , lens-family-core, optparse-applicative, prettyprinter
+     , prettyprinter-ansi-terminal, scientific, tasty, tasty-hunit
+     , tasty-silver, text, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "dhall-json";
+       version = "1.7.7";
+       sha256 = "163600cr04a5c9gjqg0846wwjp4wl61yhfg80zvsadkaq5zfzlll";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson aeson-pretty aeson-yaml base bytestring containers dhall
+         exceptions filepath lens-family-core optparse-applicative
+         prettyprinter scientific text unordered-containers vector
+       ];
+       executableHaskellDepends = [
+         aeson aeson-pretty ansi-terminal base bytestring dhall exceptions
+         optparse-applicative prettyprinter prettyprinter-ansi-terminal text
+       ];
+       testHaskellDepends = [
+         aeson base bytestring dhall tasty tasty-hunit tasty-silver text
+       ];
+       description = "Convert between Dhall and JSON or YAML";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ Gabriel439 ];
+     }) {};
+
   "dhall-lex" = callPackage
     ({ mkDerivation, alex, array, base, bytestring, criterion, deepseq
      , hspec, hspec-dirstream, scientific
···
        maintainers = with lib.maintainers; [ Gabriel439 ];
      }) {};
 
+  "dhall-lsp-server_1_0_15" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
+     , data-default, dhall, dhall-json, directory, doctest, filepath
+     , haskell-lsp, haskell-lsp-types, hslogger, hspec, lens, lsp-test
+     , megaparsec, mtl, network-uri, optparse-applicative, prettyprinter
+     , QuickCheck, rope-utf16-splay, tasty, tasty-hspec, text
+     , transformers, unordered-containers, uri-encode
+     }:
+     mkDerivation {
+       pname = "dhall-lsp-server";
+       version = "1.0.15";
+       sha256 = "0bq6k92g22vdym9zyj95gx052yyzvgr1jv7yszlcj8p5angbxdqy";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson aeson-pretty base bytestring containers data-default dhall
+         dhall-json directory filepath haskell-lsp hslogger lens megaparsec
+         mtl network-uri prettyprinter rope-utf16-splay text transformers
+         unordered-containers uri-encode
+       ];
+       executableHaskellDepends = [ base optparse-applicative ];
+       testHaskellDepends = [
+         base directory doctest filepath haskell-lsp-types hspec lsp-test
+         QuickCheck tasty tasty-hspec text
+       ];
+       description = "Language Server Protocol (LSP) server for Dhall";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ Gabriel439 ];
+     }) {};
+
   "dhall-nix" = callPackage
     ({ mkDerivation, base, containers, data-fix, dhall, hnix
      , lens-family-core, neat-interpolation, optparse-generic, text
···
        maintainers = with lib.maintainers; [ Gabriel439 ];
      }) {};
 
+  "dhall-nix_1_1_21" = callPackage
+    ({ mkDerivation, base, containers, data-fix, dhall, hnix
+     , lens-family-core, neat-interpolation, optparse-generic, text
+     }:
+     mkDerivation {
+       pname = "dhall-nix";
+       version = "1.1.21";
+       sha256 = "0yqqjq8yqswcaiqrrgx37rlwvxgciwhvird34hsaq4fr3kbjgv4h";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers data-fix dhall hnix lens-family-core
+         neat-interpolation text
+       ];
+       executableHaskellDepends = [
+         base dhall hnix optparse-generic text
+       ];
+       description = "Dhall to Nix compiler";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ Gabriel439 ];
+     }) {};
+
   "dhall-nixpkgs" = callPackage
     ({ mkDerivation, aeson, base, data-fix, dhall, foldl, hnix
      , lens-family-core, megaparsec, mmorph, neat-interpolation
···
      }:
      mkDerivation {
        pname = "dhall-nixpkgs";
-       version = "1.0.4";
-       sha256 = "0yr7z17dvmr1zipk29fmzm46myxxsz514587n6a7h00c56dyvnc3";
-       revision = "1";
-       editedCabalFile = "1y08jxg51sbxx0i7ra45ii2v81plzf4hssmwlrw35l8n5gib1vcg";
+       version = "1.0.5";
+       sha256 = "10gvkw2rdmz7pgr9675xqnhkgi8pwjid77mwsriid81d703z2b6j";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        maintainers = with lib.maintainers; [ Gabriel439 ];
      }) {};
 
+  "dhall-openapi_1_0_1" = callPackage
+    ({ mkDerivation, aeson, base, containers, dhall, directory
+     , filepath, megaparsec, optparse-applicative, parser-combinators
+     , prettyprinter, scientific, sort, text, vector
+     }:
+     mkDerivation {
+       pname = "dhall-openapi";
+       version = "1.0.1";
+       sha256 = "1n34amb97dqpvz0s3mhqb46gjq1ix1gicsq700z6v6y7xssrgbz2";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base containers dhall prettyprinter scientific sort text
+         vector
+       ];
+       executableHaskellDepends = [
+         aeson base containers dhall directory filepath megaparsec
+         optparse-applicative parser-combinators prettyprinter sort text
+         vector
+       ];
+       description = "Convert an OpenAPI specification to a Dhall package";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ Gabriel439 ];
+     }) {};
+
   "dhall-recursive-adt" = callPackage
     ({ mkDerivation, base, data-fix, dhall, either, hedgehog
-     , neat-interpolation, recursion-schemes, tasty, tasty-hedgehog
-     , tasty-hunit
+     , recursion-schemes, tasty, tasty-hedgehog, tasty-hunit, yasi
      }:
      mkDerivation {
        pname = "dhall-recursive-adt";
-       version = "0.1.0.0";
-       sha256 = "01wk6xsakbhsx14s59f0rj32mlccgxgc29a3n5d3b923yd5w64zm";
-       revision = "1";
-       editedCabalFile = "0gj4dsl70wjn4bpi62dqcqc9y9wwj2c9w6rai620ps4ykg36pygb";
+       version = "0.1.0.1";
+       sha256 = "09s3m86vflj5im2walab8d0wpvihsvxc5mzy55m10pfzr3gxsd11";
        libraryHaskellDepends = [ base data-fix dhall recursion-schemes ];
        testHaskellDepends = [
-         base dhall either hedgehog neat-interpolation recursion-schemes
-         tasty tasty-hedgehog tasty-hunit
+         base dhall either hedgehog recursion-schemes tasty tasty-hedgehog
+         tasty-hunit yasi
        ];
        description = "Convert recursive ADTs from and to Dhall";
        license = lib.licenses.cc0;
···
        maintainers = with lib.maintainers; [ Gabriel439 ];
      }) {};
 
+  "dhall-yaml_1_2_7" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, base, bytestring, dhall
+     , dhall-json, exceptions, HsYAML, HsYAML-aeson
+     , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal
+     , tasty, tasty-expected-failure, tasty-hunit, text, vector
+     }:
+     mkDerivation {
+       pname = "dhall-yaml";
+       version = "1.2.7";
+       sha256 = "17fpxjlhmjnra92l8iv4k40bxbx1plmhkijf6axxkjyhfh0ax303";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring dhall dhall-json HsYAML HsYAML-aeson
+         optparse-applicative text vector
+       ];
+       executableHaskellDepends = [
+         aeson ansi-terminal base bytestring dhall dhall-json exceptions
+         optparse-applicative prettyprinter prettyprinter-ansi-terminal text
+       ];
+       testHaskellDepends = [
+         base bytestring dhall dhall-json tasty tasty-expected-failure
+         tasty-hunit text
+       ];
+       description = "Convert between Dhall and YAML";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ Gabriel439 ];
+     }) {};
+
   "dhcp-lease-parser" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, chronos, ip, tasty
      , tasty-hunit, text
···
        description = "Parse a DHCP lease file";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "dhrun" = callPackage
···
        pname = "diagrams-lib";
        version = "1.4.4";
        sha256 = "09np7kj8si8kcb854f95a0cq392mgbxif8lnazbpfsa1k87d9vzy";
+       revision = "1";
+       editedCabalFile = "1c7kpnbvxwdcmk5znqyig3l6s986ppj168ck5v72dfbp8cjvwa8i";
        libraryHaskellDepends = [
          active adjunctions array base bytestring cereal colour containers
          data-default-class diagrams-core diagrams-solve directory
···
      }:
      mkDerivation {
        pname = "discord-haskell";
-       version = "1.8.7";
-       sha256 = "0nby3267nhdgc8692k5c28yy0a2bzvl84dn54sg25j6nchzs991g";
+       version = "1.8.8";
+       sha256 = "0fvj9m59gsdicl061xlkqq8hrwsksyrysjdh5ijbv8gaql99k17v";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "equational-reasoning";
        version = "0.7.0.0";
        sha256 = "0l6gyq43byh6cy2pblb9a4qjy7w5k9maa97c076dxlsf53myj01h";
-       revision = "1";
-       editedCabalFile = "1a8dw9givg0przqrm33kkmff9r0fdv1ih6ik3dqa99ww71cc8q66";
+       revision = "2";
+       editedCabalFile = "0zlcd62kapcybli65w47mb1kg5fnyzgdnf7kr8y8qgslg0lidzpp";
        libraryHaskellDepends = [
          base containers template-haskell th-desugar void
        ];
···
        pname = "exp-extended";
        version = "0.2";
        sha256 = "14bz6wfzd8b51s09d2psg5hv5zq4f8lplgx0yvd3n0z704x3mcy6";
+       revision = "1";
+       editedCabalFile = "1kzrlr1j6xfm8r9j1iz9vp2c7x72gmmqzmki1ypxaawdzibyfysl";
        libraryHaskellDepends = [ base ];
        description = "floating point with extended exponent range";
        license = lib.licenses.bsd3;
···
        benchmarkHaskellDepends = [ base leancheck ];
        description = "Dynamically-typed expressions involving applications and variables";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "express_0_1_14" = callPackage
+    ({ mkDerivation, base, leancheck, template-haskell }:
+     mkDerivation {
+       pname = "express";
+       version = "0.1.14";
+       sha256 = "19sjh12sjpxhk7wg2b3abga7bpk6ckry19zi58imqmy8xbh6ds39";
+       libraryHaskellDepends = [ base template-haskell ];
+       testHaskellDepends = [ base leancheck ];
+       benchmarkHaskellDepends = [ base leancheck ];
+       description = "Dynamically-typed expressions involving applications and variables";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "expression-parser" = callPackage
···
        ];
        description = "GHC plugin to make stream fusion more predictable";
        license = lib.licenses.asl20;
+     }) {};
+
+  "fusion-plugin_0_2_3" = callPackage
+    ({ mkDerivation, base, containers, directory, filepath
+     , fusion-plugin-types, ghc, syb, time, transformers
+     }:
+     mkDerivation {
+       pname = "fusion-plugin";
+       version = "0.2.3";
+       sha256 = "1lklrd3afvm8fwd14yiavx5h8zxjkn2k2vqnxbqwcakcnljxrfyq";
+       libraryHaskellDepends = [
+         base containers directory filepath fusion-plugin-types ghc syb time
+         transformers
+       ];
+       description = "GHC plugin to make stream fusion more predictable";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "fusion-plugin-types" = callPackage
···
        broken = true;
      }) {};
 
+  "hackage-db_2_1_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
+     , directory, exceptions, filepath, tar, time, utf8-string
+     }:
+     mkDerivation {
+       pname = "hackage-db";
+       version = "2.1.0";
+       sha256 = "1vsc0lrbrb525frycqq0c5z846whymgcjl888gnlqd16nknbsn3l";
+       revision = "1";
+       editedCabalFile = "1h3x5a8xmqkkcd3h1m7z0il1vbsh2c77685y68zmyp21zb1y88hy";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring Cabal containers directory exceptions
+         filepath tar time utf8-string
+       ];
+       description = "Access cabal-install's Hackage database via Data.Map";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ peti ];
+     }) {};
+
   "hackage-db" = callPackage
     ({ mkDerivation, aeson, base, bytestring, Cabal, containers
      , directory, exceptions, filepath, tar, time, utf8-string
···
      , parsec, process, QuickCheck, random, regex-tdfa, resourcet
      , scientific, tagsoup, tasty, tasty-golden, tasty-hunit
      , tasty-quickcheck, template-haskell, text, time
-     , time-locale-compat, unordered-containers, utillinux, vector, wai
+     , time-locale-compat, unordered-containers, util-linux, vector, wai
      , wai-app-static, warp, yaml
      }:
      mkDerivation {
···
          base bytestring containers filepath QuickCheck tasty tasty-golden
          tasty-hunit tasty-quickcheck text unordered-containers yaml
        ];
-       testToolDepends = [ utillinux ];
+       testToolDepends = [ util-linux ];
        description = "A static website compiler library";
        license = lib.licenses.bsd3;
        maintainers = with lib.maintainers; [ erictapen ];
-     }) {inherit (pkgs) utillinux;};
+     }) {inherit (pkgs) util-linux;};
 
   "hakyll-R" = callPackage
     ({ mkDerivation, base, directory, filepath, hakyll, pandoc, process
···
 
   "hasklepias" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, flow, hspec
-     , interval-algebra, QuickCheck, safe, text, time
+     , interval-algebra, lens, lens-aeson, QuickCheck, safe, text, time
      , unordered-containers, vector, witherable
      }:
      mkDerivation {
        pname = "hasklepias";
-       version = "0.7.1";
-       sha256 = "1w6gs3n1g12sw2w72l04l27na3kgmyqsip8d53wpmslqwccr6blc";
+       version = "0.8.3";
+       sha256 = "01lq7q9gq7b5zi2bwlc6wpj914l660cl5wlvbznimhfnkr1aqrgm";
        libraryHaskellDepends = [
-         aeson base bytestring containers flow interval-algebra QuickCheck
-         safe text time unordered-containers vector witherable
+         aeson base bytestring containers flow interval-algebra lens
+         lens-aeson QuickCheck safe text time unordered-containers vector
+         witherable
        ];
        testHaskellDepends = [
-         aeson base bytestring containers flow hspec interval-algebra
+         aeson base bytestring containers flow hspec interval-algebra lens
          QuickCheck text time unordered-containers vector
        ];
        description = "Define features from events";
···
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        broken = true;
+     }) {};
+
+  "hindley-milner-type-check" = callPackage
+    ({ mkDerivation, base, containers, data-fix, deepseq
+     , deriving-compat, dlist, mtl, prettyprinter, tasty, tasty-hunit
+     , text
+     }:
+     mkDerivation {
+       pname = "hindley-milner-type-check";
+       version = "0.1.0.0";
+       sha256 = "0ym8jchjx6n9i6n76b852s511n0vafz8ixr22zx7lrzqi9ax4ayz";
+       libraryHaskellDepends = [
+         base containers data-fix deepseq deriving-compat dlist mtl
+         prettyprinter text
+       ];
+       testHaskellDepends = [
+         base containers data-fix prettyprinter tasty tasty-hunit text
+       ];
+       description = "Type inference for Hindley-Milner based languages";
+       license = lib.licenses.mit;
      }) {};
 
   "hinduce-associations-apriori" = callPackage
···
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
+
+  "hscdio" = callPackage
+    ({ mkDerivation, base, base-compat, bitwise, bytestring, c2hs, cdio
+     , containers, directory, hedgehog, hedgehog-classes, HUnit, mtl
+     , text, vector
+     }:
+     mkDerivation {
+       pname = "hscdio";
+       version = "0.1.0.0";
+       sha256 = "0lwyy8x5zrdl0mg7siclagic7xg2iywapwkdk8kcz3ksdsir7xpd";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bitwise bytestring containers mtl text vector
+       ];
+       librarySystemDepends = [ cdio ];
+       libraryToolDepends = [ c2hs ];
+       testHaskellDepends = [
+         base base-compat bytestring directory hedgehog hedgehog-classes
+         HUnit text
+       ];
+       description = "Haskell bindings to the libcdio disc-reading library";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {cdio = null;};
 
   "hscharm" = callPackage
     ({ mkDerivation, base, random, random-shuffle }:
···
        ];
        description = "Library for IP and MAC addresses";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ip-quoter" = callPackage
···
        description = "RFC-based resource identifier library";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "iridium" = callPackage
···
        description = "High-performance JSON parser and encoder";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "json-to-haskell" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "leancheck_0_9_10" = callPackage
+    ({ mkDerivation, base, template-haskell }:
+     mkDerivation {
+       pname = "leancheck";
+       version = "0.9.10";
+       sha256 = "0d35w3y309fw3bkaj6fxyl67k4cp32mp003l44m3m2z2fvq08cdn";
+       libraryHaskellDepends = [ base template-haskell ];
+       testHaskellDepends = [ base ];
+       description = "Enumerative property-based testing";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "leancheck-enum-instances" = callPackage
     ({ mkDerivation, base, enum-types, leancheck }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "lentil";
-       version = "1.5.1.0";
-       sha256 = "03h7fk37rrxpnxfpckpfi5k3v7ch4v5vn601m9lj9shbs26h1cdx";
+       version = "1.5.2.0";
+       sha256 = "0mkr8ng7i4cli8wscqy2l8112nr7wdg8dh32li354fvahmv6i4si";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
   "libarchive" = callPackage
     ({ mkDerivation, base, bytestring, c2hs, Cabal, chs-cabal
      , composition-prelude, cpphs, criterion, deepseq, dir-traverse
-     , directory, dlist, filepath, hspec, libarchive, mtl
+     , directory, dlist, filepath, hspec, hspec-core, libarchive, mtl
      , pathological-bytestrings, tar, tar-conduit, temporary
      , unix-compat
      }:
      mkDerivation {
        pname = "libarchive";
-       version = "3.0.2.1";
-       sha256 = "16h5pw49g9nc4aq7g8hwj1bq1raf1jas09xcsk99sylssvf2yf43";
+       version = "3.0.2.2";
+       sha256 = "1i3zrby1pmlm7dwv1xra9xmlv4a30cgmbwz5zygdyw1mwy4y9wnh";
        setupHaskellDepends = [ base Cabal chs-cabal ];
        libraryHaskellDepends = [
          base bytestring composition-prelude deepseq dlist filepath mtl
          unix-compat
        ];
        libraryPkgconfigDepends = [ libarchive ];
-       libraryToolDepends = [ c2hs ];
+       libraryToolDepends = [ c2hs cpphs ];
        testHaskellDepends = [
          base bytestring composition-prelude dir-traverse directory filepath
-         hspec mtl pathological-bytestrings temporary
+         hspec hspec-core mtl pathological-bytestrings temporary
        ];
        testToolDepends = [ cpphs ];
        benchmarkHaskellDepends = [
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
+     }) {};
+
+  "lifx-lan" = callPackage
+    ({ mkDerivation, base, binary, bytestring, composition, containers
+     , extra, monad-loops, mtl, network, random, safe, text, time
+     }:
+     mkDerivation {
+       pname = "lifx-lan";
+       version = "0.1.0.2";
+       sha256 = "0kk89h1jxz7djxcxz4scwk33r9y1raq8mskypcyx93hzs0f1b4y1";
+       libraryHaskellDepends = [
+         base binary bytestring composition containers extra monad-loops mtl
+         network random safe text time
+       ];
+       description = "LIFX LAN API";
+       license = lib.licenses.bsd3;
      }) {};
 
   "ligature" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "literatex_0_1_0_1" = callPackage
+    ({ mkDerivation, ansi-wl-pprint, base, bytestring, conduit
+     , filepath, optparse-applicative, tasty, tasty-hunit, text, ttc
+     , unliftio
+     }:
+     mkDerivation {
+       pname = "literatex";
+       version = "0.1.0.1";
+       sha256 = "0nig3k78h86b80hsfqm04g9jc24lsicbw2pc3wnvxfs3nhkmhl0b";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring conduit text ttc unliftio
+       ];
+       executableHaskellDepends = [
+         ansi-wl-pprint base optparse-applicative ttc
+       ];
+       testHaskellDepends = [
+         base bytestring filepath tasty tasty-hunit text ttc unliftio
+       ];
+       description = "transform literate source code to Markdown";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "little-earley" = callPackage
     ({ mkDerivation, base, containers, mtl, tasty, tasty-hunit }:
      mkDerivation {
···
      }) {};
 
   "little-logger" = callPackage
-    ({ mkDerivation, base, co-log, co-log-core, microlens, mtl, tasty
-     , tasty-hunit, text, unliftio-core
+    ({ mkDerivation, base, co-log, co-log-core, directory, microlens
+     , mtl, tasty, tasty-hunit, temporary, text, unliftio-core
      }:
      mkDerivation {
        pname = "little-logger";
-       version = "0.3.1";
-       sha256 = "0iqnidlv7r2kw6764aq3dlvxbmvm1c7qk8jkgbhbpm5g07k97c68";
+       version = "0.3.2";
+       sha256 = "0pwywpxdladsaprdzw856njcn42js7l73f361m0w3gd86xprwm8y";
        libraryHaskellDepends = [
          base co-log co-log-core microlens mtl text unliftio-core
        ];
        testHaskellDepends = [
-         base co-log co-log-core microlens mtl tasty tasty-hunit text
-         unliftio-core
+         base co-log co-log-core directory microlens mtl tasty tasty-hunit
+         temporary text unliftio-core
        ];
        description = "Basic logging based on co-log";
        license = lib.licenses.bsd3;
···
        pname = "long-double";
        version = "0.1.1";
        sha256 = "0byrpngsh1a8w9n5nbw9lfmj4nmh33avzfh883zw9ya10pfa7x3g";
+       revision = "1";
+       editedCabalFile = "0831x773ypp0lv14cgh6vr7rzbyvrjsvw99c40z41fr8bhdw2x4j";
        libraryHaskellDepends = [ base integer-gmp ];
        description = "FFI bindings for C long double";
        license = lib.licenses.bsd3;
···
        ];
        description = "Abstraction for HTML-embedded content";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "markup-preview" = callPackage
···
        ];
        description = "Massiv (Массив) is an Array Library";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "massiv_0_6_1_0" = callPackage
+    ({ mkDerivation, base, bytestring, deepseq, doctest, exceptions
+     , mersenne-random-pure64, primitive, QuickCheck, random, scheduler
+     , splitmix, template-haskell, unliftio-core, vector
+     }:
+     mkDerivation {
+       pname = "massiv";
+       version = "0.6.1.0";
+       sha256 = "0j3br93kxxyb1q5mdf440f8l8d2lc0gi9vhc3h3ri94ls4ix099v";
+       libraryHaskellDepends = [
+         base bytestring deepseq exceptions primitive scheduler
+         unliftio-core vector
+       ];
+       testHaskellDepends = [
+         base doctest mersenne-random-pure64 QuickCheck random splitmix
+         template-haskell
+       ];
+       description = "Massiv (Массив) is an Array Library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "massiv-io" = callPackage
···
      }:
      mkDerivation {
        pname = "mp";
-       version = "1.1.0";
-       sha256 = "1msy52c1702q16pmbzc69iyj7bj9xdh4c72d15sigblh9hwvipmm";
+       version = "1.2.0";
+       sha256 = "0jn987fg2kah3m39rdgnkmqy940ks2c8f2ld8lrj8k2zyjbgls5b";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        testHaskellDepends = [ base HUnit ip text ];
        description = "A Multipath TCP path manager";
        license = lib.licenses.gpl3Only;
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "mpvguihs" = callPackage
···
      }) {};
 
   "multi-except" = callPackage
-    ({ mkDerivation, base, dlist, hspec, semigroupoids }:
+    ({ mkDerivation, base, dlist-nonempty, hspec, semigroupoids }:
      mkDerivation {
        pname = "multi-except";
-       version = "0.2.1.0";
-       sha256 = "0ai19lk32wbpsmwxig5wzc7iqi81h0mxpykrmfw05vv4zwjqiqfz";
-       libraryHaskellDepends = [ base dlist semigroupoids ];
+       version = "0.3.0.0";
+       sha256 = "1zk8cihmv5dimdhld0h0h622zsvn71rdbhslj4b8dh3dv4qdfji0";
+       libraryHaskellDepends = [ base dlist-nonempty semigroupoids ];
        testHaskellDepends = [ base hspec semigroupoids ];
        description = "Multiple Exceptions";
        license = lib.licenses.mit;
···
      }) {};
 
   "mysql" = callPackage
-    ({ mkDerivation, base, bytestring, Cabal, containers, hspec, mysql
+    ({ mkDerivation, base, bytestring, Cabal, containers, hspec
+     , libmysqlclient
      }:
      mkDerivation {
        pname = "mysql";
···
        sha256 = "16m8hv9yy2nf4jwgqg6n9z53n2pzskbc3gwbp2i3kgff8wsmf8sd";
        setupHaskellDepends = [ base Cabal ];
        libraryHaskellDepends = [ base bytestring containers ];
-       librarySystemDepends = [ mysql ];
+       librarySystemDepends = [ libmysqlclient ];
        testHaskellDepends = [ base bytestring hspec ];
        description = "A low-level MySQL client library";
        license = lib.licenses.bsd3;
-     }) {inherit (pkgs) mysql;};
+     }) {inherit (pkgs) libmysqlclient;};
 
   "mysql-effect" = callPackage
     ({ mkDerivation, base, bytestring, extensible-effects, mysql
···
        license = lib.licenses.asl20;
      }) {};
 
+  "opentelemetry_0_7_0" = callPackage
+    ({ mkDerivation, base, bytestring, exceptions, ghc-trace-events
+     , hashable
+     }:
+     mkDerivation {
+       pname = "opentelemetry";
+       version = "0.7.0";
+       sha256 = "10k9if33ydjc099mgjvgglp6fcmrz0zxpv6khwkhra6lcz35mylv";
+       libraryHaskellDepends = [
+         base bytestring exceptions ghc-trace-events hashable
+       ];
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "opentelemetry-extra" = callPackage
     ({ mkDerivation, aeson, async, base, binary, bytestring, clock
      , containers, directory, exceptions, filepath, gauge
···
        testToolDepends = [ tasty-discover ];
        benchmarkHaskellDepends = [ base gauge opentelemetry ];
        license = lib.licenses.asl20;
+     }) {};
+
+  "opentelemetry-extra_0_7_0" = callPackage
+    ({ mkDerivation, async, base, binary, bytestring, clock, containers
+     , directory, exceptions, filepath, generic-arbitrary, ghc-events
+     , hashable, hashtables, http-client, http-client-tls, http-types
+     , hvega, jsonifier, opentelemetry, process, QuickCheck
+     , quickcheck-instances, random, scientific, splitmix, stm, tasty
+     , tasty-bench, tasty-discover, tasty-hunit, tasty-quickcheck, text
+     , text-show, typed-process, unordered-containers
+     }:
+     mkDerivation {
+       pname = "opentelemetry-extra";
+       version = "0.7.0";
+       sha256 = "11lwhm3rpajmch7kjb4qwngram5ka8fbd3c0mxszlf4a9dlqag32";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         async base binary bytestring clock containers directory exceptions
+         filepath ghc-events hashable http-client http-client-tls http-types
+         jsonifier opentelemetry random scientific splitmix stm text
+         text-show unordered-containers
+       ];
+       executableHaskellDepends = [
+         async base bytestring clock containers directory exceptions
+         filepath hashtables http-client http-client-tls hvega opentelemetry
+         process text typed-process
+       ];
+       testHaskellDepends = [
+         base bytestring generic-arbitrary ghc-events hashable opentelemetry
+         QuickCheck quickcheck-instances splitmix tasty tasty-discover
+         tasty-hunit tasty-quickcheck text text-show unordered-containers
+       ];
+       testToolDepends = [ tasty-discover ];
+       benchmarkHaskellDepends = [ base opentelemetry tasty-bench ];
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "opentelemetry-http-client" = callPackage
···
        license = lib.licenses.asl20;
      }) {};
 
+  "opentelemetry-lightstep_0_7_0" = callPackage
+    ({ mkDerivation, async, base, bytestring, clock, containers
+     , exceptions, filepath, ghc-events, http-client, http-client-tls
+     , http-types, network, opentelemetry, opentelemetry-extra
+     , scientific, splitmix, stm, text, typed-process
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "opentelemetry-lightstep";
+       version = "0.7.0";
+       sha256 = "1yd6gzhwwmjjh41ipz2kifzpn7hha9nli3war2rqdjvhj349lrw8";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         async base bytestring exceptions http-client http-client-tls
+         http-types network opentelemetry opentelemetry-extra scientific stm
+         text unordered-containers
+       ];
+       executableHaskellDepends = [
+         async base bytestring clock containers exceptions filepath
+         ghc-events http-client http-types opentelemetry opentelemetry-extra
+         splitmix text typed-process unordered-containers
+       ];
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "opentelemetry-wai" = callPackage
     ({ mkDerivation, base, bytestring, http-types, opentelemetry, text
      , wai
···
          base bytestring http-types opentelemetry text wai
        ];
        license = lib.licenses.asl20;
+     }) {};
+
+  "opentelemetry-wai_0_7_0" = callPackage
+    ({ mkDerivation, base, bytestring, http-types, opentelemetry, text
+     , wai
+     }:
+     mkDerivation {
+       pname = "opentelemetry-wai";
+       version = "0.7.0";
+       sha256 = "09mh8kfh49vx2gascwwmzs4s649sm5i90nsifp76kjvg1nvqhd1m";
+       libraryHaskellDepends = [
+         base bytestring http-types opentelemetry text wai
+       ];
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "opentheory" = callPackage
···
      }:
      mkDerivation {
        pname = "opentracing";
-       version = "0.1.0.0";
-       sha256 = "0j791hv525mcskqmji3f9n8v803pailm8jrl336pxzdh3iacqvsl";
+       version = "0.2.0";
+       sha256 = "1yl3hhg32npj4ncqc9j5gl2jikzvczkpnrwp124nk45mzi13aszq";
        libraryHaskellDepends = [
          aeson async base base64-bytestring bytestring case-insensitive
          clock containers http-types iproute lens mtl mwc-random network
···
     ({ mkDerivation, base, http-client, lens, mtl, opentracing, text }:
      mkDerivation {
        pname = "opentracing-http-client";
-       version = "0.1.0.0";
-       sha256 = "1jzdnlk2cacmymjkcfx4n569n6gqy6kwzh9dxrgjnagwh3jqk7q3";
+       version = "0.2.0";
+       sha256 = "19mwl69ggyd7zf1dvx5yjzsq5mlw5l94h989hgwc4ryvp8zqwv4n";
        libraryHaskellDepends = [
          base http-client lens mtl opentracing text
        ];
···
 
   "opentracing-jaeger" = callPackage
     ({ mkDerivation, base, bytestring, exceptions, hashable
-     , http-client, http-types, lens, mtl, network, opentracing
-     , QuickCheck, safe-exceptions, text, thrift, unordered-containers
-     , vector
+     , http-client, http-types, lens, mtl, network, opentracing, pinch
+     , QuickCheck, safe-exceptions, text, unordered-containers, vector
+     , vector-instances
      }:
      mkDerivation {
        pname = "opentracing-jaeger";
-       version = "0.1.0.0";
-       sha256 = "1yr9vhbpqq12hj9blv3v1wc26n9qsp0g7pjngxh0k1zcv759s1k0";
+       version = "0.2.0";
+       sha256 = "0ffcbmg8qzvyhm7vzk2zkk5czli4ndrp18cc328i7600gzv1gr81";
        libraryHaskellDepends = [
          base bytestring exceptions hashable http-client http-types lens mtl
-         network opentracing QuickCheck safe-exceptions text thrift
-         unordered-containers vector
+         network opentracing pinch QuickCheck safe-exceptions text
+         unordered-containers vector vector-instances
        ];
        description = "Jaeger backend for OpenTracing";
        license = lib.licenses.asl20;
···
     ({ mkDerivation, base, lens, opentracing, text, wai }:
      mkDerivation {
        pname = "opentracing-wai";
-       version = "0.1.0.0";
-       sha256 = "1m68l4gxpyl81yhkd209kdgzydzyg632x8gl2jh3l4k83ysdg545";
+       version = "0.2.0";
+       sha256 = "178xxgg0rw94gld5jlvix6czsvg66q60h06nj2b1x7rnd0pjryc6";
        libraryHaskellDepends = [ base lens opentracing text wai ];
        description = "Middleware adding OpenTracing tracing for WAI applications";
        license = lib.licenses.asl20;
···
     ({ mkDerivation, aeson, base, opentracing, text }:
      mkDerivation {
        pname = "opentracing-zipkin-common";
-       version = "0.1.0.0";
-       sha256 = "00pg2k0v685gc4fmrcb464fapvpz8lw0249n6gmi2zkhpw8frnm0";
+       version = "0.2.0";
+       sha256 = "0yngiz8135v844wcx28izwhx18iz06di3dl8bm5xqh47ir43wdw6";
        libraryHaskellDepends = [ aeson base opentracing text ];
        description = "Zipkin OpenTracing Backend Commons";
        license = lib.licenses.asl20;
···
   "opentracing-zipkin-v1" = callPackage
     ({ mkDerivation, base, bytestring, exceptions, hashable
      , http-client, http-types, iproute, lens, opentracing
-     , opentracing-zipkin-common, QuickCheck, text, thrift
-     , unordered-containers, vector
+     , opentracing-zipkin-common, pinch, QuickCheck, text
+     , unordered-containers, vector, vector-instances
      }:
      mkDerivation {
        pname = "opentracing-zipkin-v1";
-       version = "0.1.0.0";
-       sha256 = "0mw6x9jqh42ymn1a3maq47mw1mbzki5lv1axapqkhkx0w13824pp";
+       version = "0.2.0";
+       sha256 = "15n9m7affy81fr80zw7l54lch7gr6bvhcqpga797x7rvdxqqjv9j";
        libraryHaskellDepends = [
          base bytestring exceptions hashable http-client http-types iproute
-         lens opentracing opentracing-zipkin-common QuickCheck text thrift
-         unordered-containers vector
+         lens opentracing opentracing-zipkin-common pinch QuickCheck text
+         unordered-containers vector vector-instances
        ];
        description = "Zipkin V1 backend for OpenTracing";
        license = lib.licenses.asl20;
···
      }:
      mkDerivation {
        pname = "opentracing-zipkin-v2";
-       version = "0.1.0.0";
-       sha256 = "0rmrlx2g228p4ys95d4zqc0l56a62avsawq320g4n9i2g0hrl5n4";
+       version = "0.2.0";
+       sha256 = "1ykssjhknfyiw02abjpz38zmlw8l03zb8c3y3ic5njmsg23nxfzb";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring exceptions http-client
          http-types lens opentracing opentracing-zipkin-common text
···
      }:
      mkDerivation {
        pname = "ordinal";
-       version = "0.4.0.5";
-       sha256 = "0m073n6yln9rfdzlkwd10fl04b725h3hpybz01r0wiyw4bfv2n3b";
+       version = "0.4.0.6";
+       sha256 = "0zpqhyn8f2iphgz2746fxsjk817ly8q6s4dz6129jrrd25v3kdc7";
        libraryHaskellDepends = [
          base containers data-default QuickCheck regex template-haskell text
          time vector
···
 
   "org-mode" = callPackage
     ({ mkDerivation, base, containers, filepath, hashable, megaparsec
-     , parser-combinators, tasty, tasty-hunit, text
+     , parser-combinators, tasty, tasty-hunit, text, time
      }:
      mkDerivation {
        pname = "org-mode";
-       version = "1.1.1";
-       sha256 = "0kbfgafv3xkgczz27ap7xyqfvvn8a6sizc9h3ylklc8qrw38n149";
+       version = "2.0.0";
+       sha256 = "17yn9si0mxyydjgv40q6rc5nw579kswlx69ycyinhdx0q34ds7rl";
        libraryHaskellDepends = [
          base containers filepath hashable megaparsec parser-combinators
-         text
+         text time
        ];
-       testHaskellDepends = [ base megaparsec tasty tasty-hunit text ];
+       testHaskellDepends = [
+         base megaparsec tasty tasty-hunit text time
+       ];
        description = "Parser for Emacs org-mode files";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "org-mode-lucid";
-       version = "1.6.0";
-       sha256 = "0qkar6cwmz67zm2jlah1yi004vap8d136167qwvm485cpd3vwxz7";
+       version = "1.6.1";
+       sha256 = "0fkwwwrmfq22g1yak9srmlbq5yixf4kdwfapq0dyr8f3pqaglf1v";
        libraryHaskellDepends = [
          base containers hashable lucid org-mode text
        ];
···
        description = "Parse syslog traffic from PAN-OS";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "panda" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "pantry_0_5_2_2" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, base, bytestring, Cabal
+     , casa-client, casa-types, conduit, conduit-extra, containers
+     , cryptonite, cryptonite-conduit, digest, exceptions, filelock
+     , generic-deriving, hackage-security, hedgehog, hpack, hspec
+     , http-client, http-client-tls, http-conduit, http-download
+     , http-types, memory, mtl, network-uri, path, path-io, persistent
+     , persistent-sqlite, persistent-template, primitive, QuickCheck
+     , raw-strings-qq, resourcet, rio, rio-orphans, rio-prettyprint
+     , tar-conduit, text, text-metrics, time, transformers, unix-compat
+     , unliftio, unordered-containers, vector, yaml, zip-archive
+     }:
+     mkDerivation {
+       pname = "pantry";
+       version = "0.5.2.2";
+       sha256 = "05ykb6jn19jiakrn6mdcz3gyc6v6hkg3r8drwxncf04syz0l60mm";
+       libraryHaskellDepends = [
+         aeson ansi-terminal base bytestring Cabal casa-client casa-types
+         conduit conduit-extra containers cryptonite cryptonite-conduit
+         digest filelock generic-deriving hackage-security hpack http-client
+         http-client-tls http-conduit http-download http-types memory mtl
+         network-uri path path-io persistent persistent-sqlite
+         persistent-template primitive resourcet rio rio-orphans
+         rio-prettyprint tar-conduit text text-metrics time transformers
+         unix-compat unliftio unordered-containers vector yaml zip-archive
+       ];
+       testHaskellDepends = [
+         aeson ansi-terminal base bytestring Cabal casa-client casa-types
+         conduit conduit-extra containers cryptonite cryptonite-conduit
+         digest exceptions filelock generic-deriving hackage-security
+         hedgehog hpack hspec http-client http-client-tls http-conduit
+         http-download http-types memory mtl network-uri path path-io
+         persistent persistent-sqlite persistent-template primitive
+         QuickCheck raw-strings-qq resourcet rio rio-orphans rio-prettyprint
+         tar-conduit text text-metrics time transformers unix-compat
+         unliftio unordered-containers vector yaml zip-archive
+       ];
+       description = "Content addressable Haskell package management";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "pantry-tmp" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, array, base, base-orphans
      , base64-bytestring, bytestring, Cabal, conduit, conduit-extra
···
     ({ mkDerivation, base, containers, extensible-exceptions, random }:
      mkDerivation {
        pname = "parallel-io";
-       version = "0.3.4";
-       sha256 = "10bglxm685pljh0i896zrgs6g3iz0n7gl1qslvfn63pjxgvz5v2a";
+       version = "0.3.5";
+       sha256 = "0b67rjz80n58grz7hcb1lvk15lmww41967kv7f85vlpacfykng49";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "path-io_1_6_3" = callPackage
+    ({ mkDerivation, base, containers, directory, dlist, exceptions
+     , filepath, hspec, path, temporary, time, transformers, unix-compat
+     }:
+     mkDerivation {
+       pname = "path-io";
+       version = "1.6.3";
+       sha256 = "1dnc48hf8x83p0jy05qi8j8gmfmsy50swnql9ssdv74lsryp615n";
+       libraryHaskellDepends = [
+         base containers directory dlist exceptions filepath path temporary
+         time transformers unix-compat
+       ];
+       testHaskellDepends = [
+         base directory exceptions filepath hspec path transformers
+         unix-compat
+       ];
+       description = "Interface to ‘directory’ package for users of ‘path’";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "path-like" = callPackage
     ({ mkDerivation, base, path }:
      mkDerivation {
···
        ];
        description = "Read and write UTF-8 text files";
        license = lib.licenses.asl20;
+     }) {};
+
+  "path-text-utf8_0_0_1_8" = callPackage
+    ({ mkDerivation, base, bytestring, path, safe-exceptions, text }:
+     mkDerivation {
+       pname = "path-text-utf8";
+       version = "0.0.1.8";
+       sha256 = "1xi60cw75qzhb03z2a66xfxgr17xz39bdk7wmjc7yprqy0v016jj";
+       libraryHaskellDepends = [
+         base bytestring path safe-exceptions text
+       ];
+       description = "Read and write UTF-8 text files";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "path-utils" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "persistent-mtl_0_2_2_0" = callPackage
+    ({ mkDerivation, base, bytestring, conduit, containers
+     , monad-logger, mtl, persistent, persistent-postgresql
+     , persistent-sqlite, persistent-template, resource-pool, resourcet
+     , tasty, tasty-golden, tasty-hunit, text, transformers, unliftio
+     , unliftio-core, unliftio-pool
+     }:
+     mkDerivation {
+       pname = "persistent-mtl";
+       version = "0.2.2.0";
+       sha256 = "0z78xs1gi45i3a9q28yr7jpsdsbzfqjahch3m27gygkja9dgm438";
+       libraryHaskellDepends = [
+         base conduit containers mtl persistent resource-pool resourcet text
+         transformers unliftio unliftio-core unliftio-pool
+       ];
+       testHaskellDepends = [
+         base bytestring conduit containers monad-logger persistent
+         persistent-postgresql persistent-sqlite persistent-template
+         resource-pool resourcet tasty tasty-golden tasty-hunit text
+         unliftio
+       ];
+       description = "Monad transformer for the persistent API";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "persistent-mysql" = callPackage
     ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
      , containers, fast-logger, hspec, http-api-data, HUnit
···
      }:
      mkDerivation {
        pname = "phonetic-languages-phonetics-basics";
-       version = "0.6.3.0";
-       sha256 = "1hc1wmq2syvi0xsbkrm52hd5k8j2kk80n45695zd85fqwbayhj2c";
+       version = "0.7.0.0";
+       sha256 = "16a8b5xpdrayfh03czs0nb1xz6kn95rr4k4dim5viqjxpc9f0zbn";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-generalized-examples-array";
-       version = "0.2.1.0";
-       sha256 = "0bz5lyl75i143crva3piz4005k81ia26rj455cgbgz3yknj3qpaf";
+       version = "0.3.0.0";
+       sha256 = "15k2nij8rpf1yvm5kjgkrvx1y4zlfskxfdxjbjirmaidamr2ha6d";
        libraryHaskellDepends = [
          base heaps mmsyn2-array parallel
          phonetic-languages-constraints-array
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-generalized-examples-common";
-       version = "0.1.2.0";
-       sha256 = "1k65ynaz2mh35nqsf3izqq0lxqbkyj24i1g3r3gbfpbkajdhqz0v";
+       version = "0.2.0.0";
+       sha256 = "15ngw29ffsyp7j71rpyllfyifvqybgpb5mh2cfgi1vscl8c6zydl";
        libraryHaskellDepends = [
          base heaps phonetic-languages-phonetics-basics subG
        ];
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-generalized-properties-array";
-       version = "0.1.2.0";
-       sha256 = "1vlzgcq8pv22m9pxwx0p1xss9zzlvwap11gn88pdgn0zgkhcsm0b";
+       version = "0.2.0.0";
+       sha256 = "1k1id4dz0siz3qqax738k4k2dfj68slph4yy8ad6f4r9fink9jqr";
        libraryHaskellDepends = [
          base phonetic-languages-phonetics-basics
          phonetic-languages-rhythmicity phonetic-languages-simplified-base
        ];
-       description = "Generalization of the functionality of the phonetic-languages-simplified-properties-array";
+       description = "Some 'properties' of the phonetic languages approach text";
        license = lib.licenses.mit;
      }) {};
 
···
      , quickcheck-assertions, quickcheck-instances, resource-pool
      , semigroups, tasty, tasty-hunit, tasty-quickcheck, tasty-th
      , template-haskell, text, th-lift, th-lift-instances, time
-     , transformers, transformers-base, transformers-compat, type-fun
+     , transformers, transformers-base, transformers-compat
      }:
      mkDerivation {
        pname = "postgresql-query";
-       version = "3.8.1";
-       sha256 = "09lld8fibwn0brszpz040pr8q7b5wrpc9fzdw8pwf7gfsb02wvx1";
+       version = "3.8.2";
+       sha256 = "1vcfs5yg9ab0axdm661kjpsfxii7h3s8rrq38kgc68vhr280m110";
        libraryHaskellDepends = [
          aeson attoparsec base blaze-builder bytestring containers
          data-default exceptions file-embed haskell-src-meta hreader hset
          inflections monad-control monad-logger mtl postgresql-simple
          resource-pool semigroups template-haskell text th-lift
          th-lift-instances time transformers transformers-base
-         transformers-compat type-fun
+         transformers-compat
        ];
        testHaskellDepends = [
          attoparsec base generic-arbitrary postgresql-simple QuickCheck
···
        pname = "process";
        version = "1.6.11.0";
        sha256 = "0nv8c2hnx1l6xls6b61l8sm7j250qfbj1fjj5n6m15ppk9f0d9jd";
-       revision = "1";
-       editedCabalFile = "136mp45m1jh27yayb0gx4giybp6imh7hbr774fsb2m9vj2l52b27";
+       revision = "2";
+       editedCabalFile = "1yz98g78syad217c816q5rrdb7w93lpsp3pcc4djsy050w9ji56n";
        libraryHaskellDepends = [ base deepseq directory filepath unix ];
        testHaskellDepends = [ base bytestring directory ];
        description = "Process libraries";
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "regex-tdfa_1_3_1_1" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers, directory
+     , filepath, mtl, parsec, regex-base, text, utf8-string
+     }:
+     mkDerivation {
+       pname = "regex-tdfa";
+       version = "1.3.1.1";
+       sha256 = "1msrq31k4jmn2lmrdzn87jqarqhw265ca69rfg5jpa5adrzm3gmi";
+       libraryHaskellDepends = [
+         array base bytestring containers mtl parsec regex-base text
+       ];
+       testHaskellDepends = [
+         array base bytestring containers directory filepath mtl regex-base
+         text utf8-string
+       ];
+       description = "Pure Haskell Tagged DFA Backend for \"Text.Regex\" (regex-base)";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "regex-tdfa-pipes" = callPackage
     ({ mkDerivation, array, base, lens, monads-tf, pipes, regex-base
      , regex-tdfa
···
        doCheck = false;
        description = "Easy-to-use, type-safe, expandable, high-level HTTP client library";
        license = lib.licenses.bsd3;
+       maintainers = with lib.maintainers; [ maralorn ];
+     }) {};
+
+  "req_3_9_1" = callPackage
+    ({ mkDerivation, aeson, authenticate-oauth, base, blaze-builder
+     , bytestring, case-insensitive, connection, exceptions, hspec
+     , hspec-core, hspec-discover, http-api-data, http-client
+     , http-client-tls, http-types, modern-uri, monad-control, mtl
+     , QuickCheck, retry, template-haskell, text, time, transformers
+     , transformers-base, unliftio-core, unordered-containers
+     }:
+     mkDerivation {
+       pname = "req";
+       version = "3.9.1";
+       sha256 = "0468ah4142jrqp5l3pw4izrw6f6kznisan888b30jhif4c6xncr0";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson authenticate-oauth base blaze-builder bytestring
+         case-insensitive connection exceptions http-api-data http-client
+         http-client-tls http-types modern-uri monad-control mtl retry
+         template-haskell text time transformers transformers-base
+         unliftio-core
+       ];
+       testHaskellDepends = [
+         aeson base blaze-builder bytestring case-insensitive hspec
+         hspec-core http-client http-types modern-uri monad-control mtl
+         QuickCheck retry template-haskell text time unordered-containers
+       ];
+       testToolDepends = [ hspec-discover ];
+       doCheck = false;
+       description = "HTTP client library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
···
        pname = "rounded";
        version = "1.1";
        sha256 = "0hja4ak3qd80zg996jwyi1kndj2vfsp10vwr4wyrcvppzl4gj4a0";
+       revision = "1";
+       editedCabalFile = "02zrazan3ljalfy1cnr3d0cdw7n426k5wg5xkifk87vb8ds2wx1j";
        libraryHaskellDepends = [
          base ghc-prim hgmp long-double reflection
        ];
···
        pname = "rss";
        version = "3000.2.0.7";
        sha256 = "0z48xb610k1h29rg03q19y08fp78agxp2gr48innw5y3rz00s6ym";
-       revision = "1";
-       editedCabalFile = "0ql1ffjw0g1sdyz9icin4cq86i5b9ljzhvpivfbbyaipg2nc9z0s";
+       revision = "3";
+       editedCabalFile = "02jbnl7y76ahjdj2bciyjwgcglfs7sy60733z5c8610rk34f99dy";
        libraryHaskellDepends = [ base HaXml network network-uri time ];
        description = "A library for generating RSS 2.0 feeds.";
        license = lib.licenses.publicDomain;
···
        testHaskellDepends = [ base containers doctest ];
        description = "Safe arithmetic operations";
        license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "safe-plugins" = callPackage
···
        ];
        description = "Scientific notation intended for tokenization";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "scion" = callPackage
···
        pname = "servant-auth";
        version = "0.4.0.0";
        sha256 = "0v2g80kakjwpws92bk3anzy4k8vgxq99y7g3ib4amc5x6kxcmjh1";
+       revision = "2";
+       editedCabalFile = "0mbx44l1jnvfvppv6diiixqx5rdkb68djxl36m5sd12qz6rqmcx0";
        libraryHaskellDepends = [
          aeson base jose lens servant text unordered-containers
        ];
···
        pname = "servant-auth-docs";
        version = "0.2.10.0";
        sha256 = "0j1ynnrb6plrhpb2vzs2p7a9jb41llp0j1jwgap7hjhkwhyc7wxd";
-       revision = "5";
-       editedCabalFile = "1113d9hczzksy5bqf8pfriz9x158xr4a3p5na8p83vl46ddad82y";
+       revision = "7";
+       editedCabalFile = "10178ahxq36l9mik7dcn1c1f97fpp8b4r7xiqwiv21llp95s7cqp";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base lens servant servant-auth servant-docs text
···
        pname = "servant-auth-server";
        version = "0.4.6.0";
        sha256 = "0isl9pzzhfbs8pgh3qr2vbgfp0bh741dfa59sq7n3cmbkc6ndpkk";
+       revision = "2";
+       editedCabalFile = "1vf0mnbq0wmwha3aa2fn593dwibaw00l4agspgvchx7574jyr5wp";
        libraryHaskellDepends = [
          aeson base base64-bytestring blaze-builder bytestring
          case-insensitive cookie data-default-class entropy http-types jose
···
        pname = "servant-auth-swagger";
        version = "0.2.10.1";
        sha256 = "029nvb4wxwl98ah26bgcq1b7izrnvssxwn1682liimvsh4a8bady";
+       revision = "2";
+       editedCabalFile = "0b8fawx2wv9zshn9i4abnwy4lgf3fkhbhm8bhfpgm9d867dx21y4";
        libraryHaskellDepends = [
          base lens servant servant-auth servant-swagger swagger2 text
        ];
···
        pname = "servant-docs";
        version = "0.11.8";
        sha256 = "0zbsv75zyfg44l4822qnmvw2naxcxwgnpzc55jnvz766l2dydjrb";
+       revision = "1";
+       editedCabalFile = "0bfhypzm02aqwckjrvjmhvf602di0pmp4r0rjbfcraxzvkrzm6qv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "servant-foreign";
        version = "0.15.3";
        sha256 = "1bz2ry5pd8cx5pmsvg7q29r9gd5kqjjv9nd97f7abwjqi8as2413";
-       revision = "1";
-       editedCabalFile = "0d9h941g7ja73g10az13pad9rjlp126b662f71q7c8yd6kh4jl9r";
+       revision = "2";
+       editedCabalFile = "1fdbxyyp2h5gcighjrww2mbg8z6givmhx2in8293kw58w7y2im0i";
        libraryHaskellDepends = [
          base base-compat http-types lens servant text
        ];
···
        pname = "servant-js";
        version = "0.9.4.2";
        sha256 = "15n5s3i491cxjxj70wa8yhpipaz47q46s04l4ysc64wgijlnm8xy";
+       revision = "1";
+       editedCabalFile = "0lka70i2qjjj9x8i1ilsfgqq5hwdlrcyd2cj1qcpyhj85c9anxl3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        testHaskellDepends = [
          base bytestring http-types servant-server string-conversions tasty
          tasty-wai text
+       ];
+       description = "multipart/form-data (e.g file upload) support for servant";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "servant-multipart_0_12_1" = callPackage
+    ({ mkDerivation, base, bytestring, directory, http-types, lens
+     , resourcet, servant, servant-docs, servant-foreign
+     , servant-multipart-api, servant-server, string-conversions, tasty
+     , tasty-wai, text, wai, wai-extra
+     }:
+     mkDerivation {
+       pname = "servant-multipart";
+       version = "0.12.1";
+       sha256 = "1p55kb3zhq25ncp7wimhggssn68abfgsnlldk13rk1iajaj6y8y5";
+       libraryHaskellDepends = [
+         base bytestring directory lens resourcet servant servant-docs
+         servant-foreign servant-multipart-api servant-server
+         string-conversions text wai wai-extra
+       ];
+       testHaskellDepends = [
+         base bytestring http-types servant-server string-conversions tasty
+         tasty-wai text
+       ];
+       description = "multipart/form-data (e.g file upload) support for servant";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "servant-multipart-api" = callPackage
+    ({ mkDerivation, base, bytestring, servant, text, transformers }:
+     mkDerivation {
+       pname = "servant-multipart-api";
+       version = "0.12.1";
+       sha256 = "1gifa9g7ggs0plzffrd9a8j24dmqvgbkkdkfzyy7mpmwrjqw7mcj";
+       libraryHaskellDepends = [
+         base bytestring servant text transformers
+       ];
+       description = "multipart/form-data (e.g file upload) support for servant";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "servant-multipart-client" = callPackage
+    ({ mkDerivation, array, base, bytestring, http-client, http-media
+     , network, random, servant, servant-client, servant-client-core
+     , servant-multipart, servant-multipart-api, servant-server, text
+     , warp
+     }:
+     mkDerivation {
+       pname = "servant-multipart-client";
+       version = "0.12.1";
+       sha256 = "07haaf9nq96lfv2dhqf4319vl321f53v0mypbbg3swzb6rrfkw9h";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         array base bytestring http-media random servant servant-client-core
+         servant-multipart-api text
+       ];
+       executableHaskellDepends = [
+         base bytestring http-client network servant servant-client
+         servant-client-core servant-multipart servant-multipart-api
+         servant-server warp
        ];
        description = "multipart/form-data (e.g file upload) support for servant";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "simple-ui";
-       version = "0.1.2";
-       sha256 = "106fcxl97gnkpv2bc50bg5zv8j7f1cdyxbl1l99p3rsq6wr6mr0m";
+       version = "0.2.0";
+       sha256 = "0j0xq5s9l7dckbv0bakw96f3xnqsa2b7pqsji7s1y46k2fcr0r5s";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base data-default-class exceptions lens mtl stm template-haskell
···
        description = "Serialize to bytes";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "smallarray" = callPackage
···
        libraryHaskellDepends = [ base bytesmith primitive ];
        description = "Parse arrays of tokens";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "smith-cli" = callPackage
···
      }) {};
 
   "sound-collage" = callPackage
-    ({ mkDerivation, array, base, Cabal, carray, containers, fft
-     , filepath, numeric-prelude, optparse-applicative, pathtype
-     , sample-frame, soxlib, storablevector, storablevector-carray
+    ({ mkDerivation, array, base, carray, containers, fft, filepath
+     , numeric-prelude, optparse-applicative, pathtype, sample-frame
+     , shell-utility, soxlib, storablevector, storablevector-carray
      , synthesizer-core, temporary, transformers, utility-ht
      }:
      mkDerivation {
        pname = "sound-collage";
-       version = "0.2.0.1";
-       sha256 = "0ywsy3q8f6y6k0vg4g21v6cm3n7662ngbzvfx502makdkf47i75a";
+       version = "0.2.0.2";
+       sha256 = "11rirlg25iawv4shwhvc4bcnzk4axvgk5n7yj05nnbpyx4s6r0pp";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         array base Cabal carray containers fft filepath numeric-prelude
-         optparse-applicative pathtype sample-frame soxlib storablevector
-         storablevector-carray synthesizer-core temporary transformers
-         utility-ht
+         array base carray containers fft filepath numeric-prelude
+         optparse-applicative pathtype sample-frame shell-utility soxlib
+         storablevector storablevector-carray synthesizer-core temporary
+         transformers utility-ht
        ];
        description = "Approximate a song from other pieces of sound";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.mit;
      }) {};
 
+  "stripe-concepts_1_0_2_8" = callPackage
+    ({ mkDerivation, base, bytestring, text }:
+     mkDerivation {
+       pname = "stripe-concepts";
+       version = "1.0.2.8";
+       sha256 = "03sqgmbbjqi18wjb96sc3lvc6p3bqk5sgsgbcf9z8k9rbdspribm";
+       libraryHaskellDepends = [ base bytestring text ];
+       description = "Types for the Stripe API";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "stripe-core" = callPackage
     ({ mkDerivation, aeson, base, bytestring, mtl, text, time
      , transformers, unordered-containers
···
      }:
      mkDerivation {
        pname = "stripe-scotty";
-       version = "1.0.0.8";
-       sha256 = "1r91lf3yjivfcxdnqy1ayfzs2ckszyx8x6f6fn8rjiz0gfv1v6hn";
+       version = "1.1";
+       sha256 = "15l3b01wf55k3cnwspkqvphs822cmdbnxyfcka8bi0vaj8xl84x9";
        libraryHaskellDepends = [
          aeson base bytestring http-types scotty stripe-concepts
          stripe-signature text unordered-containers
···
      }:
      mkDerivation {
        pname = "stripe-signature";
-       version = "1.0.0.8";
-       sha256 = "0cybjsvzknsldqhf7fjd4ar2qjyym43x2ymmgw01f9a1ixyaxgmn";
+       version = "1.0.0.10";
+       sha256 = "04b5z6hnm000fii4qiczm4xpr41v55fgcj07yh35iwh4gwgc7c4h";
        libraryHaskellDepends = [
          base base16-bytestring bytestring cryptonite memory stripe-concepts
          text
···
      }:
      mkDerivation {
        pname = "stripe-wreq";
-       version = "1.0.1.8";
-       sha256 = "1km0h94d1clgba0yy520yx54axdkf4xl5p5hnmn8ghg40r0pax73";
+       version = "1.0.1.10";
+       sha256 = "0pxaffbmnibivg8pdkvmyjkw8hz0grq3x84apd94mkji7vjg9xgh";
        libraryHaskellDepends = [
          aeson base bytestring lens stripe-concepts text
          unordered-containers wreq
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "sydtest_0_2_0_0" = callPackage
+    ({ mkDerivation, async, base, bytestring, containers, Diff, dlist
+     , envparse, filepath, MonadRandom, mtl, optparse-applicative, path
+     , path-io, pretty-show, QuickCheck, quickcheck-io, random-shuffle
+     , safe, safe-coloured-text, safe-coloured-text-terminfo, split, stm
+     , sydtest-discover, text, yaml, yamlparse-applicative
+     }:
+     mkDerivation {
+       pname = "sydtest";
+       version = "0.2.0.0";
+       sha256 = "1k0jpnvfizvgscwpgd827w7x4nczlv7krwj10y35byj79wb5xy2m";
+       libraryHaskellDepends = [
+         async base bytestring containers Diff dlist envparse filepath
+         MonadRandom mtl optparse-applicative path path-io pretty-show
+         QuickCheck quickcheck-io random-shuffle safe safe-coloured-text
+         safe-coloured-text-terminfo split text yaml yamlparse-applicative
+       ];
+       testHaskellDepends = [
+         base bytestring path path-io QuickCheck safe-coloured-text
+         safe-coloured-text-terminfo stm text
+       ];
+       testToolDepends = [ sydtest-discover ];
+       description = "A modern testing framework for Haskell with good defaults and advanced testing features";
+       license = "unknown";
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "sydtest-aeson" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, path
+     , path-io, sydtest, sydtest-discover, text
+     }:
+     mkDerivation {
+       pname = "sydtest-aeson";
+       version = "0.0.0.0";
+       sha256 = "0x4n27v60m6h44xwpf60j11j1r9r1zzixlszq21skrf2r6lla2gn";
+       libraryHaskellDepends = [
+         aeson aeson-pretty base bytestring path path-io sydtest text
+       ];
+       testHaskellDepends = [ aeson base sydtest text ];
+       testToolDepends = [ sydtest-discover ];
+       description = "An aeson companion library for sydtest";
+       license = "unknown";
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "sydtest-amqp" = callPackage
+    ({ mkDerivation, aeson, amqp, async, base, bytestring, network
+     , path, path-io, port-utils, process, stm, sydtest
+     , sydtest-discover, sydtest-rabbitmq, sydtest-typed-process, text
+     , typed-process
+     }:
+     mkDerivation {
+       pname = "sydtest-amqp";
+       version = "0.1.0.0";
+       sha256 = "122n2nf0z2s925yjg6zlp3bvl70yprip57v6775vqglhbr959v8m";
+       libraryHaskellDepends = [
+         aeson amqp async base bytestring network path path-io port-utils
+         process stm sydtest sydtest-rabbitmq sydtest-typed-process text
+         typed-process
+       ];
+       testHaskellDepends = [ amqp base sydtest ];
+       testToolDepends = [ sydtest-discover ];
+       description = "An amqp companion library for sydtest";
+       license = "unknown";
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "sydtest-discover" = callPackage
     ({ mkDerivation, base, filepath, optparse-applicative, path
      , path-io
···
        ];
        executableHaskellDepends = [ base ];
        description = "Automatic test suite discovery for sydtest";
+       license = "unknown";
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "sydtest-hedis" = callPackage
+    ({ mkDerivation, base, bytestring, hedis, network, path, path-io
+     , port-utils, sydtest, sydtest-discover, sydtest-typed-process
+     , text, typed-process
+     }:
+     mkDerivation {
+       pname = "sydtest-hedis";
+       version = "0.0.0.0";
+       sha256 = "0y31aqn4ra92arq054amhkcxxng0wsngv59ngwn05gc5jv6whi9j";
+       libraryHaskellDepends = [
+         base bytestring hedis network path path-io port-utils sydtest
+         sydtest-typed-process text typed-process
+       ];
+       testHaskellDepends = [ base hedis sydtest ];
+       testToolDepends = [ sydtest-discover ];
+       description = "An hedis companion library for sydtest";
+       license = "unknown";
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "sydtest-hspec" = callPackage
+    ({ mkDerivation, base, hspec, hspec-core, mtl, sydtest
+     , sydtest-discover
+     }:
+     mkDerivation {
+       pname = "sydtest-hspec";
+       version = "0.0.0.0";
+       sha256 = "1fjj6v1f6rilzjcjgg0yqmhhmj067g45sw7q2xr8q9p7qiqnpkh1";
+       libraryHaskellDepends = [ base hspec-core mtl sydtest ];
+       testHaskellDepends = [ base hspec sydtest ];
+       testToolDepends = [ sydtest-discover ];
+       description = "An Hspec companion library for sydtest";
+       license = "unknown";
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "sydtest-mongo" = callPackage
+    ({ mkDerivation, base, binary, bson, bytestring, mongoDB, network
+     , path, path-io, port-utils, process, sydtest, sydtest-discover
+     , sydtest-process, text, yaml
+     }:
+     mkDerivation {
+       pname = "sydtest-mongo";
+       version = "0.0.0.0";
+       sha256 = "0jm2c05dxri0w83ii3pyphb2rrla72fih5g26w0indb51i0wlnq1";
+       libraryHaskellDepends = [
+         base binary bson bytestring mongoDB network path path-io port-utils
+         process sydtest sydtest-process text yaml
+       ];
+       testHaskellDepends = [ base mongoDB sydtest text ];
+       testToolDepends = [ sydtest-discover ];
+       description = "An mongoDB companion library for sydtest";
+       license = "unknown";
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "sydtest-persistent-postgresql" = callPackage
+    ({ mkDerivation, base, monad-logger, mtl, persistent
+     , persistent-postgresql, persistent-template, sydtest
+     , sydtest-discover, tmp-postgres
+     }:
+     mkDerivation {
+       pname = "sydtest-persistent-postgresql";
+       version = "0.1.0.0";
+       sha256 = "1g669w4rcjd7pnf6hrcc5lb6li30m9fdkrchm00bmg1350kxmnmp";
+       libraryHaskellDepends = [
+         base monad-logger mtl persistent persistent-postgresql sydtest
+         tmp-postgres
+       ];
+       testHaskellDepends = [
+         base persistent persistent-postgresql persistent-template sydtest
+       ];
+       testToolDepends = [ sydtest-discover ];
+       description = "An persistent-postgresql companion library for sydtest";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
      }) {};
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "sydtest-persistent-sqlite_0_1_0_0" = callPackage
+    ({ mkDerivation, base, monad-logger, mtl, persistent
+     , persistent-sqlite, persistent-template, sydtest, sydtest-discover
+     }:
+     mkDerivation {
+       pname = "sydtest-persistent-sqlite";
+       version = "0.1.0.0";
+       sha256 = "1al80sym9r2h769szky5kpkllbs7gm4lc8gn9nlavj0in663x0ly";
+       libraryHaskellDepends = [
+         base monad-logger mtl persistent persistent-sqlite
+         persistent-template sydtest
+       ];
+       testHaskellDepends = [
+         base persistent persistent-sqlite persistent-template sydtest
+       ];
+       testToolDepends = [ sydtest-discover ];
+       description = "A persistent-sqlite companion library for sydtest";
+       license = "unknown";
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "sydtest-process" = callPackage
+    ({ mkDerivation, base, bytestring, process, sydtest
+     , sydtest-discover
+     }:
+     mkDerivation {
+       pname = "sydtest-process";
+       version = "0.0.0.0";
+       sha256 = "1afjwxq7bq4q0g5qznffxfn20ikxxmr7yywiksfyfnyh4n0a1zsf";
+       libraryHaskellDepends = [ base process sydtest ];
+       testHaskellDepends = [ base bytestring process sydtest ];
+       testToolDepends = [ sydtest-discover ];
+       description = "A typed-process companion library for sydtest";
+       license = "unknown";
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "sydtest-rabbitmq" = callPackage
+    ({ mkDerivation, aeson, amqp, async, base, bytestring, network
+     , path, path-io, port-utils, process, stm, sydtest
+     , sydtest-discover, sydtest-typed-process, text, typed-process
+     }:
+     mkDerivation {
+       pname = "sydtest-rabbitmq";
+       version = "0.1.0.0";
+       sha256 = "0ra32y2w7hirjmaz67myq26waccznkl7gqmdnwdd93n6n1h1gb9p";
+       libraryHaskellDepends = [
+         aeson amqp async base bytestring network path path-io port-utils
+         process stm sydtest sydtest-typed-process text typed-process
+       ];
+       testHaskellDepends = [ amqp base sydtest ];
+       testToolDepends = [ sydtest-discover ];
+       description = "An rabbitmq companion library for sydtest";
+       license = "unknown";
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "sydtest-servant" = callPackage
     ({ mkDerivation, base, http-client, servant, servant-client
      , servant-server, stm, sydtest, sydtest-discover, sydtest-wai
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "sydtest-servant_0_1_0_0" = callPackage
+    ({ mkDerivation, base, http-client, servant, servant-client
+     , servant-server, stm, sydtest, sydtest-discover, sydtest-wai
+     }:
+     mkDerivation {
+       pname = "sydtest-servant";
+       version = "0.1.0.0";
+       sha256 = "0mn7fys01qakapnrcrlpji1kwc3cgywblid4wpipmh2kdpy61ndk";
+       libraryHaskellDepends = [
+         base http-client servant servant-client servant-server sydtest
+         sydtest-wai
+       ];
+       testHaskellDepends = [
+         base servant servant-client servant-server stm sydtest
+       ];
+       testToolDepends = [ sydtest-discover ];
+       description = "A servant companion library for sydtest";
+       license = "unknown";
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "sydtest-typed-process" = callPackage
+    ({ mkDerivation, base, bytestring, sydtest, sydtest-discover
+     , typed-process
+     }:
+     mkDerivation {
+       pname = "sydtest-typed-process";
+       version = "0.0.0.0";
+       sha256 = "0j5x2liimaxnd1p7bhkd1ic9vccxdph431rq3dmzl3f440qb3rws";
+       libraryHaskellDepends = [ base sydtest typed-process ];
+       testHaskellDepends = [ base bytestring sydtest typed-process ];
+       testToolDepends = [ sydtest-discover ];
+       description = "A typed-process companion library for sydtest";
+       license = "unknown";
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "sydtest-wai" = callPackage
     ({ mkDerivation, base, http-client, http-types, stm, sydtest
      , sydtest-discover, wai, warp
···
        version = "0.0.0.0";
        sha256 = "01fqys32zj1rg9ciq04l7d4av3i1ynw3yinkgc84c3ia330i98ws";
        libraryHaskellDepends = [ base http-client sydtest wai warp ];
+       testHaskellDepends = [
+         base http-client http-types stm sydtest wai
+       ];
+       testToolDepends = [ sydtest-discover ];
+       description = "A wai companion library for sydtest";
+       license = "unknown";
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "sydtest-wai_0_1_0_0" = callPackage
+    ({ mkDerivation, base, bytestring, case-insensitive, http-client
+     , http-types, mtl, network, pretty-show, stm, sydtest
+     , sydtest-discover, text, time, wai, warp
+     }:
+     mkDerivation {
+       pname = "sydtest-wai";
+       version = "0.1.0.0";
+       sha256 = "0fk1b7205h8ib35bp4pma37vk7cy7dwg0kkcv63k60sq1laj48rl";
+       libraryHaskellDepends = [
+         base bytestring case-insensitive http-client http-types mtl network
+         pretty-show sydtest text time wai warp
+       ];
        testHaskellDepends = [
          base http-client http-types stm sydtest wai
        ];
···
 
   "talash" = callPackage
     ({ mkDerivation, alfred-margaret, base, brick, bytestring
-     , colorful-monoids, containers, directory, ghc-compact, intro
-     , microlens, microlens-th, text, unix, unordered-containers, vector
+     , colorful-monoids, directory, ghc-compact, intro, microlens
+     , microlens-th, text, unix, unordered-containers, vector
      , vector-algorithms, vector-sized, vty
      }:
      mkDerivation {
        pname = "talash";
-       version = "0.1.0.1";
-       sha256 = "1j28i5aipldjknfx22dil0xi1gwlv89frl1fn606yl1g84q1kr5n";
+       version = "0.1.1.1";
+       sha256 = "0sa4ay2dc4srh5wbk72iznjwr5bjjhggafhf27zyyxjhnjvfgsq1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         alfred-margaret base brick bytestring colorful-monoids containers
-         directory ghc-compact intro microlens microlens-th text unix
+         alfred-margaret base brick bytestring colorful-monoids directory
+         ghc-compact intro microlens microlens-th text unix
          unordered-containers vector vector-algorithms vector-sized vty
        ];
-       executableHaskellDepends = [ base ];
+       executableHaskellDepends = [ base intro ];
        description = "Line oriented fast enough text search";
        license = lib.licenses.gpl3Only;
      }) {};
···
      }:
      mkDerivation {
        pname = "themoviedb";
-       version = "1.2.0.1";
-       sha256 = "1n6raffsjn9iq427nyh7hnnx1jvgvilisfy6dz72hl4ry5198sdq";
+       version = "1.2.1";
+       sha256 = "0dd1f0lhq0sdl2i3cz7maf49vif89jlv6ny64pw4ywnwycblq3if";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Haskell API bindings for http://themoviedb.org";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "themplate" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "ttc_1_0_0_0" = callPackage
+    ({ mkDerivation, base, bytestring, tasty, tasty-hunit
+     , template-haskell, text
+     }:
+     mkDerivation {
+       pname = "ttc";
+       version = "1.0.0.0";
+       sha256 = "1w9xzgks9vj89mzrnjpgrx1iv67xbp6rn8s1ffc0qam268y8dbzv";
+       libraryHaskellDepends = [ base bytestring template-haskell text ];
+       testHaskellDepends = [
+         base bytestring tasty tasty-hunit template-haskell text
+       ];
+       description = "Textual Type Classes";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ttl-hashtables" = callPackage
     ({ mkDerivation, base, clock, containers, data-default, failable
      , hashable, hashtables, hspec, mtl, transformers
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "type-fun";
-       version = "0.1.2";
-       sha256 = "1qb9h6x1npq1pc8h7n6ism5a6jccysn76czqym1f69x0qh1jjlay";
+       version = "0.1.3";
+       sha256 = "0br31kghd0hm2qaz14pm6lxbl2z1ci3c0758qfpiq1dmm9mmc4ir";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base ];
        description = "Collection of widely reimplemented type families";
···
        description = "maybes of numeric values with fewer indirections";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "unpacked-maybe-text" = callPackage
···
        ];
        description = "Memory efficient url type and parser";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "url-decoders" = callPackage
···
        ];
        description = "Painfully simple URL deployment";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "urn" = callPackage
···
        ];
        description = "UUID parsing using byteverse packages";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "uuid-crypto" = callPackage
···
      }:
      mkDerivation {
        pname = "vimeta";
-       version = "0.3.0.1";
-       sha256 = "0i834y50b4820109asrzp61bqprxs9rfgr9b8310zhsisrlbxgl3";
+       version = "0.3.1";
+       sha256 = "1q40cny80lf0yb38ahmpz42k0w6646mscajlny8zxb6rwylvscv9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Frontend for video metadata tagging tools";
        license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "vimus" = callPackage
···
     ({ mkDerivation, base, bytestring, transformers, vector, vulkan }:
      mkDerivation {
        pname = "vulkan";
-       version = "3.10.1";
-       sha256 = "0lk4l65qvq1b3dz9fkz981zgm2m9nx38ylccnsxcgxns2s2zx9b3";
+       version = "3.10.2";
+       sha256 = "0l3afdavqn226vg96cq5di2ra7snl0ygmil5g8zcs46vkamgzcmy";
        libraryHaskellDepends = [ base bytestring transformers vector ];
        libraryPkgconfigDepends = [ vulkan ];
        description = "Bindings to the Vulkan graphics API";
···
        ];
        description = "Route to different middlewares based on the incoming Accept header";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "wai-middleware-crowd" = callPackage
···
     ({ mkDerivation, base, Cabal, gtk2hs-buildtools, webkitgtk }:
      mkDerivation {
        pname = "webkit2gtk3-javascriptcore";
-       version = "0.14.4.1";
-       sha256 = "0bi42gpw0cf5ymnwlffnfdq68jfvk0j4qcnqv8lvwz2vp1ngs23j";
+       version = "0.14.4.2";
+       sha256 = "1l77qh9iyrcvsf0kha9vcm1v6fayk5i71qprdzbvfp5sihbcnz3r";
        setupHaskellDepends = [ base Cabal gtk2hs-buildtools ];
        libraryHaskellDepends = [ base ];
        libraryPkgconfigDepends = [ webkitgtk ];
···
        ];
        description = "Data types for large but fixed width signed and unsigned integers";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "wide-word-instances" = callPackage
···
        libraryHaskellDepends = [ base binary serialise wide-word ];
        description = "Instances for wide-word";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "wigner-symbols" = callPackage
···
        testToolDepends = [ hspec-discover ];
        description = "X11-specific implementation for WildBind";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "wild-bind-x11_0_2_0_13" = callPackage
+    ({ mkDerivation, async, base, containers, fold-debounce, hspec
+     , hspec-discover, mtl, semigroups, stm, text, time, transformers
+     , wild-bind, X11
+     }:
+     mkDerivation {
+       pname = "wild-bind-x11";
+       version = "0.2.0.13";
+       sha256 = "0fs8k2kfzm6qq9xy35278xprgq7vf0v4qz7q0gz8qv480hffccc5";
+       libraryHaskellDepends = [
+         base containers fold-debounce mtl semigroups stm text transformers
+         wild-bind X11
+       ];
+       testHaskellDepends = [
+         async base hspec text time transformers wild-bind X11
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "X11-specific implementation for WildBind";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "willow" = callPackage
···
        ];
        description = "A simple CLI utility for interacting with a websocket";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ws-chans" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "yamlparse-applicative_0_2_0_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers
+     , optparse-applicative, path, path-io, prettyprinter
+     , safe-coloured-text, scientific, text, unordered-containers
+     , validity, validity-text, vector, yaml
+     }:
+     mkDerivation {
+       pname = "yamlparse-applicative";
+       version = "0.2.0.0";
+       sha256 = "1c287mc7rl6xhwsb3gw51m6sx29dz88a9b6qa0b324hgcmf086sk";
+       libraryHaskellDepends = [
+         aeson base bytestring containers optparse-applicative path path-io
+         prettyprinter safe-coloured-text scientific text
+         unordered-containers validity validity-text vector yaml
+       ];
+       description = "Declaritive configuration parsing with free docs";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "yampa-canvas" = callPackage
     ({ mkDerivation, base, blank-canvas, stm, time, Yampa }:
      mkDerivation {
···
        ];
        description = "Code for using the ip package with yesod";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "yesod-job-queue" = callPackage
···
        ];
        description = "Operations on zip archives";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "zip_1_7_1" = callPackage
+    ({ mkDerivation, base, bytestring, bzlib-conduit, case-insensitive
+     , cereal, conduit, conduit-extra, conduit-zstd, containers, digest
+     , directory, dlist, exceptions, filepath, hspec, monad-control, mtl
+     , QuickCheck, resourcet, temporary, text, time, transformers
+     , transformers-base, unix
+     }:
+     mkDerivation {
+       pname = "zip";
+       version = "1.7.1";
+       sha256 = "0impiv9xsirbvnpnv1lh6lhnl8a4fqylpjif7niyjjbcvyxh4zqd";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring bzlib-conduit case-insensitive cereal conduit
+         conduit-extra conduit-zstd containers digest directory dlist
+         exceptions filepath monad-control mtl resourcet text time
+         transformers transformers-base unix
+       ];
+       executableHaskellDepends = [ base filepath ];
+       testHaskellDepends = [
+         base bytestring conduit containers directory dlist exceptions
+         filepath hspec QuickCheck temporary text time transformers
+       ];
+       description = "Operations on zip archives";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "zip-archive" = callPackage

pkgs/development/libraries/box2d/default.nix

···
     description = "2D physics engine";
     homepage = "https://box2d.org/";
     maintainers = [ maintainers.raskin ];
-    platforms = platforms.linux;
+    platforms = platforms.unix;
     license = licenses.zlib;
   };
 }

pkgs/development/libraries/liblangtag/default.nix

···
-{ lib, stdenv, fetchurl, fetchFromBitbucket, autoreconfHook, gtk-doc, gettext
+{ lib, stdenv, fetchurl, autoreconfHook, gtk-doc, gettext
 , pkg-config, glib, libxml2, gobject-introspection, gnome-common, unzip
 }:
 
···
   pname = "liblangtag";
   version = "0.6.3";
 
-  src = fetchFromBitbucket {
-    owner = "tagoh";
-    repo = pname;
-    rev = version;
-    sha256 = "10rycs8xrxzf9frzalv3qx8cs1jcildhrr4imzxdmr9f4l585z96";
+  # Artifact tarball contains lt-localealias.h needed for darwin
+  src = fetchurl {
+    url = "https://bitbucket.org/tagoh/liblangtag/downloads/${pname}-${version}.tar.bz2";
+    sha256 = "sha256-HxKiCgLsOo0i5U3tuLaDpDycFgvaG6M3vxBgYHrnM70=";
   };
 
   core_zip = fetchurl {
···
     cp "${language_subtag_registry}" data/language-subtag-registry
   '';
 
-  configureFlags = [
-    "--with-locale-alias=${stdenv.cc.libc}/share/locale/locale.alias"
-  ];
+  configureFlags =
+    lib.optional
+      (stdenv.hostPlatform.libc == "glibc")
+      "--with-locale-alias=${stdenv.cc.libc}/share/locale/locale.alias";
 
   buildInputs = [ gettext glib libxml2 gobject-introspection gnome-common ];
   nativeBuildInputs = [ autoreconfHook gtk-doc gettext pkg-config unzip ];
 
-  meta = {
-    inherit version;
+  meta = with lib; {
     description = "An interface library to access tags for identifying languages";
-    license = lib.licenses.mpl20;
-    maintainers = [lib.maintainers.raskin];
-    platforms = lib.platforms.linux;
+    license = licenses.mpl20;
+    maintainers = [ maintainers.raskin ];
+    platforms = platforms.unix;
     # There are links to a homepage that are broken by a BitBucket change
     homepage = "https://bitbucket.org/tagoh/liblangtag/overview";
   };

pkgs/development/ocaml-modules/arp/default.nix

···
 
 buildDunePackage rec {
   pname = "arp";
-  version = "2.3.1";
-
-  minimumOCamlVersion = "4.06";
-
-  useDune2 = true;
+  version = "2.3.2";
 
   src = fetchurl {
     url = "https://github.com/mirage/${pname}/releases/download/v${version}/${pname}-v${version}.tbz";
-    sha256 = "1nzm3fbkvz702g8f60fs49736lpffwchy64i1l1raxm9b4lmdk3p";
+    sha256 = "1s09ibj9v6pp2ckn96wxmn3mjifcj97asls5xc4zg75pflk0grgz";
   };
+
+  minimumOCamlVersion = "4.06";
+  useDune2 = true;
 
   nativeBuildInputs = [
     bisect_ppx
···
 
   propagatedBuildInputs = [
     cstruct
-    ipaddr
-    macaddr
-    logs
-    mirage-time
-    mirage-protocols
-    lwt
     duration
+    ipaddr
+    logs
+    lwt
+    macaddr
     mirage-profile
+    mirage-protocols
+    mirage-time
   ];
 
   doCheck = true;
   checkInputs = [
     alcotest
+    ethernet
+    mirage-clock-unix
     mirage-profile
     mirage-random
     mirage-random-test
-    mirage-vnetif
-    mirage-clock-unix
-    mirage-random
     mirage-time-unix
-    ethernet
+    mirage-vnetif
   ];
 
   meta = with lib; {
     description = "Address Resolution Protocol purely in OCaml";
-    license = licenses.isc;
     homepage = "https://github.com/mirage/arp";
-    maintainers = [ maintainers.sternenseemann ];
+    license = licenses.isc;
+    maintainers = with maintainers; [ sternenseemann ];
   };
 }

pkgs/development/ocaml-modules/index/default.nix

···
 
 buildDunePackage rec {
   pname = "index";
-  version = "1.3.0";
-
-  minimumOCamlVersion = "4.08";
-
-  useDune2 = true;
+  version = "1.3.1";
 
   src = fetchurl {
     url = "https://github.com/mirage/index/releases/download/${version}/index-${version}.tbz";
-    sha256 = "00qwhwg79scs5bgp8nbppv06qs9yhicf686q7lh64ngh0642iz6n";
+    sha256 = "sha256-ycZi/TFLoGRloSpjYqH5FCHWP3eyiTCIDLESEn5inuI=";
   };
 
-  buildInputs = [ stdlib-shims ];
+  minimumOCamlVersion = "4.08";
+  useDune2 = true;
+
+  buildInputs = [
+    stdlib-shims
+  ];
   propagatedBuildInputs = [
-    fmt logs mtime repr ppx_repr cmdliner progress semaphore-compat
+    cmdliner
+    fmt
+    logs
+    mtime
+    ppx_repr
+    progress
+    repr
+    semaphore-compat
   ];
 
+  checkInputs = [
+    alcotest
+    crowbar
+    re
+  ];
   doCheck = true;
-  checkInputs = [ alcotest crowbar re ];
 
-  meta = {
-    homepage = "https://github.com/mirage/index";
+  meta = with lib; {
     description = "A platform-agnostic multi-level index";
-    license = lib.licenses.mit;
-    maintainers = [ lib.maintainers.vbgl ];
+    homepage = "https://github.com/mirage/index";
+    license = licenses.mit;
+    maintainers = with maintainers; [ vbgl ];
   };
 }

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

···
+{ lib
+, buildPythonPackage
+, pythonOlder
+, fetchFromGitHub
+, aiohttp
+, poetry-core
+, yarl
+, aresponses
+, pytest-asyncio
+, pytestCheckHook
+}:
+
+buildPythonPackage rec {
+  pname = "ambee";
+  version = "0.2.1";
+  disabled = pythonOlder "3.8";
+  format = "pyproject";
+
+  src = fetchFromGitHub {
+    owner = "frenck";
+    repo = "python-ambee";
+    rev = "v${version}";
+    sha256 = "11liw2206lyrnx09giqapjpi25lr2qnbmigi6rgynr2a1i9vxy1s";
+  };
+
+  nativeBuildInputs = [
+    poetry-core
+  ];
+
+  propagatedBuildInputs = [
+    aiohttp
+    yarl
+  ];
+
+  checkInputs = [
+    aresponses
+    pytest-asyncio
+    pytestCheckHook
+  ];
+
+  postPatch = ''
+    # Upstream doesn't set a version for the pyproject.toml
+    substituteInPlace pyproject.toml \
+      --replace "0.0.0" "${version}" \
+      --replace "--cov" ""
+  '';
+
+  pythonImportsCheck = [ "ambee" ];
+
+  meta = with lib; {
+    description = "Python client for Ambee API";
+    homepage = "https://github.com/frenck/python-ambee";
+    license = with licenses; [ mit ];
+    maintainers = with maintainers; [ fab ];
+  };
+}

pkgs/development/scheme-modules/scheme-bytestructures/default.nix

···
+{ lib
+, stdenv
+, fetchFromGitHub
+, guile
+, autoreconfHook
+, pkg-config
+}:
+
+stdenv.mkDerivation rec {
+  pname = "scheme-bytestructures";
+  version = "1.0.7";
+
+  src = fetchFromGitHub {
+    owner = "TaylanUB";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "0q0habjiy3h9cigb7q1br9kz6z212dn2ab31f6dgd3rrmsfn5rvb";
+  };
+
+  postConfigure = ''
+    sed -i '/moddir\s*=/s%=.*%=''${out}/share/guile/site%' Makefile;
+    sed -i '/godir\s*=/s%=.*%=''${out}/share/guile/ccache%' Makefile;
+  '';
+
+  nativeBuildInputs = [
+    autoreconfHook pkg-config
+  ];
+  buildInputs = [
+    guile
+  ];
+
+  meta = with lib; {
+    description = "Structured access to bytevector contents";
+    homepage = "https://github.com/TaylanUB/scheme-bytestructures";
+    license = licenses.gpl3Plus;
+    maintainers = with maintainers; [ ethancedwards8 ];
+    platforms = platforms.linux;
+  };
+}

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

···
 
 buildGoModule rec {
   pname = "tflint";
-  version = "0.29.0";
+  version = "0.29.1";
 
   src = fetchFromGitHub {
     owner = "terraform-linters";
     repo = pname;
     rev = "v${version}";
-    sha256 = "1ciwr2bwbxnw8366wvgl5ga3y2qj46i0h3yp3av1x9n2r8rddrlh";
+    sha256 = "1pkz8y3da7i4a3nm79a0640xjj4wfkx3dz6614c4hynqn5svji82";
   };
 
   vendorSha256 = "0k8v49sr0jmljfl4fa5pnvzd5k3pg865h201114l6cs257sdkczk";

pkgs/misc/emulators/wine/sources.nix

···
 
   unstable = fetchurl rec {
     # NOTE: Don't forget to change the SHA256 for staging as well.
-    version = "6.9";
+    version = "6.10";
     url = "https://dl.winehq.org/wine/source/6.x/wine-${version}.tar.xz";
-    sha256 = "sha256-GFVOYB3vhqmiAXKwhcZoMpFPwh511VX25U/4nn6uW/4=";
+    sha256 = "sha256-WO3hSEgtSRiCYtWi0MnXAKdMacUcyqEcWt9j0/MUQZ8=";
     inherit (stable) gecko32 gecko64;
 
     ## see http://wiki.winehq.org/Mono
     mono = fetchurl rec {
-      version = "6.1.1";
+      version = "6.2.0";
       url = "https://dl.winehq.org/wine/wine-mono/${version}/wine-mono-${version}-x86.msi";
-      sha256 = "sha256-rDsUvq/eNLhIIofllwABE9wGqRXzLJ/QbHfrgZB544s=";
+      sha256 = "sha256-zY1TUT2DV7KHama6sIllTvmUH0LvaQ+1VcZJP1OB28o=";
     };
 
     patches = [
···
   staging = fetchFromGitHub rec {
     # https://github.com/wine-staging/wine-staging/releases
     inherit (unstable) version;
-    sha256 = "sha256-g0NmiypafOAmKDRoRf4uz5NnhFo6uga0fKYNCF29jbE=";
+    sha256 = "sha256-nqXgJe2i1xDW1aCAmwFPshiUI2PtZ/S7p8Cq2ODMTQk=";
     owner = "wine-staging";
     repo = "wine-staging";
-    #rev = "v${version}";
-    # FIXME: replace with line above with 6.10 release
-    # Fix https://bugs.winehq.org/show_bug.cgi?id=51172
-    rev = "5bbe3e47a559b3c04bc8791e0b398a271c772af7";
+    rev = "v${version}";
 
-    # Actually only "d3d11-Deferred_Context" cause problems, two others only dependencies
-    # see FIXME above
-    disabledPatchsets = [ "d3d11-Deferred_Context" "wined3d-CSMT_Main" "nvapi-Stub_DLL" "nvcuvid-CUDA_Video_Support" "nvencodeapi-Video_Encoder" ];
+    disabledPatchsets = [ ];
   };
 
   winetricks = fetchFromGitHub rec {

pkgs/os-specific/darwin/mas/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "mas";
-  version = "1.8.1";
+  version = "1.8.2";
 
   src = fetchurl {
     url = "https://github.com/mas-cli/mas/releases/download/v${version}/mas.pkg";
-    sha256 = "W/wgg+ETeJPoZ7MoVGH2uJzQiZMLIy3n1JYKUloc3ZU=";
+    sha256 = "HlLQKBVIYKanS6kjkbYdabBi1T0irxE6fNd2H6mDKe4=";
   };
 
   nativeBuildInputs = [ libarchive p7zip ];
···
 
   installPhase = ''
     mkdir -p $out
-    cp -r ./bin $out
-    cp -r ./Frameworks $out
-  '';
-
-  postFixup = ''
-    install_name_tool -change @rpath/MasKit.framework/Versions/A/MasKit $out/Frameworks/MasKit.framework/Versions/A/MasKit $out/bin/mas
-    install_name_tool -change @rpath/Commandant.framework/Commandant $out/Frameworks/MasKit.framework/Versions/A/Frameworks/Commandant.framework/Versions/A/Commandant $out/bin/mas
+    cp -r ./usr/local/bin $out
   '';
 
   meta = with lib; {

pkgs/servers/fileshare/default.nix

···
-{ stdenv, lib, fetchgit, pkg-config, git, libmicrohttpd_0_9_70 }:
+{ stdenv, lib, fetchgit, pkg-config, git, libmicrohttpd }:
 
 stdenv.mkDerivation rec {
   pname = "fileshare";
···
   '';
 
   nativeBuildInputs = [ pkg-config git ];
-  buildInputs = [ libmicrohttpd_0_9_70 ];
+  buildInputs = [ libmicrohttpd ];
 
   makeFlags = [ "BUILD=release" ];
 

pkgs/servers/monitoring/grafana/default.nix

···
 
 buildGoModule rec {
   pname = "grafana";
-  version = "8.0.0";
+  version = "8.0.1";
 
   excludedPackages = [ "release_publisher" ];
 
···
     rev = "v${version}";
     owner = "grafana";
     repo = "grafana";
-    sha256 = "sha256-HtubiSx4Orf9knZcuYy4eF2qwclX/JVd2Ba9L33tM74=";
+    sha256 = "sha256-Vs/4urH/XuoVly26YfhFbf/T3x5jdS4BgrVStuTHaHo=";
   };
 
   srcStatic = fetchurl {
     url = "https://dl.grafana.com/oss/release/grafana-${version}.linux-amd64.tar.gz";
-    sha256 = "sha256-bwBpkPy4kwfnkRsLOktUgQx+Sm8WJA2d65efMBCnGp4=";
+    sha256 = "sha256-b05nUApLjdQW5vbS56HUK+/GXKcHo2UAHybfe6ZTr3U=";
   };
 
-  vendorSha256 = "sha256-Hon5WrhXUvZUtMRxx3XcBDQe3rkRkfqbnXjY3xCzuuM=";
+  vendorSha256 = "sha256-iwB1JtekxFYSHjaV+TqBDqnyE5zt3RJ4dQmf12AA53U=";
 
   preBuild = ''
     # The testcase makes an API call against grafana.com:
···
 
     # main module (github.com/grafana/grafana) does not contain package github.com/grafana/grafana/scripts/go
     rm -r scripts/go
+  '';
+
+  buildFlagsArray = ''
+    -ldflags=-s -w -X main.version=${version}
   '';
 
   postInstall = ''

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

···
 
 stdenv.mkDerivation rec {
   pname = "pgvector";
-  version = "0.1.5";
+  version = "0.1.6";
 
   src = fetchFromGitHub {
     owner = "ankane";
     repo = pname;
     rev = "v${version}";
-    sha256 = "0zrb9r9yh05nip2gwg96fhfk766hwqwa8plcvj2b4x4hhjk6q1ps";
+    sha256 = "108qf5pvqhz4vh31sijikajf4hrrk7rknrqzwj999psr33acag4z";
   };
 
   buildInputs = [ postgresql ];

pkgs/servers/teleport/default.nix

···
   webassets = fetchFromGitHub {
     owner = "gravitational";
     repo = "webassets";
-    rev = "cf396f868aebb8ba654ea2398c25f033181e7114";
-    sha256 = "sha256-12jkpWl/kL0ttRHtxyDnKjYAZNrheEGQF8HEGSXvvAk=";
+    rev = "8c2812c169fa6bd5f31c13160bd93ef8b317bbc9";
+    sha256 = "sha256-O+H8N1yqQiH645mgXeSc330GRmxF+gxiJJ5iYn65Z6Q=";
   };
 in
 
 buildGoModule rec {
   pname = "teleport";
-  version = "6.1.3";
+  version = "6.2.3";
 
   # This repo has a private submodule "e" which fetchgit cannot handle without failing.
   src = fetchFromGitHub {
     owner = "gravitational";
     repo = "teleport";
     rev = "v${version}";
-    sha256 = "sha256-kb7qRPZKXDY0Qy3/72epAGaN2FCOO/XAN8lOoUYkoM0=";
+    sha256 = "sha256-3syl1a2ui8/aTgCvihuhg575Df31loOXuENBNJG3nR0=";
   };
 
   vendorSha256 = null;

pkgs/tools/admin/google-cloud-sdk/default.nix

···
   sources = name: system: {
     x86_64-darwin = {
       url = "${baseUrl}/${name}-darwin-x86_64.tar.gz";
-      sha256 = "1f86pkjsp8lrmk8ap40wh9zbzb2ni49vc2cjsdjbj4pkkwivihpv";
+      sha256 = "0xhy2sa04ir5ncjnnx25nyf66k21w3f649smhfpz9973s7vk5vhg";
     };
 
     x86_64-linux = {
       url = "${baseUrl}/${name}-linux-x86_64.tar.gz";
-      sha256 = "1l47lq2wq8y0adrjij3w5ki1mm1f00503ks398flfmbzyav6bad3";
+      sha256 = "1dkj4cpy891nd3l1xcqaj1mfphirs9fzbm081i8pyn36nwmdpg2j";
     };
   }.${system};
 
 in stdenv.mkDerivation rec {
   pname = "google-cloud-sdk";
-  version = "343.0.0";
+  version = "344.0.0";
 
   src = fetchurl (sources "${pname}-${version}" stdenv.hostPlatform.system);
 

pkgs/tools/misc/fend/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "fend";
-  version = "0.1.16";
+  version = "0.1.17";
 
   src = fetchFromGitHub {
     owner = "printfn";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-ITS2wE4vwp0W/nlTyX55cY5E95VIwR46JBzF0pD/xsE=";
+    sha256 = "sha256-Xq2UjeZiKy9BjNQ9xnC7tppEwrEtg8ZN5BVDz1bUOmw=";
   };
 
-  cargoSha256 = "sha256-YqOc/B+ZP1i9xJLrOguQ6fwQr6SV0qvQ3fWwguY2S0I=";
+  cargoSha256 = "sha256-Bf3fYHhpoX05AmTdwwdRU2YRfGVb1EmaGDm75i+Vs2w=";
 
   doInstallCheck = true;
 

pkgs/tools/security/secp256k1/default.nix

···
-{ lib, stdenv, fetchFromGitHub, autoreconfHook, jdk
-
-# Enable ECDSA pubkey recovery module
-, enableRecovery ? true
-
-# Enable ECDH shared secret computation (disabled by default because it is
-# experimental)
-, enableECDH ? false
-
-# Enable libsecp256k1_jni (disabled by default because it requires a jdk,
-# which is a large dependency)
-, enableJNI ? false
-
+{ lib
+, stdenv
+, fetchFromGitHub
+, autoreconfHook
 }:
-
-let inherit (lib) optionals; in
 
 stdenv.mkDerivation {
   pname = "secp256k1";
 
   # I can't find any version numbers, so we're just using the date of the
   # last commit.
-  version = "2020-08-16";
+  version = "unstable-2021-06-06";
 
   src = fetchFromGitHub {
     owner = "bitcoin-core";
     repo = "secp256k1";
-    rev = "670cdd3f8be25f81472b2d16dcd228b0d24a5c45";
-    sha256 = "0ak2hrr0wznl5d9s905qwn5yds7k22i28d2jp957l4a8yf8cqv3s";
+    rev = "7973576f6e3ab27d036a09397152b124d747f4ae";
+    sha256 = "0vjk55dv0mkph4k6bqgkykmxn05ngzvhc4rzjnvn33xzi8dzlvah";
   };
-
-  buildInputs = optionals enableJNI [ jdk ];
 
   nativeBuildInputs = [ autoreconfHook ];
 
-  configureFlags =
-    [ "--enable-benchmark=no" "--enable-tests=yes" "--enable-exhaustive-tests=no" ] ++
-    optionals enableECDH [ "--enable-module-ecdh" "--enable-experimental" ] ++
-    optionals enableRecovery [ "--enable-module-recovery" ] ++
-    optionals enableJNI [ "--enable-jni" ];
+  configureFlags = [
+    "--enable-benchmark=no"
+    "--enable-exhaustive-tests=no"
+    "--enable-experimental"
+    "--enable-module-ecdh"
+    "--enable-module-recovery"
+    "--enable-module-schnorrsig"
+    "--enable-tests=yes"
+  ];
 
   doCheck = true;
+
   checkPhase = "./tests";
 
   meta = with lib; {

pkgs/top-level/all-packages.nix

···
 
   nvchecker = with python3Packages; toPythonApplication nvchecker;
 
-  nvfetcher = with haskell.lib; overrideCabal (justStaticExecutables haskellPackages.nvfetcher) (drv: {
-    executableToolDepends = [ makeWrapper ];
-    postInstall = ''
-      wrapProgram $out/bin/nvfetcher \
-        --prefix PATH ":" "${nvchecker}/bin:${nix-prefetch-git}/bin"
-    '';
-  });
+  nvfetcher = haskell.lib.justStaticExecutables haskellPackages.nvfetcher;
 
   miller = callPackage ../tools/text/miller { };
 
···
 
   scheme48 = callPackage ../development/interpreters/scheme48 { };
 
+  scheme-bytestructures = callPackage ../development/scheme-modules/scheme-bytestructures { };
+
   self = pkgsi686Linux.callPackage ../development/interpreters/self { };
 
   spark = callPackage ../applications/networking/cluster/spark { };
···
   guile-commonmark = callPackage ../development/guile-modules/guile-commonmark { };
 
   guile-fibers = callPackage ../development/guile-modules/guile-fibers { };
+
+  guile-git = callPackage ../development/guile-modules/guile-git { };
 
   guile-gnome = callPackage ../development/guile-modules/guile-gnome {
     gconf = gnome2.GConf;
···
 
   jnetmap = callPackage ../applications/networking/jnetmap {};
 
-  libbitcoin = callPackage ../tools/misc/libbitcoin/libbitcoin.nix {
-    secp256k1 = secp256k1.override { enableECDH = true; };
-  };
-
+  libbitcoin = callPackage ../tools/misc/libbitcoin/libbitcoin.nix { };
   libbitcoin-protocol = callPackage ../tools/misc/libbitcoin/libbitcoin-protocol.nix { };
   libbitcoin-client   = callPackage ../tools/misc/libbitcoin/libbitcoin-client.nix { };
   libbitcoin-network  = callPackage ../tools/misc/libbitcoin/libbitcoin-network.nix { };

pkgs/top-level/dotnet-packages.nix

···
     outputFiles = [ "*" ];
   };
 
-  YamlDotNet = fetchNuGet {
-    baseName = "YamlDotNet";
-    version = "11.1.1";
-    sha256 = "rwZ/QyDVrN3wGrEYKY3QY5Xqo2Tp3FkR6dh4QrC+QS0=";
-    outputFiles = [ "lib/*" ];
-
-    meta = with lib; {
-      description = "YamlDotNet is a .NET library for YAML";
-      homepage = "https://github.com/aaubry/YamlDotNet";
-      license = licenses.mit;
-      maintainers = [ maintainers.ratsclub ];
-    };
-  };
-
 }; in self

pkgs/top-level/python-packages.nix

···
 
   amazon_kclpy = callPackage ../development/python-modules/amazon_kclpy { };
 
+  ambee = callPackage ../development/python-modules/ambee { };
+
   ambiclimate = callPackage ../development/python-modules/ambiclimate { };
 
   amcrest = callPackage ../development/python-modules/amcrest { };

pkgs/top-level/release-haskell.nix

···
       # working as expected.
       cabal-install = all;
       Cabal_3_4_0_0 = with compilerNames; [ ghc884 ghc8104 ];
+      cabal2nix-unstable = all;
       funcmp = all;
       # Doesn't currently work on ghc-9.0:
       # https://github.com/haskell/haskell-language-server/issues/297