Merge pull request #131591 from NixOS/haskell-updates

haskellPackages: update stackage and hackage

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "51c018b566e360a908addb7fcabf98fc0fbaafbe",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/51c018b566e360a908addb7fcabf98fc0fbaafbe.tar.gz",
-  "sha256": "0xbc0z6zx60c0m3ck0iaa5xsw7d5phk2d8wh66w66j7ci7dyah85",
-  "msg": "Update from Hackage at 2021-07-21T05:42:12Z"
+  "commit": "e40930a03e038e12969b8eac001e86d7aa7355b4",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/e40930a03e038e12969b8eac001e86d7aa7355b4.tar.gz",
+  "sha256": "16wzasswii49xj9pyxmr4r5lwp2qqc2z90a4gq5ihclcy15r8kdc",
+  "msg": "Update from Hackage at 2021-07-26T15:54:23Z"
 }

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

···
 }:
 mkDerivation {
   pname = "cabal2nix";
-  version = "unstable-2021-07-08";
+  version = "unstable-2021-07-21";
   src = fetchzip {
-    url = "https://github.com/NixOS/cabal2nix/archive/b28902718d89f6a14a836d95a7093bc46e4f8bb5.tar.gz";
-    sha256 = "1jdbz0krwzzsl3vb10xgman642v49bbgwyl6dw3p9aw6s7a8nfgk";
+    url = "https://github.com/NixOS/cabal2nix/archive/b5b8981921771af9c592cd48631b7f8f21745dff.tar.gz";
+    sha256 = "1r2rkqq0knnn4m8xhjmnkl07mv4cb13adf88y2qq69zpxkb24frn";
   };
   isLibrary = true;
   isExecutable = true;

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

···
     excludes = ["test/buildtest"];
   });
 
-  # workaround for https://github.com/peti/distribution-nixpkgs/issues/9
-  pam = super.pam.override { inherit (pkgs) pam; };
-
   # Too strict version bounds on base:
   # https://github.com/obsidiansystems/database-id/issues/1
   database-id-class = doJailbreak super.database-id-class;
 
-  cabal2nix-unstable = overrideCabal super.cabal2nix-unstable {
+  cabal2nix-unstable = overrideCabal (super.cabal2nix-unstable.override {
+    distribution-nixpkgs = self.distribution-nixpkgs_1_6_0;
+  }) {
     passthru.updateScript = ../../../maintainers/scripts/haskell/update-cabal2nix-unstable.sh;
   };
 
···
   # unrestrict bounds for hashable and semigroups
   # https://github.com/HeinrichApfelmus/reactive-banana/issues/215
   reactive-banana = doJailbreak super.reactive-banana;
-
-  hackage-db_2_1_0 = doDistribute super.hackage-db_2_1_0;
 
   # Too strict bounds on QuickCheck
   # https://github.com/muesli4/table-layout/issues/16

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

···
       executableHaskellDepends = drv.executableToolDepends or [] ++ [ self.repline ];
     }));
 
-  # hackage-db 2.1.1 is incompatible with Cabal < 3.4
-  # See https://github.com/NixOS/cabal2nix/issues/501
-  hackage-db = self.hackage-db_2_1_0;
-
 }

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

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

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

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

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

···
   - EnumMap
   - enummapmap
   - enum-utf8
+  - env-extra
   - env-parser
   - envstatus
   - epanet-haskell
···
   - ghc-syb-utils
   - ghc-tags
   - ghc-tags-core
+  - ghc-tcplugin-api
   - ghc-time-alloc-prof
   - ghc-usage
   - gh-labeler
···
   - hs-tags
   - hstats
   - hstatsd
+  - hs-term-emulator
   - hstest
   - hstidy
   - hs-twitter
···
   - streaming-utils
   - streaming-with
   - streamly-examples
-  - streamly-fsnotify
+  - streamly-process
   - stream-monad
   - streamproc
   - StrictBench
···
   - tapioca
   - TaskMonad
   - tasty-auto
+  - tasty-checklist
   - tasty-fail-fast
   - tasty-grading-system
   - tasty-hedgehog-coverage

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

···
   - dual-tree < 0.2.3.0
   - diagrams-core < 1.5.0
   - diagrams-lib < 1.4.4
-  # streamly-bytestring 0.1.3 needs streamly 0.8.0 which is not included in our stackage snapshot
-  - streamly-bytestring == 0.1.2
+  # streamly-* packages which are not in stackage and to be constrained
+  # as long as we have streamly < 0.8.0
+  - streamly-archive < 0.1.0
+  - streamly-bytestring < 0.1.3
+  - streamly-lmdb < 0.3.0
+  - streamly-process
+  - distribution-nixpkgs < 1.6.0        # 2021-07-26: required until cabal2nix 2.17.1 is released
 
 extra-packages:
   - base16-bytestring < 1               # required for cabal-install etc.
···
   - sbv == 7.13                         # required for pkgs.petrinizer
   - crackNum < 3.0                      # 2021-05-21: 3.0 removed the lib which sbv 7.13 uses
   - ShellCheck == 0.7.1                 # 2021-05-09: haskell-ci 0.12.1 pins this version
-  - hackage-db < 2.1.1                  # 2021-06-10: Need older hackage-db as long as Cabal < 3.4, see https://github.com/NixOS/cabal2nix/issues/501
 
 package-maintainers:
   abbradar:

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

···
-# Stackage LTS 18.2
+# Stackage LTS 18.4
 # This file is auto-generated by
 # maintainers/scripts/haskell/update-stackage.sh
 default-package-overrides:
···
   - ghc-lib-parser-ex ==8.10.0.21
   - ghc-parser ==0.2.3.0
   - ghc-paths ==0.1.0.12
-  - ghc-prof ==1.4.1.8
+  - ghc-prof ==1.4.1.9
   - ghc-source-gen ==0.4.1.0
   - ghc-syntax-highlighter ==0.0.6.0
   - ghc-tcplugins-extra ==0.4.2
···
   - gtk-strut ==0.1.3.0
   - guarded-allocation ==0.0.1
   - H ==0.9.0.1
-  - hackage-db ==2.1.1
+  - hackage-db ==2.1.2
   - hackage-security ==0.6.0.1
   - haddock-library ==1.10.0
   - hadoop-streaming ==0.2.0.3
···
   - inline-c-cpp ==0.4.0.3
   - inline-r ==0.10.4
   - inliterate ==0.1.0
-  - input-parsers ==0.2.2
+  - input-parsers ==0.2.3
   - insert-ordered-containers ==0.2.5
   - inspection-testing ==0.4.5.0
   - instance-control ==0.1.2.0
···
   - json-rpc-generic ==0.2.1.5
   - JuicyPixels ==3.3.5
   - JuicyPixels-blurhash ==0.1.0.3
-  - JuicyPixels-extra ==0.5.1
+  - JuicyPixels-extra ==0.5.2
   - JuicyPixels-scale-dct ==0.1.2
   - junit-xml ==0.1.0.2
   - justified-containers ==0.3.0.0
···
   - kmeans ==0.1.3
   - koji ==0.0.2
   - koofr-client ==1.0.0.3
-  - krank ==0.2.2
+  - krank ==0.2.3
   - kubernetes-webhook-haskell ==0.2.0.3
   - l10n ==0.1.0.1
   - labels ==0.3.3
···
   - liboath-hs ==0.0.1.2
   - libyaml ==0.1.2
   - LibZip ==1.0.1
-  - lifted-async ==0.10.2
+  - lifted-async ==0.10.2.1
   - lifted-base ==0.2.3.12
   - lift-generics ==0.2
   - lift-type ==0.1.0.1
···
   - lukko ==0.1.1.3
   - lz4-frame-conduit ==0.1.0.1
   - lzma ==0.0.0.3
+  - lzma-clib ==5.2.2
   - lzma-conduit ==1.2.1
   - machines ==0.7.2
   - machines-binary ==7.0.0.0
···
   - monad-unlift ==0.2.0
   - monad-unlift-ref ==0.2.1
   - mongoDB ==2.7.1.1
-  - monoid-subclasses ==1.1
+  - monoid-subclasses ==1.1.1
   - monoid-transformer ==0.0.4
   - mono-traversable ==1.0.15.1
   - mono-traversable-instances ==0.1.1.0
···
   - nqe ==0.6.3
   - nri-env-parser ==0.1.0.7
   - nri-observability ==0.1.1.1
-  - nri-prelude ==0.6.0.2
+  - nri-prelude ==0.6.0.3
   - nsis ==0.3.3
   - numbers ==3000.2.0.2
   - numeric-extras ==0.1
···
   - prospect ==0.1.0.0
   - proto3-wire ==1.2.2
   - protobuf ==0.2.1.3
-  - protobuf-simple ==0.1.1.0
+  - protobuf-simple ==0.1.1.1
   - protocol-buffers ==2.4.17
   - protocol-buffers-descriptor ==2.4.17
   - protocol-radius ==0.0.1.1
···
   - Ranged-sets ==0.4.0
   - range-set-list ==0.1.3.1
   - rank1dynamic ==0.4.1
-  - rank2classes ==1.4.1
+  - rank2classes ==1.4.2
   - Rasterific ==0.7.5.4
   - rasterific-svg ==0.3.3.2
   - ratel ==1.0.15
···
   - regex-compat-tdfa ==0.95.1.4
   - regex-pcre ==0.95.0.0
   - regex-pcre-builtin ==0.95.2.3.8.43
-  - regex-posix ==0.96.0.0
+  - regex-posix ==0.96.0.1
   - regex-tdfa ==1.3.1.1
   - regex-with-pcre ==1.1.0.0
   - registry ==0.2.0.3
   - reinterpret-cast ==0.1.0
   - relapse ==1.0.0.0
-  - relational-query ==0.12.2.3
+  - relational-query ==0.12.3.0
   - relational-query-HDBC ==0.7.2.0
   - relational-record ==0.2.2.0
   - relational-schemas ==0.1.8.0
···
   - rosezipper ==0.2
   - rot13 ==0.2.0.1
   - rpmbuild-order ==0.4.5
+  - rpm-nvr ==0.1.0
   - rp-tree ==0.6
   - RSA ==2.4.1
   - runmemo ==1.0.0.1
···
   - sandwich ==0.1.0.8
   - sandwich-quickcheck ==0.1.0.5
   - sandwich-slack ==0.1.0.4
-  - sandwich-webdriver ==0.1.0.5
+  - sandwich-webdriver ==0.1.0.6
   - say ==0.1.0.1
   - sbp ==2.6.3
   - sbv ==8.15
···
   - SHA ==1.6.4.4
   - shake ==0.19.5
   - shake-language-c ==0.12.0
-  - shake-plus ==0.3.3.1
+  - shake-plus ==0.3.4.0
   - shake-plus-extended ==0.4.1.0
   - shakespeare ==2.0.25
   - shared-memory ==0.2.0.0
···
   - squeather ==0.8.0.0
   - srcloc ==0.6
   - stache ==2.3.0
-  - stack ==2.7.1
+  - stack ==2.7.3
   - stackcollapse-ghc ==0.0.1.3
   - stack-templatizer ==0.1.0.2
   - stateref ==0.3
   - StateVar ==1.2.1
-  - static-text ==0.2.0.6
+  - static-text ==0.2.0.7
   - statistics ==0.15.2.0
-  - status-notifier-item ==0.3.0.5
+  - status-notifier-item ==0.3.1.0
   - stb-image-redux ==0.2.1.3
   - step-function ==0.2
   - stm-chans ==3.0.0.4
···
   - th-test-utils ==1.1.0
   - th-utilities ==0.2.4.3
   - thyme ==0.3.5.5
-  - tidal ==1.7.7
+  - tidal ==1.7.8
   - tile ==0.3.0.0
   - time-compat ==1.9.5
   - timeit ==2.0
···
   - unix-bytestring ==0.3.7.3
   - unix-compat ==0.5.3
   - unix-time ==0.4.7
-  - unliftio ==0.2.18
+  - unliftio ==0.2.19
   - unliftio-core ==0.2.0.1
   - unliftio-pool ==0.2.1.1
   - unliftio-streams ==0.1.1.1
···
   - Win32 ==2.6.1.0
   - Win32-notify ==0.3.0.3
   - windns ==0.1.0.1
-  - witch ==0.3.3.0
+  - witch ==0.3.4.0
   - witherable ==0.4.1
   - within ==0.2.0.1
   - with-location ==0.1.0
···
   - yesod-auth-hashdb ==1.7.1.7
   - yesod-auth-oauth2 ==0.6.3.4
   - yesod-bin ==1.6.1
-  - yesod-core ==1.6.20.2
+  - yesod-core ==1.6.21.0
   - yesod-fb ==0.6.1
   - yesod-form ==1.7.0
-  - yesod-gitrev ==0.2.1
+  - yesod-gitrev ==0.2.2
   - yesod-markdown ==0.12.6.11
   - yesod-newsfeed ==1.7.0.0
-  - yesod-page-cursor ==2.0.0.8
+  - yesod-page-cursor ==2.0.0.9
   - yesod-paginator ==1.1.1.0
   - yesod-persistent ==1.6.0.7
   - yesod-sitemap ==1.6.0

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

···
  - keid-geometry
  - keid-render-basic
  - keid-resource-gltf
+ - keid-sound-openal
  - keid-ui-dearimgui
  - kevin
  - keysafe
···
  - polysemy-log-co
  - polysemy-log-di
  - polysemy-methodology
+ - polysemy-methodology-co-log
  - polysemy-methodology-composite
  - polysemy-mocks
  - polysemy-optics
···
  - polysemy-readline
  - polysemy-req
  - polysemy-resume
+ - polysemy-several
  - polysemy-socket
  - polysemy-test
  - polysemy-time

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

···
      }:
      mkDerivation {
        pname = "JuicyPixels-extra";
-       version = "0.5.1";
-       sha256 = "1kgb2l6ymhjr7wq93jpdhxy3k4i7jz0rz256phz10ycdpyvdbjpq";
+       version = "0.5.2";
+       sha256 = "11y4735bbp99wvi4fkpvkda7cj4c6iqp437drs27flicx2ygc687";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [ base JuicyPixels ];
        testHaskellDepends = [ base hspec JuicyPixels ];
···
        description = "an adapter for LogicGrowsOnTrees that uses MPI";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
-     }) {openmpi = null;};
+     }) {inherit (pkgs) openmpi;};
 
   "LogicGrowsOnTrees-network" = callPackage
     ({ mkDerivation, base, cereal, cmdtheline, composition, containers
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "StateVar_1_2_2" = callPackage
+    ({ mkDerivation, base, stm, transformers }:
+     mkDerivation {
+       pname = "StateVar";
+       version = "1.2.2";
+       sha256 = "098q4lk60najzpbfal4bg4sh7izxm840aa5h4ycaamjn77d3jjsy";
+       libraryHaskellDepends = [ base stm transformers ];
+       description = "State variables";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "StateVar-transformer" = callPackage
     ({ mkDerivation, base, mtl, transformers }:
      mkDerivation {
···
     ({ mkDerivation, base, bytestring, transformers, vector, vulkan }:
      mkDerivation {
        pname = "VulkanMemoryAllocator";
-       version = "0.6.0.1";
-       sha256 = "082i8jhx9s977j8dgn6v92h9nzkblcyw820jk87bg14w4lcgi91v";
+       version = "0.7";
+       sha256 = "0f7l91lds878s49yjq210sc49y6c6i3m3hys02902b64dqdgslpa";
        libraryHaskellDepends = [
          base bytestring transformers vector vulkan
        ];
···
     ({ mkDerivation, base, bytestring, Cabal, case-insensitive
      , containers, deepseq, ghc-prim, hashable, hspec, hspec-discover
      , HUnit, integer-gmp, primitive, QuickCheck, quickcheck-instances
-     , scientific, tagged, template-haskell, time, unicode-collation
-     , unordered-containers
+     , random, scientific, tagged, template-haskell, time
+     , unicode-collation, unordered-containers, uuid-types
      }:
      mkDerivation {
        pname = "Z-Data";
-       version = "1.0.0.1";
-       sha256 = "1lhcmcjhr6p3ac50lpmppdvj80vx2wi8xjljd9s9mbiy5kf4pc63";
+       version = "1.1.0.0";
+       sha256 = "0zjgai814a4zbcyjrmfcy1kq97rds0pjsiz8lma1g8c0fhq2gy5c";
        setupHaskellDepends = [ base Cabal ];
        libraryHaskellDepends = [
          base bytestring case-insensitive containers deepseq ghc-prim
-         hashable integer-gmp primitive QuickCheck scientific tagged
+         hashable integer-gmp primitive QuickCheck random scientific tagged
          template-haskell time unicode-collation unordered-containers
+         uuid-types
        ];
        testHaskellDepends = [
          base containers hashable hspec HUnit integer-gmp primitive
···
      }:
      mkDerivation {
        pname = "arch-hs";
-       version = "0.9.0.0";
-       sha256 = "09i5b4pdbc1x7977icq0m7amk59iy0822ki5dlhd7y74m2dmdf9z";
+       version = "0.9.1.0";
+       sha256 = "0k9xi2k4ifrnnh6p80pf1xhf45cbhrs1zdwy0ayp08p0ajdlh74b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {inherit (pkgs) blas; liblapack = null;};
+     }) {inherit (pkgs) blas; inherit (pkgs) liblapack;};
 
   "bindings-libcddb" = callPackage
     ({ mkDerivation, base, bindings-DSL, libcddb }:
···
        pname = "cabal2nix";
        version = "2.17.0";
        sha256 = "0y91agkhgpzzaf9l7l1h7x516iryj8z2vk1in1h7pyjlxaiak6lm";
+       revision = "2";
+       editedCabalFile = "05lb28s4l4c1s6jv1zaqpm9mwx5r4gm113akzq9xr1w5447vw2c3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "capability_0_5_0_0" = callPackage
+    ({ mkDerivation, base, constraints, containers, dlist, exceptions
+     , generic-lens, hspec, lens, monad-control, mtl, mutable-containers
+     , primitive, reflection, safe-exceptions, silently, streaming
+     , temporary, text, transformers, unliftio, unliftio-core
+     }:
+     mkDerivation {
+       pname = "capability";
+       version = "0.5.0.0";
+       sha256 = "116phv80mqs5jd3pv0ar29xfjcg8jf2c77fp530dk0k3da8v5d38";
+       libraryHaskellDepends = [
+         base constraints dlist exceptions generic-lens lens monad-control
+         mtl mutable-containers primitive reflection safe-exceptions
+         streaming transformers unliftio unliftio-core
+       ];
+       testHaskellDepends = [
+         base containers dlist hspec lens mtl silently streaming temporary
+         text unliftio
+       ];
+       description = "Extensional capabilities and deriving combinators";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "capataz" = callPackage
     ({ mkDerivation, async, base, bytestring, pretty-show
      , prettyprinter, rio, tasty, tasty-hunit, tasty-smallcheck
···
      }:
      mkDerivation {
        pname = "clckwrks";
-       version = "0.26.3";
-       sha256 = "119hybfny3sriscgk8zjf56yfc36jxnzydkhb04wxfip9r84mn03";
+       version = "0.26.4";
+       sha256 = "0gvfplid34idkfg5s7dvcwg22ij3fryn82hz958z2960a4jb7ngv";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          acid-state aeson aeson-qq attoparsec base blaze-html bytestring
···
      }:
      mkDerivation {
        pname = "clckwrks-theme-bootstrap";
-       version = "0.4.2.4";
-       sha256 = "0ay3rb6vfzvb43mwhjzgdf3cp7dcya0l9sl7msns0niak4xmnz1l";
+       version = "0.4.3";
+       sha256 = "01hs4rh89zp0y2gkfam27kdwywh5fqr10pzwf1d4c92kpnz9xd5d";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base clckwrks happstack-authenticate hsp hsx-jmacro hsx2hs jmacro
···
      }:
      mkDerivation {
        pname = "compdoc";
-       version = "0.2.0.0";
-       sha256 = "0cdgyvbx2xf7dgvg0h6k980yfh9vj7yg5vsg08i7cb8iik2w0k0m";
+       version = "0.3.0.0";
+       sha256 = "07gbs64r8qsxw4j0mlk7kldbdjjzz4v34pm8b5cj7a6r1l33w7k5";
        libraryHaskellDepends = [
          aeson base composite-aeson composite-aeson-throw composite-base
          pandoc pandoc-throw path rio vinyl
···
      }:
      mkDerivation {
        pname = "compdoc-dhall-decoder";
-       version = "0.2.0.0";
-       sha256 = "0iygbgcqcs3ixdnphhrp57s1ihpwnf9q59z7r74qqj7qx1yjrxig";
-       revision = "1";
-       editedCabalFile = "1g15qxkxfipvf6al3k8bdcvvcl1vyhjhg3r1w2z2g91ngz0b5y18";
+       version = "0.3.0.0";
+       sha256 = "0qsq67zj8gr9xlgcbxgn5fi1cyv4qf7w5vzfl3v4hvil7xf3fn77";
        libraryHaskellDepends = [
          base compdoc composite-aeson composite-base dhall either pandoc
          text
···
        libraryHaskellDepends = [ base binary composite-base ];
        description = "Orphan binary instances";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "composite-dhall" = callPackage
+    ({ mkDerivation, base, composite-base, dhall, lens, text }:
+     mkDerivation {
+       pname = "composite-dhall";
+       version = "0.0.1.0";
+       sha256 = "1hhy3incp4j8n0c8jyk12qi9zgxmwqpvb08zhc8rql855g88rpfq";
+       revision = "2";
+       editedCabalFile = "16ki1iii379yn1qwxs76qfjm4wvkysdm15b60m24v1gz1vkxidhi";
+       libraryHaskellDepends = [ base composite-base dhall lens text ];
+       description = "Dhall instances for composite records";
+       license = lib.licenses.mit;
      }) {};
 
   "composite-ekg" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "contravariant_1_5_4" = callPackage
+    ({ mkDerivation, base, StateVar, transformers }:
+     mkDerivation {
+       pname = "contravariant";
+       version = "1.5.4";
+       sha256 = "19bwqkxvpgdfvjamk0g8wk1q4rfvbhxain6lx78ldhjmc7m5v9ql";
+       libraryHaskellDepends = [ base StateVar transformers ];
+       description = "Contravariant functors";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "contravariant-extras" = callPackage
     ({ mkDerivation, base, contravariant, template-haskell
      , template-haskell-compat-v0208
···
        license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {python3 = null;};
+     }) {inherit (pkgs) python3;};
 
   "cql" = callPackage
     ({ mkDerivation, base, bytestring, cereal, containers, Decimal
···
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
+  "distribution-nixpkgs_1_6_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
+     , deepseq, hspec, language-nix, lens, pretty, process, split
+     }:
+     mkDerivation {
+       pname = "distribution-nixpkgs";
+       version = "1.6.0";
+       sha256 = "0m1kw3wy0n611487qhskldivrxmkh7m5bkzib44d8n0qfg5lv06i";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson base bytestring Cabal containers deepseq language-nix lens
+         pretty process split
+       ];
+       testHaskellDepends = [ base deepseq hspec lens ];
+       description = "Types and functions to manipulate the Nixpkgs distribution";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ peti ];
+     }) {};
+
   "distribution-opensuse" = callPackage
     ({ mkDerivation, aeson, base, binary, bytestring, containers
      , deepseq, Diff, extra, foldl, hashable, hsemail, mtl, parsec-class
···
     ({ mkDerivation, base, base16-bytestring, bytestring
      , case-insensitive, conduit, conduit-extra, config-ini, containers
      , cryptonite, exceptions, extra, filepath, generic-lens, hspec
-     , http-client-tls, http-conduit, http-types, memory, microlens
-     , mime-types, mtl, resourcet, text, time, transformers, xml-conduit
+     , http-api-data, http-client-tls, http-conduit, http-types, memory
+     , microlens, mime-types, mtl, resourcet, text, time, transformers
+     , unliftio, xml-conduit
      }:
      mkDerivation {
        pname = "do-spaces";
-       version = "0.1.0";
-       sha256 = "1xj0n2pmmwkm4ss5gvsbvw8m545w4890a3hhk1ns1vbbm06zmvsi";
+       version = "0.2";
+       sha256 = "0nl3gj7jfamm4j8z16jxxl6xq3507p091zsvsa0gxmqiwkjqfc65";
        libraryHaskellDepends = [
          base base16-bytestring bytestring case-insensitive conduit
          conduit-extra config-ini containers cryptonite exceptions extra
-         filepath generic-lens http-client-tls http-conduit http-types
-         memory microlens mime-types mtl text time transformers xml-conduit
+         filepath generic-lens http-api-data http-client-tls http-conduit
+         http-types memory microlens mime-types mtl text time transformers
+         unliftio xml-conduit
        ];
        testHaskellDepends = [
          base bytestring case-insensitive conduit conduit-extra containers
···
      }:
      mkDerivation {
        pname = "dynamic-pipeline";
-       version = "0.3.1.2";
-       sha256 = "02dnji253nvszgma7yzn7ghkz7gy4a24qa54l0pbm3mnf9xmwn31";
+       version = "0.3.1.3";
+       sha256 = "01f98acd9hkqi5jbgm7zb69ci6gsf8rwlwddw6g5id2kvim557n8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Safe helpers for accessing and modifying environment variables";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "env-locale" = callPackage
···
      }:
      mkDerivation {
        pname = "ghc-prof";
-       version = "1.4.1.8";
-       sha256 = "02k6il0a6cdr5dvf5x6gpjyn9vzn43kahqdsq5lzjvw5c6l0462p";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         attoparsec base containers scientific text time
-       ];
-       testHaskellDepends = [
-         attoparsec base containers directory filepath process tasty
-         tasty-hunit temporary text
-       ];
-       description = "Library for parsing GHC time and allocation profiling reports";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "ghc-prof_1_4_1_9" = callPackage
-    ({ mkDerivation, attoparsec, base, containers, directory, filepath
-     , process, scientific, tasty, tasty-hunit, temporary, text, time
-     }:
-     mkDerivation {
-       pname = "ghc-prof";
        version = "1.4.1.9";
        sha256 = "1m7pwrwf45hc8nscl9kzzw9n0blnfpx7dl38kv8hvshaqbbg0v4q";
        isLibrary = true;
···
        ];
        description = "Library for parsing GHC time and allocation profiling reports";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ghc-prof-aeson" = callPackage
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "ghc-tcplugin-api" = callPackage
+    ({ mkDerivation, base, ghc, transformers }:
+     mkDerivation {
+       pname = "ghc-tcplugin-api";
+       version = "0.2.0.0";
+       sha256 = "0x58s2ip5p59vpx1x6lwdq46vxjfx6b28yzxjpd9pb148x787yfd";
+       libraryHaskellDepends = [ base ghc transformers ];
+       description = "An API for type-checker plugins";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "ghc-tcplugins-extra_0_3_2" = callPackage
     ({ mkDerivation, base, ghc }:
      mkDerivation {
···
        license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {gtk-mac-integration-gtk3 = null;};
+     }) {inherit (pkgs) gtk-mac-integration-gtk3;};
 
   "gi-gtksheet" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, gi-atk
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "gitlab-haskell_0_3_0_1" = callPackage
+  "gitlab-haskell_0_3_0_2" = callPackage
     ({ mkDerivation, aeson, base, bytestring, connection, http-client
      , http-conduit, http-types, tasty, tasty-hunit, temporary, text
      , time, transformers, unix, unliftio, unliftio-core
      }:
      mkDerivation {
        pname = "gitlab-haskell";
-       version = "0.3.0.1";
-       sha256 = "103wkbfnx8n5klaacqfl4vyg6rwszac04rpg7p7hka1m7jsrikwf";
+       version = "0.3.0.2";
+       sha256 = "0ndwff0rk1b7vkggymb0ca0h0hg69kym7npcckv2x2pnw55lb5yz";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring connection http-client http-conduit
···
      }:
      mkDerivation {
        pname = "gloss-export";
-       version = "0.1.0.3";
-       sha256 = "1m1fxv516kfqx4y684xcd1x0vvzirgv1acawiam5nm26hqvxcf85";
+       version = "0.1.0.4";
+       sha256 = "1mllkmb11cqgaw183jjxmivs8h1n8vbr31bqlw94v4vjm4r4ljzl";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "gtk-sni-tray";
-       version = "0.1.6.2";
-       sha256 = "1rcw57d5f0298y40ajmb2664ryrqsmcwbr2y1pk0sl2ggwr1zzsl";
+       version = "0.1.8.0";
+       sha256 = "0b8b8hvsv60zvnjidqm1qchxdgqdf5gcmm5pz8fvrvcjqq27b1xa";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {gtk-mac-integration-gtk3 = null;};
+     }) {inherit (pkgs) gtk-mac-integration-gtk3;};
 
   "gtkglext" = callPackage
     ({ mkDerivation, base, Cabal, glib, gtk, gtk2, gtk2hs-buildtools
···
        license = "GPL";
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {inherit (pkgs) blas; liblapack = null;};
+     }) {inherit (pkgs) blas; inherit (pkgs) liblapack;};
 
   "hXmixer" = callPackage
     ({ mkDerivation, base, directory, gtk3, process, split, text }:
···
        broken = true;
      }) {};
 
-  "hackage-db_2_1_0" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
-     , directory, exceptions, filepath, tar, time, utf8-string
-     }:
-     mkDerivation {
-       pname = "hackage-db";
-       version = "2.1.0";
-       sha256 = "1vsc0lrbrb525frycqq0c5z846whymgcjl888gnlqd16nknbsn3l";
-       revision = "1";
-       editedCabalFile = "1h3x5a8xmqkkcd3h1m7z0il1vbsh2c77685y68zmyp21zb1y88hy";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson base bytestring Cabal containers directory exceptions
-         filepath tar time utf8-string
-       ];
-       description = "Access cabal-install's Hackage database via Data.Map";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       maintainers = with lib.maintainers; [ peti ];
-     }) {};
-
   "hackage-db" = callPackage
     ({ mkDerivation, aeson, base, bytestring, Cabal, containers
      , directory, exceptions, filepath, tar, time, utf8-string
      }:
      mkDerivation {
        pname = "hackage-db";
-       version = "2.1.1";
-       sha256 = "16y1iqb3y019hjdsq7q3zx51qy834ky3mw5vszqmzzhflqpicd31";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson base bytestring Cabal containers directory exceptions
-         filepath tar time utf8-string
-       ];
-       description = "Access cabal-install's Hackage database via Data.Map";
-       license = lib.licenses.bsd3;
-       maintainers = with lib.maintainers; [ peti ];
-     }) {};
-
-  "hackage-db_2_1_2" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
-     , directory, exceptions, filepath, tar, time, utf8-string
-     }:
-     mkDerivation {
-       pname = "hackage-db";
        version = "2.1.2";
        sha256 = "1aj82n2ay16zman829gq7s9dkg3qyyavca8hhjfibx8hzg6pmnap";
        isLibrary = true;
···
        ];
        description = "Access cabal-install's Hackage database via Data.Map";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {open-pal = null; open-rte = null; openmpi = null;};
+     }) {open-pal = null; open-rte = null; inherit (pkgs) openmpi;};
 
   "haskell-names" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers
···
   "hasklepias" = callPackage
     ({ mkDerivation, aeson, base, bytestring, cmdargs, co-log
      , containers, flow, ghc-prim, hspec, interval-algebra, lens
-     , lens-aeson, mtl, process, QuickCheck, safe, tasty, tasty-hspec
-     , tasty-hunit, text, time, unordered-containers, vector, witherable
+     , lens-aeson, mtl, nonempty-containers, process, QuickCheck, safe
+     , semiring-simple, tasty, tasty-hspec, tasty-hunit, text, time
+     , unordered-containers, vector, witherable
      }:
      mkDerivation {
        pname = "hasklepias";
-       version = "0.12.0";
-       sha256 = "0zjlzd6c5plyi803vpx0f4js9b2zys8pd6ikbdya2ifmgxfwj2zh";
+       version = "0.13.1";
+       sha256 = "1fhlw490bwyblsgjrzgms4lzkv0zd8bhsvl2ywlpz0flhdd999zr";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson base bytestring cmdargs co-log containers flow ghc-prim
-         interval-algebra lens lens-aeson mtl process QuickCheck safe tasty
-         tasty-hunit text time unordered-containers vector witherable
+         interval-algebra lens lens-aeson mtl nonempty-containers process
+         QuickCheck safe semiring-simple tasty tasty-hunit text time
+         unordered-containers vector witherable
        ];
        testHaskellDepends = [
          aeson base bytestring containers flow hspec interval-algebra lens
···
      }:
      mkDerivation {
        pname = "haskoin-store";
-       version = "0.53.6";
-       sha256 = "04f9aybim3nv5xhlcawcm9jgbf4ql8v3lqgw8yvk5snrzy30yf1f";
+       version = "0.53.8";
+       sha256 = "1djlq58v6wm3kr8jsvr612qxaxz1k03mfxvywd6ia45f761ry1ks";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "haskoin-store-data";
-       version = "0.53.7";
-       sha256 = "150nprl5i8v5api6h7svdwdskzjiy7ljrwmz3zfil1h05b2qz3l6";
+       version = "0.53.8";
+       sha256 = "06q9h1n9c8gz6fycc8nsjxp98c98zin1f7y7qiyy80cddhcj1jzf";
        libraryHaskellDepends = [
          aeson base binary bytes bytestring cereal containers data-default
          deepseq hashable haskoin-core http-client http-types lens mtl
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {inherit (pkgs) blas; liblapack = null;};
+     }) {inherit (pkgs) blas; inherit (pkgs) liblapack;};
 
   "hblock" = callPackage
     ({ mkDerivation, aeson, base, blaze-markup, bytestring, cereal
···
      , case-insensitive, conduit, conduit-extra, config-ini, containers
      , exceptions, filepath, generic-lens, hashable, hspec
      , http-api-data, http-client, http-client-tls, http-conduit
-     , http-types, microlens, mtl, random, scientific, split, text, time
-     , unliftio, unordered-containers, uri-bytestring
+     , http-types, microlens, microlens-ghc, mtl, random, scientific
+     , split, text, time, unliftio, unordered-containers, uri-bytestring
      }:
      mkDerivation {
        pname = "heddit";
-       version = "0.0.3";
-       sha256 = "04kdhsxlna5l6h6wxyvxacxvmklhv19h5r802qac34gkpfvld851";
+       version = "0.2";
+       sha256 = "1hxshqw9s40yzpk0j4byqyvb3cqnfw2l3b2s4azbng77prvnmmd7";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
          aeson aeson-casing base bytestring case-insensitive conduit
          conduit-extra config-ini containers exceptions filepath
          generic-lens hashable http-api-data http-client http-client-tls
-         http-conduit http-types microlens mtl random scientific split text
-         time unliftio unordered-containers uri-bytestring
+         http-conduit http-types microlens microlens-ghc mtl random
+         scientific split text time unliftio unordered-containers
+         uri-bytestring
        ];
        testHaskellDepends = [
          aeson base bytestring containers generic-lens hspec microlens
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-       sha256 = "0nii20qc7w0m2kjbbhg91iad497hlrd35l29xri0lrjmk9s1hsnw";
+     }) {inherit (pkgs) liblapack;};
 
        sha256 = "0nii20qc7w0m2kjbbhg91iad497hlrd35l29xri0lrjmk9s1hsnw";
        sha256 = "0nii20qc7w0m2kjbbhg91iad497hlrd35l29xri0lrjmk9s1hsnw";
···
        sha256 = "0nii20qc7w0m2kjbbhg91iad497hlrd35l29xri0lrjmk9s1hsnw";
        sha256 = "0nii20qc7w0m2kjbbhg91iad497hlrd35l29xri0lrjmk9s1hsnw";
        license = lib.licenses.bsd3;
-     }) {inherit (pkgs) blas; liblapack = null;};
+     }) {inherit (pkgs) blas; inherit (pkgs) liblapack;};
 
        sha256 = "0nii20qc7w0m2kjbbhg91iad497hlrd35l29xri0lrjmk9s1hsnw";
     ({ mkDerivation, base, hmatrix }:
···
        broken = true;
      }) {};
 
+  "hs-term-emulator" = callPackage
+    ({ mkDerivation, ansi-terminal, attoparsec, base, bytestring
+     , containers, criterion, hspec, hspec-discover, lens, text, vector
+     }:
+     mkDerivation {
+       pname = "hs-term-emulator";
+       version = "0.1.0.0";
+       sha256 = "03aidqaw9pmwggd1w8ir6qhb08hlhv0q5gnl0hqa5zjj86dd0rp2";
+       libraryHaskellDepends = [
+         ansi-terminal attoparsec base bytestring containers lens text
+         vector
+       ];
+       testHaskellDepends = [
+         ansi-terminal attoparsec base hspec text vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [ base criterion ];
+       description = "Terminal Emulator written in 100% Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "hs-twitter" = callPackage
     ({ mkDerivation, base, HTTP, json, mime, network, old-locale
      , old-time, random, utf8-string
···
        libraryPkgconfigDepends = [ gsl ];
        description = "Signal processing and EEG data analysis";
        license = lib.licenses.bsd3;
-     }) {inherit (pkgs) blas; inherit (pkgs) gsl; liblapack = null;};
+     }) {inherit (pkgs) blas; inherit (pkgs) gsl; 
+         inherit (pkgs) liblapack;};
 
   "hsilop" = callPackage
     ({ mkDerivation, base, directory, filepath, haskeline, xdg-basedir
···
      }:
      mkDerivation {
        pname = "hurl";
-       version = "2.1.0.1";
-       sha256 = "16j7kxxp60i0nbiscc1x5a14s7n8qyv8rzjm6a03pqdpbmfzrrwq";
+       version = "2.1.1.0";
+       sha256 = "0hlkqgbk8siycz055lqn01qgn8npgqyq59br2yvpbk4rz7jzjmfa";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "input-parsers";
-       version = "0.2.2";
-       sha256 = "1kb70nxg8bji7bd0y0w81bqyhx62xrbv3y2vib6sp3jkz7yriarz";
-       libraryHaskellDepends = [
-         attoparsec base binary bytestring monoid-subclasses parsec parsers
-         text transformers
-       ];
-       description = "Extension of the parsers library with more capability and efficiency";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "input-parsers_0_2_3" = callPackage
-    ({ mkDerivation, attoparsec, base, binary, bytestring
-     , monoid-subclasses, parsec, parsers, text, transformers
-     }:
-     mkDerivation {
-       pname = "input-parsers";
        version = "0.2.3";
        sha256 = "1ck2y3bl60bgzqg43kfcff1y84qygmanay1x8cjlxam60mip1w7v";
        libraryHaskellDepends = [
···
        ];
        description = "Extension of the parsers library with more capability and efficiency";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "inquire" = callPackage
···
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {python = null;};
+     }) {inherit (pkgs) python;};
 
   "json-qq" = callPackage
     ({ mkDerivation, base, haskell-src-meta, parsec, template-haskell
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "keid-sound-openal" = callPackage
+    ({ mkDerivation, base, geomancy, keid-core, OpenAL, opusfile
+     , resourcet, rio, unliftio
+     }:
+     mkDerivation {
+       pname = "keid-sound-openal";
+       version = "0.1.0.0";
+       sha256 = "17ml9xh8qrvyrcsi1ai6br286bf9c6j29wbmp5sp65spp2kwlyng";
+       libraryHaskellDepends = [
+         base geomancy keid-core OpenAL opusfile resourcet rio unliftio
+       ];
+       description = "OpenAL sound system for Keid engine";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "keid-ui-dearimgui" = callPackage
     ({ mkDerivation, base, binary, bytestring, cryptohash-md5
      , dear-imgui, derive-storable, derive-storable-plugin, foldl
···
   "krank" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, hspec
      , hspec-expectations, http-client, http-types, lifted-async, mtl
-     , optparse-applicative, pcre-heavy, pretty-terminal, PyF, req
-     , safe-exceptions, text, unordered-containers
-     }:
-     mkDerivation {
-       pname = "krank";
-       version = "0.2.2";
-       sha256 = "10w6vbpcn9n07s99w02izg7nfizpbq5m5mg6zv46f1llm35jpv6w";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson base bytestring containers http-client http-types
-         lifted-async mtl pcre-heavy pretty-terminal PyF req safe-exceptions
-         text unordered-containers
-       ];
-       executableHaskellDepends = [
-         base containers mtl optparse-applicative pcre-heavy pretty-terminal
-         PyF text
-       ];
-       testHaskellDepends = [
-         aeson base bytestring containers hspec hspec-expectations
-         http-client http-types lifted-async mtl pcre-heavy pretty-terminal
-         PyF req safe-exceptions text unordered-containers
-       ];
-       description = "Krank checks your code source comments for important markers";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "krank_0_2_3" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, hspec
-     , hspec-expectations, http-client, http-types, lifted-async, mtl
      , optparse-applicative, pcre-heavy, pretty-terminal, process, PyF
      , req, safe-exceptions, text, unordered-containers
      }:
···
        ];
        description = "Krank checks issue tracker link status in your source code";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "krapsh" = callPackage
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-       sha256 = "0nii20qc7w0m2kjbbhg91iad497hlrd35l29xri0lrjmk9s1hsnw";
+     }) {inherit (pkgs) liblapack;};
 
   "lapack-ffi-tools" = callPackage
     ({ mkDerivation, base, bytestring, cassava, containers
···
      }:
      mkDerivation {
        pname = "lifted-async";
-       version = "0.10.2";
-       sha256 = "0alhvrvxp4f4srllyq5br3waiba4c93cc4nxm7jd23440swr6a31";
+       version = "0.10.2.1";
+       sha256 = "0j4f5471qfxkxy84ri87bcvp30ikh4m30imcggwn8m5v8igp218d";
        libraryHaskellDepends = [
          async base constraints lifted-base monad-control transformers-base
        ];
···
      }:
      mkDerivation {
        pname = "monoid-subclasses";
-       version = "1.1";
-       sha256 = "1bv0ripdw53121aj39zalczkfwrajpzzd1i99jn49sr4bfwgy3p4";
-       libraryHaskellDepends = [
-         base bytestring containers primes text vector
-       ];
-       testHaskellDepends = [
-         base bytestring containers primes QuickCheck quickcheck-instances
-         tasty tasty-quickcheck text vector
-       ];
-       description = "Subclasses of Monoid";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "monoid-subclasses_1_1_1" = callPackage
-    ({ mkDerivation, base, bytestring, containers, primes, QuickCheck
-     , quickcheck-instances, tasty, tasty-quickcheck, text, vector
-     }:
-     mkDerivation {
-       pname = "monoid-subclasses";
        version = "1.1.1";
        sha256 = "13nc9qcwz10y1gxdp277gqq675pbcxav35fwqnbyrvz9hx1m545x";
        libraryHaskellDepends = [
···
        ];
        description = "Subclasses of Monoid";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "monoid-transformer" = callPackage
···
      }:
      mkDerivation {
        pname = "nri-prelude";
-       version = "0.6.0.2";
-       sha256 = "002bq6qwaiw4v30b677hg8pv2sa9iaqdv90h02fbq4pkhqsqhpkw";
-       libraryHaskellDepends = [
-         aeson aeson-pretty async auto-update base bytestring containers
-         directory exceptions filepath ghc hedgehog junit-xml pretty-diff
-         pretty-show safe-coloured-text safe-coloured-text-terminfo
-         safe-exceptions terminal-size text time vector
-       ];
-       testHaskellDepends = [
-         aeson aeson-pretty async auto-update base bytestring containers
-         directory exceptions filepath ghc hedgehog junit-xml pretty-diff
-         pretty-show safe-coloured-text safe-coloured-text-terminfo
-         safe-exceptions terminal-size text time vector
-       ];
-       description = "A Prelude inspired by the Elm programming language";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "nri-prelude_0_6_0_3" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, async, auto-update, base
-     , bytestring, containers, directory, exceptions, filepath, ghc
-     , hedgehog, junit-xml, pretty-diff, pretty-show, safe-coloured-text
-     , safe-coloured-text-terminfo, safe-exceptions, terminal-size, text
-     , time, vector
-     }:
-     mkDerivation {
-       pname = "nri-prelude";
        version = "0.6.0.3";
        sha256 = "1xv1khi5pv84haasrf24lyyi41zc5biyqlgahzlg4n3mci2zz9ik";
        libraryHaskellDepends = [
···
        ];
        description = "A Prelude inspired by the Elm programming language";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "nri-redis" = callPackage
···
        platforms = [
          "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
        ];
-     }) {pam = null;};
+     }) {inherit (pkgs) pam;};
 
   "pan-os-syslog" = callPackage
     ({ mkDerivation, base, byteslice, bytesmith, chronos, gauge, ip
···
     ({ mkDerivation }:
      mkDerivation {
        pname = "pandora";
-       version = "0.4.3";
-       sha256 = "1z40rjmcbs7d0f9aksgdm2w4l3jyglgm5iap4z110mfkmrvwrlfx";
+       version = "0.4.4";
+       sha256 = "17kwyqwywnj694b30bs3da4pns73jp7pr2jxpc7zy261gmfqvpyz";
        description = "A box of patterns and paradigms";
        license = lib.licenses.mit;
      }) {};
···
      }:
      mkDerivation {
        pname = "parsley-core";
-       version = "1.3.0.0";
-       sha256 = "0qx5q7a9hkj9swpwlxh24c19pf9i6yvlmp44xiwshflz4cf1n8dq";
-       revision = "1";
-       editedCabalFile = "03a4l7ai39kii4qdxv78wgknj3iz2n2g2055rk3mi0wsiy280jfg";
+       version = "1.4.0.0";
+       sha256 = "1w9pilgaajaycxr0nvjwdzk5fjf7pg4spnwh2197gbpqhbkj75q3";
        libraryHaskellDepends = [
          array base bytestring containers dependent-map dependent-sum
          ghc-prim hashable mtl pretty-terminal template-haskell text
···
      }:
      mkDerivation {
        pname = "persistent-documentation";
-       version = "0.1.0.3";
-       sha256 = "03p3ppjrn9j76bwgq7n921c2h0xkzsf9ish6nx6bhxdggyq3bfwy";
+       version = "0.1.0.4";
+       sha256 = "0ib56hz4q83knw6lqdbfcflnpwd0x8381p67yibmnbyn9p5b6r1q";
        libraryHaskellDepends = [
          base containers mtl persistent template-haskell text
        ];
···
 
   "phonetic-languages-phonetics-basics" = callPackage
     ({ mkDerivation, base, foldable-ix, lists-flines, mmsyn2-array
-     , mmsyn5
+     , mmsyn3, mmsyn5
      }:
      mkDerivation {
        pname = "phonetic-languages-phonetics-basics";
-       version = "0.7.0.0";
-       sha256 = "16a8b5xpdrayfh03czs0nb1xz6kn95rr4k4dim5viqjxpc9f0zbn";
+       version = "0.8.1.0";
+       sha256 = "1y67w8ywcmv8d86b52vhiqxsgk31pglf8hcjnmml2q5kh8cpjwmp";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base foldable-ix lists-flines mmsyn2-array mmsyn5
+         base foldable-ix lists-flines mmsyn2-array mmsyn3 mmsyn5
        ];
        executableHaskellDepends = [
-         base foldable-ix lists-flines mmsyn2-array mmsyn5
+         base foldable-ix lists-flines mmsyn2-array mmsyn3 mmsyn5
        ];
        description = "A library for working with generalized phonetic languages usage";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-examples-array";
-       version = "0.5.0.0";
-       sha256 = "0p7zsk9d6p4srjr0vk18r454p72v49kjpdh7hk3iwh9vh9mbjrbx";
+       version = "0.5.0.1";
+       sha256 = "0wrh3bmwa6l5vfjv481wvnqqd82xgm27vcbm9xg1nm7psihj6gqj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-generalized-examples-array";
-       version = "0.4.2.1";
-       sha256 = "1h95v0vspx9dziqnki4553b7sblpq33l9h3a86xwim0rv7mpqsjs";
+       version = "0.5.0.1";
+       sha256 = "0gif3xwcbc5v4qjyhn1qwyj36jkqj7rdrq35fzxsr7xbmjcw13h2";
        libraryHaskellDepends = [
          base heaps mmsyn2-array mmsyn3 parallel
          phonetic-languages-constraints-array
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-generalized-properties-array";
-       version = "0.2.0.0";
-       sha256 = "1k1id4dz0siz3qqax738k4k2dfj68slph4yy8ad6f4r9fink9jqr";
+       version = "0.3.0.0";
+       sha256 = "192i7dr6kpzrclvym1y1j3zgabcx3fldaan07rgxhhys3k7gbqxa";
        libraryHaskellDepends = [
          base phonetic-languages-phonetics-basics
          phonetic-languages-rhythmicity phonetic-languages-simplified-base
···
     ({ mkDerivation, base, mmsyn2-array, mmsyn5 }:
      mkDerivation {
        pname = "phonetic-languages-ukrainian-array";
-       version = "0.1.0.0";
-       sha256 = "0h88qcdkckgn5cjyjiwvdxci8p04h12xr6jj5pjp4wzqyp6a5wcf";
+       version = "0.2.1.0";
+       sha256 = "17gyg64hwk5cj9drpdsadyn3l94g2n6m859ghfplr665id2pgzlg";
        libraryHaskellDepends = [ base mmsyn2-array mmsyn5 ];
        description = "Prepares Ukrainian text to be used as a phonetic language text";
        license = lib.licenses.mit;
···
        broken = true;
      }) {};
 
+  "polynomial-algebra" = callPackage
+    ({ mkDerivation, array, base, compact-word-vectors, containers }:
+     mkDerivation {
+       pname = "polynomial-algebra";
+       version = "0.1";
+       sha256 = "03133j7hknn0d6b6lvq0q05zy6m92lx5wh68chimgm45xh2p8y0a";
+       libraryHaskellDepends = [
+         array base compact-word-vectors containers
+       ];
+       description = "Multivariate polynomial rings";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "polynomials-bernstein" = callPackage
     ({ mkDerivation, base, vector }:
      mkDerivation {
···
      }) {};
 
   "polysemy-methodology" = callPackage
-    ({ mkDerivation, base, co-log-polysemy, polysemy, polysemy-plugin
-     , polysemy-zoo
+    ({ mkDerivation, base, polysemy, polysemy-kvstore, polysemy-plugin
+     , polysemy-several
      }:
      mkDerivation {
        pname = "polysemy-methodology";
-       version = "0.1.8.0";
-       sha256 = "0p4h6vjrq6g6pd27mqpzp33jg84gfi3wpymjkbxfrwz7ky74jag5";
+       version = "0.2.0.0";
+       sha256 = "0cfd0xqcx8b5zrl5my03zx1h1mxqkdyrhn1nba453mk3lnvynwmw";
        libraryHaskellDepends = [
-         base co-log-polysemy polysemy polysemy-plugin polysemy-zoo
+         base polysemy polysemy-kvstore polysemy-plugin polysemy-several
        ];
        description = "Domain modelling algebra for polysemy";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "polysemy-methodology-co-log" = callPackage
+    ({ mkDerivation, base, co-log-polysemy, polysemy
+     , polysemy-methodology, polysemy-plugin
+     }:
+     mkDerivation {
+       pname = "polysemy-methodology-co-log";
+       version = "0.1.0.0";
+       sha256 = "1pvvb83lkpxqni6055y3s0ckjg50nd1jfivq1c8701zjv31ylbpa";
+       libraryHaskellDepends = [
+         base co-log-polysemy polysemy polysemy-methodology polysemy-plugin
+       ];
+       description = "Logging functions for polysemy-methodology";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
      }) {};
···
      }) {};
 
   "polysemy-path" = callPackage
-    ({ mkDerivation, base, path, polysemy, polysemy-extra
-     , polysemy-plugin
-     }:
+    ({ mkDerivation, base, path, polysemy, polysemy-extra }:
      mkDerivation {
        pname = "polysemy-path";
-       version = "0.2.0.0";
-       sha256 = "0p5ylp8758zkhlgqrhq6v6fli03q9gmak7bzkw1czrxwdshkv0gi";
-       libraryHaskellDepends = [
-         base path polysemy polysemy-extra polysemy-plugin
-       ];
+       version = "0.2.1.0";
+       sha256 = "0smaai432vpqci9w7pyg443kcd1rpz7zpwww2wcxbyqszzllbhnr";
+       libraryHaskellDepends = [ base path polysemy polysemy-extra ];
        description = "Polysemy versions of Path functions";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "polysemy-several" = callPackage
+    ({ mkDerivation, base, polysemy }:
+     mkDerivation {
+       pname = "polysemy-several";
+       version = "0.1.0.0";
+       sha256 = "1mw6a6fz3879yqnpq6h0221i8b8f05j90b1zydhzr57nsbklxzps";
+       libraryHaskellDepends = [ base polysemy ];
+       description = "Run several effects at once, taken from the polysemy-zoo";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "polysemy-socket" = callPackage
     ({ mkDerivation, base, bytestring, polysemy, polysemy-plugin
      , socket
···
        pname = "polysemy-uncontrolled";
        version = "0.1.0.0";
        sha256 = "137zw5366c4h7q8w7cj7h4wc4njf1n2f7kabyrl6bqav1fjb96lx";
+       revision = "1";
+       editedCabalFile = "1wadnvrazf6z10k5s86749zadymmw2j45amak286706qfh4zwjd1";
        libraryHaskellDepends = [
          base polysemy polysemy-methodology polysemy-plugin
        ];
···
      }) {};
 
   "polysemy-vinyl" = callPackage
-    ({ mkDerivation, base, polysemy, polysemy-extra, vinyl }:
+    ({ mkDerivation, base, polysemy, polysemy-extra, polysemy-several
+     , vinyl
+     }:
      mkDerivation {
        pname = "polysemy-vinyl";
-       version = "0.1.4.0";
-       sha256 = "1545a125bfgi5314dxhak5dnx9h5kwanzgbp1f88f96hlxik1rjh";
-       libraryHaskellDepends = [ base polysemy polysemy-extra vinyl ];
+       version = "0.1.5.0";
+       sha256 = "06y91nv2fcis058gqv5hlpl5a6kmia5r9sc6npp6102lc19vkkc4";
+       libraryHaskellDepends = [
+         base polysemy polysemy-extra polysemy-several vinyl
+       ];
        description = "Functions for mapping vinyl records in polysemy";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
···
        license = lib.licenses.mit;
      }) {};
 
-  "process_1_6_12_0" = callPackage
+  "process_1_6_13_1" = callPackage
     ({ mkDerivation, base, bytestring, deepseq, directory, filepath
      , unix
      }:
      mkDerivation {
        pname = "process";
-       version = "1.6.12.0";
-       sha256 = "1zw551zrnq70ip9dsc564aw1zf90l48jf59rxhjgx4d00ngs165x";
+       version = "1.6.13.1";
+       sha256 = "1fkaapar94w5prsvdpyybqb0j4hyjhf68czdlr5psb42i314lnj7";
        libraryHaskellDepends = [ base deepseq directory filepath unix ];
        testHaskellDepends = [ base bytestring directory ];
        description = "Process libraries";
···
      }) {};
 
   "procex" = callPackage
-    ({ mkDerivation, async, base, bytestring, containers, unix
-     , utf8-string
+    ({ mkDerivation, async, base, bytestring, containers, deepseq
+     , hspec, unix, utf8-string
      }:
      mkDerivation {
        pname = "procex";
-       version = "0.1.0.0";
-       sha256 = "08pd4v8jxhfy6i9vry0hlssqhlzx1wmi64kmhb0qwxagrj3r6dsx";
+       version = "0.2.2";
+       sha256 = "0gnrpk3n8127wc92m3qrq0hka6p56pxjrmgafxgb0w03mlvwc89q";
        libraryHaskellDepends = [
-         async base bytestring containers unix utf8-string
+         async base bytestring containers deepseq unix utf8-string
        ];
-       testHaskellDepends = [ base ];
+       testHaskellDepends = [ async base bytestring hspec unix ];
        description = "Ergonomic process launching with extreme flexibility and speed";
        license = lib.licenses.asl20;
        hydraPlatforms = lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "protobuf-simple";
-       version = "0.1.1.0";
-       sha256 = "1i6dmf9nppjk2xd2s91bmbnb9r915h5ypq5923jpralry2ax6ach";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base binary bytestring containers data-binary-ieee754 mtl text
-       ];
-       executableHaskellDepends = [
-         base containers directory filepath mtl parsec split text
-       ];
-       testHaskellDepends = [
-         base binary bytestring containers data-binary-ieee754 filepath
-         hspec parsec QuickCheck quickcheck-instances split text
-       ];
-       description = "Simple Protocol Buffers library (proto2)";
-       license = lib.licenses.mit;
-     }) {};
-
-  "protobuf-simple_0_1_1_1" = callPackage
-    ({ mkDerivation, base, binary, bytestring, containers
-     , data-binary-ieee754, directory, filepath, hspec, mtl, parsec
-     , QuickCheck, quickcheck-instances, split, text
-     }:
-     mkDerivation {
-       pname = "protobuf-simple";
        version = "0.1.1.1";
        sha256 = "1j4grl8dvzhrj88q2ig6slsdj60lcw29r1ls123zk66fgj19f8l6";
        isLibrary = true;
···
        ];
        description = "Simple Protocol Buffers library (proto2)";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "protocol" = callPackage
···
      }:
      mkDerivation {
        pname = "provenience";
-       version = "0.1.2.1";
-       sha256 = "15ghl4zdf4hz27kkfky4m405abmarzr8j7fqi07ax7mswwwha9f1";
+       version = "0.1.2.2";
+       sha256 = "1glilqib6bs1kbb0yyrzqxbsijrcrdm9q3cgmymgacc7kllc616n";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {python = null;};
+     }) {inherit (pkgs) python;};
 
   "pyfi" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, pureMD5
···
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {python = null;};
+     }) {inherit (pkgs) python;};
 
   "python-pickle" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, cereal, cmdargs
···
      }:
      mkDerivation {
        pname = "rank2classes";
-       version = "1.4.1";
-       sha256 = "1cmc7xqnvjdvzgfyz7i3nmnhdm92rwfc9bqlpjcirmnkn47va4kb";
-       setupHaskellDepends = [ base Cabal cabal-doctest ];
-       libraryHaskellDepends = [
-         base distributive template-haskell transformers
-       ];
-       testHaskellDepends = [
-         base distributive doctest tasty tasty-hunit
-       ];
-       testToolDepends = [ markdown-unlit ];
-       description = "standard type constructor class hierarchy, only with methods of rank 2 types";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "rank2classes_1_4_2" = callPackage
-    ({ mkDerivation, base, Cabal, cabal-doctest, distributive, doctest
-     , markdown-unlit, tasty, tasty-hunit, template-haskell
-     , transformers
-     }:
-     mkDerivation {
-       pname = "rank2classes";
        version = "1.4.2";
        sha256 = "0b32mgqzwj9hzz29fhvzidw40iygkbra5ng7z7l9kpp15pbak0pp";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
···
        testToolDepends = [ markdown-unlit ];
        description = "standard type constructor class hierarchy, only with methods of rank 2 types";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "rapid" = callPackage
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {raptor2 = null; redland = null;};
+     }) {raptor2 = null; inherit (pkgs) redland;};
 
   "redo" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory, filepath
···
     ({ mkDerivation, array, base, bytestring, containers, regex-base }:
      mkDerivation {
        pname = "regex-posix";
-       version = "0.96.0.0";
-       sha256 = "08a584jabmmn5gmaqrcar5wsp3qzk0hklldzp2mr2bmvlvqh04r5";
-       revision = "2";
-       editedCabalFile = "10al5qljh6pc46581nkhrs0rjn8w05pp6jb4v55lgfr17ac0z1xx";
-       libraryHaskellDepends = [
-         array base bytestring containers regex-base
-       ];
-       description = "POSIX Backend for \"Text.Regex\" (regex-base)";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "regex-posix_0_96_0_1" = callPackage
-    ({ mkDerivation, array, base, bytestring, containers, regex-base }:
-     mkDerivation {
-       pname = "regex-posix";
        version = "0.96.0.1";
        sha256 = "1715b57z67q4hg0jz44wkxrxi3v7n5iagw6gw48pf8hr34wpr0n7";
        libraryHaskellDepends = [
···
        ];
        description = "POSIX Backend for \"Text.Regex\" (regex-base)";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "regex-posix-clib" = callPackage
···
      }:
      mkDerivation {
        pname = "relational-query";
-       version = "0.12.2.3";
-       sha256 = "0zjqk0gkzdhg1l8rw0bz7iwvp55p585xaqp8dc3sbbr0abhmsgi5";
-       libraryHaskellDepends = [
-         array base bytestring containers dlist names-th persistable-record
-         product-isomorphic sql-words template-haskell text
-         th-constraint-compat th-reify-compat time time-locale-compat
-         transformers
-       ];
-       testHaskellDepends = [
-         base containers product-isomorphic quickcheck-simple transformers
-       ];
-       description = "Typeful, Modular, Relational, algebraic query engine";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "relational-query_0_12_3_0" = callPackage
-    ({ mkDerivation, array, base, bytestring, containers, dlist
-     , names-th, persistable-record, product-isomorphic
-     , quickcheck-simple, sql-words, template-haskell, text
-     , th-constraint-compat, th-reify-compat, time, time-locale-compat
-     , transformers
-     }:
-     mkDerivation {
-       pname = "relational-query";
        version = "0.12.3.0";
        sha256 = "1acbz0zy4bb8r7q2nw96jgpi45y8gy4j1qik4fn8ndqw8l3fpzvl";
        libraryHaskellDepends = [
···
        ];
        description = "Typeful, Modular, Relational, algebraic query engine";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "relational-query-HDBC" = callPackage
···
 
   "require" = callPackage
     ({ mkDerivation, ansi-terminal, base, bytestring, criterion
-     , directory, dlist, megaparsec, mtl, optparse-generic, relude
-     , tasty, tasty-hspec, text
+     , directory, dlist, hspec, megaparsec, mtl, optparse-generic
+     , relude, tasty, tasty-hspec, text
      }:
      mkDerivation {
        pname = "require";
-       version = "0.4.10";
-       sha256 = "0ha9301ncb5li3sxjlbbq5hgjijr40vl5jy33fsi0wn13zp99x94";
+       version = "0.4.11";
+       sha256 = "17nfpzwhwxnl6jmqnh2rf52mki3mh44y24w7masscbnadxnfp98a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          optparse-generic relude text
        ];
        testHaskellDepends = [
-         ansi-terminal base bytestring directory dlist megaparsec mtl
+         ansi-terminal base bytestring directory dlist hspec megaparsec mtl
          optparse-generic relude tasty tasty-hspec text
        ];
        benchmarkHaskellDepends = [
···
      }) {};
 
   "sandwich-webdriver" = callPackage
-    ({ mkDerivation, aeson, base, containers, convertible, data-default
-     , directory, exceptions, filepath, http-client, http-client-tls
-     , http-conduit, lifted-base, microlens, microlens-aeson
-     , monad-control, monad-logger, mtl, network, process, random, retry
-     , safe, safe-exceptions, sandwich, string-interpolate, temporary
-     , text, time, transformers, unix, unordered-containers, vector
-     , webdriver, X11
-     }:
-     mkDerivation {
-       pname = "sandwich-webdriver";
-       version = "0.1.0.5";
-       sha256 = "113as1i4f3hghbwrf4ii8lnxxb8nih177ffjbx3shsddnhx0fa8y";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson base containers convertible data-default directory exceptions
-         filepath http-client http-client-tls http-conduit lifted-base
-         microlens microlens-aeson monad-control monad-logger mtl network
-         process random retry safe safe-exceptions sandwich
-         string-interpolate temporary text time transformers unix
-         unordered-containers vector webdriver X11
-       ];
-       executableHaskellDepends = [
-         aeson base containers convertible data-default directory exceptions
-         filepath http-client http-client-tls http-conduit lifted-base
-         microlens microlens-aeson monad-control monad-logger mtl network
-         process random retry safe safe-exceptions sandwich
-         string-interpolate temporary text time transformers unix
-         unordered-containers vector webdriver X11
-       ];
-       testHaskellDepends = [
-         aeson base containers convertible data-default directory exceptions
-         filepath http-client http-client-tls http-conduit lifted-base
-         microlens microlens-aeson monad-control monad-logger mtl network
-         process random retry safe safe-exceptions sandwich
-         string-interpolate temporary text time transformers unix
-         unordered-containers vector webdriver X11
-       ];
-       description = "Sandwich integration with Selenium WebDriver";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "sandwich-webdriver_0_1_0_6" = callPackage
     ({ mkDerivation, aeson, base, containers, data-default, directory
      , exceptions, filepath, http-client, http-client-tls, http-conduit
      , lifted-base, microlens, microlens-aeson, monad-control
···
        ];
        description = "Sandwich integration with Selenium WebDriver";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sarasvati" = callPackage
···
      }) {};
 
   "servant-util" = callPackage
-    ({ mkDerivation, aeson, autoexporter, base, containers
-     , data-default, fmt, hspec, hspec-discover, hspec-expectations
-     , http-client, http-types, insert-ordered-containers, lens
-     , megaparsec, mtl, pretty-terminal, QuickCheck, reflection
-     , regex-posix, safe-exceptions, servant, servant-client
-     , servant-client-core, servant-server, servant-swagger
-     , servant-swagger-ui, servant-swagger-ui-core, swagger2, text
-     , text-format, time, universum, wai, wai-extra, warp
+    ({ mkDerivation, aeson, base, containers, data-default, fmt, hspec
+     , hspec-discover, hspec-expectations, http-client, http-types
+     , insert-ordered-containers, lens, megaparsec, mtl, pretty-terminal
+     , QuickCheck, reflection, regex-posix, safe-exceptions, servant
+     , servant-client, servant-client-core, servant-server
+     , servant-swagger, servant-swagger-ui, servant-swagger-ui-core
+     , swagger2, text, text-format, time, universum, wai, wai-extra
+     , warp
      }:
      mkDerivation {
        pname = "servant-util";
-       version = "0.1.0.1";
-       sha256 = "0idb3h2482hhrj9yvphdb74wxyr2y3rzfql2q2qn2a724b1bmax4";
+       version = "0.1.0.2";
+       sha256 = "1l0pwwz8y4qwnpn30w3mla3j3dmbyv99kilbb8z283iwpnbgrn2w";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          servant-swagger-ui servant-swagger-ui-core swagger2 text
          text-format time universum wai
        ];
-       libraryToolDepends = [ autoexporter ];
        executableHaskellDepends = [
          aeson base containers data-default fmt http-types
          insert-ordered-containers lens megaparsec mtl pretty-terminal
···
      }) {};
 
   "servant-util-beam-pg" = callPackage
-    ({ mkDerivation, autoexporter, base, beam-core, beam-postgres
-     , containers, hspec, hspec-discover, QuickCheck, servant
-     , servant-client, servant-client-core, servant-server, servant-util
-     , text, universum
+    ({ mkDerivation, base, beam-core, beam-postgres, containers, hspec
+     , hspec-discover, QuickCheck, servant, servant-client
+     , servant-client-core, servant-server, servant-util, text
+     , universum
      }:
      mkDerivation {
        pname = "servant-util-beam-pg";
-       version = "0.1.0.1";
-       sha256 = "1qhs2bvlka3qm4kv64m5p5ldcd9nfgzs0za9vqy2z9fmdhzihxz1";
+       version = "0.1.0.2";
+       sha256 = "048ybnlkhp7dabki4r3k6q147cdm3w3l14c57rrf1n1vf4rwkgn2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          base beam-core beam-postgres containers servant servant-client
          servant-client-core servant-server servant-util text universum
        ];
-       libraryToolDepends = [ autoexporter ];
        executableHaskellDepends = [
          base beam-core beam-postgres containers servant servant-client
          servant-client-core servant-server servant-util text universum
···
     ({ mkDerivation, base, extra, path, rio, shake }:
      mkDerivation {
        pname = "shake-plus";
-       version = "0.3.3.1";
-       sha256 = "09zinaphlmdshny3hiyibbqqkfflj2rkxh8zkpnnk5dvf2qb15p5";
-       libraryHaskellDepends = [ base extra path rio shake ];
-       description = "Re-export of Shake using well-typed paths and ReaderT";
-       license = lib.licenses.mit;
-     }) {};
-
-  "shake-plus_0_3_4_0" = callPackage
-    ({ mkDerivation, base, extra, path, rio, shake }:
-     mkDerivation {
-       pname = "shake-plus";
        version = "0.3.4.0";
        sha256 = "0022npwhvzlpz6d6xl75kx0f7ydr8fqqcy04zkv70gwsv0gp5zbm";
        libraryHaskellDepends = [ base extra path rio shake ];
        description = "Re-export of Shake using well-typed paths and ReaderT";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "shake-plus-extended" = callPackage
···
     ({ mkDerivation, base, formatting, simple-media-timestamp }:
      mkDerivation {
        pname = "simple-media-timestamp-formatting";
-       version = "0.1.0.0";
-       sha256 = "05km174zc9as8aa4l18fgwnjl19068kqr1chvmnn7r3b8ms00z57";
+       version = "0.1.1.0";
+       sha256 = "1fkjplpkv1jxcadhc596rv7jzbgn2f1xnmwdfa68wls3hl0h7s70";
        libraryHaskellDepends = [ base formatting simple-media-timestamp ];
        description = "Formatting for simple-media-timestamp";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "simple-parser";
-       version = "0.8.0";
-       sha256 = "0k2sj1n42kkfvr0g8sdhz5vasv0h38hgs04r8fjy5gpxmrzni472";
+       version = "0.8.2";
+       sha256 = "15nxh0byl0893gzsakb80asam8dr4lqxqnlj372cdjgqvrzcxrap";
        libraryHaskellDepends = [
          base bytestring containers errata list-t mmorph mtl
          nonempty-containers scientific text text-builder
···
        license = lib.licenses.mit;
      }) {};
 
+  "srt-dhall" = callPackage
+    ({ mkDerivation, attoparsec, base, dhall, either, formatting
+     , simple-media-timestamp, simple-media-timestamp-formatting, srt
+     , srt-attoparsec, srt-formatting, text
+     }:
+     mkDerivation {
+       pname = "srt-dhall";
+       version = "0.1.0.0";
+       sha256 = "16ygxiqb9d0js3gr4823fdkk8pzsairby6iywnvsafas1qvhm0yp";
+       libraryHaskellDepends = [
+         attoparsec base dhall either formatting simple-media-timestamp
+         simple-media-timestamp-formatting srt srt-attoparsec srt-formatting
+         text
+       ];
+       description = "Dhall Encoder/Decoder for SRT";
+       license = lib.licenses.mit;
+     }) {};
+
+  "srt-formatting" = callPackage
+    ({ mkDerivation, base, formatting, simple-media-timestamp
+     , simple-media-timestamp-formatting, srt
+     }:
+     mkDerivation {
+       pname = "srt-formatting";
+       version = "0.1.0.0";
+       sha256 = "0ssbxjlzqn0n3lj3f4m3881m1z0jk5qq94badddwszxs898d1zk5";
+       libraryHaskellDepends = [
+         base formatting simple-media-timestamp
+         simple-media-timestamp-formatting srt
+       ];
+       description = "Format an SRT";
+       license = lib.licenses.mit;
+     }) {};
+
   "sscan" = callPackage
     ({ mkDerivation, async, base, brick, directory, filepath, microlens
      , microlens-th, process, temporary, text, time, vty
···
      }:
      mkDerivation {
        pname = "stack";
-       version = "2.7.1";
-       sha256 = "09mw5jwgcmbkwsgvg1ls114hq9v2vl49pdvix8ir7vvgicvdhnv0";
-       configureFlags = [
-         "-fdisable-git-info" "-fhide-dependency-versions"
-         "-fsupported-build"
-       ];
-       isLibrary = true;
-       isExecutable = true;
-       setupHaskellDepends = [ base Cabal filepath ];
-       libraryHaskellDepends = [
-         aeson annotated-wl-pprint ansi-terminal array async attoparsec base
-         base64-bytestring bytestring Cabal casa-client casa-types colour
-         conduit conduit-extra containers cryptonite cryptonite-conduit
-         deepseq directory echo exceptions extra file-embed filelock
-         filepath fsnotify generic-deriving hackage-security hashable
-         hi-file-parser hpack hpc http-client http-client-tls http-conduit
-         http-download http-types memory microlens mintty mono-traversable
-         mtl mustache neat-interpolation network-uri open-browser
-         optparse-applicative pantry path path-io persistent
-         persistent-sqlite persistent-template pretty primitive process
-         project-template regex-applicative-text retry rio rio-prettyprint
-         semigroups split stm streaming-commons tar template-haskell
-         temporary text text-metrics th-reify-many time tls transformers
-         typed-process unicode-transforms unix unix-compat unliftio
-         unordered-containers vector yaml zip-archive zlib
-       ];
-       executableHaskellDepends = [
-         aeson annotated-wl-pprint ansi-terminal array async attoparsec base
-         base64-bytestring bytestring Cabal casa-client casa-types colour
-         conduit conduit-extra containers cryptonite cryptonite-conduit
-         deepseq directory echo exceptions extra file-embed filelock
-         filepath fsnotify generic-deriving hackage-security hashable
-         hi-file-parser hpack hpc http-client http-client-tls http-conduit
-         http-download http-types memory microlens mintty mono-traversable
-         mtl mustache neat-interpolation network-uri open-browser
-         optparse-applicative pantry path path-io persistent
-         persistent-sqlite persistent-template pretty primitive process
-         project-template regex-applicative-text retry rio rio-prettyprint
-         semigroups split stm streaming-commons tar template-haskell
-         temporary text text-metrics th-reify-many time tls transformers
-         typed-process unicode-transforms unix unix-compat unliftio
-         unordered-containers vector yaml zip-archive zlib
-       ];
-       testHaskellDepends = [
-         aeson annotated-wl-pprint ansi-terminal array async attoparsec base
-         base64-bytestring bytestring Cabal casa-client casa-types colour
-         conduit conduit-extra containers cryptonite cryptonite-conduit
-         deepseq directory echo exceptions extra file-embed filelock
-         filepath fsnotify generic-deriving hackage-security hashable
-         hi-file-parser hpack hpc hspec http-client http-client-tls
-         http-conduit http-download http-types memory microlens mintty
-         mono-traversable mtl mustache neat-interpolation network-uri
-         open-browser optparse-applicative pantry path path-io persistent
-         persistent-sqlite persistent-template pretty primitive process
-         project-template QuickCheck raw-strings-qq regex-applicative-text
-         retry rio rio-prettyprint semigroups smallcheck split stm
-         streaming-commons tar template-haskell temporary text text-metrics
-         th-reify-many time tls transformers typed-process
-         unicode-transforms unix unix-compat unliftio unordered-containers
-         vector yaml zip-archive zlib
-       ];
-       doCheck = false;
-       preCheck = "export HOME=$TMPDIR";
-       postInstall = ''
-         exe=$out/bin/stack
-         mkdir -p $out/share/bash-completion/completions
-         $exe --bash-completion-script $exe >$out/share/bash-completion/completions/stack
-       '';
-       description = "The Haskell Tool Stack";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "stack_2_7_3" = callPackage
-    ({ mkDerivation, aeson, annotated-wl-pprint, ansi-terminal, array
-     , async, attoparsec, base, base64-bytestring, bytestring, Cabal
-     , casa-client, casa-types, colour, conduit, conduit-extra
-     , containers, cryptonite, cryptonite-conduit, deepseq, directory
-     , echo, exceptions, extra, file-embed, filelock, filepath, fsnotify
-     , generic-deriving, hackage-security, hashable, hi-file-parser
-     , hpack, hpc, hspec, http-client, http-client-tls, http-conduit
-     , http-download, http-types, memory, microlens, mintty
-     , mono-traversable, mtl, mustache, neat-interpolation, network-uri
-     , open-browser, optparse-applicative, pantry, path, path-io
-     , persistent, persistent-sqlite, persistent-template, pretty
-     , primitive, process, project-template, QuickCheck, raw-strings-qq
-     , regex-applicative-text, retry, rio, rio-prettyprint, semigroups
-     , smallcheck, split, stm, streaming-commons, tar, template-haskell
-     , temporary, text, text-metrics, th-reify-many, time, tls
-     , transformers, typed-process, unicode-transforms, unix
-     , unix-compat, unliftio, unordered-containers, vector, yaml
-     , zip-archive, zlib
-     }:
-     mkDerivation {
-       pname = "stack";
        version = "2.7.3";
        sha256 = "0i2v5i6bg90n6i4clcaww8m8702d3y5z8r03xdizdisjhf0zijj7";
        configureFlags = [
···
        '';
        description = "The Haskell Tool Stack";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "stack-all" = callPackage
···
      }:
      mkDerivation {
        pname = "static-text";
-       version = "0.2.0.6";
-       sha256 = "14z6ib2b1n6m460c5li58wh0p5kwmb471zwpwjn0pmgsayp8vzzi";
-       libraryHaskellDepends = [
-         base bytestring template-haskell text vector
-       ];
-       testHaskellDepends = [
-         base bytestring doctest doctest-driver-gen markdown-unlit tasty
-         tasty-hunit template-haskell
-       ];
-       testToolDepends = [ markdown-unlit ];
-       description = "Lists, Texts, ByteStrings and Vectors of statically known length";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "static-text_0_2_0_7" = callPackage
-    ({ mkDerivation, base, bytestring, doctest, doctest-driver-gen
-     , markdown-unlit, tasty, tasty-hunit, template-haskell, text
-     , vector
-     }:
-     mkDerivation {
-       pname = "static-text";
        version = "0.2.0.7";
        sha256 = "1mphxd0wpr4qwyznff96qn5b1xb2x9k956aghap6nnabnyhgvqr4";
        libraryHaskellDepends = [
···
        testToolDepends = [ markdown-unlit ];
        description = "Lists, Texts, ByteStrings and Vectors of statically known length";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "staticanalysis" = callPackage
···
      }:
      mkDerivation {
        pname = "status-notifier-item";
-       version = "0.3.0.5";
-       sha256 = "165kdg1wb0xpy4z7hlk8654ph2psdibal1p0f32zzrccbnk0w801";
+       version = "0.3.1.0";
+       sha256 = "1x3zqa2b9vl5mirfbh2bmyali47jpfcqsw4xxgbmsgz9jiffpda9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Elegant definition of Storable instances for records";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "storable-record_0_0_6" = callPackage
+    ({ mkDerivation, base, QuickCheck, semigroups, transformers
+     , utility-ht
+     }:
+     mkDerivation {
+       pname = "storable-record";
+       version = "0.0.6";
+       sha256 = "1d4c1ccbrpq8rnacsjib9nmxhgxk9yb1zxx1nvfavhqhv8nwq2fd";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base QuickCheck semigroups transformers utility-ht
+       ];
+       description = "Elegant definition of Storable instances for records";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "storable-static-array" = callPackage
···
        license = lib.licenses.bsd3;
      }) {archive = null;};
 
+  "streamly-archive_0_1_0" = callPackage
+    ({ mkDerivation, archive, base, bytestring, cryptonite, directory
+     , filepath, QuickCheck, streamly, tar, tasty, tasty-hunit
+     , tasty-quickcheck, temporary, zlib
+     }:
+     mkDerivation {
+       pname = "streamly-archive";
+       version = "0.1.0";
+       sha256 = "0094qi2n7fg7hsdaag307gmcvgrl39m4w0lz29csrk1fq4yy578x";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [ base bytestring streamly ];
+       librarySystemDepends = [ archive ];
+       testHaskellDepends = [
+         base bytestring cryptonite directory filepath QuickCheck streamly
+         tar tasty tasty-hunit tasty-quickcheck temporary zlib
+       ];
+       testSystemDepends = [ archive ];
+       description = "Stream data from archives using the streamly library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {archive = null;};
+
   "streamly-binary" = callPackage
     ({ mkDerivation, base, binary, bytestring, hspec, QuickCheck
      , streamly
···
        ];
        description = "Folder watching as a Streamly stream";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "streamly-lmdb" = callPackage
···
        license = lib.licenses.bsd3;
      }) {inherit (pkgs) lmdb;};
 
+  "streamly-lmdb_0_3_0" = callPackage
+    ({ mkDerivation, async, base, bytestring, directory, lmdb
+     , QuickCheck, streamly, tasty, tasty-quickcheck, temporary
+     }:
+     mkDerivation {
+       pname = "streamly-lmdb";
+       version = "0.3.0";
+       sha256 = "1da87rbmh9sgffjy5367pzy1d80f7zlxhszi9sq87jfws4i20pk7";
+       libraryHaskellDepends = [ async base bytestring streamly ];
+       librarySystemDepends = [ lmdb ];
+       testHaskellDepends = [
+         async base bytestring directory QuickCheck streamly tasty
+         tasty-quickcheck temporary
+       ];
+       testSystemDepends = [ lmdb ];
+       description = "Stream data to or from LMDB databases using the streamly library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) lmdb;};
+
   "streamly-posix" = callPackage
     ({ mkDerivation, base, bytestring, filepath, hpath-posix, hspec
      , hspec-discover, safe-exceptions, streamly, streamly-bytestring
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "streamly-process" = callPackage
+    ({ mkDerivation, base, directory, exceptions, fusion-plugin, hspec
+     , process, QuickCheck, streamly, tasty-bench, unix
+     }:
+     mkDerivation {
+       pname = "streamly-process";
+       version = "0.1.0";
+       sha256 = "066ldbphb230cc21jvsmmqlnjli6cwqpphs7vjb88q62lbl8yf6p";
+       libraryHaskellDepends = [ base exceptions process streamly unix ];
+       testHaskellDepends = [
+         base directory exceptions hspec process QuickCheck streamly
+       ];
+       benchmarkHaskellDepends = [
+         base directory fusion-plugin process streamly tasty-bench
+       ];
+       description = "Use OS processes as stream transformation functions";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "streamproc" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "taffybar";
-       version = "3.2.5";
-       sha256 = "1gfdlqgdqq2ivvzj7cgqahpm2bmwg90ri5ss7ah38alrp5rvda1v";
+       version = "3.3.0";
+       sha256 = "17ggcv1y3md11sccbb9mpss2qdanlkv7wy098qh28gra9kq4ibgm";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "tagged";
        version = "0.8.6.1";
        sha256 = "00kcc6lmj7v3xm2r3wzw5jja27m4alcw1wi8yiismd0bbzwzrq7m";
-       revision = "1";
-       editedCabalFile = "1rzqfw2pafxbnfpl1lizf9zldpxyy28g92x4jzq49miw9hr1xpsx";
+       revision = "2";
+       editedCabalFile = "0qi63c3z40i9qm44r571yjzcpb8d473vj2km4kq0fij0ljc7vii9";
        libraryHaskellDepends = [
          base deepseq template-haskell transformers
        ];
···
      }) {};
 
   "tasty-checklist" = callPackage
-    ({ mkDerivation, base, exceptions, parameterized-utils, tasty
-     , tasty-expected-failure, tasty-hunit, text
+    ({ mkDerivation, base, doctest, exceptions, HUnit
+     , parameterized-utils, tasty, tasty-expected-failure, tasty-hunit
+     , text
      }:
      mkDerivation {
        pname = "tasty-checklist";
-       version = "1.0.1.0";
-       sha256 = "0nj4xjnlrd3righ0d0yv4py7wjls51khjyacpgjs3s5knaxyippp";
+       version = "1.0.2.0";
+       sha256 = "0smd93c1zs44nwiz0dk87izg0c9cyvx2klzy126w0p0xcxwwbhlr";
        libraryHaskellDepends = [
          base exceptions parameterized-utils text
        ];
        testHaskellDepends = [
-         base parameterized-utils tasty tasty-expected-failure tasty-hunit
-         text
+         base doctest HUnit parameterized-utils tasty tasty-expected-failure
+         tasty-hunit text
        ];
        description = "Check multiple items during a tasty test";
        license = lib.licenses.isc;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "tasty-dejafu" = callPackage
···
      }:
      mkDerivation {
        pname = "tidal";
-       version = "1.7.7";
-       sha256 = "19r9h45yd2xwmah81xqmwx5bi5gi0x2hqhq2nqa47jgb0nd12a25";
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         base bifunctors bytestring clock colour containers deepseq hosc
-         network parsec primitive random text transformers
-       ];
-       testHaskellDepends = [
-         base containers deepseq hosc microspec parsec
-       ];
-       benchmarkHaskellDepends = [ base criterion weigh ];
-       description = "Pattern language for improvised music";
-       license = lib.licenses.gpl3Only;
-     }) {};
-
-  "tidal_1_7_8" = callPackage
-    ({ mkDerivation, base, bifunctors, bytestring, clock, colour
-     , containers, criterion, deepseq, hosc, microspec, network, parsec
-     , primitive, random, text, transformers, weigh
-     }:
-     mkDerivation {
-       pname = "tidal";
        version = "1.7.8";
        sha256 = "0l8k4f89rhmvd0ys7klgi57k0313ki1vr256mkc60xc6a6gb3g93";
        enableSeparateDataOutput = true;
···
        benchmarkHaskellDepends = [ base criterion weigh ];
        description = "Pattern language for improvised music";
        license = lib.licenses.gpl3Only;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "tidal-midi" = callPackage
···
        broken = true;
      }) {};
 
+  "token-limiter-concurrent" = callPackage
+    ({ mkDerivation, async, base, genvalidity, genvalidity-sydtest
+     , QuickCheck, sydtest, sydtest-discover
+     }:
+     mkDerivation {
+       pname = "token-limiter-concurrent";
+       version = "0.0.0.0";
+       sha256 = "1g64638v7kiblixb8xg5dvnif60mlpplp1l18pv32lr9sph7yv1c";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [
+         async base genvalidity genvalidity-sydtest QuickCheck sydtest
+       ];
+       testToolDepends = [ sydtest-discover ];
+       description = "A thread-safe concurrent token-bucket rate limiter that guarantees fairness";
+       license = lib.licenses.mit;
+     }) {};
+
   "token-search" = callPackage
     ({ mkDerivation, aeson, base, bytestring, conduit, hashable, hspec
      , process, streaming-commons, text, unordered-containers
···
        pname = "tracetree";
        version = "0.1.0.2";
        sha256 = "0ga78nkrfg2hlanqfd65il0yw596n7xy9jx76l7sffs438mx4wvr";
+       revision = "1";
+       editedCabalFile = "1k6a5n70qmch9vqyv9kyrkii4pnwjdgbiwrqwk8q3yhv9naqijkh";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        libraryHaskellDepends = [ base ghc-prim transformers ];
        description = "A small compatibility shim for the transformers library";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "transformers-compat_0_7" = callPackage
+    ({ mkDerivation, base, ghc-prim, transformers }:
+     mkDerivation {
+       pname = "transformers-compat";
+       version = "0.7";
+       sha256 = "13x9f3rq1ibx5lhzrsysg7m5nkqas75kv6b0zmzvspjiswfp7bd4";
+       libraryHaskellDepends = [ base ghc-prim transformers ];
+       description = "A small compatibility shim for the transformers library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "transformers-compose" = callPackage
···
      }:
      mkDerivation {
        pname = "tweet-hs";
-       version = "1.0.2.2";
-       sha256 = "1sl4pld3jig1m26alhj4s96ff43v3g00wxzrng4yhb76d88z0ipw";
+       version = "1.0.2.3";
+       sha256 = "0chkg9xkancp6dms0ha0m86fkcmvk690q6z0rvprg37lhj42xp1i";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "unicode-transforms";
        version = "0.3.7.1";
        sha256 = "1010sahi4mjzqmxqlj3w73rlymbl2370x5vizjqbx7mb86kxzx4f";
-       revision = "1";
-       editedCabalFile = "01kf1hanqcwc7vpkwq2rw5v2mn4nxx58l3v5hpk166jalmwqijaz";
+       revision = "2";
+       editedCabalFile = "0kbcn5881sxh0i8pqckjam4kwr1n7m3gl5ppcq4li32dzfiz9b57";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring ghc-prim text ];
···
        ];
        description = "Unicode normalization";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "unicode-transforms_0_3_8" = callPackage
+    ({ mkDerivation, base, bytestring, deepseq, filepath
+     , getopt-generics, ghc-prim, hspec, path, path-io, QuickCheck
+     , split, tasty-bench, text, unicode-data
+     }:
+     mkDerivation {
+       pname = "unicode-transforms";
+       version = "0.3.8";
+       sha256 = "1j3dwz3qmak3fyb1p4qzr1rnxch2ydqfp2jizyy4rv425h0smxzl";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring ghc-prim text unicode-data
+       ];
+       testHaskellDepends = [
+         base deepseq getopt-generics hspec QuickCheck split text
+         unicode-data
+       ];
+       benchmarkHaskellDepends = [
+         base deepseq filepath path path-io tasty-bench text
+       ];
+       description = "Unicode normalization";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "unicode-tricks" = callPackage
···
     ({ mkDerivation, array, base, mtl }:
      mkDerivation {
        pname = "union-find-array";
-       version = "0.1.0.2";
-       sha256 = "1pxb1v2k04i8ds2n8zqra74gacry6dj5p87sxgkf4fazx4s316dk";
+       version = "0.1.0.3";
+       sha256 = "1nfvgmgvins9gq5ba9vf9yqj9svj2c22xgvvfq03ls9wm62vj1xw";
        libraryHaskellDepends = [ array base mtl ];
        description = "union find data structure";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "unliftio";
-       version = "0.2.18";
-       sha256 = "0yg5x2v3p4pdw7892l1mkihmdbak14qvmni1vk2a0y2gdmxfvx1y";
-       libraryHaskellDepends = [
-         async base bytestring deepseq directory filepath process stm time
-         transformers unix unliftio-core
-       ];
-       testHaskellDepends = [
-         async base bytestring containers deepseq directory filepath hspec
-         process QuickCheck stm time transformers unix unliftio-core
-       ];
-       benchmarkHaskellDepends = [
-         async base bytestring deepseq directory filepath gauge process stm
-         time transformers unix unliftio-core
-       ];
-       description = "The MonadUnliftIO typeclass for unlifting monads to IO (batteries included)";
-       license = lib.licenses.mit;
-     }) {};
-
-  "unliftio_0_2_19" = callPackage
-    ({ mkDerivation, async, base, bytestring, containers, deepseq
-     , directory, filepath, gauge, hspec, process, QuickCheck, stm, time
-     , transformers, unix, unliftio-core
-     }:
-     mkDerivation {
-       pname = "unliftio";
        version = "0.2.19";
        sha256 = "052m0vr6444r5adzyzr3aqj07p9ay5y2sqfsczwj52bc66qqyy36";
        libraryHaskellDepends = [
···
        ];
        description = "The MonadUnliftIO typeclass for unlifting monads to IO (batteries included)";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "unliftio-core" = callPackage
···
        broken = true;
      }) {};
 
+  "variable-media-field" = callPackage
+    ({ mkDerivation, base, text }:
+     mkDerivation {
+       pname = "variable-media-field";
+       version = "0.1.0.0";
+       sha256 = "13fpvd3w3c7lndkf4l4d48fcfsssxwi7ip9309gzwlrlycq57908";
+       libraryHaskellDepends = [ base text ];
+       description = "Simple type for representing one of several media types";
+       license = lib.licenses.mit;
+     }) {};
+
+  "variable-media-field-dhall" = callPackage
+    ({ mkDerivation, base, dhall, variable-media-field }:
+     mkDerivation {
+       pname = "variable-media-field-dhall";
+       version = "0.1.0.0";
+       sha256 = "0h2gm5h86n7bm5gf9rbc0zlkkhrkyavygvrkz251r9l57qw48qax";
+       libraryHaskellDepends = [ base dhall variable-media-field ];
+       description = "Dhall instances for VF";
+       license = lib.licenses.mit;
+     }) {};
+
+  "variable-media-field-optics" = callPackage
+    ({ mkDerivation, base, optics-th, variable-media-field }:
+     mkDerivation {
+       pname = "variable-media-field-optics";
+       version = "0.1.0.0";
+       sha256 = "1n4ccd52yy5yna28bmn4sc7cyrngyllgk976q4v7f262l49wmphj";
+       libraryHaskellDepends = [ base optics-th variable-media-field ];
+       description = "Optics for variable-media-field";
+       license = lib.licenses.mit;
+     }) {};
+
   "variable-precision" = callPackage
     ({ mkDerivation, base, complex-generic, floatshow, integer-gmp
      , type-level-natural-number
···
      }:
      mkDerivation {
        pname = "vulkan-utils";
-       version = "0.5.0.2";
-       sha256 = "19jxd73li1ybdfzznlql2im8k0qad1yas75d5cdfvjazv7x4g3n1";
+       version = "0.5.1";
+       sha256 = "1552vk9nzvcpkgh5b9lln9gl6rxg1jr8z7blgp3sss3pjsvi3s11";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base bytestring containers dependent-map dependent-sum extra
···
      }:
      mkDerivation {
        pname = "wai-make-assets";
-       version = "0.2";
-       sha256 = "0h6ng8g42bpb8d75wykb1q9byqh3zx745asy31yqzp49v0aip1vy";
+       version = "0.3";
+       sha256 = "07h56bjyap8x2aaay23k3l6n6gk1h5a3qqijd33b4pnc0nygfzci";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "witch";
-       version = "0.3.3.0";
-       sha256 = "0wckjjy7yxq899f515xhwl2izqmrr9zck0kjlgz6qfa1fsl6lbvx";
-       libraryHaskellDepends = [
-         base bytestring containers template-haskell text time
-       ];
-       testHaskellDepends = [
-         base bytestring containers HUnit text time
-       ];
-       description = "Convert values from one type into another";
-       license = lib.licenses.isc;
-     }) {};
-
-  "witch_0_3_4_0" = callPackage
-    ({ mkDerivation, base, bytestring, containers, HUnit
-     , template-haskell, text, time
-     }:
-     mkDerivation {
-       pname = "witch";
        version = "0.3.4.0";
        sha256 = "0ykdd47kfan9zr656l6q3cmp3npxq44ykjci2q51bphlawiwh496";
        libraryHaskellDepends = [
···
        ];
        description = "Convert values from one type into another";
        license = lib.licenses.isc;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "with-index" = callPackage
···
        broken = true;
      }) {};
 
+  "xml-parser" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, containers, hashable
+     , QuickCheck, quickcheck-instances, rerebase, tasty, tasty-hunit
+     , tasty-quickcheck, text, text-builder, transformers
+     , unordered-containers, xml-conduit
+     }:
+     mkDerivation {
+       pname = "xml-parser";
+       version = "0.1.0.1";
+       sha256 = "079ggb9bhad9px6gqbjhbir423hds389p42jc853caz7232dc6vx";
+       libraryHaskellDepends = [
+         attoparsec base bytestring containers hashable text text-builder
+         transformers unordered-containers xml-conduit
+       ];
+       testHaskellDepends = [
+         attoparsec QuickCheck quickcheck-instances rerebase tasty
+         tasty-hunit tasty-quickcheck xml-conduit
+       ];
+       description = "XML parser with informative error-reporting and simple API";
+       license = lib.licenses.mit;
+     }) {};
+
   "xml-picklers" = callPackage
     ({ mkDerivation, base, Cabal, containers, QuickCheck, tasty
      , tasty-hunit, tasty-quickcheck, text, xml-types
···
      }) {};
 
   "xsd" = callPackage
-    ({ mkDerivation, attoparsec, base, directory, doctest, filepath
-     , lens, QuickCheck, quickcheck-instances, text, time
+    ({ mkDerivation, base, lens, parsec, parsers, semigroupoids, text
+     , time
      }:
      mkDerivation {
        pname = "xsd";
-       version = "0.5.0.1";
-       sha256 = "1a5i2idpkm5i70jpp2kjglpylja4b9cd0nklgvl6lm8cpjn2j0k0";
-       libraryHaskellDepends = [ attoparsec base lens text time ];
-       testHaskellDepends = [
-         base directory doctest filepath QuickCheck quickcheck-instances
+       version = "0.6.2";
+       sha256 = "0m8xb12bfcr03w5b15xx5s2wwy7kz735vwaxyk3qbny3wkq7m0fw";
+       libraryHaskellDepends = [
+         base lens parsec parsers semigroupoids text time
        ];
        description = "XML Schema data structures";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "yesod-core";
-       version = "1.6.20.2";
-       sha256 = "184j6nslwrfxw4zmsxlii6gs1z0h350kgmbnr5y3wwk3n4dsdzyb";
+       version = "1.6.21.0";
+       sha256 = "0wmh7ip318p89lyy6k5mvxkkpq43knp41wlq9iaf3icz0ahqdmb7";
        libraryHaskellDepends = [
          aeson auto-update base blaze-html blaze-markup bytestring
          case-insensitive cereal clientsession conduit conduit-extra
···
      }) {};
 
   "yesod-gitrev" = callPackage
-    ({ mkDerivation, aeson, base, githash, template-haskell, yesod-core
-     }:
-     mkDerivation {
-       pname = "yesod-gitrev";
-       version = "0.2.1";
-       sha256 = "0wd6xvq9aa11n8y4hna0a5ivqfxnbg8w2bq5lramm895xs7c8d7w";
-       libraryHaskellDepends = [
-         aeson base githash template-haskell yesod-core
-       ];
-       testHaskellDepends = [ base yesod-core ];
-       description = "A subsite for displaying git information";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "yesod-gitrev_0_2_2" = callPackage
     ({ mkDerivation, aeson, base, githash, process, template-haskell
      , yesod-core
      }:
···
      }:
      mkDerivation {
        pname = "yesod-page-cursor";
-       version = "2.0.0.8";
-       sha256 = "1azd2kv5b36kryz3l587mn329a46m8mp4z8knzx5va24bmhca9jy";
-       libraryHaskellDepends = [
-         aeson base bytestring containers http-link-header network-uri text
-         unliftio yesod-core
-       ];
-       testHaskellDepends = [
-         aeson base bytestring hspec hspec-expectations-lifted
-         http-link-header http-types lens lens-aeson monad-logger mtl
-         persistent persistent-sqlite persistent-template scientific text
-         time unliftio unliftio-core wai-extra yesod yesod-core yesod-test
-       ];
-       license = lib.licenses.mit;
-     }) {};
-
-  "yesod-page-cursor_2_0_0_9" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, hspec
-     , hspec-expectations-lifted, http-link-header, http-types, lens
-     , lens-aeson, monad-logger, mtl, network-uri, persistent
-     , persistent-sqlite, persistent-template, scientific, text, time
-     , unliftio, unliftio-core, wai-extra, yesod, yesod-core, yesod-test
-     }:
-     mkDerivation {
-       pname = "yesod-page-cursor";
        version = "2.0.0.9";
        sha256 = "13wvivls1yqaanvkc9bpbiwx6qxa78ffgivm4qws4fyicqp628ak";
        libraryHaskellDepends = [
···
          time unliftio unliftio-core wai-extra yesod yesod-core yesod-test
        ];
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "yesod-paginate" = callPackage