Merge master into staging-next

maintainers/maintainer-list.nix

···
     githubId = 623509;
     name = "Martijn Vermaat";
   };
+  martinetd = {
+    email = "[e-mail]";
+    github = "martinetd";
+    githubId = 1729331;
+    name = "Dominique Martinet";
+  };
   martingms = {
     email = "[e-mail]";
     github = "martingms";

nixos/doc/manual/from_md/release-notes/rl-2205.section.xml

···
           <literal>enableParallelBuilding=false</literal>.
         </para>
       </listitem>
+      <listitem>
+        <para>
+          <literal>pkgs.claws-mail-gtk2</literal>, representing Claws
+          Mail’s older release version three, was removed in order to
+          get rid of Python 2. Please switch to
+          <literal>claws-mail</literal>, which is Claws Mail’s latest
+          release based on GTK+3 and Python 3.
+        </para>
+      </listitem>
     </itemizedlist>
   </section>
   <section xml:id="sec-release-22.05-notable-changes">

nixos/doc/manual/release-notes/rl-2205.section.md

···
 
 - The `wafHook` hook now honors `NIX_BUILD_CORES` when `enableParallelBuilding` is not set explicitly. Packages can restore the old behaviour by setting `enableParallelBuilding=false`.
 
+- `pkgs.claws-mail-gtk2`, representing Claws Mail's older release version three, was removed in order to get rid of Python 2.
+  Please switch to `claws-mail`, which is Claws Mail's latest release based on GTK+3 and Python 3.
+
 ## Other Notable Changes {#sec-release-22.05-notable-changes}

nixos/modules/programs/bcc.nix

···
-{ config, lib, ... }:
+{ config, pkgs, lib, ... }:
 {
   options.programs.bcc.enable = lib.mkEnableOption "bcc";
 
   config = lib.mkIf config.programs.bcc.enable {
-    environment.systemPackages = [ config.boot.kernelPackages.bcc ];
-    boot.extraModulePackages = [ config.boot.kernelPackages.bcc ];
+    environment.systemPackages = [ pkgs.bcc ];
+    boot.extraModulePackages = [ pkgs.bcc ];
   };
 }

nixos/tests/all-tests.nix

···
   boot-stage1 = handleTest ./boot-stage1.nix {};
   borgbackup = handleTest ./borgbackup.nix {};
   botamusique = handleTest ./botamusique.nix {};
+  bpf = handleTestOn ["x86_64-linux" "aarch64-linux"] ./bpf.nix {};
   btrbk = handleTest ./btrbk.nix {};
   buildbot = handleTest ./buildbot.nix {};
   buildkite-agents = handleTest ./buildkite-agents.nix {};

nixos/tests/bpf.nix

···
+import ./make-test-python.nix ({ pkgs, ... }: {
+  name = "bpf";
+  meta.maintainers = with pkgs.lib.maintainers; [ martinetd ];
+
+  machine = { pkgs, ... }: {
+    programs.bcc.enable = true;
+    environment.systemPackages = with pkgs; [ bpftrace ];
+  };
+
+  testScript = ''
+    ## bcc
+    # syscount -d 1 stops 1s after probe started so is good for that
+    print(machine.succeed("syscount -d 1"))
+
+    ## bpftrace
+    # list probes
+    machine.succeed("bpftrace -l")
+    # simple BEGIN probe (user probe on bpftrace itself)
+    print(machine.succeed("bpftrace -e 'BEGIN { print(\"ok\"); exit(); }'"))
+    # tracepoint
+    print(machine.succeed("bpftrace -e 'tracepoint:syscalls:sys_enter_* { print(probe); exit(); }'"))
+    # kprobe
+    print(machine.succeed("bpftrace -e 'kprobe:schedule { print(probe); exit() }'"))
+  '';
+})

pkgs/applications/networking/browsers/lagrange/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "lagrange";
-  version = "1.9.0";
+  version = "1.9.1";
 
   src = fetchFromGitHub {
     owner = "skyjake";
     repo = "lagrange";
     rev = "v${version}";
-    sha256 = "sha256-T4LZcdQHqykcv1HnTHMt5LE/1gwKPjN3f0ZmqSCID/A=";
+    sha256 = "sha256-5mZbx9L7YDG2VwrF/iFhYCw8R/0FOnZz9cRkA5Wl9MA=";
     fetchSubmodules = true;
   };
 

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

···
 
 buildGoModule rec {
   pname = "cilium-cli";
-  version = "0.9.2";
+  version = "0.9.3";
 
   src = fetchFromGitHub {
     owner = "cilium";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-vIm5PkRyh41jtvDrLDxFVzSkhFipYYYEEY0/qxbOXGE=";
+    sha256 = "sha256-t4Im3/2qcKnDDcKWmUUa/lsZszDDlos+uTERKxd7x1c=";
   };
 
   vendorSha256 = null;

pkgs/applications/networking/instant-messengers/whatsapp-for-linux/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "whatsapp-for-linux";
-  version = "1.3.0";
+  version = "1.3.1";
 
   src = fetchFromGitHub {
     owner = "eneshecan";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-VdkCjzmZqP/ZVY1H9FxBGe5rN0nZEPZbMp3MVKL6WLc=";
+    sha256 = "sha256-TX6fMuhe6VHbhWJSsPM0iOV4CuCfULD5McJyHuTW4lI=";
   };
 
   nativeBuildInputs = [

pkgs/applications/networking/mailreaders/claws-mail/default.nix

···
 { stdenv, lib, fetchgit, fetchpatch, wrapGAppsHook, autoreconfHook, bison, flex
-, curl, gtk2, gtk3, pkg-config, python2, python3, shared-mime-info
+, curl, gtk3, pkg-config, python3, shared-mime-info
 , glib-networking, gsettings-desktop-schemas
-
-# Selector between the GTK+ 3 and GTK+ 2 releases.
-, useGtk3
 
 # Package compatibility: old parameters whose name were not directly derived
 , enablePgp ? true
···
 , enablePluginBsfilter ? true
 , enablePluginClamd ? true
 , enablePluginDillo ? true
-, enablePluginFancy ? useGtk3, libsoup, webkitgtk
+, enablePluginFancy ? true, libsoup, webkitgtk
 , enablePluginFetchInfo ? true
 , enablePluginLibravatar ? enablePluginRavatar
 , enablePluginLitehtmlViewer ? true, gumbo
 , enablePluginMailmbox ? true
 , enablePluginManageSieve ? true
 , enablePluginNewMail ? true
-, enablePluginNotification ? (enablePluginNotificationDialogs || enablePluginNotificationSounds), libcanberra-gtk2, libcanberra-gtk3, libnotify
+, enablePluginNotification ? (enablePluginNotificationDialogs || enablePluginNotificationSounds), libcanberra-gtk3, libnotify
 , enablePluginPdfViewer ? enablePluginPdf, poppler
 , enablePluginPerl ? true, perl
 , enablePluginPython ? true
···
 with lib;
 
 let
-  # Last release and hash for both the GTK+ 3 and GTK+ 2 version.
-  version = if useGtk3 then "4.0.0" else "3.18.0";
-
-  gtk2src = {
-    sha256 = "1vsiy3xsppw4d8ylsz70wsyrvmgy88lp2hj7vrc353ckny80r9lh";
-  };
-
-  gtk3src = {
-    sha256 = "0mwnjiqg2sj61va0y9yi3v52iyr5kzmbnvsqxav3a48m2f8p27qn";
-  };
-
-  python = if useGtk3 then python3 else python2;
-  pythonPkgs = if useGtk3
-    then
-      with python.pkgs; [ python wrapPython pygobject3 ]
-    else
-      with python.pkgs; [ python wrapPython pygtk pygobject2 ];
+  pythonPkgs = with python3.pkgs; [ python3 wrapPython pygobject3 ];
 
   features = [
     { flags = [ "acpi_notifier-plugin" ]; enabled = enablePluginAcpiNotifier; }
···
     { flags = [ "managesieve-plugin" ]; enabled = enablePluginManageSieve; }
     { flags = [ "networkmanager" ]; enabled = enableNetworkManager; deps = [ networkmanager ]; }
     { flags = [ "newmail-plugin" ]; enabled = enablePluginNewMail; }
-    { flags = [ "notification-plugin" ]; enabled = enablePluginNotification; deps = [ libnotify ] ++ [(if useGtk3 then libcanberra-gtk3 else libcanberra-gtk2)]; }
+    { flags = [ "notification-plugin" ]; enabled = enablePluginNotification; deps = [ libnotify ] ++ [libcanberra-gtk3]; }
     { flags = [ "pdf_viewer-plugin" ]; enabled = enablePluginPdfViewer; deps = [ poppler ]; }
     { flags = [ "perl-plugin" ]; enabled = enablePluginPerl; deps = [ perl ]; }
     { flags = [ "pgpcore-plugin" "pgpinline-plugin" "pgpmime-plugin" ]; enabled = enablePluginPgp; deps = [ gnupg gpgme ]; }
···
   ];
 in stdenv.mkDerivation rec {
   pname = "claws-mail";
-  inherit version;
+  version = "4.0.0";
 
-  src = fetchgit ({
+  src = fetchgit {
     rev = version;
     url = "git://git.claws-mail.org/claws.git";
-  } // (if useGtk3 then gtk3src else gtk2src));
+    sha256 = "0mwnjiqg2sj61va0y9yi3v52iyr5kzmbnvsqxav3a48m2f8p27qn";
+    };
 
   outputs = [ "out" "dev" ];
 
···
 
   preConfigure = ''
     # autotools check tries to dlopen libpython as a requirement for the python plugin
-    export LD_LIBRARY_PATH=$LD_LIBRARY_PATH''${LD_LIBRARY_PATH:+:}${python}/lib
+    export LD_LIBRARY_PATH=$LD_LIBRARY_PATH''${LD_LIBRARY_PATH:+:}${python3}/lib
     # generate version without .git
     [ -e version ] || echo "echo ${version}" > version
   '';
···
   propagatedBuildInputs = pythonPkgs;
 
   buildInputs =
-    [ curl gsettings-desktop-schemas glib-networking ]
-    ++ [(if useGtk3 then gtk3 else gtk2)]
+    [ curl gsettings-desktop-schemas glib-networking gtk3 ]
     ++ concatMap (f: optionals f.enabled f.deps) (filter (f: f ? deps) features)
   ;
 

pkgs/applications/office/hledger-check-fancyassertions/default.nix

···
     "hledger-check-fancyassertions"
     {
       libraries = with haskellPackages; [
-        base base-compat base-compat-batteries filepath hledger-lib_1_23
+        base base-compat base-compat-batteries filepath hledger-lib_1_24
         megaparsec microlens optparse-applicative string-qq text time
         transformers
       ];

pkgs/applications/video/kodi/unwrapped.nix

···
     '' + lib.optionalString (stdenv.hostPlatform != stdenv.buildPlatform) ''
       # Need these tools on the build system when cross compiling,
       # hacky, but have found no other way.
-      CXX=${stdenv.cc.targetPrefix}c++ LD=ld make -C tools/depends/native/JsonSchemaBuilder
+      CXX=$CXX_FOR_BUILD LD=ld make -C tools/depends/native/JsonSchemaBuilder
       cmakeFlags+=" -DWITH_JSONSCHEMABUILDER=$PWD/tools/depends/native/JsonSchemaBuilder/bin"
 
-      CXX=${stdenv.cc.targetPrefix}c++ LD=ld make EXTRA_CONFIGURE= -C tools/depends/native/TexturePacker
+      CXX=$CXX_FOR_BUILD LD=ld make EXTRA_CONFIGURE= -C tools/depends/native/TexturePacker
       cmakeFlags+=" -DWITH_TEXTUREPACKER=$PWD/tools/depends/native/TexturePacker/bin"
     '';
 

pkgs/applications/video/kodi/wrapper.nix

···
   paths = [ kodi ] ++ addons;
   pathsToLink = [ "/share" ];
 
-  buildInputs = [ makeWrapper ];
+  nativeBuildInputs = [ makeWrapper ];
 
   postBuild = ''
     mkdir $out/bin

pkgs/applications/virtualization/runc/default.nix

···
 
 buildGoModule rec {
   pname = "runc";
-  version = "1.0.2";
+  version = "1.0.3";
 
   src = fetchFromGitHub {
     owner = "opencontainers";
     repo = "runc";
     rev = "v${version}";
-    sha256 = "sha256-l+Uq7aiXFrI+qbKSOZpYFIXz0VJBBR7ZZxlAJeGb7K4=";
+    sha256 = "sha256-Tl/JKbIpao+FCjngPzaVkxse50zo3XQ9Mg/AdkblMcI=";
   };
 
   vendorSha256 = null;

pkgs/data/misc/conway_polynomials/default.nix

···
 { lib, stdenv
 , fetchurl
-, python2
+, python3
 }:
 
 stdenv.mkDerivation rec {
   pname = "conway_polynomials";
   version = "0.5";
 
-  pythonEnv = python2.withPackages (ps: with ps; [ six ]);
-
   src = fetchurl {
     url = "mirror://sageupstream/conway_polynomials/conway_polynomials-${version}.tar.bz2";
     sha256 = "05zb1ly9x2bbscqv0jgc45g48xx77mfs7qdbqhn4ihmihn57iwnq";
···
 
   # Script that creates the "database" (nested python array) and pickles it
   spkg-install = fetchurl {
-    url = "https://git.sagemath.org/sage.git/plain/build/pkgs/conway_polynomials/spkg-install.py?id=07d6c37d18811e2b377a9689790a7c5e24da16ba";
-    sha256 = "0m12nfb37j3bn4bp06ddgnyp2d6z0hg5f83pbbjszxw7vxs33a82";
+    url = "https://git.sagemath.org/sage.git/plain/build/pkgs/conway_polynomials/spkg-install.py?id=9.2";
+    sha256 = "1bwnqasnyv793hxg29viing4dnliz29grkhldsirq19d509yk1fs";
   };
 
   installPhase = ''
···
     export SAGE_SHARE="$out/share"
     export PYTHONPATH=$PWD
 
-    ${pythonEnv.interpreter} ${spkg-install}
+    ${python3.interpreter} ${spkg-install}
   '';
 
   meta = with lib; {

pkgs/data/misc/elliptic_curves/default.nix

···
 { lib, stdenv
 , fetchurl
-, python2
+, python3
 }:
 
 stdenv.mkDerivation rec {
···
     export SAGE_SHARE="$out/share"
     export PYTHONPATH=$PWD
 
-    ${python2.interpreter} ${spkg-install}
+    ${python3.interpreter} ${spkg-install}
   '';
 
   meta = with lib; {

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "5ac4efab1c8e40b19b0bc4ba833477a4abc75358",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/5ac4efab1c8e40b19b0bc4ba833477a4abc75358.tar.gz",
-  "sha256": "0xnrdwmc646ghwzp61jp376s9fkpcd74slxc39law7akfp77v4ls",
-  "msg": "Update from Hackage at 2021-11-18T20:32:52Z"
+  "commit": "d859530d8342c52d09a73d1d125c144725b5945d",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/d859530d8342c52d09a73d1d125c144725b5945d.tar.gz",
+  "sha256": "0gjahsqqq99dc4bjcx9p3z8adpwy51w3mzrf57nib856jlvlfmv5",
+  "msg": "Update from Hackage at 2021-12-02T21:05:02Z"
 }

pkgs/desktops/gnome/apps/gnome-maps/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "gnome-maps";
-  version = "41.1";
+  version = "41.2";
 
   src = fetchurl {
     url = "mirror://gnome/sources/${pname}/${lib.versions.major version}/${pname}-${version}.tar.xz";
-    sha256 = "sha256-XtyUpXlHDO1HztKSxUq6Z8vnBIGOF0BsCQwB1Dlb4a0=";
+    sha256 = "sha256-gYIbTK/GQc1QDXOzMMY85aBahPBDBxbWPoizyuqs/Qw=";
   };
 
   doCheck = true;

pkgs/desktops/gnome/core/gnome-control-center/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "gnome-control-center";
-  version = "41.1";
+  version = "41.2";
 
   src = fetchurl {
     url = "mirror://gnome/sources/${pname}/${lib.versions.major version}/${pname}-${version}.tar.xz";
-    sha256 = "sha256-6gxxSExlzizBE3b5sB5iEfpKf/0zT0MH/FLJPw/d1Mc=";
+    sha256 = "sha256-gnH8azPsJBileDBN0+V9Zl8NfMcGqZqXvkGYSGGP4kg=";
   };
 
   patches = [

pkgs/desktops/gnome/core/gnome-initial-setup/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "gnome-initial-setup";
-  version = "41.0";
+  version = "41.2";
 
   src = fetchurl {
     url = "mirror://gnome/sources/${pname}/${lib.versions.major version}/${pname}-${version}.tar.xz";
-    sha256 = "R/ZHW2bIQ+fVPZC6Dns5SHYt8VFjSkNvaMK5u6BQVgo=";
+    sha256 = "GTr79qMILaCjKncU8ejVKo20Vycpde0vNlQ2SjM5Gz8=";
   };
 
   patches = [

pkgs/desktops/gnome/core/yelp-xsl/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "yelp-xsl";
-  version = "41.0";
+  version = "41.1";
 
   src = fetchurl {
     url = "mirror://gnome/sources/yelp-xsl/${lib.versions.major version}/${pname}-${version}.tar.xz";
-    sha256 = "sha256-yM1kwJO72MXV5H/TiGTpCDG1+c90A1MIcCBvqWY2pKU=";
+    sha256 = "sha256-DW2zesLvgSSD4BBHA/H6nPAy6eCVal8cOvvMI3kfilQ=";
   };
 
   nativeBuildInputs = [

pkgs/desktops/gnome/games/aisleriot/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "aisleriot";
-  version = "3.22.19";
+  version = "3.22.20";
 
   src = fetchFromGitLab {
     domain = "gitlab.gnome.org";
     owner = "GNOME";
     repo = pname;
     rev = version;
-    sha256 = "sha256-YY0/HkafcbbW0xuE9RmjYMHN50lM0o0zugOyTefT0bE=";
+    sha256 = "sha256-5xFwlhT9qjtvNDQ8kfGd2BeK2KcJDzpfsEC8z4Ei3ns=";
   };
 
   nativeBuildInputs = [

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

···
       name = "git-annex-${super.git-annex.version}-src";
       url = "git://git-annex.branchable.com/";
       rev = "refs/tags/" + super.git-annex.version;
-      sha256 = "06njg44840na3ps3s29kjhjba0962vdr2zpd12yvqf16rwgf4zmq";
+      sha256 = "1x2d0gfqxxfygzigm34n0spaxh8bwipxs9317f6c5lkpj916p957";
       # delete android and Android directories which cause issues on
       # darwin (case insensitive directory). Since we don't need them
       # during the build process, we can delete it to prevent a hash
···
     })
     super.hledger-lib;
 
-  # hledger-lib 1.23 depends on doctest >= 0.18
-  hledger-lib_1_23 = super.hledger-lib_1_23.override {
+  # hledger-lib 1.24 depends on doctest >= 0.18
+  hledger-lib_1_24 = super.hledger-lib_1_24.override {
     doctest = self.doctest_0_18_2;
   };
 
···
   dhall-json = generateOptparseApplicativeCompletions ["dhall-to-json" "dhall-to-yaml"] (dontCheck super.dhall-json);
   dhall-nix = generateOptparseApplicativeCompletion "dhall-to-nix" super.dhall-nix;
   dhall-yaml = generateOptparseApplicativeCompletions ["dhall-to-yaml-ng" "yaml-to-dhall"] super.dhall-yaml;
+  # Too strict lower bound on base64-bytestring
+  # https://github.com/dhall-lang/dhall-haskell/issues/2346
+  dhall-nixpkgs = overrideCabal (drv: {
+    revision = assert !(drv ? revision); "1";
+    editedCabalFile = "0ld4z4d3gw9mxyhm5g2hgw4w68izjnwrcqd6j7yhwhrblhdmqrr4";
+  }) (generateOptparseApplicativeCompletion "dhall-to-nixpkgs" super.dhall-nixpkgs);
 
   # https://github.com/haskell-hvr/netrc/pull/2#issuecomment-469526558
   netrc = doJailbreak super.netrc;
···
     resource-pool = self.hasura-resource-pool;
     ekg-core = self.hasura-ekg-core;
     ekg-json = self.hasura-ekg-json;
-    hspec = dontCheck self.hspec_2_9_1;
-    hspec-core = dontCheck self.hspec-core_2_9_1;
-    hspec-discover = dontCheck super.hspec-discover_2_9_1;
+    hspec = dontCheck self.hspec_2_9_2;
+    hspec-core = dontCheck self.hspec-core_2_9_2;
+    hspec-discover = dontCheck super.hspec-discover_2_9_2;
     tasty-hspec = self.tasty-hspec_1_2;
   }));
   hasura-ekg-core = doJailbreak (super.hasura-ekg-core.overrideScope (self: super: {
-    hspec = dontCheck self.hspec_2_9_1;
-    hspec-core = dontCheck self.hspec-core_2_9_1;
-    hspec-discover = dontCheck super.hspec-discover_2_9_1;
+    hspec = dontCheck self.hspec_2_9_2;
+    hspec-core = dontCheck self.hspec-core_2_9_2;
+    hspec-discover = dontCheck super.hspec-discover_2_9_2;
   }));
   hasura-ekg-json = super.hasura-ekg-json.overrideScope (self: super: {
     ekg-core = self.hasura-ekg-core;
-    hspec = dontCheck self.hspec_2_9_1;
-    hspec-core = dontCheck self.hspec-core_2_9_1;
-    hspec-discover = dontCheck super.hspec-discover_2_9_1;
+    hspec = dontCheck self.hspec_2_9_2;
+    hspec-core = dontCheck self.hspec-core_2_9_2;
+    hspec-discover = dontCheck super.hspec-discover_2_9_2;
   });
   pg-client = overrideCabal (drv: {
     librarySystemDepends = with pkgs; [ postgresql krb5.dev openssl.dev ];
···
   # https://github.com/enomsg/science-constants-dimensional/pull/1
   science-constants-dimensional = doJailbreak super.science-constants-dimensional;
 
-  # Tests are flaky on busy machines
+  # Tests are flaky on busy machines, upstream doesn't intend to fix
   # https://github.com/merijn/paramtree/issues/4
   paramtree = dontCheck super.paramtree;
 
···
   composite-aeson = assert super.composite-aeson.version == "0.7.5.0";
     doJailbreak super.composite-aeson;
 
-  # Too strict bounds on profunctors
-  # https://github.com/google/proto-lens/issues/413
-  proto-lens = doJailbreak super.proto-lens;
-
   # 2021-06-20: Outdated upper bounds
   # https://github.com/Porges/email-validate-hs/issues/58
   email-validate = doJailbreak super.email-validate;
···
   ghcup = doJailbreak (super.ghcup.overrideScope (self: super: {
     hspec-golden-aeson = self.hspec-golden-aeson_0_9_0_0;
     optics = self.optics_0_4;
-    streamly = self.streamly_0_8_0;
+    streamly = self.streamly_0_8_1;
     Cabal = self.Cabal_3_6_2_0;
     libyaml-streamly = markUnbroken super.libyaml-streamly;
   }));
···
 
   # Jailbreak isn't sufficient, but this is ok as it's a leaf package.
   hadolint = super.hadolint.overrideScope (self: super: {
-    language-docker = self.language-docker_10_3_0;
-    hspec = dontCheck self.hspec_2_9_1;
-    hspec-core = dontCheck self.hspec-core_2_9_1;
-    hspec-discover = dontCheck self.hspec-discover_2_9_1;
+    language-docker = self.language-docker_10_4_0;
+    hspec = dontCheck self.hspec_2_9_2;
+    hspec-core = dontCheck self.hspec-core_2_9_2;
+    hspec-discover = dontCheck self.hspec-discover_2_9_2;
     colourista = doJailbreak super.colourista;
   });
 
   # These should be updated in lockstep
-  hledger_1_23 = super.hledger_1_23.override {
-    hledger-lib = self.hledger-lib_1_23;
+  hledger_1_24 = super.hledger_1_24.override {
+    hledger-lib = self.hledger-lib_1_24;
   };
 
   # Needs brick > 0.64
   nix-tree = super.nix-tree.override {
-    brick = self.brick_0_64_2;
+    brick = self.brick_0_65;
   };
 
   # build newer version for `pkgs.shellcheck`
   ShellCheck_0_8_0 = doDistribute super.ShellCheck_0_8_0;
+
+  # test suite requires stack to run, https://github.com/dino-/photoname/issues/24
+  photoname = dontCheck super.photoname;
+
+  # Too strict bounds on recursive-zipper
+  # https://github.com/ChrisPenner/jet/issues/1
+  jet = doJailbreak super.jet;
 
 } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

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

···
   c2hsc = addTestToolDepends [ pkgs.gcc ] super.c2hsc;
 
   # streamly depends on Cocoa starting with 0.8.0
-  streamly_0_8_0 = overrideCabal (drv: {
+  streamly_0_8_1 = overrideCabal (drv: {
     libraryFrameworkDepends = [
       darwin.apple_sdk.frameworks.Cocoa
     ] ++ (drv.libraryFrameworkDepends or []);
-  }) super.streamly_0_8_0;
+  }) super.streamly_0_8_1;
 
 } // lib.optionalAttrs pkgs.stdenv.isAarch64 {  # aarch64-darwin
 

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

···
   # 2021-11-08: Fixed in autoapply-0.4.2
   autoapply = doJailbreak self.autoapply_0_4_1_1;
 
-  # Doesn't allow Dhall 1.39.*
-  weeder_2_3_0 = super.weeder_2_3_0.override {
-    dhall = self.dhall_1_40_1;
-  };
+  # Doesn't allow Dhall 1.39.*; forbids lens 5.1
+  weeder_2_3_0 = doJailbreak (super.weeder_2_3_0.override {
+    dhall = self.dhall_1_40_2;
+  });
 
   # Upstream also disables test for GHC 9: https://github.com/kcsongor/generic-lens/pull/130
   generic-lens_2_2_0_0 = dontCheck super.generic-lens_2_2_0_0;
···
   # 2021-09-18: Need semialign >= 1.2 for correct bounds
   semialign = super.semialign_1_2_0_1;
 
-  # Will probably be needed for brittany support
-  # https://github.com/lspitzner/czipwith/pull/2
-  #czipwith = appendPatch
-  #    (pkgs.fetchpatch {
-  #      url = "https://github.com/lspitzner/czipwith/commit/b6245884ae83e00dd2b5261762549b37390179f8.patch";
-  #      sha256 = "08rpppdldsdwzb09fmn0j55l23pwyls2dyzziw3yjc1cm0j5vic5";
-  #    }) super.czipwith;
-
-  # 2021-09-18: https://github.com/mokus0/th-extras/pull/8
-  # Release is missing, but asked for in the above PR.
-  th-extras = overrideCabal (old: {
-      version = assert old.version == "0.0.0.4"; "unstable-2021-09-18";
-      src = pkgs.fetchFromGitHub  {
-        owner = "mokus0";
-        repo = "th-extras";
-        rev = "0d050b24ec5ef37c825b6f28ebd46787191e2a2d";
-        sha256 = "045f36yagrigrggvyb96zqmw8y42qjsllhhx2h20q25sk5h44xsd";
-      };
-      libraryHaskellDepends = old.libraryHaskellDepends ++ [self.th-abstraction];
-    }) super.th-extras;
-
   # 2021-09-18: GHC 9 compat release is missing
   # Issue: https://github.com/obsidiansystems/dependent-sum/issues/65
   dependent-sum-template = dontCheck (appendPatch
···
   # Restrictive upper bound on ormolu
   hls-ormolu-plugin = doJailbreak super.hls-ormolu-plugin;
 
+  # Too strict bounds on base
+  # https://github.com/lspitzner/multistate/issues/9
+  multistate = doJailbreak super.multistate;
+  # https://github.com/lspitzner/butcher/issues/7
+  butcher = doJailbreak super.butcher;
+  # Fixes a bug triggered on GHC 9.0.1
+  text-short = self.text-short_0_1_4;
+
   # 2021-09-18: The following plugins don‘t work yet on ghc9.
   haskell-language-server = appendConfigureFlags [
     "-f-tactic"
···
 
     hls-fourmolu-plugin = null; # No upstream support, needs new fourmolu release
     hls-stylish-haskell-plugin = null; # No upstream support
-    hls-brittany-plugin = null; # No upstream support, needs new brittany release
+    hls-brittany-plugin = null; # Dependencies don't build with 9.0.1
   });
 }

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

···
   data-fix = doJailbreak super.data-fix;
   dec = doJailbreak super.dec;
   ed25519 = doJailbreak super.ed25519;
+  genvalidity = self.genvalidity_1_0_0_1;
+  genvalidity-property = self.genvalidity-property_1_0_0_0;
+  genvalidity-hspec = self.genvalidity-hspec_1_0_0_0;
   ghc-byteorder = doJailbreak super.ghc-byteorder;
   ghc-lib = self.ghc-lib_9_2_1_20211101;
   ghc-lib-parser = self.ghc-lib-parser_9_2_1_20211101;
   ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_2_0_1;
   hackage-security = doJailbreak super.hackage-security;
-  hashable = super.hashable_1_4_0_0;
+  hashable = super.hashable_1_4_0_1;
   hashable-time = doJailbreak super.hashable-time_0_3;
   hedgehog = doJailbreak super.hedgehog;
   HTTP = overrideCabal (drv: { postPatch = "sed -i -e 's,! Socket,!Socket,' Network/TCP.hs"; }) (doJailbreak super.HTTP);
···
   lifted-async = doJailbreak super.lifted-async;
   lukko = doJailbreak super.lukko;
   network = super.network_3_1_2_5;
+  ormolu = self.ormolu_0_4_0_0;
   OneTuple = super.OneTuple_0_3_1;
   parallel = doJailbreak super.parallel;
+  path = doJailbreak super.path_0_9_1;
   polyparse = overrideCabal (drv: { postPatch = "sed -i -e 's, <0.11, <0.12,' polyparse.cabal"; }) (doJailbreak super.polyparse);
   primitive = doJailbreak super.primitive;
-  quickcheck-instances = super.quickcheck-instances_0_3_26_1;
+  quickcheck-instances = super.quickcheck-instances_0_3_27;
   regex-posix = doJailbreak super.regex-posix;
   resolv = doJailbreak super.resolv;
   semialign = super.semialign_1_2_0_1;
···
     ] ++ drv.testFlags or [];
   }) (doJailbreak super.hpack);
 
+  validity = pkgs.lib.pipe super.validity_0_12_0_0 [
+    # head.hackage patch
+    (appendPatch (pkgs.fetchpatch {
+      url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/master/patches/validity-0.11.0.1.patch";
+      sha256 = "0qs6g1naqvcvklk78cadnpsfqnff1yflryi2ms6im203w75f2fsc";
+    }))
+    # head.hackage ignores test suite
+    dontCheck
+    # 0.12.0.0 disabled CPP in fetched file, breaks haddock
+    (appendConfigureFlag "--ghc-option=-XCPP")
+    dontHaddock
+  ];
+
   # lens >= 5.1 supports 9.2.1
   lens = super.lens_5_1;
 
···
   memory = appendPatch (pkgs.fetchpatch {
     url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/dfd024c9a336c752288ec35879017a43bd7e85a0/patches/memory-0.16.0.patch";
     sha256 = "1kjganx729a6xfgfnrb3z7q6mvnidl042zrsd9n5n5a3i76nl5nl";
-  }) super.memory_0_16_0;
+  }) (overrideCabal {
+    editedCabalFile = null;
+    revision = null;
+  } super.memory_0_16_0);
 
   # GHC 9.0.x doesn't like `import Spec (main)` in Main.hs
   # https://github.com/snoyberg/mono-traversable/issues/192

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

···
   - docopt
   - docrecords
   - doctest-discover-configurator
+  - doctest-parallel
   - doctest-prop
   - docusign-example
   - docvim
···
   - pandoc-filter-indent
   - pandoc-include
   - pandoc-lens
+  - pandoc-lua-marshal
   - pandoc-markdown-ghci-filter
   - pandoc-placetable
   - pandoc-pyplot

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

···
   - gi-webkit2webextension < 4.0.27
   - gi-wnck < 3.0.11
   # gi-cogl, gi-coglpango, gi-clutter, gi-json, gi-rsvg are only available for haskell-gi >= 0.26
+  # 1.2.1.0 needs opaleye >= 0.8 which stackage doesn't provide
+  - rel8 < 1.2.1.0
+  # 0.14.0.0 drops support for every GHC < 9.0.1
+  - brittany < 0.14
 
 extra-packages:
   - base16-bytestring < 1               # required for cabal-install etc.
···
   - ghc-lib-parser == 9.0.1.*           # 2021-11-05: Need one GHC 9.0.1 compatible version
   - ghc-lib-parser-ex == 9.0.*          # 2021-11-05: Need one GHC 9.0.1 compatible version
   - doctest == 0.18.*                   # 2021-11-19: closest to stackage version for GHC 9.*
+  - brick == 0.64.*                     # 2021-12-03: matterhorn depends on brick < 0.65
+  - path == 0.9.0                       # 2021-12-03: path version building with stackage genvalidity and GHC 9.0.1
+  - ormolu == 0.3.*                     # 2021-12-03: for HLS with GHC 9.0.1
 
 package-maintainers:
   abbradar:

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

···
-# Stackage LTS 18.17
+# Stackage LTS 18.18
 # This file is auto-generated by
 # maintainers/scripts/haskell/update-stackage.sh
 default-package-overrides:
···
   - appendmap ==0.1.5
   - apply-refact ==0.9.3.0
   - apportionment ==0.0.0.3
-  - approximate ==0.3.4
+  - approximate ==0.3.5
   - approximate-equality ==1.1.0.2
   - app-settings ==0.2.0.12
   - arbor-lru-cache ==0.1.1.1
···
   - autoexporter ==1.1.20
   - auto-update ==0.1.6
   - avro ==0.5.2.0
-  - aws-cloudfront-signed-cookies ==0.2.0.8
+  - aws-cloudfront-signed-cookies ==0.2.0.10
   - aws-xray-client ==0.1.0.1
   - aws-xray-client-wai ==0.1.0.1
   - backprop ==0.2.6.4
···
   - data-dword ==0.3.2
   - data-endian ==0.1.1
   - data-fix ==0.3.2
-  - data-forest ==0.1.0.8
+  - data-forest ==0.1.0.9
   - data-has ==0.4.0.0
   - data-hash ==0.2.0.1
   - data-interval ==2.1.1
···
   - doctemplates ==0.9
   - doctest ==0.17
   - doctest-discover ==0.2.0.0
-  - doctest-driver-gen ==0.3.0.4
+  - doctest-driver-gen ==0.3.0.5
   - doctest-exitcode-stdio ==0.0
   - doctest-extract ==0.1
   - doctest-lib ==0.1
···
   - error-or-utils ==0.1.1
   - errors ==2.3.0
   - errors-ext ==0.4.2
-  - ersatz ==0.4.9
+  - ersatz ==0.4.10
   - esqueleto ==3.5.3.0
   - essence-of-live-coding ==0.2.5
   - essence-of-live-coding-gloss ==0.2.5
···
   - fold-debounce ==0.2.0.9
   - fold-debounce-conduit ==0.2.0.6
   - foldl ==1.4.12
-  - folds ==0.7.6
+  - folds ==0.7.7
   - follow-file ==0.0.3
   - FontyFruity ==0.5.3.5
   - foreign-store ==0.2
···
   - fuzzcheck ==0.1.1
   - fuzzy ==0.1.0.1
   - fuzzy-dates ==0.1.1.2
-  - fuzzyset ==0.2.1
+  - fuzzyset ==0.2.2
   - fuzzy-time ==0.1.0.0
   - gauge ==0.2.5
   - gd ==3000.7.3
···
   - gi-gobject ==2.0.26
   - gi-graphene ==1.0.3
   - gi-gtk ==3.0.37
-  - gi-gtk-hs ==0.3.10
+  - gi-gtk-hs ==0.3.11
   - gi-harfbuzz ==0.0.4
   - ginger ==0.10.1.0
   - gingersnap ==0.3.1.0
···
   - Glob ==0.10.2
   - gloss ==1.13.2.1
   - gloss-rendering ==1.13.1.1
-  - GLURaw ==2.0.0.4
+  - GLURaw ==2.0.0.5
   - GLUT ==2.7.0.16
   - gluturtle ==0.0.58.1
   - gnuplot ==0.5.6.1
···
   - hxt-unicode ==9.0.2.4
   - hybrid-vectors ==0.2.2
   - hyper ==0.2.1.1
-  - hyperloglog ==0.4.4
+  - hyperloglog ==0.4.5
   - hyphenation ==0.8.2
   - iconv ==0.4.1.3
   - identicon ==0.2.2
···
   - inj ==1.0
   - inline-c ==0.9.1.5
   - inline-c-cpp ==0.4.0.3
-  - inline-r ==0.10.4
+  - inline-r ==0.10.5
   - inliterate ==0.1.0
   - input-parsers ==0.2.3.1
-  - insert-ordered-containers ==0.2.5
+  - insert-ordered-containers ==0.2.5.1
   - inspection-testing ==0.4.6.0
   - instance-control ==0.1.2.0
   - int-cast ==0.2.0.0
···
   - leapseconds-announced ==2017.1.0.1
   - learn-physics ==0.6.5
   - lens ==4.19.2
-  - lens-action ==0.2.5
-  - lens-aeson ==1.1.2
+  - lens-action ==0.2.6
+  - lens-aeson ==1.1.3
   - lens-csv ==0.1.1.0
   - lens-datetime ==0.3
   - lens-family ==2.0.0
···
   - locators ==0.3.0.3
   - loch-th ==0.2.2
   - lockfree-queue ==0.2.3.1
-  - log-domain ==0.13.1
+  - log-domain ==0.13.2
   - logfloat ==0.13.4
   - logging ==3.0.5
-  - logging-facade ==0.3.0
+  - logging-facade ==0.3.1
   - logging-facade-syslog ==1
   - logict ==0.7.1.0
   - logstash ==0.1.0.1
···
   - nonemptymap ==0.0.6.0
   - non-empty-sequence ==0.2.0.4
   - nonempty-vector ==0.2.1.0
-  - nonempty-zipper ==1.0.0.2
+  - nonempty-zipper ==1.0.0.3
   - non-negative ==0.1.2
   - not-gloss ==0.7.7.0
   - no-value ==1.0.0.0
···
   - open-browser ==0.2.1.0
   - openexr-write ==0.1.0.2
   - OpenGL ==3.0.3.0
-  - OpenGLRaw ==3.3.4.0
+  - OpenGLRaw ==3.3.4.1
   - openpgp-asciiarmor ==0.1.2
   - opensource ==0.1.1.0
   - openssl-streams ==1.2.3.0
···
   - primitive-addr ==0.1.0.2
   - primitive-extras ==0.10.1
   - primitive-unaligned ==0.1.1.1
-  - primitive-unlifted ==0.1.3.0
+  - primitive-unlifted ==0.1.3.1
   - prim-uniq ==0.2
   - print-console-colors ==0.1.0.0
   - probability ==0.2.7
···
   - pureMD5 ==2.1.4
   - purescript-bridge ==0.14.0.0
   - pushbullet-types ==0.4.1.0
-  - pusher-http-haskell ==2.1.0.6
+  - pusher-http-haskell ==2.1.0.7
   - pvar ==1.0.0.0
   - PyF ==0.9.0.3
   - qchas ==1.1.0.1
···
   - regex ==1.1.0.0
   - regex-applicative ==0.3.4
   - regex-applicative-text ==0.1.0.1
-  - regex-base ==0.94.0.1
+  - regex-base ==0.94.0.2
   - regex-compat ==0.95.2.1
   - regex-compat-tdfa ==0.95.1.4
   - regex-pcre ==0.95.0.0
···
   - storable-record ==0.0.5
   - storable-tuple ==0.0.3.3
   - storablevector ==0.2.13.1
-  - store ==0.7.12
+  - store ==0.7.14
   - store-core ==0.4.4.4
   - store-streaming ==0.2.0.3
   - stratosphere ==0.59.1
···
   - these-optics ==1.0.1.2
   - these-skinny ==0.7.4
   - th-expand-syns ==0.4.8.0
-  - th-extras ==0.0.0.4
+  - th-extras ==0.0.0.5
   - th-lift ==0.8.2
   - th-lift-instances ==0.1.18
   - th-nowq ==0.1.0.5
···
   - tree-diff ==0.2.1
   - tree-fun ==0.8.1.0
   - tree-view ==0.5.1
-  - trifecta ==2.1.1
+  - trifecta ==2.1.2
   - triplesec ==0.2.2.1
   - trivial-constraint ==0.7.0.0
   - tsv2csv ==0.1.0.2
···
   - tuples-homogenous-h98 ==0.1.1.0
   - tuple-sop ==0.3.1.0
   - tuple-th ==0.2.5
-  - turtle ==1.5.22
+  - turtle ==1.5.23
   - typecheck-plugin-nat-simple ==0.1.0.2
   - TypeCompose ==0.9.14
   - typed-process ==0.2.7.0
···
   - unexceptionalio-trans ==0.5.1
   - unicode ==0.0.1.1
   - unicode-collation ==0.1.3.1
-  - unicode-show ==0.1.0.5
+  - unicode-show ==0.1.1.0
   - unicode-transforms ==0.3.7.1
   - unification-fd ==0.11.1
   - union-angle ==0.1.0.1
···
   - utility-ht ==0.0.16
   - uuid ==1.3.15
   - uuid-types ==1.0.5
-  - validation ==1.1.1
+  - validation ==1.1.2
   - validation-selective ==0.1.0.1
   - validity ==0.11.0.1
   - validity-aeson ==0.2.0.4
···
   - wai-slack-middleware ==0.2.0
   - wai-websockets ==3.0.1.2
   - wakame ==0.1.0.0
-  - warp ==3.3.17
+  - warp ==3.3.18
   - warp-tls ==3.3.2
   - warp-tls-uid ==0.2.0.6
   - wave ==0.2.0
···
   - yaml ==0.11.7.0
   - yamlparse-applicative ==0.2.0.1
   - yesod ==1.6.1.2
-  - yesod-auth ==1.6.10.4
+  - yesod-auth ==1.6.10.5
   - yesod-auth-hashdb ==1.7.1.7
   - yesod-auth-oauth2 ==0.6.3.4
   - yesod-bin ==1.6.1
···
   - zip ==1.7.2
   - zip-archive ==0.4.1
   - zipper-extra ==0.1.3.2
-  - zippers ==0.3.1
+  - zippers ==0.3.2
   - zip-stream ==0.2.1.0
   - zlib ==0.6.2.3
   - zlib-bindings ==0.1.1.5

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

···
  - fields
  - filepath-crypto
  - filepath-io-access
- - filepather
  - filesystem-enumerator
  - find-clumpiness
  - findhttp
···
  - fortran-vars
  - foscam-directory
  - foscam-sort
- - fp-ieee
  - fplll
  - fpnla-examples
  - frame-markdown
···
  - pairing
  - panda
  - pandoc-japanese-filters
- - pandoc_2_16_1
+ - pandoc_2_16_2
  - papa
  - papa-base
  - papa-base-implement
···
  - phonetic-languages-simplified-generalized-examples-array
  - phonetic-languages-simplified-lists-examples
  - phooey
- - photoname
  - pianola
  - pier
  - ping
···
  - rose-trie
  - roshask
  - rosmsg-bin
- - rounded-hw
  - roundtrip-xml
  - route-generator
  - route-planning

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

···
     ({ mkDerivation, base, libGL, libGLU, OpenGLRaw, transformers }:
      mkDerivation {
        pname = "GLURaw";
-       version = "2.0.0.4";
-       sha256 = "1i2xi35n5z0d372px9mh6cyhgg1m0cfaiy3fnspkf6kbn9fgsqxq";
-       libraryHaskellDepends = [ base OpenGLRaw transformers ];
-       librarySystemDepends = [ libGL libGLU ];
-       description = "A raw binding for the OpenGL graphics system";
-       license = lib.licenses.bsd3;
-     }) {inherit (pkgs) libGL; inherit (pkgs) libGLU;};
-
-  "GLURaw_2_0_0_5" = callPackage
-    ({ mkDerivation, base, libGL, libGLU, OpenGLRaw, transformers }:
-     mkDerivation {
-       pname = "GLURaw";
        version = "2.0.0.5";
        sha256 = "1b3rnva77k9naw5bl573bqgmsq7n9i8rrrvfvhbjcndqgmzhkini";
        libraryHaskellDepends = [ base OpenGLRaw transformers ];
        librarySystemDepends = [ libGL libGLU ];
        description = "A raw binding for the OpenGL graphics system";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) libGL; inherit (pkgs) libGLU;};
 
   "GLUT" = callPackage
···
        pname = "Glob";
        version = "0.10.2";
        sha256 = "1h3kh46qds4nqvixm4myy1kb5slg53f44hfn8aymrlr7hjn75xka";
-       revision = "1";
-       editedCabalFile = "10iqhx37v6hsw4wj174j3kcbpxm1diznys3hnss9f0vqr2dramgc";
+       revision = "2";
+       editedCabalFile = "175v5r0gzlln5y70dgxaq5xw4ilrf3xhgqr3hrzsilqnb32kfi9a";
        libraryHaskellDepends = [
          base containers directory dlist filepath transformers
          transformers-compat
···
        license = "LGPL";
      }) {};
 
+  "HaXml_1_25_8" = callPackage
+    ({ mkDerivation, base, bytestring, containers, directory, filepath
+     , polyparse, pretty, random
+     }:
+     mkDerivation {
+       pname = "HaXml";
+       version = "1.25.8";
+       sha256 = "1n65s75l4manb65msh9fz97dzqf9554x58bqdhyylgsgk84mfg80";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring containers filepath polyparse pretty random
+       ];
+       executableHaskellDepends = [ base directory polyparse pretty ];
+       description = "Utilities for manipulating XML documents";
+       license = lib.licenses.lgpl21Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "Hach" = callPackage
     ({ mkDerivation, base, containers, network, old-locale, text, time
      , vty, vty-ui
···
        pname = "HsOpenSSL";
        version = "0.11.7.2";
        sha256 = "0ysdfl8ck3nzhx597fa13dqf31jq5gzwajlak6r91jajks9w0dl5";
+       revision = "1";
+       editedCabalFile = "1lccw8x48xxmw1cpd260fdr9mxqr39f4b623i78027l0m93dw38b";
        setupHaskellDepends = [ base Cabal ];
        libraryHaskellDepends = [ base bytestring network time ];
        librarySystemDepends = [ openssl ];
···
        pname = "MissingH";
        version = "1.4.3.0";
        sha256 = "196cniya5wzcv2d777nr0f7hinclpals4ia1mkzzv35870pqr6lw";
-       revision = "1";
-       editedCabalFile = "0f8x0vpwcbcvy3b421pahx1ff6l3lfaqvvfkyks1vllcr4p8ky9j";
+       revision = "2";
+       editedCabalFile = "0p5md995w0nh2m89v3jsb1bvhfkrnp2s14smjbnh3g0pbq3fgfzg";
        libraryHaskellDepends = [
          array base containers directory filepath hslogger mtl network
          network-bsd old-locale old-time parsec process random regex-compat
···
      }:
      mkDerivation {
        pname = "NaCl";
-       version = "0.0.4.0";
-       sha256 = "13wjrki7d7a7zk67np00in5n3gkpmgw682hib09fmncnnisrwd9m";
+       version = "0.0.5.0";
+       sha256 = "1q6wr6a3q0w594z8lrldmvzc1fs4krds8nbady8ymz2vll71q1kz";
        libraryHaskellDepends = [
          base bytestring libsodium memory safe-exceptions
        ];
···
      }:
      mkDerivation {
        pname = "OpenGLRaw";
-       version = "3.3.4.0";
-       sha256 = "0gmsmysqzpm13qnyq4vvqxm4dzw25nayfd9wi5x645pympm6jqbm";
-       libraryHaskellDepends = [
-         base bytestring containers fixed half text transformers
-       ];
-       librarySystemDepends = [ libGL ];
-       description = "A raw binding for the OpenGL graphics system";
-       license = lib.licenses.bsd3;
-     }) {inherit (pkgs) libGL;};
-
-  "OpenGLRaw_3_3_4_1" = callPackage
-    ({ mkDerivation, base, bytestring, containers, fixed, half, libGL
-     , text, transformers
-     }:
-     mkDerivation {
-       pname = "OpenGLRaw";
        version = "3.3.4.1";
        sha256 = "07nk0rgm6jcxz6yshwhv5lj5frs6371w3hdjxwa4biws2kmbs6hj";
        libraryHaskellDepends = [
···
        librarySystemDepends = [ libGL ];
        description = "A raw binding for the OpenGL graphics system";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) libGL;};
 
   "OpenGLRaw21" = callPackage
···
        pname = "STMonadTrans";
        version = "0.4.6";
        sha256 = "0rvhh0hhwz601ibpzisry7xf3j61r5sxfgp47imaa37i5bvrlynb";
+       revision = "1";
+       editedCabalFile = "04svg3fwiir2zd5da44pklvw51bs2qm8pqmsnicyav0g0wvhbxbc";
        libraryHaskellDepends = [ array base mtl ];
        testHaskellDepends = [
          array base tasty tasty-hunit tasty-quickcheck transformers
···
     ({ mkDerivation, base, bytestring, transformers, vector, vulkan }:
      mkDerivation {
        pname = "VulkanMemoryAllocator";
-       version = "0.7.4";
-       sha256 = "0rzvishkjp4vjwc64a12knj1kr7c793ncpgf9x54l2xj6q7a9mrj";
+       version = "0.7.5";
+       sha256 = "0wcq09q5jhvigfp8vshgs3yc170g7c39jz2m6jk2j6v0nji2lp40";
        libraryHaskellDepends = [
          base bytestring transformers vector vulkan
        ];
···
        platforms = lib.platforms.none;
      }) {};
 
-  "Win32_2_13_1_0" = callPackage
+  "Win32_2_13_2_0" = callPackage
     ({ mkDerivation }:
      mkDerivation {
        pname = "Win32";
-       version = "2.13.1.0";
-       sha256 = "1a86hmkba4gd1qqfanl06vi2r77ip53l3dcbgvjp7wlp6rjampvc";
+       version = "2.13.2.0";
+       sha256 = "1gmhqb0v3ds7csrmzw211jqjjp955akgp7ykngwnpqb6kpbvpcf4";
        description = "A binding to Windows Win32 API";
        license = lib.licenses.bsd3;
        platforms = lib.platforms.none;
···
        libraryPkgconfigDepends = [ libXft ];
        description = "Bindings to the Xft, X Free Type interface library, and some Xrender parts";
        license = "LGPL";
+     }) {inherit (pkgs.xorg) libXft;};
+
+  "X11-xft_0_3_3" = callPackage
+    ({ mkDerivation, base, libXft, utf8-string, X11 }:
+     mkDerivation {
+       pname = "X11-xft";
+       version = "0.3.3";
+       sha256 = "08m6rm27d33axh695dhqwirkzhcdn32dimb5sqkqnwkds8pagjc8";
+       libraryHaskellDepends = [ base utf8-string X11 ];
+       libraryPkgconfigDepends = [ libXft ];
+       description = "Bindings to the Xft and some Xrender parts";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs.xorg) libXft;};
 
   "X11-xshape" = callPackage
···
      }) {};
 
   "acc" = callPackage
-    ({ mkDerivation, base, criterion, deepseq, QuickCheck
+    ({ mkDerivation, base, deepseq, gauge, QuickCheck
      , quickcheck-instances, rerebase, semigroupoids, tasty, tasty-hunit
      , tasty-quickcheck
      }:
      mkDerivation {
        pname = "acc";
-       version = "0.1.3";
-       sha256 = "12mzmxmdishmcym3ci8hihp97n17jl5hisnqg6y8yvqzfp7k3cd7";
+       version = "0.2.0.1";
+       sha256 = "03wk2pnh3scjf5102w882hg6hsczj9ihj8pb9g3928na2zk1jw1v";
        libraryHaskellDepends = [ base deepseq semigroupoids ];
        testHaskellDepends = [
          QuickCheck quickcheck-instances rerebase tasty tasty-hunit
          tasty-quickcheck
        ];
-       benchmarkHaskellDepends = [ criterion rerebase ];
+       benchmarkHaskellDepends = [ gauge rerebase ];
        description = "Sequence optimized for monoidal construction and folding";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "advent-of-code-api";
-       version = "0.2.8.0";
-       sha256 = "1g1wybpir0053pjav8czccnva38jr35gnii1as0lbyinc1k7vlhq";
+       version = "0.2.8.1";
+       sha256 = "17s80883jq75i129b1976qbvr56ml0bsadhfnx2qybbh7b55gxfh";
        libraryHaskellDepends = [
          aeson base bytestring containers deepseq directory filepath
          finite-typelits http-api-data http-client http-client-tls
···
        pname = "aeson";
        version = "1.5.6.0";
        sha256 = "1s5z4bgb5150h6a4cjf5vh8dmyrn6ilh29gh05999v6jwd5w6q83";
-       revision = "3";
-       editedCabalFile = "08xh5gbvms73d6jnffhm8hjniw7q79yxf7zk6p3cxv21a3bkbma5";
+       revision = "4";
+       editedCabalFile = "1sgn62rdcfxcc9axiaixw2g2zr5zy4prm9zcpd6fngmvjfqagqln";
        libraryHaskellDepends = [
          attoparsec base base-compat-batteries bytestring containers
          data-fix deepseq dlist ghc-prim hashable primitive scientific
···
        pname = "aeson-better-errors";
        version = "0.9.1.0";
        sha256 = "09vkyrhwak3bmpfsqcd2az8hfqqkxyhg468hv5avgisy0nzh3w38";
+       revision = "1";
+       editedCabalFile = "1kwhnabcfwbm9r116y19pgwsds5vd0g62sp8r6n43q5crdnc7ly7";
        libraryHaskellDepends = [
          aeson base bytestring dlist mtl scientific text transformers
          transformers-compat unordered-containers vector void
···
        pname = "aeson-compat";
        version = "0.3.10";
        sha256 = "0ia3qfdpbrzhwwg4ywpdwca0z1m85k081pcz6jh1sx8qjsvcr71w";
+       revision = "1";
+       editedCabalFile = "1k4bnmq76ihk0vlx9nhxsyyawhnbca9dxj1ivxs3k4aip40bjjq8";
        libraryHaskellDepends = [
          aeson attoparsec attoparsec-iso8601 base base-compat bytestring
          containers exceptions hashable scientific tagged text time
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "align-affine" = callPackage
+    ({ mkDerivation, base, containers, transformers, vector }:
+     mkDerivation {
+       pname = "align-affine";
+       version = "0.1.0.0";
+       sha256 = "01y9svlisci6yjb7xb424hmram33ri81v5a503gfvlg0g9p00237";
+       libraryHaskellDepends = [ base containers transformers vector ];
+       description = "Sequence alignment with an affine gap penalty model";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "align-audio" = callPackage
     ({ mkDerivation, base, comfort-array, comfort-fftw, containers
      , netlib-ffi, numeric-prelude, optparse-applicative, shell-utility
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "ansi-terminal_0_11_1" = callPackage
+    ({ mkDerivation, base, colour }:
+     mkDerivation {
+       pname = "ansi-terminal";
+       version = "0.11.1";
+       sha256 = "0avjvd2492y2rqvi63a633rqsrmi1aq6dv18q5cp0x4kch3dlm5f";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base colour ];
+       description = "Simple ANSI terminal support, with Windows compatibility";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ansi-terminal-game" = callPackage
     ({ mkDerivation, ansi-terminal, array, base, bytestring, cereal
-     , clock, exceptions, hspec, linebreak, mintty, mtl, QuickCheck
-     , random, split, terminal-size, timers-tick, unidecode
+     , clock, containers, exceptions, hspec, linebreak, mintty, mtl
+     , QuickCheck, random, split, terminal-size, timers-tick, unidecode
      }:
      mkDerivation {
        pname = "ansi-terminal-game";
-       version = "1.7.0.0";
-       sha256 = "0cb2n8vp4wbqchdi9136zgkgdl8ksm538ysq6j30ciy53k5phirv";
+       version = "1.8.0.0";
+       sha256 = "09wd7gh8zm90wq080fsah0qjbr9x3vrh89am7yf0d84a0akqw65m";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         ansi-terminal array base bytestring cereal clock exceptions
-         linebreak mintty mtl QuickCheck random split terminal-size
-         timers-tick unidecode
+         ansi-terminal array base bytestring cereal clock containers
+         exceptions linebreak mintty mtl QuickCheck random split
+         terminal-size timers-tick unidecode
        ];
        testHaskellDepends = [
-         ansi-terminal array base bytestring cereal clock exceptions hspec
-         linebreak mintty mtl QuickCheck random split terminal-size
-         timers-tick unidecode
+         ansi-terminal array base bytestring cereal clock containers
+         exceptions hspec linebreak mintty mtl QuickCheck random split
+         terminal-size timers-tick unidecode
        ];
        description = "sdl-like functions for terminal applications, based on ansi-terminal";
        license = lib.licenses.gpl3Only;
···
      }:
      mkDerivation {
        pname = "approximate";
-       version = "0.3.4";
-       sha256 = "06akbrmy66nkgnnk3x87jss9qgv5y9m638rvxy57mfzibf925kbd";
-       libraryHaskellDepends = [
-         base binary bytes cereal comonad deepseq ghc-prim hashable lens
-         log-domain pointed safecopy semigroupoids semigroups vector
-       ];
-       description = "Approximate discrete values and numbers";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "approximate_0_3_5" = callPackage
-    ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq
-     , ghc-prim, hashable, lens, log-domain, pointed, safecopy
-     , semigroupoids, semigroups, vector
-     }:
-     mkDerivation {
-       pname = "approximate";
        version = "0.3.5";
        sha256 = "1f168ac9xryrv50k7gvh89xv0mj6c42cxw7pj01pqcbppbs0rm3g";
        libraryHaskellDepends = [
···
        ];
        description = "Approximate discrete values and numbers";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "approximate-equality" = callPackage
···
        pname = "attoparsec";
        version = "0.14.2";
        sha256 = "157lc8s6a8jw4s8w1a1rylxlggsa6lyq239na8ix3czmi79g3jwz";
-       revision = "1";
-       editedCabalFile = "1lj36f2w5ja2qgwkdjzsvsr89k8932v7hm87xdmh1nj8xlb8wslb";
+       revision = "2";
+       editedCabalFile = "10p0bic82q0yhhyaanj1rdwmms1wql11dnni5mhpk45dv3f5icvj";
        libraryHaskellDepends = [
          array base bytestring containers deepseq ghc-prim scientific text
          transformers
···
        pname = "attoparsec-iso8601";
        version = "1.0.2.0";
        sha256 = "162gc101mwhmjbfhhv1wm3yvk2h4ra34wpw5x87735cfqxvjv582";
-       revision = "2";
-       editedCabalFile = "18557xy5gvkhj0sb35wwxmhqirkiqrkwm0y0pqygsr0aimccs5zm";
+       revision = "3";
+       editedCabalFile = "1kjwc15lwn9axsx4nkl0ar1afimvhz0wsfir2wrxq17jsj9k0cjj";
        libraryHaskellDepends = [
          attoparsec base base-compat-batteries text time time-compat
        ];
···
        maintainers = with lib.maintainers; [ expipiplus1 ];
      }) {};
 
+  "autodocodec" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, doctest
+     , hashable, mtl, scientific, text, time, unordered-containers
+     , validity, validity-scientific, vector
+     }:
+     mkDerivation {
+       pname = "autodocodec";
+       version = "0.0.0.0";
+       sha256 = "0b8iwzmyf8l80i6p84yd4xhbxipbz10dn2428kmhyzlywjci6pps";
+       libraryHaskellDepends = [
+         aeson base bytestring containers hashable mtl scientific text time
+         unordered-containers validity validity-scientific vector
+       ];
+       testHaskellDepends = [ base doctest ];
+       description = "Self-documenting encoder and decoder";
+       license = lib.licenses.mit;
+     }) {};
+
+  "autodocodec-openapi3" = callPackage
+    ({ mkDerivation, aeson, autodocodec, base
+     , insert-ordered-containers, openapi3, scientific, text
+     }:
+     mkDerivation {
+       pname = "autodocodec-openapi3";
+       version = "0.0.0.0";
+       sha256 = "0fj4acmzrbv94zdm6h1c8r7z312gh6cmjj4gy16ykqhks965h9v9";
+       libraryHaskellDepends = [
+         aeson autodocodec base insert-ordered-containers openapi3
+         scientific text
+       ];
+       description = "Autodocodec interpreters for openapi3";
+       license = lib.licenses.mit;
+     }) {};
+
+  "autodocodec-schema" = callPackage
+    ({ mkDerivation, aeson, autodocodec, base, containers, mtl, text
+     , unordered-containers, validity, validity-aeson
+     , validity-containers, validity-text
+     }:
+     mkDerivation {
+       pname = "autodocodec-schema";
+       version = "0.0.0.0";
+       sha256 = "0r5mhzfcyl0vzxzih9ckq21nly1i3y0ch2yj49idvw4df2wl5q8p";
+       libraryHaskellDepends = [
+         aeson autodocodec base containers mtl text unordered-containers
+         validity validity-aeson validity-containers validity-text
+       ];
+       description = "Autodocodec interpreters for JSON Schema";
+       license = lib.licenses.mit;
+     }) {};
+
+  "autodocodec-swagger2" = callPackage
+    ({ mkDerivation, aeson, autodocodec, base
+     , insert-ordered-containers, scientific, swagger2, text
+     }:
+     mkDerivation {
+       pname = "autodocodec-swagger2";
+       version = "0.0.0.0";
+       sha256 = "1z7ap55y0wzrlkfa2z420flb5ipb5nmwfcgmw8ld8arp1p1dq80m";
+       libraryHaskellDepends = [
+         aeson autodocodec base insert-ordered-containers scientific
+         swagger2 text
+       ];
+       description = "Autodocodec interpreters for swagger2";
+       license = lib.licenses.mit;
+     }) {};
+
+  "autodocodec-yaml" = callPackage
+    ({ mkDerivation, autodocodec, autodocodec-schema, base, bytestring
+     , containers, path, path-io, safe-coloured-text, scientific, text
+     , unordered-containers, vector, yaml
+     }:
+     mkDerivation {
+       pname = "autodocodec-yaml";
+       version = "0.0.0.0";
+       sha256 = "19ryi7kqxazng2iy5bdf7h8r2bvdydbb1f2fbxf5gzf1algb421z";
+       libraryHaskellDepends = [
+         autodocodec autodocodec-schema base bytestring containers path
+         path-io safe-coloured-text scientific text unordered-containers
+         vector yaml
+       ];
+       description = "Autodocodec interpreters for yaml";
+       license = lib.licenses.mit;
+     }) {};
+
   "autoexporter" = callPackage
     ({ mkDerivation, base, Cabal, directory, filepath }:
      mkDerivation {
···
     ({ mkDerivation, aeson, aeson-pretty, asn1-encoding, asn1-types
      , base, base64-bytestring, bytestring, cookie, cryptonite, hedgehog
      , lens, lens-aeson, neat-interpolation, optparse-applicative, pem
-     , text, time, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "aws-cloudfront-signed-cookies";
-       version = "0.2.0.8";
-       sha256 = "07640asv46gvqqzv8d050x19b2j6wjasm98gpy6047aqg1a6f3ac";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson aeson-pretty asn1-encoding asn1-types base base64-bytestring
-         bytestring cookie cryptonite lens lens-aeson optparse-applicative
-         pem text time unordered-containers vector
-       ];
-       executableHaskellDepends = [ base ];
-       testHaskellDepends = [ base hedgehog neat-interpolation ];
-       description = "Generate signed cookies for AWS CloudFront";
-       license = lib.licenses.mit;
-     }) {};
-
-  "aws-cloudfront-signed-cookies_0_2_0_10" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, asn1-encoding, asn1-types
-     , base, base64-bytestring, bytestring, cookie, cryptonite, hedgehog
-     , lens, lens-aeson, neat-interpolation, optparse-applicative, pem
      , text, time, vector
      }:
      mkDerivation {
···
        testHaskellDepends = [ base hedgehog neat-interpolation ];
        description = "Generate signed cookies for AWS CloudFront";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "aws-cloudfront-signer" = callPackage
···
        pname = "base-compat-batteries";
        version = "0.12.1";
        sha256 = "12w3bpsz3xykhibc8wkhiii9nav7yxhlv424cy1b9v9ihbfkr3zr";
-       revision = "1";
-       editedCabalFile = "19w7sy7x3ikxx06brx33a82sqd5icx6rqikhin91k750d02v5p48";
+       revision = "2";
+       editedCabalFile = "0p522rvawkpyr12jwa0cikpqihvq2xd99nr95l0s3zdjf1srv0gf";
        libraryHaskellDepends = [ base base-compat ghc-prim OneTuple ];
        testHaskellDepends = [ base hspec QuickCheck ];
        testToolDepends = [ hspec-discover ];
···
        pname = "base64-bytestring-type";
        version = "1.0.1";
        sha256 = "03kq4rjj6by02rf3hg815jfdqpdk0xygm5f46r2pn8mb99yd01zn";
-       revision = "10";
-       editedCabalFile = "0d9nd34ga5xhgkvbysqzyn03w3zi42hgfjk6cza2ymiqxrl2yk9m";
+       revision = "11";
+       editedCabalFile = "0aj0av37xgxz6pyzwc8d3qr915a2d2pwz1g21ad8nd5ms4zpgz7l";
        libraryHaskellDepends = [
          aeson base base-compat base64-bytestring binary bytestring cereal
          deepseq hashable http-api-data QuickCheck serialise text
···
        pname = "beam-core";
        version = "0.9.1.0";
        sha256 = "1rw3db9qmf08wi5gcd0cbsz5cpndf8cwkbzkh74gbwwpcpa7lg39";
+       revision = "1";
+       editedCabalFile = "1skynr0yg6ig6p9wic3dkbz88qrpnirljkb429yshwbzns55gimh";
        libraryHaskellDepends = [
          aeson base bytestring containers dlist free ghc-prim hashable
          microlens mtl network-uri scientific tagged text time vector
···
     ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring
      , bytestring-lexing, case-insensitive, clustering, conduit
      , conduit-extra, containers, criterion, data-default-class
-     , data-ordlist, double-conversion, hexpat, HsHTSLib, http-conduit
-     , IntervalMap, math-functions, matrices, microlens, microlens-th
-     , mtl, parallel, primitive, random, split, statistics, tasty
-     , tasty-golden, tasty-hunit, text, transformers
+     , data-ordlist, deepseq, double-conversion, hexpat, HsHTSLib
+     , http-conduit, IntervalMap, math-functions, matrices, microlens
+     , microlens-th, mtl, parallel, primitive, random, split, statistics
+     , tasty, tasty-golden, tasty-hunit, text, transformers
      , unordered-containers, vector, vector-algorithms, word8
      }:
      mkDerivation {
        pname = "bioinformatics-toolkit";
-       version = "0.9.5";
-       sha256 = "03nra5ngirlkfm9xhndiwsl51ixcgp5rf7xfwgvw0bfvzddrc6i9";
+       version = "0.10.0";
+       sha256 = "07fzdwl5cknkjwzwf8ixhapx0c5wyxgimrx4pxipj5gm30ryl62z";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson aeson-pretty attoparsec base bytestring bytestring-lexing
          case-insensitive clustering conduit conduit-extra containers
-         data-default-class data-ordlist double-conversion hexpat HsHTSLib
-         http-conduit IntervalMap math-functions matrices microlens
+         data-default-class data-ordlist deepseq double-conversion hexpat
+         HsHTSLib http-conduit IntervalMap math-functions matrices microlens
          microlens-th mtl parallel primitive split statistics text
          transformers unordered-containers vector vector-algorithms word8
        ];
···
          unordered-containers vector
        ];
        benchmarkHaskellDepends = [
-         base bytestring clustering conduit criterion data-default-class mtl
-         random
+         base bytestring clustering conduit conduit-extra criterion
+         data-default-class mtl random
        ];
        description = "A collection of bioinformatics tools";
        license = lib.licenses.mit;
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "brick_0_65" = callPackage
+    ({ mkDerivation, base, bytestring, config-ini, containers
+     , contravariant, data-clist, deepseq, directory, dlist, exceptions
+     , filepath, microlens, microlens-mtl, microlens-th, QuickCheck, stm
+     , template-haskell, text, text-zipper, transformers, unix, vector
+     , vty, word-wrap
+     }:
+     mkDerivation {
+       pname = "brick";
+       version = "0.65";
+       sha256 = "1yk9r5igg5p7aixlpls167z2fajq3vp0xxqcjw4cg168g20lnhbs";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring config-ini containers contravariant data-clist
+         deepseq directory dlist exceptions filepath microlens microlens-mtl
+         microlens-th stm template-haskell text text-zipper transformers
+         unix vector vty word-wrap
+       ];
+       testHaskellDepends = [
+         base containers microlens QuickCheck vector
+       ];
+       description = "A declarative terminal user interface library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "brick-dropdownmenu" = callPackage
     ({ mkDerivation, base, brick, containers, microlens, microlens-ghc
      , microlens-th, pointedlist, vector, vty
···
        license = lib.licenses.agpl3Only;
      }) {};
 
+  "brittany_0_14_0_0" = callPackage
+    ({ mkDerivation, aeson, base, butcher, bytestring, cmdargs
+     , containers, czipwith, data-tree-print, deepseq, directory, extra
+     , filepath, ghc, ghc-boot, ghc-boot-th, ghc-exactprint, hspec
+     , monad-memo, mtl, multistate, pretty, random, safe, semigroups
+     , strict, syb, text, transformers, uniplate, yaml
+     }:
+     mkDerivation {
+       pname = "brittany";
+       version = "0.14.0.0";
+       sha256 = "10xphm9szdflwqkfbhz9pngiq0sn5jmysa015dhqc3prhz4qha2b";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base butcher bytestring cmdargs containers czipwith
+         data-tree-print deepseq directory extra filepath ghc ghc-boot
+         ghc-boot-th ghc-exactprint monad-memo mtl multistate pretty random
+         safe semigroups strict syb text transformers uniplate yaml
+       ];
+       executableHaskellDepends = [
+         aeson base butcher bytestring cmdargs containers czipwith
+         data-tree-print deepseq directory extra filepath ghc ghc-boot
+         ghc-boot-th ghc-exactprint monad-memo mtl multistate pretty random
+         safe semigroups strict syb text transformers uniplate yaml
+       ];
+       testHaskellDepends = [
+         aeson base butcher bytestring cmdargs containers czipwith
+         data-tree-print deepseq directory extra filepath ghc ghc-boot
+         ghc-boot-th ghc-exactprint hspec monad-memo mtl multistate pretty
+         random safe semigroups strict syb text transformers uniplate yaml
+       ];
+       description = "Haskell source code formatter";
+       license = lib.licenses.agpl3Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "broadcast-chan" = callPackage
     ({ mkDerivation, async, base, criterion, deepseq, stm, transformers
      , unliftio-core
···
        broken = true;
      }) {};
 
+  "bugsnag-haskell_0_0_4_2" = callPackage
+    ({ mkDerivation, aeson, aeson-qq, base, bytestring
+     , case-insensitive, containers, doctest, Glob, hspec, http-client
+     , http-client-tls, http-conduit, http-types, iproute, network
+     , parsec, template-haskell, text, th-lift-instances, time
+     , ua-parser, unliftio, wai, yaml
+     }:
+     mkDerivation {
+       pname = "bugsnag-haskell";
+       version = "0.0.4.2";
+       sha256 = "0q7my31jq0rgpj08zxylvzmml5mms9f1hiavcfy4rpqkjqv8kwir";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring case-insensitive containers Glob http-client
+         http-client-tls http-conduit http-types iproute network parsec
+         template-haskell text th-lift-instances time ua-parser wai
+       ];
+       testHaskellDepends = [
+         aeson aeson-qq base doctest hspec text time unliftio yaml
+       ];
+       description = "Bugsnag error reporter for Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "bugsnag-hs" = callPackage
     ({ mkDerivation, aeson, base, bytestring, hedgehog, http-client
      , text, time, unordered-containers
···
        testHaskellDepends = [ base containers hspec QuickCheck text ];
        description = "Parse and render URI templates";
        license = lib.licenses.isc;
+     }) {};
+
+  "burrito_1_2_0_4" = callPackage
+    ({ mkDerivation, base, bytestring, containers, hspec, parsec
+     , QuickCheck, template-haskell, text, transformers
+     }:
+     mkDerivation {
+       pname = "burrito";
+       version = "1.2.0.4";
+       sha256 = "1i08p5g6yivmkgbhxv48amfdw523agjwyd02pbk5lbzyssc2sp7d";
+       libraryHaskellDepends = [
+         base bytestring containers parsec template-haskell text
+         transformers
+       ];
+       testHaskellDepends = [ base containers hspec QuickCheck text ];
+       description = "Parse and render URI templates";
+       license = lib.licenses.isc;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "burst-detection" = callPackage
···
 
   "bytebuild" = callPackage
     ({ mkDerivation, base, byteslice, bytestring, gauge
-     , integer-logarithms, natural-arithmetic, primitive
-     , primitive-offset, primitive-unlifted, QuickCheck
+     , haskell-src-meta, integer-logarithms, natural-arithmetic
+     , primitive, primitive-offset, primitive-unlifted, QuickCheck
      , quickcheck-classes, quickcheck-instances, run-st, tasty
-     , tasty-hunit, tasty-quickcheck, text, text-short, vector
-     , wide-word
+     , tasty-hunit, tasty-quickcheck, template-haskell, text, text-short
+     , vector, wide-word
      }:
      mkDerivation {
        pname = "bytebuild";
-       version = "0.3.8.0";
-       sha256 = "19gg4qjlj595j8zd0n6cz2kgz70g8z6w666c6wlf5lj32j8p6yh5";
+       version = "0.3.9.0";
+       sha256 = "07ln4qva3qb81w8rsdfxg4i1m659lf97680abm78y1qb41c8ampz";
        libraryHaskellDepends = [
-         base byteslice bytestring integer-logarithms natural-arithmetic
-         primitive primitive-offset primitive-unlifted run-st text-short
-         wide-word
+         base byteslice bytestring haskell-src-meta integer-logarithms
+         natural-arithmetic primitive primitive-offset primitive-unlifted
+         run-st template-haskell text-short wide-word
        ];
        testHaskellDepends = [
          base byteslice bytestring natural-arithmetic primitive
          primitive-unlifted QuickCheck quickcheck-classes
-         quickcheck-instances tasty tasty-hunit tasty-quickcheck text vector
-         wide-word
+         quickcheck-instances tasty tasty-hunit tasty-quickcheck text
+         text-short vector wide-word
        ];
        benchmarkHaskellDepends = [
          base byteslice gauge natural-arithmetic primitive text-short
···
        license = lib.licenses.mit;
      }) {};
 
+  "bytestring-strict-builder_0_4_5_5" = callPackage
+    ({ mkDerivation, base, bytestring, criterion, QuickCheck
+     , quickcheck-instances, rerebase, tasty, tasty-hunit
+     , tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "bytestring-strict-builder";
+       version = "0.4.5.5";
+       sha256 = "1knin3mfj2qfh7xhvbrpakd037y7qqic24f1w93v8p6y5g7bc3zp";
+       libraryHaskellDepends = [ base bytestring ];
+       testHaskellDepends = [
+         QuickCheck quickcheck-instances rerebase tasty tasty-hunit
+         tasty-quickcheck
+       ];
+       benchmarkHaskellDepends = [ criterion rerebase ];
+       description = "An efficient strict bytestring builder";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "bytestring-substring" = callPackage
     ({ mkDerivation, base, bytestring, pipes, primitive }:
      mkDerivation {
···
      }) {};
 
   "bytestring-trie" = callPackage
-    ({ mkDerivation, base, binary, bytestring }:
+    ({ mkDerivation, base, binary, bytestring, QuickCheck, smallcheck
+     , tasty, tasty-hunit, tasty-quickcheck, tasty-smallcheck
+     }:
      mkDerivation {
        pname = "bytestring-trie";
-       version = "0.2.5.3";
-       sha256 = "1751g4bgkvyjh46nzzy4m8cj71ml7znchqaicyz74n93j1bqpj89";
+       version = "0.2.6";
+       sha256 = "00wz54cmn2wa8vvhvhmdxj16nj0blhhyabp54ddahicnnizi2hzf";
        libraryHaskellDepends = [ base binary bytestring ];
+       testHaskellDepends = [
+         base binary bytestring QuickCheck smallcheck tasty tasty-hunit
+         tasty-quickcheck tasty-smallcheck
+       ];
        description = "An efficient finite map from (byte)strings to values";
        license = lib.licenses.bsd3;
      }) {};
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "cabal-flatpak_0_1_0_3" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, cabal-plan
+     , containers, cryptohash-sha256, http-client, http-client-tls
+     , http-types, optparse-applicative, pathtype, shell-utility, tar
+     , text, utility-ht, zlib
+     }:
+     mkDerivation {
+       pname = "cabal-flatpak";
+       version = "0.1.0.3";
+       sha256 = "1k0fzhyvlcq1l09fnf3f3wig4g9l61wsm1dmsjd3nwsgh52xb37v";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         aeson aeson-pretty base bytestring cabal-plan containers
+         cryptohash-sha256 http-client http-client-tls http-types
+         optparse-applicative pathtype shell-utility tar text utility-ht
+         zlib
+       ];
+       description = "Generate a FlatPak manifest from a Cabal package description";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "cabal-fmt" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, directory
      , filepath, mtl, optparse-applicative, parsec, pretty, process
···
        pname = "cabal-install";
        version = "3.6.2.0";
        sha256 = "0dihpm4h3xh13vnpvwflnb7v614qdvljycc6ffg5cvhwbwfrxyfw";
+       revision = "1";
+       editedCabalFile = "0891zma6ci26ndbb98mahps0dxy7zccj3mqa9d194j3d305hs9av";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "call-alloy";
        version = "0.2.2.0";
        sha256 = "09xy823lxmp4siqxbv8f6v192a9bs0vmq36293cbiv7g7w65bnvi";
-       revision = "1";
-       editedCabalFile = "0fpgqjb8njrw43pz1rf9nck6v0n0pb2drwx5gzhvlgjpppygwpyj";
+       revision = "2";
+       editedCabalFile = "0c90z46ks7sybx899ama5dsvbxvm62a2cclwqav1rak1vjygglk2";
        libraryHaskellDepends = [
          base bytestring containers directory file-embed filepath hashable
          mtl process split trifecta unix
···
      }:
      mkDerivation {
        pname = "capnp";
-       version = "0.14.0.0";
-       sha256 = "15v0s597wq0ipvikd727fzcqg5r6685lvr8y1x93q5mdl975gi8m";
-       revision = "1";
-       editedCabalFile = "1s57x426qkn54g8zj8rbn77qg849mx5ps1zwjj6gwfjifddgd5g5";
+       version = "0.15.0.0";
+       sha256 = "15vywgr01as3avmz9q1zp899w39xf6p9pk95bvvdmh9py2jh4sf4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "cayley-client_0_4_17" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, binary, bytestring
+     , exceptions, hspec, http-client, http-conduit, lens, lens-aeson
+     , mtl, text, transformers, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "cayley-client";
+       version = "0.4.17";
+       sha256 = "1mc4r45vlwbrcjz33akqs5kh27wc97b8dg1byanvyjyvsvabg5bb";
+       libraryHaskellDepends = [
+         aeson attoparsec base binary bytestring exceptions http-client
+         http-conduit lens lens-aeson mtl text transformers
+         unordered-containers vector
+       ];
+       testHaskellDepends = [ aeson base hspec unordered-containers ];
+       description = "A Haskell client for the Cayley graph database";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "cayley-dickson" = callPackage
     ({ mkDerivation, base, random }:
      mkDerivation {
···
        pname = "cborg";
        version = "0.2.6.0";
        sha256 = "1mvsavi8ngsvmcvlmaygsnygf7hn8kdqdhfff91n1zajgpz577h6";
+       revision = "1";
+       editedCabalFile = "0ry5p8cnmm772m3z074azh1ldxvq851dmffsp2b7vljjhzd9j4sc";
        libraryHaskellDepends = [
          array base bytestring containers deepseq ghc-prim half integer-gmp
          primitive text
···
        license = lib.licenses.mit;
      }) {};
 
+  "classy-prelude_1_5_0_1" = callPackage
+    ({ mkDerivation, async, base, basic-prelude, bifunctors, bytestring
+     , chunked-data, containers, deepseq, dlist, ghc-prim, hashable
+     , hspec, mono-traversable, mono-traversable-instances, mtl
+     , mutable-containers, primitive, QuickCheck, say, stm, stm-chans
+     , text, time, transformers, unliftio, unordered-containers, vector
+     , vector-instances
+     }:
+     mkDerivation {
+       pname = "classy-prelude";
+       version = "1.5.0.1";
+       sha256 = "1khc2acwmx9b226j6yxkhnvhddx40rzracpp96ra96gln109vpbx";
+       libraryHaskellDepends = [
+         async base basic-prelude bifunctors bytestring chunked-data
+         containers deepseq dlist ghc-prim hashable mono-traversable
+         mono-traversable-instances mtl mutable-containers primitive say stm
+         stm-chans text time transformers unliftio unordered-containers
+         vector vector-instances
+       ];
+       testHaskellDepends = [
+         base containers hspec QuickCheck transformers unordered-containers
+       ];
+       description = "A typeclass-based Prelude";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "classy-prelude-conduit" = callPackage
     ({ mkDerivation, base, bytestring, classy-prelude, conduit, hspec
      , monad-control, QuickCheck, resourcet, transformers, void
···
        license = lib.licenses.bsd2;
      }) {};
 
+  "concurrent-output_1_10_14" = callPackage
+    ({ mkDerivation, ansi-terminal, async, base, directory, exceptions
+     , process, stm, terminal-size, text, transformers, unix
+     }:
+     mkDerivation {
+       pname = "concurrent-output";
+       version = "1.10.14";
+       sha256 = "01d5zq7ja55jjn65fj5rs11kzqnc6baysxkzkq0jfd23wdqf9f92";
+       libraryHaskellDepends = [
+         ansi-terminal async base directory exceptions process stm
+         terminal-size text transformers unix
+       ];
+       description = "Ungarble output from several threads or commands";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "concurrent-resource-map" = callPackage
     ({ mkDerivation, base, containers, random, stm }:
      mkDerivation {
···
        pname = "contiguous";
        version = "0.6.1";
        sha256 = "1cgmz0adrv1kv1z21cfs4s4lmzbyp4acq5v2ly96bckp8a35cbix";
+       revision = "1";
+       editedCabalFile = "0lmqkbz8cgnxyds1wbhb9mxmc3rwz5x9hcamx08znrjl6fpkxs4f";
        libraryHaskellDepends = [
          base deepseq primitive primitive-unlifted run-st
        ];
···
        license = lib.licenses.mit;
      }) {};
 
-  "core-program_0_4_0_0" = callPackage
+  "core-program_0_4_2_0" = callPackage
     ({ mkDerivation, async, base, bytestring, chronologique, core-data
      , core-text, directory, exceptions, filepath, fsnotify, hashable
      , hourglass, mtl, prettyprinter, safe-exceptions, stm
···
      }:
      mkDerivation {
        pname = "core-program";
-       version = "0.4.0.0";
-       sha256 = "116l104ljadjg3bsri5ypgmj8abzihqwdsds9ziqljcw5079b0kp";
+       version = "0.4.2.0";
+       sha256 = "1xbfshfy6h7afpnlaafyq4mj3x0q4i83sxk6720k0dd0hhszb6b0";
        libraryHaskellDepends = [
          async base bytestring chronologique core-data core-text directory
          exceptions filepath fsnotify hashable hourglass mtl prettyprinter
···
      }:
      mkDerivation {
        pname = "crypto-sodium";
-       version = "0.0.4.0";
-       sha256 = "0wypzd06z12mc7pffryp7bq7rzzws348i79yg3x25d4kmi6xqydw";
+       version = "0.0.5.0";
+       sha256 = "0c1q0kmvglmlvv8z8q8nyjjjy02r41bk32pr1z080x79z612zad5";
        libraryHaskellDepends = [
          base bytestring cereal libsodium memory NaCl random safe-exceptions
        ];
···
        license = lib.licenses.mit;
      }) {};
 
+  "cursor_0_3_1_0" = callPackage
+    ({ mkDerivation, base, containers, deepseq, microlens, text
+     , validity, validity-containers, validity-text
+     }:
+     mkDerivation {
+       pname = "cursor";
+       version = "0.3.1.0";
+       sha256 = "1axwbs1aq00cxw2b6dxijqsr1s1ygfi9wbgdknx84giy7zfpxav6";
+       libraryHaskellDepends = [
+         base containers deepseq microlens text validity validity-containers
+         validity-text
+       ];
+       description = "Purely Functional Cursors";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "cursor-brick" = callPackage
     ({ mkDerivation, base, brick, cursor, text }:
      mkDerivation {
···
        license = lib.licenses.mit;
      }) {};
 
+  "cursor-brick_0_1_0_1" = callPackage
+    ({ mkDerivation, base, brick, cursor, text }:
+     mkDerivation {
+       pname = "cursor-brick";
+       version = "0.1.0.1";
+       sha256 = "108pmv6f8y3szrh3n96dyl7hsfr6qim8axikf82dgs1fd2nx61vw";
+       libraryHaskellDepends = [ base brick cursor text ];
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "cursor-fuzzy-time" = callPackage
     ({ mkDerivation, base, containers, cursor, deepseq, fuzzy-time
      , megaparsec, microlens, text, time, validity, validity-time
···
      }:
      mkDerivation {
        pname = "cursor-fuzzy-time-gen";
-       version = "0.0.0.0";
-       sha256 = "1m18d7098vivbqj079axmhrwzwk7mr89m159apnx2ff9200br31z";
+       version = "0.1.0.0";
+       sha256 = "12bwxpghgry3dhlpny4zmyjf4xillrajdr2xas07aknddks5bzn1";
        libraryHaskellDepends = [
          base containers cursor-fuzzy-time cursor-gen deepseq fuzzy-time
          fuzzy-time-gen genvalidity genvalidity-time megaparsec time
···
        ];
        description = "Generators for Purely Functional Cursors";
        license = lib.licenses.mit;
+     }) {};
+
+  "cursor-gen_0_4_0_0" = callPackage
+    ({ mkDerivation, base, containers, criterion, cursor, genvalidity
+     , genvalidity-containers, genvalidity-criterion, genvalidity-hspec
+     , genvalidity-hspec-optics, genvalidity-text, hspec, microlens
+     , pretty-show, QuickCheck, text
+     }:
+     mkDerivation {
+       pname = "cursor-gen";
+       version = "0.4.0.0";
+       sha256 = "1a591kx30d8zmwl1rp78scjgbakkslq45wx6f558wmpph33gnw5s";
+       libraryHaskellDepends = [
+         base containers cursor genvalidity genvalidity-containers
+         genvalidity-text QuickCheck text
+       ];
+       testHaskellDepends = [
+         base containers cursor genvalidity-hspec genvalidity-hspec-optics
+         hspec microlens pretty-show QuickCheck text
+       ];
+       benchmarkHaskellDepends = [
+         base criterion cursor genvalidity-criterion
+       ];
+       description = "Generators for Purely Functional Cursors";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "curve25519" = callPackage
···
        pname = "czipwith";
        version = "1.0.1.4";
        sha256 = "0zvi7wmbh09ngbyvavvhn6s3vz1pnps59fl1sq3vih6s03s0zmai";
+       revision = "1";
+       editedCabalFile = "1lijciq9ly8cmv7kjkazi8rz8zhh205f64iv3fsjj4spy2lpkyhx";
        libraryHaskellDepends = [ base template-haskell ];
        testHaskellDepends = [ base transformers ];
        description = "CZipWith class and deriving via TH";
···
      }) {};
 
   "data-forest" = callPackage
-    ({ mkDerivation, base, doctest }:
-     mkDerivation {
-       pname = "data-forest";
-       version = "0.1.0.8";
-       sha256 = "0b9b7h526580rsyqv8cfcc3109qjz4rv3prb7p98ddygcpbhm6rl";
-       libraryHaskellDepends = [ base ];
-       testHaskellDepends = [ base doctest ];
-       description = "A simple multi-way tree data structure";
-       license = lib.licenses.asl20;
-     }) {};
-
-  "data-forest_0_1_0_9" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "data-forest";
···
        testHaskellDepends = [ base ];
        description = "A simple multi-way tree data structure";
        license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "data-fresh" = callPackage
···
        pname = "dear-imgui";
        version = "1.2.2";
        sha256 = "095mv60dvikw1pmj59kwq6p9s8yp04zd8ndbcq3fdia8w0razrxf";
+       revision = "1";
+       editedCabalFile = "002s2a3hl1scadwqvhairhh7kqvz6fzbjgw4knc9lj6qm9b70gf0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "decision-diagrams" = callPackage
-    ({ mkDerivation, base, containers, hashable, hashtables, intern
-     , mwc-random, primitive, QuickCheck, random, reflection, statistics
-     , tasty, tasty-hunit, tasty-quickcheck, tasty-th
-     , unordered-containers
+    ({ mkDerivation, base, containers, deepseq, doctest, hashable
+     , hashtables, intern, mwc-random, primitive, QuickCheck
+     , quickcheck-instances, random, reflection, statistics, tasty
+     , tasty-hunit, tasty-quickcheck, tasty-th, unordered-containers
+     , vector
      }:
      mkDerivation {
        pname = "decision-diagrams";
-       version = "0.1.0.0";
-       sha256 = "056990c7bv7y4f51743jwqgdqpklgljn2v5g942wrzp71bkmgm9q";
-       revision = "2";
-       editedCabalFile = "01bcy569xp71b2vgiwxfd844pcicg7vmi1szggd6j73lk36sggr4";
+       version = "0.2.0.0";
+       sha256 = "0l03mwig95h300rn1cfhd5ahwrlap6zsw09lwmkx6wkw6rjf4a5s";
        libraryHaskellDepends = [
          base containers hashable hashtables intern mwc-random primitive
-         random reflection unordered-containers
+         random reflection unordered-containers vector
        ];
        testHaskellDepends = [
-         base containers mwc-random QuickCheck statistics tasty tasty-hunit
-         tasty-quickcheck tasty-th
+         base containers deepseq doctest mwc-random QuickCheck
+         quickcheck-instances statistics tasty tasty-hunit tasty-quickcheck
+         tasty-th vector
        ];
        description = "Binary Decision Diagrams (BDD) and Zero-suppressed Binary Decision Diagrams (ZDD)";
        license = lib.licenses.bsd3;
···
        pname = "deepseq-generics";
        version = "0.2.0.0";
        sha256 = "17bwghc15mc9pchfd1w46jh2p3wzc86aj6a537wqwxn08rayzcxh";
-       revision = "6";
-       editedCabalFile = "1qwnpdjsrqzn18pjmvv9aqz3l12fbdcimf62wkj33yfh69rx4s42";
+       revision = "7";
+       editedCabalFile = "1issqf30ykabjpk7f66k8pfyylxw7bxa39b5iq72s76nxi392lig";
        libraryHaskellDepends = [ base deepseq ghc-prim ];
        testHaskellDepends = [
          base deepseq ghc-prim HUnit test-framework test-framework-hunit
···
      }:
      mkDerivation {
        pname = "dep-t";
-       version = "0.5.0.0";
-       sha256 = "1l62zn12zknn3zlngyrsfwz1f7rxb7cf23lkmlg4ysbdh1wdf8sz";
+       version = "0.5.1.0";
+       sha256 = "1rj12an1dbppci4j8psffw5j28a6brqbpnwklv7k8y9iwmmyhiaz";
        libraryHaskellDepends = [ base mtl transformers unliftio-core ];
        testHaskellDepends = [
          aeson barbies base bytestring containers doctest mtl rank2classes
···
 
   "dep-t-advice" = callPackage
     ({ mkDerivation, aeson, barbies, base, containers, criterion, dep-t
-     , doctest, mtl, rank2classes, sop-core, tasty, tasty-hunit
-     , template-haskell, text, transformers, unliftio-core
+     , doctest, microlens, mtl, rank2classes, sop-core, tasty
+     , tasty-hunit, template-haskell, text, transformers, unliftio-core
      }:
      mkDerivation {
        pname = "dep-t-advice";
-       version = "0.5.0.0";
-       sha256 = "1bc5x0h9rsxp8da7h2qcvvgv0whg5zjfbv7js5i0aihvikywfjpx";
+       version = "0.5.1.0";
+       sha256 = "0bpxqb8nzf7sl0h7g0dzf30pvcf3z6kqf57aczy925x1spw58bpx";
        libraryHaskellDepends = [
          base dep-t mtl sop-core transformers unliftio-core
        ];
        testHaskellDepends = [
-         aeson barbies base containers dep-t doctest mtl rank2classes
-         sop-core tasty tasty-hunit template-haskell text transformers
-         unliftio-core
+         aeson barbies base containers dep-t doctest microlens mtl
+         rank2classes sop-core tasty tasty-hunit template-haskell text
+         transformers unliftio-core
        ];
        benchmarkHaskellDepends = [
          base criterion dep-t mtl rank2classes sop-core template-haskell
          text transformers unliftio-core
        ];
-       description = "Giving good advice to functions in a record-of-functions";
+       description = "Giving good advice to functions in records-of-functions";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
      }) {};
···
        license = lib.licenses.publicDomain;
      }) {};
 
+  "dependent-sum-template_0_1_1_1" = callPackage
+    ({ mkDerivation, base, constraints-extras, dependent-sum
+     , template-haskell, th-abstraction, th-extras
+     }:
+     mkDerivation {
+       pname = "dependent-sum-template";
+       version = "0.1.1.1";
+       sha256 = "03xffmih70ksk7jgfs3ypaa91bm1x21fjxqpj1gkhp9gbj6w2vyl";
+       libraryHaskellDepends = [
+         base dependent-sum template-haskell th-abstraction th-extras
+       ];
+       testHaskellDepends = [ base constraints-extras dependent-sum ];
+       description = "Template Haskell code to generate instances of classes in dependent-sum package";
+       license = lib.licenses.publicDomain;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "depends" = callPackage
     ({ mkDerivation, base, containers, directory, filepath, hspec
      , process, QuickCheck, transformers, yaml-config
···
        maintainers = with lib.maintainers; [ Gabriel439 ];
      }) {};
 
-  "dhall_1_40_1" = callPackage
+  "dhall_1_40_2" = 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, temporary, text
-     , text-manipulate, th-lift-instances, time, transformers, turtle
+     , base, base16-bytestring, bytestring, case-insensitive, cborg
+     , cborg-json, containers, contravariant, cryptohash-sha256
+     , 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, 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, system-filepath, tasty
+     , tasty-expected-failure, tasty-hunit, tasty-quickcheck
+     , tasty-silver, template-haskell, temporary, text, text-manipulate
+     , th-lift-instances, time, transformers, turtle
      , unordered-containers, uri-encode, vector
      }:
      mkDerivation {
        pname = "dhall";
-       version = "1.40.1";
-       sha256 = "0m2fw9ak9l6fz8ylpbi0cdihf2j66jlnd5j3vf56r7wlqgbkxhi1";
-       revision = "5";
-       editedCabalFile = "1dp9byzmjd2kvydc0q5s3mv59a131jqwhc9cl22jgbhp0whq9jgc";
+       version = "1.40.2";
+       sha256 = "14wh497fipvz01zc9s31gv144spg1iqfwp6x5mlk1hjk0v9qs5by";
        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 time transformers unordered-containers uri-encode
-         vector
+         aeson aeson-pretty ansi-terminal atomic-write base
+         base16-bytestring bytestring case-insensitive cborg cborg-json
+         containers contravariant cryptohash-sha256 data-fix deepseq Diff
+         directory dotgen either exceptions filepath half hashable haskeline
+         http-client http-client-tls http-types lens-family-core megaparsec
+         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 time transformers
+         unordered-containers uri-encode vector
        ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [
···
          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 temporary text time transformers
-         turtle unordered-containers vector
+         system-filepath tasty tasty-expected-failure tasty-hunit
+         tasty-quickcheck tasty-silver template-haskell temporary text time
+         transformers turtle unordered-containers vector
        ];
        benchmarkHaskellDepends = [
          base bytestring containers directory gauge text
···
        maintainers = with lib.maintainers; [ Gabriel439 ];
      }) {};
 
-  "dhall-bash_1_0_38" = callPackage
+  "dhall-bash_1_0_39" = callPackage
     ({ mkDerivation, base, bytestring, containers, dhall
      , neat-interpolation, optparse-generic, shell-escape, text
      }:
      mkDerivation {
        pname = "dhall-bash";
-       version = "1.0.38";
-       sha256 = "0pfwqz4l3nn4mr16pv5703j517g3nsgzpmiv18kzl4fs6141d881";
+       version = "1.0.39";
+       sha256 = "0by0w5dqsi0yrs9qnkpls7n5m0qwslxkcycb4s97vk8xl6nj5kk8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "dhall-csv";
-       version = "1.0.0";
-       sha256 = "1dg310mq4c00ykkm1vsvrcicls25zbx7iypcg0nqa8ggchac5jmh";
-       revision = "1";
-       editedCabalFile = "06mya0h8kw8609chxrbkq24gi7yk3fviz2q6balyv5gp3wivzzvg";
+       version = "1.0.1";
+       sha256 = "00a08lcxf9r1ln87bzy4j83z08yl1m7xmzv1irg0xa03vskby3lx";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "dhall-docs" = callPackage
-    ({ mkDerivation, base, bytestring, containers, cryptonite, dhall
-     , directory, doctest, file-embed, filepath, foldl, hashable
-     , lens-family-core, lucid, megaparsec, memory, mmark, mtl
+    ({ mkDerivation, base, base16-bytestring, bytestring, containers
+     , cryptohash-sha256, dhall, directory, doctest, file-embed
+     , filepath, foldl, lens-family-core, lucid, megaparsec, mmark, mtl
      , optparse-applicative, path, path-io, pretty, prettyprinter, tasty
      , tasty-hunit, tasty-silver, text, transformers, turtle
      }:
      mkDerivation {
        pname = "dhall-docs";
-       version = "1.0.7";
-       sha256 = "1h7bzpp3xa5m8zknhi24q0wh1n6w6z26ka780mdsbmchhhj59njm";
-       revision = "2";
-       editedCabalFile = "19mn12l8qljrf41n0xs58hqi89xaaab4wp6dldvi7pym276zg7pn";
+       version = "1.0.8";
+       sha256 = "1rkwvk6vd8l52nxv186fw3qdmsjvi8098yccnnbysmf41rz80fi7";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         base bytestring containers cryptonite dhall directory file-embed
-         filepath lens-family-core lucid megaparsec memory mmark mtl
-         optparse-applicative path path-io prettyprinter text transformers
+         base base16-bytestring bytestring containers cryptohash-sha256
+         dhall directory file-embed filepath lens-family-core lucid
+         megaparsec mmark mtl optparse-applicative path path-io
+         prettyprinter text transformers
        ];
        executableHaskellDepends = [ base dhall ];
        testHaskellDepends = [
          base bytestring containers dhall directory doctest filepath foldl
-         hashable path path-io pretty tasty tasty-hunit tasty-silver text
+         lucid path path-io pretty tasty tasty-hunit tasty-silver text
          turtle
        ];
        description = "Generate HTML docs from a dhall package";
···
        maintainers = with lib.maintainers; [ Gabriel439 ];
      }) {};
 
-  "dhall-json_1_7_8" = callPackage
+  "dhall-json_1_7_9" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, aeson-yaml, ansi-terminal
      , base, bytestring, containers, dhall, exceptions, filepath
      , lens-family-core, optparse-applicative, prettyprinter
···
      }:
      mkDerivation {
        pname = "dhall-json";
-       version = "1.7.8";
-       sha256 = "0g4c71di93r6vnbhajsj5k3ivhzvn0n0aicvvc2j9nbjfhvahd3h";
+       version = "1.7.9";
+       sha256 = "11rl46vn6lzcm9kznpfc43c3a2cbq2si2zba3k2x4j360kvg9fgn";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        maintainers = with lib.maintainers; [ Gabriel439 ];
      }) {};
 
+  "dhall-lsp-server_1_0_17" = 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.17";
+       sha256 = "0h4wji3fsvkplj78bfqi3x9p7q9ikcsmj65nfrfn4p6p6i1knhw8";
+       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_22" = callPackage
+  "dhall-nix_1_1_23" = callPackage
     ({ mkDerivation, base, containers, data-fix, dhall, hnix
      , lens-family-core, neat-interpolation, optparse-generic, text
      }:
      mkDerivation {
        pname = "dhall-nix";
-       version = "1.1.22";
-       sha256 = "1da64h52fz4imvk7hqblri27zg54r9rcs6hlyzkbnqg4yivpiclg";
+       version = "1.1.23";
+       sha256 = "17ajfkhxg4kjn6w7v3ymr6nsbqplvywkcwmfzybxqvmphh4zmfjb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "dhall-nixpkgs" = callPackage
-    ({ mkDerivation, aeson, base, data-fix, dhall, foldl, hnix
-     , lens-family-core, megaparsec, mmorph, neat-interpolation
-     , network-uri, optparse-applicative, prettyprinter, text
-     , transformers, turtle
+    ({ mkDerivation, aeson, base, base16-bytestring, base64-bytestring
+     , bytestring, data-fix, dhall, foldl, hnix, lens-family-core
+     , megaparsec, mmorph, neat-interpolation, network-uri
+     , optparse-applicative, prettyprinter, text, transformers, turtle
      }:
      mkDerivation {
        pname = "dhall-nixpkgs";
-       version = "1.0.6";
-       sha256 = "12sfxz7n86m69m1xbnrrr1ybggh70rfwmr4maflq522bhkc2hgvk";
-       revision = "2";
-       editedCabalFile = "13i04l52jb8xyhqa48r8rlr0d4p657aarfhsxm407ziph5pi60vk";
+       version = "1.0.7";
+       sha256 = "1s7md4b2jzgmf557clln9fc5lmdrd9xjs55dd97dv8q6krm8nabg";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         aeson base data-fix dhall foldl hnix lens-family-core megaparsec
-         mmorph neat-interpolation network-uri optparse-applicative
-         prettyprinter text transformers turtle
+         aeson base base16-bytestring base64-bytestring bytestring data-fix
+         dhall foldl hnix lens-family-core megaparsec mmorph
+         neat-interpolation network-uri optparse-applicative prettyprinter
+         text transformers turtle
        ];
        description = "Convert Dhall projects to Nix packages";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "dhall-openapi";
-       version = "1.0.2";
-       sha256 = "1p678nn1gfj2xp0kmw8i5pzsv6s5bpnsmyng45adb9pnpiyxbcyj";
-       revision = "2";
-       editedCabalFile = "0gkxzfadkpz4dcmcfbyf66s2xa656lf2vw0n282qnc1rsy74ra85";
+       version = "1.0.3";
+       sha256 = "0k7yq7g77ws7wjfzd35ydsjwaq2kc1y0rhwjwb6yvkyvljmr0ykz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "dhall-toml";
-       version = "1.0.0";
-       sha256 = "13pz6y0l70h3x62wkhay2jiws6s5m6dy9v7kpd2c5mqzaspfy0w2";
+       version = "1.0.1";
+       sha256 = "024cillwk8rq7jlv6vh85ifypy1ddfvszf3fzmgl1r0ca9iclmbb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        maintainers = with lib.maintainers; [ Gabriel439 ];
      }) {};
 
-  "dhall-yaml_1_2_8" = callPackage
+  "dhall-yaml_1_2_9" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, base, bytestring, dhall
      , dhall-json, exceptions, HsYAML, HsYAML-aeson
      , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal
···
      }:
      mkDerivation {
        pname = "dhall-yaml";
-       version = "1.2.8";
-       sha256 = "1p766ybwib3f2i5h7m1hh71vc255ahvf7237bpprdapqw3ag8nak";
-       revision = "1";
-       editedCabalFile = "06jr2b5zj82zcsq7dp6d8v9rfarkpqkp6m1s61d76vlzv9kc2pp2";
+       version = "1.2.9";
+       sha256 = "0gn9jrqihimjs8i9ksgmlkh8c64km52rmsgz2y6k3ab0igkv8dw6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "digit";
-       version = "0.10";
-       sha256 = "1qvz2gj4f2fcq8m8s4h6q5r2y3z55dhk4zxxijxha3mqfiybh4ky";
+       version = "0.11";
+       sha256 = "1ic9qvlqrdi3a8wlgrahl6mrc43sc9x1k9p7myydzai4zg1wr013";
        libraryHaskellDepends = [
          base lens parsers scientific semigroupoids semigroups
          template-haskell
···
      }:
      mkDerivation {
        pname = "discord-haskell";
-       version = "1.9.1";
-       sha256 = "10k45mw4z36j9imgcnpv7xnldl6gv556fbyzfnpq9bsgz1cyxdcs";
+       version = "1.9.2";
+       sha256 = "1dqnhnd55qkrs33gbq1kpcq2hyp2ni33qp4xq9cwjlplgzpc32w6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, doctest }:
      mkDerivation {
        pname = "doctest-driver-gen";
-       version = "0.3.0.4";
-       sha256 = "1fbqi4s4ajxhyv4a7nbh3v98limla0z8rfqlh02pwc1a90qpwy1a";
-       revision = "2";
-       editedCabalFile = "1hf8ncgj3jybyyw2vw96pznr39gsadj6jf7p34s82hkmsnalxfql";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [ base ];
-       executableHaskellDepends = [ base ];
-       testHaskellDepends = [ base doctest ];
-       description = "Generate driver file for doctest's cabal integration";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "doctest-driver-gen_0_3_0_5" = callPackage
-    ({ mkDerivation, base, doctest }:
-     mkDerivation {
-       pname = "doctest-driver-gen";
        version = "0.3.0.5";
        sha256 = "08zv5c1cfklknpbw974sw4rb6jiijd3q28cpjw1cncc06n2jy85b";
        isLibrary = true;
···
        testHaskellDepends = [ base doctest ];
        description = "Generate driver file for doctest's cabal integration";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "doctest-exitcode-stdio" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "doctest-parallel" = callPackage
+    ({ mkDerivation, base, base-compat, Cabal, cabal-install-parsers
+     , code-page, containers, deepseq, directory, exceptions, filepath
+     , ghc, ghc-paths, Glob, hspec, hspec-core, hspec-discover, HUnit
+     , mockery, pretty, process, QuickCheck, setenv, silently
+     , stringbuilder, syb, template-haskell, transformers
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "doctest-parallel";
+       version = "0.1";
+       sha256 = "0hc5zg94idc62kgfsinbd5cd6xcy9cjvcpav38x4b0slr7i69b4v";
+       libraryHaskellDepends = [
+         base base-compat Cabal cabal-install-parsers code-page containers
+         deepseq directory exceptions filepath ghc ghc-paths Glob pretty
+         process syb template-haskell transformers unordered-containers
+       ];
+       testHaskellDepends = [
+         base base-compat code-page deepseq directory exceptions filepath
+         ghc ghc-paths hspec hspec-core hspec-discover HUnit mockery process
+         QuickCheck setenv silently stringbuilder syb transformers
+       ];
+       testToolDepends = [ hspec-discover ];
+       doHaddock = false;
+       description = "Test interactive Haskell examples";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "doctest-prop" = callPackage
     ({ mkDerivation, base, doctest, HUnit, QuickCheck }:
      mkDerivation {
···
        ];
        description = "Loads environment variables from dotenv files";
        license = lib.licenses.mit;
+     }) {};
+
+  "dotenv_0_9_0_0" = callPackage
+    ({ mkDerivation, base, base-compat, containers, directory
+     , exceptions, hspec, hspec-discover, hspec-megaparsec, megaparsec
+     , optparse-applicative, process, text, transformers
+     }:
+     mkDerivation {
+       pname = "dotenv";
+       version = "0.9.0.0";
+       sha256 = "12w7n6yn8mk5l3b2a1ppzg3s4fvs24gx2plas8amhxrqdpx4gdk7";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base base-compat containers directory exceptions megaparsec process
+         text transformers
+       ];
+       executableHaskellDepends = [
+         base base-compat megaparsec optparse-applicative process text
+         transformers
+       ];
+       testHaskellDepends = [
+         base base-compat containers directory exceptions hspec
+         hspec-megaparsec megaparsec process text transformers
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Loads environment variables from dotenv files";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "dotfs" = callPackage
···
      }:
      mkDerivation {
        pname = "dump-core";
-       version = "0.1.3.2";
-       sha256 = "04p3x8lvf4if82xjin9cxhc3r478lp3zmr3xn33xqp37lmcqvr5k";
+       version = "0.1.4";
+       sha256 = "0fl6lmwrzjxwirnpwmjiqbc5fj2s4fnp0dv8s3bcdslxwxkmi9l4";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring containers directory filepath ghc monadLib
···
     ({ mkDerivation, aeson, async, base, blaze-html, blaze-markup
      , commonmark, commonmark-extensions, commonmark-pandoc, containers
      , data-default, directory, filepath, filepattern, fsnotify
-     , http-types, lvar, monad-logger, monad-logger-extras
-     , neat-interpolation, optparse-applicative, pandoc-types
-     , profunctors, relude, safe-exceptions, shower, stm, tagged, text
-     , time, unliftio, wai, wai-middleware-static, wai-websockets, warp
-     , websockets
+     , http-types, lvar, megaparsec, monad-logger, monad-logger-extras
+     , neat-interpolation, optparse-applicative, pandoc-types, parsec
+     , parser-combinators, relude, safe-exceptions, stm, text, time
+     , unicode-transforms, unionmount, unliftio, uri-encode, wai
+     , wai-middleware-static, wai-websockets, warp, websockets, yaml
      }:
      mkDerivation {
        pname = "ema";
-       version = "0.1.0.0";
-       sha256 = "0b7drwqcdap52slnw59vx3mhpabcl72p7rinnfkzsh74jfx21vz0";
-       isLibrary = true;
-       isExecutable = true;
+       version = "0.2.0.0";
+       sha256 = "1pjgpy4rvpwvrdszppb51nys281aglbpjgx4yci9hklp0kbkkh9i";
        libraryHaskellDepends = [
          aeson async base blaze-html blaze-markup commonmark
          commonmark-extensions commonmark-pandoc containers data-default
-         directory filepath filepattern fsnotify http-types lvar
+         directory filepath filepattern fsnotify http-types lvar megaparsec
          monad-logger monad-logger-extras neat-interpolation
-         optparse-applicative pandoc-types profunctors relude
-         safe-exceptions shower stm tagged text time unliftio wai
-         wai-middleware-static wai-websockets warp websockets
+         optparse-applicative pandoc-types parsec parser-combinators relude
+         safe-exceptions stm text time unicode-transforms unionmount
+         unliftio uri-encode wai wai-middleware-static wai-websockets warp
+         websockets yaml
        ];
-       executableHaskellDepends = [ base ];
        description = "Static site generator library with hot reload";
        license = lib.licenses.agpl3Only;
      }) {};
···
   "ersatz" = callPackage
     ({ mkDerivation, array, attoparsec, base, bytestring, containers
      , data-default, fail, lens, mtl, parsec, process, semigroups
-     , temporary, transformers, unordered-containers
-     }:
-     mkDerivation {
-       pname = "ersatz";
-       version = "0.4.9";
-       sha256 = "1pnqz7zvkfw70pjhhs5lm965iydrj8cgbj685fh50fpm0wapnmfd";
-       isLibrary = true;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         array attoparsec base bytestring containers data-default lens mtl
-         process semigroups temporary transformers unordered-containers
-       ];
-       executableHaskellDepends = [
-         array base containers fail lens mtl parsec semigroups
-       ];
-       testHaskellDepends = [ array base ];
-       description = "A monad for expressing SAT or QSAT problems using observable sharing";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "ersatz_0_4_10" = callPackage
-    ({ mkDerivation, array, attoparsec, base, bytestring, containers
-     , data-default, fail, lens, mtl, parsec, process, semigroups
      , streams, temporary, transformers, unordered-containers
      }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "eventlog2html";
-       version = "0.9.1";
-       sha256 = "17fp0q44lk3nkqzpilxlvzbr0b25girbh7j18yl6blcp5mcmq2cd";
-       revision = "1";
-       editedCabalFile = "17p7h7xii3p0k8ji11jw7dcprmcrwhw0lfpyq2f557s87cpwlinf";
+       version = "0.9.2";
+       sha256 = "0mr916gppp8pgyqdx89zhmcil7hkm7462h6vsq1y4n1qf5hx30jv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "exact-pi";
        version = "0.5.0.1";
        sha256 = "0q0qrkmpff835m3zz3w60i1y4sqicnzqb6vqmk13cjh4ign5d0ax";
-       revision = "1";
-       editedCabalFile = "1l55d7x61i2d5rlh7sh2nhn0af9cyp92gzdmqqnnjzg55d347qsm";
+       revision = "2";
+       editedCabalFile = "11g9w0rcndi8c28hykzipcfcxffxgdys21di1fdz4n5p05f3ldqa";
        libraryHaskellDepends = [ base numtype-dk ];
        testHaskellDepends = [
          base numtype-dk QuickCheck tasty tasty-hunit tasty-quickcheck
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "exception-transformers_0_4_0_11" = callPackage
+    ({ mkDerivation, base, fail, HUnit, test-framework
+     , test-framework-hunit, transformers, transformers-compat
+     }:
+     mkDerivation {
+       pname = "exception-transformers";
+       version = "0.4.0.11";
+       sha256 = "1zmd2s40m86c9mhv32l5bvvf5r52cgpxvb4v5phyc3pjwlr7m8g5";
+       libraryHaskellDepends = [
+         base fail transformers transformers-compat
+       ];
+       testHaskellDepends = [
+         base HUnit test-framework test-framework-hunit transformers
+         transformers-compat
+       ];
+       description = "Type classes and monads for unchecked extensible exceptions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "exception-via" = callPackage
     ({ mkDerivation, base, template-haskell }:
      mkDerivation {
···
        pname = "exiftool";
        version = "0.2.0.0";
        sha256 = "138d25fxqz3vg62mfgmva52flyzjxd8dxr0kc7ayfil1zk3bp4jg";
-       revision = "1";
-       editedCabalFile = "0sgi3w8x1zlch0v3zpxrjhisxd1s6wj1qznjlm0gz2r5d1pzc03z";
+       revision = "2";
+       editedCabalFile = "1f1qa9qlmi3i7iif6ddazgqpgds64fr467c0rs53060rcbyjr9gd";
        libraryHaskellDepends = [
          aeson base base64 bytestring hashable process scientific
          string-conversions temporary text unordered-containers vector
···
        broken = true;
      }) {};
 
-  "faktory_1_1_2_0" = callPackage
+  "faktory_1_1_2_1" = callPackage
     ({ mkDerivation, aeson, aeson-casing, aeson-qq, async, base
      , bytestring, connection, cryptonite, errors, hspec, markdown-unlit
      , megaparsec, memory, mtl, network, random, safe-exceptions
···
      }:
      mkDerivation {
        pname = "faktory";
-       version = "1.1.2.0";
-       sha256 = "0rsypmqy6gkpsjgzzc20wy5jjw13bb4j2zsxwn9zchyihfpak36a";
+       version = "1.1.2.1";
+       sha256 = "0hdwp12qn6m7xd2d7wsj3092jgvx2h6gf4b0gdswy1mkf0c2jql9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "feed";
        version = "1.3.2.0";
        sha256 = "0kv3vx3njqlhwvkmf12m1gmwl8jj97kfa60da2362vwdavhcf4dk";
-       revision = "2";
-       editedCabalFile = "12kl1bsgv6jdbvm1dblxjkvc2n8p83wgcpalp8vyf414lhxrjnpx";
+       revision = "3";
+       editedCabalFile = "029bip9jrmygvsdrdxn5gyb899kny41a98xjvy65gapd8ir1fd43";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base base-compat bytestring old-locale old-time safe text time
···
      }) {};
 
   "filepather" = callPackage
-    ({ mkDerivation, base, comonad, comonad-transformers, data-lens
-     , directory, filepath, mtl, transformers
+    ({ mkDerivation, base, bytestring, contravariant, directory
+     , filepath, lens, mmorph, mtl, semigroupoids, semigroups
+     , transformers
      }:
      mkDerivation {
        pname = "filepather";
-       version = "0.3.0";
-       sha256 = "1gqnanmnhrpdw5iryf757qwj7j9izyzx1j4y74ydivxafz8w469v";
+       version = "0.4.0";
+       sha256 = "0b103xaxs09lr720md8rrn5gc581ihja6v1jv8gcp8yfnqrn4m1p";
        libraryHaskellDepends = [
-         base comonad comonad-transformers data-lens directory filepath mtl
-         transformers
+         base bytestring contravariant directory filepath lens mmorph mtl
+         semigroupoids semigroups transformers
        ];
        description = "Functions on System.FilePath";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "filepattern" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "flow_1_0_23" = callPackage
+    ({ mkDerivation, base, HUnit }:
+     mkDerivation {
+       pname = "flow";
+       version = "1.0.23";
+       sha256 = "064dzij0qj0psnis7fcr3zklkkm8bncl448c9k1na1g7h46660mv";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base HUnit ];
+       description = "Write more understandable Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "flow-er" = callPackage
     ({ mkDerivation, base, doctest, flow, QuickCheck }:
      mkDerivation {
···
        pname = "foldl";
        version = "1.4.12";
        sha256 = "0zf4yljh3s2ddxa7dhzdglmylj14kfldhkclc44g37zvjq6kcnag";
+       revision = "1";
+       editedCabalFile = "15d002khil6d4qjzm4hgfwnl502884jys9pqdm22jvdvsln84jjm";
        libraryHaskellDepends = [
          base bytestring comonad containers contravariant hashable primitive
          profunctors random semigroupoids text transformers
···
      }:
      mkDerivation {
        pname = "folds";
-       version = "0.7.6";
-       sha256 = "06sy3arl37k7qz6zm2rscpvzl9za165214f5bgjppj7zdv0qkc3v";
-       configureFlags = [ "-f-test-hlint" ];
-       libraryHaskellDepends = [
-         adjunctions base bifunctors comonad constraints contravariant
-         data-reify distributive lens mtl pointed profunctors reflection
-         semigroupoids transformers unordered-containers vector
-       ];
-       description = "Beautiful Folding";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "folds_0_7_7" = callPackage
-    ({ mkDerivation, adjunctions, base, bifunctors, comonad
-     , constraints, contravariant, data-reify, distributive, lens, mtl
-     , pointed, profunctors, reflection, semigroupoids, transformers
-     , unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "folds";
        version = "0.7.7";
        sha256 = "1hggk92i61f3nxcjdxvgs3b8am3jypig09s9wqwrwzaclx0mk5sh";
        configureFlags = [ "-f-test-hlint" ];
···
        ];
        description = "Beautiful Folding";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "folds-common" = callPackage
···
        pname = "fourmolu";
        version = "0.4.0.0";
        sha256 = "1mq0h6nsl7ssfwh6zqhyja7w212vn8msmlm5iwwimca279hzwywb";
+       revision = "1";
+       editedCabalFile = "03bwhqj547brmgk191gy3k9xayi6fqqk2f5sbz3ail1bk7b73xnq";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "fp-ieee" = callPackage
-    ({ mkDerivation, base, decimal-arithmetic, doctest, gauge, hspec
-     , hspec-core, integer-gmp, integer-logarithms, QuickCheck, random
+    ({ mkDerivation, base, doctest, hspec, hspec-core, integer-gmp
+     , integer-logarithms, QuickCheck, random, tasty-bench
      }:
      mkDerivation {
        pname = "fp-ieee";
-       version = "0.1.0.1";
-       sha256 = "11hj4ldpxcvpnyqhs02s0ryfjiql9pmn1h1caly3cfd1r9aairl9";
+       version = "0.1.0.2";
+       sha256 = "0zfrjqyi3pvfmsidq2vsfwqaah0ag6pkixlxicr43jmfyrhi4snl";
        libraryHaskellDepends = [ base integer-gmp integer-logarithms ];
        testHaskellDepends = [
-         base decimal-arithmetic doctest hspec hspec-core integer-logarithms
-         QuickCheck random
+         base doctest hspec hspec-core integer-logarithms QuickCheck random
        ];
-       benchmarkHaskellDepends = [ base gauge ];
+       benchmarkHaskellDepends = [ base tasty-bench ];
        description = "IEEE 754-2019 compliant operations";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "fpco-api" = callPackage
···
 
   "franz" = callPackage
     ({ mkDerivation, base, bytestring, cereal, concurrent-resource-map
-     , containers, cpu, deepseq, directory, fast-builder, filepath
-     , fsnotify, mtl, network, optparse-applicative, process, retry
-     , sendfile, stm, stm-delay, transformers, unboxed-ref
-     , unordered-containers, vector
+     , containers, cpu, deepseq, directory, exceptions, fast-builder
+     , filepath, fsnotify, hashable, mtl, network, optparse-applicative
+     , process, retry, sendfile, stm, stm-delay, temporary, text
+     , transformers, unboxed-ref, unordered-containers, vector
      }:
      mkDerivation {
        pname = "franz";
-       version = "0.3.0.1";
-       sha256 = "0lzi5ckz2x88yayrlq5w15wd6x05bx44210b10w0yz5vg9dfz2y0";
+       version = "0.5";
+       sha256 = "1fhh27sjv46yk2kqw6kgn1wn6m1acl8vp1j9r7ag3pd93y0w3d1s";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          base bytestring cereal concurrent-resource-map containers cpu
-         deepseq directory fast-builder filepath fsnotify mtl network
-         process retry sendfile stm stm-delay transformers unboxed-ref
-         unordered-containers vector
+         deepseq directory exceptions fast-builder filepath fsnotify
+         hashable mtl network process retry sendfile stm stm-delay temporary
+         text transformers unboxed-ref unordered-containers vector
        ];
        executableHaskellDepends = [
          base bytestring network optparse-applicative stm vector
···
        license = lib.licenses.isc;
      }) {};
 
-  "futhark_0_20_6" = callPackage
+  "futhark_0_20_7" = callPackage
     ({ mkDerivation, aeson, alex, ansi-terminal, array, base
      , base16-bytestring, binary, blaze-html, bmp, bytestring
      , bytestring-to-vector, cmark-gfm, containers, cryptohash-md5
···
      }:
      mkDerivation {
        pname = "futhark";
-       version = "0.20.6";
-       sha256 = "1ysbxv597v1m1n655f5d8fvcx4mmxgip2858q81jv4lw9m3xg89l";
+       version = "0.20.7";
+       sha256 = "1j91gilrjyi0hd7fsh1pq687y4vdmk9kv0lwrwhq74rcczyyyrvj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.mit;
      }) {};
 
+  "fuzzy-time_0_2_0_0" = callPackage
+    ({ mkDerivation, base, containers, deepseq, megaparsec, text, time
+     , validity, validity-time
+     }:
+     mkDerivation {
+       pname = "fuzzy-time";
+       version = "0.2.0.0";
+       sha256 = "0gf6bj0jrd8jh30n1cdjc31ynjpsrikwacp3mysa76kqb4mxl3xz";
+       libraryHaskellDepends = [
+         base containers deepseq megaparsec text time validity validity-time
+       ];
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "fuzzy-time-gen" = callPackage
     ({ mkDerivation, base, containers, criterion, fuzzy-time
      , genvalidity, genvalidity-criterion, genvalidity-hspec
···
      }:
      mkDerivation {
        pname = "fuzzy-time-gen";
-       version = "0.1.0.0";
-       sha256 = "01hvzb6x25qbsbcfacjba1niwfswkxmarspniiaa7agzcfds45z3";
+       version = "0.2.0.0";
+       sha256 = "0lcs0kgm935rizvsy2p8v8g1kjsjishd9l7jzgl45vlwbs5g863l";
        libraryHaskellDepends = [
          base containers fuzzy-time genvalidity genvalidity-time megaparsec
          QuickCheck time
···
      }:
      mkDerivation {
        pname = "fuzzyset";
-       version = "0.2.1";
-       sha256 = "13hzy1qkxd7d7qirxhixi1qyrcjjvx6y3qmbggw5c0mkgckw7gpi";
-       libraryHaskellDepends = [
-         base data-default text text-metrics unordered-containers vector
-       ];
-       testHaskellDepends = [
-         base data-default hspec ieee754 text text-metrics
-         unordered-containers vector
-       ];
-       description = "Fuzzy set for approximate string matching";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "fuzzyset_0_2_2" = callPackage
-    ({ mkDerivation, base, data-default, hspec, ieee754, text
-     , text-metrics, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "fuzzyset";
        version = "0.2.2";
        sha256 = "1153xv53l6khw7yy36pfaf7pmmlwpg4ig7ywk4rxj375janlg1g8";
        libraryHaskellDepends = [
···
        ];
        description = "Fuzzy set for approximate string matching";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "fuzzytime" = callPackage
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "gemcap" = callPackage
+    ({ mkDerivation, base, bytestring, hspec, io-streams, network
+     , tcp-streams, text, tls, transformers, x509
+     }:
+     mkDerivation {
+       pname = "gemcap";
+       version = "0.1.0";
+       sha256 = "0173dhqdcfkkrlj3x3m0fml4rk3sfmiflwfp9bnpja7iq9br2vhf";
+       libraryHaskellDepends = [
+         base bytestring io-streams network tcp-streams text tls
+         transformers x509
+       ];
+       testHaskellDepends = [
+         base bytestring hspec io-streams network tcp-streams text tls
+         transformers x509
+       ];
+       description = "a simple Gemini capsule (server)";
+       license = lib.licenses.agpl3Plus;
+     }) {};
+
   "gemini-router" = callPackage
     ({ mkDerivation, base, gemini-server, HsOpenSSL, network-uri
      , transformers
···
        license = lib.licenses.mit;
      }) {};
 
-  "generic-random_1_5_0_0" = callPackage
+  "generic-random_1_5_0_1" = callPackage
     ({ mkDerivation, base, deepseq, QuickCheck }:
      mkDerivation {
        pname = "generic-random";
-       version = "1.5.0.0";
-       sha256 = "033cs5vkx57ny035ngndhg3n32jbzyp98li9559gyiz8glp79pzg";
-       revision = "1";
-       editedCabalFile = "0p0im7py1hrarad8pg5vcggz52d702p749nvx3h5glcygzlag14v";
+       version = "1.5.0.1";
+       sha256 = "02iczjf2xc4sxfi234nf6irfj5slvf3p5hpaxl8r5nc8hy052d6x";
        libraryHaskellDepends = [ base QuickCheck ];
        testHaskellDepends = [ base deepseq QuickCheck ];
        description = "Generic random generators for QuickCheck";
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity_1_0_0_1" = callPackage
+    ({ mkDerivation, base, hspec, hspec-core, QuickCheck, random
+     , validity
+     }:
+     mkDerivation {
+       pname = "genvalidity";
+       version = "1.0.0.1";
+       sha256 = "1rkrw46mhb4cvvg69avmbvsmssg5aii9g2kb4xqa9488jf8wz3m0";
+       libraryHaskellDepends = [ base QuickCheck random validity ];
+       testHaskellDepends = [ base hspec hspec-core QuickCheck ];
+       description = "Testing utilities for the validity library";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-aeson" = callPackage
     ({ mkDerivation, aeson, base, genvalidity, genvalidity-hspec
      , genvalidity-scientific, genvalidity-text
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-aeson_1_0_0_0" = callPackage
+    ({ mkDerivation, aeson, base, criterion, deepseq, genvalidity
+     , genvalidity-criterion, genvalidity-hspec, genvalidity-scientific
+     , genvalidity-text, genvalidity-unordered-containers
+     , genvalidity-vector, hspec, QuickCheck, validity, validity-aeson
+     }:
+     mkDerivation {
+       pname = "genvalidity-aeson";
+       version = "1.0.0.0";
+       sha256 = "1k28vl7i2idv44962wspvhpqpfznj52ckd3g7h580894vghhwi89";
+       libraryHaskellDepends = [
+         aeson base genvalidity genvalidity-scientific genvalidity-text
+         genvalidity-unordered-containers genvalidity-vector QuickCheck
+         validity validity-aeson
+       ];
+       testHaskellDepends = [
+         aeson base deepseq genvalidity genvalidity-hspec hspec
+       ];
+       benchmarkHaskellDepends = [
+         aeson base criterion genvalidity-criterion
+       ];
+       description = "GenValidity support for aeson";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-bytestring" = callPackage
     ({ mkDerivation, base, bytestring, criterion, deepseq, genvalidity
      , genvalidity-criterion, genvalidity-hspec, hspec, QuickCheck
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-bytestring_1_0_0_0" = callPackage
+    ({ mkDerivation, base, bytestring, criterion, deepseq, genvalidity
+     , genvalidity-criterion, genvalidity-hspec, hspec, QuickCheck
+     , random, validity, validity-bytestring
+     }:
+     mkDerivation {
+       pname = "genvalidity-bytestring";
+       version = "1.0.0.0";
+       sha256 = "0bsi0y05pivyx14cvl7w46fgp1y5b53w2bk07q3vgzk079vfrcrg";
+       libraryHaskellDepends = [
+         base bytestring genvalidity QuickCheck random validity
+         validity-bytestring
+       ];
+       testHaskellDepends = [
+         base bytestring deepseq genvalidity genvalidity-hspec hspec
+         QuickCheck validity
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring criterion genvalidity genvalidity-criterion
+         QuickCheck
+       ];
+       description = "GenValidity support for ByteString";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-containers" = callPackage
     ({ mkDerivation, base, containers, criterion, genvalidity
      , genvalidity-criterion, genvalidity-hspec, genvalidity-property
···
        ];
        description = "GenValidity support for containers";
        license = lib.licenses.mit;
+     }) {};
+
+  "genvalidity-containers_1_0_0_0" = callPackage
+    ({ mkDerivation, base, containers, criterion, genvalidity
+     , genvalidity-criterion, genvalidity-hspec, genvalidity-property
+     , hspec, QuickCheck, validity, validity-containers
+     }:
+     mkDerivation {
+       pname = "genvalidity-containers";
+       version = "1.0.0.0";
+       sha256 = "146nnn1k82js6vkgx3ys5nl251jbryqg1lvb56fd3849az68px3k";
+       libraryHaskellDepends = [
+         base containers genvalidity QuickCheck validity validity-containers
+       ];
+       testHaskellDepends = [
+         base containers genvalidity genvalidity-hspec genvalidity-property
+         hspec QuickCheck validity validity-containers
+       ];
+       benchmarkHaskellDepends = [
+         base containers criterion genvalidity genvalidity-criterion
+         QuickCheck
+       ];
+       description = "GenValidity support for containers";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "genvalidity-criterion" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-criterion_1_0_0_0" = callPackage
+    ({ mkDerivation, base, criterion, deepseq, genvalidity, QuickCheck
+     }:
+     mkDerivation {
+       pname = "genvalidity-criterion";
+       version = "1.0.0.0";
+       sha256 = "050i515v8wggamlnywmx93nlb8gqhnlf5qafsrn0gl5w8d82blc9";
+       libraryHaskellDepends = [
+         base criterion deepseq genvalidity QuickCheck
+       ];
+       benchmarkHaskellDepends = [
+         base criterion genvalidity QuickCheck
+       ];
+       description = "Criterion benchmarks for generators";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-hspec" = callPackage
     ({ mkDerivation, base, genvalidity, genvalidity-property, hspec
      , hspec-core, QuickCheck, transformers, validity
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-hspec_1_0_0_0" = callPackage
+    ({ mkDerivation, base, genvalidity, genvalidity-property, hspec
+     , hspec-core, QuickCheck, transformers, validity
+     }:
+     mkDerivation {
+       pname = "genvalidity-hspec";
+       version = "1.0.0.0";
+       sha256 = "1p00iphswnsaabcnjmvf4ahydpqg66zya4qfjb52bbz6cb7k06s7";
+       libraryHaskellDepends = [
+         base genvalidity genvalidity-property hspec hspec-core QuickCheck
+         transformers validity
+       ];
+       testHaskellDepends = [
+         base genvalidity hspec hspec-core QuickCheck
+       ];
+       description = "Standard spec's for GenValidity instances";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-hspec-aeson" = callPackage
     ({ mkDerivation, aeson, base, bytestring, deepseq, genvalidity
      , genvalidity-aeson, genvalidity-hspec, genvalidity-property
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-hspec-aeson_1_0_0_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, deepseq, genvalidity
+     , genvalidity-aeson, genvalidity-hspec, genvalidity-property
+     , genvalidity-text, hspec, QuickCheck, text, validity
+     }:
+     mkDerivation {
+       pname = "genvalidity-hspec-aeson";
+       version = "1.0.0.0";
+       sha256 = "18ga4g62z0fwkxbr2390dbmhpxpzczgz923gq0vvhnvc34r1vjh6";
+       libraryHaskellDepends = [
+         aeson base bytestring deepseq genvalidity genvalidity-hspec hspec
+         QuickCheck
+       ];
+       testHaskellDepends = [
+         aeson base genvalidity genvalidity-aeson genvalidity-hspec
+         genvalidity-property genvalidity-text hspec QuickCheck text
+         validity
+       ];
+       description = "Standard spec's for aeson-related instances";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-hspec-binary" = callPackage
     ({ mkDerivation, base, binary, deepseq, genvalidity
      , genvalidity-hspec, genvalidity-property, hspec, QuickCheck
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-hspec-binary_1_0_0_0" = callPackage
+    ({ mkDerivation, base, binary, deepseq, genvalidity
+     , genvalidity-hspec, genvalidity-property, hspec, QuickCheck
+     , validity
+     }:
+     mkDerivation {
+       pname = "genvalidity-hspec-binary";
+       version = "1.0.0.0";
+       sha256 = "08avm7kdx6y90mmms5hdq4xryg5jdca6bqfhzy9wrkr79q2jv4vc";
+       libraryHaskellDepends = [
+         base binary deepseq genvalidity genvalidity-hspec hspec QuickCheck
+       ];
+       testHaskellDepends = [
+         base binary genvalidity genvalidity-property hspec validity
+       ];
+       description = "Standard spec's for binary-related Instances";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-hspec-cereal" = callPackage
     ({ mkDerivation, base, cereal, deepseq, genvalidity
      , genvalidity-hspec, genvalidity-property, hspec, QuickCheck
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-hspec-cereal_1_0_0_0" = callPackage
+    ({ mkDerivation, base, cereal, deepseq, genvalidity
+     , genvalidity-hspec, genvalidity-property, hspec, QuickCheck
+     , validity
+     }:
+     mkDerivation {
+       pname = "genvalidity-hspec-cereal";
+       version = "1.0.0.0";
+       sha256 = "1cj5jcgjyjf8ib7h8ldkjfwgdq4wzk7xkmxlmyyi37iscjpv32ni";
+       libraryHaskellDepends = [
+         base cereal deepseq genvalidity genvalidity-hspec hspec QuickCheck
+       ];
+       testHaskellDepends = [
+         base cereal genvalidity genvalidity-property hspec QuickCheck
+         validity
+       ];
+       description = "Standard spec's for cereal-related instances";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-hspec-hashable" = callPackage
     ({ mkDerivation, base, genvalidity, genvalidity-hspec
      , genvalidity-property, hashable, hspec, hspec-core, QuickCheck
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-hspec-hashable_1_0_0_0" = callPackage
+    ({ mkDerivation, base, genvalidity, genvalidity-hspec
+     , genvalidity-property, hashable, hspec, hspec-core, QuickCheck
+     , validity
+     }:
+     mkDerivation {
+       pname = "genvalidity-hspec-hashable";
+       version = "1.0.0.0";
+       sha256 = "14fg796iivlpp4gqsmma9zf0z9iqk524ydyqmza83qrjh8v2ff5v";
+       libraryHaskellDepends = [
+         base genvalidity genvalidity-hspec genvalidity-property hashable
+         hspec QuickCheck validity
+       ];
+       testHaskellDepends = [
+         base genvalidity genvalidity-hspec genvalidity-property hashable
+         hspec hspec-core QuickCheck validity
+       ];
+       description = "Standard spec's for Hashable instances";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-hspec-optics" = callPackage
     ({ mkDerivation, base, genvalidity, genvalidity-hspec
      , genvalidity-property, hspec, microlens, QuickCheck, validity
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-hspec-optics_1_0_0_0" = callPackage
+    ({ mkDerivation, base, genvalidity, genvalidity-hspec
+     , genvalidity-property, hspec, microlens, QuickCheck, validity
+     }:
+     mkDerivation {
+       pname = "genvalidity-hspec-optics";
+       version = "1.0.0.0";
+       sha256 = "1bhhhihk4r8q78l35dm4gm8kf5mjzpynawbcq9vzpq3ny9h7bxmr";
+       libraryHaskellDepends = [
+         base genvalidity genvalidity-hspec hspec microlens QuickCheck
+       ];
+       testHaskellDepends = [
+         base genvalidity genvalidity-hspec genvalidity-property hspec
+         microlens validity
+       ];
+       description = "Standard spec's for lens";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-hspec-persistent" = callPackage
     ({ mkDerivation, base, genvalidity, genvalidity-hspec
      , genvalidity-property, genvalidity-text, hspec, persistent
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-hspec-persistent_1_0_0_0" = callPackage
+    ({ mkDerivation, base, genvalidity, genvalidity-hspec
+     , genvalidity-property, genvalidity-text, hspec, persistent
+     , QuickCheck, text, validity
+     }:
+     mkDerivation {
+       pname = "genvalidity-hspec-persistent";
+       version = "1.0.0.0";
+       sha256 = "131k8yibypaqb4pbwrm0ql6h2ywqchlm2w0rzmax9ylzg71vkm0z";
+       libraryHaskellDepends = [
+         base genvalidity genvalidity-hspec hspec persistent QuickCheck text
+       ];
+       testHaskellDepends = [
+         base genvalidity genvalidity-hspec genvalidity-property
+         genvalidity-text hspec persistent QuickCheck text validity
+       ];
+       description = "Standard spec's for persistent-related instances";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-mergeful" = callPackage
     ({ mkDerivation, base, containers, criterion, genvalidity
      , genvalidity-containers, genvalidity-criterion, genvalidity-hspec
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-mergeful_0_3_0_0" = callPackage
+    ({ mkDerivation, base, containers, criterion, genvalidity
+     , genvalidity-containers, genvalidity-criterion, genvalidity-hspec
+     , genvalidity-hspec-aeson, genvalidity-time, genvalidity-uuid
+     , hspec, mergeful, mtl, pretty-show, QuickCheck, random, time, uuid
+     }:
+     mkDerivation {
+       pname = "genvalidity-mergeful";
+       version = "0.3.0.0";
+       sha256 = "0dd22kdlydhdns86awmmzbnr9bwrb84623zcyb5b9aaxmq75ifza";
+       libraryHaskellDepends = [
+         base containers genvalidity genvalidity-containers genvalidity-time
+         mergeful QuickCheck
+       ];
+       testHaskellDepends = [
+         base containers genvalidity-hspec genvalidity-hspec-aeson
+         genvalidity-uuid hspec mergeful mtl pretty-show QuickCheck random
+         time uuid
+       ];
+       benchmarkHaskellDepends = [
+         base criterion genvalidity-criterion mergeful
+       ];
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-mergeless" = callPackage
     ({ mkDerivation, base, containers, criterion, genvalidity
      , genvalidity-containers, genvalidity-criterion, genvalidity-hspec
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-mergeless_0_3_0_0" = callPackage
+    ({ mkDerivation, base, containers, criterion, genvalidity
+     , genvalidity-containers, genvalidity-criterion, genvalidity-hspec
+     , genvalidity-hspec-aeson, genvalidity-time, genvalidity-uuid
+     , hspec, mergeless, mtl, pretty-show, QuickCheck, random, time
+     , uuid
+     }:
+     mkDerivation {
+       pname = "genvalidity-mergeless";
+       version = "0.3.0.0";
+       sha256 = "1glz1w7mpbwpn800khqd2jzigs19k6y0bxx7cid2zvzwrnhz6prl";
+       libraryHaskellDepends = [
+         base containers genvalidity genvalidity-containers genvalidity-time
+         mergeless QuickCheck
+       ];
+       testHaskellDepends = [
+         base containers genvalidity-hspec genvalidity-hspec-aeson
+         genvalidity-uuid hspec mergeless mtl pretty-show QuickCheck random
+         time uuid
+       ];
+       benchmarkHaskellDepends = [
+         base criterion genvalidity-criterion mergeless
+       ];
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-path" = callPackage
     ({ mkDerivation, base, criterion, genvalidity
      , genvalidity-criterion, genvalidity-hspec, hspec, path, QuickCheck
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-path_1_0_0_0" = callPackage
+    ({ mkDerivation, base, criterion, genvalidity
+     , genvalidity-criterion, genvalidity-hspec, hspec, path, QuickCheck
+     , validity-path
+     }:
+     mkDerivation {
+       pname = "genvalidity-path";
+       version = "1.0.0.0";
+       sha256 = "172gss10xl274s95l3ywgra32ldnl2a4gicc1xgi5q7v5zmj5gaa";
+       libraryHaskellDepends = [
+         base genvalidity path QuickCheck validity-path
+       ];
+       testHaskellDepends = [ base genvalidity-hspec hspec path ];
+       benchmarkHaskellDepends = [
+         base criterion genvalidity genvalidity-criterion path QuickCheck
+       ];
+       description = "GenValidity support for Path";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-persistent" = callPackage
     ({ mkDerivation, base, containers, criterion, deepseq, genvalidity
      , genvalidity-containers, genvalidity-criterion, genvalidity-hspec
···
        broken = true;
      }) {};
 
+  "genvalidity-persistent_1_0_0_0" = callPackage
+    ({ mkDerivation, base, containers, criterion, deepseq, genvalidity
+     , genvalidity-containers, genvalidity-criterion, genvalidity-hspec
+     , hspec, persistent, persistent-template, QuickCheck
+     , validity-containers, validity-persistent
+     }:
+     mkDerivation {
+       pname = "genvalidity-persistent";
+       version = "1.0.0.0";
+       sha256 = "0a03vgsi5px45838q6a4b4yckf7djdy3xwd4g85b2ik3psv9vgl9";
+       libraryHaskellDepends = [
+         base containers genvalidity genvalidity-containers persistent
+         QuickCheck validity-containers validity-persistent
+       ];
+       testHaskellDepends = [
+         base genvalidity genvalidity-hspec hspec persistent
+         persistent-template QuickCheck validity-containers
+       ];
+       benchmarkHaskellDepends = [
+         base criterion deepseq genvalidity genvalidity-criterion persistent
+         persistent-template
+       ];
+       description = "GenValidity support for Persistent";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "genvalidity-property" = callPackage
     ({ mkDerivation, base, directory, doctest, filepath, genvalidity
      , hspec, pretty-show, QuickCheck, validity
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-property_1_0_0_0" = callPackage
+    ({ mkDerivation, base, genvalidity, hspec, pretty-show, QuickCheck
+     , validity
+     }:
+     mkDerivation {
+       pname = "genvalidity-property";
+       version = "1.0.0.0";
+       sha256 = "1nxcdq04rkckrb3v49pjx378n5s828k24x7hix6manyxqmd3hplw";
+       libraryHaskellDepends = [
+         base genvalidity hspec pretty-show QuickCheck validity
+       ];
+       testHaskellDepends = [ base genvalidity hspec QuickCheck ];
+       description = "Standard properties for functions on `Validity` types";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-scientific" = callPackage
     ({ mkDerivation, base, genvalidity, genvalidity-hspec, hspec
      , QuickCheck, scientific, validity, validity-scientific
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-scientific_1_0_0_0" = callPackage
+    ({ mkDerivation, base, genvalidity, genvalidity-hspec, hspec
+     , QuickCheck, scientific, validity, validity-scientific
+     }:
+     mkDerivation {
+       pname = "genvalidity-scientific";
+       version = "1.0.0.0";
+       sha256 = "0xi1a1jsby1dqv50lmpp98x2y5j9vaf3sl38spv5bnafyp1i6pmq";
+       libraryHaskellDepends = [
+         base genvalidity QuickCheck scientific validity validity-scientific
+       ];
+       testHaskellDepends = [
+         base genvalidity genvalidity-hspec hspec QuickCheck scientific
+       ];
+       description = "GenValidity support for Scientific";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-sydtest" = callPackage
     ({ mkDerivation, base, genvalidity, pretty-show, QuickCheck
      , sydtest, sydtest-discover, validity
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-sydtest_1_0_0_0" = callPackage
+    ({ mkDerivation, base, genvalidity, pretty-show, QuickCheck
+     , sydtest, sydtest-discover, validity
+     }:
+     mkDerivation {
+       pname = "genvalidity-sydtest";
+       version = "1.0.0.0";
+       sha256 = "11v66s8srcfigb4jkvz7nm0ynczg8mdslw4vn98qyv2j85sp6l45";
+       libraryHaskellDepends = [
+         base genvalidity pretty-show QuickCheck sydtest validity
+       ];
+       testHaskellDepends = [ base genvalidity QuickCheck sydtest ];
+       testToolDepends = [ sydtest-discover ];
+       description = "Standard properties for functions on `Validity` types for the sydtest framework";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-sydtest-aeson" = callPackage
     ({ mkDerivation, aeson, base, bytestring, deepseq, genvalidity
      , genvalidity-aeson, genvalidity-sydtest, genvalidity-text
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-sydtest-aeson_1_0_0_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, deepseq, genvalidity
+     , genvalidity-aeson, genvalidity-sydtest, genvalidity-text
+     , QuickCheck, sydtest, sydtest-discover, text, validity
+     }:
+     mkDerivation {
+       pname = "genvalidity-sydtest-aeson";
+       version = "1.0.0.0";
+       sha256 = "1n8n07h5v7gwpfrfd8f4jir3d2331licmv78ih0i0qxwr87grv02";
+       libraryHaskellDepends = [
+         aeson base bytestring deepseq genvalidity genvalidity-sydtest
+         QuickCheck sydtest
+       ];
+       testHaskellDepends = [
+         aeson base genvalidity genvalidity-aeson genvalidity-sydtest
+         genvalidity-text QuickCheck sydtest text validity
+       ];
+       testToolDepends = [ sydtest-discover ];
+       description = "Standard spec's for aeson-related instances in sydtest";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-sydtest-hashable" = callPackage
     ({ mkDerivation, base, genvalidity, genvalidity-sydtest, hashable
      , QuickCheck, sydtest, sydtest-discover, validity
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-sydtest-hashable_1_0_0_0" = callPackage
+    ({ mkDerivation, base, genvalidity, genvalidity-sydtest, hashable
+     , QuickCheck, sydtest, sydtest-discover, validity
+     }:
+     mkDerivation {
+       pname = "genvalidity-sydtest-hashable";
+       version = "1.0.0.0";
+       sha256 = "05482ynm19k9wj0hvvlfimvdng1wkl35409lp1r6vj02b7ml4i2z";
+       libraryHaskellDepends = [
+         base genvalidity genvalidity-sydtest hashable QuickCheck sydtest
+         validity
+       ];
+       testHaskellDepends = [
+         base genvalidity genvalidity-sydtest hashable QuickCheck sydtest
+         validity
+       ];
+       testToolDepends = [ sydtest-discover ];
+       description = "Standard spec's for Hashable instances for sydtest";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-sydtest-lens" = callPackage
     ({ mkDerivation, base, genvalidity, genvalidity-sydtest, microlens
      , QuickCheck, sydtest, sydtest-discover, validity
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-sydtest-lens_1_0_0_0" = callPackage
+    ({ mkDerivation, base, genvalidity, genvalidity-sydtest, microlens
+     , QuickCheck, sydtest, sydtest-discover, validity
+     }:
+     mkDerivation {
+       pname = "genvalidity-sydtest-lens";
+       version = "1.0.0.0";
+       sha256 = "0yvgbyhbf8mbqy6hil8g1zk1l0zgjnrw3y3cydnqvvbvka5h7jm9";
+       libraryHaskellDepends = [
+         base genvalidity genvalidity-sydtest microlens QuickCheck sydtest
+       ];
+       testHaskellDepends = [
+         base genvalidity genvalidity-sydtest microlens sydtest validity
+       ];
+       testToolDepends = [ sydtest-discover ];
+       description = "Standard spec's for lens for sydtest";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-sydtest-persistent" = callPackage
     ({ mkDerivation, base, genvalidity, genvalidity-sydtest
      , genvalidity-text, persistent, QuickCheck, sydtest
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-sydtest-persistent_1_0_0_0" = callPackage
+    ({ mkDerivation, base, genvalidity, genvalidity-sydtest
+     , genvalidity-text, persistent, QuickCheck, sydtest
+     , sydtest-discover, text, validity
+     }:
+     mkDerivation {
+       pname = "genvalidity-sydtest-persistent";
+       version = "1.0.0.0";
+       sha256 = "1njjwl9x7kirvzxpqpdw5gzfba1ixxx8z3ji3yn3fvhm8rkswfyp";
+       libraryHaskellDepends = [
+         base genvalidity genvalidity-sydtest persistent QuickCheck sydtest
+         text
+       ];
+       testHaskellDepends = [
+         base genvalidity genvalidity-sydtest genvalidity-text persistent
+         QuickCheck sydtest text validity
+       ];
+       testToolDepends = [ sydtest-discover ];
+       description = "Standard spec's for persistent-related instances for sydtest";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-text" = callPackage
     ({ mkDerivation, array, base, criterion, genvalidity
      , genvalidity-criterion, genvalidity-hspec, hspec, QuickCheck
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-text_1_0_0_0" = callPackage
+    ({ mkDerivation, array, base, criterion, genvalidity
+     , genvalidity-criterion, genvalidity-hspec, hspec, QuickCheck
+     , random, text, validity, validity-text
+     }:
+     mkDerivation {
+       pname = "genvalidity-text";
+       version = "1.0.0.0";
+       sha256 = "1gr5wqp2rph212hz60kk94wp14p7pwrhay8vlg2b8g40ixai8qw6";
+       libraryHaskellDepends = [
+         array base genvalidity QuickCheck random text validity
+         validity-text
+       ];
+       testHaskellDepends = [
+         base genvalidity genvalidity-hspec hspec QuickCheck text
+       ];
+       benchmarkHaskellDepends = [
+         base criterion genvalidity genvalidity-criterion QuickCheck text
+       ];
+       description = "GenValidity support for Text";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-time" = callPackage
     ({ mkDerivation, base, criterion, genvalidity
      , genvalidity-criterion, genvalidity-hspec, hspec, QuickCheck, time
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-time_1_0_0_0" = callPackage
+    ({ mkDerivation, base, criterion, genvalidity
+     , genvalidity-criterion, genvalidity-hspec, hspec, QuickCheck, time
+     , validity-time
+     }:
+     mkDerivation {
+       pname = "genvalidity-time";
+       version = "1.0.0.0";
+       sha256 = "15xj7x915524h0hi9b6c7y6imwkv3g7b10cr7wx8yaysh5d1cx7r";
+       libraryHaskellDepends = [
+         base genvalidity QuickCheck time validity-time
+       ];
+       testHaskellDepends = [ base genvalidity-hspec hspec time ];
+       benchmarkHaskellDepends = [
+         base criterion genvalidity-criterion time
+       ];
+       description = "GenValidity support for time";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-typed-uuid" = callPackage
     ({ mkDerivation, base, criterion, genvalidity
      , genvalidity-criterion, genvalidity-hspec, genvalidity-hspec-aeson
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-typed-uuid_0_1_0_1" = callPackage
+    ({ mkDerivation, base, criterion, genvalidity
+     , genvalidity-criterion, genvalidity-hspec, genvalidity-hspec-aeson
+     , genvalidity-uuid, hspec, QuickCheck, typed-uuid
+     }:
+     mkDerivation {
+       pname = "genvalidity-typed-uuid";
+       version = "0.1.0.1";
+       sha256 = "18lfvw9slpgpng80mcj7mh7pfpl4xdyn9cfydafb7yq5lyr1vkym";
+       libraryHaskellDepends = [
+         base genvalidity genvalidity-uuid QuickCheck typed-uuid
+       ];
+       testHaskellDepends = [
+         base genvalidity genvalidity-hspec genvalidity-hspec-aeson
+         genvalidity-uuid hspec QuickCheck typed-uuid
+       ];
+       benchmarkHaskellDepends = [
+         base criterion genvalidity genvalidity-criterion genvalidity-uuid
+         QuickCheck typed-uuid
+       ];
+       description = "Generators for Phantom-Typed version of UUID";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-unordered-containers" = callPackage
     ({ mkDerivation, base, genvalidity, genvalidity-hspec, hashable
      , hspec, QuickCheck, unordered-containers, validity
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-unordered-containers_1_0_0_0" = callPackage
+    ({ mkDerivation, base, genvalidity, genvalidity-hspec, hashable
+     , hspec, QuickCheck, unordered-containers, validity
+     , validity-unordered-containers
+     }:
+     mkDerivation {
+       pname = "genvalidity-unordered-containers";
+       version = "1.0.0.0";
+       sha256 = "1sd67x2kw7l0kbsaa67x3an94sv1hvnkbb8r42v36cc5jjaw29dk";
+       libraryHaskellDepends = [
+         base genvalidity hashable QuickCheck unordered-containers validity
+         validity-unordered-containers
+       ];
+       testHaskellDepends = [
+         base genvalidity genvalidity-hspec hspec unordered-containers
+         validity
+       ];
+       description = "GenValidity support for unordered-containers";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-uuid" = callPackage
     ({ mkDerivation, base, criterion, genvalidity
      , genvalidity-criterion, genvalidity-hspec, hspec, QuickCheck, uuid
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-uuid_1_0_0_0" = callPackage
+    ({ mkDerivation, base, criterion, genvalidity
+     , genvalidity-criterion, genvalidity-hspec, hspec, QuickCheck, uuid
+     , validity, validity-uuid
+     }:
+     mkDerivation {
+       pname = "genvalidity-uuid";
+       version = "1.0.0.0";
+       sha256 = "1w53ziz3zbm4dv64gr60md5riis28bi3lrznzsrjyvd6nngxx460";
+       libraryHaskellDepends = [
+         base genvalidity QuickCheck uuid validity validity-uuid
+       ];
+       testHaskellDepends = [
+         base genvalidity genvalidity-hspec hspec QuickCheck uuid
+       ];
+       benchmarkHaskellDepends = [
+         base criterion genvalidity genvalidity-criterion QuickCheck uuid
+       ];
+       description = "GenValidity support for UUID";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-vector" = callPackage
     ({ mkDerivation, base, genvalidity, genvalidity-hspec, hspec
      , QuickCheck, validity, validity-vector, vector
···
        ];
        description = "GenValidity support for vector";
        license = lib.licenses.mit;
+     }) {};
+
+  "genvalidity-vector_1_0_0_0" = callPackage
+    ({ mkDerivation, base, genvalidity, genvalidity-hspec, hspec
+     , QuickCheck, validity, validity-vector, vector
+     }:
+     mkDerivation {
+       pname = "genvalidity-vector";
+       version = "1.0.0.0";
+       sha256 = "1l2zjbfjg05xxxgn359zfj93yx26zcz9xlayw2jf9brwv8wx23gy";
+       libraryHaskellDepends = [
+         base genvalidity QuickCheck validity validity-vector vector
+       ];
+       testHaskellDepends = [
+         base genvalidity genvalidity-hspec hspec vector
+       ];
+       description = "GenValidity support for vector";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "geo-resolver" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "ghc-events_0_17_0_1" = callPackage
+    ({ mkDerivation, array, base, binary, bytestring, containers, text
+     , vector
+     }:
+     mkDerivation {
+       pname = "ghc-events";
+       version = "0.17.0.1";
+       sha256 = "1jbfl8wprbrc1pwiw2dv70add9pssqrfllhn1zgic1vks15q37sr";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         array base binary bytestring containers text vector
+       ];
+       executableHaskellDepends = [ base containers ];
+       testHaskellDepends = [ base ];
+       description = "Library and tool for parsing .eventlog files from GHC";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ghc-events-analyze" = callPackage
     ({ mkDerivation, base, blaze-svg, bytestring, containers
      , diagrams-lib, diagrams-svg, filepath, ghc-events, hashable, lens
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "ghc-exactprint_1_2_0" = callPackage
+  "ghc-exactprint_1_3_0" = callPackage
     ({ mkDerivation }:
      mkDerivation {
        pname = "ghc-exactprint";
-       version = "1.2.0";
-       sha256 = "0dxjhw7vqd7grhghwz5zcjfb7bm5sa9mq0iqsr9vsz4vxxlfyi4k";
+       version = "1.3.0";
+       sha256 = "012ka8qxc340sijbn6sgwdpzdkk07kpbs6i8b71kwnpk5k5ahqdl";
        isLibrary = true;
        isExecutable = true;
        description = "ExactPrint for GHC";
···
      }:
      mkDerivation {
        pname = "ghc-heap-view";
-       version = "0.6.2";
-       sha256 = "1wj11g24zap7r2xvp46dir54hwyki025xnkgymc73224lisc3134";
+       version = "0.6.3";
+       sha256 = "1pwla6985y7kh98rpzl1wrcqcn6w47qaaviyd9vcpkwhgvv62zij";
        enableSeparateDataOutput = true;
        setupHaskellDepends = [ base Cabal filepath ];
        libraryHaskellDepends = [
···
        pname = "ghc-tags";
        version = "1.3";
        sha256 = "1fshj5zdnhr879c9q48mb89f1fidc2skgmgi385sa5r8wxn1ili0";
+       revision = "1";
+       editedCabalFile = "000haj96zlg110hxi1hi9vpcyg8w4xkm24d1xbcccn71grvhig5i";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "ghcide";
-       version = "1.5.0";
-       sha256 = "16l6fpi6xl9ddifais4phwri4hdk1f95rvi4lqgdyzi0y6ms98zx";
+       version = "1.5.0.1";
+       sha256 = "0z6fq9p6wikcgacnqg8brq0bkphd14h7g5absw53ya047vgp02gc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "gi-cairo-connector";
-       version = "0.1.0";
-       sha256 = "115iy6sd77aabzghdmfpn5w2zqqalrxgbs5i93z49y3vz4wsjiwf";
+       version = "0.1.1";
+       sha256 = "0jkca1x0dlyfwyywn6gmsnxhyad3j7vfwa0c4hpvx8k8m350dn3c";
        libraryHaskellDepends = [
          base gi-cairo gi-cairo-render haskell-gi-base mtl
        ];
···
      }:
      mkDerivation {
        pname = "gi-cairo-render";
-       version = "0.1.0";
-       sha256 = "1b2qxfahs4w288i6w5m0rs74amnm3zp0mj2vsccf34q437yni2gx";
+       version = "0.1.1";
+       sha256 = "09gxykx633xvwcqx1cjl9kj2748jdq49ayy6z5p3hz7bxqlna952";
        libraryHaskellDepends = [
          array base bytestring haskell-gi-base mtl text utf8-string
        ];
···
      }:
      mkDerivation {
        pname = "gi-gtk-hs";
-       version = "0.3.10";
-       sha256 = "00vhnkblvvq7qjs65rmfy0q2rs388954p6yd1lga2y79lc2xr6fw";
-       libraryHaskellDepends = [
-         base base-compat containers gi-gdk gi-gdkpixbuf gi-glib gi-gobject
-         gi-gtk haskell-gi-base mtl text transformers
-       ];
-       description = "A wrapper for gi-gtk, adding a few more idiomatic API parts on top";
-       license = lib.licenses.lgpl21Only;
-     }) {};
-
-  "gi-gtk-hs_0_3_11" = callPackage
-    ({ mkDerivation, base, base-compat, containers, gi-gdk
-     , gi-gdkpixbuf, gi-glib, gi-gobject, gi-gtk, haskell-gi-base, mtl
-     , text, transformers
-     }:
-     mkDerivation {
-       pname = "gi-gtk-hs";
        version = "0.3.11";
        sha256 = "0scbipy7086pv1xc57vmq48wcx3p7wbznwjcn99dqw4gf9yrqwwz";
        libraryHaskellDepends = [
···
        ];
        description = "A wrapper for gi-gtk, adding a few more idiomatic API parts on top";
        license = lib.licenses.lgpl21Only;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gi-gtk-layer-shell" = callPackage
···
      }:
      mkDerivation {
        pname = "git-annex";
-       version = "8.20211117";
-       sha256 = "0kcgjj8q6mhrbxj3m4dyha3yv1sw72lhf9bsv1bbwvm729hy9lpd";
+       version = "8.20211123";
+       sha256 = "0i9dhh601axv0b1i56yzn6jnfp160z530fp9pd557kpq4nbvg5kl";
        configureFlags = [
          "-fassistant" "-f-benchmark" "-fdbus" "-f-debuglocks" "-fmagicmime"
          "-fnetworkbsd" "-fpairing" "-fproduction" "-fs3" "-ftorrentparser"
···
        pname = "github-rest";
        version = "1.1.1";
        sha256 = "1wf4gs3324h4pfal5qcpb65lfpm4kpmxmv4fiv6asrvhas9cwglm";
+       revision = "1";
+       editedCabalFile = "0xk5xkl4zcymcms6fybngkj9xj6pwi01vz4yklpjs21f9iyccljv";
        libraryHaskellDepends = [
          aeson base bytestring http-client http-client-tls http-types jwt
          mtl scientific text time transformers unliftio unliftio-core
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "gothic_0_1_8" = callPackage
+    ({ mkDerivation, aeson, base, binary, bytestring, connection
+     , exceptions, hashable, http-client, http-client-tls, http-conduit
+     , http-types, lens, lens-aeson, scientific, text, unix
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "gothic";
+       version = "0.1.8";
+       sha256 = "1gicw2g86xz68a8qvj0p2nxw42rwibr0qqi53nily5yvlc40v4qd";
+       libraryHaskellDepends = [
+         aeson base binary bytestring connection exceptions hashable
+         http-client http-client-tls http-conduit http-types lens lens-aeson
+         scientific text unix unordered-containers vector
+       ];
+       description = "A Haskell Vault KVv2 secret engine client";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "gotta-go-fast" = callPackage
     ({ mkDerivation, base, brick, cmdargs, directory, file-embed
      , random, split, text, time, vty, word-wrap
···
        pname = "hOpenPGP";
        version = "2.9.5";
        sha256 = "1wzvlk7my7a8rwmsw1glw2dlph3b2hwyz2jkcjr0hd1jj8ywksnx";
+       revision = "1";
+       editedCabalFile = "0zislyrgjdnxzrk8hnlby19cb7v14rcr1xk9jj6hpi1b7vrks8q9";
        libraryHaskellDepends = [
          aeson asn1-encoding attoparsec base base16-bytestring bifunctors
          binary binary-conduit bytestring bz2 conduit conduit-extra
···
        ];
        description = "native Haskell implementation of OpenPGP (RFC4880)";
        license = lib.licenses.mit;
+     }) {};
+
+  "hOpenPGP_2_9_7" = callPackage
+    ({ mkDerivation, aeson, asn1-encoding, attoparsec, base
+     , base16-bytestring, bifunctors, binary, binary-conduit, bytestring
+     , bz2, conduit, conduit-extra, containers, criterion
+     , crypto-cipher-types, cryptonite, errors, hashable
+     , incremental-parser, ixset-typed, lens, memory, monad-loops
+     , nettle, network-uri, openpgp-asciiarmor, prettyprinter
+     , QuickCheck, quickcheck-instances, resourcet, split, tasty
+     , tasty-hunit, tasty-quickcheck, text, time, time-locale-compat
+     , transformers, unliftio-core, unordered-containers, zlib
+     }:
+     mkDerivation {
+       pname = "hOpenPGP";
+       version = "2.9.7";
+       sha256 = "1fix387wi8fqdav4zzczc3dyzcwrnb4zvpq72prs5cs7sc609w3z";
+       libraryHaskellDepends = [
+         aeson asn1-encoding attoparsec base base16-bytestring bifunctors
+         binary binary-conduit bytestring bz2 conduit conduit-extra
+         containers crypto-cipher-types cryptonite errors hashable
+         incremental-parser ixset-typed lens memory monad-loops nettle
+         network-uri openpgp-asciiarmor prettyprinter resourcet split text
+         time time-locale-compat transformers unliftio-core
+         unordered-containers zlib
+       ];
+       testHaskellDepends = [
+         aeson attoparsec base base16-bytestring bifunctors binary
+         binary-conduit bytestring bz2 conduit conduit-extra containers
+         crypto-cipher-types cryptonite errors hashable incremental-parser
+         ixset-typed lens memory monad-loops nettle network-uri
+         prettyprinter QuickCheck quickcheck-instances resourcet split tasty
+         tasty-hunit tasty-quickcheck text time time-locale-compat
+         transformers unliftio-core unordered-containers zlib
+       ];
+       benchmarkHaskellDepends = [
+         aeson attoparsec base base16-bytestring bifunctors binary
+         binary-conduit bytestring bz2 conduit conduit-extra containers
+         criterion crypto-cipher-types cryptonite errors hashable
+         incremental-parser ixset-typed lens memory monad-loops nettle
+         network-uri prettyprinter resourcet split text time
+         time-locale-compat transformers unliftio-core unordered-containers
+         zlib
+       ];
+       description = "native Haskell implementation of OpenPGP (RFC4880)";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hPDB" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "hashable_1_4_0_0" = callPackage
+  "hashable_1_4_0_1" = callPackage
     ({ mkDerivation, base, base-orphans, bytestring, containers
      , deepseq, ghc-prim, HUnit, integer-gmp, QuickCheck, random
      , test-framework, test-framework-hunit, test-framework-quickcheck2
···
      }:
      mkDerivation {
        pname = "hashable";
-       version = "1.4.0.0";
-       sha256 = "0zg5fvr6561r6nzyqsirxcsyjc2rcr07snv2gl9vxp3dks44gbx1";
+       version = "1.4.0.1";
+       sha256 = "04v61w87hvm6lg9a7p5mz177iab3rvb86pzcclcdw0w314dsxpaw";
        libraryHaskellDepends = [
          base base-orphans bytestring containers deepseq ghc-prim
          integer-gmp text
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "hashtables_1_3" = callPackage
+    ({ mkDerivation, base, ghc-prim, hashable, HUnit, mwc-random
+     , primitive, QuickCheck, test-framework, test-framework-hunit
+     , test-framework-quickcheck2, vector
+     }:
+     mkDerivation {
+       pname = "hashtables";
+       version = "1.3";
+       sha256 = "1lqdz4hp6lrzi37f6d2448dmk8jpv56igv5h0kcbnbl42dnmly5g";
+       libraryHaskellDepends = [
+         base ghc-prim hashable primitive vector
+       ];
+       testHaskellDepends = [
+         base ghc-prim hashable HUnit mwc-random primitive QuickCheck
+         test-framework test-framework-hunit test-framework-quickcheck2
+         vector
+       ];
+       description = "Mutable hash tables in the ST monad";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hashtables-plus" = callPackage
     ({ mkDerivation, base, criterion-plus, deepseq, hashable
      , hashtables, lens, loch-th, mtl, mwc-random, placeholders
···
      }:
      mkDerivation {
        pname = "haskell-language-server";
-       version = "1.5.0.0";
-       sha256 = "1jzak20xdbbq4pdiwx7w6znp6hc3j0sbcfv5h7x7l4rwzsckjhv7";
+       version = "1.5.1.0";
+       sha256 = "0aixq570sbrg9nnhaxlj8lv3k1dskbz53iwp5c1ljgrlmsz786ky";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "haskoin-core" = callPackage
-    ({ mkDerivation, aeson, array, base, base16, binary, bytes
+    ({ mkDerivation, aeson, array, base, base16, base64, binary, bytes
      , bytestring, cereal, conduit, containers, cryptonite, deepseq
      , entropy, hashable, hspec, hspec-discover, HUnit, lens, lens-aeson
      , memory, mtl, murmur3, network, QuickCheck, safe, scientific
···
      }:
      mkDerivation {
        pname = "haskoin-core";
-       version = "0.20.5";
-       sha256 = "1nx0m51nxm6m2nq6cdcsd8xiap7x6rr2z5ckbzga33fh73ivmkmp";
+       version = "0.21.0";
+       sha256 = "13jc15jdk2331j0rbqjqbi041rz9dl04f60xbxyjiq76hlqpaphw";
        libraryHaskellDepends = [
          aeson array base base16 binary bytes bytestring cereal conduit
          containers cryptonite deepseq entropy hashable hspec memory mtl
···
          vector
        ];
        testHaskellDepends = [
-         aeson array base base16 binary bytes bytestring cereal conduit
-         containers cryptonite deepseq entropy hashable hspec HUnit lens
-         lens-aeson memory mtl murmur3 network QuickCheck safe scientific
-         secp256k1-haskell split string-conversions text time transformers
-         unordered-containers vector
+         aeson array base base16 base64 binary bytes bytestring cereal
+         conduit containers cryptonite deepseq entropy hashable hspec HUnit
+         lens lens-aeson memory mtl murmur3 network QuickCheck safe
+         scientific secp256k1-haskell split string-conversions text time
+         transformers unordered-containers vector
        ];
        testToolDepends = [ hspec-discover ];
        description = "Bitcoin & Bitcoin Cash library for Haskell";
···
      , optparse-applicative, QuickCheck, random, rocksdb-haskell-jprupp
      , rocksdb-query, scotty, stm, string-conversions, text, time
      , transformers, unliftio, unordered-containers, vault, wai
-     , wai-extra, warp, wreq
+     , wai-extra, wai-websockets, warp, websockets, wreq
      }:
      mkDerivation {
        pname = "haskoin-store";
-       version = "0.53.11";
-       sha256 = "0b6q74zk58chz1b9pv6rm1ipx2ss08ks4qwlyhzqgwfy5npn1x6p";
+       version = "0.61.0";
+       sha256 = "0br8xni0qi7c4zy27f3ajrpg4g6fxa9siy0hglwz8ahbhw852ylg";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          monad-control monad-logger mtl network nqe random
          rocksdb-haskell-jprupp rocksdb-query scotty stm string-conversions
          text time transformers unliftio unordered-containers vault wai
-         wai-extra warp wreq
+         wai-extra wai-websockets warp websockets wreq
        ];
        executableHaskellDepends = [
          aeson aeson-pretty base base16 bytes bytestring cereal conduit
···
          http-types lens monad-control monad-logger mtl network nqe
          optparse-applicative random rocksdb-haskell-jprupp rocksdb-query
          scotty stm string-conversions text time transformers unliftio
-         unordered-containers vault wai wai-extra warp wreq
+         unordered-containers vault wai wai-extra wai-websockets warp
+         websockets wreq
        ];
        testHaskellDepends = [
          aeson aeson-pretty base base16 base64 bytes bytestring cereal
···
          http-types lens monad-control monad-logger mtl network nqe
          QuickCheck random rocksdb-haskell-jprupp rocksdb-query scotty stm
          string-conversions text time transformers unliftio
-         unordered-containers vault wai wai-extra warp wreq
+         unordered-containers vault wai wai-extra wai-websockets warp
+         websockets wreq
        ];
        testToolDepends = [ hspec-discover ];
        description = "Storage and index for Bitcoin and Bitcoin Cash";
···
      }:
      mkDerivation {
        pname = "haskoin-store-data";
-       version = "0.53.11";
-       sha256 = "0x75vm28j8gpwan2kdy3di14myhk6gfk8wa70iys8cj43c7ds83l";
+       version = "0.61.0";
+       sha256 = "06skq0syh1wfrm36kqvp2n77i6b0cmkhijff1mclabqnhkpzdk3d";
        libraryHaskellDepends = [
          aeson base binary bytes bytestring cereal containers data-default
          deepseq hashable haskoin-core http-client http-types lens mtl
···
        pname = "hasktags";
        version = "0.72.0";
        sha256 = "09p79w16fgpqi6bwq162769xdrnyb7wnmz56k00nz6dj1a0bbbdd";
-       revision = "1";
-       editedCabalFile = "0q39ssdgm6lcmqj92frjvr53i34divx53zli0qar39mx8ka1l8ml";
+       revision = "2";
+       editedCabalFile = "0f3v6k3bvsczz0z5i09286c0i74wz782vayzyp5lndqvrx3b4g0x";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
   "instance-map" = callPackage
   "instance-map" = callPackage
   "instance-map" = callPackage
+       revision = "1";
+       editedCabalFile = "0w7960730qh8y41xa1mx4lbk288axkqa03wamh9j6pmag9axcphq";
        libraryHaskellDepends = [
   "instance-map" = callPackage
   "instance-map" = callPackage
···
   "instance-map" = callPackage
        version = "0.15.0";
   "instance-map" = callPackage
+       revision = "1";
+       editedCabalFile = "0njy7nh5r935xb0za9r0hligqy0nzwlfnzlfqcvb1frkzxissydp";
        libraryHaskellDepends = [
   "instance-map" = callPackage
   "instance-map" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "hie-bios_0_8_0" = callPackage
+    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
+  "instance-map" = callPackage
+  "instance-map" = callPackage
+  "instance-map" = callPackage
+  "instance-map" = callPackage
+  "instance-map" = callPackage
+     }:
+     mkDerivation {
+  "instance-map" = callPackage
+       version = "0.8.0";
+       sha256 = "1apy7zdafrw96f7sbhhq62hlk4blcsi4kc4kq59wcm2yvj134rvv";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+  "instance-map" = callPackage
+  "instance-map" = callPackage
+  "instance-map" = callPackage
+  "instance-map" = callPackage
+       ];
+       executableHaskellDepends = [
+  "instance-map" = callPackage
+       ];
+       testHaskellDepends = [
+         aeson base directory extra filepath ghc hspec-expectations tasty
+  "instance-map" = callPackage
+         unordered-containers yaml
+       ];
+  "instance-map" = callPackage
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "instance-map" = callPackage
     ({ mkDerivation, array, base, bytestring, containers, directory
   "instance-map" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "hint_0_9_0_5" = callPackage
+    ({ mkDerivation, base, containers, directory, exceptions, filepath
+  "instance-map" = callPackage
+     , transformers, unix
+     }:
+     mkDerivation {
+  "instance-map" = callPackage
+       version = "0.9.0.5";
+       sha256 = "1qjasjbilvrfwk8lxfw0pa0hwpsr7nn0n9yd95lwjgfnqnigzcb8";
+       libraryHaskellDepends = [
+         base containers directory exceptions filepath ghc ghc-boot
+         ghc-paths random temporary transformers unix
+       ];
+       testHaskellDepends = [
+  "instance-map" = callPackage
+       ];
+  "instance-map" = callPackage
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "instance-map" = callPackage
   "instance-map" = callPackage
      }:
···
   "instance-map" = callPackage
        version = "0.2.0.4";
   "instance-map" = callPackage
+       revision = "1";
+       editedCabalFile = "0ni726dy3a0mmqwlpqby4yhy7cdddjala1vwgaq75pgb0bmp7wr0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
-  "hledger_1_23" = callPackage
-    ({ mkDerivation, aeson, ansi-terminal, base, base-compat-batteries
-     , bytestring, cmdargs, containers, data-default, Decimal, Diff
-     , directory, extra, filepath, githash, hashable, haskeline
-     , hledger-lib, lucid, math-functions, megaparsec, microlens, mtl
-     , process, regex-tdfa, safe, shakespeare, split, tabular, tasty
-     , temporary, terminfo, text, time, timeit, transformers
-     , unordered-containers, utf8-string, utility-ht, wizards
+  "hledger_1_24" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, base, bytestring, cmdargs
+     , containers, data-default, Decimal, Diff, directory, extra
+     , filepath, githash, hashable, haskeline, hledger-lib, lucid
+     , math-functions, megaparsec, microlens, mtl, process, regex-tdfa
+     , safe, shakespeare, split, tabular, tasty, temporary, terminfo
+     , text, time, timeit, transformers, unordered-containers
+     , utf8-string, utility-ht, wizards
      }:
      mkDerivation {
        pname = "hledger";
-       version = "1.23";
-       sha256 = "0s7dbizgx6x6p5phn61ljnhjwm7alp3vgbakbd51m30asnzxm98b";
-       revision = "1";
-       editedCabalFile = "1mpl3scnif7p51clbdhak1z7ja7bky73c3a223fv1q4n8y9zxpk6";
+       version = "1.24";
+       sha256 = "19aw0q5i4i114wms063z4id08vfknz2zn1ydzbv53kykqc8h26n0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson ansi-terminal base base-compat-batteries bytestring cmdargs
-         containers data-default Decimal Diff directory extra filepath
-         githash hashable haskeline hledger-lib lucid math-functions
-         megaparsec microlens mtl process regex-tdfa safe shakespeare split
-         tabular tasty temporary terminfo text time timeit transformers
-         unordered-containers utf8-string utility-ht wizards
+         aeson ansi-terminal base bytestring cmdargs containers data-default
+         Decimal Diff directory extra filepath githash hashable haskeline
+         hledger-lib lucid math-functions megaparsec microlens mtl process
+         regex-tdfa safe shakespeare split tabular tasty temporary terminfo
+         text time timeit transformers unordered-containers utf8-string
+         utility-ht wizards
        ];
        executableHaskellDepends = [
-         aeson ansi-terminal base base-compat-batteries bytestring cmdargs
-         containers data-default Decimal directory extra filepath githash
-         haskeline hledger-lib math-functions megaparsec microlens mtl
-         process regex-tdfa safe shakespeare split tabular tasty temporary
-         terminfo text time timeit transformers unordered-containers
-         utf8-string utility-ht wizards
+         aeson ansi-terminal base bytestring cmdargs containers data-default
+         Decimal directory extra filepath githash haskeline hledger-lib
+         math-functions megaparsec microlens mtl process regex-tdfa safe
+         shakespeare split tabular tasty temporary terminfo text time timeit
+         transformers unordered-containers utf8-string utility-ht wizards
        ];
        testHaskellDepends = [
-         aeson ansi-terminal base base-compat-batteries bytestring cmdargs
-         containers data-default Decimal directory extra filepath githash
-         haskeline hledger-lib math-functions megaparsec microlens mtl
-         process regex-tdfa safe shakespeare split tabular tasty temporary
-         terminfo text time timeit transformers unordered-containers
-         utf8-string utility-ht wizards
+         aeson ansi-terminal base bytestring cmdargs containers data-default
+         Decimal directory extra filepath githash haskeline hledger-lib
+         math-functions megaparsec microlens mtl process regex-tdfa safe
+         shakespeare split tabular tasty temporary terminfo text time timeit
+         transformers unordered-containers utf8-string utility-ht wizards
        ];
        description = "Command-line interface for the hledger accounting system";
        license = lib.licenses.gpl3Only;
···
        license = lib.licenses.gpl3Only;
      }) {};
 
-  "hledger-lib_1_23" = callPackage
+  "hledger-lib_1_24" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, array, base
-     , base-compat-batteries, blaze-markup, bytestring, call-stack
-     , cassava, cassava-megaparsec, cmdargs, containers, data-default
-     , Decimal, directory, doctest, extra, file-embed, filepath, Glob
-     , hashtables, megaparsec, microlens, microlens-th, mtl
-     , parser-combinators, pretty-simple, regex-tdfa, safe, tabular
-     , tasty, tasty-hunit, template-haskell, text, time, timeit
-     , transformers, uglymemo, unordered-containers, utf8-string
+     , blaze-markup, bytestring, call-stack, cassava, cassava-megaparsec
+     , cmdargs, containers, data-default, Decimal, directory, doclayout
+     , doctest, extra, file-embed, filepath, Glob, hashtables
+     , megaparsec, microlens, microlens-th, mtl, parser-combinators
+     , pretty-simple, regex-tdfa, safe, tabular, tasty, tasty-hunit
+     , template-haskell, text, time, timeit, transformers, uglymemo
+     , unordered-containers, utf8-string
      }:
      mkDerivation {
        pname = "hledger-lib";
-       version = "1.23";
-       sha256 = "182pa9f4paqbyrqqnn8vhgwys0sk9lrkvf972d9hbvr339iysm1c";
-       revision = "1";
-       editedCabalFile = "0xrzix8fw4dyyga7pqqqdsz6bdljf5sx3l6g81iyqg5y4a9grv9h";
+       version = "1.24";
+       sha256 = "1gjqcjvcmkhwm8z0aanv93n0zglh699mnbh9a7symw06ii4yv5ll";
        libraryHaskellDepends = [
-         aeson aeson-pretty ansi-terminal array base base-compat-batteries
-         blaze-markup bytestring call-stack cassava cassava-megaparsec
-         cmdargs containers data-default Decimal directory extra file-embed
-         filepath Glob hashtables megaparsec microlens microlens-th mtl
+         aeson aeson-pretty ansi-terminal array base blaze-markup bytestring
+         call-stack cassava cassava-megaparsec cmdargs containers
+         data-default Decimal directory doclayout extra file-embed filepath
+         Glob hashtables megaparsec microlens microlens-th mtl
          parser-combinators pretty-simple regex-tdfa safe tabular tasty
          tasty-hunit template-haskell text time timeit transformers uglymemo
          unordered-containers utf8-string
        ];
        testHaskellDepends = [
-         aeson aeson-pretty ansi-terminal array base base-compat-batteries
-         blaze-markup bytestring call-stack cassava cassava-megaparsec
-         cmdargs containers data-default Decimal directory doctest extra
-         file-embed filepath Glob hashtables megaparsec microlens
-         microlens-th mtl parser-combinators pretty-simple regex-tdfa safe
-         tabular tasty tasty-hunit template-haskell text time timeit
-         transformers uglymemo unordered-containers utf8-string
+         aeson aeson-pretty ansi-terminal array base blaze-markup bytestring
+         call-stack cassava cassava-megaparsec cmdargs containers
+         data-default Decimal directory doclayout doctest extra file-embed
+         filepath Glob hashtables megaparsec microlens microlens-th mtl
+         parser-combinators pretty-simple regex-tdfa safe tabular tasty
+         tasty-hunit template-haskell text time timeit transformers uglymemo
+         unordered-containers utf8-string
        ];
        description = "A reusable library providing the core functionality of hledger";
        license = lib.licenses.gpl3Only;
···
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
-  "hledger-ui_1_23" = callPackage
-    ({ mkDerivation, ansi-terminal, async, base, base-compat-batteries
-     , brick, cmdargs, containers, data-default, directory, extra
-     , filepath, fsnotify, hledger, hledger-lib, megaparsec, microlens
+  "hledger-ui_1_24" = callPackage
+    ({ mkDerivation, ansi-terminal, async, base, brick, cmdargs
+     , containers, data-default, directory, doclayout, extra, filepath
+     , fsnotify, hledger, hledger-lib, megaparsec, microlens
      , microlens-platform, process, safe, split, text, text-zipper, time
      , transformers, unix, vector, vty
      }:
      mkDerivation {
        pname = "hledger-ui";
-       version = "1.23";
-       sha256 = "04wsp0jlrv5lmlaw38644q66mg8ga6l2ij32pqa585713zcx2frs";
-       revision = "1";
-       editedCabalFile = "1199c443hfy8pdag6h218kwi237g51b7ljy5vvswmslkc9xa37x8";
+       version = "1.24";
+       sha256 = "0a0n677f8s3397yzmfvj2686nsc90zz289lgb41qclbnz4ppcr9c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         ansi-terminal async base base-compat-batteries brick cmdargs
-         containers data-default directory extra filepath fsnotify hledger
-         hledger-lib megaparsec microlens microlens-platform process safe
-         split text text-zipper time transformers unix vector vty
+         ansi-terminal async base brick cmdargs containers data-default
+         directory doclayout extra filepath fsnotify hledger hledger-lib
+         megaparsec microlens microlens-platform process safe split text
+         text-zipper time transformers unix vector vty
        ];
        description = "Curses-style terminal interface for the hledger accounting system";
        license = lib.licenses.gpl3Only;
···
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
-  "hledger-web_1_23" = callPackage
+  "hledger-web_1_24" = callPackage
     ({ mkDerivation, aeson, base, base64, blaze-html, blaze-markup
      , bytestring, case-insensitive, clientsession, cmdargs, conduit
      , conduit-extra, containers, data-default, Decimal, directory
···
      }:
      mkDerivation {
        pname = "hledger-web";
-       version = "1.23";
-       sha256 = "0sphhmh43d2lifvx8xbvgdmfs0f8cd5zpnpzhv8dp6mzd72g44wi";
-       revision = "1";
-       editedCabalFile = "1ck8jv7hx8kzzimg9hm39h5la8im2kn4f21g7nqmzl4s7bqmmkrw";
+       version = "1.24";
+       sha256 = "0xpj6v1ks4d0m9pk6sljyx9f2vxq440bl59qn7gz0hv1lzm6zrbi";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hlrdb-core";
-       version = "0.1.6.1";
-       sha256 = "0sy87qz7v1x4rmqclfz2q8bnca2k7zyc7cgk67s80xhp4jsab90x";
-       revision = "1";
-       editedCabalFile = "1nyvgbpvr7l0b9cvnlavmc88aszvxfrdcj57grrs6dcd1d4lv7ss";
+       version = "0.1.6.2";
+       sha256 = "19pnwjlcg504kpvxq8r1hwb533adi2d919vgb1lr25c9bdyxc32n";
        libraryHaskellDepends = [
          base bytestring hashable hedis lens mtl profunctors random time
          unordered-containers
···
      }:
      mkDerivation {
        pname = "hls-class-plugin";
-       version = "1.0.1.1";
-       sha256 = "0wsg9jxm8fg3jr2wgrqz4if85w6zv4q4ink15plva9mngrhjk5na";
+       version = "1.0.1.2";
+       sha256 = "1ybg6dd3m8ynhkn80189nqc8ng2lfplk3xrq7cq4mdx4bgdnjbgq";
        libraryHaskellDepends = [
          aeson base containers ghc ghc-exactprint ghcide hls-plugin-api lens
          lsp text transformers
···
      }:
      mkDerivation {
        pname = "hls-eval-plugin";
-       version = "1.2.0.1";
-       sha256 = "0g28nirb23f2p29mbap5vkkagnnvswzz3caymig1k03y0wj0b1f0";
+       version = "1.2.0.2";
+       sha256 = "0nrlfs40hmbjjw6r01b3fcxwh01b4ap9v2ij6jyqrgkbs19qfp49";
        libraryHaskellDepends = [
          aeson base containers data-default deepseq Diff directory dlist
          extra filepath ghc ghc-boot-th ghc-paths ghcide hashable hls-graph
···
      }:
      mkDerivation {
        pname = "hls-explicit-imports-plugin";
-       version = "1.0.1.1";
-       sha256 = "06wf8crlaczx970br10svnk34isgr2yvsmla7d5b3m36w584dvrc";
+       version = "1.0.1.2";
+       sha256 = "12m0idqxx47ixyn6i03jzwp4z9xwnb5q0p0655ik03xhibwjja7d";
        libraryHaskellDepends = [
          aeson base containers deepseq ghc ghcide hls-graph hls-plugin-api
          lsp text unordered-containers
···
      }:
      mkDerivation {
        pname = "hls-fourmolu-plugin";
-       version = "1.0.1.1";
-       sha256 = "0pw5raypa6zkr2a15pjlaqsh89dg7si40rry384ch593y2cbl7bv";
+       version = "1.0.1.2";
+       sha256 = "1w7rnb18fn71aqzspq7wic0nd1qwh5r2vr9j2yiwvp95p42zxf0n";
        libraryHaskellDepends = [
          base filepath fourmolu ghc ghc-boot-th ghcide hls-plugin-api lens
          lsp text
···
      }:
      mkDerivation {
        pname = "hls-graph";
-       version = "1.5.1.0";
-       sha256 = "12aj8r531wcpjx4nh8wk73whlpv97im8sydfq8yl1xwsbx42xwac";
+       version = "1.5.1.1";
+       sha256 = "1ak6i03ch5xm6r4ym09k9vxfq7y5xwr9c6d84cgl8288g2i0fnpz";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson async base bytestring containers deepseq directory exceptions
···
      }:
      mkDerivation {
        pname = "hls-hlint-plugin";
-       version = "1.0.2.0";
-       sha256 = "19rhp1xdwbq6c6f23jpc5rw8kdrb5abb7vsg16h2y77s91g8sq41";
+       version = "1.0.2.1";
+       sha256 = "11a6gkz4af137zdg0m4bipjy2vn8bmarjd127sdrwli3vy7jzs3s";
        libraryHaskellDepends = [
          aeson apply-refact base binary bytestring containers data-default
          deepseq Diff directory extra filepath ghc ghc-exactprint ghc-lib
···
      }:
      mkDerivation {
        pname = "hls-module-name-plugin";
-       version = "1.0.0.2";
-       sha256 = "1b8rc6vr9940pvxm4ph0nlhykknxw0756b0vcskssbivwl60b6h0";
+       version = "1.0.0.3";
+       sha256 = "0nymxfwvqalmwgv3a0a5a10vk8yi6k7r3gb1yyd0iz6vkz6k10p3";
        libraryHaskellDepends = [
          aeson base directory filepath ghcide hls-plugin-api lsp text
          transformers unordered-containers
···
      }:
      mkDerivation {
        pname = "hls-ormolu-plugin";
-       version = "1.0.1.1";
-       sha256 = "1f8zx8fnjs79ajbrxid4cfj5ksza038ydi45d522l0f3mii5n7qw";
+       version = "1.0.1.2";
+       sha256 = "1kp63ydmczvjbwzkmxzd8m4fnm8yljzxraisa85sd7pagv2djh7q";
        libraryHaskellDepends = [
          base filepath ghc ghc-boot-th ghcide hls-plugin-api lens lsp ormolu
          text
···
        pname = "hls-rename-plugin";
        version = "1.0.0.0";
        sha256 = "0j13nh3fvvmj1sd11fiq9fccq23s6p7jz3m96b49kprkayx65zhh";
+       revision = "1";
+       editedCabalFile = "193q5qz563lvwm1vpfadr7cy7yxk15z2va5p9bw0xjz2x8yhc5fq";
        libraryHaskellDepends = [
          base containers extra ghc ghc-exactprint ghcide hiedb
          hls-plugin-api hls-retrie-plugin lsp lsp-types syb text
···
      }:
      mkDerivation {
        pname = "hls-retrie-plugin";
-       version = "1.0.1.3";
-       sha256 = "1wd31x38v7cllwcldwx6vybka9fqi2jlhvhl3ap6f4a88426pcx0";
+       version = "1.0.1.4";
+       sha256 = "18ldvywi8zl08xfd1z4dhj84xhxa9kq0hdminv6d3xf470ghkrdv";
        libraryHaskellDepends = [
          aeson base containers deepseq directory extra ghc ghcide hashable
          hls-plugin-api lsp lsp-types retrie safe-exceptions text
···
      }:
      mkDerivation {
        pname = "hls-splice-plugin";
-       version = "1.0.0.5";
-       sha256 = "0d5bwnfs6dyl39m03asvb0kgj48gw3sggdnin31ly7pywh4f12ns";
+       version = "1.0.0.6";
+       sha256 = "0cnm0kaimbcyrjgphz61fhs9wg4wscv8bj9c09pxxwz6npf2r3wz";
        libraryHaskellDepends = [
          aeson base containers dlist extra foldl ghc ghc-exactprint ghcide
          hls-plugin-api lens lsp retrie syb text transformers unliftio-core
···
      }:
      mkDerivation {
        pname = "hls-stylish-haskell-plugin";
-       version = "1.0.0.3";
-       sha256 = "0rd3b9kxwck3wlwrn2mp6qvmrrhmfj3a9h97fvbf4bk7rp58552h";
+       version = "1.0.0.4";
+       sha256 = "0p6cqjslf9qnb2df6dvznyzily55mcs13f0kd0x64p8kf2chc6ic";
        libraryHaskellDepends = [
          base directory filepath ghc ghc-boot-th ghcide hls-plugin-api
          lsp-types stylish-haskell text
···
      }:
      mkDerivation {
        pname = "hls-tactics-plugin";
-       version = "1.5.0.0";
-       sha256 = "0bwjkj9canxr2njjica9nbl0lmlyqvyj6ybrx2xdk533rajxbnpf";
+       version = "1.5.0.1";
+       sha256 = "1fji3m1dczswzsrvvsg00jflsq9h4jpgclyma91rcncdrl7j4ylz";
        libraryHaskellDepends = [
          aeson base containers deepseq directory extra filepath fingertree
          generic-lens ghc ghc-boot-th ghc-exactprint ghc-source-gen ghcide
···
      }:
      mkDerivation {
        pname = "hls-test-utils";
-       version = "1.1.0.1";
-       sha256 = "07nxmfld8shg2kr08j6wa4rilw301y0bhixblb2mmv9i98y7203w";
+       version = "1.1.0.2";
+       sha256 = "1506438g4bzc05f8km5kcjq8hv1sk56bllbcnjkx3fdqdamr3piv";
        libraryHaskellDepends = [
          aeson async base blaze-markup bytestring containers data-default
          directory extra filepath ghcide hls-graph hls-plugin-api hspec
···
        pname = "hoist-error";
        version = "0.2.1.0";
        sha256 = "028lczd80nhj3yj5dq9qixzdzkyisl34qpi6bb28r8b9nj2i2nss";
-       revision = "4";
-       editedCabalFile = "1xp8l236gflh5njl3s8f0d2ahqypks70pfjnawskc0fcnl818qpa";
+       revision = "5";
+       editedCabalFile = "173vmbviw39ivb1cg2c0w35m0dd32n0ki82nd6h3j8yww0pzgk5p";
        libraryHaskellDepends = [ base either mtl ];
        description = "Some convenience facilities for hoisting errors into a monad";
        license = lib.licenses.mit;
···
        license = lib.licenses.mit;
      }) {};
 
+  "hpack_0_34_6" = callPackage
+    ({ mkDerivation, aeson, base, bifunctors, bytestring, Cabal
+     , containers, cryptonite, deepseq, directory, filepath, Glob, hspec
+     , hspec-discover, http-client, http-client-tls, http-types, HUnit
+     , infer-license, interpolate, mockery, pretty, QuickCheck
+     , scientific, template-haskell, temporary, text, transformers
+     , unordered-containers, vector, yaml
+     }:
+     mkDerivation {
+       pname = "hpack";
+       version = "0.34.6";
+       sha256 = "0hmaf5j4blyav3a0r1qbdhr5hs8s88c6l7ryxi011xj7hqs4fi8w";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bifunctors bytestring Cabal containers cryptonite
+         deepseq directory filepath Glob http-client http-client-tls
+         http-types infer-license pretty scientific text transformers
+         unordered-containers vector yaml
+       ];
+       executableHaskellDepends = [
+         aeson base bifunctors bytestring Cabal containers cryptonite
+         deepseq directory filepath Glob http-client http-client-tls
+         http-types infer-license pretty scientific text transformers
+         unordered-containers vector yaml
+       ];
+       testHaskellDepends = [
+         aeson base bifunctors bytestring Cabal containers cryptonite
+         deepseq directory filepath Glob hspec http-client http-client-tls
+         http-types HUnit infer-license interpolate mockery pretty
+         QuickCheck scientific template-haskell temporary text transformers
+         unordered-containers vector yaml
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "A modern format for Haskell packages";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hpack-convert" = callPackage
     ({ mkDerivation, aeson, aeson-qq, base, base-compat, bytestring
      , Cabal, containers, deepseq, directory, filepath, Glob, hspec
···
      }:
      mkDerivation {
        pname = "hpqtypes-extras";
-       version = "1.13.0.0";
-       sha256 = "07pma23i8cy8153g3grb1jr4sasaaczlqym1jv9q5vzb03mdqcaw";
+       version = "1.13.1.0";
+       sha256 = "19d55ivy39pipal8v3anymnh5fpzms4skcxd2mgv1chpdw60n09w";
        libraryHaskellDepends = [
          base base16-bytestring bytestring containers cryptohash exceptions
          extra fields-json hpqtypes lifted-base log-base monad-control mtl
···
        license = lib.licenses.bsd3;
      }) {inherit (pkgs) ruby;};
 
+  "hruby_0_4_0_0" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, Cabal
+     , process, QuickCheck, ruby, scientific, stm, text
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "hruby";
+       version = "0.4.0.0";
+       sha256 = "0qd3mfc8mr5b0vmvfqnmjrba5abvwb4vn6mjlm0mhlgigmh685f9";
+       setupHaskellDepends = [ base Cabal process ];
+       libraryHaskellDepends = [
+         aeson attoparsec base bytestring scientific stm text
+         unordered-containers vector
+       ];
+       librarySystemDepends = [ ruby ];
+       testHaskellDepends = [
+         aeson attoparsec base QuickCheck text vector
+       ];
+       description = "Embed a Ruby intepreter in your Haskell program !";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) ruby;};
+
   "hs" = callPackage
     ({ mkDerivation, base, containers, data-default, directory
      , enum-text, filepath, fmt, optparse-applicative, possibly, text
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "hs-opentelemetry-api" = callPackage
+    ({ mkDerivation, async, attoparsec, base, binary, bytestring
+     , charset, clock, containers, ghc-prim, hashable, hspec, http-types
+     , memory, mtl, template-haskell, text, thread-utils-context
+     , unliftio-core, unordered-containers, vault, vector
+     , vector-builder
+     }:
+     mkDerivation {
+       pname = "hs-opentelemetry-api";
+       version = "0.0.1.0";
+       sha256 = "0n2x9yrrfqf1z7klfwllpl42rpi84s5kdywb3c77a9386xrf9gvw";
+       libraryHaskellDepends = [
+         async attoparsec base binary bytestring charset clock containers
+         ghc-prim hashable http-types memory mtl template-haskell text
+         thread-utils-context unliftio-core unordered-containers vault
+         vector vector-builder
+       ];
+       testHaskellDepends = [
+         async attoparsec base binary bytestring charset clock containers
+         ghc-prim hashable hspec http-types memory mtl template-haskell text
+         thread-utils-context unliftio-core unordered-containers vault
+         vector vector-builder
+       ];
+       description = "OpenTelemetry API for use by libraries for direct instrumentation or wrapper packages";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "hs-opentelemetry-exporter-in-memory" = callPackage
+    ({ mkDerivation, async, base, hs-opentelemetry-api, unagi-chan }:
+     mkDerivation {
+       pname = "hs-opentelemetry-exporter-in-memory";
+       version = "0.0.1.0";
+       sha256 = "0hd7pdcziyygvvv9c4klcihj4zyla6kzyc7k42gbg3383r7iw99r";
+       libraryHaskellDepends = [
+         async base hs-opentelemetry-api unagi-chan
+       ];
+       testHaskellDepends = [
+         async base hs-opentelemetry-api unagi-chan
+       ];
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "hs-opentelemetry-exporter-otlp" = callPackage
+    ({ mkDerivation, base, bytestring, case-insensitive, clock
+     , hs-opentelemetry-api, hs-opentelemetry-otlp, http-client
+     , http-conduit, http-types, microlens, mtl, proto-lens, text
+     , unordered-containers, vector, vector-builder
+     }:
+     mkDerivation {
+       pname = "hs-opentelemetry-exporter-otlp";
+       version = "0.0.1.0";
+       sha256 = "0vkxi2agwnhwlncijz2aqb45ri1c3aq6azpmn1igzzd29vsh4qam";
+       libraryHaskellDepends = [
+         base bytestring case-insensitive clock hs-opentelemetry-api
+         hs-opentelemetry-otlp http-client http-conduit http-types microlens
+         mtl proto-lens text unordered-containers vector vector-builder
+       ];
+       testHaskellDepends = [
+         base bytestring case-insensitive clock hs-opentelemetry-api
+         hs-opentelemetry-otlp http-client http-conduit http-types microlens
+         mtl proto-lens text unordered-containers vector vector-builder
+       ];
+       description = "OpenTelemetry exporter supporting the standard OTLP protocol";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "hs-opentelemetry-instrumentation-wai" = callPackage
+    ({ mkDerivation, base, bytestring, hs-opentelemetry-api, http-types
+     , iproute, network, text, vault, wai
+     }:
+     mkDerivation {
+       pname = "hs-opentelemetry-instrumentation-wai";
+       version = "0.0.1.0";
+       sha256 = "075jbkcxsgmjrq731zlyq70421yrmqfsb8zsm149sxsnalxp4jpw";
+       libraryHaskellDepends = [
+         base bytestring hs-opentelemetry-api http-types iproute network
+         text vault wai
+       ];
+       testHaskellDepends = [
+         base bytestring hs-opentelemetry-api http-types iproute network
+         text vault wai
+       ];
+       description = "WAI instrumentation middleware for OpenTelemetry";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "hs-opentelemetry-instrumentation-yesod" = callPackage
+    ({ mkDerivation, base, hs-opentelemetry-api
+     , hs-opentelemetry-instrumentation-wai, microlens, mtl
+     , template-haskell, text, unliftio, wai, yesod-core
+     }:
+     mkDerivation {
+       pname = "hs-opentelemetry-instrumentation-yesod";
+       version = "0.0.1.0";
+       sha256 = "1jywbj76xf2nq2vayx0wa875csisnd0xgb14lq37jr9hqqmzam4z";
+       libraryHaskellDepends = [
+         base hs-opentelemetry-api hs-opentelemetry-instrumentation-wai
+         microlens mtl template-haskell text unliftio wai yesod-core
+       ];
+       testHaskellDepends = [
+         base hs-opentelemetry-api hs-opentelemetry-instrumentation-wai
+         microlens mtl template-haskell text unliftio wai yesod-core
+       ];
+       description = "Yesod middleware for providing OpenTelemetry instrumentation";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "hs-opentelemetry-otlp" = callPackage
+    ({ mkDerivation, base, proto-lens, proto-lens-runtime }:
+     mkDerivation {
+       pname = "hs-opentelemetry-otlp";
+       version = "0.0.1.0";
+       sha256 = "1hlflmr51lz4pbxxmlmp2rb5p4lcj09fhry41rv52nmk9iim4qr0";
+       libraryHaskellDepends = [ base proto-lens proto-lens-runtime ];
+       description = "OpenTelemetry protocol buffer modules generated for the OTLP protocol by the proto-lens package";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "hs-opentelemetry-propagator-w3c" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, hs-opentelemetry-api
+     , http-types, text
+     }:
+     mkDerivation {
+       pname = "hs-opentelemetry-propagator-w3c";
+       version = "0.0.1.0";
+       sha256 = "0kv59ljydrl557ifs5z5kix1lwrglr4mr1ky3nixq7ydrzmsxr16";
+       libraryHaskellDepends = [
+         attoparsec base bytestring hs-opentelemetry-api http-types text
+       ];
+       testHaskellDepends = [
+         attoparsec base bytestring hs-opentelemetry-api http-types text
+       ];
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "hs-opentelemetry-sdk" = callPackage
+    ({ mkDerivation, async, base, bytestring, clock
+     , hs-opentelemetry-api, hs-opentelemetry-exporter-otlp
+     , hs-opentelemetry-propagator-w3c, hspec, http-types, mwc-random
+     , network-bsd, random, random-bytestring, stm, text, unagi-chan
+     , unix, unordered-containers, vector, vector-builder
+     }:
+     mkDerivation {
+       pname = "hs-opentelemetry-sdk";
+       version = "0.0.1.0";
+       sha256 = "01p934rlifsfq3mfxrlm1zp6nwb8xscibvprl4qylyanhhvngd4z";
+       libraryHaskellDepends = [
+         async base bytestring hs-opentelemetry-api
+         hs-opentelemetry-exporter-otlp hs-opentelemetry-propagator-w3c
+         http-types mwc-random network-bsd random random-bytestring stm text
+         unagi-chan unix unordered-containers vector vector-builder
+       ];
+       testHaskellDepends = [
+         async base bytestring clock hs-opentelemetry-api
+         hs-opentelemetry-exporter-otlp hs-opentelemetry-propagator-w3c
+         hspec http-types mwc-random network-bsd random random-bytestring
+         stm text unagi-chan unix unordered-containers vector vector-builder
+       ];
+       description = "OpenTelemetry SDK for use in applications";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "hs-pattrans" = callPackage
     ({ mkDerivation, async, base, bytestring, cassava, Chart
      , Chart-cairo, colour, containers, contravariant, directory
···
        license = lib.licenses.isc;
      }) {};
 
+  "hsinstall_2_7" = callPackage
+    ({ mkDerivation, ansi-wl-pprint, base, Cabal, directory, exceptions
+     , filepath, heredoc, newtype-generics, optparse-applicative
+     , process, safe-exceptions, transformers
+     }:
+     mkDerivation {
+       pname = "hsinstall";
+       version = "2.7";
+       sha256 = "142gdcdka2i61hv9pxpqfi25h5nzz8k7nxlnymfmn4inpayvdr29";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base directory filepath ];
+       executableHaskellDepends = [
+         ansi-wl-pprint base Cabal directory exceptions filepath heredoc
+         newtype-generics optparse-applicative process safe-exceptions
+         transformers
+       ];
+       description = "Install Haskell software";
+       license = lib.licenses.isc;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hskeleton" = callPackage
     ({ mkDerivation, base, Cabal }:
      mkDerivation {
···
        license = lib.licenses.mit;
      }) {};
 
-  "hspec_2_9_1" = callPackage
+  "hspec_2_9_2" = callPackage
     ({ mkDerivation, base, hspec-core, hspec-discover
      , hspec-expectations, QuickCheck
      }:
      mkDerivation {
        pname = "hspec";
-       version = "2.9.1";
-       sha256 = "1q4zknkqgdvkbv2alny9ysbdh7b28v91xazfnka0cqfgfbm22h2i";
+       version = "2.9.2";
+       sha256 = "0zyy2pinv77a161aybpay6syy4y275ap409rzns0v3yqndxn250c";
        libraryHaskellDepends = [
          base hspec-core hspec-discover hspec-expectations QuickCheck
        ];
···
        license = lib.licenses.mit;
      }) {};
 
-  "hspec-core_2_9_1" = callPackage
+  "hspec-core_2_9_2" = callPackage
     ({ mkDerivation, ansi-terminal, array, base, base-orphans
      , call-stack, clock, deepseq, directory, filepath
      , hspec-expectations, hspec-meta, HUnit, process, QuickCheck
···
      }:
      mkDerivation {
        pname = "hspec-core";
-       version = "2.9.1";
-       sha256 = "1nfnzihyn5k02cn627pkj87rdvg1q850gpbyr831jivfi2qia8vq";
-       revision = "1";
-       editedCabalFile = "12qy6gdag9ycabp90mpm4v4vwc9948rkqfldxr2fp36ijx100hc2";
+       version = "2.9.2";
+       sha256 = "175c4g98ancn42j8czjrxm60hik6f3wysifszsqlprhna3cxw1yn";
        libraryHaskellDepends = [
          ansi-terminal array base call-stack clock deepseq directory
          filepath hspec-expectations HUnit QuickCheck quickcheck-io random
···
        maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
-  "hspec-discover_2_9_1" = callPackage
+  "hspec-discover_2_9_2" = callPackage
     ({ mkDerivation, base, directory, filepath, hspec-meta, mockery
      , QuickCheck
      }:
      mkDerivation {
        pname = "hspec-discover";
-       version = "2.9.1";
-       sha256 = "13cbjyzmd543jcpi7bh420adh2bpn088v8fv0cb25zgx8q5khmxw";
+       version = "2.9.2";
+       sha256 = "0chp9fcmjqmwbh2s77ixzjk0w5d19yyph6093j6cky03cbzv1a05";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base directory filepath ];
···
        testHaskellDepends = [ aeson-qq base hspec ];
        description = "Hspec expectations for JSON Values";
        license = lib.licenses.mit;
+     }) {};
+
+  "hspec-expectations-json_1_0_0_5" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec
+     , HUnit, scientific, text, vector
+     }:
+     mkDerivation {
+       pname = "hspec-expectations-json";
+       version = "1.0.0.5";
+       sha256 = "12kb0dsw36rwg522lhs31gi2ij8vf8lq36j3983i352yiqrzb586";
+       libraryHaskellDepends = [
+         aeson aeson-pretty base Diff HUnit scientific text vector
+       ];
+       testHaskellDepends = [ aeson-qq base hspec ];
+       description = "Hspec expectations for JSON Values";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hspec-expectations-lens" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
-  "hspec-junit-formatter_1_0_1_0" = callPackage
+  "hspec-junit-formatter_1_0_3_0" = callPackage
     ({ mkDerivation, base, conduit, containers, directory, exceptions
-     , filepath, hspec, hspec-core, text, time, xml-conduit, xml-types
+     , filepath, hspec, hspec-core, markdown-unlit, temporary, text
+     , time, xml-conduit, xml-types
      }:
      mkDerivation {
        pname = "hspec-junit-formatter";
-       version = "1.0.1.0";
-       sha256 = "1n0hv2xhplpg6fhy8dxzp63k4b7mfzm1g92wglrsqc2lsvnx09ky";
+       version = "1.0.3.0";
+       sha256 = "06003bw98bp9jl379463x1bk3ds30spsmg9h4lvr367k6diyi6ax";
        libraryHaskellDepends = [
          base conduit containers directory exceptions filepath hspec-core
          text time xml-conduit xml-types
        ];
-       testHaskellDepends = [ base hspec ];
+       testHaskellDepends = [
+         base containers filepath hspec hspec-core markdown-unlit temporary
+         text xml-conduit
+       ];
+       testToolDepends = [ markdown-unlit ];
        description = "A JUnit XML runner/formatter for hspec";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
···
        license = lib.licenses.mit;
      }) {};
 
-  "hspec-meta_2_9_0_1" = callPackage
+  "hspec-meta_2_9_2" = callPackage
     ({ mkDerivation, ansi-terminal, array, base, call-stack, clock
      , deepseq, directory, filepath, QuickCheck, quickcheck-io, random
      , setenv, stm, time, transformers
      }:
      mkDerivation {
        pname = "hspec-meta";
-       version = "2.9.0.1";
-       sha256 = "1bcnx7lmcs0hi6skk6xbx4mypq9q92v9rgbn3npy2c79gz01vz6m";
+       version = "2.9.2";
+       sha256 = "1pbmy93vqgb1i2qf1qij3z9q73as9fcv3c1wbff4mnd1fxsxgc9y";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "http-api-data";
        version = "0.4.3";
        sha256 = "171bw2a44pg50d3y77gw2y9vmx72laky7hnn5hw6r93pnjmlf9yz";
-       revision = "4";
-       editedCabalFile = "04nzx6a81v7c6s8mrb7nssv23w3dpalcbm6lvzrg2k8dddr0rwi1";
+       revision = "5";
+       editedCabalFile = "18gh7q1j2jiz4c6sn352j5rl4009gi238nni8ff9kqgi3c4mlrs0";
        libraryHaskellDepends = [
          attoparsec attoparsec-iso8601 base base-compat bytestring
          containers cookie hashable http-types tagged text time-compat
···
        pname = "http-query";
        version = "0.1.0.1";
        sha256 = "11l3bxbaxkd0mrarp5l3s3c4xhvdiq8lj739hxspi6cgk0ywjwxw";
+       revision = "1";
+       editedCabalFile = "1c1xxzsdwclzmrgflaj1nz4k2ll5h53swpfimzxs37kjdxsxkr2b";
        libraryHaskellDepends = [
          aeson base bytestring http-conduit network-uri text
        ];
        description = "Simple http queries";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "http-query_0_1_1" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, http-conduit, network-uri
+     , text
+     }:
+     mkDerivation {
+       pname = "http-query";
+       version = "0.1.1";
+       sha256 = "0k97ck1x2j9is5bslxaaw1fghh4yrvy50fahdy7sg51h5ihzcarp";
+       libraryHaskellDepends = [
+         aeson base bytestring http-conduit network-uri text
+       ];
+       description = "Simple http queries";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "http-querystring" = callPackage
···
      }:
      mkDerivation {
        pname = "hyperloglog";
-       version = "0.4.4";
-       sha256 = "0iwjxv934vid7bzaxyqq4v7r52vdcqjxmw043dmxykwyzim59l3v";
-       libraryHaskellDepends = [
-         approximate base binary bits bytes cereal cereal-vector comonad
-         deepseq distributive hashable lens reflection semigroupoids
-         semigroups siphash tagged vector
-       ];
-       description = "An approximate streaming (constant space) unique object counter";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "hyperloglog_0_4_5" = callPackage
-    ({ mkDerivation, approximate, base, binary, bits, bytes, cereal
-     , cereal-vector, comonad, deepseq, distributive, hashable, lens
-     , reflection, semigroupoids, semigroups, siphash, tagged, vector
-     }:
-     mkDerivation {
-       pname = "hyperloglog";
        version = "0.4.5";
        sha256 = "0v2zw0p104gbydj6hp2cxa2s4b85pq4srcspr582aqj38bs7spfz";
        libraryHaskellDepends = [
···
        ];
        description = "An approximate streaming (constant space) unique object counter";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hyperloglogplus" = callPackage
···
        pname = "ihaskell";
        version = "0.10.2.1";
        sha256 = "1bpxm51c8f0cl7cvg7d2f39fnar7a811s3fgxvxmvsb7yw3v92vc";
+       revision = "1";
+       editedCabalFile = "0qw3zi7fs82k5kk08s6qmpnb6zhfjp77fpqylq9j2ip04sgdcdrp";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        license = lib.licenses.mit;
      }) {};
 
+  "ihaskell_0_10_2_2" = callPackage
+    ({ mkDerivation, aeson, base, base64-bytestring, binary, bytestring
+     , cmdargs, containers, directory, exceptions, filepath, ghc
+     , ghc-boot, ghc-parser, ghc-paths, haskeline, here, hlint, hspec
+     , hspec-contrib, http-client, http-client-tls, HUnit
+     , ipython-kernel, parsec, process, random, raw-strings-qq, setenv
+     , shelly, split, stm, strict, text, time, transformers, unix
+     , unordered-containers, utf8-string, vector
+     }:
+     mkDerivation {
+       pname = "ihaskell";
+       version = "0.10.2.2";
+       sha256 = "1lcyhj19v44wc6blj31fc4gfzsbqj0wnf9fyll8xi4nq0wq0zw89";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson base base64-bytestring binary bytestring cmdargs containers
+         directory exceptions filepath ghc ghc-boot ghc-parser ghc-paths
+         haskeline hlint http-client http-client-tls ipython-kernel parsec
+         process random shelly split stm strict text time transformers unix
+         unordered-containers utf8-string vector
+       ];
+       executableHaskellDepends = [
+         aeson base bytestring containers directory ghc ipython-kernel
+         process strict text transformers unix unordered-containers
+       ];
+       testHaskellDepends = [
+         base directory ghc ghc-paths here hspec hspec-contrib HUnit
+         raw-strings-qq setenv shelly text transformers
+       ];
+       description = "A Haskell backend kernel for the IPython project";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ihaskell-aeson" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, here
      , ihaskell, text
···
      }:
      mkDerivation {
        pname = "implicit-hie-cradle";
-       version = "0.4.0.1";
-       sha256 = "07k0d2lda4kj20121h8lzbjl074s90cnhbins1dvgngxbz0ddxa2";
+       version = "0.5.0.0";
+       sha256 = "0cfciqc0lpvksyvs3azqncbc0c2ckqg9avzd69cnd59b0mc8jsiy";
        libraryHaskellDepends = [
          base base16-bytestring bytestring containers directory extra
          filepath hie-bios hslogger implicit-hie process temporary text time
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "influxdb_1_9_2_2" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, Cabal
+     , cabal-doctest, clock, containers, doctest, foldl, http-client
+     , http-types, lens, network, optional-args, raw-strings-qq
+     , scientific, tagged, tasty, tasty-hunit, template-haskell, text
+     , time, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "influxdb";
+       version = "1.9.2.2";
+       sha256 = "08nqby0m69n8vqppprd3wk5z4r0aqs8kggkjzps106k809q0ycdg";
+       isLibrary = true;
+       isExecutable = true;
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         aeson attoparsec base bytestring clock containers foldl http-client
+         http-types lens network optional-args scientific tagged text time
+         unordered-containers vector
+       ];
+       testHaskellDepends = [
+         base containers doctest lens raw-strings-qq tasty tasty-hunit
+         template-haskell time vector
+       ];
+       description = "InfluxDB client library for Haskell";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "informative" = callPackage
     ({ mkDerivation, base, containers, csv, highlighting-kate
      , http-conduit, monad-logger, pandoc, persistent
···
      }:
      mkDerivation {
        pname = "inline-r";
-       version = "0.10.4";
-       sha256 = "0jvfi2izhxn0n5xzz6rhhfs3fxlx7p1mhd9pjrazqckib14jw8ml";
-       revision = "1";
-       editedCabalFile = "0lfjfk2hliiqs0wx3i5g513r2y8kafdb07hyscg0dq9x53ia067k";
-       libraryHaskellDepends = [
-         aeson base bytestring containers data-default-class deepseq
-         exceptions inline-c mtl pretty primitive process reflection setenv
-         singletons template-haskell text th-lift th-orphans transformers
-         unix vector
-       ];
-       libraryPkgconfigDepends = [ R ];
-       testHaskellDepends = [
-         base bytestring directory filepath ieee754 mtl process
-         quickcheck-assertions silently singletons strict tasty
-         tasty-expected-failure tasty-golden tasty-hunit tasty-quickcheck
-         template-haskell temporary text unix vector
-       ];
-       benchmarkHaskellDepends = [
-         base criterion filepath primitive process singletons
-         template-haskell vector
-       ];
-       description = "Seamlessly call R from Haskell and vice versa. No FFI required.";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {inherit (pkgs) R;};
-
-  "inline-r_0_10_5" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, criterion
-     , data-default-class, deepseq, directory, exceptions, filepath
-     , ieee754, inline-c, mtl, pretty, primitive, process
-     , quickcheck-assertions, R, reflection, setenv, silently
-     , singletons, strict, tasty, tasty-expected-failure, tasty-golden
-     , tasty-hunit, tasty-quickcheck, template-haskell, temporary, text
-     , th-lift, th-orphans, transformers, unix, vector
-     }:
-     mkDerivation {
-       pname = "inline-r";
        version = "0.10.5";
        sha256 = "1jaj3p4vj9g1pk4rfs1sywbq04w24g137yvl6g6mlsxyzd4mldwh";
        libraryHaskellDepends = [
···
   "insert-ordered-containers" = callPackage
     ({ mkDerivation, aeson, base, base-compat, deepseq, hashable
      , indexed-traversable, lens, optics-core, optics-extra, QuickCheck
-     , semigroupoids, semigroups, tasty, tasty-quickcheck, text
-     , transformers, unordered-containers
-     }:
-     mkDerivation {
-       pname = "insert-ordered-containers";
-       version = "0.2.5";
-       sha256 = "0bb3ggzic8z5zmvmzp1fsnb572c2v383740b0ddf1fwihpn52c1y";
-       revision = "2";
-       editedCabalFile = "1xjrd1sn3wkhv8f40wi5p53y8n74lkj5pnr4psjlbpqqlr4hy2ya";
-       libraryHaskellDepends = [
-         aeson base base-compat deepseq hashable indexed-traversable lens
-         optics-core optics-extra semigroupoids semigroups text transformers
-         unordered-containers
-       ];
-       testHaskellDepends = [
-         aeson base base-compat hashable lens QuickCheck semigroupoids
-         semigroups tasty tasty-quickcheck text transformers
-         unordered-containers
-       ];
-       description = "Associative containers retaining insertion order for traversals";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "insert-ordered-containers_0_2_5_1" = callPackage
-    ({ mkDerivation, aeson, base, base-compat, deepseq, hashable
-     , indexed-traversable, lens, optics-core, optics-extra, QuickCheck
      , semigroupoids, tasty, tasty-quickcheck, text, transformers
      , unordered-containers
      }:
···
        ];
        description = "Associative containers retaining insertion order for traversals";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "inserts" = callPackage
···
        ];
        description = "Integer roots and perfect powers";
        license = lib.licenses.mit;
+     }) {};
+
+  "integer-roots_1_0_2_0" = callPackage
+    ({ mkDerivation, base, doctest, integer-gmp, smallcheck, tasty
+     , tasty-hunit, tasty-quickcheck, tasty-smallcheck
+     }:
+     mkDerivation {
+       pname = "integer-roots";
+       version = "1.0.2.0";
+       sha256 = "15sn3jgm8axm8f9z02aj3xdf318qwwc5qfc8b4r0n7hfr1jgrqs5";
+       libraryHaskellDepends = [ base integer-gmp ];
+       testHaskellDepends = [
+         base doctest smallcheck tasty tasty-hunit tasty-quickcheck
+         tasty-smallcheck
+       ];
+       description = "Integer roots and perfect powers";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "integer-simple" = callPackage
···
      }) {};
 
   "ip2location" = callPackage
-    ({ mkDerivation, base, binary, bytestring, iproute }:
+    ({ mkDerivation, aeson, base, binary, bytestring, http-client
+     , http-client-tls, http-types, iproute, split, uri-encode
+     }:
      mkDerivation {
        pname = "ip2location";
-       version = "8.3.1";
-       sha256 = "01sdx0j0rm7rgylac51mk4ph5krdnzdd8532di5g5ik3p112dzg8";
-       libraryHaskellDepends = [ base binary bytestring iproute ];
+       version = "8.4.0";
+       sha256 = "0004hfjvy5dcvvphiarswpy7vnl4lip25qbc662l6vjia0wwn95x";
+       libraryHaskellDepends = [
+         aeson base binary bytestring http-client http-client-tls http-types
+         iproute split uri-encode
+       ];
        description = "IP2Location Haskell package for IP geolocation";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
···
        pname = "ipython-kernel";
        version = "0.10.2.1";
        sha256 = "016w7bmji3k1cnnl3vq35zq6fnqdvc2x762zfzv4ync2jz63rq38";
+       revision = "1";
+       editedCabalFile = "12h7nm3z53g7q0c8ckq3dqp7gdgcm6paln577c4pyhvh218iqycl";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        ];
        description = "A library for creating kernels for IPython frontends";
        license = lib.licenses.mit;
+     }) {};
+
+  "ipython-kernel_0_10_2_2" = callPackage
+    ({ mkDerivation, aeson, base, binary, bytestring, containers
+     , cryptonite, directory, filepath, memory, parsec, process
+     , temporary, text, transformers, unordered-containers, uuid
+     , zeromq4-haskell
+     }:
+     mkDerivation {
+       pname = "ipython-kernel";
+       version = "0.10.2.2";
+       sha256 = "1zvpabfqnkga2smp4p0p46i9llkvxdcdvf0ysafh5xia4ls2icyq";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson base binary bytestring containers cryptonite directory
+         filepath memory parsec process temporary text transformers
+         unordered-containers uuid zeromq4-haskell
+       ];
+       description = "A library for creating kernels for IPython frontends";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "irc" = callPackage
···
        broken = true;
      }) {};
 
+  "jet" = callPackage
+    ({ mkDerivation, aeson, aeson-extra, aeson-pretty, ansi-terminal
+     , base, bytestring, comonad, containers, free, hashable, Hclip
+     , lens, mtl, prettyprinter, prettyprinter-ansi-terminal
+     , recursion-schemes, recursive-zipper, scientific, text
+     , text-zipper, transformers, unix, unordered-containers, vector
+     , vty
+     }:
+     mkDerivation {
+       pname = "jet";
+       version = "0.0.0.1";
+       sha256 = "07l4lq9h9c470jrlprqc3r9iag44m97066hy8kcwdqw5iwi1yqld";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson aeson-extra aeson-pretty ansi-terminal base bytestring
+         comonad containers free hashable Hclip lens mtl prettyprinter
+         prettyprinter-ansi-terminal recursion-schemes recursive-zipper
+         scientific text text-zipper transformers unix unordered-containers
+         vector vty
+       ];
+       executableHaskellDepends = [
+         aeson aeson-extra aeson-pretty ansi-terminal base bytestring
+         comonad containers free hashable Hclip lens mtl prettyprinter
+         prettyprinter-ansi-terminal recursion-schemes recursive-zipper
+         scientific text text-zipper transformers unix unordered-containers
+         vector vty
+       ];
+       testHaskellDepends = [
+         aeson aeson-extra aeson-pretty ansi-terminal base bytestring
+         comonad containers free hashable Hclip lens mtl prettyprinter
+         prettyprinter-ansi-terminal recursion-schemes recursive-zipper
+         scientific text text-zipper transformers unix unordered-containers
+         vector vty
+       ];
+       license = lib.licenses.bsd3;
+     }) {};
+
   "jet-stream" = callPackage
     ({ mkDerivation, async, base, bytestring, conceit, doctest, foldl
      , process, stm, stm-chans, tasty, tasty-hunit, text, time
···
        pname = "json-stream";
        version = "0.4.2.4";
        sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
+       revision = "1";
+       editedCabalFile = "0i1250irn8zxhr3vlik3zaja81a8yj7rjyfk1654bwpih9rq81f6";
        libraryHaskellDepends = [
          aeson base bytestring scientific text unordered-containers vector
        ];
···
      }:
      mkDerivation {
        pname = "jsonrpc-conduit";
-       version = "0.3.6";
-       sha256 = "1czk9i9xkw4r6pg2x8ics4ki15icq2mh8zby2ci9ld5b6iz61196";
+       version = "0.3.7";
+       sha256 = "0i1anr471rm7wil2l62mcwkqsyd62zwcgc0rb3iblr64bjd6kl80";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring conduit conduit-extra mtl text
          transformers unordered-containers
···
        license = lib.licenses.mit;
      }) {};
 
+  "jwt_0_10_1" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, cryptonite
+     , doctest, http-types, HUnit, lens, lens-aeson, memory, network-uri
+     , QuickCheck, scientific, semigroups, tasty, tasty-hunit
+     , tasty-quickcheck, tasty-th, text, time, unordered-containers
+     , vector, x509, x509-store
+     }:
+     mkDerivation {
+       pname = "jwt";
+       version = "0.10.1";
+       sha256 = "02nymdz8yrvq4vw41ah5qmb4rn01xf300d7vz18j4nif55viag4z";
+       libraryHaskellDepends = [
+         aeson base bytestring containers cryptonite http-types memory
+         network-uri scientific semigroups text time unordered-containers
+         vector x509 x509-store
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers cryptonite doctest http-types
+         HUnit lens lens-aeson memory network-uri QuickCheck scientific
+         semigroups tasty tasty-hunit tasty-quickcheck tasty-th text time
+         unordered-containers vector x509 x509-store
+       ];
+       description = "JSON Web Token (JWT) decoding and encoding";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "kademlia" = callPackage
     ({ mkDerivation, base, bytestring, containers, HUnit, mtl, network
      , QuickCheck, stm, tasty, tasty-hunit, tasty-quickcheck
···
        license = lib.licenses.mit;
      }) {};
 
+  "katip-logstash_0_1_0_2" = callPackage
+    ({ mkDerivation, aeson, base, katip, logstash, retry, stm
+     , stm-chans, text, transformers, unliftio
+     }:
+     mkDerivation {
+       pname = "katip-logstash";
+       version = "0.1.0.2";
+       sha256 = "0hd277cvgs83aqr70g3c59nb5jc81fxhv7ngkk80gx4gc62q6l19";
+       libraryHaskellDepends = [
+         aeson base katip logstash retry stm stm-chans text transformers
+         unliftio
+       ];
+       description = "Logstash backend for katip";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "katip-logzio" = callPackage
     ({ mkDerivation, aeson, async, base, bytestring, errors, hedgehog
      , hostname, http-client, http-client-tls, http-types, katip, retry
···
        license = lib.licenses.gpl3Only;
      }) {};
 
-  "language-docker_10_3_0" = callPackage
+  "language-docker_10_4_0" = callPackage
     ({ mkDerivation, base, bytestring, containers, data-default-class
      , hspec, hspec-megaparsec, HUnit, megaparsec, prettyprinter
      , QuickCheck, split, text, time
      }:
      mkDerivation {
        pname = "language-docker";
-       version = "10.3.0";
-       sha256 = "1vwgm2902xzmcq9bkjs4nah5jcijmqa7qviaz96awgb6rc5wamnb";
+       version = "10.4.0";
+       sha256 = "04qn8a0jaxcaircl8ib9p5m45xiay33i4i0gdpgk2qdidac9m2al";
        libraryHaskellDepends = [
          base bytestring containers data-default-class megaparsec
          prettyprinter split text time
···
        pname = "language-sygus";
        version = "0.1.1.2";
        sha256 = "1vgd45bd866mm2w80hg8q11iz8g9ifz5ccm0sh13xrnpvfvdv862";
+       revision = "1";
+       editedCabalFile = "1byjfj7r2ggw122hl1vrx4crdnq9xi57xipyxfa35ixmx4r306ji";
        libraryHaskellDepends = [ array base hashable text ];
        testHaskellDepends = [ base deepseq tasty tasty-hunit text ];
        description = "A parser and printer for the SyGuS 2.0 language.";
···
        pname = "lattices";
        version = "2.0.3";
        sha256 = "1mn78xqwsksybggnsnx8xkmzlc9his1si14dy5v6vmlchkjym9qg";
-       revision = "1";
-       editedCabalFile = "0wj1xk69v6jf8ni1m6962kr1ygci1wrmbji2slfgmdpdlls43b1r";
+       revision = "2";
+       editedCabalFile = "0dnfpgvrq7qkza4k82siayy0rpwj0gcdd2nybzp0m25dq7lign3r";
        libraryHaskellDepends = [
          base base-compat containers deepseq hashable integer-logarithms
          OneTuple QuickCheck semigroupoids tagged transformers universe-base
···
      }:
      mkDerivation {
        pname = "lens-action";
-       version = "0.2.5";
-       sha256 = "02sv76far3y57p2pgcjsx5ffaai8rm4669qkp82l06vv964f0v2r";
-       libraryHaskellDepends = [
-         base comonad contravariant lens mtl profunctors semigroupoids
-         transformers
-       ];
-       description = "Monadic Getters and Folds";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "lens-action_0_2_6" = callPackage
-    ({ mkDerivation, base, comonad, contravariant, lens, mtl
-     , profunctors, semigroupoids, transformers
-     }:
-     mkDerivation {
-       pname = "lens-action";
        version = "0.2.6";
        sha256 = "0cdprc5j6r976dmrga2zwvcr7qsv7nqy3nvncp66yyy0dk2qlwm3";
        libraryHaskellDepends = [
···
        ];
        description = "Monadic Getters and Folds";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "lens-aeson" = callPackage
···
      }:
      mkDerivation {
        pname = "lens-aeson";
-       version = "1.1.2";
-       sha256 = "0pdjjyjwlavcgm2wrv1fiz09l41hisl2xj6y67xbdix1h6h07hxz";
-       libraryHaskellDepends = [
-         aeson attoparsec base bytestring lens scientific text
-         unordered-containers vector
-       ];
-       description = "Law-abiding lenses for aeson";
-       license = lib.licenses.mit;
-     }) {};
-
-  "lens-aeson_1_1_3" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, bytestring, lens
-     , scientific, text, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "lens-aeson";
        version = "1.1.3";
        sha256 = "05jyn6rn0anhgfmk754gmmpcy5jv3ki213z4v243n9jvdjdlg7ms";
        libraryHaskellDepends = [
···
        ];
        description = "Law-abiding lenses for aeson";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "lens-core" = callPackage
···
 
   "libnix" = callPackage
     ({ mkDerivation, aeson, base, bytestring, deepseq, directory
-     , errors, filepath, process, tasty, tasty-hunit, text
+     , errors, filepath, mtl, process, tasty, tasty-hunit, text
      }:
      mkDerivation {
        pname = "libnix";
-       version = "0.3.0.0";
-       sha256 = "0p2fhk5x7zwg70c6wq829b1j8zmms1s5xh2lahfdsr0x5q2k8jif";
+       version = "0.4.1.0";
+       sha256 = "0p9icnwwz38whg9vnvy5id7rnj92n9mgb8jhrlahbgxhz1af7idk";
        libraryHaskellDepends = [
-         aeson base bytestring deepseq errors filepath process text
+         aeson base bytestring deepseq errors filepath mtl process text
        ];
        testHaskellDepends = [
          base directory errors tasty tasty-hunit text
···
      }) {};
 
   "libyaml-streamly" = callPackage
-    ({ mkDerivation, base, bytestring, safe-exceptions, streamly }:
+    ({ mkDerivation, base, bytestring, deepseq, safe-exceptions
+     , streamly
+     }:
      mkDerivation {
        pname = "libyaml-streamly";
-       version = "0.2.0";
-       sha256 = "0lvpavy78clizrizj7zlj9msgfwkhj3c6shnss7swnp1xfi1a1k9";
+       version = "0.2.1";
+       sha256 = "0jh980ilaxhdhyp3vbmg0s3c2vf5ckxlkyj6n45vqb56847mg5bk";
        libraryHaskellDepends = [
-         base bytestring safe-exceptions streamly
+         base bytestring deepseq safe-exceptions streamly
        ];
        description = "Low-level, streaming YAML interface via streamly";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.mit;
      }) {};
 
+  "list-t_1_0_5_1" = callPackage
+    ({ mkDerivation, base, base-prelude, foldl, HTF, logict, mmorph
+     , monad-control, mtl, mtl-prelude, semigroups, transformers
+     , transformers-base
+     }:
+     mkDerivation {
+       pname = "list-t";
+       version = "1.0.5.1";
+       sha256 = "0apcqxz5i0swwfkszwh5rdrda641n4jzkdc5kp3q78ja932vavwy";
+       libraryHaskellDepends = [
+         base foldl logict mmorph monad-control mtl semigroups transformers
+         transformers-base
+       ];
+       testHaskellDepends = [ base-prelude HTF mmorph mtl-prelude ];
+       description = "ListT done right";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "list-t-attoparsec" = callPackage
     ({ mkDerivation, attoparsec, base-prelude, either, hspec, list-t
      , list-t-text, text, transformers
···
      }:
      mkDerivation {
        pname = "log-domain";
-       version = "0.13.1";
-       sha256 = "0ipiiflzs1r7wm5k8b9cqn4l09rjdyks3pxnm4p3kmncd5s2ajsv";
-       libraryHaskellDepends = [
-         base binary bytes cereal comonad deepseq distributive hashable
-         semigroupoids semigroups vector
-       ];
-       description = "Log-domain arithmetic";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "log-domain_0_13_2" = callPackage
-    ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq
-     , distributive, hashable, semigroupoids, semigroups, vector
-     }:
-     mkDerivation {
-       pname = "log-domain";
        version = "0.13.2";
        sha256 = "0i4fx9k8cwjvmj0pgfnbici1b68zmif1jmmqxplpjqy32ksnyifa";
        libraryHaskellDepends = [
···
        ];
        description = "Log-domain arithmetic";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "log-effect" = callPackage
···
      }) {};
 
   "logging-facade" = callPackage
-    ({ mkDerivation, base, call-stack, hspec, transformers }:
-     mkDerivation {
-       pname = "logging-facade";
-       version = "0.3.0";
-       sha256 = "0d0lwxxgd16is9aw6v3ps4r9prv3dj8xscmm45fvzq3nicjiawcf";
-       revision = "1";
-       editedCabalFile = "1wzln1b02wipm1m7slipij031p96ak0z3qnnzl2xz5lh7bp3zb13";
-       libraryHaskellDepends = [ base call-stack transformers ];
-       testHaskellDepends = [ base hspec ];
-       description = "Simple logging abstraction that allows multiple back-ends";
-       license = lib.licenses.mit;
-     }) {};
-
-  "logging-facade_0_3_1" = callPackage
     ({ mkDerivation, base, call-stack, hspec, hspec-discover
      , transformers
      }:
···
        testToolDepends = [ hspec-discover ];
        description = "Simple logging abstraction that allows multiple back-ends";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "logging-facade-journald" = callPackage
···
        ];
        description = "Logstash client library for Haskell";
        license = lib.licenses.mit;
+     }) {};
+
+  "logstash_0_1_0_3" = callPackage
+    ({ mkDerivation, aeson, async, base, bytestring, data-default-class
+     , exceptions, monad-control, mtl, network, resource-pool, resourcet
+     , retry, stm, stm-chans, time, tls, unbounded-delays, unliftio
+     }:
+     mkDerivation {
+       pname = "logstash";
+       version = "0.1.0.3";
+       sha256 = "17s7529mcvpm7pqjz5d980ra70z41zk0k52l6ps1p1zfi5p4niys";
+       libraryHaskellDepends = [
+         aeson async base bytestring data-default-class exceptions
+         monad-control mtl network resource-pool resourcet retry stm
+         stm-chans time tls unbounded-delays unliftio
+       ];
+       description = "Logstash client library for Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "lojban" = callPackage
···
 
   "lorentz" = callPackage
     ({ mkDerivation, aeson-pretty, base-noprelude, bimap, bytestring
-     , constraints, containers, data-default, first-class-families, fmt
-     , interpolate, lens, morley, morley-prelude, mtl, named
-     , optparse-applicative, singletons, template-haskell, text
+     , constraints, containers, cryptonite, data-default
+     , first-class-families, fmt, lens, morley, morley-prelude, mtl
+     , named, optparse-applicative, singletons, template-haskell, text
      , text-manipulate, unordered-containers, vinyl, with-utf8
      }:
      mkDerivation {
        pname = "lorentz";
-       version = "0.12.1";
-       sha256 = "1ba511lxmlmv3dj483q6bgk5bvb16d2js0qldz513j4azqjr5f19";
+       version = "0.13.0";
+       sha256 = "1r4pni5hnf8vaxyv62jvq9dvhwalgzczhymm4w9ixfhncnr6znv4";
        libraryHaskellDepends = [
          aeson-pretty base-noprelude bimap bytestring constraints containers
-         data-default first-class-families fmt interpolate lens morley
+         cryptonite data-default first-class-families fmt lens morley
          morley-prelude mtl named optparse-applicative singletons
          template-haskell text text-manipulate unordered-containers vinyl
          with-utf8
···
     ({ mkDerivation, base, lua5_3, tasty, tasty-hunit }:
      mkDerivation {
        pname = "lua";
-       version = "2.0.1";
-       sha256 = "1ff50sqk52kpyam5mb66spnk8j1n8vbyqgd6p0kmhqpc71890zmp";
+       version = "2.0.2";
+       sha256 = "0hsbwws16p9xrpmx4j8f9hmz8lhjjz9b8ngb3y7pxi6lx08mypgw";
        configureFlags = [ "-fsystem-lua" "-f-use-pkgconfig" ];
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ lua5_3 ];
···
        pname = "managed";
        version = "1.0.8";
        sha256 = "00wzfy9facwgimrilz7bxaigr79w10733h8zfgyhll644p2rnz38";
+       revision = "1";
+       editedCabalFile = "1b95c8lfc45lqjmykbyrls7lpnyjsv770zsdyg5fw9x65r83mdw2";
        libraryHaskellDepends = [ base transformers ];
        description = "A monad for managed values";
        license = lib.licenses.bsd3;
+       maintainers = with lib.maintainers; [ Gabriel439 ];
+     }) {};
+
+  "managed_1_0_9" = callPackage
+    ({ mkDerivation, base, transformers }:
+     mkDerivation {
+       pname = "managed";
+       version = "1.0.9";
+       sha256 = "0vx8aim8bcyyvxxnmi1xkbl3kwrvskjn99z3y8h458g7nsinsisd";
+       revision = "1";
+       editedCabalFile = "1sp7nsav3ln1m4kiian9y2jql0ywlswk8zb4wv8i4wkcr2cbbjkq";
+       libraryHaskellDepends = [ base transformers ];
+       description = "A monad for managed values";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ Gabriel439 ];
      }) {};
 
···
      }) {};
 
   "mason" = callPackage
-    ({ mkDerivation, array, base, bytestring, ghc-prim, integer-gmp
-     , network, text
+    ({ mkDerivation, array, base, bytestring, ghc-prim, network, text
      }:
      mkDerivation {
        pname = "mason";
-       version = "0.2.4";
-       sha256 = "1ic2h2mj31hb972x146wn7p29hlmx9p30f5gi2ccqv2ww96l56fv";
+       version = "0.2.5";
+       sha256 = "0ch8qajaj83pifxy24z4srb3j51z5zn94lrx0ziqcfrpshck569j";
        libraryHaskellDepends = [
-         array base bytestring ghc-prim integer-gmp network text
+         array base bytestring ghc-prim network text
        ];
        description = "Fast and extensible bytestring builder";
        license = lib.licenses.bsd3;
···
        broken = true;
      }) {};
 
-  "massiv-persist_1_0_0_1" = callPackage
+  "massiv-persist_1_0_0_2" = callPackage
     ({ mkDerivation, base, bytestring, deepseq, doctest, hspec
      , hspec-discover, massiv, massiv-test, persist, primitive
      , QuickCheck
      }:
      mkDerivation {
        pname = "massiv-persist";
-       version = "1.0.0.1";
-       sha256 = "1j5vzk5m2r1cs5v5pzmf1i7p8zdlf29g0gdklf6snl9llk755pgy";
+       version = "1.0.0.2";
+       sha256 = "1hqmwbrxv664y4rfm37ziym25l9218pd21lz4180c0k3hfpdfsxy";
        libraryHaskellDepends = [
          base bytestring deepseq massiv persist primitive
        ];
···
        broken = true;
      }) {};
 
-  "massiv-serialise_1_0_0_1" = callPackage
+  "massiv-serialise_1_0_0_2" = callPackage
     ({ mkDerivation, base, deepseq, doctest, hspec, hspec-discover
      , massiv, massiv-test, QuickCheck, serialise, vector
      }:
      mkDerivation {
        pname = "massiv-serialise";
-       version = "1.0.0.1";
-       sha256 = "0zmikmfjjshf9p0fawcg05832hxdzj04kqqh11bz1kqcc1yc7yk0";
+       version = "1.0.0.2";
+       sha256 = "1309nsjk36l1qiq769f9yrvn20xgf6abkmqqddzb8gqfbvhkzzym";
        libraryHaskellDepends = [ base deepseq massiv serialise vector ];
        testHaskellDepends = [
          base doctest hspec massiv massiv-test QuickCheck serialise
···
        pname = "memory";
        version = "0.16.0";
        sha256 = "0zzxyr2b7gj92h3jzaq1lfqfyfkfj4l636ry35191i9bp3wa0v8l";
+       revision = "1";
+       editedCabalFile = "02ql04drvyk8sdadxs4yi1h4aic0pxgnrph3j5ndcm6r7hfnv8py";
        libraryHaskellDepends = [
          base basement bytestring deepseq ghc-prim
        ];
···
      }:
      mkDerivation {
        pname = "mergeful-persistent";
-       version = "0.0.0.0";
-       sha256 = "13lw0gb57as7mplaqwg0i6cpdp1gyw0qghbq4l19y7ib8c6jqnxi";
+       version = "0.1.0.0";
+       sha256 = "13i2bajgxwmyr5w8qfswlpizhsajnnhgs96hav74sj5m5i6z0dpi";
        libraryHaskellDepends = [
          base containers mergeful microlens mtl persistent
        ];
···
      }:
      mkDerivation {
        pname = "mergeless-persistent";
-       version = "0.0.0.0";
-       sha256 = "0b75qs3f1vp4cab28j9znr83apzrsfx7i0p42nk42m5kn5vg2rzs";
+       version = "0.1.0.0";
+       sha256 = "05fazha6q5lmpagfazlrly7ms0p1jag9n6llwmr0zspx0raq35mb";
        libraryHaskellDepends = [
          base containers mergeless microlens persistent
        ];
···
        ];
        description = "Logstash backend for monad-logger";
        license = lib.licenses.mit;
+     }) {};
+
+  "monad-logger-logstash_0_2_0_2" = callPackage
+    ({ mkDerivation, aeson, base, logstash, monad-logger, retry, stm
+     , stm-chans, text, transformers, unliftio
+     }:
+     mkDerivation {
+       pname = "monad-logger-logstash";
+       version = "0.2.0.2";
+       sha256 = "1f0376s3xmrd0gqz0laxbqsh3h4g12bk0v885ik648bxwaliq2zf";
+       libraryHaskellDepends = [
+         aeson base logstash monad-logger retry stm stm-chans text
+         transformers unliftio
+       ];
+       description = "Logstash backend for monad-logger";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "monad-logger-prefix" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "monad-skeleton_0_2" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "monad-skeleton";
+       version = "0.2";
+       sha256 = "0hqlwimwdhxwcikmy41qlkzr09dxx7ibpzr2g4czlv07c6fwlm3q";
+       libraryHaskellDepends = [ base ];
+       description = "Monads of program skeleta";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "monad-st" = callPackage
     ({ mkDerivation, base, transformers }:
      mkDerivation {
···
 
   "morley" = callPackage
     ({ mkDerivation, aeson, aeson-casing, aeson-pretty, base-noprelude
-     , base58-bytestring, binary, bytestring, Cabal, constraints
-     , containers, cryptonite, data-default, doctest, elliptic-curve
-     , first-class-families, fmt, galois-field, generic-deriving, gitrev
-     , haskeline, hex-text, interpolate, lens, megaparsec, memory
-     , MonadRandom, morley-prelude, mtl, named, optparse-applicative
-     , pairing, parser-combinators, process, scientific, semigroups
-     , show-type, singletons, syb, tasty-discover, template-haskell
-     , text, text-manipulate, th-lift, th-lift-instances, time, timerep
+     , base58-bytestring, binary, bytestring, constraints, containers
+     , cryptonite, data-default, elliptic-curve, first-class-families
+     , fmt, galois-field, generic-deriving, gitrev, haskeline, hex-text
+     , lens, megaparsec, memory, MonadRandom, morley-prelude, mtl, named
+     , optparse-applicative, pairing, parser-combinators, scientific
+     , semigroups, show-type, singletons, syb, template-haskell, text
+     , text-manipulate, th-lift, th-lift-instances, time, timerep
      , uncaught-exception, unordered-containers, vector, vinyl
      , with-utf8, wl-pprint-text
      }:
      mkDerivation {
        pname = "morley";
-       version = "1.15.1";
-       sha256 = "03r6p37b9hw9n0b143d38z07fjv05jnbw76s1fjx92rm2ybbgh3p";
+       version = "1.16.0";
+       sha256 = "02ysr8qh0jgwz25nlwk88qxkpx3jsijd854i5dp9h19n5iibh7l8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-casing aeson-pretty base-noprelude base58-bytestring
          binary bytestring constraints containers cryptonite data-default
          elliptic-curve first-class-families fmt galois-field
-         generic-deriving gitrev hex-text interpolate lens megaparsec memory
-         MonadRandom morley-prelude mtl named optparse-applicative pairing
+         generic-deriving gitrev hex-text lens megaparsec memory MonadRandom
+         morley-prelude mtl named optparse-applicative pairing
          parser-combinators scientific semigroups show-type singletons syb
          template-haskell text text-manipulate th-lift th-lift-instances
          time timerep uncaught-exception unordered-containers vector vinyl
          with-utf8 wl-pprint-text
        ];
        executableHaskellDepends = [
-         aeson base-noprelude bytestring fmt haskeline megaparsec
-         morley-prelude named optparse-applicative text vinyl with-utf8
-       ];
-       testHaskellDepends = [
-         base-noprelude bytestring Cabal doctest morley-prelude
-         optparse-applicative process
+         aeson base-noprelude base58-bytestring bytestring fmt haskeline
+         hex-text megaparsec MonadRandom morley-prelude named
+         optparse-applicative text vinyl with-utf8
        ];
-       testToolDepends = [ tasty-discover ];
        description = "Developer tools for the Michelson Language";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
      }) {};
 
   "morley-prelude" = callPackage
-    ({ mkDerivation, base-noprelude, lens, universum }:
+    ({ mkDerivation, base-noprelude, int-cast, lens, universum }:
      mkDerivation {
        pname = "morley-prelude";
-       version = "0.4.2";
-       sha256 = "0cmrs0hqrbwrmxycqk39csk0y7hswj2r6p1hgzrxyhy536szabby";
-       libraryHaskellDepends = [ base-noprelude lens universum ];
+       version = "0.5.0";
+       sha256 = "1j78ki07jh31am9i2g43crkajynb39agdk4as7gdkhj3lfrbriz4";
+       libraryHaskellDepends = [ base-noprelude int-cast lens universum ];
        description = "A custom prelude used in Morley";
        license = lib.licenses.mit;
      }) {};
···
   "mptcp-pm" = callPackage
     ({ mkDerivation, aeson, aeson-extra, aeson-pretty, base, bytestring
      , bytestring-conversion, c2hs, cereal, containers, enumset
-     , filepath, hslogger, HUnit, ip, katip, mtl, netlink
-     , optparse-applicative, process, temporary, text, transformers
+     , filepath, formatting, HUnit, ip, mtl, netlink
+     , optparse-applicative, polysemy, polysemy-log, polysemy-log-co
+     , polysemy-plugin, process, readable, temporary, text, transformers
      , unordered-containers
      }:
      mkDerivation {
        pname = "mptcp-pm";
-       version = "0.0.3";
-       sha256 = "0h7r9i9izflsbgb8kimsz0hmglbd4s9pjycjsm0h64lg8b1sy4gs";
+       version = "0.0.4";
+       sha256 = "1i84pkifb8mqyhv4cg0gc6adss673yp25ffmlyif3zcrc3dshjyc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-extra aeson-pretty base bytestring
-         bytestring-conversion cereal containers enumset ip katip mtl
-         netlink process text transformers unordered-containers
+         bytestring-conversion cereal containers enumset formatting ip mtl
+         netlink polysemy polysemy-log polysemy-log-co polysemy-plugin
+         process readable text transformers unordered-containers
        ];
        libraryToolDepends = [ c2hs ];
        executableHaskellDepends = [
          aeson aeson-extra aeson-pretty base bytestring cereal containers
-         filepath hslogger ip mtl netlink optparse-applicative process
+         filepath formatting ip mtl netlink optparse-applicative polysemy
+         polysemy-log polysemy-log-co polysemy-plugin process readable
          temporary text transformers
        ];
        testHaskellDepends = [ base HUnit ip text ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "mustache_2_3_2" = callPackage
+    ({ mkDerivation, aeson, base, base-unicode-symbols, bytestring
+     , cmdargs, containers, directory, filepath, hspec, lens, mtl
+     , parsec, process, scientific, tar, template-haskell, temporary
+     , text, th-lift, unordered-containers, vector, wreq, yaml, zlib
+     }:
+     mkDerivation {
+       pname = "mustache";
+       version = "2.3.2";
+       sha256 = "0pnvnqrm7sd1iglh298yl91mv69p3ra25s5xrlk73kb56albdbaq";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring containers directory filepath mtl parsec
+         scientific template-haskell text th-lift unordered-containers
+         vector
+       ];
+       executableHaskellDepends = [
+         aeson base bytestring cmdargs filepath text yaml
+       ];
+       testHaskellDepends = [
+         aeson base base-unicode-symbols bytestring directory filepath hspec
+         lens process tar temporary text unordered-containers wreq yaml zlib
+       ];
+       description = "A mustache template parser library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "mustache-haskell" = callPackage
     ({ mkDerivation, aeson, base, bytestring, directory
      , optparse-applicative, parsec, pretty-show, scientific, text
···
      }:
      mkDerivation {
        pname = "natural";
-       version = "0.3.0.5";
-       sha256 = "0w137fa7qy70zi0a2r38bbczpyiafvqf2x7y91r3h0g1ajk9zfys";
+       version = "0.3.0.6";
+       sha256 = "0bnqniczz0hzdlxn3l97k51jm8ivm06plj3khzcksf9al7269hzv";
        libraryHaskellDepends = [ base lens semigroupoids ];
        testHaskellDepends = [
          base checkers hedgehog lens QuickCheck tasty tasty-hedgehog
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "ngx-export-distribution" = callPackage
+    ({ mkDerivation, base, Cabal, directory, filepath }:
+     mkDerivation {
+       pname = "ngx-export-distribution";
+       version = "0.3.0.0";
+       sha256 = "0vxbrr82w8sw7fbp5nwi6ksfdlbgwqsdfzlyp72fx71dradqpbsx";
+       libraryHaskellDepends = [ base Cabal directory filepath ];
+       description = "Build custom libraries for Nginx haskell module";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "ngx-export-tools" = callPackage
     ({ mkDerivation, aeson, base, binary, bytestring, ngx-export, safe
      , template-haskell
···
     ({ mkDerivation, base, comonad, deepseq, doctest, Glob, safe }:
      mkDerivation {
        pname = "nonempty-zipper";
-       version = "1.0.0.2";
-       sha256 = "10fj56ry851npkhrkw9gb1sckhx764l2s2c5x83cnylxlg7cfijj";
-       libraryHaskellDepends = [ base comonad deepseq safe ];
-       testHaskellDepends = [ base comonad deepseq doctest Glob safe ];
-       description = "A non-empty comonadic list zipper";
-       license = lib.licenses.mit;
-     }) {};
-
-  "nonempty-zipper_1_0_0_3" = callPackage
-    ({ mkDerivation, base, comonad, deepseq, doctest, Glob, safe }:
-     mkDerivation {
-       pname = "nonempty-zipper";
        version = "1.0.0.3";
        sha256 = "1cifrld76j43spf265arwp2sdpkbhrb4ca2fmj4g9mw0nxj4dbqq";
        libraryHaskellDepends = [ base comonad deepseq safe ];
        testHaskellDepends = [ base comonad deepseq doctest Glob safe ];
        description = "A non-empty comonadic list zipper";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "nonemptymap" = callPackage
···
        pname = "normalization-insensitive";
        version = "2.0.2";
        sha256 = "1rr12rrij64hi6jkd42h4x2m86k1ra10ykzpzc38n6rfdhyiswpn";
-       revision = "1";
-       editedCabalFile = "0q5h2017r0zwgi2xdrznhq2llljz9bslqnhq1l5zczrm9xs3304x";
+       revision = "2";
+       editedCabalFile = "1gf3msmrgd6amqhsy18b7wygjmjcz295v7pj9pdwdig7mlak1r7s";
        libraryHaskellDepends = [
          base bytestring deepseq hashable text unicode-transforms
        ];
···
        broken = true;
      }) {};
 
+  "oeis2_1_0_6" = callPackage
+    ({ mkDerivation, aeson, base, containers, hspec, http-conduit, lens
+     , lens-aeson, QuickCheck, text, vector
+     }:
+     mkDerivation {
+       pname = "oeis2";
+       version = "1.0.6";
+       sha256 = "1y1i2v59nhijh50akkjk9b7cnmrx33lgmk4p13fvwimkm5g9avs2";
+       libraryHaskellDepends = [
+         aeson base containers http-conduit lens lens-aeson text vector
+       ];
+       testHaskellDepends = [
+         aeson base containers hspec http-conduit lens lens-aeson QuickCheck
+         text vector
+       ];
+       description = "Interface for Online Encyclopedia of Integer Sequences (OEIS)";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "off-simple" = callPackage
     ({ mkDerivation, base, parsec3, vector }:
      mkDerivation {
···
     ({ mkDerivation, base, one-liner, random }:
      mkDerivation {
        pname = "one-liner-instances";
-       version = "0.1.2.1";
-       sha256 = "1gy900nd5n6cffqw63hlkqg4ly86wjlfqgdcm1zy2nyx7dxg914k";
+       version = "0.1.3.0";
+       sha256 = "0qkvbrxgnr51a0hdd2ap6fndipgfplsdy4lh841h8hda5d4dhabg";
        libraryHaskellDepends = [ base one-liner random ];
        description = "Generics-based implementations for common typeclasses";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "opaleye_0_8_0_0" = callPackage
+  "opaleye_0_8_0_1" = callPackage
     ({ mkDerivation, aeson, base, base16-bytestring, bytestring
      , case-insensitive, containers, contravariant, dotenv, hspec
      , hspec-discover, multiset, postgresql-simple, pretty
···
      }:
      mkDerivation {
        pname = "opaleye";
-       version = "0.8.0.0";
-       sha256 = "0rsgr82sndd81bbr3djzralvns51145ars36l6r9v9y5b9hjm32h";
-       revision = "1";
-       editedCabalFile = "018fnqx469vbyp8r3w631b65j759nrcm843m0jalzrs9z7l2bk29";
+       version = "0.8.0.1";
+       sha256 = "1py950js9k80manm3xj1sfls0xnw1kd609hw268wr9izd0syfva4";
        libraryHaskellDepends = [
          aeson base base16-bytestring bytestring case-insensitive
          contravariant postgresql-simple pretty product-profunctors
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "ormolu_0_4_0_0" = callPackage
+    ({ mkDerivation, ansi-terminal, array, base, bytestring, Cabal
+     , containers, Diff, directory, dlist, exceptions, filepath
+     , ghc-lib-parser, gitrev, hspec, hspec-discover, mtl
+     , optparse-applicative, path, path-io, syb, temporary, text
+     }:
+     mkDerivation {
+       pname = "ormolu";
+       version = "0.4.0.0";
+       sha256 = "1alibf9ya2igwwjx23pjd0fi2kdaldrkfdpyr2w211irf9agy0j9";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         ansi-terminal array base bytestring Cabal containers Diff directory
+         dlist exceptions filepath ghc-lib-parser mtl syb text
+       ];
+       executableHaskellDepends = [
+         base filepath ghc-lib-parser gitrev optparse-applicative text
+       ];
+       testHaskellDepends = [
+         base containers directory filepath hspec path path-io temporary
+         text
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "A formatter for Haskell source code";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "orthotope" = callPackage
     ({ mkDerivation, base, deepseq, dlist, HUnit, pretty, QuickCheck
      , test-framework, test-framework-hunit, test-framework-quickcheck2
···
      }:
      mkDerivation {
        pname = "ory-hydra-client";
-       version = "1.9.2";
-       sha256 = "0z1897xl10465mzhriis9bmxk0hnswl5ap2m6x8ks5m120irh894";
+       version = "1.10";
+       sha256 = "0ciyyd1925z2wnd6w57f993dva519cm1wgcs39kiw20n2bpb2myi";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring case-insensitive containers
          deepseq exceptions http-api-data http-client http-client-tls
···
          aeson base bytestring containers hspec iso8601-time mtl QuickCheck
          semigroups text time transformers unordered-containers vector
        ];
-       description = "Auto-generated ory-hydra API Client";
+       description = "Auto-generated ory-hydra-client API Client";
        license = lib.licenses.mit;
      }) {};
 
···
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
-  "pandoc_2_16_1" = callPackage
+  "pandoc_2_16_2" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, array, attoparsec, base
      , base64-bytestring, binary, blaze-html, blaze-markup, bytestring
      , case-insensitive, citeproc, commonmark, commonmark-extensions
···
      , hslua-marshalling, hslua-module-path, hslua-module-system
      , hslua-module-text, hslua-module-version, http-client
      , http-client-tls, http-types, ipynb, jira-wiki-markup, JuicyPixels
-     , mtl, network, network-uri, pandoc-types, parsec, pretty
+     , lpeg, mtl, network, network-uri, pandoc-types, parsec, pretty
      , pretty-show, process, QuickCheck, random, safe, scientific, SHA
      , skylighting, skylighting-core, split, syb, tagsoup, tasty
      , tasty-bench, tasty-golden, tasty-hunit, tasty-lua
···
      }:
      mkDerivation {
        pname = "pandoc";
-       version = "2.16.1";
-       sha256 = "1gjmry6bnwh20myhqsj8ysfdhhcq7ccawkykxf4k4bnp7yppdfza";
+       version = "2.16.2";
+       sha256 = "0pnw4v5i20bi9j3gg0i9wlikk2fhj34x5vhh23zhj8v4p72r3wkj";
+       revision = "1";
+       editedCabalFile = "013i4hsgfdq38zsxq4c3l80hqxrqccy41h1ihyakamb8m3p3pq8q";
        configureFlags = [ "-fhttps" "-f-trypandoc" ];
        isLibrary = true;
        isExecutable = true;
···
          emojis exceptions file-embed filepath Glob haddock-library hslua
          hslua-marshalling hslua-module-path hslua-module-system
          hslua-module-text hslua-module-version http-client http-client-tls
-         http-types ipynb jira-wiki-markup JuicyPixels mtl network
+         http-types ipynb jira-wiki-markup JuicyPixels lpeg mtl network
          network-uri pandoc-types parsec pretty pretty-show process random
          safe scientific SHA skylighting skylighting-core split syb tagsoup
          temporary texmath text text-conversions time unicode-collation
···
          zip-archive
        ];
        benchmarkHaskellDepends = [
-         base bytestring containers deepseq mtl tasty-bench text time
+         base bytestring deepseq mtl tasty-bench text
        ];
        postInstall = ''
          mkdir -p $out/share/man/man1
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "pandoc-lua-marshal" = callPackage
+    ({ mkDerivation, base, bytestring, exceptions, hslua
+     , hslua-marshalling, lua, pandoc-types, QuickCheck, safe, tasty
+     , tasty-hunit, tasty-lua, tasty-quickcheck, text
+     }:
+     mkDerivation {
+       pname = "pandoc-lua-marshal";
+       version = "0.1.0.1";
+       sha256 = "091aliy9ys5sq4bp69fa6ypynqvbkkr9xx8xzxq0dd4lmdy36a7q";
+       libraryHaskellDepends = [
+         base bytestring exceptions hslua hslua-marshalling lua pandoc-types
+         safe text
+       ];
+       testHaskellDepends = [
+         base bytestring exceptions hslua hslua-marshalling lua pandoc-types
+         QuickCheck safe tasty tasty-hunit tasty-lua tasty-quickcheck text
+       ];
+       description = "Use pandoc types in Lua";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "pandoc-markdown-ghci-filter" = callPackage
     ({ mkDerivation, aeson, base, containers, ghcid, pandoc
      , pandoc-types, QuickCheck, tasty, tasty-hunit, tasty-quickcheck
···
        broken = true;
      }) {};
 
-  "parsec_3_1_14_0" = callPackage
-    ({ mkDerivation, base, bytestring, HUnit, mtl, test-framework
-     , test-framework-hunit, text
-     }:
+  "parsec_3_1_15_0" = callPackage
+    ({ mkDerivation, base, bytestring, mtl, tasty, tasty-hunit, text }:
      mkDerivation {
        pname = "parsec";
-       version = "3.1.14.0";
-       sha256 = "132waj2cpn892midbhpkfmb74qq83v0zv29v885frlp1gvh94b67";
-       revision = "4";
-       editedCabalFile = "0p65q054iaz2117a5qk1428dic4sb41acclys9k00zna24ks7iq3";
+       version = "3.1.15.0";
+       sha256 = "1v8zs8zv1rk16lag2yqaxfwanjpgnh4gxw1vd70py0n04d20z0lq";
        libraryHaskellDepends = [ base bytestring mtl text ];
-       testHaskellDepends = [
-         base HUnit mtl test-framework test-framework-hunit
-       ];
+       testHaskellDepends = [ base mtl tasty tasty-hunit ];
        description = "Monadic parser combinators";
-       license = lib.licenses.bsd3;
+       license = lib.licenses.bsd2;
        hydraPlatforms = lib.platforms.none;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "parsley";
-       version = "1.0.2.0";
-       sha256 = "1wjq2lrggdaxbw9i00dph3m737san52qm7wfa5rl214lpmap6wi6";
-       revision = "1";
-       editedCabalFile = "1vagq523r4hl3lsqfvl67kqlkfnm1fmpaznr19yd0davq7xzgvva";
+       version = "2.0.0.0";
+       sha256 = "0h6msk2a11bq4bzl5gs3aq0sqd1z13smp2n8bxsr49vm51hmd1qh";
        libraryHaskellDepends = [
          base parsley-core template-haskell text
        ];
···
      }:
      mkDerivation {
        pname = "parsley-core";
-       version = "1.8.0.0";
-       sha256 = "100lv531azfvzgh4w7pfdxm2xxm42h83547ql5prjjs5zc1bdzqr";
+       version = "2.0.0.0";
+       sha256 = "1v46wpi80fdjpdgr6jcrhljxjrmf1gf7cxmi3y0sdlininr4273i";
        libraryHaskellDepends = [
          array base bytestring containers dependent-map dependent-sum
          ghc-prim hashable mtl pretty-terminal template-haskell text
···
        pname = "path";
        version = "0.9.0";
        sha256 = "14h811rrydpiwi1rdi5wmcdlcq2qjld3iv92p4czqf08a7lxaz4g";
+       libraryHaskellDepends = [
+         aeson base deepseq exceptions filepath hashable template-haskell
+         text
+       ];
+       testHaskellDepends = [
+         aeson base bytestring filepath genvalidity genvalidity-hspec
+         genvalidity-property hspec mtl QuickCheck template-haskell validity
+       ];
+       description = "Support for well-typed paths";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "path_0_9_1" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, deepseq, exceptions
+     , filepath, genvalidity, genvalidity-hspec, genvalidity-property
+     , hashable, hspec, mtl, QuickCheck, template-haskell, text
+     , validity
+     }:
+     mkDerivation {
+       pname = "path";
+       version = "0.9.1";
+       sha256 = "0n0mp0cs2abybhpbrj1xgdcllcrxnjpw0c663aapm48irrq1fjbf";
        libraryHaskellDepends = [
          aeson base deepseq exceptions filepath hashable template-haskell
          text
···
      }:
      mkDerivation {
        pname = "perceptual-hash";
-       version = "0.1.4.4";
-       sha256 = "00jbxkspjbxg4yv6jh9d1gx0fq5v5gqaxnvr9h7hx6xiyfc4n2wi";
+       version = "0.1.4.5";
+       sha256 = "1qh7crpb78pd7kn7g8sh5h8wr911ldz30p23m9lqfk0cyxd1pxvy";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }) {};
 
   "photoname" = callPackage
-    ({ mkDerivation, base, directory, exif, filepath, HUnit, mtl
-     , old-locale, parsec, process, regex-posix, time, unix
+    ({ mkDerivation, ansi-wl-pprint, base, containers, directory
+     , filepath, heredoc, hsexif, hslogger, mtl, newtype-generics
+     , optparse-applicative, parsec, process, regex-posix, tasty
+     , tasty-hunit, tasty-quickcheck, time, unix
      }:
      mkDerivation {
        pname = "photoname";
-       version = "3.3";
-       sha256 = "1fcl0m5hm6xvnzvn8v0l69vr7yh2q58six62147mwf4nlzny61gd";
-       isLibrary = false;
+       version = "5.0";
+       sha256 = "0g17jbnrgl2crgd04sy9s8d1g8da7p8wxq7hgnlg9h4n40yjxbd8";
+       isLibrary = true;
        isExecutable = true;
+       libraryHaskellDepends = [
+         base containers directory filepath hsexif hslogger mtl
+         newtype-generics parsec process time unix
+       ];
        executableHaskellDepends = [
-         base directory exif filepath mtl old-locale parsec time unix
+         ansi-wl-pprint base directory filepath heredoc hslogger
+         newtype-generics optparse-applicative unix
        ];
        testHaskellDepends = [
-         base directory exif filepath HUnit mtl old-locale parsec process
-         regex-posix time unix
+         base directory filepath process regex-posix tasty tasty-hunit
+         tasty-quickcheck time unix
        ];
        description = "Rename photo image files based on EXIF shoot date";
        license = lib.licenses.isc;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "phraskell" = callPackage
···
        broken = true;
      }) {};
 
+  "pid" = callPackage
+    ({ mkDerivation, base, mtl }:
+     mkDerivation {
+       pname = "pid";
+       version = "0.1.0.1";
+       sha256 = "0qabdl1y7k7ycsg4r4hhq8lvq8vaps5rhv4r45mwfbj90vm1n9wa";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [ base mtl ];
+       description = "a simple pid controller";
+       license = "unknown";
+     }) {};
+
   "pid1" = callPackage
     ({ mkDerivation, base, directory, process, unix }:
      mkDerivation {
···
        testHaskellDepends = [ async base pipes stm ];
        description = "Concurrency for the pipes ecosystem";
        license = lib.licenses.bsd3;
+       maintainers = with lib.maintainers; [ Gabriel439 ];
+     }) {};
+
+  "pipes-concurrency_2_0_13" = callPackage
+    ({ mkDerivation, async, base, contravariant, pipes, stm, void }:
+     mkDerivation {
+       pname = "pipes-concurrency";
+       version = "2.0.13";
+       sha256 = "085xvzpl25k5fx9lj35pznw51rfq6037shlcikdmqn4hqi5gxk5l";
+       libraryHaskellDepends = [
+         async base contravariant pipes stm void
+       ];
+       testHaskellDepends = [ async base pipes stm ];
+       description = "Concurrency for the pipes ecosystem";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ Gabriel439 ];
      }) {};
 
···
        pname = "pipes-extras";
        version = "1.0.15";
        sha256 = "1cyb05bv5xkarab3090ikpjiqm79lr46n3nalplliz8jr4x67a82";
-       revision = "3";
-       editedCabalFile = "177l1fs1wgm34ifbx83xxf29m0ghq6z9skpkwm86qfln2hpikkj9";
+       revision = "4";
+       editedCabalFile = "0dis0i8l76cd94qgabvjbmn7iqwnqqdf8kgj4d5nby0xc02mqbw9";
        libraryHaskellDepends = [ base foldl lens pipes transformers ];
        testHaskellDepends = [
          base HUnit pipes test-framework test-framework-hunit transformers
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "polysemy_1_7_0_0" = callPackage
+  "polysemy_1_7_1_0" = callPackage
     ({ mkDerivation, async, base, Cabal, cabal-doctest, containers
      , criterion, doctest, first-class-families, free, freer-simple
      , hspec, hspec-discover, inspection-testing, mtl, QuickCheck, stm
···
      }:
      mkDerivation {
        pname = "polysemy";
-       version = "1.7.0.0";
-       sha256 = "1wry69zv5rbjvn2ll16cbynfkmjzz8gglv1dy1n8i3pn6xbs1rn6";
+       version = "1.7.1.0";
+       sha256 = "09629gyjdp567dsqk0mgzzk5glrwnpn0cwanank5z3zkqg05d5ac";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          async base containers first-class-families mtl QuickCheck stm syb
···
        broken = true;
      }) {};
 
-  "polysemy-plugin_0_4_2_0" = callPackage
+  "polysemy-plugin_0_4_3_0" = callPackage
     ({ mkDerivation, base, Cabal, cabal-doctest, containers, doctest
      , ghc, ghc-tcplugins-extra, hspec, hspec-discover
      , inspection-testing, polysemy, should-not-typecheck, syb
···
      }:
      mkDerivation {
        pname = "polysemy-plugin";
-       version = "0.4.2.0";
-       sha256 = "02ci30l7235nyz0z733ccwvjxb2pbsm8gdm21c6bscbkndpp25vg";
+       version = "0.4.3.0";
+       sha256 = "1y4najvwas9rmd7xzn4k1nkpdld86606z3qzky7zr1d3l1z1vafb";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base containers ghc ghc-tcplugins-extra polysemy syb transformers
···
        pname = "postgresql-simple";
        version = "0.6.4";
        sha256 = "0rz2bklxp4pvbxb2w49h5p6pbwabn6d5d4j4mrya4fpa0d13k43d";
-       revision = "4";
-       editedCabalFile = "1s3y4ij6xw5ck6c1zk1d9v9smnby098mn1pj8wys01qy5mac78x1";
+       revision = "5";
+       editedCabalFile = "0vnawd7f2lwqgh1hi6s5y5wny85a12i27haz93bmjvpmdljjmsjk";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring bytestring-builder
          case-insensitive containers hashable Only postgresql-libpq
···
      }:
      mkDerivation {
        pname = "powerdns";
-       version = "0.1.1";
-       sha256 = "1pyh9whqzx7fkvr3090paiz1x29fkfkrgs1v3k4d0x3vfdxv6n1f";
+       version = "0.2.0";
+       sha256 = "0ddrgvpvss342zmnyd0svj7424k8gynd7bwb2i0r10zw1l4kai26";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring case-insensitive containers
          deepseq servant servant-client servant-client-core text time
···
        license = lib.licenses.mit;
      }) {};
 
+  "pretty-relative-time_0_3_0_0" = callPackage
+    ({ mkDerivation, base, genvalidity, genvalidity-hspec
+     , genvalidity-time, hspec, QuickCheck, time, validity
+     , validity-time
+     }:
+     mkDerivation {
+       pname = "pretty-relative-time";
+       version = "0.3.0.0";
+       sha256 = "1sqdz7bh99ya0d8wb721bbs25cqjfhg81q8xxvrmlamrrgc1z7bh";
+       libraryHaskellDepends = [ base time validity validity-time ];
+       testHaskellDepends = [
+         base genvalidity genvalidity-hspec genvalidity-time hspec
+         QuickCheck time validity validity-time
+       ];
+       description = "Pretty relative time";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "pretty-show" = callPackage
     ({ mkDerivation, array, base, filepath, ghc-prim, happy
      , haskell-lexer, pretty, text
···
        license = lib.licenses.mit;
      }) {};
 
-  "primitive-extras_0_10_1_1" = callPackage
+  "primitive-extras_0_10_1_2" = callPackage
     ({ mkDerivation, base, bytestring, cereal, deferred-folds, focus
      , foldl, list-t, primitive, primitive-unlifted, profunctors
      , QuickCheck, quickcheck-instances, rerebase, tasty, tasty-hunit
···
      }:
      mkDerivation {
        pname = "primitive-extras";
-       version = "0.10.1.1";
-       sha256 = "117bgh5bafzvamkpl4g97c8vprs4lndl5pjc3nl6wqj7jbrgpw25";
+       version = "0.10.1.2";
+       sha256 = "0517ln7ihsqb15m0h0nw9qjh73kdwcc2nkg9n39hnmhiw4im9d1i";
        libraryHaskellDepends = [
          base bytestring cereal deferred-folds focus foldl list-t primitive
          primitive-unlifted profunctors vector
···
     ({ mkDerivation, base, bytestring, primitive, stm, text-short }:
      mkDerivation {
        pname = "primitive-unlifted";
-       version = "0.1.3.0";
-       sha256 = "1q7scarsdv51x74g6ahvc5znk9h628s984a7bawig0lnx67wzwih";
+       version = "0.1.3.1";
+       sha256 = "1gilzgclpvz200sybw86nmdm7084nrklscq48cs36qqlgcd0wcwb";
        libraryHaskellDepends = [ base bytestring primitive text-short ];
        testHaskellDepends = [ base primitive stm ];
        description = "Primitive GHC types with unlifted types inside";
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "product-profunctors_0_11_0_3" = callPackage
+    ({ mkDerivation, base, bifunctors, contravariant, criterion
+     , deepseq, profunctors, tagged, template-haskell, th-abstraction
+     }:
+     mkDerivation {
+       pname = "product-profunctors";
+       version = "0.11.0.3";
+       sha256 = "11q9vxj7pnby51gwgm0d17gd6ps2bxwrvajpqaqcg6bsdgdzvjws";
+       libraryHaskellDepends = [
+         base bifunctors contravariant profunctors tagged template-haskell
+         th-abstraction
+       ];
+       testHaskellDepends = [ base profunctors ];
+       benchmarkHaskellDepends = [ base criterion deepseq ];
+       description = "product-profunctors";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "prof-flamegraph" = callPackage
     ({ mkDerivation, base, optparse-applicative }:
      mkDerivation {
···
          tagged transformers
        ];
        description = "Profunctors";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "program" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "program";
+       version = "0.1.0.0";
+       sha256 = "00zzd0fnkjvrazmc9icn0zvzdb6imbw4ajb4fip3w4zv63qzv266";
+       libraryHaskellDepends = [ base ];
+       description = "Programs with Environments and Managed Resources";
        license = lib.licenses.bsd3;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "pusher-http-haskell";
-       version = "2.1.0.6";
-       sha256 = "029pxzidmflsa19417bcx82hbxj3yq1khzb6skf97xbzzf3hs6ki";
+       version = "2.1.0.7";
+       sha256 = "0dk3m4gxcifarmn8l92bqlpn1n6fdmryjazspj0nm1a6r0zc1q9p";
        libraryHaskellDepends = [
          aeson base base16-bytestring bytestring cryptonite hashable
          http-client http-client-tls http-types memory text time
···
      }:
      mkDerivation {
        pname = "quic";
-       version = "0.0.0";
-       sha256 = "0hiyw9qpx7h42ay9jna8xr7vr16jlr62v0nfnq4y29gki38221a4";
+       version = "0.0.1";
+       sha256 = "0vwcfzkz56ldp8fx322vgxrh8g4f236zrv05rg9839x95l6jscsv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "quickcheck-instances_0_3_26_1" = callPackage
+  "quickcheck-instances_0_3_27" = callPackage
     ({ mkDerivation, array, base, bytestring, case-insensitive
      , containers, data-fix, hashable, integer-logarithms, old-time
      , OneTuple, QuickCheck, scientific, splitmix, strict, tagged, text
···
      }:
      mkDerivation {
        pname = "quickcheck-instances";
-       version = "0.3.26.1";
-       sha256 = "0zgsz1sisw3zlxlc5ssir6q4sm1qcvzwkmw50plrna04i0xj8bv4";
-       revision = "1";
-       editedCabalFile = "0saw3pxa8078s671n954wzdmhw3l4q2krcwngw6z9yscw9z1a0j4";
+       version = "0.3.27";
+       sha256 = "10vb3rl1ma9x4qdych9vn8gj9kngkqs2b97f4s6s1a908ddxv4m5";
        libraryHaskellDepends = [
          array base bytestring case-insensitive containers data-fix hashable
          integer-logarithms old-time OneTuple QuickCheck scientific splitmix
···
        broken = true;
      }) {};
 
-  "rattletrap_11_2_3" = callPackage
+  "rattletrap_11_2_4" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, array, base, bytestring
      , containers, filepath, http-client, http-client-tls, text
      }:
      mkDerivation {
        pname = "rattletrap";
-       version = "11.2.3";
-       sha256 = "00hqymw1fbg4crgrd5ixivbpx5qblvp109j0yw8nkzidb4bbdhjj";
+       version = "11.2.4";
+       sha256 = "0cqk2sfh4brm94zvy3d23khxl2x7zrjc0c62ww96549qpvp8za4y";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.mit;
      }) {};
 
+  "rebase_1_13_2" = callPackage
+    ({ mkDerivation, base, bifunctors, bytestring, comonad, containers
+     , contravariant, deepseq, dlist, either, groups, hashable
+     , hashable-time, invariant, mtl, profunctors, scientific, selective
+     , semigroupoids, stm, text, time, transformers
+     , unordered-containers, uuid-types, vector, vector-instances, void
+     }:
+     mkDerivation {
+       pname = "rebase";
+       version = "1.13.2";
+       sha256 = "0lvz4cx9bgny4s5az75clza90nb573vqr8c2ls0bmrsb7sx4p3jh";
+       libraryHaskellDepends = [
+         base bifunctors bytestring comonad containers contravariant deepseq
+         dlist either groups hashable hashable-time invariant mtl
+         profunctors scientific selective semigroupoids stm text time
+         transformers unordered-containers uuid-types vector
+         vector-instances void
+       ];
+       description = "A more progressive alternative to the \"base\" package";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "rebindable" = callPackage
     ({ mkDerivation, base, data-default-class, indexed }:
      mkDerivation {
···
          base bytestring containers filepath gtk mtl process
        ];
        description = "Count lines in files and display them hierarchically";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "recursive-zipper" = callPackage
+    ({ mkDerivation, base, comonad, containers, free, lens, mtl
+     , recursion-schemes, transformers
+     }:
+     mkDerivation {
+       pname = "recursive-zipper";
+       version = "0.0.0.1";
+       sha256 = "0qv8zwss6csbhib840d8r45bkrpnvx832vvi1kl749mh2aywi5rl";
+       libraryHaskellDepends = [
+         base comonad containers free lens mtl recursion-schemes
+         transformers
+       ];
+       description = "Zippers over recursive data structures";
        license = lib.licenses.bsd3;
      }) {};
 
···
        libraryHaskellDepends = [ base stm transformers ];
        description = "A type class for monads with references using type families";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "ref-tf_0_5_0_1" = callPackage
+    ({ mkDerivation, base, stm, transformers }:
+     mkDerivation {
+       pname = "ref-tf";
+       version = "0.5.0.1";
+       sha256 = "0isilgcbw12zyh8s2liaj5r9r5m3yg1xskyhag6f36qi60y29hx5";
+       libraryHaskellDepends = [ base stm transformers ];
+       description = "A type class for monads with references using type families";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "refact" = callPackage
···
      }) {};
 
   "regex-base" = callPackage
-    ({ mkDerivation, array, base, bytestring, containers, mtl, text }:
-     mkDerivation {
-       pname = "regex-base";
-       version = "0.94.0.1";
-       sha256 = "1ngdmmrxs1rhvib052c6shfa40yad82jylylikz327r0zxpxkcbi";
-       revision = "1";
-       editedCabalFile = "19rzll80mpr4licfzz6qfy4i9xbmhxy4r7n1d523db73q09jvzrm";
-       libraryHaskellDepends = [
-         array base bytestring containers mtl text
-       ];
-       description = "Common \"Text.Regex.*\" API for Regex matching";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "regex-base_0_94_0_2" = callPackage
     ({ mkDerivation, array, base, bytestring, containers, text }:
      mkDerivation {
        pname = "regex-base";
···
        libraryHaskellDepends = [ array base bytestring containers text ];
        description = "Common \"Text.Regex.*\" API for Regex matching";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "regex-compat" = callPackage
···
        broken = true;
      }) {};
 
+  "registry_0_2_1_0" = callPackage
+    ({ mkDerivation, async, base, bytestring, containers, directory
+     , exceptions, generic-lens, hashable, hedgehog, io-memoize, mmorph
+     , MonadRandom, mtl, multimap, protolude, random, resourcet
+     , semigroupoids, semigroups, tasty, tasty-discover, tasty-hedgehog
+     , tasty-th, template-haskell, text, transformers-base, universum
+     }:
+     mkDerivation {
+       pname = "registry";
+       version = "0.2.1.0";
+       sha256 = "1qsw33fysnq5lxb48ckcwja7ws99fji5w2hkq7y3nly8yj6mdna3";
+       libraryHaskellDepends = [
+         base containers exceptions hashable mmorph mtl protolude resourcet
+         semigroupoids semigroups template-haskell text transformers-base
+       ];
+       testHaskellDepends = [
+         async base bytestring containers directory exceptions generic-lens
+         hashable hedgehog io-memoize mmorph MonadRandom mtl multimap
+         protolude random resourcet semigroupoids semigroups tasty
+         tasty-discover tasty-hedgehog tasty-th template-haskell text
+         transformers-base universum
+       ];
+       testToolDepends = [ tasty-discover ];
+       description = "data structure for assembling components";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "registry-hedgehog" = callPackage
-    ({ mkDerivation, base, containers, generic-lens, hedgehog, mmorph
-     , multimap, protolude, registry, tasty, tasty-discover
-     , tasty-hedgehog, tasty-th, template-haskell, text, transformers
-     , universum, unordered-containers
+    ({ mkDerivation, base, containers, hedgehog, mmorph, multimap
+     , protolude, registry, tasty, tasty-discover, tasty-hedgehog
+     , tasty-th, template-haskell, text, transformers, universum
+     , unordered-containers
      }:
      mkDerivation {
        pname = "registry-hedgehog";
-       version = "0.4.0.0";
-       sha256 = "0mq5x9a8z70ibq78wx1p1za2f4r1mgrpdy78p5yvxvlzcazwqnp6";
+       version = "0.4.1.0";
+       sha256 = "1wak4bg7fkd1ywacg74snr1wvain62mg62i7wqk5zllypf3rxkxi";
        libraryHaskellDepends = [
          base containers hedgehog mmorph multimap protolude registry tasty
          tasty-discover tasty-hedgehog tasty-th template-haskell text
          transformers universum unordered-containers
        ];
        testHaskellDepends = [
-         base containers generic-lens hedgehog mmorph multimap protolude
-         registry tasty tasty-discover tasty-hedgehog tasty-th
-         template-haskell text transformers universum unordered-containers
+         base containers hedgehog mmorph multimap protolude registry tasty
+         tasty-discover tasty-hedgehog tasty-th template-haskell text
+         transformers universum unordered-containers
        ];
        testToolDepends = [ tasty-discover ];
        description = "utilities to work with Hedgehog generators and `registry`";
···
        maintainers = with lib.maintainers; [ sternenseemann ];
      }) {};
 
+  "rel8_1_2_1_0" = callPackage
+    ({ mkDerivation, aeson, base, bifunctors, bytestring
+     , case-insensitive, comonad, containers, contravariant, hasql
+     , hasql-transaction, hedgehog, mmorph, opaleye, pretty
+     , product-profunctors, profunctors, scientific, semialign
+     , semigroupoids, tasty, tasty-hedgehog, text, these, time
+     , tmp-postgres, transformers, uuid
+     }:
+     mkDerivation {
+       pname = "rel8";
+       version = "1.2.1.0";
+       sha256 = "0f4rnyr90f989ww4hh8h65fhnj16ir144qsin9abc767fxnb7wis";
+       libraryHaskellDepends = [
+         aeson base bifunctors bytestring case-insensitive comonad
+         contravariant hasql opaleye pretty product-profunctors profunctors
+         scientific semialign semigroupoids text these time uuid
+       ];
+       testHaskellDepends = [
+         base bytestring case-insensitive containers hasql hasql-transaction
+         hedgehog mmorph scientific tasty tasty-hedgehog text time
+         tmp-postgres transformers uuid
+       ];
+       description = "Hey! Hey! Can u rel8?";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ sternenseemann ];
+     }) {};
+
   "relacion" = callPackage
     ({ mkDerivation, array, base, containers }:
      mkDerivation {
···
        libraryHaskellDepends = [ rebase ];
        description = "Reexports from \"base\" with a bunch of other standard libraries";
        license = lib.licenses.mit;
+     }) {};
+
+  "rerebase_1_13_2" = callPackage
+    ({ mkDerivation, rebase }:
+     mkDerivation {
+       pname = "rerebase";
+       version = "1.13.2";
+       sha256 = "04bzdyz17azwx6afdys3vh8iydrq6z58j77ib4pwvmz54v2jfcaa";
+       libraryHaskellDepends = [ rebase ];
+       description = "Reexports from \"base\" with a bunch of other standard libraries";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "reroute" = callPackage
···
        ];
        description = "Directed rounding for built-in floating types";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "rounding" = callPackage
···
      }:
      mkDerivation {
        pname = "rrule";
-       version = "0.1.1";
-       sha256 = "0xb0yf0p5r7szb7zxlcc95d22f49s9ql671f1lmvjvzg1jkmsvva";
+       version = "0.1.2";
+       sha256 = "0mq2nlkw7244x2y8qh1m1mpff3ykygr7xrvadjfrx6m6sbp4wl1n";
        libraryHaskellDepends = [
          base megaparsec parser-combinators text time
        ];
···
        license = lib.licenses.mit;
      }) {};
 
+  "safe-json_1_1_2_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, dlist
+     , generic-arbitrary, hashable, quickcheck-instances, scientific
+     , tasty, tasty-hunit, tasty-quickcheck, temporary, text, time
+     , unordered-containers, uuid, uuid-types, vector
+     }:
+     mkDerivation {
+       pname = "safe-json";
+       version = "1.1.2.0";
+       sha256 = "1908s40l6chnxlxnqmn95p8hvr5jbjm8hm5dnjbq7czxpw22x7s2";
+       libraryHaskellDepends = [
+         aeson base bytestring containers dlist hashable scientific tasty
+         tasty-hunit tasty-quickcheck text time unordered-containers
+         uuid-types vector
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers dlist generic-arbitrary hashable
+         quickcheck-instances scientific tasty tasty-hunit tasty-quickcheck
+         temporary text time unordered-containers uuid uuid-types vector
+       ];
+       description = "Automatic JSON format versioning";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "safe-lazy-io" = callPackage
     ({ mkDerivation, base, extensible-exceptions, parallel, strict-io
      }:
···
      }:
      mkDerivation {
        pname = "secure-memory";
-       version = "0.0.0.1";
-       sha256 = "0765lkdnkzdmk3r8hbipxb2brg000jg4dqscqcjjh59lvsiaq367";
+       version = "0.0.0.2";
+       sha256 = "1635ygbqbr6x86y6n88j4d8hlwqskic2ri7vc6fiwsy650zr563q";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "semirings";
        version = "0.6";
        sha256 = "16q535bvjl7395sqkx6zlw48y4fzr7irp44pcp7w9irpn4cncdcr";
+       revision = "1";
+       editedCabalFile = "1c06yhfa053sv3rfz0d72a33l5qb0xmj1b3hy2z7pzxrcay6g1yc";
        libraryHaskellDepends = [
          base base-compat-batteries containers hashable unordered-containers
        ];
···
      }:
      mkDerivation {
        pname = "seonbi";
-       version = "0.3.0";
-       sha256 = "0cn423jydf1nalj5hrnr1mjpfzg78srjh1kmc8bwnv9lhjr3dq36";
+       version = "0.3.1";
+       sha256 = "11hbx3d0d3c08axbxa275rlsa6kgr7p4h6wdwvlpnwmp7h4sgasi";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }) {};
 
   "servant-hmac-auth" = callPackage
-    ({ mkDerivation, aeson, base, base64-bytestring, binary, bytestring
+    ({ mkDerivation, base, base64-bytestring, binary, bytestring
      , case-insensitive, containers, cryptonite, http-client, http-types
-     , markdown-unlit, memory, mtl, servant, servant-client
-     , servant-client-core, servant-server, transformers, wai, warp
+     , memory, mtl, servant, servant-client, servant-client-core
+     , servant-server, transformers, wai
      }:
      mkDerivation {
        pname = "servant-hmac-auth";
-       version = "0.0.0";
-       sha256 = "08873pwmn2wzhl2r87gx6db3f2j8848g4xq2i4gnwqj23s7sfy0z";
-       isLibrary = true;
-       isExecutable = true;
+       version = "0.1.3";
+       sha256 = "057v665rkdblqga71sm4pk7gklwpnrgkwg540ky7mmhmdm2nicj4";
        libraryHaskellDepends = [
          base base64-bytestring binary bytestring case-insensitive
          containers cryptonite http-client http-types memory mtl servant
          servant-client servant-client-core servant-server transformers wai
        ];
-       executableHaskellDepends = [
-         aeson base http-client servant servant-client servant-server warp
-       ];
-       executableToolDepends = [ markdown-unlit ];
        testHaskellDepends = [ base ];
        description = "Servant authentication with HMAC";
        license = lib.licenses.mit;
···
        pname = "shelly";
        version = "1.9.0";
        sha256 = "1kma77gixhyciimh19p64h1ndbcrs9qhk8fgyv71iqh5q57zvday";
-       revision = "1";
-       editedCabalFile = "0827p6wq8j92svrvmx02gdk961xx42g1ng4j6g7nflrfks9hw0zf";
+       revision = "2";
+       editedCabalFile = "0d08dlfgwi2m3wvcmcrcsn2g8lpqzkmxwxw74sysh94qb1gasr0y";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "shh";
-       version = "0.7.1.4";
-       sha256 = "1yriini033kja8w9hrxyfbc62nbwg4fb5nl8rj004gdkbaiz7wbl";
+       version = "0.7.2.0";
+       sha256 = "0rcjvkpxdwvhgn7i1dindhbskr8kwgm977kxgi2xcv398c71014y";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          async base bytestring deepseq directory temporary unix
        ];
        testHaskellDepends = [
-         async base bytestring directory doctest filepath markdown-unlit
-         tasty tasty-hunit tasty-quickcheck utf8-string
+         async base bytestring directory doctest filepath tasty tasty-hunit
+         tasty-quickcheck utf8-string
        ];
        testToolDepends = [ markdown-unlit ];
        description = "Simple shell scripting from Haskell";
···
        pname = "some";
        version = "1.0.3";
        sha256 = "0w3syapwz9v916zf1i4f8vxymdfg7syc2cpxgnqr018pbswzxrk2";
-       revision = "1";
-       editedCabalFile = "14nsajf1n3ba58ljhbk3hk2nr61s896grbi07jvg68dvg7h5rln5";
+       revision = "2";
+       editedCabalFile = "1w3snkgqhrgi2x2bdny9i7a9ybmal3asrh6g6kg8v86kq1gyr34k";
        libraryHaskellDepends = [ base deepseq ];
        testHaskellDepends = [ base ];
        description = "Existential type: Some";
···
        pname = "spacecookie";
        version = "1.0.0.0";
        sha256 = "0v61n5afcrfmj7dd51h4wi7d5hzl4r86wvaymhsi3h4jday58ln0";
+       revision = "1";
+       editedCabalFile = "108pigixhnfgawqhsb6781dhvi4pyv7f5dyww1s4jahi7ix22d44";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        maintainers = with lib.maintainers; [ sternenseemann ];
      }) {};
 
+  "spacecookie_1_0_0_1" = callPackage
+    ({ mkDerivation, aeson, async, attoparsec, base, bytestring
+     , containers, directory, download-curl, fast-logger
+     , filepath-bytestring, hxt-unicode, mtl, process, socket, systemd
+     , tasty, tasty-expected-failure, tasty-hunit, text, transformers
+     , unix
+     }:
+     mkDerivation {
+       pname = "spacecookie";
+       version = "1.0.0.1";
+       sha256 = "1qv48gbq5h1vqinihgzjgljd7igrnypp55kvy9f7q0vyxha5gg88";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         async attoparsec base bytestring containers directory
+         filepath-bytestring hxt-unicode mtl socket text transformers unix
+       ];
+       executableHaskellDepends = [
+         aeson attoparsec base bytestring containers directory fast-logger
+         filepath-bytestring mtl socket systemd text transformers unix
+       ];
+       testHaskellDepends = [
+         attoparsec base bytestring containers directory download-curl
+         filepath-bytestring process tasty tasty-expected-failure
+         tasty-hunit
+       ];
+       description = "Gopher server library and daemon";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ sternenseemann ];
+     }) {};
+
   "spacefill" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "stack-clean-old";
-       version = "0.4.1";
-       sha256 = "08sbgclcbnl67zayps2clgw8xk7s6bbyhm8r0pp4slx9mk4nrv4l";
+       version = "0.4.3";
+       sha256 = "1978fc1v7i6g41fa755sb2lpwbkahr76w5f5bm0iqv5hid536a60";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "step-function";
        version = "0.2";
        sha256 = "1mg7zqqs32zdh1x1738kk0yydyksbhx3y3x8n31f7byk5fvzqq6j";
-       revision = "6";
-       editedCabalFile = "01ncir4kfij1wp591wi333isf20v4sppjfcv27siz6m048cbscg4";
+       revision = "7";
+       editedCabalFile = "0fnzln04c8wvhag730hl3h4wwykizwwg5xzsbw5qd3zzx2fmbywz";
        libraryHaskellDepends = [
          base base-compat-batteries containers deepseq QuickCheck
        ];
···
      }:
      mkDerivation {
        pname = "stm-hamt";
-       version = "1.2.0.6";
-       sha256 = "15jqj31h9ff4g2k3sq35nm122sy0hqapxf4fm5vlkfh33zdn28di";
+       version = "1.2.0.7";
+       sha256 = "1sny6ippahlxhm94888lj19ar36cnjilbw2yza5p223mv0cgnapx";
        libraryHaskellDepends = [
          base deferred-folds focus hashable list-t primitive
          primitive-extras transformers
···
      , base64-bytestring, bifunctors, bytestring, cereal, cereal-vector
      , clock, containers, contravariant, criterion, cryptohash, deepseq
      , directory, filepath, free, ghc-prim, hashable, hspec
-     , hspec-smallcheck, integer-gmp, lifted-base, monad-control
-     , mono-traversable, nats, network, primitive, resourcet, safe
-     , smallcheck, store-core, syb, template-haskell, text, th-lift
-     , th-lift-instances, th-orphans, th-reify-many, th-utilities, time
-     , transformers, unordered-containers, vector
-     , vector-binary-instances, void, weigh
-     }:
-     mkDerivation {
-       pname = "store";
-       version = "0.7.12";
-       sha256 = "1r6wajaxjlh38bivzmcdx8p0x89g04p6alddlibpa356drzl3jbp";
-       revision = "1";
-       editedCabalFile = "073xa2jpgzkds01f405rcl6p574vnf8vyqsmh4vlyhwzn14q5mgi";
-       libraryHaskellDepends = [
-         array async base base-orphans base64-bytestring bifunctors
-         bytestring containers contravariant cryptohash deepseq directory
-         filepath free ghc-prim hashable hspec hspec-smallcheck integer-gmp
-         lifted-base monad-control mono-traversable nats network primitive
-         resourcet safe smallcheck store-core syb template-haskell text
-         th-lift th-lift-instances th-orphans th-reify-many th-utilities
-         time transformers unordered-containers vector void
-       ];
-       testHaskellDepends = [
-         array async base base-orphans base64-bytestring bifunctors
-         bytestring clock containers contravariant cryptohash deepseq
-         directory filepath free ghc-prim hashable hspec hspec-smallcheck
-         integer-gmp lifted-base monad-control mono-traversable nats network
-         primitive resourcet safe smallcheck store-core syb template-haskell
-         text th-lift th-lift-instances th-orphans th-reify-many
-         th-utilities time transformers unordered-containers vector void
-       ];
-       benchmarkHaskellDepends = [
-         array async base base-orphans base64-bytestring bifunctors
-         bytestring cereal cereal-vector containers contravariant criterion
-         cryptohash deepseq directory filepath free ghc-prim hashable hspec
-         hspec-smallcheck integer-gmp lifted-base monad-control
-         mono-traversable nats network primitive resourcet safe smallcheck
-         store-core syb template-haskell text th-lift th-lift-instances
-         th-orphans th-reify-many th-utilities time transformers
-         unordered-containers vector vector-binary-instances void weigh
-       ];
-       description = "Fast binary serialization";
-       license = lib.licenses.mit;
-     }) {};
-
-  "store_0_7_14" = callPackage
-    ({ mkDerivation, array, async, base, base-orphans
-     , base64-bytestring, bifunctors, bytestring, cereal, cereal-vector
-     , clock, containers, contravariant, criterion, cryptohash, deepseq
-     , directory, filepath, free, ghc-prim, hashable, hspec
      , hspec-discover, hspec-smallcheck, integer-gmp, lifted-base
      , monad-control, mono-traversable, nats, network, primitive
      , resourcet, safe, smallcheck, store-core, syb, template-haskell
···
        ];
        description = "Fast binary serialization";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "store-core" = callPackage
···
        maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
-  "streamly_0_8_0" = callPackage
+  "streamly_0_8_1" = callPackage
     ({ mkDerivation, atomic-primops, base, containers, deepseq
-     , directory, exceptions, fusion-plugin-types, ghc-prim, heaps
-     , lockfree-queue, monad-control, mtl, network, primitive
-     , transformers, transformers-base
+     , directory, exceptions, filepath, fusion-plugin-types, ghc-prim
+     , heaps, lockfree-queue, monad-control, mtl, network, primitive
+     , transformers, transformers-base, unicode-data
      }:
      mkDerivation {
        pname = "streamly";
-       version = "0.8.0";
-       sha256 = "1ng1zfayk21z03rr3m1kwhrj0if4yl3nggp971r25rks9rb01il5";
-       revision = "1";
-       editedCabalFile = "1fb1klpvgdp3igxqii8ksbn101hfwwgh8n7gslw29b7bjkwyy4q5";
+       version = "0.8.1";
+       sha256 = "0ix78q3fxjdvi7094wl14242i2i7xqybnrikzlgcjhbk8rz6sgfz";
        libraryHaskellDepends = [
          atomic-primops base containers deepseq directory exceptions
-         fusion-plugin-types ghc-prim heaps lockfree-queue monad-control mtl
-         network primitive transformers transformers-base
+         filepath fusion-plugin-types ghc-prim heaps lockfree-queue
+         monad-control mtl network primitive transformers transformers-base
+         unicode-data
        ];
        description = "Dataflow programming and declarative concurrency";
        license = lib.licenses.bsd3;
···
        pname = "string-interpolate";
        version = "0.3.1.1";
        sha256 = "0hhzvrs9msyqsxwsqqm55lyxf85vhg4vcsszl735zsbs7431av69";
-       revision = "1";
-       editedCabalFile = "1grn08zg3n26d58al25hvg6czbliabrlf1srlhymjdvkvd4a5i4y";
+       revision = "2";
+       editedCabalFile = "1blxy1ld69i8bg2340j0dcrcbdrqqnx5q8v47jda6183jfzwrxr6";
        libraryHaskellDepends = [
          base bytestring haskell-src-exts haskell-src-meta split
          template-haskell text text-conversions utf8-string
···
      }:
      mkDerivation {
        pname = "swiss-ephemeris";
-       version = "1.4.0.0";
-       sha256 = "0ss502h2083qbiprspylwv02lbgidqgi106qs6k4s6jppgay34gx";
+       version = "1.4.1.0";
+       sha256 = "1a1c8rx3jnlshf1bffpjx6al8v0a46ya3cwmvrh58hwy7ci320bm";
        libraryHaskellDepends = [ base time vector ];
        testHaskellDepends = [
          base directory hspec QuickCheck random time vector
···
        description = "A modern testing framework for Haskell with good defaults and advanced testing features";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {autodocodec = null; autodocodec-yaml = null;};
+     }) {};
 
   "sydtest-aeson" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, path
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "tagtree" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, data-default
+     , filepattern, megaparsec, parser-combinators, relude, text
+     }:
+     mkDerivation {
+       pname = "tagtree";
+       version = "0.1.0.0";
+       sha256 = "1gmfw1znz4n6a08fpi0g4jkkz1m03yl59v1yj1w6kmlvyzf6dw1z";
+       libraryHaskellDepends = [
+         aeson base bytestring containers data-default filepattern
+         megaparsec parser-combinators relude text
+       ];
+       description = "Hierarchical Tags & Tag Trees";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "tai" = callPackage
     ({ mkDerivation, base, clock, lens, mtl, parsers, time, trifecta
      , wreq
···
      }:
      mkDerivation {
        pname = "taskwarrior";
-       version = "0.3.0.0";
-       sha256 = "1h24d799q1s6b36hd40bxa4c9m1izkgh6j7p2jv1p6cxngz28ni0";
-       revision = "6";
-       editedCabalFile = "02jag4yib1fqf2fp9p323hb3vsbkrqm1k9zp2wag6ysl5kvvq1x6";
+       version = "0.3.1.0";
+       sha256 = "04cnrzl9rj9zhdbk9g6hjsvd69v3g6w8d2jkh51a2pqjrw4bljf0";
        libraryHaskellDepends = [
          aeson base bytestring containers process random text time
          unordered-containers uuid
···
        maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
-  "taskwarrior_0_4_0_0" = callPackage
+  "taskwarrior_0_6_0_1" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, hspec
      , hspec-discover, process, QuickCheck, quickcheck-instances, random
      , text, time, uuid
      }:
      mkDerivation {
        pname = "taskwarrior";
-       version = "0.4.0.0";
-       sha256 = "0f815vfhabry64zjwjp48cdcnk875bx2a8c1ix8lxsa700g2rmav";
+       version = "0.6.0.1";
+       sha256 = "0g7g03hnlij7ggrq0rlxy4gay6b8f9j1yxm71y4yb80wnrj9lgwf";
        libraryHaskellDepends = [
          aeson base bytestring containers process random text time uuid
        ];
···
        license = lib.licenses.mit;
      }) {};
 
+  "tasty_1_4_2_1" = callPackage
+    ({ mkDerivation, ansi-terminal, base, clock, containers, mtl
+     , optparse-applicative, stm, tagged, unbounded-delays, unix
+     , wcwidth
+     }:
+     mkDerivation {
+       pname = "tasty";
+       version = "1.4.2.1";
+       sha256 = "0ki3gdzfsqvk9mwzzvgj18ck1sbkwac06gcc128wpwh9g8c4bzqr";
+       revision = "1";
+       editedCabalFile = "1fm1yx9dqikspw3a6ygnwj61vx1zwgjxm84zpkydbhcf6hgab5sg";
+       libraryHaskellDepends = [
+         ansi-terminal base clock containers mtl optparse-applicative stm
+         tagged unbounded-delays unix wcwidth
+       ];
+       description = "Modern and extensible testing framework";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "tasty-ant-xml" = callPackage
     ({ mkDerivation, base, containers, directory, filepath
      , generic-deriving, ghc-prim, mtl, stm, tagged, tasty, transformers
···
        testHaskellDepends = [ base pcre-light tasty tasty-hunit ];
        description = "QuickCheck support for the Tasty test framework";
        license = lib.licenses.mit;
+     }) {};
+
+  "tasty-quickcheck_0_10_2" = callPackage
+    ({ mkDerivation, base, optparse-applicative, pcre-light, QuickCheck
+     , random, tagged, tasty, tasty-hunit
+     }:
+     mkDerivation {
+       pname = "tasty-quickcheck";
+       version = "0.10.2";
+       sha256 = "1qnc6rdvjvlw08q6sln2n98rvj0s0pp689h6w4z58smjbn0lr25l";
+       libraryHaskellDepends = [
+         base optparse-applicative QuickCheck random tagged tasty
+       ];
+       testHaskellDepends = [ base pcre-light tasty tasty-hunit ];
+       description = "QuickCheck support for the Tasty test framework";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "tasty-quickcheck-laws" = callPackage
···
 
   "tesla" = callPackage
     ({ mkDerivation, aeson, base, base64-bytestring, bytestring, casing
-     , containers, cryptonite, exceptions, generic-deriving, http-client
-     , HUnit, lens, lens-aeson, memory, monad-logger, mtl, random, retry
-     , tagsoup, tasty, tasty-hunit, tasty-quickcheck, template-haskell
-     , text, time, unliftio-core, vector, wreq
+     , containers, cryptonite, exceptions, finite-typelits
+     , generic-deriving, http-client, HUnit, lens, lens-aeson, memory
+     , monad-logger, mtl, random, retry, tagsoup, tasty, tasty-hunit
+     , tasty-quickcheck, template-haskell, text, time, unliftio-core
+     , vector, wreq
      }:
      mkDerivation {
        pname = "tesla";
-       version = "0.4.1.3";
-       sha256 = "1g4kl1lnbx37ffqir3w20j5aifl3196cnb28366c77jmp9dmwxna";
+       version = "0.5.0.0";
+       sha256 = "1nlzibxw9ayb2yjhpfky0sxd8q44ss8hxvgs4vi9xkw4afymr2w5";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring casing containers
-         cryptonite exceptions generic-deriving http-client lens lens-aeson
-         memory monad-logger mtl random retry tagsoup template-haskell text
-         time unliftio-core vector wreq
+         cryptonite exceptions finite-typelits generic-deriving http-client
+         lens lens-aeson memory monad-logger mtl random retry tagsoup
+         template-haskell text time unliftio-core vector wreq
        ];
        testHaskellDepends = [
          aeson base base64-bytestring bytestring casing containers
-         cryptonite exceptions generic-deriving http-client HUnit lens
-         lens-aeson memory monad-logger mtl random retry tagsoup tasty
-         tasty-hunit tasty-quickcheck template-haskell text time
+         cryptonite exceptions finite-typelits generic-deriving http-client
+         HUnit lens lens-aeson memory monad-logger mtl random retry tagsoup
+         tasty tasty-hunit tasty-quickcheck template-haskell text time
          unliftio-core vector wreq
        ];
        description = "Tesla API client";
···
        pname = "test-framework";
        version = "0.8.2.0";
        sha256 = "1hhacrzam6b8f10hyldmjw8pb7frdxh04rfg3farxcxwbnhwgbpm";
-       revision = "7";
-       editedCabalFile = "0an5fypqx6r9v3ql5n9xwdxnaq922lpwh759z5y6vx8rasnd98jw";
+       revision = "8";
+       editedCabalFile = "1sal1qqvc8c1rvsqz292bniy1kr5rx6ll7z9chwsz6j2ncw5sgmg";
        libraryHaskellDepends = [
          ansi-terminal ansi-wl-pprint base containers hostname old-locale
          random regex-posix time xml
···
        license = lib.licenses.gpl2Only;
      }) {};
 
+  "texmath_0_12_3_3" = callPackage
+    ({ mkDerivation, base, bytestring, containers, directory, filepath
+     , mtl, pandoc-types, parsec, process, split, syb, temporary, text
+     , utf8-string, xml
+     }:
+     mkDerivation {
+       pname = "texmath";
+       version = "0.12.3.3";
+       sha256 = "0zccnb61z0l2h6yzvnqh78bhqrqjd8237rrw4llsyzz149m7j3n8";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers mtl pandoc-types parsec split syb text xml
+       ];
+       testHaskellDepends = [
+         base bytestring directory filepath process temporary text
+         utf8-string xml
+       ];
+       description = "Conversion between formats used to represent mathematics";
+       license = lib.licenses.gpl2Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "texrunner" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, directory, filepath
      , HUnit, io-streams, lens, mtl, process, semigroups, temporary
···
        pname = "text-ansi";
        version = "0.1.1";
        sha256 = "1vcrsg7v8n6znh1pd9kbm20bc6dg3zijd3xjdjljadf15vfkd5f6";
-       revision = "1";
-       editedCabalFile = "09s363h3lw4p8f73m7vw0d1cqnwmap9ndrfxd4qbzbra5xf58q38";
+       revision = "2";
+       editedCabalFile = "03r5318sxzxykms6jjmry6mkm4zy83ajamk727jym9r9kp16dkmc";
        libraryHaskellDepends = [ base text ];
        description = "Text styling for ANSI terminals";
        license = lib.licenses.bsd3;
···
        pname = "text-display";
        version = "0.0.1.0";
        sha256 = "0ljh2pxwk6nl37z6az83wh50lvh5mr0gwxjc1vwnwva62yg3f0nx";
+       revision = "1";
+       editedCabalFile = "1094rlcqs2dl6j0gapaspvl80dv4k34r1lpqqz6xnxwb33s4padq";
        libraryHaskellDepends = [ base bytestring text ];
        testHaskellDepends = [
          base bytestring hspec should-not-typecheck text
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "text-show-instances_3_8_5" = callPackage
+  "text-show-instances_3_8_6" = callPackage
     ({ mkDerivation, base, base-compat-batteries, bifunctors, binary
      , containers, directory, generic-deriving, ghc-boot-th, ghc-prim
      , haskeline, hpc, hspec, hspec-discover, old-locale, old-time
-     , pretty, QuickCheck, quickcheck-instances, random, semigroups
-     , tagged, template-haskell, terminfo, text, text-short, text-show
-     , th-orphans, time, transformers, transformers-compat, unix
-     , unordered-containers, vector, xhtml
+     , pretty, QuickCheck, quickcheck-instances, random, scientific
+     , semigroups, tagged, template-haskell, terminfo, text, text-short
+     , text-show, th-orphans, time, transformers, transformers-compat
+     , unix, unordered-containers, vector, xhtml
      }:
      mkDerivation {
        pname = "text-show-instances";
-       version = "3.8.5";
-       sha256 = "1qpkap6p57js8x4b3hm0xnk3xbyv8w1g6w84qda49dv6x67chyn3";
+       version = "3.8.6";
+       sha256 = "1jg1wsjnp6q68nsynwzw26s4akr0d9a4frd9dvnddalm2c6vdwaz";
        libraryHaskellDepends = [
          base base-compat-batteries bifunctors binary containers directory
          ghc-boot-th haskeline hpc old-locale old-time pretty random
-         semigroups tagged template-haskell terminfo text text-short
-         text-show time transformers transformers-compat unix
+         scientific semigroups tagged template-haskell terminfo text
+         text-short text-show time transformers transformers-compat unix
          unordered-containers vector xhtml
        ];
        testHaskellDepends = [
          base base-compat-batteries bifunctors binary containers directory
          generic-deriving ghc-boot-th ghc-prim haskeline hpc hspec
          old-locale old-time pretty QuickCheck quickcheck-instances random
-         tagged template-haskell terminfo text-short text-show th-orphans
-         time transformers transformers-compat unix unordered-containers
-         vector xhtml
+         scientific tagged template-haskell terminfo text-short text-show
+         th-orphans time transformers transformers-compat unix
+         unordered-containers vector xhtml
        ];
        testToolDepends = [ hspec-discover ];
        description = "Additional instances for text-show";
···
      }) {};
 
   "th-extras" = callPackage
-    ({ mkDerivation, base, syb, template-haskell }:
+    ({ mkDerivation, base, containers, syb, template-haskell
+     , th-abstraction
+     }:
      mkDerivation {
        pname = "th-extras";
-       version = "0.0.0.4";
-       sha256 = "1vgvqgfm2lvx6v5r2mglwyl63647c9n6b9a5ikqc93pjm98g9vwg";
-       libraryHaskellDepends = [ base syb template-haskell ];
+       version = "0.0.0.5";
+       sha256 = "03pfwadxxnabkpy1i6jmmgk6p8w3r9cn3xz7d7jvzqsig70mnpim";
+       libraryHaskellDepends = [
+         base containers syb template-haskell th-abstraction
+       ];
        description = "A grab bag of functions for use with Template Haskell";
        license = lib.licenses.publicDomain;
      }) {};
···
        pname = "through-text";
        version = "0.1.0.0";
        sha256 = "1kdl36n98kajaa7v7js2sy8bi09p8rrxmlfcclcfc1l92bd2aclk";
-       revision = "6";
-       editedCabalFile = "12mqlm77g0fymx3xwlkf6s9nqivcf78szhrzkvssi7lq1lqq9lbc";
+       revision = "7";
+       editedCabalFile = "0cgh3sxd7ms5wdrrr174jf7pf6n7c66srpsmg3yk8h8msnrvw1qr";
        libraryHaskellDepends = [ base bytestring case-insensitive text ];
        description = "Convert textual types through Text without needing O(n^2) instances";
        license = lib.licenses.bsd3;
···
        pname = "timeit";
        version = "2.0";
        sha256 = "1sliqpvl501rlcj6s0lhmsf5ym24j4h881wzc1f1wdyvg3jz8kd1";
-       revision = "1";
-       editedCabalFile = "0d4vjg48xyqjmydnjqjxica0zr30vgb91b3vv75cig686ikpjmq7";
+       revision = "2";
+       editedCabalFile = "1vgxfk2021jh6jk3dimchmf9f71844zj080342qvnn5lck7c7mrm";
        libraryHaskellDepends = [ base ];
        description = "Time monadic computations with an IO base";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "timezone-olson-th";
-       version = "0.1.0.5";
-       sha256 = "1b28drcgdal7ifghw9bk3k8rmk7k0mjq3kl55xqbnlip6p99pka7";
+       version = "0.1.0.10";
+       sha256 = "0lks0mgshcsq36aminfbrz524mgn5q02lwln8lli1l54d8bn4x8n";
        libraryHaskellDepends = [
          base template-haskell time timezone-olson timezone-series
        ];
···
      }:
      mkDerivation {
        pname = "trifecta";
-       version = "2.1.1";
-       sha256 = "1lhzi0xxvilvgjy3yf3f85wfmrks562hhsnl0kg1xwji36rgwp6y";
-       libraryHaskellDepends = [
-         ansi-terminal array base blaze-builder blaze-html blaze-markup
-         bytestring charset comonad containers deepseq fingertree ghc-prim
-         hashable indexed-traversable lens mtl parsers prettyprinter
-         prettyprinter-ansi-terminal profunctors reducers transformers
-         unordered-containers utf8-string
-       ];
-       testHaskellDepends = [ base parsers QuickCheck ];
-       description = "A modern parser combinator library with convenient diagnostics";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "trifecta_2_1_2" = callPackage
-    ({ mkDerivation, ansi-terminal, array, base, blaze-builder
-     , blaze-html, blaze-markup, bytestring, charset, comonad
-     , containers, deepseq, fingertree, ghc-prim, hashable
-     , indexed-traversable, lens, mtl, parsers, prettyprinter
-     , prettyprinter-ansi-terminal, profunctors, QuickCheck, reducers
-     , transformers, unordered-containers, utf8-string
-     }:
-     mkDerivation {
-       pname = "trifecta";
        version = "2.1.2";
        sha256 = "1akx8m6mgskwsbhsf90cxlqjq23jk4pwaxagvm923dpncwrlwfla";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base parsers QuickCheck ];
        description = "A modern parser combinator library with convenient diagnostics";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "trigger" = callPackage
···
 
   "turtle" = callPackage
     ({ mkDerivation, ansi-wl-pprint, async, base, bytestring, clock
-     , containers, criterion, directory, doctest, exceptions, foldl
-     , hostname, managed, optional-args, optparse-applicative, process
-     , stm, streaming-commons, system-fileio, system-filepath, temporary
-     , text, time, transformers, unix, unix-compat
+     , containers, directory, doctest, exceptions, foldl, hostname
+     , managed, optional-args, optparse-applicative, process, stm
+     , streaming-commons, system-fileio, system-filepath, tasty-bench
+     , temporary, text, time, transformers, unix, unix-compat
      }:
      mkDerivation {
        pname = "turtle";
-       version = "1.5.22";
-       sha256 = "14lf43b5rxci6p9sy1gkb715m4b1s4rl65swn2qpdqv3h2yvpi4s";
+       version = "1.5.23";
+       sha256 = "02g0a6az01lfikrinx2027zqrp8wyivldwi36s2yqk9a5qm3ap5c";
        libraryHaskellDepends = [
          ansi-wl-pprint async base bytestring clock containers directory
          exceptions foldl hostname managed optional-args
···
          system-filepath temporary text time transformers unix unix-compat
        ];
        testHaskellDepends = [ base doctest system-filepath temporary ];
-       benchmarkHaskellDepends = [ base criterion text ];
+       benchmarkHaskellDepends = [ base tasty-bench text ];
        description = "Shell programming, Haskell-style";
        license = lib.licenses.bsd3;
        maintainers = with lib.maintainers; [ Gabriel439 ];
···
   "twitter-conduit" = callPackage
     ({ mkDerivation, aeson, attoparsec, authenticate-oauth, base
      , bytestring, Cabal, cabal-doctest, conduit, conduit-extra
-     , containers, data-default, doctest, exceptions, ghc-prim, hspec
-     , hspec-discover, http-client, http-conduit, http-types, lens
-     , lens-aeson, resourcet, text, time, transformers, twitter-types
-     , twitter-types-lens
+     , containers, data-default, deepseq, doctest, exceptions, ghc-prim
+     , hspec, hspec-discover, http-client, http-conduit, http-types
+     , lens, lens-aeson, resourcet, text, time, transformers
+     , twitter-types, twitter-types-lens
      }:
      mkDerivation {
        pname = "twitter-conduit";
-       version = "0.6.0";
-       sha256 = "1gln8dsq8krvabknlpzxfaij8mwky4kca34m666wqfsfzgvkni8p";
+       version = "0.6.1";
+       sha256 = "06fbcbx4cyi1m4qvxc16qfn66fnv5lp3naawqf6xw6yj3lczzh6w";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          aeson attoparsec authenticate-oauth base bytestring conduit
-         conduit-extra containers data-default exceptions ghc-prim
+         conduit-extra containers data-default deepseq exceptions ghc-prim
          http-client http-conduit http-types lens lens-aeson resourcet text
          time transformers twitter-types twitter-types-lens
        ];
···
        license = lib.licenses.mit;
      }) {};
 
+  "typed-process_0_2_8_0" = callPackage
+    ({ mkDerivation, async, base, base64-bytestring, bytestring, hspec
+     , process, stm, temporary, transformers, unliftio-core
+     }:
+     mkDerivation {
+       pname = "typed-process";
+       version = "0.2.8.0";
+       sha256 = "1af0g34sws7fppziv7firr9r2wrnly4y6sr9nyqa8bvbbmadly45";
+       libraryHaskellDepends = [
+         async base bytestring process stm transformers unliftio-core
+       ];
+       testHaskellDepends = [
+         async base base64-bytestring bytestring hspec process stm temporary
+         transformers unliftio-core
+       ];
+       description = "Run external processes, with strong typing of streams";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "typed-spreadsheet" = callPackage
     ({ mkDerivation, async, base, diagrams-cairo, diagrams-gtk
      , diagrams-lib, foldl, gtk, microlens, stm, text, transformers
···
        license = lib.licenses.mit;
      }) {};
 
+  "typed-uuid_0_2_0_0" = callPackage
+    ({ mkDerivation, aeson, autodocodec, base, binary, bytestring
+     , deepseq, hashable, http-api-data, random, text, uuid, validity
+     , validity-uuid
+     }:
+     mkDerivation {
+       pname = "typed-uuid";
+       version = "0.2.0.0";
+       sha256 = "1f97q4vxr30sinbcilhyizhri4gkq68yzw6pnv2dh2bdy1nd2yqk";
+       libraryHaskellDepends = [
+         aeson autodocodec base binary bytestring deepseq hashable
+         http-api-data random text uuid validity validity-uuid
+       ];
+       description = "Phantom-Typed version of UUID";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "typed-wire" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, directory
      , filepath, gitrev, HTF, http-types, mtl, optparse-applicative
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "unagi-chan_0_4_1_4" = callPackage
+    ({ mkDerivation, async, atomic-primops, base, containers, criterion
+     , ghc-prim, primitive
+     }:
+     mkDerivation {
+       pname = "unagi-chan";
+       version = "0.4.1.4";
+       sha256 = "1d98a6s7rydjlf2p3jv6j7wglq8ahf8kgcibji5fiy6y0ymz9mnr";
+       libraryHaskellDepends = [ atomic-primops base ghc-prim primitive ];
+       testHaskellDepends = [
+         atomic-primops base containers ghc-prim primitive
+       ];
+       benchmarkHaskellDepends = [ async base criterion ];
+       description = "Fast concurrent queues with a Chan-like API, and more";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "unagi-streams" = callPackage
     ({ mkDerivation, base, io-streams, unagi-chan }:
      mkDerivation {
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "unicode-data";
-       version = "0.1.0.1";
-       sha256 = "1rxybzbls2l732gj5ql0ccmlzsmcncaw22g0l9bc2ism0i2qf2gz";
+       version = "0.2.0";
+       sha256 = "1vn1kzy49k314gprpi8ls91vs5xrjwwxklzgnxx0krcpjq8zy100";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
···
     ({ mkDerivation, base, hspec, QuickCheck }:
      mkDerivation {
        pname = "unicode-show";
-       version = "0.1.0.5";
-       sha256 = "0iq2fivi6fclra32y5yqc6p18pd7qlyxb042hkc082pvgmj8b40v";
-       libraryHaskellDepends = [ base ];
-       testHaskellDepends = [ base hspec QuickCheck ];
-       description = "print and show in unicode";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "unicode-show_0_1_1_0" = callPackage
-    ({ mkDerivation, base, hspec, QuickCheck }:
-     mkDerivation {
-       pname = "unicode-show";
        version = "0.1.1.0";
        sha256 = "1g945vkj75vrm4c3v79c61hlhx3s6q5v0lm92bjzf29r45clnzsi";
        libraryHaskellDepends = [ base ];
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "unicode-transforms_0_3_8" = callPackage
-    ({ mkDerivation, base, bytestring, deepseq, filepath
-     , getopt-generics, ghc-prim, hspec, path, path-io, QuickCheck
-     , split, tasty-bench, text, unicode-data
+  "unicode-transforms_0_4_0" = callPackage
+    ({ mkDerivation, base, bytestring, deepseq, filepath, ghc-prim
+     , hspec, path, path-io, QuickCheck, split, tasty-bench, text
+     , unicode-data
      }:
      mkDerivation {
        pname = "unicode-transforms";
-       version = "0.3.8";
-       sha256 = "1j3dwz3qmak3fyb1p4qzr1rnxch2ydqfp2jizyy4rv425h0smxzl";
+       version = "0.4.0";
+       sha256 = "0m234yhjizl28xm8y08bdhrbni666r7q2z71a8s64lynqk4lzq5k";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          base bytestring ghc-prim text unicode-data
        ];
        testHaskellDepends = [
-         base deepseq getopt-generics hspec QuickCheck split text
-         unicode-data
+         base deepseq hspec QuickCheck split text unicode-data
        ];
        benchmarkHaskellDepends = [
          base deepseq filepath path path-io tasty-bench text
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
+     }) {};
+
+  "unionmount" = callPackage
+    ({ mkDerivation, async, base, bytestring, containers, data-default
+     , directory, filepath, filepattern, fsnotify, lvar, monad-logger
+     , mtl, relude, text, time, unliftio, with-utf8
+     }:
+     mkDerivation {
+       pname = "unionmount";
+       version = "0.1.0.0";
+       sha256 = "05i7bh8dg8bcm8070hxdh8fc2y0l2v25bvsqmbvnlbrlfcijphg6";
+       libraryHaskellDepends = [
+         async base bytestring containers data-default directory filepath
+         filepattern fsnotify lvar monad-logger mtl relude text time
+         unliftio with-utf8
+       ];
+       description = "Union mount filesystem paths into Haskell datastructures";
+       license = lib.licenses.mit;
      }) {};
 
   "unipatterns" = callPackage
···
        pname = "universe-base";
        version = "1.1.3";
        sha256 = "0lnvjpndqj7kk3f95dmpa62ax0m243h8iy7ghcsd2db4nyczx7f5";
+       revision = "2";
+       editedCabalFile = "1fr7w3qc46aph0xxya8jw1a4gqzvq03f6vpx75pam9ynfndz8gw0";
        libraryHaskellDepends = [
          base containers OneTuple tagged transformers
        ];
···
        pname = "universe-some";
        version = "1.2.1";
        sha256 = "0pdvk5qi39d0wg8ac936c1fxs7v7qld2ggpqc9v7xc4pk3xq24bp";
-       revision = "1";
-       editedCabalFile = "1hrb5anm2cp2a8zhhzazxc8zjm2nm8q7zvl1c4shx7arpi1ka3ax";
+       revision = "2";
+       editedCabalFile = "0haz8fprwxx22jg4394p7a6zll8jim2hcb1rjy366vslwlczr03z";
        libraryHaskellDepends = [
          base some template-haskell th-abstraction transformers
   "instance-map" = callPackage
···
 
   "validated-literals" = callPackage
     ({ mkDerivation, base, bytestring, deepseq, tasty, tasty-hunit
-     , tasty-travis, template-haskell
+     , tasty-travis, template-haskell, th-compat
      }:
      mkDerivation {
        pname = "validated-literals";
-       version = "0.3.0";
-       sha256 = "1k77jp19kl7h4v9hl2jhsmbq8dhzl8z9sgkw1jxx1rblm3fszjx1";
-       revision = "4";
-       editedCabalFile = "16fwvivw1barrgkw7cl2hfgksfhambfmhrwibhi6n8096sj79h0j";
-       libraryHaskellDepends = [ base template-haskell ];
+       version = "0.3.1";
+       sha256 = "0s6ag8wm19qzfhxpz686nsmvrf3lhbq1g5fcck6d97lij559xlvg";
+       libraryHaskellDepends = [ base template-haskell th-compat ];
        testHaskellDepends = [
          base bytestring deepseq tasty tasty-hunit tasty-travis
-         template-haskell
+         template-haskell th-compat
        ];
        description = "Compile-time checking for partial smart-constructors";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "validation";
-       version = "1.1.1";
-       sha256 = "1dv7azpljdcf7irbnznnz31hq611bn1aj2m6ywghz3hgv835qqak";
-       libraryHaskellDepends = [
-         assoc base bifunctors deepseq lens semigroupoids semigroups
-       ];
-       testHaskellDepends = [ base hedgehog HUnit lens semigroups ];
-       description = "A data-type like Either but with an accumulating Applicative";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "validation_1_1_2" = callPackage
-    ({ mkDerivation, assoc, base, bifunctors, deepseq, hedgehog, HUnit
-     , lens, semigroupoids, semigroups
-     }:
-     mkDerivation {
-       pname = "validation";
        version = "1.1.2";
        sha256 = "15hhz2kj6h9zv568bvq79ymck3s3b89fpkasdavbwvyhfyjm5k8x";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base hedgehog HUnit lens semigroups ];
        description = "A data-type like Either but with an accumulating Applicative";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "validation-selective" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "validity_0_12_0_0" = callPackage
+    ({ mkDerivation, base, hspec }:
+     mkDerivation {
+       pname = "validity";
+       version = "0.12.0.0";
+       sha256 = "03md04q3ymilgc1pssczij392bphmg9ld6aa0fwfwjyjlqjj67fk";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base hspec ];
+       description = "Validity typeclass";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "validity-aeson" = callPackage
     ({ mkDerivation, aeson, base, hspec, validity, validity-scientific
      , validity-text, validity-unordered-containers, validity-vector
···
        license = lib.licenses.mit;
      }) {};
 
+  "validity-text_0_3_1_2" = callPackage
+    ({ mkDerivation, base, bytestring, text, validity }:
+     mkDerivation {
+       pname = "validity-text";
+       version = "0.3.1.2";
+       sha256 = "00sfiykazz2iwwr43lxl0q6dn03jpf515k0s8hymqpychmflyqhi";
+       libraryHaskellDepends = [ base bytestring text validity ];
+       description = "Validity instances for text";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "validity-time" = callPackage
     ({ mkDerivation, base, time, validity }:
      mkDerivation {
···
        license = lib.licenses.mit;
      }) {};
 
+  "validity-time_0_5_0_0" = callPackage
+    ({ mkDerivation, base, time, validity }:
+     mkDerivation {
+       pname = "validity-time";
+       version = "0.5.0.0";
+       sha256 = "1ik3syh9hd7jcfydp7fj8rghxl6zjs6lcm1f0xadm0czw6gb82k1";
+       libraryHaskellDepends = [ base time validity ];
+       description = "Validity instances for time";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "validity-unordered-containers" = callPackage
     ({ mkDerivation, base, hashable, unordered-containers, validity }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "vector-extras";
-       version = "0.2.1.1";
-       sha256 = "0q5wm0hfk84hr9rgbb084d222ys0k1hab5cydwnnrpb7wy42199p";
+       version = "0.2.2.2";
+       sha256 = "1xlwfdyqmf0z2g3fmisz4gfz1f7y8db5446vkbp5qwlq3r1m6acd";
        libraryHaskellDepends = [
          base containers deferred-folds foldl hashable unordered-containers
          vector
···
        pname = "vgrep";
        version = "0.2.3.0";
        sha256 = "1zzzmvhqcvgvni96b1zzqjwpmlncsjd08sqllrbp4d4a7j43b9g5";
+       revision = "1";
+       editedCabalFile = "1avwygy2xrh9z1dj5k4gb0r1pwrrljd9l1hgpc8y4h4w97hxwbi3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "visualize-cbn";
        version = "0.1.0.2";
        sha256 = "1vlidljhy0ykflgf7k8gawlqazcrkvcs7r8wbv7h9x6wfnx0w334";
+       revision = "1";
+       editedCabalFile = "04cb9j0m83g6qix3lwh62l56kk8qvpzsv3ia8yw43aw9zi4jnrc3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "vulkan";
-       version = "3.13.4";
-       sha256 = "0vjvm54d42m7p7717dsckp5i1wy0zzf70rpq16xdppkzr265h7kg";
+       version = "3.14.1";
+       sha256 = "1ai8iw41z43l4x3x7hpdb0c0fxl4c4mc86g0r00m617056756732";
        libraryHaskellDepends = [ base bytestring transformers vector ];
        libraryPkgconfigDepends = [ vulkan ];
        testHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "vulkan-utils";
-       version = "0.5.3";
-       sha256 = "16p1yn72il988phw4h8ixs0p2dgk96xg26yp9lgbpri1l0da8kiq";
+       version = "0.5.4";
+       sha256 = "1mkx2h7yjmq8djgg1pi3vlx2pq4armasa1hvam955p3x09vwbisk";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base bytestring containers dependent-map dependent-sum extra
···
      }:
      mkDerivation {
        pname = "warp";
-       version = "3.3.17";
-       sha256 = "0v54ca3wpa79gdyiikwhbv9h8b5vr3d60piq3ndb2v7s7fi1qpm0";
+       version = "3.3.18";
+       sha256 = "1m93s3p2zz00fdgkisl6sbnqnc6vvq0vz997i5y4mk9a3ssjflqw";
        libraryHaskellDepends = [
          array auto-update base bsb-http-chunked bytestring case-insensitive
          containers ghc-prim hashable http-date http-types http2 iproute
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "wild-bind_0_1_2_8" = callPackage
+    ({ mkDerivation, base, containers, hspec, hspec-discover, microlens
+     , QuickCheck, semigroups, stm, text, transformers
+     }:
+     mkDerivation {
+       pname = "wild-bind";
+       version = "0.1.2.8";
+       sha256 = "1ag0lwh5pii8z356sii2zm2i7qyk9q9j7ivc3x0fkvz6p5gk1aj1";
+       libraryHaskellDepends = [
+         base containers semigroups text transformers
+       ];
+       testHaskellDepends = [
+         base hspec microlens QuickCheck stm transformers
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Dynamic key binding framework";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "wild-bind-indicator" = callPackage
     ({ mkDerivation, async, base, containers, gi-gdk, gi-glib, gi-gtk
      , text, transformers, wild-bind
···
        testToolDepends = [ hspec-discover ];
        description = "X11-specific implementation for WildBind";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "wild-bind-x11_0_2_0_14" = 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.14";
+       sha256 = "0qxzv4xvqqm7xcz17a3h1pgc3g84dp3676vb40yi9dfxdwag3xxs";
+       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
···
        maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
+  "witch_0_3_4_1" = callPackage
+    ({ mkDerivation, base, bytestring, containers, HUnit
+     , template-haskell, text, time
+     }:
+     mkDerivation {
+       pname = "witch";
+       version = "0.3.4.1";
+       sha256 = "12nrikciqg85lnkncdibs65z0psn93n68ljy1gvdiaxcbxzydswp";
+       libraryHaskellDepends = [
+         base bytestring containers template-haskell text time
+       ];
+       testHaskellDepends = [
+         base bytestring containers HUnit text time
+       ];
+       description = "Convert values from one type into another";
+       license = lib.licenses.isc;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ maralorn ];
+     }) {};
+
   "with-index" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        pname = "witherable";
        version = "0.4.2";
        sha256 = "0121ic4xkv3k568j23zp22a5lrv0k11h94fq7cbijd18fjr2n3br";
-       revision = "1";
-       editedCabalFile = "1mwmnc4pdsw0v8p9bh8n49xjjmbyf5bd0kvlg970iyq3cqik546f";
+       revision = "2";
+       editedCabalFile = "1ljnv5xf6w7x58akj0a0yw16j63jkka0dvfvmjqwbn76aqg3pzc1";
        libraryHaskellDepends = [
          base base-orphans containers hashable indexed-traversable
          indexed-traversable-instances transformers unordered-containers
···
        license = lib.licenses.mit;
      }) {};
 
+  "wuss_1_1_19" = callPackage
+    ({ mkDerivation, base, bytestring, connection, network, websockets
+     }:
+     mkDerivation {
+       pname = "wuss";
+       version = "1.1.19";
+       sha256 = "1i7y6kqynbc5qbl091ihdfn9ak8ny8rdp83svl06m6ijvphjqskq";
+       libraryHaskellDepends = [
+         base bytestring connection network websockets
+       ];
+       description = "Secure WebSocket (WSS) clients";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "wx" = callPackage
     ({ mkDerivation, base, stm, time, wxcore }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "xml-optics";
-       version = "0.1.0";
-       sha256 = "01sa1hk87aw32wafxxnvnljazi78bnishpmk5k77p28jmhpa1gn8";
+       version = "0.2.0";
+       sha256 = "1faxprzgql8kbji7ip53dn3xcxwhbqzgjjyabf5dmcfq98kv87mk";
        libraryHaskellDepends = [
          base containers optics-core text xml-conduit
        ];
···
        pname = "xmonad-extras";
        version = "0.17.0";
        sha256 = "0kkwng84hp19vc9nw97y77n3hsg9scn0c9fa1ivf4r9s5x3p6flx";
+       revision = "1";
+       editedCabalFile = "1ivm1nncg8qa5ww1kgk1d8zdawniz83ab5s2dj0hbcxffymgxp0k";
        configureFlags = [
          "-f-with_hlist" "-fwith_parsec" "-fwith_split"
        ];
···
 
   "yaml-streamly" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, base-compat, bytestring
-     , containers, directory, filepath, hspec, hspec-discover, HUnit
-     , libyaml-streamly, mockery, mtl, raw-strings-qq, safe-exceptions
-     , scientific, streamly, template-haskell, temporary, text
-     , transformers, unordered-containers, vector
+     , containers, criterion, deepseq, directory, filepath, hspec
+     , hspec-discover, HUnit, libyaml-streamly, megaparsec, mockery, mtl
+     , raw-strings-qq, safe-exceptions, scientific, streamly, strict
+     , template-haskell, temporary, text, transformers
+     , unordered-containers, vector, versions
      }:
      mkDerivation {
        pname = "yaml-streamly";
-       version = "0.12.0";
-       sha256 = "1jvvj1g20n8v7rnbvqgsvqm7l4nnh97ibkvb2zkj2wskir0l00mc";
+       version = "0.12.1";
+       sha256 = "1rcv4y9f2p1biiaxh4j1wdq79ba1mi33yn5v6kds20am574ia1hq";
+       revision = "1";
+       editedCabalFile = "18gv1h6h9n8bmysdfb0h9kgifhi3rj9zf055l2dibaw0jixqqs2c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson attoparsec base bytestring containers directory filepath
-         libyaml-streamly mtl safe-exceptions scientific streamly
+         aeson attoparsec base bytestring containers deepseq directory
+         filepath libyaml-streamly mtl safe-exceptions scientific streamly
          template-haskell text transformers unordered-containers vector
        ];
        testHaskellDepends = [
···
          temporary text unordered-containers vector
        ];
        testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         aeson base bytestring containers criterion deepseq directory
+         filepath megaparsec strict temporary text versions
+       ];
        description = "Support for parsing and rendering YAML documents";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "yaml-unscrambler";
-       version = "0.1.0.3";
-       sha256 = "1n8q5dsvs6sh2gzs24m49cz5pg1pavn9sma4fk5jizrjrabik4sj";
+       version = "0.1.0.4";
+       sha256 = "01x3l618qj0a78xcwn7i76nij812150b2ncz9x6pqr0s839vi7fa";
        libraryHaskellDepends = [
          acc attoparsec attoparsec-data attoparsec-time base base64
          bytestring conduit containers foldl hashable libyaml mtl scientific
···
      }:
      mkDerivation {
        pname = "yesod-auth";
-       version = "1.6.10.4";
-       sha256 = "01s5svba45g0d12cz8kc8lvdw18jfhjxr7yk69cf5157qg0f2czv";
-       libraryHaskellDepends = [
-         aeson authenticate base base16-bytestring base64-bytestring binary
-         blaze-builder blaze-html blaze-markup bytestring conduit
-         conduit-extra containers cryptonite data-default email-validate
-         file-embed http-client http-client-tls http-conduit http-types
-         memory network-uri nonce persistent random safe shakespeare
-         template-haskell text time transformers unliftio unliftio-core
-         unordered-containers wai yesod-core yesod-form yesod-persistent
-       ];
-       description = "Authentication for Yesod";
-       license = lib.licenses.mit;
-     }) {};
-
-  "yesod-auth_1_6_10_5" = callPackage
-    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
-     , base64-bytestring, binary, blaze-builder, blaze-html
-     , blaze-markup, bytestring, conduit, conduit-extra, containers
-     , cryptonite, data-default, email-validate, file-embed, http-client
-     , http-client-tls, http-conduit, http-types, memory, network-uri
-     , nonce, persistent, random, safe, shakespeare, template-haskell
-     , text, time, transformers, unliftio, unliftio-core
-     , unordered-containers, wai, yesod-core, yesod-form
-     , yesod-persistent
-     }:
-     mkDerivation {
-       pname = "yesod-auth";
        version = "1.6.10.5";
        sha256 = "11nywgjnivbfrbn8mg3lfr8r8lfpygn30vhnn0bzy9pa07nvgxnz";
        libraryHaskellDepends = [
···
        ];
        description = "Authentication for Yesod";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "yesod-auth-account" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "yesod-auth-oidc" = callPackage
+    ({ mkDerivation, aeson, base, base64-bytestring, blaze-html, broch
+     , bytestring, classy-prelude, classy-prelude-yesod, containers
+     , cryptonite, directory, email-validate, fast-logger, hspec
+     , hspec-discover, http-client, http-conduit, http-types, jose-jwt
+     , lens, lens-regex-pcre, memory, monad-logger, oidc-client
+     , persistent, persistent-sqlite, postgresql-simple, reroute
+     , resource-pool, shakespeare, sqlite-simple, text, time
+     , unordered-containers, wai-app-static, wai-extra, warp, yesod
+     , yesod-auth, yesod-core, yesod-form, yesod-persistent, yesod-test
+     }:
+     mkDerivation {
+       pname = "yesod-auth-oidc";
+       version = "0.1.0";
+       sha256 = "1kxki50zwyqblpglm8rgmhvf8rm0fr38vzygigxpky4qaraqxpk6";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base base64-bytestring classy-prelude-yesod cryptonite
+         http-client jose-jwt oidc-client shakespeare text time
+         unordered-containers yesod-auth yesod-core yesod-form
+       ];
+       executableHaskellDepends = [
+         aeson base base64-bytestring blaze-html broch bytestring
+         classy-prelude classy-prelude-yesod containers cryptonite directory
+         email-validate fast-logger hspec http-client http-conduit
+         http-types jose-jwt lens lens-regex-pcre memory monad-logger
+         oidc-client persistent persistent-sqlite postgresql-simple reroute
+         resource-pool shakespeare sqlite-simple text time
+         unordered-containers wai-app-static wai-extra warp yesod yesod-auth
+         yesod-core yesod-form yesod-persistent yesod-test
+       ];
+       testHaskellDepends = [
+         aeson base base64-bytestring blaze-html broch bytestring
+         classy-prelude classy-prelude-yesod containers cryptonite directory
+         email-validate fast-logger hspec http-client http-conduit
+         http-types jose-jwt lens lens-regex-pcre memory monad-logger
+         oidc-client persistent persistent-sqlite postgresql-simple reroute
+         resource-pool shakespeare sqlite-simple text time
+         unordered-containers wai-app-static wai-extra warp yesod yesod-auth
+         yesod-core yesod-form yesod-persistent yesod-test
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "A yesod-auth plugin for multi-tenant SSO via OpenID Connect";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {broch = null;};
+
   "yesod-auth-pam" = callPackage
     ({ mkDerivation, base, hamlet, pam, text, yesod-auth, yesod-core
      , yesod-form
···
        pname = "yoctoparsec";
        version = "0.1.0.0";
        sha256 = "0p9kw60glcgrjfx04x3innn3rqnh12yrv4wh0a0fivcx8b9kj1yp";
-       revision = "4";
-       editedCabalFile = "00icvzsb8l70w5dcy0kkxrg0hpq273r8zyy6cx6hscpzgck090jf";
+       revision = "5";
+       editedCabalFile = "1xf2haxw974zsnwx5dqflqq736i7cfz1mqfpfkkggsnfx86d5gg0";
        libraryHaskellDepends = [ base free mtl ];
        description = "A truly tiny monadic parsing library";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "zeolite-lang";
-       version = "0.20.0.1";
-       sha256 = "0j1qkihz5ci5skxkbjpzg8yakbrmh6d6fvl6y4n54bd5dci8f2gs";
+       version = "0.21.0.0";
+       sha256 = "1vavvyn2p7q02gflxhnppxqqwhlzj36plcpybnm8yf9wgrpxrlqg";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "zippers";
-       version = "0.3.1";
-       sha256 = "17z1zi9zd6a8g7sp4zyimgwdvhjj27hj4znbm4ps0kp73gadb953";
-       libraryHaskellDepends = [
-         base fail indexed-traversable lens profunctors semigroupoids
-         semigroups
-       ];
-       benchmarkHaskellDepends = [ base criterion lens ];
-       description = "Traversal based zippers";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "zippers_0_3_2" = callPackage
-    ({ mkDerivation, base, criterion, fail, indexed-traversable, lens
-     , profunctors, semigroupoids, semigroups
-     }:
-     mkDerivation {
-       pname = "zippers";
        version = "0.3.2";
        sha256 = "0n85mnp3mv8qwk3wmmm2wpc3j2l4q2fb0gbzb5il3nrd0p42xjld";
        libraryHaskellDepends = [
···
        benchmarkHaskellDepends = [ base criterion lens ];
        description = "Traversal based zippers";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "zippo" = callPackage
···
      }:
      mkDerivation {
        pname = "zoovisitor";
-       version = "0.1.5.0";
-       sha256 = "0sksa3sjgd2yg2cj6vr9ssk52zlhap45c93cwslk3q788c8krr35";
+       version = "0.1.7.0";
+       sha256 = "0g9881llwb7arv4m3klc69lhzlwbdb7wrgv7418qcl2a8nmvp4cb";
        libraryHaskellDepends = [ base Z-Data Z-IO ];
        librarySystemDepends = [ zookeeper_mt ];
        testHaskellDepends = [ async base hspec uuid Z-Data ];

pkgs/development/interpreters/python/update-python-libraries/update-python-libraries.py

···
     with open(path, 'r') as f:
         text = f.read()
 
-    # Determine pname.
-    pname = _get_unique_value('pname', text)
+    # Determine pname. Many files have more than one pname
+    pnames = _get_values('pname', text)
 
     # Determine version.
     version = _get_unique_value('version', text)
···
 
     extension = _determine_extension(text, fetcher)
 
-    new_version, new_sha256, prefix = FETCHERS[fetcher](pname, extension, version, target)
+    # Attempt a fetch using each pname, e.g. backports-zoneinfo vs backports.zoneinfo
+    successful_fetch = False
+    for pname in pnames:
+        try:
+            new_version, new_sha256, prefix = FETCHERS[fetcher](pname, extension, version, target)
+            successful_fetch = True
+            break
+        except ValueError:
+            continue
+
+    if not successful_fetch:
+        raise ValueError(f"Unable to find correct package using these pnames: {pnames}")
 
     if new_version == version:
         logging.info("Path {}: no update available for {}.".format(path, pname))
···
         raise ValueError("no file available for {}.".format(pname))
 
     text = _replace_value('version', new_version, text)
-    text = _replace_value('sha256', new_sha256, text)
+
+    # fetchers can specify a sha256, or a sri hash
+    try:
+        text = _replace_value('sha256', new_sha256, text)
+    except ValueError:
+        # hashes from pypi are 16-bit encoded sha256's, need translate to an sri hash if used with "hash"
+        sri_hash = subprocess.check_output(["nix", "hash", "to-sri", "--type", "sha256", new_sha256]).decode('utf-8').strip()
+        text = _replace_value('hash', sri_hash, text)
+
     if fetcher == 'fetchFromGitHub':
         text = _replace_value('rev', f"{prefix}${{version}}", text)
         # incase there's no prefix, just rewrite without interpolation

pkgs/development/libraries/physics/apfel/default.nix

···
-{ lib, stdenv, fetchFromGitHub, gfortran, lhapdf, python2, zlib }:
+{ lib, stdenv, fetchFromGitHub, gfortran, lhapdf, python3, zlib }:
 
 stdenv.mkDerivation rec {
   pname = "apfel";
···
     sha256 = "sha256-szEtSC/NouYlHSjVoX9Hoh7yQ0W82rVccYEF1L2tXoU=";
   };
 
-  buildInputs = [ gfortran lhapdf python2 zlib ];
+  buildInputs = [ gfortran lhapdf python3 zlib ];
 
   enableParallelBuilding = true;
 

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

···
 
 buildPythonPackage rec {
   pname = "aprslib";
-  version = "0.6.47";
+  version = "0.7.0";
 
   src = fetchFromGitHub {
     owner = "rossengeorgiev";
     repo = "aprs-python";
     rev = "v${version}";
-    sha256 = "1569v74ym2r8vxx3dnjcs5fr7rdrfb0i9sycny5frw2zgms4ag6b";
+    sha256 = "sha256-QasyF0Ch4zdPoAgcqRavEENVGA/02/AgeWAgXYcSUjk=";
   };
 
   checkInputs = [

pkgs/development/python-modules/azure-mgmt-subscription/default.nix

···
 
 buildPythonPackage rec {
   pname = "azure-mgmt-subscription";
-  version = "1.0.0";
+  version = "2.0.0";
 
   src = fetchPypi {
     inherit pname version;
     extension = "zip";
-    sha256 = "22f606f298419f466a8149811fc762686c93da00a7dc15d3b7cdbf22b96cf5db";
+    sha256 = "70ec6e3395549c434bfd981f8f76cb8b6863339bad9b31924c1510af661dbf45";
   };
 
   propagatedBuildInputs = [

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

···
 }:
 
 buildPythonPackage rec {
-  version = "0.5.0";
+  version = "1.0.0";
   pname = "filebrowser_safe";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "5dcd31dd79684025139b43841f6515af1da5a4bb0de15bc4d88003db1970648e";
+    sha256 = "1209a26abd5a085a6453e020513fd94e920bde3908a2bcf3fe0ad5e4292b943b";
   };
 
   buildInputs = [ django ];

pkgs/development/python-modules/flake8-length/default.nix

···
 
 buildPythonPackage rec {
   pname = "flake8-length";
-  version = "0.2.0";
+  version = "0.2.2";
   disabled = pythonOlder "3.6";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "15frvccm1qx783jlx8fw811ks9jszln3agbb58lg4dhbmjaf2cxw";
+    sha256 = "3536fee1d2a19c01f56ebb909c4d81f686f8181091a9bc3ddf3a5621c464760a";
   };
 
   propagatedBuildInputs = [

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

···
 { buildPythonPackage, lib, libffi, isPy3k, pyasn1, clint, ndg-httpsclient
-, protobuf, requests, args, gpapi, pyaxmlparser, fetchFromGitHub
+, protobuf, requests, args, gpapi, pyaxmlparser, setuptools, fetchFromGitHub
 }:
 
 buildPythonPackage rec {
···
 
   disabled = !isPy3k;
 
-  propagatedBuildInputs = [ libffi pyasn1 clint ndg-httpsclient protobuf requests args gpapi pyaxmlparser ];
+  propagatedBuildInputs = [ libffi pyasn1 clint ndg-httpsclient protobuf requests args gpapi pyaxmlparser setuptools ];
 
   meta = with lib; {
     homepage = "https://github.com/matlink/gplaycli";

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

···
 
 buildPythonPackage rec {
   pname = "lc7001";
-  version = "1.0.3";
+  version = "1.0.4";
   format = "pyproject";
 
   disabled = pythonOlder "3.8";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "NgnszlgmeUnfWs9onnboFRz3c4OibsNaZHjDINvoMPc=";
+    sha256 = "sha256-1qObmGpu6mU3gdxS8stH+4Zc2NA7W1+pS7fOXALC0Ug=";
   };
 
   nativeBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "numexpr";
-  version = "2.7.3";
+  version = "2.8.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "43616529f9b7d1afc83386f943dc66c4da5e052f00217ba7e3ad8dd1b5f3a825";
+    sha256 = "9fec076b76c90a5f3929373f548834bb203c6d23a81a895e60d0fe9cca075e99";
   };
 
   # Remove existing site.cfg, use the one we built for numpy.

pkgs/development/python-modules/papis-python-rofi/default.nix

···
 
 buildPythonPackage rec {
   pname = "papis-python-rofi";
-  version = "1.0.2";
+  version = "1.0.3";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "13k6mw2nq923zazs77hpmh2s96v6zv13g7p89510qqkvp6fiml1v";
+    sha256 = "358e24f5fb0a86de6f15d5168753ad4cbb97e52b36b1bd7abbad4053aeb6f621";
   };
 
   # No tests existing

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

···
     if stdenv.isDarwin then [ mesa_drivers.dev ] else [ ocl-icd ];
 in buildPythonPackage rec {
   pname = "pyopencl";
-  version = "2021.2.9";
+  version = "2021.2.10";
 
   checkInputs = [ pytest ];
   buildInputs = [ opencl-headers pybind11 ] ++ os-specific-buildInputs;
···
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "51425e65ec49c738eefe21b1eeb1f39245b01cc0ddfd495fbe1f8df33dbc6c9e";
+    sha256 = "75a1f202741bace9606a8680bbbfac69bf8a73d4e7511fb1a6ce3e48185996ae";
   };
 
   # py.test is not needed during runtime, so remove it from `install_requires`

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

···
 
 buildPythonPackage rec {
   pname = "pywbem";
-  version = "1.2.0";
+  version = "1.2.1";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "8ef48185e0adbaeb9bd5181c4c5de951f6d58d54e2e1d7e87a9834e10eabe957";
+    sha256 = "5e4b4cf4813da57a02ce999d5e2e97e7a9f1ec8014e6561a896ee8b14ae5fa4d";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "teslajsonpy";
-  version = "1.2.1";
+  version = "1.4.0";
   format = "pyproject";
 
   disabled = pythonOlder "3.6";
···
     owner = "zabuldon";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-49dQgzYsEn5jmHWTJ3e3QOTqNeoTRMjUWxp+MaOYod4=";
+    sha256 = "17ld1ciylfc8kmf5iazzrlqqdf434wi5dfjzm68nm5d539gccfss";
   };
 
   nativeBuildInputs = [

pkgs/development/tools/misc/pahole/default.nix

···
-{ lib, stdenv, fetchgit, cmake, elfutils, zlib }:
+{ lib, stdenv, fetchgit, pkg-config, libbpf, cmake, elfutils, zlib }:
 
 stdenv.mkDerivation rec {
   pname = "pahole";
-  version = "1.20";
+  version = "1.22";
   src = fetchgit {
     url = "https://git.kernel.org/pub/scm/devel/pahole/pahole.git";
     rev = "v${version}";
-    sha256 = "11q9dpfi4qj2v8z0nlf8c0079mlv10ljhh0d1yr0j4ds3saacd15";
-    fetchSubmodules = true;
+    sha256 = "sha256-U1/i9WNlLphPIcNysC476sqil/q9tMYmu+Y6psga8I0=";
   };
 
-  nativeBuildInputs = [ cmake ];
-  buildInputs = [ elfutils zlib ];
+  nativeBuildInputs = [ cmake pkg-config ];
+  buildInputs = [ elfutils zlib libbpf ];
 
   # Put libraries in "lib" subdirectory, not top level of $out
-  cmakeFlags = [ "-D__LIB=lib" ];
+  cmakeFlags = [ "-D__LIB=lib" "-DLIBBPF_EMBEDDED=OFF" ];
 
   meta = with lib; {
     homepage = "https://git.kernel.org/cgit/devel/pahole/pahole.git/";
···
     license = licenses.gpl2Only;
 
     platforms = platforms.linux;
-    maintainers = [ maintainers.bosu ];
+    maintainers = with maintainers; [ bosu martinetd ];
   };
 }

pkgs/development/tools/typos/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "typos";
-  version = "1.3.0";
+  version = "1.3.1";
 
   src = fetchFromGitHub {
     owner = "crate-ci";
     repo = pname;
     rev = "v${version}";
-    sha256 = "Y+sIyueLdREoq/NR6LwppyhWxB8s0iBjdFaDUSKnlRw=";
+    sha256 = "sha256-b81xopCkAUo9m9FBgL4v7OT+eZu4PNcF5QO1jXHVMT0=";
   };
 
-  cargoSha256 = "3oqmiHH9QU8uHs9q2CgE0uTvfyaRxV3rFBxkXxC5/Tw=";
+  cargoSha256 = "sha256-3LFhUSg5cNtWPe8g43MsbGkmZR9BQdAT5m8k0eCBqIs=";
 
   meta = with lib; {
     description = "Source code spell checker";

pkgs/development/tools/yq-go/default.nix

···
 
 buildGoModule rec {
   pname = "yq-go";
-  version = "4.13.5";
+  version = "4.16.1";
 
   src = fetchFromGitHub {
     owner = "mikefarah";
     repo = "yq";
     rev = "v${version}";
-    sha256 = "sha256-ckcuA9jf8aFgcuts3VOE629WGkvBkdZP86PKXqzBvks=";
+    sha256 = "sha256-4o38f5ltTH6ea0na919GnJMao8w5rgkDWMp2mkoKwcY=";
   };
 
-  vendorSha256 = "sha256-jlQ4TH5PiO/68ZFOzOVUTYKkVe9lQleVjZoP4adRrUI=";
+  vendorSha256 = "sha256-PCDM1VbqUcAVXzCPWDZtCRLpRIu43sF1lGazAG2HZJ0=";
 
   doCheck = false;
 

pkgs/games/0ad/game.nix

···
-{ stdenv, lib, perl, fetchurl, python2, fmt, libidn
+{ stdenv, lib, perl, fetchurl, python3, fmt, libidn
 , pkg-config, spidermonkey_78, boost, icu, libxml2, libpng, libsodium
 , libjpeg, zlib, curl, libogg, libvorbis, enet, miniupnpc
 , openal, libGLU, libGL, xorgproto, libX11, libXcursor, nspr, SDL2
···
     sha256 = "1p9fa8f7sjb9c5wl3mawzyfqvgr614kdkhrj2k4db9vkyisws3fp";
   };
 
-  nativeBuildInputs = [ python2 perl pkg-config ];
+  nativeBuildInputs = [ python3 perl pkg-config ];
 
   buildInputs = [
     spidermonkey_78_6 boost icu libxml2 libpng libjpeg

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

···
 { lib, stdenv, fetchFromGitHub
-, makeWrapper, cmake, llvmPackages, kernel
+, makeWrapper, cmake, llvmPackages
 , flex, bison, elfutils, python, luajit, netperf, iperf, libelf
-, systemtap, bash
+, bash, libbpf, nixosTests
 }:
 
 python.pkgs.buildPythonApplication rec {
···
     owner = "iovisor";
     repo = "bcc";
     rev = "v${version}";
-    sha256 = "sha256-4zfjr3VLg26uZ4xNKA1wayti7f2tqGvYSbwoZnr+Ygk=";
-    fetchSubmodules = true;
+    sha256 = "sha256-iLVUwJTDQ8Bn38sgHOcIR8TYxIB+gIlfTgr9+gPU0gE=";
   };
   format = "other";
 
   buildInputs = with llvmPackages; [
-    llvm llvm.dev libclang kernel
+    llvm llvm.dev libclang
     elfutils luajit netperf iperf
-    systemtap.stapBuild flex bash
+    flex bash libbpf
   ];
 
   patches = [
···
   ];
 
   propagatedBuildInputs = [ python.pkgs.netaddr ];
-  nativeBuildInputs = [ makeWrapper cmake flex bison llvmPackages.llvm.dev ]
-    # libelf is incompatible with elfutils-libelf
-    ++ lib.filter (x: x != libelf) kernel.moduleBuildDependencies;
+  nativeBuildInputs = [ makeWrapper cmake flex bison llvmPackages.llvm.dev ];
 
   cmakeFlags = [
-    "-DBCC_KERNEL_MODULES_DIR=${kernel.dev}/lib/modules"
+    "-DBCC_KERNEL_MODULES_DIR=/run/booted-system/kernel-modules/lib/modules"
     "-DREVISION=${version}"
     "-DENABLE_USDT=ON"
     "-DENABLE_CPP_API=ON"
+    "-DCMAKE_USE_LIBBPF_PACKAGE=ON"
   ];
 
   postPatch = ''
···
     wrapPythonProgramsIn "$out/share/bcc/tools" "$out $pythonPath"
   '';
 
+  passthru.tests = {
+    bpf = nixosTests.bpf;
+  };
+
   meta = with lib; {
     description = "Dynamic Tracing Tools for Linux";
     homepage    = "https://iovisor.github.io/bcc/";
     license     = licenses.asl20;
-    maintainers = with maintainers; [ ragge mic92 thoughtpolice ];
+    maintainers = with maintainers; [ ragge mic92 thoughtpolice martinetd ];
   };
 }

pkgs/os-specific/linux/bpftrace/btf-dump-new-0.6.0.patch

···
+diff -ur source/src/btf.cpp new/src/btf.cpp
+--- source/src/btf.cpp	1970-01-01 09:00:01.000000000 +0900
++++ new/src/btf.cpp	2021-12-04 21:46:59.337023489 +0900
+@@ -225,7 +225,7 @@
+   char err_buf[256];
+   int err;
+ 
+-  dump = btf_dump__new(btf, nullptr, &opts, dump_printf);
++  dump = btf_dump__new_deprecated(btf, nullptr, &opts, dump_printf);
+   err = libbpf_get_error(dump);
+   if (err)
+   {
+@@ -496,7 +496,7 @@
+   char err_buf[256];
+   int err;
+ 
+-  dump = btf_dump__new(btf, nullptr, &opts, dump_printf);
++  dump = btf_dump__new_deprecated(btf, nullptr, &opts, dump_printf);
+   err = libbpf_get_error(dump);
+   if (err)
+   {
+@@ -554,7 +554,7 @@
+   char err_buf[256];
+   int err;
+ 
+-  dump = btf_dump__new(btf, nullptr, &opts, dump_printf);
++  dump = btf_dump__new_deprecated(btf, nullptr, &opts, dump_printf);
+   err = libbpf_get_error(dump);
+   if (err)
+   {
+@@ -648,7 +648,7 @@
+   char err_buf[256];
+   int err;
+ 
+-  dump = btf_dump__new(btf, nullptr, &opts, dump_printf);
++  dump = btf_dump__new_deprecated(btf, nullptr, &opts, dump_printf);
+   err = libbpf_get_error(dump);
+   if (err)
+   {

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

···
 { lib, stdenv, fetchFromGitHub
 , cmake, pkg-config, flex, bison
-, llvmPackages, kernel, elfutils
+, llvmPackages, elfutils
 , libelf, libbfd, libbpf, libopcodes, bcc
+, cereal, asciidoctor
+, nixosTests
 }:
 
 stdenv.mkDerivation rec {
   pname = "bpftrace";
-  version = "0.13.0";
+  version = "0.14.0";
 
   src = fetchFromGitHub {
     owner  = "iovisor";
     repo   = "bpftrace";
     rev    = "v${version}";
-    sha256 = "sha256-BKWBdFzj0j7rAfG30A0fwyYCpOG/5NFRPODW46EP1u0=";
+    sha256 = "sha256-rlaajNfpoiMtU/4aNAnbQ0VixPz9/302TZMarGzsb58=";
   };
 
+  # libbpf 0.6.0 relies on typeof in bpf/btf.h to pick the right version of
+  # btf_dump__new() but that's not valid c++.
+  # see https://github.com/iovisor/bpftrace/issues/2068
+  patches = [ ./btf-dump-new-0.6.0.patch ];
+
   buildInputs = with llvmPackages;
     [ llvm libclang
-      kernel elfutils libelf bcc
+      elfutils libelf bcc
       libbpf libbfd libopcodes
+      cereal asciidoctor
     ];
 
-  nativeBuildInputs = [ cmake pkg-config flex bison llvmPackages.llvm.dev ]
-    # libelf is incompatible with elfutils-libelf
-    ++ lib.filter (x: x != libelf) kernel.moduleBuildDependencies;
-
-  # patch the source, *then* substitute on @NIX_KERNEL_SRC@ in the result. we could
-  # also in theory make this an environment variable around bpftrace, but this works
-  # nicely without wrappers.
-  patchPhase = ''
-    patch -p1 < ${./fix-kernel-include-dir.patch}
-    substituteInPlace ./src/utils.cpp \
-      --subst-var-by NIX_KERNEL_SRC '${kernel.dev}/lib/modules/${kernel.modDirVersion}'
-  '';
+  nativeBuildInputs = [ cmake pkg-config flex bison llvmPackages.llvm.dev ];
 
   # tests aren't built, due to gtest shenanigans. see:
   #
···
 
   outputs = [ "out" "man" ];
 
+  passthru.tests = {
+    bpf = nixosTests.bpf;
+  };
+
   meta = with lib; {
     description = "High-level tracing language for Linux eBPF";
     homepage    = "https://github.com/iovisor/bpftrace";
     license     = licenses.asl20;
-    maintainers = with maintainers; [ rvl thoughtpolice ];
+    maintainers = with maintainers; [ rvl thoughtpolice martinetd ];
   };
 }

pkgs/os-specific/linux/bpftrace/fix-kernel-include-dir.patch

···
-commit b6172952c0150d84912fa6f09bab782dd0549f1e
-Author: Austin Seipp <[e-mail]>
-Date:   Fri May 3 00:47:12 2019 -0500
-
-    src: special case nix build directories for clang
-    
-    Signed-off-by: Austin Seipp <[e-mail]>
-
-diff --git a/src/clang_parser.cpp b/src/clang_parser.cpp
-index b1db8ff..0cfb01f 100644
---- a/src/utils.cpp
-+++ b/src/utils.cpp
-@@ -140,6 +140,9 @@ static bool is_dir(const std::string& path)
- // Both ksrc and kobj are guaranteed to be != "", if at least some trace of kernel sources was found.
- std::tuple<std::string, std::string> get_kernel_dirs(const struct utsname& utsname)
- {
-+  // NB (aseipp): special case the kernel directory for nix
-+  return { "@NIX_KERNEL_SRC@/source", "@NIX_KERNEL_SRC@/build" };
-+
- #ifdef KERNEL_HEADERS_DIR
-   return {KERNEL_HEADERS_DIR, KERNEL_HEADERS_DIR};
- #endif

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

···
   enableParallelBuilding = true;
   makeFlags = [ "PREFIX=$(out)" ];
 
+  postInstall = ''
+    # install linux's libbpf-compatible linux/btf.h
+    install -Dm444 ../include/uapi/linux/btf.h -t $out/include/linux
+  '';
+
   # FIXME: Multi-output requires some fixes to the way the pkg-config file is
   # constructed (it gets put in $out instead of $dev for some reason, with
   # improper paths embedded). Don't enable it for now.
···
     description = "Upstream mirror of libbpf";
     homepage    = "https://github.com/libbpf/libbpf";
     license     = with licenses; [ lgpl21 /* or */ bsd2 ];
-    maintainers = with maintainers; [ thoughtpolice vcunat saschagrunert ];
+    maintainers = with maintainers; [ thoughtpolice vcunat saschagrunert martinetd ];
     platforms   = platforms.linux;
   };
 }

pkgs/servers/matrix-synapse/plugins/mjolnir-antispam.nix

···
 
 buildPythonPackage rec {
   pname = "matrix-synapse-mjolnir-antispam";
-  version = "1.1.20";
+  version = "1.2.1";
 
   src = fetchFromGitHub {
     owner = "matrix-org";
     repo = "mjolnir";
     rev = "v${version}";
-    sha256 = "06779z08qni1kgr292gpkxd2xvyg4apfnbhynli9qjp2vaf03wy9";
+    sha256 = "0fvdzn5l1a6bhr1qzgs30a3kh6nj0byqichnl149sjgr0v4lpkz1";
   };
 
   sourceRoot = "./source/synapse_antispam";

pkgs/tools/admin/trivy/default.nix

···
 
 buildGoModule rec {
   pname = "trivy";
-  version = "0.21.0";
+  version = "0.21.1";
 
   src = fetchFromGitHub {
     owner = "aquasecurity";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-weLzW1pyv9q9VKvFxno+f/L29wlpvxlVUZJUwx6Gn2A=";
+    sha256 = "sha256-KxGG59H5EzIcYigvbQlrwpZLP4zMqErO3vDKhBOPc3w=";
   };
 
-  vendorSha256 = "sha256-1kQ2m8gFBHKznbjNPtYN0BVrRbxyCs2H1f7+XZqgVvc=";
+  vendorSha256 = "sha256-lITzqPMsZk/G2nG4LcUdyTb3gE3rtlXET/c2UaYODvU=";
 
   excludedPackages = "misc";
 

pkgs/tools/misc/recoverjpeg/default.nix

···
-{ lib, stdenv, fetchurl, makeWrapper, python2, exif, imagemagick }:
+{ lib, stdenv, fetchurl, makeWrapper, python3, exif, imagemagick }:
 
 stdenv.mkDerivation rec {
   pname = "recoverjpeg";
···
 
   nativeBuildInputs = [ makeWrapper ];
 
-  buildInputs = [ python2 ];
+  buildInputs = [ python3 ];
 
   postFixup = ''
     wrapProgram $out/bin/sort-pictures \

pkgs/tools/package-management/cargo-outdated/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "cargo-outdated";
-  version = "0.10.1";
+  version = "0.10.2";
 
   src = fetchCrate {
     inherit pname version;
-    sha256 = "sha256-jg8KuIu1SaIRlEI9yvpLCESZfAyNgSThJ6pe7+IM6j0=";
+    sha256 = "sha256-U6qElZkray4kjScv9X4I5m2z1ZWQzqcPYAuPzpyRpW0=";
   };
 
-  cargoSha256 = "sha256-jfZUtUVHEC8zK+FJHSOQxELWTG/Of2WSDoqdg/Sckws=";
+  cargoSha256 = "sha256-0J02Uz184zx5xZYhqUmyaAFCQ0aogwy0fQTXbteBdV8=";
 
   nativeBuildInputs = [ pkg-config ];
 

pkgs/tools/package-management/cargo-release/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "cargo-release";
-  version = "0.18.4";
+  version = "0.18.5";
 
   src = fetchFromGitHub {
     owner = "crate-ci";
     repo = "cargo-release";
     rev = "v${version}";
-    sha256 = "sha256-m+mLnlTBBS3DdxOmOi+NvoSSWgBZ9lI9tqIgq3GHnJI=";
+    sha256 = "sha256-bbxOavpEVVRv5czl2UiV6brulvjod7X7n+j8/9bO+SE=";
   };
 
-  cargoSha256 = "sha256-L6Izc8OrZ+RnGPpWKWBMpyyOthWzB0DjmQxf20R6dE4=";
+  cargoSha256 = "sha256-E0Mo+hgI0uRaV2GAX52YtdNyZdd9wHVOBB3tJz36/8I=";
 
   nativeBuildInputs = [ pkg-config ];
 

pkgs/tools/text/grin/default.nix

···
-{ lib, fetchFromGitHub, python2Packages }:
+{ lib, fetchFromGitHub, python3Packages }:
 
-python2Packages.buildPythonApplication rec {
+python3Packages.buildPythonApplication rec {
   pname = "grin";
-  version = "1.2.1";
+  version = "1.3.0";
   namePrefix = "";
 
   src = fetchFromGitHub {
-    owner = "rkern";
+    owner = "matthew-brett";
     repo = pname;
-    rev = "8dd4b5309b3bc04fe9d3e71836420f7d8d4a293f";
-    sha256 = "0vz2aahwdcy1296g4w3i79dkvmzk9jc2n2zmlcvlg5m3s6h7b6jd";
+    rev = "1.3.0";
+    sha256 = "057d05vzx4sf415vnh3qj2g351xhb3illjxjs9mdl3nsnb5r84kv";
   };
 
-  buildInputs = with python2Packages; [ nose ];
+  buildInputs = with python3Packages; [ nose ];
 
   meta = {
-    homepage = "https://github.com/rkern/grin";
+    homepage = "https://github.com/matthew-brett/grin";
     description = "A grep program configured the way I like it";
     platforms = lib.platforms.all;
     maintainers = [ lib.maintainers.sjagoe ];

pkgs/tools/virtualization/google-compute-engine/default.nix

···
 , buildPythonPackage
 , bash
 , bashInteractive
+, systemd
 , util-linux
 , boto
 , setuptools
 , distro
-, stdenv
-, pythonOlder
-, pytestCheckHook
 }:
 
-let
-  guest-configs = stdenv.mkDerivation rec {
-    pname = "guest-configs";
-    version = "20210702.00";
-
-    src = fetchFromGitHub {
-      owner = "GoogleCloudPlatform";
-      repo = "guest-configs";
-      rev = version;
-      sha256 = "1965kdrb1ig3z4qwzvyzx1fb4282ak5vgxcvvg5k9c759pzbc5nn";
-    };
-
-    buildInputs = [ bash ];
-
-    dontConfigure = true;
-    dontBuild = true;
-
-    installPhase = ''
-      runHook preInstall
-
-      # allows to install the package in `services.udev.packages` in NixOS
-      mkdir -p $out/lib/udev $out/bin
-
-      cp -r "src/lib/udev/rules.d" $out/lib/udev
-      cp "src/lib/udev/google_nvme_id" $out/bin
-
-      for rules in $out/lib/udev/*.rules; do
-        substituteInPlace "$rules" \
-          --replace /bin/sh "${bash}/bin/sh" \
-          --replace /bin/umount "${util-linux}/bin/umount" \
-          --replace /usr/bin/logger "${util-linux}/bin/logger"
-      done
-
-      # sysctl snippets will be used by google-compute-config.nix
-      cp -r "src/etc/sysctl.d" $out
-
-      patchShebangs $out/bin/*
-
-      runHook postInstall
-    '';
-  };
-in
 buildPythonPackage rec {
   pname = "google-compute-engine";
-  version = "20200113.0";
+  version = "20190124";
 
   src = fetchFromGitHub {
     owner = "GoogleCloudPlatform";
     repo = "compute-image-packages";
-    rev = "506b9a0dbffec5620887660cd42c57b3cbbadba6";
-    sha256 = "0lmc426mvrajghpavhs6hwl19mgnnh08ziqx5yi15fzpnvwmb8vz";
+    rev = version;
+    sha256 = "08cy0jd463kng6hwbd3nfldsp4dpd2lknlvdm88cq795wy0kh4wp";
   };
 
-  buildInputs = [ bash guest-configs ];
-  propagatedBuildInputs = [ (if pythonOlder "3.7" then boto else distro) setuptools ];
-
-  preBuild = ''
-    cd packages/python-google-compute-engine
-  '';
-
-  disabledTests = [
-    "testExtractInterfaceMetadata"
-    "testCallDhclientIpv6"
-    "testWriteConfig"
-    "testCreateInterfaceMapNetifaces"
-    "testCreateInterfaceMapSysfs"
-    "testGetNetworkInterface"
-  ];
-
-  checkInputs = [ pytestCheckHook ];
+  buildInputs = [ bash ];
+  propagatedBuildInputs = [ boto setuptools distro ];
 
   postPatch = ''
     for file in $(find google_compute_engine -type f); do
···
         --replace /sbin/hwclock "${util-linux}/bin/hwclock"
       # SELinux tool ???  /sbin/restorecon
     done
+
+    substituteInPlace google_config/udev/64-gce-disk-removal.rules \
+      --replace /bin/sh "${bash}/bin/sh" \
+      --replace /bin/umount "${util-linux}/bin/umount" \
+      --replace /usr/bin/logger "${util-linux}/bin/logger"
   '';
 
+  postInstall = ''
+    # allows to install the package in `services.udev.packages` in NixOS
+    mkdir -p $out/lib/udev/rules.d
+    cp -r google_config/udev/*.rules $out/lib/udev/rules.d
+
+    # sysctl snippets will be used by google-compute-config.nix
+    mkdir -p $out/sysctl.d
+    cp google_config/sysctl/*.conf $out/sysctl.d
+
+    patchShebangs $out/bin/*
+  '';
+
+  doCheck = false;
   pythonImportsCheck = [ "google_compute_engine" ];
 
   meta = with lib; {
     description = "Google Compute Engine tools and services";
     homepage = "https://github.com/GoogleCloudPlatform/compute-image-packages";
     license = licenses.asl20;
-    maintainers = with maintainers; [ cpcloud zimbatm ];
+    maintainers = with maintainers; [ zimbatm ];
     platforms = platforms.linux;
   };
 }

pkgs/top-level/aliases.nix

···
   clangAnalyzer = clang-analyzer;  # added 2015-02-20
   claws-mail-gtk3 = claws-mail; # added 2021-07-10
   clawsMail = claws-mail; # added 2016-04-29
+  claws-mail-gtk2 = throw "claws-mail-gtk2 was removed to get rid of Python 2, please use claws-mail"; # added 2021-12-05
   clutter_gtk = clutter-gtk; # added 2018-02-25
   cmakeWithQt4Gui = throw "cmakeWithQt4Gui has been removed in favor of cmakeWithGui (Qt 5)"; # added 2021-05
   codimd = hedgedoc; # added 2020-11-29

pkgs/top-level/all-packages.nix

···
 
   google-clasp = callPackage ../development/misc/google-clasp { };
 
-  google-compute-engine = with python3.pkgs; toPythonApplication google-compute-engine;
+  google-compute-engine = with python38.pkgs; toPythonApplication google-compute-engine;
 
   google-compute-engine-oslogin = callPackage ../tools/virtualization/google-compute-engine-oslogin { };
 
···
   libbpf = callPackage ../os-specific/linux/libbpf { };
 
   bpftools = callPackage ../os-specific/linux/bpftools { };
+
+  bcc = callPackage ../os-specific/linux/bcc {
+    python = pkgs.python3;
+  };
+
+  bpftrace = callPackage ../os-specific/linux/bpftrace { };
 
   bpm-tools = callPackage ../tools/audio/bpm-tools { };
 
···
 
   ciscoPacketTracer8 = callPackage ../applications/networking/cisco-packet-tracer/8.nix { };
 
-  claws-mail-gtk2 = callPackage ../applications/networking/mailreaders/claws-mail {
-    inherit (xorg) libSM;
-    useGtk3 = false;
-  };
   claws-mail = callPackage ../applications/networking/mailreaders/claws-mail {
     inherit (xorg) libSM;
-    useGtk3 = true;
   };
 
   clfswm = callPackage ../applications/window-managers/clfswm { };

pkgs/top-level/linux-kernels.nix

···
     inherit (kernel) kernelOlder kernelAtLeast;
     # Obsolete aliases (these packages do not depend on the kernel).
     inherit (pkgs) odp-dpdk pktgen; # added 2018-05
+    inherit (pkgs) bcc bpftrace; # added 2021-12
 
     acpi_call = callPackage ../os-specific/linux/acpi-call {};
 
···
     apfs = callPackage ../os-specific/linux/apfs { };
 
     batman_adv = callPackage ../os-specific/linux/batman-adv {};
-
-    bcc = callPackage ../os-specific/linux/bcc {
-      python = pkgs.python3;
-    };
-
-    bpftrace = callPackage ../os-specific/linux/bpftrace { };
 
     bbswitch = callPackage ../os-specific/linux/bbswitch {};