Merge pull request #141286 from NixOS/haskell-updates

haskellPackages: update stackage and hackage

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "ba457d86df5e8781485cf1b109f249ecf00ee4c6",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/ba457d86df5e8781485cf1b109f249ecf00ee4c6.tar.gz",
-  "sha256": "1h1qnllhdfp6n71b36jw8kaw7kani76z3mmbigrvy8cmkbvj2mdc",
-  "msg": "Update from Hackage at 2021-10-08T09:46:02Z"
+  "commit": "67f421ee170f4f161832c146be8ef87499ff0d37",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/67f421ee170f4f161832c146be8ef87499ff0d37.tar.gz",
+  "sha256": "0rzwh0iff4xn499vvzv960gmrd85z6amjbbsyhb5qcldcap5jpjs",
+  "msg": "Update from Hackage at 2021-10-11T20:00:11Z"
 }

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 = "1022ff2x9jvi2a0820lbgmmh54cxh1vbn0qfdwr50w7ggvjp88i6";
+      sha256 = "1yn84q0iy81b2sczbf4gx8b56f9ghb9kgwjc0n7l5xn5lb2wqlqa";
       # 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
···
 
   # Needs Cabal >= 3.4
   chs-cabal = super.chs-cabal.override {
-    Cabal = self.Cabal_3_6_1_0;
+    Cabal = self.Cabal_3_6_2_0;
   };
 
   # 2021-08-18: streamly-posix was released with hspec 2.8.2, but it works with older versions too.

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

···
 
   # cabal-install needs more recent versions of Cabal and base16-bytestring.
   cabal-install = super.cabal-install.overrideScope (self: super: {
-    Cabal = self.Cabal_3_6_1_0;
+    Cabal = self.Cabal_3_6_2_0;
   });
 
   # cabal-install-parsers is written for Cabal 3.6
-  cabal-install-parsers = super.cabal-install-parsers.override { Cabal = super.Cabal_3_6_1_0; };
+  cabal-install-parsers = super.cabal-install-parsers.override { Cabal = super.Cabal_3_6_2_0; };
 
   # older version of cabal-install-parsers for reverse dependencies that use Cabal 3.4
   cabal-install-parsers_0_4_2 = super.cabal-install-parsers_0_4_2.override {
-    Cabal = self.Cabal_3_4_0_0;
+    Cabal = self.Cabal_3_4_1_0;
   };
 
   # Jailbreak to fix the build.

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

···
   # cabal-install needs more recent versions of Cabal and random, but an older
   # version of base16-bytestring.
   cabal-install = super.cabal-install.overrideScope (self: super: {
-    Cabal = self.Cabal_3_6_1_0;
+    Cabal = self.Cabal_3_6_2_0;
   });
 
   # Ignore overly restrictive upper version bounds.
···
   darcs = dontDistribute super.darcs;
 
   # The package needs the latest Cabal version.
-  cabal-install-parsers = super.cabal-install-parsers.overrideScope (self: super: { Cabal = self.Cabal_3_6_1_0; });
+  cabal-install-parsers = super.cabal-install-parsers.overrideScope (self: super: { Cabal = self.Cabal_3_6_2_0; });
 
   # cabal-fmt requires Cabal3
   cabal-fmt = super.cabal-fmt.override { Cabal = self.Cabal_3_2_1_0; };

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

···
 
   # cabal-install needs more recent versions of Cabal and base16-bytestring.
   cabal-install = (doJailbreak super.cabal-install).overrideScope (self: super: {
-    Cabal = self.Cabal_3_6_1_0;
+    Cabal = self.Cabal_3_6_2_0;
   });
 
   # Jailbreaks & Version Updates
···
   vector-binary-instances = doJailbreak super.vector-binary-instances;
   vector-th-unbox = doJailbreak super.vector-th-unbox;
   zlib = doJailbreak super.zlib;
+  weeder = self.weeder_2_3_0;
+  generic-lens-core = self.generic-lens-core_2_2_0_0;
+  generic-lens = self.generic-lens_2_2_0_0;
+
+  # Doesn't allow Dhall 1.39.*
+  weeder_2_3_0 = super.weeder_2_3_0.override {
+    dhall = self.dhall_1_40_1;
+  };
+
+  # 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;
 
   # Apply patches from head.hackage.
   alex = appendPatch (dontCheck super.alex) (pkgs.fetchpatch {

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

···
   - escape-artist
   - escoger
   - espial
+  - esqueleto-pgcrypto
   - ess
   - estimators
   - EstProgress
···
   - funcons-values
   - function-instances-algebra
   - functor
-  - functor-combinators
   - functor-friends
   - functor-infix
   - functorm
···
   - git-cuk
   - git-date
   - gitdo
+  - github
   - github-backup
   - github-data
   - github-tools
···
   - process-leksah
   - process-listlike
   - processmemory
-  - procex
   - procrastinating-variable
   - procstat
   - prof2pretty
···
   - shopify
   - shortcut-links
   - shorten-strings
+  - short-vec
   - show-prettyprint
   - Shpadoinkle-backend-snabbdom
   - Shpadoinkle-isreal
···
   - SVD2HS
   - svfactor
   - svg-builder-fork
+  - svgcairo
   - svgutils
   - svm-light-utils
   - svm-simple
···
   - warc
   - warp-dynamic
   - warp-grpc
+  - warp-quic
   - warp-static
   - warp-systemd
   - wasm

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

···
   - ghc-api-compat == 8.10.7
   # 2021-09-14: Pin hiedb to version needed by ghcide
   - hiedb == 0.4.0.*
+  # 2021-10-13: weeder 2.3.0 require GHC == 9.0.*; remove pin when GHC version changes
+  - weeder < 2.3.0
 
 extra-packages:
   - base16-bytestring < 1               # required for cabal-install etc.

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

···
  - base64-bytes
  - baserock-schema
  - batchd
+ - batching
  - battlenet-yesod
  - battleships
  - bayes-stack
···
  - claferwiki
  - clash
  - clash-ghc
+ - clash-ghc_1_4_4
  - clash-lib
+ - clash-lib_1_4_4
  - clash-multisignal
  - clash-prelude-quickcheck
  - clash-shake
···
  - delta
  - delta-h
  - dep-t-advice
+ - dependent-literals-plugin
  - dependent-state
  - dephd
  - deptrack-devops
···
  - filesystem-enumerator
  - find-clumpiness
  - findhttp
+ - finite-table
  - firstify
  - fix-parser-simple
  - fixed-point-vector
···
  - nomyx-language
  - nomyx-library
  - nomyx-server
+ - notifications-tray-icon
  - notmuch-haskell
  - notmuch-web
  - numeric-ode
···
  - one-liner_2_0
  - online
  - online-csv
+ - opc-xml-da-client
  - open-adt-tutorial
  - open-union
  - openpgp-Crypto
···
  - polh-lexicon
  - polydata
  - polysemy-RandomFu
+ - polysemy-check
  - polysemy-http
  - polysemy-log-co
  - polysemy-methodology-co-log
···
  - servant-auth-token-persistent
  - servant-auth-token-rocksdb
  - servant-auth-wordpress
- - servant-cli
  - servant-client-namedargs
  - servant-csharp
  - servant-db-postgresql
  - servant-ede
  - servant-event-stream
  - servant-examples
+ - servant-github-webhook
  - servant-http2-client
  - servant-matrix-param
  - servant-polysemy
···
  - shelduck
  - shellmate-extras
  - shine-varying
+ - short-vec-lens
  - showdown
  - shpider
  - shuffle

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

···
     doCheck = with pkgs.stdenv; hostPlatform == buildPlatform
       && buildPlatform.isx86;
   };
+
+  # procex relies on close_range which has been introduced in Linux 5.9,
+  # the test suite seems to force the use of this feature (or the fallback
+  # mechanism is broken), so we can't run the test suite on machines with a
+  # Kernel < 5.9. To check for this, we use uname -r to obtain the Kernel
+  # version and sort -V to compare against our minimum version. If the
+  # Kernel turns out to be older, we disable the test suite.
+  procex = overrideCabal super.procex (drv: {
+    postConfigure = ''
+      minimumKernel=5.9
+      higherVersion=`printf "%s\n%s\n" "$minimumKernel" "$(uname -r)" | sort -rV | head -n1`
+      if [[ "$higherVersion" = "$minimumKernel" ]]; then
+        echo "Used Kernel doesn't support close_range, disabling tests"
+        unset doCheck
+      fi
+    '' + (drv.postConfigure or "");
+  });
 }

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

···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "Cabal_3_4_0_0" = callPackage
+  "Cabal_3_4_1_0" = callPackage
     ({ mkDerivation, array, async, base, base-compat, base-orphans
      , binary, bytestring, clock, containers, deepseq, Diff, directory
      , filepath, integer-logarithms, mtl, optparse-applicative, parsec
···
      }:
      mkDerivation {
        pname = "Cabal";
-       version = "3.4.0.0";
-       sha256 = "1za1cl14fkw8y89hhw6sqirzmkixjaa4wpqsibyk0fvnjs59jydq";
+       version = "3.4.1.0";
+       sha256 = "1rqpq6l4b9990rmlgcyz44awps6r37ccyi6bgk7dhcsflad6prj4";
        setupHaskellDepends = [ mtl parsec ];
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory filepath
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "Cabal_3_6_1_0" = callPackage
+  "Cabal_3_6_2_0" = callPackage
     ({ mkDerivation, array, base, binary, bytestring, containers
      , deepseq, directory, filepath, mtl, parsec, pretty, process, text
      , time, transformers, unix
      }:
      mkDerivation {
        pname = "Cabal";
-       version = "3.6.1.0";
-       sha256 = "0yjdp78775752k10q4j5dbvqj37xaa2b3anmfld53mgr17k182a7";
+       version = "3.6.2.0";
+       sha256 = "0hmw2wkypd42qyyfi6rhbsxmymbxg9rrw683yg39627vlw33v44y";
        setupHaskellDepends = [ mtl parsec ];
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory filepath
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "Color_0_3_3" = callPackage
+    ({ mkDerivation, base, colour, criterion, data-default-class
+     , deepseq, hspec, hspec-discover, HUnit, JuicyPixels, massiv
+     , massiv-test, QuickCheck, random, vector
+     }:
+     mkDerivation {
+       pname = "Color";
+       version = "0.3.3";
+       sha256 = "14sf71lhqc1w6s3p1k8a99xgzcwfnr3v5irvfkr09rvv7fd66nva";
+       libraryHaskellDepends = [ base data-default-class deepseq vector ];
+       testHaskellDepends = [
+         base colour hspec HUnit JuicyPixels massiv massiv-test QuickCheck
+         random vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [ base colour criterion deepseq random ];
+       description = "Color spaces and conversions between them";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "Combinatorrent" = callPackage
     ({ mkDerivation, array, attoparsec, base, bytestring, cereal
      , containers, deepseq, directory, filepath, hopenssl, hslogger
···
        pname = "HTTP";
        version = "4000.3.16";
        sha256 = "0bgyj3ahqlyg0jw6qsm2sncp8mklc4h0dj91s043vb3ig01iq2fn";
+       revision = "1";
+       editedCabalFile = "0wagwgzfy2mqkha88fjl37ah0l7h4biz34v65993xd502ly68hk0";
        libraryHaskellDepends = [
          array base bytestring mtl network network-uri parsec time
        ];
···
        pname = "SecureHash-SHA3";
        version = "0.1.1.0";
        sha256 = "0dva3bzfzyzh8kxljyipd041a2w1zhxjvxmhnw2mlv2jcywnk2hz";
-       revision = "2";
-       editedCabalFile = "0rvalvvjadb0i0rh9z5lgw2hca4a9yw3cg2f6gcx7h30f5dp8x1j";
+       revision = "3";
+       editedCabalFile = "0jsx09bjk98nvfy0fvr5n2dyx8s22xnq66dvniyl572g5kfyknwm";
        libraryHaskellDepends = [ base bytestring ];
        description = "simple static linked SHA3 using private symbols and the ref impl";
        license = lib.licenses.bsd2;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "aeson_2_0_1_0" = callPackage
+    ({ mkDerivation, attoparsec, base, base-compat
+     , base-compat-batteries, base-orphans, base16-bytestring
+     , bytestring, containers, data-fix, deepseq, Diff, directory, dlist
+     , filepath, generic-deriving, ghc-prim, hashable
+     , indexed-traversable, integer-logarithms, primitive, QuickCheck
+     , quickcheck-instances, scientific, semialign, strict, tagged
+     , tasty, tasty-golden, tasty-hunit, tasty-quickcheck
+     , template-haskell, text, th-abstraction, these, time, time-compat
+     , unordered-containers, uuid-types, vector, witherable
+     }:
+     mkDerivation {
+       pname = "aeson";
+       version = "2.0.1.0";
+       sha256 = "0zlplkgsv1czp4rvi9k6pyyrfgd6vcdkj9vq84dr9zf7pzi8fl1s";
+       libraryHaskellDepends = [
+         attoparsec base base-compat-batteries bytestring containers
+         data-fix deepseq dlist ghc-prim hashable indexed-traversable
+         primitive scientific semialign strict tagged template-haskell text
+         th-abstraction these time time-compat unordered-containers
+         uuid-types vector witherable
+       ];
+       testHaskellDepends = [
+         attoparsec base base-compat base-orphans base16-bytestring
+         bytestring containers data-fix Diff directory dlist filepath
+         generic-deriving ghc-prim hashable integer-logarithms QuickCheck
+         quickcheck-instances scientific strict tagged tasty tasty-golden
+         tasty-hunit tasty-quickcheck template-haskell text these time
+         time-compat unordered-containers uuid-types vector
+       ];
+       description = "Fast JSON parsing and encoding";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "aeson-applicative" = callPackage
     ({ mkDerivation, aeson, base, text, unordered-containers }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "aeson-compat_0_3_10" = callPackage
+    ({ mkDerivation, aeson, attoparsec, attoparsec-iso8601, base
+     , base-compat, base-orphans, bytestring, containers, exceptions
+     , hashable, QuickCheck, quickcheck-instances, scientific, tagged
+     , tasty, tasty-hunit, tasty-quickcheck, text, time
+     , time-locale-compat, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "aeson-compat";
+       version = "0.3.10";
+       sha256 = "0ia3qfdpbrzhwwg4ywpdwca0z1m85k081pcz6jh1sx8qjsvcr71w";
+       libraryHaskellDepends = [
+         aeson attoparsec attoparsec-iso8601 base base-compat bytestring
+         containers exceptions hashable scientific tagged text time
+         time-locale-compat unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson attoparsec base base-compat base-orphans bytestring
+         containers exceptions hashable QuickCheck quickcheck-instances
+         scientific tagged tasty tasty-hunit tasty-quickcheck text time
+         time-locale-compat unordered-containers vector
+       ];
+       description = "Compatibility layer for aeson";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "aeson-decode" = callPackage
     ({ mkDerivation, aeson, aeson-qq, base, containers, data-default
      , hedgehog, text, time, unordered-containers, vector
···
      }:
      mkDerivation {
        pname = "aeson-extra";
-       version = "0.5";
-       sha256 = "0nlp6bwb8zynfncfzr05fi9acfs8n2fkz4anm2c0g97dk2ziq213";
-       revision = "2";
-       editedCabalFile = "02c6rjwm8dyijfcj2wvhx1s9pd3d37g9yqgih4x80na533naps31";
+       version = "0.5.1";
+       sha256 = "13d01hppx71cm7f901n1bd0hxj69ikbp57i6ckfygc6da0mg49jc";
        libraryHaskellDepends = [
          aeson attoparsec attoparsec-iso8601 base base-compat-batteries
          bytestring containers deepseq exceptions hashable parsec
···
        license = lib.licenses.mit;
      }) {};
 
+  "aeson-optics_1_1_1" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, base-compat, bytestring
+     , optics-core, optics-extra, scientific, text, unordered-containers
+     , vector
+     }:
+     mkDerivation {
+       pname = "aeson-optics";
+       version = "1.1.1";
+       sha256 = "1na5nsbp4sds8q289knzj4rgiwabbinxm0ihh66jfz0sjiia4wp7";
+       libraryHaskellDepends = [
+         aeson attoparsec base base-compat bytestring optics-core
+         optics-extra scientific text unordered-containers vector
+       ];
+       description = "Law-abiding optics for aeson";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "aeson-options" = callPackage
     ({ mkDerivation, aeson, base }:
      mkDerivation {
···
        pname = "aeson-pretty";
        version = "0.8.8";
        sha256 = "09n7gs91y1fbw6gjszrd2na3isnvk3y5rsi90lzjrwywnqfadkl1";
+       revision = "1";
+       editedCabalFile = "0xr8f76vmcdvlg8wvw0jdrzpzqy73d4rvf633wfwhmslfr7f5jvg";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.mit;
      }) {};
 
+  "aeson-qq_0_8_4" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, base-compat, ghc-prim
+     , haskell-src-meta, hspec, hspec-discover, parsec, scientific
+     , template-haskell, text, vector
+     }:
+     mkDerivation {
+       pname = "aeson-qq";
+       version = "0.8.4";
+       sha256 = "0dpklq2xdhrkg1rdc7zfdjnzm6c3qxx2i1xskrqdxpqi84ffnlyh";
+       libraryHaskellDepends = [
+         aeson attoparsec base base-compat haskell-src-meta parsec
+         scientific template-haskell text vector
+       ];
+       testHaskellDepends = [
+         aeson attoparsec base base-compat ghc-prim haskell-src-meta hspec
+         parsec scientific template-haskell text vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "JSON quasiquoter for Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "aeson-quick" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, criterion
      , deepseq, microlens, tasty, tasty-hunit, text
···
        broken = true;
      }) {};
 
+  "aeson-schemas_1_3_5" = callPackage
+    ({ mkDerivation, aeson, aeson-qq, base, criterion, deepseq
+     , first-class-families, hashable, hint, interpolate, megaparsec
+     , QuickCheck, raw-strings-qq, tasty, tasty-golden, tasty-hunit
+     , tasty-quickcheck, template-haskell, text, th-orphans
+     , th-test-utils, unordered-containers
+     }:
+     mkDerivation {
+       pname = "aeson-schemas";
+       version = "1.3.5";
+       sha256 = "1fdq109yjmvixri7hamj8z0iryxxdja8kkm6pk54mi0az0vx9743";
+       libraryHaskellDepends = [
+         aeson base first-class-families hashable megaparsec
+         template-haskell text unordered-containers
+       ];
+       testHaskellDepends = [
+         aeson aeson-qq base deepseq first-class-families hashable hint
+         interpolate megaparsec QuickCheck raw-strings-qq tasty tasty-golden
+         tasty-hunit tasty-quickcheck template-haskell text th-orphans
+         th-test-utils unordered-containers
+       ];
+       benchmarkHaskellDepends = [
+         aeson base criterion deepseq first-class-families hashable
+         megaparsec template-haskell text th-test-utils unordered-containers
+       ];
+       description = "Easily consume JSON data on-demand with type-safety";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "aeson-serialize" = callPackage
     ({ mkDerivation, aeson, base, cereal, hspec, HUnit }:
      mkDerivation {
···
        pname = "amazonka-core";
        version = "1.6.1";
        sha256 = "0hx250dja1l4n4y5115w0qngzlqj8f6p861sdaykh0yjm4nzb621";
-       revision = "1";
-       editedCabalFile = "1656dyw6fk3gvph6v3xzvdp3p8xny3ji0gxg7qxvmvn60gj9ricv";
+       revision = "2";
+       editedCabalFile = "15mwn2cv4f99rb53wzk7hplb6ncpcl7crsvj8dx71ymm60cf2kxr";
        libraryHaskellDepends = [
          aeson attoparsec base bifunctors bytestring case-insensitive
          conduit conduit-extra cryptonite deepseq exceptions hashable
···
      }:
      mkDerivation {
        pname = "ansi-terminal-game";
-       version = "1.1.1.0";
-       sha256 = "07b4sxx36r604j2q3xyk1y962c6fgy091ly4gc27v49zhmfrmypr";
+       version = "1.2.0.0";
+       sha256 = "167zld2dwb1l81w1n8iiqdgxx8805sirr9lsacn1ni8cfzzl2gf6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "attenuation" = callPackage
-    ({ mkDerivation, base, profunctors }:
+    ({ mkDerivation, base, constraints }:
      mkDerivation {
        pname = "attenuation";
-       version = "0.1.0.0";
-       sha256 = "0swiqnh34654rljydbd91nbkpgi1x816b7y3f57i4qnync29nsd0";
+       version = "0.2.0";
+       sha256 = "0qp203qchmllxsrcfz04lxnssrij203i5q8byy159vc8cspd03nq";
        revision = "1";
-       editedCabalFile = "1bh0ydj5fywx8zcgvfb40092jb09njj2kk09kg7gfvq2fvpz5whr";
-       libraryHaskellDepends = [ base profunctors ];
-       description = "Representational subtyping relations and variance roles";
+       editedCabalFile = "11h8m92hb0spgzvbijkgfbhbhrnf76a8w2z6yw8zahk0bgdqxrzi";
+       libraryHaskellDepends = [ base constraints ];
+       description = "Subtyping relations and variance roles";
+       license = lib.licenses.asl20;
+     }) {};
+
+  "attenuation-profunctors" = callPackage
+    ({ mkDerivation, attenuation, base, constraints, profunctors }:
+     mkDerivation {
+       pname = "attenuation-profunctors";
+       version = "0.1.0";
+       sha256 = "11zhh9iwb7r2jfp9bn8bqx1wzl4mln9v80gb2jijp0rryag25ili";
+       libraryHaskellDepends = [
+         attenuation base constraints profunctors
+       ];
+       description = "Attenuation support for Profunctors";
        license = lib.licenses.asl20;
      }) {};
 
···
        pname = "authenticate";
        version = "1.3.5";
        sha256 = "10df40ycd4r45p58xzdh0vcsa401909fa99nkgd18fx5alqh84sz";
+       revision = "1";
+       editedCabalFile = "0lmb1m5d1l2scnm2fqxfk348m8xqbc7f7kvk7zvpsvcdcpxinafz";
        libraryHaskellDepends = [
          aeson attoparsec base blaze-builder bytestring case-insensitive
          conduit containers html-conduit http-conduit http-types network-uri
···
        pname = "aws";
        version = "0.22";
        sha256 = "1l3f94mpih7slz37ikyjkyrwvlf110w87997d8sbnbd8glwlcb8r";
+       revision = "1";
+       editedCabalFile = "1xj2chcn73v45wxb3lr0b3px6p3gbbzvwgx1mqrds4lp2yy7a1cr";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "base64-bytestring-type";
        version = "1.0.1";
        sha256 = "03kq4rjj6by02rf3hg815jfdqpdk0xygm5f46r2pn8mb99yd01zn";
-       revision = "9";
-       editedCabalFile = "003vi0psr8s5whjy1qw43swiw1g1l1mxa962xqz9fdpxbmvlanfy";
+       revision = "10";
+       editedCabalFile = "0d9nd34ga5xhgkvbysqzyn03w3zi42hgfjk6cza2ymiqxrl2yk9m";
        libraryHaskellDepends = [
          aeson base base-compat base64-bytestring binary bytestring cereal
          deepseq hashable http-api-data QuickCheck serialise text
···
        ];
        description = "An Applicative Functor deferring actions to run in a batch later";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "battlenet" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "binary-instances_1_0_2" = callPackage
+    ({ mkDerivation, aeson, base, binary, binary-orphans, bytestring
+     , case-insensitive, hashable, QuickCheck, quickcheck-instances
+     , scientific, tagged, tasty, tasty-quickcheck, text, text-binary
+     , time-compat, unordered-containers, vector
+     , vector-binary-instances
+     }:
+     mkDerivation {
+       pname = "binary-instances";
+       version = "1.0.2";
+       sha256 = "10z29k35clq74ma2f0yrkbyf14wdax1zzgb6mn26ja4vp9f5wc14";
+       libraryHaskellDepends = [
+         aeson base binary binary-orphans case-insensitive hashable
+         scientific tagged text text-binary time-compat unordered-containers
+         vector vector-binary-instances
+       ];
+       testHaskellDepends = [
+         aeson base binary bytestring case-insensitive hashable QuickCheck
+         quickcheck-instances scientific tagged tasty tasty-quickcheck text
+         time-compat unordered-containers vector
+       ];
+       description = "Orphan instances for binary";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "binary-io" = callPackage
     ({ mkDerivation, async, base, binary, bytestring, concurrency
      , deque, exceptions, hspec, process, stm, transformers
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "binary-tagged_0_3_1" = callPackage
+    ({ mkDerivation, array, base, base16-bytestring, binary
+     , binary-instances, bytestring, containers, criterion, deepseq
+     , QuickCheck, quickcheck-instances, singleton-bool, structured
+     , tagged, tasty, tasty-hunit, tasty-quickcheck, text, transformers
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "binary-tagged";
+       version = "0.3.1";
+       sha256 = "01d1wb8h5mz76l09r2azphvhm1y3nar8pqrh2waxn797bd2dh6fp";
+       libraryHaskellDepends = [
+         array base base16-bytestring binary bytestring containers
+         structured tagged
+       ];
+       testHaskellDepends = [
+         base binary binary-instances bytestring QuickCheck
+         quickcheck-instances singleton-bool tagged tasty tasty-hunit
+         tasty-quickcheck transformers
+       ];
+       benchmarkHaskellDepends = [
+         base binary binary-instances bytestring criterion deepseq text
+         unordered-containers
+       ];
+       description = "Tagged binary serialisation";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "binary-tree" = callPackage
     ({ mkDerivation, base, ChasingBottoms, checkers, criterion, deepseq
      , doctest, ghc-prim, HUnit, QuickCheck, random, test-framework
···
        pname = "blank-canvas";
        version = "0.7.3";
        sha256 = "1g10959ly5nv2xfhax4pamzxnxkqbniahplc5za8k5r4nq1vjrm2";
-       revision = "3";
-       editedCabalFile = "0bdl3xbxj2dpg5gv1h0561hhjjs6pp3bkgrg18gpl3pbksmr9q8j";
+       revision = "4";
+       editedCabalFile = "0lxslpm4s98ddh12py9810k2q872vizphfrszp8gxkkvfzflbb5b";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base base-compat-batteries base64-bytestring bytestring
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "bugsnag-hs_0_2_0_5" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, hedgehog, http-client
+     , text, time, unordered-containers
+     }:
+     mkDerivation {
+       pname = "bugsnag-hs";
+       version = "0.2.0.5";
+       sha256 = "1gm38w8vjgxmn2a9a7xr364pcv7vsvd3brf90hwbwh7y88q6jdn2";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson base bytestring http-client text time unordered-containers
+       ];
+       testHaskellDepends = [ aeson base bytestring hedgehog ];
+       description = "A Bugsnag client for Haskell";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "bugzilla" = callPackage
     ({ mkDerivation, aeson, base, blaze-builder, bytestring, connection
      , containers, data-default, http-conduit, http-types, iso8601-time
···
      }:
      mkDerivation {
        pname = "bytesmith";
-       version = "0.3.7.0";
-       sha256 = "13dc4cwiga63wmnw9hl332d8gvqjl4yl0p09z2pkmwl81br7ybrc";
-       revision = "1";
-       editedCabalFile = "0jwax6jdzfcy007dqwdza1r4q8s12ly2gpzpaqy8gi52ap6xc05x";
+       version = "0.3.8.0";
+       sha256 = "0rfqpnc1awnpn50yfjxgwb65byhdcg5rivg3mbsd5clmq337cz12";
        libraryHaskellDepends = [
          base byteslice bytestring contiguous primitive run-st text-short
          wide-word
···
      }:
      mkDerivation {
        pname = "cabal-install";
-       version = "3.6.0.0";
-       sha256 = "0ishq4n1jn0kll8257akrzm95lg9ryhyp9pzypcikgvqhl0sz741";
+       version = "3.6.2.0";
+       sha256 = "0dihpm4h3xh13vnpvwflnb7v614qdvljycc6ffg5cvhwbwfrxyfw";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "cabal-install-parsers";
        version = "0.4.3";
        sha256 = "0gpnfv80rhrws12b1klyi5fkqvn8pgnl2hxh5fbnfp8fbrwklfjq";
+       revision = "1";
+       editedCabalFile = "18ngagasjind29r0840rnsjzzki92q01yi1p0fw4i5p129mczc8n";
        libraryHaskellDepends = [
          aeson base base16-bytestring binary binary-instances bytestring
          Cabal containers cryptohash-sha256 deepseq directory filepath lukko
···
        ];
        description = "Library and utility for processing cabal's plan.json file";
        license = lib.licenses.gpl2Plus;
+     }) {};
+
+  "cabal-plan_0_7_2_1" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, async, base, base-compat
+     , base16-bytestring, bytestring, containers, directory, filepath
+     , mtl, optics-core, optparse-applicative, parsec, process
+     , semialign, singleton-bool, text, these, topograph, transformers
+     , vector
+     }:
+     mkDerivation {
+       pname = "cabal-plan";
+       version = "0.7.2.1";
+       sha256 = "0n45bakzf1r1nyvs76fmrj0cf74knqnpyb2i82baxia0falbp48r";
+       configureFlags = [ "-fexe" ];
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base base16-bytestring bytestring containers directory
+         filepath text
+       ];
+       executableHaskellDepends = [
+         ansi-terminal async base base-compat bytestring containers
+         directory mtl optics-core optparse-applicative parsec process
+         semialign singleton-bool text these topograph transformers vector
+       ];
+       description = "Library and utility for processing cabal's plan.json file";
+       license = lib.licenses.gpl2Plus;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "cabal-progdeps" = callPackage
···
      }:
      mkDerivation {
        pname = "camfort";
-       version = "1.1.1";
-       sha256 = "173k5mf2w4ba553j8qh5biljw3xhrk0qipix72cx8xd0vadkh62f";
+       version = "1.1.2";
+       sha256 = "13a6x4j4f95izwz7g5sykpb2pq4lzwcswi31986gkyl6nicn5cfj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "clash-ghc_1_4_4" = callPackage
+    ({ mkDerivation, array, base, bifunctors, bytestring, Cabal
+     , clash-lib, clash-prelude, concurrent-supply, containers, deepseq
+     , directory, exceptions, extra, filepath, ghc, ghc-boot, ghc-prim
+     , ghc-typelits-extra, ghc-typelits-knownnat
+     , ghc-typelits-natnormalise, ghci, hashable, haskeline, integer-gmp
+     , lens, mtl, primitive, process, reflection, split
+     , template-haskell, text, time, transformers, uniplate, unix
+     , unordered-containers, utf8-string, vector
+     }:
+     mkDerivation {
+       pname = "clash-ghc";
+       version = "1.4.4";
+       sha256 = "0dcyf8q5n37v1arq7dyxbgg80j1dnh3i444v9p1p9rs93l2vfnab";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         array base bifunctors bytestring Cabal clash-lib clash-prelude
+         concurrent-supply containers deepseq directory exceptions extra
+         filepath ghc ghc-boot ghc-prim ghc-typelits-extra
+         ghc-typelits-knownnat ghc-typelits-natnormalise ghci hashable
+         haskeline integer-gmp lens mtl primitive process reflection split
+         template-haskell text time transformers uniplate unix
+         unordered-containers utf8-string vector
+       ];
+       executableHaskellDepends = [ base ];
+       description = "Clash: a functional hardware description language - GHC frontend";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "clash-lib" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, array
      , attoparsec, base, base16-bytestring, binary, bytestring
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "clash-lib_1_4_4" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, array
+     , attoparsec, base, base16-bytestring, binary, bytestring
+     , clash-prelude, concurrent-supply, containers, cryptohash-sha256
+     , data-binary-ieee754, data-default, deepseq, directory, dlist
+     , errors, exceptions, extra, filepath, ghc, ghc-boot-th
+     , ghc-typelits-knownnat, hashable, haskell-src-exts
+     , haskell-src-meta, hint, integer-gmp, interpolate, lens, mtl
+     , ordered-containers, parsers, pretty-show, prettyprinter
+     , primitive, process, quickcheck-text, reducers, tasty, tasty-hunit
+     , tasty-quickcheck, template-haskell, temporary, terminal-size
+     , text, text-show, time, transformers, trifecta
+     , unordered-containers, utf8-string, vector
+     , vector-binary-instances
+     }:
+     mkDerivation {
+       pname = "clash-lib";
+       version = "1.4.4";
+       sha256 = "1s04m806mdx12mbg30qrx8w75mavs5r8g7dmf5k1v9jn97jk4gvs";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson aeson-pretty ansi-terminal array attoparsec base
+         base16-bytestring binary bytestring clash-prelude concurrent-supply
+         containers cryptohash-sha256 data-binary-ieee754 data-default
+         deepseq directory dlist errors exceptions extra filepath ghc
+         ghc-boot-th hashable haskell-src-meta hint integer-gmp interpolate
+         lens mtl ordered-containers parsers pretty-show prettyprinter
+         primitive process reducers template-haskell temporary terminal-size
+         text text-show time transformers trifecta unordered-containers
+         utf8-string vector vector-binary-instances
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty base base16-bytestring bytestring clash-prelude
+         concurrent-supply containers data-default deepseq ghc
+         ghc-typelits-knownnat haskell-src-exts lens pretty-show
+         quickcheck-text tasty tasty-hunit tasty-quickcheck template-haskell
+         text transformers unordered-containers
+       ];
+       description = "Clash: a functional hardware description language - As a library";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "clash-multisignal" = callPackage
     ({ mkDerivation, base, clash-prelude, deepseq
      , ghc-typelits-knownnat, QuickCheck
···
        pname = "clash-prelude";
        version = "1.4.3";
        sha256 = "07mdl3196yb971hpcbysyaj6vciyrm1p5m9prcymkhkqh7vw9igy";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         array arrows base bifunctors binary bytestring constraints
+         containers data-binary-ieee754 data-default-class deepseq ghc-prim
+         ghc-typelits-extra ghc-typelits-knownnat ghc-typelits-natnormalise
+         half hashable integer-gmp interpolate lens QuickCheck
+         recursion-schemes reflection singletons template-haskell text
+         text-show th-abstraction th-lift th-orphans time transformers
+         type-errors uniplate vector
+       ];
+       testHaskellDepends = [
+         base deepseq doctest ghc-typelits-extra ghc-typelits-knownnat
+         ghc-typelits-natnormalise hedgehog hint quickcheck-classes-base
+         tasty tasty-hedgehog tasty-hunit tasty-quickcheck tasty-th
+         template-haskell
+       ];
+       benchmarkHaskellDepends = [
+         base criterion deepseq template-haskell
+       ];
+       description = "Clash: a functional hardware description language - Prelude library";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "clash-prelude_1_4_4" = callPackage
+    ({ mkDerivation, array, arrows, base, bifunctors, binary
+     , bytestring, Cabal, cabal-doctest, constraints, containers
+     , criterion, data-binary-ieee754, data-default-class, deepseq
+     , doctest, ghc-prim, ghc-typelits-extra, ghc-typelits-knownnat
+     , ghc-typelits-natnormalise, half, hashable, hedgehog, hint
+     , integer-gmp, interpolate, lens, QuickCheck
+     , quickcheck-classes-base, recursion-schemes, reflection
+     , singletons, tasty, tasty-hedgehog, tasty-hunit, tasty-quickcheck
+     , tasty-th, template-haskell, text, text-show, th-abstraction
+     , th-lift, th-orphans, time, transformers, type-errors, uniplate
+     , vector
+     }:
+     mkDerivation {
+       pname = "clash-prelude";
+       version = "1.4.4";
+       sha256 = "14304dc9s91blh8ljv8hd3h6gsz0nr83fzf83xkr6mxkdlhzknd4";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          array arrows base bifunctors binary bytestring constraints
···
        pname = "criterion";
        version = "1.5.10.0";
        sha256 = "0akws27z3i9381xrb0p0h5qicz4w5nnxy8jq7gk68gi50gj0flxq";
-       revision = "1";
-       editedCabalFile = "0j5cmc0w5m4fy28531f79dmbv3la51zh7k14l3kq3ix835crmmbz";
+       revision = "2";
+       editedCabalFile = "11jdxivx971fbwrg8g0pq365kg6zr6gs06zc5jcjhj34pyr6xpdr";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        ];
        description = "Robust, reliable performance measurement and analysis";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "criterion_1_5_11_0" = callPackage
+    ({ mkDerivation, aeson, ansi-wl-pprint, base, base-compat
+     , base-compat-batteries, binary, binary-orphans, bytestring
+     , cassava, code-page, containers, criterion-measurement, deepseq
+     , directory, exceptions, filepath, Glob, HUnit, js-chart
+     , microstache, mtl, mwc-random, optparse-applicative, parsec
+     , QuickCheck, statistics, tasty, tasty-hunit, tasty-quickcheck
+     , text, time, transformers, transformers-compat, vector
+     , vector-algorithms
+     }:
+     mkDerivation {
+       pname = "criterion";
+       version = "1.5.11.0";
+       sha256 = "1lwawng4rmhmqqn8gsalfn4xj2n19gwz7pl4wjssicl5qgmnvp8s";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson ansi-wl-pprint base base-compat-batteries binary
+         binary-orphans bytestring cassava code-page containers
+         criterion-measurement deepseq directory exceptions filepath Glob
+         js-chart microstache mtl mwc-random optparse-applicative parsec
+         statistics text time transformers transformers-compat vector
+         vector-algorithms
+       ];
+       executableHaskellDepends = [
+         base base-compat-batteries optparse-applicative
+       ];
+       testHaskellDepends = [
+         aeson base base-compat base-compat-batteries bytestring deepseq
+         directory HUnit QuickCheck statistics tasty tasty-hunit
+         tasty-quickcheck vector
+       ];
+       description = "Robust, reliable performance measurement and analysis";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "criterion-cmp" = callPackage
···
        broken = true;
      }) {cryptohash-sha256-pure = null;};
 
+  "cryptohash-sha256_0_11_102_1" = callPackage
+    ({ mkDerivation, base, base16-bytestring, bytestring, criterion
+     , SHA, tasty, tasty-hunit, tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "cryptohash-sha256";
+       version = "0.11.102.1";
+       sha256 = "1xkb7iqplbw4fy1122p79xf1zcb7k44rl0wmfj1q06l7cdqxr9vk";
+       configureFlags = [ "-fuse-cbits" ];
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base bytestring ];
+       testHaskellDepends = [
+         base base16-bytestring bytestring SHA tasty tasty-hunit
+         tasty-quickcheck
+       ];
+       benchmarkHaskellDepends = [ base bytestring criterion SHA ];
+       description = "Fast, pure and practical SHA-256 implementation";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "cryptohash-sha512" = callPackage
     ({ mkDerivation, base, base16-bytestring, bytestring, criterion
      , SHA, tasty, tasty-hunit, tasty-quickcheck
···
      }:
      mkDerivation {
        pname = "csound-expression";
-       version = "5.4.1";
-       sha256 = "0dyafw91ycsr71sxf7z3fbvfbp9vh8l260l9ygfxlrg37971l4pj";
+       version = "5.4.3";
+       sha256 = "00hd0sb1787cx7yppg2f3zkd3y8d75fsmf460qnsxc77m4qw5388";
        libraryHaskellDepends = [
          base Boolean colour containers csound-expression-dynamic
          csound-expression-opcodes csound-expression-typed data-default
···
      }:
      mkDerivation {
        pname = "csound-expression-dynamic";
-       version = "0.3.7";
-       sha256 = "1qx9qig18y89k4sxpn333hvqz74c6f56nbvaf8dfbawx5asar0jm";
+       version = "0.3.8";
+       sha256 = "0q94d228zsjrnjzl3w11i4cqdnx3w1mcvsrf3w6jrvysrn1zskbz";
        libraryHaskellDepends = [
          array base Boolean containers data-default data-fix data-fix-cse
          deriving-compat hashable transformers wl-pprint
···
      }:
      mkDerivation {
        pname = "csound-expression-typed";
-       version = "0.2.5";
-       sha256 = "1bid3wxg879l69w8c1vcana0xxrggxv30dw9bqi8zww2w23id54q";
+       version = "0.2.7";
+       sha256 = "1mh1mfyi2vx8ykyc1ca8vpbi545fkp7f0ss5nw6dkykl6zm7pj6d";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base Boolean colour containers csound-expression-dynamic
···
      }:
      mkDerivation {
        pname = "dep-t";
-       version = "0.4.4.0";
-       sha256 = "1qknqh9j7nvyy15zfi3prx6bifp2nd72kgfd085p478z887i71r4";
+       version = "0.4.5.0";
+       sha256 = "0hmyfq7xkz3l7d2f3d9ax782b6h0vvq1cfcxxnj1dg29hrnpd1ja";
        libraryHaskellDepends = [ base mtl transformers unliftio-core ];
        testHaskellDepends = [
          base doctest mtl rank2classes sop-core tasty tasty-hunit
···
      }:
      mkDerivation {
        pname = "dep-t-advice";
-       version = "0.4.6.0";
-       sha256 = "1v1nn0qbr3l7hh3f5aw6ril8ifzg6r8im7gpyj5plfbp272v4gs9";
+       version = "0.4.6.1";
+       sha256 = "1afr4qjzxvf4h56l0m1zjxy2m9vxs51wj1rcvxpqr3q9hvdg17vx";
        libraryHaskellDepends = [ base dep-t sop-core transformers ];
        testHaskellDepends = [
          barbies base dep-t doctest mtl rank2classes sop-core tasty
···
        pname = "dependent-literals";
        version = "0.1.1.0";
        sha256 = "0dw2xc5l8cmhsmr2akyyhyfj8m3qx02pz81fn52ii9mkhzs6rcjb";
+       revision = "2";
+       editedCabalFile = "1l3fns5gi8l5bav6z3ymvp93i1cq59f9b6p3dc496c0rmkh01kjq";
        libraryHaskellDepends = [
          base fin-int numeric-kinds sint snumber tagged wrapped
        ];
-       description = "Provides library support for pseudo-dependently-typed int literals";
+       description = "Library for dependent-literals-plugin";
        license = lib.licenses.asl20;
      }) {};
 
···
        pname = "dependent-literals-plugin";
        version = "0.1.0.1";
        sha256 = "1rpjlcv3g150rcmxidn48n25xxv2ghdz4x9jnap1swkz0fb10i3a";
+       revision = "2";
+       editedCabalFile = "1bfsv402cxwhwz22gqj8p0grr4wb9ynsd2swnwy1m6xdsfi1wdy4";
        libraryHaskellDepends = [ base ghc syb ];
        testHaskellDepends = [
          base dependent-literals fin-int numeric-kinds short-vec sint
          snumber wrapped
        ];
-       description = "Rewrites integer literals to a pseudo-dependently-typed form";
+       description = "Dependent integer literals";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "dependent-map_0_2_4_0" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "doclayout_0_3_1" = callPackage
+    ({ mkDerivation, base, containers, criterion, emojis, mtl, safe
+     , tasty, tasty-golden, tasty-hunit, tasty-quickcheck, text
+     }:
+     mkDerivation {
+       pname = "doclayout";
+       version = "0.3.1";
+       sha256 = "0cbb8l1m7w1ycf0pv8y9cbly9qxw3w5ngqbghj6qd5kk02my9zwj";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [ base containers emojis mtl safe text ];
+       testHaskellDepends = [
+         base emojis mtl tasty tasty-golden tasty-hunit tasty-quickcheck
+         text
+       ];
+       benchmarkHaskellDepends = [ base criterion mtl text ];
+       description = "A prettyprinting library for laying out text documents";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "docopt" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, base, bytestring, containers
      , HUnit, parsec, split, template-haskell, text
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "doctemplates_0_10" = callPackage
+  "doctemplates_0_10_0_1" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, criterion
      , doclayout, filepath, Glob, HsYAML, mtl, parsec, safe, scientific
      , tasty, tasty-golden, tasty-hunit, temporary, text
-     , text-conversions, unordered-containers, vector
+     , text-conversions, vector
      }:
      mkDerivation {
        pname = "doctemplates";
-       version = "0.10";
-       sha256 = "1nwav01dqxhbbmf4si8ks70lmhkldmy70m1dw89xrndvcgcynmrx";
+       version = "0.10.0.1";
+       sha256 = "08l8lgmvn83xwbdlh4m2jljj5gcyxiq1vjd1ggysv36d81swsg1x";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base containers doclayout filepath HsYAML mtl parsec safe
-         scientific text text-conversions unordered-containers vector
+         scientific text text-conversions vector
        ];
        testHaskellDepends = [
          aeson base bytestring containers doclayout filepath Glob tasty
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "emojis_0_1_2" = callPackage
+    ({ mkDerivation, base, containers, HUnit, text }:
+     mkDerivation {
+       pname = "emojis";
+       version = "0.1.2";
+       sha256 = "09x2xrppwypi369y7rzf3ln2g7c3g9qfckn2gydxpfzglcp9rziw";
+       libraryHaskellDepends = [ base containers text ];
+       testHaskellDepends = [ base HUnit text ];
+       description = "Conversion between emoji characters and their names";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "empty" = callPackage
     ({ mkDerivation }:
      mkDerivation {
···
        ];
        description = "Esqueleto support for the pgcrypto PostgreSQL module";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "ess" = callPackage
···
        pname = "exiftool";
        version = "0.2.0.0";
        sha256 = "138d25fxqz3vg62mfgmva52flyzjxd8dxr0kc7ayfil1zk3bp4jg";
+       revision = "1";
+       editedCabalFile = "0sgi3w8x1zlch0v3zpxrjhisxd1s6wj1qznjlm0gz2r5d1pzc03z";
        libraryHaskellDepends = [
          aeson base base64 bytestring hashable process scientific
          string-conversions temporary text unordered-containers vector
···
      }:
      mkDerivation {
        pname = "fin-int";
-       version = "0.1.0.0";
-       sha256 = "0ksjc8jz3l5jh6xd7aam424vpcq1ah7dcq2r5vmh4c7hcd48fakv";
-       revision = "1";
-       editedCabalFile = "0fq6cliihr0dhks62nim33f0sxqs2rwn4yd7gdd67h07acimcrzf";
+       version = "0.2.0";
+       sha256 = "0ra5lcd3ybmv1a0l7bisjlgi7b8mywa6c6pj7n82ppyi6rqssdlh";
        libraryHaskellDepends = [
          attenuation base data-default-class deepseq portray portray-diff
          QuickCheck sint
        ];
-       description = "The type of finite sets with elements identified by the ordinals";
+       description = "Finite sets of static size";
        license = lib.licenses.asl20;
      }) {};
 
···
        pname = "finite-table";
        version = "0.1.0.1";
        sha256 = "17bn5wmv5sz89yh3lh39i1armi168wxxnz6l9smcfmw334lidlv6";
+       revision = "1";
+       editedCabalFile = "17marqdap2mhlv90khnhygy78mn4gj9068gbz2ld4xv7q2kf3vlm";
        libraryHaskellDepends = [
          adjunctions base cereal data-default-class deepseq distributive
          fin-int indexed-traversable lens portray portray-diff short-vec
···
        ];
        description = "Types isomorphic to Fin, and Tables indexed by them";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "finite-typelits" = callPackage
···
        ];
        description = "Tools for functor combinator-based program design";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "functor-combinators_0_4_1_0" = callPackage
···
        description = "Tools for functor combinator-based program design";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "functor-combo" = callPackage
···
      }:
      mkDerivation {
        pname = "git-annex";
-       version = "8.20210903";
-       sha256 = "1p6zgk98jmxvqdin5xsdxhgq276bjdr2spi0wabj8x0ziry97rvl";
+       version = "8.20211011";
+       sha256 = "02s7921ihmbndp7lk1nhhiljky02ikq4qax4mhg609qjhbl6piwd";
        configureFlags = [
          "-fassistant" "-f-benchmark" "-fdbus" "-f-debuglocks" "-fmagicmime"
          "-fnetworkbsd" "-fpairing" "-fproduction" "-fs3" "-ftorrentparser"
···
      }:
      mkDerivation {
        pname = "github";
-       version = "0.26";
-       sha256 = "1vbskrkhmz4d3fccn3w12zgz2dbl40b2gljsm7lyd5k8hz50kds8";
+       version = "0.27";
+       sha256 = "0vlqsdhhjnfw9wk5vn1i8cmwa45vgczhz4nn46mwgs600xfn94am";
        libraryHaskellDepends = [
          aeson base base-compat base16-bytestring binary binary-instances
          bytestring containers cryptohash-sha1 deepseq deepseq-generics
···
        testToolDepends = [ hspec-discover ];
        description = "Access to the GitHub API, v3";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "github-backup" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "github-rest_1_1_0" = callPackage
+  "github-rest_1_1_1" = callPackage
     ({ mkDerivation, aeson, aeson-qq, base, bytestring, http-client
      , http-client-tls, http-types, jwt, mtl, scientific, tasty
      , tasty-golden, tasty-hunit, tasty-quickcheck, text, time
···
      }:
      mkDerivation {
        pname = "github-rest";
-       version = "1.1.0";
-       sha256 = "0xyvmc8hj3rfglnhg6xcrdsd9gbii8yzh8qw5xjdyccmdsibckx3";
+       version = "1.1.1";
+       sha256 = "1wf4gs3324h4pfal5qcpb65lfpm4kpmxmv4fiv6asrvhas9cwglm";
        libraryHaskellDepends = [
          aeson base bytestring http-client http-client-tls http-types jwt
          mtl scientific text time transformers unliftio unliftio-core
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "gitlab-haskell_0_3_1_1" = callPackage
+  "gitlab-haskell_0_3_2_0" = callPackage
     ({ mkDerivation, aeson, base, bytestring, connection, http-client
      , http-conduit, http-types, tasty, tasty-hunit, temporary, text
      , time, transformers, unix
      }:
      mkDerivation {
        pname = "gitlab-haskell";
-       version = "0.3.1.1";
-       sha256 = "146azh83v963njnkbcf6lacj95qx89wcvi294s3nc89bp72z8igz";
+       version = "0.3.2.0";
+       sha256 = "1ibsb4wyavyb6s64czy1pdbcskfwn96wcky4vlpr0r1f8gjpym5s";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring connection http-client http-conduit
···
        pname = "google-drive";
        version = "0.4.1";
        sha256 = "1whpifspbvqgw9hg367fjhp14ci61nnirskivawpv2airzn45xzk";
+       revision = "1";
+       editedCabalFile = "02hpkgp1k5gsc6rrx6gzzskcrdjzqbcdcppxkmv36lq0r1sj5afw";
        libraryHaskellDepends = [
          aeson base bytestring conduit conduit-extra directory filepath
          http-conduit http-types mtl random resourcet text time
···
        pname = "hastache";
        version = "0.6.1";
        sha256 = "0r5l8k157pgvz1ck4lfid5x05f2s0nlmwf33f4fj09b1kmk8k3wc";
-       revision = "5";
-       editedCabalFile = "0fwd1jd6sqkscmy2yq1w3dcl4va4w9n8mhs6ldrilh1cj6b54r3f";
+       revision = "6";
+       editedCabalFile = "1d9a6algvdyhjl94ikbz6ccnpbh0f68x8dp6bmx6lljq4b2srx51";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "iotransaction" = callPackage
-  "iotransaction" = callPackage
-  "iotransaction" = callPackage
+    ({ mkDerivation, async, base, bytestring, conduit, containers
+     , directory, filepath, filepath-bytestring, hinotify, hspec
+     , resourcet, stm, stm-chans, stm-conduit, temporary, unix
      }:
      mkDerivation {
   "iotransaction" = callPackage
-       version = "0.1.0.0";
-  "iotransaction" = callPackage
-       revision = "2";
-  "iotransaction" = callPackage
+       version = "0.1.0.1";
+       sha256 = "1377ws4rmafkjrnyn9x0a5wj98v5ysc85yzq6frg12aslc1bmvx9";
        libraryHaskellDepends = [
-  "iotransaction" = callPackage
-  "iotransaction" = callPackage
+         base bytestring conduit containers directory filepath
+         filepath-bytestring hinotify resourcet stm stm-chans stm-conduit
        ];
        testHaskellDepends = [
-  "iotransaction" = callPackage
-  "iotransaction" = callPackage
+         async base bytestring conduit containers directory filepath
+         filepath-bytestring hinotify hspec resourcet stm stm-chans
+         stm-conduit temporary unix
        ];
   "iotransaction" = callPackage
        license = lib.licenses.bsd3;
···
   "iotransaction" = callPackage
   "iotransaction" = callPackage
   "iotransaction" = callPackage
-       revision = "1";
-  "iotransaction" = callPackage
+       revision = "2";
+       editedCabalFile = "0p2d3pi268jkb3hz750apjn917kr40hhamc2apgiv08chqyk82bj";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
   "iotransaction" = callPackage
        version = "3.3.4";
   "iotransaction" = callPackage
+       revision = "1";
+       editedCabalFile = "10h1asqbk2qqmxac34amwjz9ybz2vahpa0dsrdljg3zw1r1yzkb8";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "hoogle";
        version = "5.0.18.2";
        sha256 = "1xacx2f33x1a4qlv25f8rlmb4wi0cjfzrj22nlnkrd0knghik3m7";
+       revision = "1";
+       editedCabalFile = "11ig5z81h27ify5sx2dyrx4kiv61gzd96k9qi8a11hvnk2w51a9y";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "hpack";
        version = "0.34.4";
        sha256 = "1xszy00al5zzga64gh7nvgqc93242f61kqy8lb09jkm98a8fs4bl";
+       revision = "1";
+       editedCabalFile = "0gq6ax8a7yc5lp0n24kd60kq0dgpgsgcgl970jrf1hqnzf53pspk";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hpqtypes-extras";
        version = "1.12.0.0";
        sha256 = "0pxidphf0qzfy5zv1q7qhp49bgglf3pqd6r91qq0iawnvgzcyi7z";
+       revision = "2";
+       editedCabalFile = "0gprlxfjdc6lxf2xazfr1wrna9whw6sh1jpv5rhp8bw0haslzl6j";
        libraryHaskellDepends = [
          base base16-bytestring bytestring containers cryptohash exceptions
          extra fields-json hpqtypes lifted-base log-base monad-control mtl
···
        pname = "hslogger";
        version = "1.3.1.0";
        sha256 = "0nyar9xcblx5jwks85y8f4jfy9k1h4ss6rvj4mdbiidrq3v688vz";
-       revision = "3";
-       editedCabalFile = "04mda3bwr2a00f5nbkqc84d46lmqfsk3gibzg3amdh74ngb451xq";
+       revision = "4";
+       editedCabalFile = "0249qf58s5dvqf98xqbqqigav055dgj5cx4dmz4ssl8ckk2dizdk";
        libraryHaskellDepends = [
          base bytestring containers deepseq network network-bsd old-locale
          time unix
···
        license = lib.licenses.publicDomain;
      }) {};
 
+  "http-link-header_1_2_1" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, criterion, directory
+     , errors, hspec, hspec-attoparsec, http-api-data, network-uri
+     , QuickCheck, text, transformers
+     }:
+     mkDerivation {
+       pname = "http-link-header";
+       version = "1.2.1";
+       sha256 = "15pcav5k7j4pvqwkyyrqgcm7yxqippx4yiprsg9fpml4kywcr2ca";
+       libraryHaskellDepends = [
+         attoparsec base bytestring errors http-api-data network-uri text
+       ];
+       testHaskellDepends = [
+         attoparsec base bytestring errors hspec hspec-attoparsec
+         http-api-data network-uri QuickCheck text
+       ];
+       benchmarkHaskellDepends = [
+         attoparsec base bytestring criterion directory errors http-api-data
+         network-uri text transformers
+       ];
+       description = "A parser and writer for the HTTP Link header per RFC 5988";
+       license = lib.licenses.publicDomain;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "http-listen" = callPackage
     ({ mkDerivation, base, bytestring, exceptions, HTTP, network
      , transformers
···
 
   "inline-asm" = callPackage
     ({ mkDerivation, base, bytestring, containers, either, ghc-prim
-     , hspec, hspec-core, megaparsec, mtl, parser-combinators
+     , hspec, hspec-core, megaparsec, mtl, parser-combinators, primitive
      , QuickCheck, template-haskell, uniplate
      }:
      mkDerivation {
        pname = "inline-asm";
-       version = "0.4.0.2";
-       sha256 = "01npi02i8wf9b0pa18cgl78ma6r9xqz0i7dc3khkj1725w5wkhvp";
+       version = "0.5.0.0";
+       sha256 = "02zxgkaa4wgacgj6si4158cxgk3cdf0gkvl5avmyrivbcc18xkdi";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          base bytestring containers either ghc-prim megaparsec mtl
-         parser-combinators template-haskell uniplate
-       ];
-       executableHaskellDepends = [
-         base bytestring containers either ghc-prim megaparsec mtl
-         parser-combinators template-haskell uniplate
+         parser-combinators primitive template-haskell uniplate
        ];
        testHaskellDepends = [
          base bytestring containers either ghc-prim hspec hspec-core
-         megaparsec mtl parser-combinators QuickCheck template-haskell
-         uniplate
+         megaparsec mtl parser-combinators primitive QuickCheck
+         template-haskell uniplate
        ];
        description = "Inline some Assembly in ur Haskell!";
        license = lib.licenses.bsd3;
···
        pname = "insert-ordered-containers";
        version = "0.2.5";
        sha256 = "0bb3ggzic8z5zmvmzp1fsnb572c2v383740b0ddf1fwihpn52c1y";
-       revision = "1";
-       editedCabalFile = "12x4xi525ikbqvxh2kmnxsl7cqmbz2l8vqc5ym4lap0p21niiazr";
+       revision = "2";
+       editedCabalFile = "1xjrd1sn3wkhv8f40wi5p53y8n74lkj5pnr4psjlbpqqlr4hy2ya";
        libraryHaskellDepends = [
          aeson base base-compat deepseq hashable indexed-traversable lens
          optics-core optics-extra semigroupoids semigroups text transformers
···
      }:
      mkDerivation {
        pname = "interval-algebra";
-       version = "1.0.1";
-       sha256 = "1pw4z3h1ihb82105v1i3809icp024a6cmlic2zfgdhdqf8wvfzv4";
+       version = "1.1.0";
+       sha256 = "16xx8fw7xf8rrji9n34r3xchjpd6sh3wnlbz70a3mhbdl3yp55vq";
        libraryHaskellDepends = [
          base containers foldl QuickCheck safe time witherable
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "invertible-grammar_0_1_3_2" = callPackage
+    ({ mkDerivation, base, bifunctors, containers, mtl, prettyprinter
+     , profunctors, semigroups, tagged, template-haskell, text
+     , transformers
+     }:
+     mkDerivation {
+       pname = "invertible-grammar";
+       version = "0.1.3.2";
+       sha256 = "14i0xf5j01j6ayvxix32qr2m0bz3818q26z3b4xyw41ikbhxmkp2";
+       libraryHaskellDepends = [
+         base bifunctors containers mtl prettyprinter profunctors semigroups
+         tagged template-haskell text transformers
+       ];
+       description = "Invertible parsing combinators framework";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "invertible-hlist" = callPackage
     ({ mkDerivation, base, HList, invertible }:
      mkDerivation {
···
      , doctest, envy, flow, Glob, http-media, lens, lens-aeson
      , monad-logger, network-ip, QuickCheck, regex-compat, rio, servant
      , servant-client, servant-multipart, servant-multipart-api
-     , servant-multipart-client, servant-server, swagger2, text, vector
-     , yaml
+     , servant-multipart-client, swagger2, text, vector, yaml
      }:
      mkDerivation {
        pname = "ipfs";
-       version = "1.3.2";
-       sha256 = "11gy8szp41l1y6mnvj6knb5lhlax859gri9j31w5lzhidj0045df";
+       version = "1.4.0";
+       sha256 = "1lz5wbjlxd053805cc0l51hj69rwj4a2i4b5y72gmajjqrcw4hcd";
        libraryHaskellDepends = [
          aeson base bytestring envy flow Glob http-media lens monad-logger
          network-ip regex-compat rio servant servant-client
          servant-multipart servant-multipart-api servant-multipart-client
-         servant-server swagger2 text vector
+         swagger2 text vector
        ];
        testHaskellDepends = [
          aeson base bytestring directory directory-tree doctest envy flow
          Glob http-media lens lens-aeson monad-logger network-ip QuickCheck
          regex-compat rio servant servant-client servant-multipart
-         servant-multipart-api servant-multipart-client servant-server
-         swagger2 text vector yaml
+         servant-multipart-api servant-multipart-client swagger2 text vector
+         yaml
        ];
        description = "Access IPFS locally and remotely";
        license = lib.licenses.asl20;
···
        license = lib.licenses.mit;
      }) {};
 
+  "jsonifier_0_1_2" = callPackage
+    ({ mkDerivation, aeson, base, buffer-builder, bytestring, gauge
+     , hedgehog, numeric-limits, ptr-poker, rerebase, scientific, text
+     , text-builder
+     }:
+     mkDerivation {
+       pname = "jsonifier";
+       version = "0.1.2";
+       sha256 = "14cgk8h7lasnm0z9qlddkn166vk557msnkrpahdzqpl7arwdddid";
+       libraryHaskellDepends = [
+         base bytestring ptr-poker scientific text
+       ];
+       testHaskellDepends = [ aeson hedgehog numeric-limits rerebase ];
+       benchmarkHaskellDepends = [
+         aeson buffer-builder gauge rerebase text-builder
+       ];
+       description = "Fast and simple JSON encoding toolkit";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "jsonnet" = callPackage
     ({ mkDerivation, aeson, ansi-wl-pprint, base, binary, bytestring
      , containers, data-fix, deriving-compat, directory, exceptions
···
      }:
      mkDerivation {
        pname = "kansas-comet";
-       version = "0.4";
-       sha256 = "1q9rffh6589a5am8mvfzxzwws34vg08rdjxggfabhmg9y9jla6hz";
-       revision = "22";
-       editedCabalFile = "0ii81jv62cbrvj8dpj86m2rs75jjjwnp9kka63y8bvdbacchycvj";
+       version = "0.4.1";
+       sha256 = "1j54rsqna8xrw1si8i74v0c9k4jjv8a2q001aa8sx4rxb7d1qbzy";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base containers data-default-class scotty stm text time
···
        license = lib.licenses.mit;
      }) {};
 
+  "lens-aeson_1_1_2" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, lens
+     , scientific, text, unordered-containers, vector
+     }:
+     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;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "lens-core" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "log-base";
-       version = "0.10.0.1";
-       sha256 = "0h4b7hjxcc75swj43wx0axcp5znsndkrnhn9c8fm7f7a2gmvb8l1";
+       version = "0.11.0.0";
+       sha256 = "155lzi9x33rhiymfy1271k0dz7c4qm1r48cz6kc7gcwxvrfh8dxi";
        libraryHaskellDepends = [
          aeson aeson-pretty base bytestring deepseq exceptions mmorph
          monad-control mtl semigroups stm text time transformers-base
···
      }:
      mkDerivation {
        pname = "log-elasticsearch";
-       version = "0.12.1.0";
-       sha256 = "07z0p5jcd5gjhk4dyf9ny74l68ja58ffa80mbfsyaz66ff6k4y6s";
+       version = "0.12.1.1";
+       sha256 = "0jrfrqydbg549d7gh38mq852kzd0nsaaaq6l5bi4ldfpj443kz8a";
        libraryHaskellDepends = [
          aeson aeson-pretty base base64-bytestring bytestring deepseq
          http-client http-client-tls http-types log-base network-uri
···
      }:
      mkDerivation {
        pname = "log-postgres";
-       version = "0.8.0.1";
-       sha256 = "0bc63v9w023xw1fq0pkfnk4ac336hgliayy21ny0zaz9xf39a24l";
+       version = "0.8.0.2";
+       sha256 = "167asvp7a5v8621sbr6r4j25byg18d125gqd2i4jrq57g5f2mivf";
        libraryHaskellDepends = [
          aeson aeson-pretty base base64-bytestring bytestring deepseq
          hpqtypes http-client lifted-base log-base mtl semigroups split text
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "massiv_1_0_0_0" = callPackage
+  "massiv_1_0_1_0" = callPackage
     ({ mkDerivation, base, bytestring, deepseq, doctest, exceptions
-     , mersenne-random-pure64, mwc-random, primitive, QuickCheck, random
-     , scheduler, splitmix, template-haskell, unliftio-core, vector
+     , primitive, random, scheduler, unliftio-core, vector
      }:
      mkDerivation {
        pname = "massiv";
-       version = "1.0.0.0";
-       sha256 = "0cb9riab486gz9xxx44sx5pagfjc8kv8936avywxpwpn3dhbxg6a";
+       version = "1.0.1.0";
+       sha256 = "1s47x3cya73mp4gxqn271yp8z23pfgw170pnlxbka61ap4kykmkk";
        libraryHaskellDepends = [
          base bytestring deepseq exceptions primitive random scheduler
          unliftio-core vector
        ];
-       testHaskellDepends = [
-         base doctest mersenne-random-pure64 mwc-random QuickCheck random
-         splitmix template-haskell
-       ];
+       testHaskellDepends = [ base doctest ];
        description = "Massiv (Массив) is an Array Library";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
        broken = true;
      }) {};
 
-  "massiv-persist_1_0_0_0" = callPackage
+  "massiv-persist_1_0_0_1" = callPackage
     ({ mkDerivation, base, bytestring, deepseq, doctest, hspec
      , hspec-discover, massiv, massiv-test, persist, primitive
      , QuickCheck
      }:
      mkDerivation {
        pname = "massiv-persist";
-       version = "1.0.0.0";
-       sha256 = "0kgw4ac6ywgx44mqyfyhhxpaxzyph9pgz27nvr625j4hg84mx552";
+       version = "1.0.0.1";
+       sha256 = "1j5vzk5m2r1cs5v5pzmf1i7p8zdlf29g0gdklf6snl9llk755pgy";
        libraryHaskellDepends = [
          base bytestring deepseq massiv persist primitive
        ];
···
        broken = true;
      }) {};
 
-  "massiv-serialise_1_0_0_0" = callPackage
+  "massiv-serialise_1_0_0_1" = callPackage
     ({ mkDerivation, base, deepseq, doctest, hspec, hspec-discover
      , massiv, massiv-test, QuickCheck, serialise, vector
      }:
      mkDerivation {
        pname = "massiv-serialise";
-       version = "1.0.0.0";
-       sha256 = "18ahbfq54mggar7wknghdjybd4pbqjzgfaghv5lp5daccbxahgyd";
+       version = "1.0.0.1";
+       sha256 = "0zmikmfjjshf9p0fawcg05832hxdzj04kqqh11bz1kqcc1yc7yk0";
        libraryHaskellDepends = [ base deepseq massiv serialise vector ];
        testHaskellDepends = [
          base doctest hspec massiv massiv-test QuickCheck serialise
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "microstache_1_0_2" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, deepseq
+     , directory, filepath, hspec, parsec, text, transformers
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "microstache";
+       version = "1.0.2";
+       sha256 = "0pirywb9304j2ylasskwq20k6d2srk616sh41l4s37yajsjggx5i";
+       libraryHaskellDepends = [
+         aeson base containers deepseq directory filepath parsec text
+         transformers unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers hspec parsec text
+       ];
+       description = "Mustache templates for Haskell";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "microtimer" = callPackage
     ({ mkDerivation, base, time }:
      mkDerivation {
···
        pname = "months";
        version = "0.2";
        sha256 = "054dag7806850hdii7s5rxg8gx2spdp33pnx4s4ckni9ayvspija";
-       revision = "2";
-       editedCabalFile = "1fvpzhfjpf2j01p2rwds6m82d2q0j77ak5v467nxsc8f161rfz21";
+       revision = "3";
+       editedCabalFile = "1j57vvb2vs0jd5jsq2dh0q5wpvxibwn43dwkg1l3ysl46k5sv58i";
        libraryHaskellDepends = [
          aeson attoparsec base base-compat deepseq hashable intervals
          QuickCheck text time-compat
···
        pname = "mustache";
        version = "2.3.1";
        sha256 = "0j5kzlirirnj2lscxgc6r9j0if8s3pvxswjblma6yxpw6qyzk2xc";
+       revision = "1";
+       editedCabalFile = "05qsxxpbqacfbvdzmz2y2yh3rpf2f0n2rvhvmhn33gsvydxvadbv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {inherit (pkgs) libsodium;};
 
+  "netcode-io_0_0_3" = callPackage
+    ({ mkDerivation, base, bindings-DSL, libsodium }:
+     mkDerivation {
+       pname = "netcode-io";
+       version = "0.0.3";
+       sha256 = "132rih1fd2qdshnpb8q3glhwgc8790pm8xpm3786hnrl3di1384z";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base bindings-DSL ];
+       librarySystemDepends = [ libsodium ];
+       description = "Bindings to the low-level netcode.io library.";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) libsodium;};
+
   "netcore" = callPackage
     ({ mkDerivation, ansi-wl-pprint, base, bimap, binary, binary-strict
      , bytestring, containers, fgl, HList, hslogger, HUnit, mtl
···
        platforms = [
          "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
        ];
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "notmuch" = callPackage
···
        pname = "numeric-kinds";
        version = "0.1.0.0";
        sha256 = "0rdx39wa7kklx9a7i5rdwf541fxpz9v3n32rvy2fa6i7n4hr64s4";
+       revision = "1";
+       editedCabalFile = "0zbn5yxga0sknpa83a6v2gx3dhi1rgxlxh0p3d1gd37x2zyd8lxf";
        libraryHaskellDepends = [ base ];
-       description = "Type-level numeric types, classes, and instances";
+       description = "Type-level numeric types and classes";
        license = lib.licenses.asl20;
      }) {};
 
···
        pname = "numeric-logarithms";
        version = "0.1.0.0";
        sha256 = "1izd7gc9xdrs7a1wbzmhhkv8s9rw2mcq77agvr351dc5jyzdnwiy";
-       revision = "1";
-       editedCabalFile = "0a37gmm0xgjzh05i7ix3nkgr5d2qa824nsh2wg78ikyksfq46vfv";
+       revision = "2";
+       editedCabalFile = "11lxh2lz3adwdb1hgxgqh2p2igqzbclpwal072fhdk1hcz987acq";
        libraryHaskellDepends = [ base integer-gmp ];
        testHaskellDepends = [
          base integer-gmp QuickCheck test-framework
          test-framework-quickcheck2
        ];
-       description = "Efficient rounded log2 algorithms on integral and rational types";
+       description = "Integral and rational log2 algorithms";
        license = lib.licenses.asl20;
      }) {};
 
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "opc-xml-da-client" = callPackage
+    ({ mkDerivation, acc, attoparsec, attoparsec-data, base, base64
+     , binary, bytestring, caerbannog, containers, data-default, domain
+     , domain-optics, hashable, hashable-time, http-client, QuickCheck
+     , quickcheck-instances, rerebase, scientific, tasty, tasty-hunit
+     , tasty-quickcheck, text, text-builder, time, transformers
+     , unordered-containers, vector, vector-instances, xml-conduit
+     , xml-parser
+     }:
+     mkDerivation {
+       pname = "opc-xml-da-client";
+       version = "0.1";
+       sha256 = "0wi2qv4594fz3z6jqdmqnxv17w1yp5ds8xwflnxawb6lpadprskp";
+       libraryHaskellDepends = [
+         acc attoparsec attoparsec-data base base64 bytestring containers
+         data-default domain domain-optics hashable hashable-time
+         http-client QuickCheck rerebase scientific text text-builder time
+         transformers unordered-containers vector vector-instances
+         xml-conduit xml-parser
+       ];
+       testHaskellDepends = [
+         attoparsec binary caerbannog data-default http-client QuickCheck
+         quickcheck-instances rerebase tasty tasty-hunit tasty-quickcheck
+         text-builder xml-conduit xml-parser
+       ];
+       doHaddock = false;
+       description = "OPC XML-DA Client";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "open-adt" = callPackage
     ({ mkDerivation, base, constraints, recursion-schemes, row-types
      , template-haskell
···
        pname = "operational";
        version = "0.2.4.0";
        sha256 = "1hwmwbsxzwv68b39rv4gn3da6irv8zm89gqrkc3rdsgwi5ziyn3i";
+       revision = "1";
+       editedCabalFile = "1b5vjp87lh34lpp9i4mrwcmr6rs45r6azdamwinlhrxynn91n8ri";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mtl ];
···
        maintainers = with lib.maintainers; [ Gabriel439 ];
      }) {};
 
+  "optparse-generic_1_4_6" = callPackage
+    ({ mkDerivation, base, bytestring, Only, optparse-applicative
+     , system-filepath, text, time, transformers, transformers-compat
+     , void
+     }:
+     mkDerivation {
+       pname = "optparse-generic";
+       version = "1.4.6";
+       sha256 = "1ihr5ly5xkhhds7frifgy1djay1d7yvdc617qqb7h61h4930kl3k";
+       libraryHaskellDepends = [
+         base bytestring Only optparse-applicative system-filepath text time
+         transformers transformers-compat void
+       ];
+       description = "Auto-generate a command-line parser for your datatype";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ Gabriel439 ];
+     }) {};
+
   "optparse-helper" = callPackage
     ({ mkDerivation, base, optparse-applicative }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "os-release";
-       version = "1.0.2";
-       sha256 = "0wjf1z76pqfv091b88zc3w0hmqv8i2i6qsx21cfcgaym4r3zqpjf";
+       version = "1.0.2.1";
+       sha256 = "0fyf6mjk4lmxvjgkvsz7ypx2ir67ry816wa6j7s27a1754cz6cw3";
        libraryHaskellDepends = [
          aeson base megaparsec safe-exceptions text unordered-containers
        ];
···
        pname = "persistent";
        version = "2.13.1.2";
        sha256 = "09si4h64i9drqr80a2sxpxhmsinacqx9bvsc3jah5zlm915q092y";
+       revision = "1";
+       editedCabalFile = "0xasbm1m5az7anp1wqfr69j0b7jycg82qdcq4kd97lqdn7rqvhsp";
        libraryHaskellDepends = [
          aeson attoparsec base base64-bytestring blaze-html bytestring
          conduit containers fast-logger http-api-data lift-type monad-logger
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-examples-common";
-       version = "0.1.4.0";
-       sha256 = "1dsfnjjri15mhm31ny82j26djbsw6lgvvqpq9k7fzgj0inb5slns";
+       version = "0.2.0.0";
+       sha256 = "1v2v571rjmfxqzdnm7z2v3dygknlk5nyvfyv7dkgzf7apmlmnpd2";
        libraryHaskellDepends = [
          base heaps mmsyn2-array phonetic-languages-constraints-array
          phonetic-languages-ukrainian-array
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-generalized-examples-common";
-       version = "0.2.1.0";
-       sha256 = "1i05h0rd6svffwpwzsrryzf6yvjwxd0g3f4wasz8mkh1sdgj0r5g";
+       version = "0.3.0.0";
+       sha256 = "1ajgp4wyfdzvvnj5272r0cpl9jykps5bwzn93asmfbilzfdjaynz";
        libraryHaskellDepends = [
          base heaps phonetic-languages-phonetics-basics
        ];
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "polysemy-check" = callPackage
+    ({ mkDerivation, base, containers, hspec, hspec-discover
+     , kind-generics, kind-generics-th, polysemy, polysemy-plugin
+     , QuickCheck
+     }:
+     mkDerivation {
+       pname = "polysemy-check";
+       version = "0.3.0.0";
+       sha256 = "1m7m1mi7fbf1nj98c91qxhbnhyqxgb8y7ryj7bk1llinmp2lmwaz";
+       libraryHaskellDepends = [
+         base containers kind-generics kind-generics-th polysemy QuickCheck
+       ];
+       testHaskellDepends = [
+         base containers hspec kind-generics kind-generics-th polysemy
+         polysemy-plugin QuickCheck
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "QuickCheck for Polysemy";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "polysemy-chronos" = callPackage
     ({ mkDerivation, aeson, base, chronos, containers, hedgehog
      , polysemy, polysemy-test, polysemy-time, relude, tasty
···
        pname = "portray";
        version = "0.2.0";
        sha256 = "1kzzvwqphlg1dmd486ijkv6vsqmxnp8h05mwc8590yjxdln5vzdw";
+       revision = "1";
+       editedCabalFile = "0bl0kagjn1k58pq6zbdj2zyzhpdpzs7ra1vrr8a1qdkb11gmp4n2";
        libraryHaskellDepends = [ base containers text wrapped ];
        testHaskellDepends = [
          base containers HUnit test-framework test-framework-hunit text
          wrapped
        ];
-       description = "A pseudo-Haskell syntax type and typeclass producing it";
+       description = "Rendering to pseudo-Haskell syntax";
        license = lib.licenses.asl20;
      }) {};
 
···
        pname = "portray-diff";
        version = "0.1.0.1";
        sha256 = "1da884cj865q6g1bd1fhcazyl1nzxb0pk2nvhcpp4iqkjvhyd8hw";
+       revision = "1";
+       editedCabalFile = "1dfl488jq79l0k8d8s2q1wxdibvnrrl64sz8gdy9mp0nkd6vaszl";
        libraryHaskellDepends = [
          base containers dlist portray text wrapped
        ];
-       description = "Visualize the structural differences between two values";
+       description = "Pretty structural diffs between two values";
        license = lib.licenses.asl20;
      }) {};
 
···
        pname = "portray-diff-hunit";
        version = "0.1.0.0";
        sha256 = "0gig1gvw0s7cl4jbffqh53r7lfs08clkcjpdypjjbpk0815pk34h";
+       revision = "1";
+       editedCabalFile = "023p7j386zbcmzsbdk7xk85ygi8qq4llh6zp6811grsyq3hfnsa1";
        libraryHaskellDepends = [
          base HUnit portray-diff portray-pretty pretty
        ];
-       description = "Equality assertion functions for HUnit based on portray-diff";
+       description = "HUnit assertions based on portray-diff";
        license = lib.licenses.asl20;
      }) {};
 
···
        pname = "portray-diff-quickcheck";
        version = "0.1.0.0";
        sha256 = "1kif82y8bapf5d3awkfv7wp3ih89q3p14djanyz6jfapryhccm12";
+       revision = "1";
+       editedCabalFile = "0nf5wxwvs9sad3bphb8dci5d3nr982nr05y99fmsy3vdifi366l2";
        libraryHaskellDepends = [
          base portray-diff portray-pretty QuickCheck
        ];
-       description = "Equality assertion functions for QuickCheck based on portray-diff";
+       description = "QuickCheck tests with portray-diff";
        license = lib.licenses.asl20;
      }) {};
 
···
        pname = "portray-pretty";
        version = "0.1.0.2";
        sha256 = "1gh50r77yz1l8qkhdz96bds2l0d5zi75fkir27x3si406h7sdic9";
+       revision = "1";
+       editedCabalFile = "0v30gdwjb0339q5phkbnwxj687w33rgivy772j37vp51zpiylnak";
        libraryHaskellDepends = [ base portray portray-diff pretty text ];
        testHaskellDepends = [
          base HUnit portray portray-diff pretty test-framework
          test-framework-hunit text
        ];
-       description = "A portray backend using the pretty package";
+       description = "Portray backend for pretty";
        license = lib.licenses.asl20;
      }) {};
 
···
        pname = "portray-prettyprinter";
        version = "0.2.0";
        sha256 = "16g55vjcfawx1jxmgy3zgl6bqv67h831z00912fbfh878s1s24ic";
+       revision = "1";
+       editedCabalFile = "1w7y8j2sx9wjyv5iknxjyq3r02l1kym85k1gq6carr49lf05s567";
        libraryHaskellDepends = [
          base portray portray-diff prettyprinter prettyprinter-ansi-terminal
          text
···
          prettyprinter-ansi-terminal QuickCheck test-framework
          test-framework-hunit test-framework-quickcheck2 text
        ];
-       description = "A portray backend using the prettyprinter package";
+       description = "Portray backend for prettyprinter";
        license = lib.licenses.asl20;
      }) {};
 
···
        license = lib.licenses.mit;
      }) {};
 
+  "postgresql-binary_0_12_4_2" = callPackage
+    ({ mkDerivation, aeson, base, binary-parser, bytestring
+     , bytestring-strict-builder, containers, conversion
+     , conversion-bytestring, conversion-text, criterion, json-ast
+     , network-ip, postgresql-libpq, QuickCheck, quickcheck-instances
+     , rerebase, scientific, tasty, tasty-hunit, tasty-quickcheck, text
+     , time, transformers, unordered-containers, uuid, vector
+     }:
+     mkDerivation {
+       pname = "postgresql-binary";
+       version = "0.12.4.2";
+       sha256 = "1bklkkf0r5dimdxgmgcviircv87ahv0g4nmkl34kc13pwn6l7xjm";
+       libraryHaskellDepends = [
+         aeson base binary-parser bytestring bytestring-strict-builder
+         containers network-ip scientific text time transformers
+         unordered-containers uuid vector
+       ];
+       testHaskellDepends = [
+         aeson conversion conversion-bytestring conversion-text json-ast
+         network-ip postgresql-libpq QuickCheck quickcheck-instances
+         rerebase tasty tasty-hunit tasty-quickcheck
+       ];
+       benchmarkHaskellDepends = [ criterion rerebase ];
+       description = "Encoders and decoders for the PostgreSQL's binary format";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "postgresql-common" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, postgresql-simple }:
      mkDerivation {
···
        pname = "postgresql-simple";
        version = "0.6.4";
        sha256 = "0rz2bklxp4pvbxb2w49h5p6pbwabn6d5d4j4mrya4fpa0d13k43d";
-       revision = "2";
-       editedCabalFile = "1kwjlj0bsc1yd4dgfc0ydawq9acfjlf0bymwc830dryp16wpj9zv";
+       revision = "3";
+       editedCabalFile = "1gx4vjk99lr10bcvdismr84i6rpl5ny0j08f7f7rq9j8hivj0frp";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring bytestring-builder
          case-insensitive containers hashable Only postgresql-libpq
···
        testHaskellDepends = [ async base bytestring hspec unix ];
        description = "Ergonomic process launching with extreme flexibility and speed";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "procrastinating-structure" = callPackage
···
      }:
      mkDerivation {
        pname = "proto-lens";
-       version = "0.7.0.0";
-       sha256 = "1dg73jwc9mis7igxdj3chkb8fz9a25wxw3d6nz11r98z3ambd8rs";
+       version = "0.7.1.0";
+       sha256 = "0b5wn89d23p87swjbafndrbmklix360amcq5jsl73zaqlh3vy4sy";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base bytestring containers deepseq ghc-prim lens-family parsec
···
      }:
      mkDerivation {
        pname = "proto-lens-arbitrary";
-       version = "0.1.2.9";
-       sha256 = "0ndh8jr9aybjpf1p6a6zs2qjci0z7h3c3v3i5hf28ls8w2g8zr4x";
+       version = "0.1.2.10";
+       sha256 = "1dx82fx4q2q58xavkw62ws34vikpg5g6p0w3mpvn0pigwykjnzda";
        libraryHaskellDepends = [
          base bytestring containers lens-family proto-lens QuickCheck text
        ];
···
     ({ mkDerivation, base, optparse-applicative, proto-lens, text }:
      mkDerivation {
        pname = "proto-lens-optparse";
-       version = "0.1.1.7";
-       sha256 = "0fskg0y66qp81z2x2r6jyvrisn7asmbynnq1zq2j97dn7003nqpa";
+       version = "0.1.1.8";
+       sha256 = "1y5ygqzwyvphxyj6qr5cnknjk06rs6h0xlbwa864p6hjwlayapcn";
        libraryHaskellDepends = [
          base optparse-applicative proto-lens text
        ];
···
      }:
      mkDerivation {
        pname = "proto-lens-protobuf-types";
-       version = "0.7.0.0";
-       sha256 = "1db0z3394g1fzw80ilxldbvy7m3a4piks0fk2wmlaw5k6bza82c7";
+       version = "0.7.1.0";
+       sha256 = "0yrwif600lr2pmqfninwap348k4xg5mvzx9cqp99gdgkknfb88hn";
        setupHaskellDepends = [ base Cabal proto-lens-setup ];
        libraryHaskellDepends = [
          base lens-family proto-lens proto-lens-runtime text
···
      }:
      mkDerivation {
        pname = "proto-lens-protoc";
-       version = "0.7.0.0";
-       sha256 = "1k060lr5d54mzj6c7d2k19vg2432mfnp66wr7gs1qcgpj19q9yvs";
+       version = "0.7.1.0";
+       sha256 = "14lbal80mrwla51h3yax8v1hsd05mh5xyipc051n0jkxdifs1cv5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base filepath ];
···
      }:
      mkDerivation {
        pname = "proto-lens-runtime";
-       version = "0.7.0.0";
-       sha256 = "0qxangmbldzdvm9qdvhw1cnjakx0zrxrq0nbscqvih2m2yzaxhad";
+       version = "0.7.0.1";
+       sha256 = "03dxnawrsz22s52qzfwgnzs18r7mdb1jvirsck2g62bh5incg80a";
        libraryHaskellDepends = [
          base bytestring containers deepseq filepath lens-family proto-lens
          text vector
···
      }:
      mkDerivation {
        pname = "proto-lens-setup";
-       version = "0.4.0.4";
-       sha256 = "09ka0x4ril0lw3ppx2q26zw2r9g2cszsyqrbwy0amw78g1kxma8v";
+       version = "0.4.0.5";
+       sha256 = "1zl6srfsa4nizrrrbm7b69200w42rfmxmyzdzgb3cl0675ks2r28";
        libraryHaskellDepends = [
          base bytestring Cabal containers deepseq directory filepath process
          proto-lens-protoc temporary text
···
      }:
      mkDerivation {
        pname = "raaz";
-       version = "0.3.4";
-       sha256 = "1kqinh0vwbl5qh55ai41nmkbcfbhmjdwp5pp0xap03cd0nmn84xq";
+       version = "0.3.5";
+       sha256 = "1b1xwsh01d5p685r85w0mlnf6ldqzy57vrbcsnr9lgdn6bjhvlih";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "ralist";
-       version = "0.3.0.0";
-       sha256 = "1qy6y7fcylbp6lym7y1k0bg28imhrfxrkvlfrm9mxg3lhvl71mrf";
+       version = "0.4.0.0";
+       sha256 = "1axn2mh1jiz5d39ygf0hg7a0bkywnld4j8jjkflycks1yr7mxha1";
        libraryHaskellDepends = [
          base deepseq indexed-traversable transformers
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "scheduler_2_0_0" = callPackage
-    ({ mkDerivation, atomic-primops, base, deepseq, doctest, exceptions
-     , genvalidity-hspec, hspec, hspec-discover, mwc-random, primitive
-     , pvar, QuickCheck, template-haskell, unliftio, unliftio-core
-     , vector
+  "scheduler_2_0_0_1" = callPackage
+    ({ mkDerivation, atomic-primops, base, deepseq, exceptions
+     , genvalidity-hspec, hspec, hspec-discover, primitive, pvar
+     , QuickCheck, unliftio, unliftio-core
      }:
      mkDerivation {
        pname = "scheduler";
-       version = "2.0.0";
-       sha256 = "1i0fz2gj2q12gfl1h8ar0ikkqksznr1rij7fsx1v0qi6qg9d7cc3";
+       version = "2.0.0.1";
+       sha256 = "1hdqm04m3n5y3xrhilj0hykrmqdsjz5p6k2p9y1005khkj5dag9f";
        libraryHaskellDepends = [
          atomic-primops base deepseq exceptions primitive pvar unliftio-core
        ];
        testHaskellDepends = [
-         base deepseq doctest genvalidity-hspec hspec mwc-random QuickCheck
-         template-haskell unliftio vector
+         base deepseq genvalidity-hspec hspec QuickCheck unliftio
        ];
        testToolDepends = [ hspec-discover ];
        description = "Work stealing scheduler";
···
        pname = "scotty";
        version = "0.12";
        sha256 = "1lpggpdzgjk23mq7aa64yylds5dbm4ynhcvbarqihjxabvh7xmz1";
-       revision = "5";
-       editedCabalFile = "0fvxkpggysz6wfpllqwzx5xywgb2fnfmknw9xhvmxgk765v60jrn";
+       revision = "6";
+       editedCabalFile = "15gwvx9gdk4vxh1x2n5xvnrix8m0wl96a4aqbdmdfrka43sywfma";
        libraryHaskellDepends = [
          aeson base base-compat-batteries blaze-builder bytestring
          case-insensitive data-default-class exceptions fail http-types
···
        pname = "semigroupoids";
        version = "5.3.6";
        sha256 = "0glhqc9x8i5z3bdg23xvl2lfns95msid3h3x0jksna7i6c8j869n";
+       revision = "1";
+       editedCabalFile = "0inbks8x588bpcw7kyap69iy0zrkygycp8hwgrd9yhbxlvj9hmh9";
        libraryHaskellDepends = [
          base base-orphans bifunctors comonad containers contravariant
          distributive hashable tagged template-haskell transformers
···
      }:
      mkDerivation {
        pname = "servant-benchmark";
-       version = "0.1.2.0";
-       sha256 = "0lqqk410nx48g895pfxkbbk85b1ijs4bfl9zr2li2p7wwwc4gyi9";
-       revision = "3";
-       editedCabalFile = "17pj6n143lpk5nsr6j8j1a6fj45y1bv61jcm16m0fwsdmhv01866";
+       version = "0.2.0.0";
+       sha256 = "0dxyq9n0v09287nz1nqb2m0bdyabdzqig9avpmx4viyf9xzyh6bd";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring case-insensitive http-media
          http-types QuickCheck servant text yaml
···
        ];
        description = "Command line interface for Servant API clients";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "servant-client" = callPackage
···
        ];
        description = "Servant combinators to facilitate writing GitHub webhooks";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "servant-haxl-client" = callPackage
···
      }:
      mkDerivation {
        pname = "servant-pagination";
-       version = "2.3.0";
-       sha256 = "0kza7lr3akx3zviqbxlw74f1y66y8c6kys52n49brvrhqwnv4xwd";
+       version = "2.4.1";
+       sha256 = "181an5p0qfzbv3cirnaq8bw778iib4qhv53y60z1ssn16v2vxhq5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "servant-to-elm";
-       version = "0.4.2.0";
-       sha256 = "1hbz6c9233wgpgmgnplg9qv5hrniynkn5n4zsmkyansw07gmaw05";
+       version = "0.4.3.0";
+       sha256 = "1s63x270bci7nyz595azff1ny868jjpqbilmy01rzbspjrfhwi7d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "sexp-grammar_2_3_3_1" = callPackage
+    ({ mkDerivation, alex, array, base, bytestring, containers
+     , criterion, data-fix, deepseq, happy, invertible-grammar
+     , prettyprinter, QuickCheck, recursion-schemes, scientific
+     , semigroups, tasty, tasty-hunit, tasty-quickcheck, text
+     , utf8-string
+     }:
+     mkDerivation {
+       pname = "sexp-grammar";
+       version = "2.3.3.1";
+       sha256 = "08sqpk5qgq3mqlxvz24sw43m52khynpf41cnd4yif4b4ri583mb9";
+       libraryHaskellDepends = [
+         array base bytestring containers data-fix deepseq
+         invertible-grammar prettyprinter recursion-schemes scientific
+         semigroups text utf8-string
+       ];
+       libraryToolDepends = [ alex happy ];
+       testHaskellDepends = [
+         base bytestring containers invertible-grammar prettyprinter
+         QuickCheck scientific semigroups tasty tasty-hunit tasty-quickcheck
+         text
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring criterion deepseq text
+       ];
+       description = "Invertible grammar combinators for S-expressions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "sexp-show" = callPackage
     ({ mkDerivation, base, pretty-show }:
      mkDerivation {
···
        pname = "shakespeare";
        version = "2.0.25";
        sha256 = "1fjv3yg425d87d3dih0l3ff95g5a5yp9w85m58sjara6xqivj9s4";
+       revision = "1";
+       editedCabalFile = "0na31a7h3sq8ndrx79waywsfj5667pm0masy10gxzhzwmf6i3s1l";
        libraryHaskellDepends = [
          aeson base blaze-html blaze-markup bytestring containers directory
          exceptions ghc-prim parsec process scientific template-haskell text
···
        pname = "short-vec";
        version = "0.1.0.0";
        sha256 = "0w651jipwxh7k4ng5rvq507br4347hzy8x8c47c1g7haryj80gzq";
-       revision = "2";
-       editedCabalFile = "1w56zmw085509grvk5ddlrv12pqpzfpmdprjd44lv4sgzv09bzfk";
+       revision = "4";
+       editedCabalFile = "1rwzaxdpkrn1v7p8jph4m91vyphdzm9h2yppnmanp636p0sjxzf4";
        libraryHaskellDepends = [
          adjunctions base data-default-class deepseq distributive fin-int
          indexed-traversable integer-gmp portray portray-diff QuickCheck
···
          gauge indexed-traversable integer-gmp portray portray-diff
          QuickCheck semigroupoids sint
        ];
-       description = "A length-indexed vector type build on 'SmallArray#'";
+       description = "Length-indexed vectors using SmallArray#";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "short-vec-lens" = callPackage
···
        pname = "short-vec-lens";
        version = "0.1.0.0";
        sha256 = "1afz1izz19xrjy0cdhmpy7b667waa5v8jh1ps3jpjfpgbmysjz3g";
+       revision = "1";
+       editedCabalFile = "1bkvx7csgqdn16kamih5h797pcg3ppcf6gln7lf01bw9pd5hpkkb";
        libraryHaskellDepends = [
          base fin-int indexed-traversable lens short-vec sint
        ];
        description = "Lenses and related functionality for the `short-vec` package";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "shortbytestring" = callPackage
···
        pname = "snumber";
        version = "0.1.0.0";
        sha256 = "0f340hzhhmiy342c5250m61f3gkcnfymjbd2a13alzdh7pmhb2mg";
+       revision = "1";
+       editedCabalFile = "0cc7chg4qhqlrkdv2m7y514gs9lm1hixwaw543dv47vqb12063im";
        libraryHaskellDepends = [ base numeric-kinds ];
-       description = "Indexed numeric types linking type-level and value-level numbers";
+       description = "Integer singletons with flexible representation";
        license = lib.licenses.asl20;
      }) {};
 
···
        pname = "stackcollapse-ghc";
        version = "0.0.1.4";
        sha256 = "1scqjjp1cpz3zzvqa6wmfz11qrhsbqwgq7h8qjg0d8ri3r9z82lb";
+       revision = "1";
+       editedCabalFile = "0k4gayvmjdfvfbyxjcmw1hk9vi90l0f9p3npi4rv2wwn1pl00vgm";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "string-interpreter";
-       version = "0.5.3.0";
-       sha256 = "0ny0py7fhcbv1zkr96ngypb9mf241avds0i77lynnpig96j1ay14";
+       version = "0.5.4.1";
+       sha256 = "1dgmqircw5gz62crxzx3d7gk2xyvmcwqdy15rpjgy2q7q5brcv7h";
        libraryHaskellDepends = [ base ];
        description = "Is used in the phonetic languages approach (e. g. in the recursive mode).";
        license = lib.licenses.mit;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "structured_0_1_1" = callPackage
+    ({ mkDerivation, aeson, array, base, base16-bytestring, binary
+     , bytestring, containers, hashable, scientific, tagged, text
+     , time-compat, transformers, unordered-containers, uuid-types
+     , vector
+     }:
+     mkDerivation {
+       pname = "structured";
+       version = "0.1.1";
+       sha256 = "1mz02ys85z79nj24ylsmgh8v2m7zv2rixf7w0iqnwc49lax52w4q";
+       libraryHaskellDepends = [
+         aeson array base base16-bytestring binary bytestring containers
+         hashable scientific tagged text time-compat transformers
+         unordered-containers uuid-types vector
+       ];
+       description = "Structure (hash) of your data types";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "structured-cli" = callPackage
     ({ mkDerivation, base, data-default, exceptions, haskeline, mtl
      , split, transformers
···
        libraryPkgconfigDepends = [ librsvg ];
        description = "Binding to the libsvg-cairo library";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) librsvg;};
 
   "svgone" = callPackage
···
        license = "unknown";
      }) {};
 
-  "sydtest_0_4_0_0" = callPackage
+  "sydtest_0_4_1_0" = callPackage
     ({ mkDerivation, async, base, bytestring, containers, Diff, dlist
      , envparse, filepath, MonadRandom, mtl, optparse-applicative, path
      , path-io, pretty-show, QuickCheck, quickcheck-io, random-shuffle
···
      }:
      mkDerivation {
        pname = "sydtest";
-       version = "0.4.0.0";
-       sha256 = "1r3isd8rjlzx7j1j5drgd1zjxdp8a1hvwsla513hpv32mkbqf0za";
+       version = "0.4.1.0";
+       sha256 = "1g63qq1hisfpnic9sl2a8bry1wyr6ccdcq0l2dagdnggripjgdl1";
        libraryHaskellDepends = [
          async base bytestring containers Diff dlist envparse filepath
          MonadRandom mtl optparse-applicative path path-io pretty-show
···
        pname = "taskwarrior";
        version = "0.3.0.0";
        sha256 = "1h24d799q1s6b36hd40bxa4c9m1izkgh6j7p2jv1p6cxngz28ni0";
-       revision = "5";
-       editedCabalFile = "1h7ybnxx5f0w1h13wzbx30ycf578dnv12wx4pqn3pfxqz1jz3gjg";
+       revision = "6";
+       editedCabalFile = "02jag4yib1fqf2fp9p323hb3vsbkrqm1k9zp2wag6ysl5kvvq1x6";
        libraryHaskellDepends = [
          aeson base bytestring containers process random text time
          unordered-containers uuid
···
        pname = "ten";
        version = "0.1.0.2";
        sha256 = "0djvcb2l9dnnjbhivchi6yyaj5i96jmy7yhr9x3paiz1l54brrqx";
+       revision = "1";
+       editedCabalFile = "1dcr49q8g3wr1glhlawvg4bbz3mykvwnx7z9pw1ssvk9w7839z6r";
        libraryHaskellDepends = [
          adjunctions base data-default-class deepseq distributive hashable
          portray portray-diff some text transformers wrapped
···
          HUnit portray portray-diff some test-framework test-framework-hunit
          text transformers wrapped
        ];
-       description = "Typeclasses like Functor, etc. over arity-1 type constructors.";
+       description = "Functors et al. over arity-1 type constructors";
        license = lib.licenses.asl20;
      }) {};
 
···
        pname = "ten-unordered-containers";
        version = "0.1.0.2";
        sha256 = "0y4aw77ix2ay43l8n17322hbmm1npcdr1bl7kdza377jd1ci20px";
+       revision = "1";
+       editedCabalFile = "196gjc39c0x4p444byh7mwnhf9ci7dxhmxl602ha52fr554cdh0j";
        libraryHaskellDepends = [
          base hashable portray portray-diff some ten unordered-containers
          wrapped
···
          portray-pretty some ten ten-lens test-framework
          test-framework-hunit text transformers unordered-containers wrapped
        ];
-       description = "A package providing one unordered container";
+       description = "Higher-kinded hash containers";
        license = lib.licenses.asl20;
      }) {};
 
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "text-short_0_1_4" = callPackage
+    ({ mkDerivation, base, binary, bytestring, deepseq, ghc-prim
+     , hashable, quickcheck-instances, tasty, tasty-hunit
+     , tasty-quickcheck, template-haskell, text
+     }:
+     mkDerivation {
+       pname = "text-short";
+       version = "0.1.4";
+       sha256 = "1p56cjm6f883ajb54y8hmrl01sqda6a36xvbmgjv3mb9gxv953v4";
+       libraryHaskellDepends = [
+         base binary bytestring deepseq ghc-prim hashable template-haskell
+         text
+       ];
+       testHaskellDepends = [
+         base binary bytestring quickcheck-instances tasty tasty-hunit
+         tasty-quickcheck template-haskell text
+       ];
+       description = "Memory-efficient representation of Unicode text strings";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "text-show" = callPackage
     ({ mkDerivation, array, base, base-compat-batteries, base-orphans
      , bifunctors, bytestring, bytestring-builder, containers, criterion
···
        pname = "threepenny-gui";
        version = "0.9.1.0";
        sha256 = "00sjkfa9qfnnwqfdw68yb8hq6nm1y5qv9896rzn5aachr7mlfpx2";
+       revision = "1";
+       editedCabalFile = "0zdpkp0pl6z4aabikbq30md392gk988fxwcqw10khv1icm143pcc";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        license = lib.licenses.gpl2Plus;
      }) {};
 
+  "tree-diff_0_2_1" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, ansi-wl-pprint, base
+     , base-compat, bytestring, bytestring-builder, containers
+     , criterion, deepseq, Diff, hashable, parsec, parsers, pretty
+     , primitive, QuickCheck, scientific, semialign, strict, tagged
+     , tasty, tasty-golden, tasty-quickcheck, text, these, time
+     , trifecta, unordered-containers, uuid-types, vector
+     }:
+     mkDerivation {
+       pname = "tree-diff";
+       version = "0.2.1";
+       sha256 = "0bybi4qp7nj9117yza5qqgw2f7s6rk3i7q642jqd7sdn3bx5cnap";
+       libraryHaskellDepends = [
+         aeson ansi-terminal ansi-wl-pprint base base-compat bytestring
+         bytestring-builder containers deepseq hashable parsec parsers
+         pretty primitive QuickCheck scientific semialign strict tagged text
+         these time unordered-containers uuid-types vector
+       ];
+       testHaskellDepends = [
+         ansi-terminal ansi-wl-pprint base base-compat parsec primitive
+         QuickCheck tagged tasty tasty-golden tasty-quickcheck trifecta
+       ];
+       benchmarkHaskellDepends = [ base criterion deepseq Diff ];
+       description = "Diffing of (expression) trees";
+       license = lib.licenses.gpl2Plus;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "tree-fun" = callPackage
     ({ mkDerivation, base, containers, mtl }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "wai-feature-flags_0_1_0_2" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, splitmix, text
+     , unordered-containers, wai, warp
+     }:
+     mkDerivation {
+       pname = "wai-feature-flags";
+       version = "0.1.0.2";
+       sha256 = "03w8hskgajvkhjsrj7ynxcx92qghqfd9rfxb5v4wm7wb6lag8qvh";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson base bytestring splitmix text unordered-containers wai
+       ];
+       executableHaskellDepends = [ base wai warp ];
+       description = "Feature flag support for WAI applications";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "wai-frontend-monadcgi" = callPackage
     ({ mkDerivation, base, bytestring, case-insensitive, cgi
      , containers, http-types, transformers, wai
···
        ];
        description = "Warp based on QUIC";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "warp-static" = callPackage
···
        maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
+  "weeder_2_3_0" = callPackage
+    ({ mkDerivation, algebraic-graphs, base, bytestring, containers
+     , dhall, directory, filepath, generic-lens, ghc, lens, mtl
+     , optparse-applicative, regex-tdfa, text, transformers
+     }:
+     mkDerivation {
+       pname = "weeder";
+       version = "2.3.0";
+       sha256 = "1l3g0afb0k91qb64kpj18nb53njbv3s5w06rkjf58p7qk6ynk9ig";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         algebraic-graphs base bytestring containers dhall directory
+         filepath generic-lens ghc lens mtl optparse-applicative regex-tdfa
+         text transformers
+       ];
+       executableHaskellDepends = [
+         base bytestring containers directory filepath ghc
+         optparse-applicative transformers
+       ];
+       description = "Detect dead code";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ maralorn ];
+     }) {};
+
   "weekdaze" = callPackage
     ({ mkDerivation, array, base, bytestring, Cabal, containers
      , cryptohash, data-default, deepseq, directory, extra, factory
···
        pname = "witherable";
        version = "0.4.1";
        sha256 = "1jj2dq0ddaa2v3hksnrv1z1ll19fa4npsqlp7fs4nn5g6833y58b";
+       revision = "1";
+       editedCabalFile = "02l2gbcab7w72hqlbs1ikylgb1970a0iyrikn847nncivbzrc3gj";
        libraryHaskellDepends = [
          base base-orphans containers hashable indexed-traversable
          indexed-traversable-instances transformers unordered-containers
···
        pname = "wrapped";
        version = "0.1.0.1";
        sha256 = "00fvammhn4dlna5d1dc8lpwrdrigj9cnlyi8scwslibr6bjsjzfp";
+       revision = "1";
+       editedCabalFile = "0qfl0k0bsxhf5zibfdfm08jn82j1nm8pdnmv23znmhv77hpm4li8";
        libraryHaskellDepends = [ base ];
-       description = "Provides a single standardized place to hang DerivingVia instances";
+       description = "Newtypes to carry DerivingVia instances";
        license = lib.licenses.asl20;
      }) {};
 
···
        pname = "wrapped-generic-default";
        version = "0.1.0.1";
        sha256 = "10hbz8m98cw8lr2xj0wkc017pnypagb11ss1ihpp6lnc4w1hpj3f";
+       revision = "1";
+       editedCabalFile = "0i75biqz6qml17yzg3k4q0ms5vzvwph37da1wl3l5v8cjnw2yrs7";
        libraryHaskellDepends = [ base data-default-class wrapped ];
-       description = "Provides an orphan instance Default (Wrapped Generic a)";
+       description = "A Generic instance of Default";
        license = lib.licenses.asl20;
      }) {};
 
···
      }) {};
 
   "xmonad-dbus" = callPackage
-    ({ mkDerivation, base, dbus, utf8-string }:
+    ({ mkDerivation, base, dbus }:
      mkDerivation {
        pname = "xmonad-dbus";
-       version = "0.1.0.0";
-       sha256 = "18phy3wxags8cmgs9bdkhwb4gy8fr72j25b18nk44q8956a3060p";
+       version = "0.1.0.1";
+       sha256 = "15sqfk4y4arrv0bjzkrw49z1p7k3fqkn4w8pak2j7rki3915iyd4";
        isLibrary = true;
        isExecutable = true;
-       libraryHaskellDepends = [ base dbus utf8-string ];
-       executableHaskellDepends = [ base dbus utf8-string ];
-       testHaskellDepends = [ base dbus utf8-string ];
+       libraryHaskellDepends = [ base dbus ];
+       executableHaskellDepends = [ base dbus ];
+       testHaskellDepends = [ base dbus ];
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
···
        pname = "yaml";
        version = "0.11.6.0";
        sha256 = "0hxg9mfi1dn9a7kp3imzfvnk7jj4sdjdxi6xyqz9ra7lqg14np3r";
+       revision = "1";
+       editedCabalFile = "1yydwna0x7fj1zw0zkz3n1cfvnwdykblk19wz5bw9rcwp0i0mzkb";
        configureFlags = [ "-fsystem-libyaml" ];
        isLibrary = true;
        isExecutable = true;
···
        ];
        description = "Support for parsing and rendering YAML documents";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "yaml_0_11_7_0" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, base-compat, bytestring
+     , conduit, containers, directory, filepath, hspec, HUnit, libyaml
+     , mockery, mtl, raw-strings-qq, resourcet, scientific
+     , template-haskell, temporary, text, transformers
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "yaml";
+       version = "0.11.7.0";
+       sha256 = "0s08kw0hqxixxripwjmz7b4yh9130dws3jaj460x8ds8q4b6khbx";
+       configureFlags = [ "-fsystem-libyaml" ];
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson attoparsec base bytestring conduit containers directory
+         filepath libyaml mtl resourcet scientific template-haskell text
+         transformers unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson attoparsec base base-compat bytestring conduit containers
+         directory filepath hspec HUnit libyaml mockery mtl raw-strings-qq
+         resourcet scientific template-haskell temporary text transformers
+         unordered-containers vector
+       ];
+       description = "Support for parsing and rendering YAML documents";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "yaml-combinators" = callPackage

pkgs/top-level/release-haskell.nix

···
       # package sets (like Cabal, jailbreak-cabal) are
       # working as expected.
       cabal-install = all;
-      Cabal_3_6_1_0 = with compilerNames; [ ghc884 ghc8107 ghc901 ghc921 ];
+      Cabal_3_6_2_0 = with compilerNames; [ ghc884 ghc8107 ghc901 ghc921 ];
       cabal2nix-unstable = all;
       funcmp = all;
       haskell-language-server = all;