haskellPackages: regenerate package set based on current config

This commit has been generated by maintainers/scripts/haskell/regenerate-hackage-packages.sh

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

···
        pname = "HStringTemplate";
        version = "0.8.7";
        sha256 = "03kbmyh0713j3qhhrl7jqbmsvyq1q82h2yxq45cc9rs55sma8kjg";
-       revision = "1";
-       editedCabalFile = "0s7y606q2q0vnbg9c51kypawyvapva60i2lw1dg1bij50aiv5d3i";
+       revision = "2";
+       editedCabalFile = "082d1lm6q1jb7rrl20jz0y4ca1qf87ihbq3v6mji9ibacl6adjaq";
+       libraryHaskellDepends = [
+         array base blaze-builder bytestring containers deepseq directory
+         filepath mtl old-locale parsec pretty semigroups syb
+         template-haskell text time void
+       ];
+       description = "StringTemplate implementation in Haskell";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "HStringTemplate_0_8_8" = callPackage
+    ({ mkDerivation, array, base, blaze-builder, bytestring, containers
+     , deepseq, directory, filepath, HUnit, mtl, old-locale, parsec
+     , pretty, QuickCheck, random, semigroups, syb, template-haskell
+     , text, time, void
+     }:
+     mkDerivation {
+       pname = "HStringTemplate";
+       version = "0.8.8";
+       sha256 = "1n8ci0kzjcgnqh4dfpqwlh7mnlzyiqiqc6hc0zr65p0balbg8zbi";
        libraryHaskellDepends = [
          array base blaze-builder bytestring containers deepseq directory
          filepath mtl old-locale parsec pretty semigroups syb
          template-haskell text time void
        ];
+       testHaskellDepends = [ base containers HUnit QuickCheck random ];
        description = "StringTemplate implementation in Haskell";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "HStringTemplateHelpers" = callPackage
···
      }:
      mkDerivation {
        pname = "Jikka";
-       version = "5.2.0.0";
-       sha256 = "0rg96x1y928dd8n2znddp8b2wgmpv6vdkm4s8xcr39rqw4jsqk0l";
+       version = "5.3.0.0";
+       sha256 = "0njy5mgzbpvqdqp343a7bh69sdrmvfd57skr3qwma7dya5m12v2r";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
     ({ mkDerivation, base, bytestring, transformers, vector, vulkan }:
      mkDerivation {
        pname = "VulkanMemoryAllocator";
-       version = "0.7";
-       sha256 = "0f7l91lds878s49yjq210sc49y6c6i3m3hys02902b64dqdgslpa";
+       version = "0.7.1";
+       sha256 = "1h9kz02s7ams9fw9x8k947nzji2b82s9xn2yvqzys14ypzc34qpn";
        libraryHaskellDepends = [
          base bytestring transformers vector vulkan
        ];
···
          inherit (pkgs.xorg) libXext; inherit (pkgs.xorg) libXinerama; 
          inherit (pkgs.xorg) libXrandr; inherit (pkgs.xorg) libXrender;};
 
+  "X11_1_10_1" = callPackage
+    ({ mkDerivation, base, data-default-class, libX11, libXext
+     , libXinerama, libXrandr, libXrender, libXScrnSaver
+     }:
+     mkDerivation {
+       pname = "X11";
+       version = "1.10.1";
+       sha256 = "13a0qf8rwn1s43wcl39f1pcq3h1kw1ddfq205j1ry0j3yafnazxg";
+       libraryHaskellDepends = [ base data-default-class ];
+       librarySystemDepends = [
+         libX11 libXext libXinerama libXrandr libXrender libXScrnSaver
+       ];
+       description = "A binding to the X11 graphics library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXScrnSaver; 
+         inherit (pkgs.xorg) libXext; inherit (pkgs.xorg) libXinerama; 
+         inherit (pkgs.xorg) libXrandr; inherit (pkgs.xorg) libXrender;};
+
   "X11-extras" = callPackage
     ({ mkDerivation, base, libX11, X11 }:
      mkDerivation {
···
        license = lib.licenses.mpl20;
      }) {};
 
+  "amazonka-contrib-rds-utils" = callPackage
+    ({ mkDerivation, amazonka, amazonka-core, amazonka-rds, base
+     , bytestring, lens, optparse-applicative, text, time
+     }:
+     mkDerivation {
+       pname = "amazonka-contrib-rds-utils";
+       version = "1.6.1.0";
+       sha256 = "1j43kn2ia8q6689p8g1b5q8pd8zcmhfjny8kydh3g5zf5360hnaz";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         amazonka amazonka-core amazonka-rds base bytestring lens text time
+       ];
+       executableHaskellDepends = [
+         amazonka base bytestring lens optparse-applicative text
+       ];
+       description = "A Haskell equivalent of \"aws rds generate-db-auth-token\"";
+       license = lib.licenses.mpl20;
+     }) {};
+
   "amazonka-core" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bifunctors, bytestring
      , case-insensitive, conduit, conduit-extra, cryptonite
···
      }) {};
 
   "assoc-list" = callPackage
-    ({ mkDerivation, base, contravariant, doctest, hedgehog }:
+    ({ mkDerivation, base, contravariant, hedgehog }:
      mkDerivation {
        pname = "assoc-list";
-       version = "0.1.0.0";
-       sha256 = "13n847aypm39djgpyrkr428y11xj7glpwavp5qxfd49n93ii8zy3";
+       version = "0.1.0.1";
+       sha256 = "1ggvws2ma9cn165h03dx0v0zd1aifhi5qx05lnymf9ca98pa7ls9";
        libraryHaskellDepends = [ base contravariant ];
-       testHaskellDepends = [ base contravariant doctest hedgehog ];
+       testHaskellDepends = [ base contravariant hedgehog ];
        description = "Association lists (lists of tuples)";
        license = lib.licenses.mit;
      }) {};
 
   "assoc-listlike" = callPackage
-    ({ mkDerivation, base, contravariant, doctest, hedgehog, ListLike
-     }:
+    ({ mkDerivation, base, contravariant, hedgehog, ListLike }:
      mkDerivation {
        pname = "assoc-listlike";
-       version = "0.1.0.0";
-       sha256 = "0nph5yvawxk1afnlqm0vizg8dv53wl1cziqqnnlqgv45yimp4fbz";
+       version = "0.1.0.1";
+       sha256 = "1jzv0x8397274ks8azm89xcca8i1h6rgi8drbp4nj05mxzvz6brv";
        libraryHaskellDepends = [ base contravariant ListLike ];
-       testHaskellDepends = [ base contravariant doctest hedgehog ];
+       testHaskellDepends = [ base contravariant hedgehog ListLike ];
        description = "Association lists (list-like collections of tuples)";
        license = lib.licenses.mit;
      }) {};
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "base64-bytestring_1_2_0_1" = callPackage
+  "base64-bytestring_1_2_1_0" = callPackage
     ({ mkDerivation, base, bytestring, criterion, deepseq, HUnit
      , QuickCheck, test-framework, test-framework-hunit
      , test-framework-quickcheck2
      }:
      mkDerivation {
        pname = "base64-bytestring";
-       version = "1.2.0.1";
-       sha256 = "0f66mzsyik3zrn72cygg8w3375qpvn3422z3j4fkkc9f0xyv22dg";
+       version = "1.2.1.0";
+       sha256 = "1ja9vkgnpkzaw8gz6sm5jmgha6wg3m1j281m0nv1w9yyxlqfvy7v";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [
          base bytestring HUnit QuickCheck test-framework
···
        license = lib.licenses.mit;
      }) {};
 
+  "both_0_1_1_2" = callPackage
+    ({ mkDerivation, base, semigroups, zero }:
+     mkDerivation {
+       pname = "both";
+       version = "0.1.1.2";
+       sha256 = "1bf9fvc2ajbwwx31lmmyc1rzp3xzypwb3yjcmbhn6si5xnlbvqhl";
+       libraryHaskellDepends = [ base semigroups zero ];
+       description = "Like Maybe, but with a different Monoid instance";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "botpp" = callPackage
     ({ mkDerivation, base, bytestring }:
      mkDerivation {
···
        license = lib.licenses.gpl3Only;
      }) {};
 
-  "byte-count-reader_0_10_1_4" = callPackage
+  "byte-count-reader_0_10_1_5" = callPackage
     ({ mkDerivation, base, extra, hspec, parsec, parsec-numbers, text
      }:
      mkDerivation {
        pname = "byte-count-reader";
-       version = "0.10.1.4";
-       sha256 = "1rscz0dqz8h4cazf1kb0w628a93ysphrih5x0yppvl3w0iy26sh0";
+       version = "0.10.1.5";
+       sha256 = "0iq40gnfw8z1rkri1rpaqx5av1ay45h6518cg0a0m4ypdzf03r0s";
        libraryHaskellDepends = [ base extra parsec parsec-numbers text ];
        testHaskellDepends = [
          base extra hspec parsec parsec-numbers text
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "cabal-clean" = callPackage
+    ({ mkDerivation, base, containers, directory, filepath, mtl
+     , optparse-applicative, pretty-terminal, process, split, string-qq
+     }:
+     mkDerivation {
+       pname = "cabal-clean";
+       version = "0.1.20210815";
+       sha256 = "0bx11grnw1x594n6si3lnswb87n2gsnn7fn7lr1ggn3rd0dm2ccg";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base containers directory filepath mtl optparse-applicative
+         pretty-terminal process split string-qq
+       ];
+       description = "Remove outdated cabal build artefacts from `dist-newstyle`";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "cabal-constraints" = callPackage
     ({ mkDerivation, base, Cabal, optparse-applicative }:
      mkDerivation {
···
        ];
        description = "RPM packaging tool for Haskell Cabal-based packages";
        license = lib.licenses.gpl3Only;
+     }) {};
+
+  "cabal-rpm_2_0_10" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, directory, extra
+     , filepath, http-client, http-client-tls, http-conduit
+     , optparse-applicative, process, simple-cabal, simple-cmd
+     , simple-cmd-args, time, unix
+     }:
+     mkDerivation {
+       pname = "cabal-rpm";
+       version = "2.0.10";
+       sha256 = "028kvvdm8dqjmk16ag8p1mb4d3nfyz1i6x8ijfcr45hrb93hdd77";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base bytestring Cabal directory extra filepath http-client
+         http-client-tls http-conduit optparse-applicative process
+         simple-cabal simple-cmd simple-cmd-args time unix
+       ];
+       description = "RPM packaging tool for Haskell Cabal-based packages";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "cabal-scripts" = callPackage
···
      }:
      mkDerivation {
        pname = "capnp";
-       version = "0.12.0.0";
-       sha256 = "0wv1rp511vzq7hkzcgcpa0jvc90bflysddz0s69dzl6llr71gb6x";
+       version = "0.14.0.0";
+       sha256 = "15v0s597wq0ipvikd727fzcqg5r6685lvr8y1x93q5mdl975gi8m";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd2;
      }) {};
 
-  "citeproc_0_4_1" = callPackage
+  "citeproc_0_5" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring
      , case-insensitive, containers, data-default, Diff, directory
      , file-embed, filepath, mtl, pandoc-types, pretty, safe, scientific
···
      }:
      mkDerivation {
        pname = "citeproc";
-       version = "0.4.1";
-       sha256 = "094x2fkhqizy26rzfz5qqjsnifmc95fyiasvnma32mak7j360xzy";
+       version = "0.5";
+       sha256 = "14l7gpa2phgmgcx2mdln1wf1gfqjmbkm5nyxnihrybmrkg9l8yfk";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "clash-ghc_1_4_3" = callPackage
+    ({ mkDerivation, array, base, bifunctors, bytestring, Cabal
+     , clash-lib, clash-prelude, concurrent-supply, containers, deepseq
+     , directory, exceptions, extra, filepath, ghc, ghc-boot, ghc-prim
+     , ghc-typelits-extra, ghc-typelits-knownnat
+     , ghc-typelits-natnormalise, ghci, hashable, haskeline, integer-gmp
+     , lens, mtl, primitive, process, reflection, split
+     , template-haskell, text, time, transformers, uniplate, unix
+     , unordered-containers, utf8-string, vector
+     }:
+     mkDerivation {
+       pname = "clash-ghc";
+       version = "1.4.3";
+       sha256 = "00ipx45s2qdjv5cj6v3cg7dgwsw3sd8ai3cr1q9n1k6g26dzc3pw";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         array base bifunctors bytestring Cabal clash-lib clash-prelude
+         concurrent-supply containers deepseq directory exceptions extra
+         filepath ghc ghc-boot ghc-prim ghc-typelits-extra
+         ghc-typelits-knownnat ghc-typelits-natnormalise ghci hashable
+         haskeline integer-gmp lens mtl primitive process reflection split
+         template-haskell text time transformers uniplate unix
+         unordered-containers utf8-string vector
+       ];
+       executableHaskellDepends = [ base ];
+       description = "Clash: a functional hardware description language - GHC frontend";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "clash-lib" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, array
      , attoparsec, base, base16-bytestring, binary, bytestring
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "clash-lib_1_4_3" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, array
+     , attoparsec, base, base16-bytestring, binary, bytestring
+     , clash-prelude, concurrent-supply, containers, cryptohash-sha256
+     , data-binary-ieee754, data-default, deepseq, directory, dlist
+     , errors, exceptions, extra, filepath, ghc, ghc-boot-th
+     , ghc-typelits-knownnat, hashable, haskell-src-exts
+     , haskell-src-meta, hint, integer-gmp, interpolate, lens, mtl
+     , ordered-containers, parsers, pretty-show, prettyprinter
+     , primitive, process, quickcheck-text, reducers, tasty, tasty-hunit
+     , tasty-quickcheck, template-haskell, temporary, terminal-size
+     , text, text-show, time, transformers, trifecta
+     , unordered-containers, utf8-string, vector
+     , vector-binary-instances
+     }:
+     mkDerivation {
+       pname = "clash-lib";
+       version = "1.4.3";
+       sha256 = "0p6sf9wn25i1f0isqskpy35x6qm2ym63x9fpb54kbd1pp9xqgysl";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson aeson-pretty ansi-terminal array attoparsec base
+         base16-bytestring binary bytestring clash-prelude concurrent-supply
+         containers cryptohash-sha256 data-binary-ieee754 data-default
+         deepseq directory dlist errors exceptions extra filepath ghc
+         ghc-boot-th hashable haskell-src-meta hint integer-gmp interpolate
+         lens mtl ordered-containers parsers pretty-show prettyprinter
+         primitive process reducers template-haskell temporary terminal-size
+         text text-show time transformers trifecta unordered-containers
+         utf8-string vector vector-binary-instances
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty base base16-bytestring bytestring clash-prelude
+         concurrent-supply containers data-default deepseq ghc
+         ghc-typelits-knownnat haskell-src-exts lens pretty-show
+         quickcheck-text tasty tasty-hunit tasty-quickcheck template-haskell
+         text transformers unordered-containers
+       ];
+       description = "Clash: a functional hardware description language - As a library";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "clash-multisignal" = callPackage
     ({ mkDerivation, base, clash-prelude, deepseq
      , ghc-typelits-knownnat, QuickCheck
···
        broken = true;
      }) {};
 
+  "clash-prelude_1_4_3" = callPackage
+    ({ mkDerivation, array, arrows, base, bifunctors, binary
+     , bytestring, Cabal, cabal-doctest, constraints, containers
+     , criterion, data-binary-ieee754, data-default-class, deepseq
+     , doctest, ghc-prim, ghc-typelits-extra, ghc-typelits-knownnat
+     , ghc-typelits-natnormalise, half, hashable, hedgehog, hint
+     , integer-gmp, interpolate, lens, QuickCheck
+     , quickcheck-classes-base, recursion-schemes, reflection
+     , singletons, tasty, tasty-hedgehog, tasty-hunit, tasty-quickcheck
+     , tasty-th, template-haskell, text, text-show, th-abstraction
+     , th-lift, th-orphans, time, transformers, type-errors, uniplate
+     , vector
+     }:
+     mkDerivation {
+       pname = "clash-prelude";
+       version = "1.4.3";
+       sha256 = "07mdl3196yb971hpcbysyaj6vciyrm1p5m9prcymkhkqh7vw9igy";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         array arrows base bifunctors binary bytestring constraints
+         containers data-binary-ieee754 data-default-class deepseq ghc-prim
+         ghc-typelits-extra ghc-typelits-knownnat ghc-typelits-natnormalise
+         half hashable integer-gmp interpolate lens QuickCheck
+         recursion-schemes reflection singletons template-haskell text
+         text-show th-abstraction th-lift th-orphans time transformers
+         type-errors uniplate vector
+       ];
+       testHaskellDepends = [
+         base deepseq doctest ghc-typelits-extra ghc-typelits-knownnat
+         ghc-typelits-natnormalise hedgehog hint quickcheck-classes-base
+         tasty tasty-hedgehog tasty-hunit tasty-quickcheck tasty-th
+         template-haskell
+       ];
+       benchmarkHaskellDepends = [
+         base criterion deepseq template-haskell
+       ];
+       description = "Clash: a functional hardware description language - Prelude library";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "clash-prelude-quickcheck" = callPackage
     ({ mkDerivation, base, clash-prelude, QuickCheck }:
      mkDerivation {
···
        license = lib.licenses.mpl20;
      }) {};
 
+  "co-log-concurrent_0_5_1_0" = callPackage
+    ({ mkDerivation, base, co-log-core, stm }:
+     mkDerivation {
+       pname = "co-log-concurrent";
+       version = "0.5.1.0";
+       sha256 = "07qmx9z03vmgq2cgz4352fsav7r1nx8n7svmrhg2lkdiyp0j7a59";
+       libraryHaskellDepends = [ base co-log-core stm ];
+       description = "Asynchronous backend for co-log library";
+       license = lib.licenses.mpl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "co-log-core" = callPackage
     ({ mkDerivation, base, doctest, Glob }:
      mkDerivation {
···
 
   "coinbase-pro" = callPackage
     ({ mkDerivation, aeson, aeson-casing, async, base, binary
-     , bytestring, containers, cryptonite, HsOpenSSL, http-api-data
-     , http-client, http-client-tls, http-streams, http-types
-     , io-streams, memory, network, servant, servant-client
+     , bytestring, containers, cryptonite, exceptions, HsOpenSSL
+     , http-api-data, http-client, http-client-tls, http-streams
+     , http-types, io-streams, memory, network, servant, servant-client
      , servant-client-core, text, time, transformers, unagi-streams
      , unordered-containers, uuid, vector, websockets, wuss
      }:
      mkDerivation {
        pname = "coinbase-pro";
-       version = "0.9.2.0";
-       sha256 = "0x7wmm123rf7zk9802bymx1b9pbsnmzhkabyacwini01gb56bwxy";
+       version = "0.9.2.2";
+       sha256 = "1jfmzzwjk81w5bm9v4zfan2w7qi2sl2a1py9nxisz1wq8vxdyvxn";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-casing async base binary bytestring containers
-         cryptonite HsOpenSSL http-api-data http-client http-client-tls
-         http-streams http-types io-streams memory network servant
-         servant-client servant-client-core text time transformers
+         cryptonite exceptions HsOpenSSL http-api-data http-client
+         http-client-tls http-streams http-types io-streams memory network
+         servant servant-client servant-client-core text time transformers
          unagi-streams unordered-containers uuid vector websockets wuss
        ];
        executableHaskellDepends = [
          aeson aeson-casing async base binary bytestring containers
-         cryptonite HsOpenSSL http-api-data http-client http-client-tls
-         http-streams http-types io-streams memory network servant
-         servant-client servant-client-core text time transformers
+         cryptonite exceptions HsOpenSSL http-api-data http-client
+         http-client-tls http-streams http-types io-streams memory network
+         servant servant-client servant-client-core text time transformers
          unagi-streams unordered-containers uuid vector websockets wuss
        ];
        description = "Client for Coinbase Pro";
···
        pname = "compdoc";
        version = "0.3.0.0";
        sha256 = "07gbs64r8qsxw4j0mlk7kldbdjjzz4v34pm8b5cj7a6r1l33w7k5";
-       revision = "3";
-       editedCabalFile = "1k9hahs857mg72krmhb0n1igfqy344pnlllbishrrj6hknc84xfq";
+       revision = "4";
+       editedCabalFile = "14p4gi1wyiwv738m505j6j2v8j2dimw1gp6qb7wfq4f8mf53lpll";
        libraryHaskellDepends = [
          aeson base composite-aeson composite-aeson-throw composite-base
          pandoc pandoc-throw path rio vinyl
···
        pname = "compdoc-dhall-decoder";
        version = "0.3.0.0";
        sha256 = "0qsq67zj8gr9xlgcbxgn5fi1cyv4qf7w5vzfl3v4hvil7xf3fn77";
+       revision = "1";
+       editedCabalFile = "0k08bcjjnvs54fjvxzy1hv7zp7z2n0iydsiix83x6a2jii7105v4";
        libraryHaskellDepends = [
          base compdoc composite-aeson composite-base dhall either pandoc
          text
···
 
   "composite-dhall" = callPackage
     ({ mkDerivation, base, composite-base, dhall, tasty, tasty-hunit
-     , text, vinyl
+     , text
      }:
      mkDerivation {
        pname = "composite-dhall";
-       version = "0.0.3.0";
-       sha256 = "1ynamdgamlri6ll0vh02kp4iy04vgsplsrda49by1b4vc9b4hcdz";
-       libraryHaskellDepends = [ base composite-base dhall text vinyl ];
+       version = "0.0.4.1";
+       sha256 = "19lhw02my7dv6gx2zlvmsbc2w4g09j1yxpwg6s203bd5n4dp5v9v";
+       libraryHaskellDepends = [ base composite-base dhall text ];
        testHaskellDepends = [
-         base composite-base dhall tasty tasty-hunit text vinyl
+         base composite-base dhall tasty tasty-hunit text
        ];
        description = "Dhall instances for composite records";
        license = lib.licenses.mit;
···
        pname = "composite-tuple";
        version = "0.1.2.0";
        sha256 = "0y5xz4q5z2lw3jy3fdm5rl19sd969cdpq1a44ar45dpab0qffr41";
+       revision = "1";
+       editedCabalFile = "0j7mj8g3v4x0vy4rbx00kxb7d41r3s3djbfin9f1h592ahyap1va";
        libraryHaskellDepends = [ base composite-base ];
        description = "Tuple functions for composite records";
        license = lib.licenses.mit;
···
        license = lib.licenses.mit;
      }) {};
 
+  "concurrency_1_11_0_2" = callPackage
+    ({ mkDerivation, array, atomic-primops, base, exceptions
+     , monad-control, mtl, stm, transformers
+     }:
+     mkDerivation {
+       pname = "concurrency";
+       version = "1.11.0.2";
+       sha256 = "0c7nq4d29s49a3h9wzjdi3idm6r68vxn6ybphsbrk2vmwqyfq36y";
+       libraryHaskellDepends = [
+         array atomic-primops base exceptions monad-control mtl stm
+         transformers
+       ];
+       description = "Typeclasses, functions, and data types for concurrency and STM";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "concurrency-benchmarks" = callPackage
     ({ mkDerivation, async, base, bench-graph, bytestring, Chart
      , Chart-diagrams, csv, deepseq, directory, gauge, getopt-generics
···
   "contiguous" = callPackage
     ({ mkDerivation, base, deepseq, primitive, primitive-unlifted
      , QuickCheck, quickcheck-classes, quickcheck-instances, random
-     , random-shuffle, vector, weigh
+     , random-shuffle, run-st, vector, weigh
      }:
      mkDerivation {
        pname = "contiguous";
-       version = "0.5.1";
-       sha256 = "1y02gqgd012zggs7kqxkky0prmbl0k9ji5ynb74i5mym88xrj67h";
+       version = "0.5.2";
+       sha256 = "04ylz0mld2yj0mdj88k38jw9330p88h0ga46p4wzlmazsy0p5s67";
        libraryHaskellDepends = [
-         base deepseq primitive primitive-unlifted
+         base deepseq primitive primitive-unlifted run-st
        ];
        testHaskellDepends = [
          base primitive QuickCheck quickcheck-classes quickcheck-instances
···
      }:
      mkDerivation {
        pname = "cursedcsv";
-       version = "0.1.3";
-       sha256 = "0q6pqsv0bvn30nlkfk285hilixa9hi3n3gzil0gb4gic2zpb55dk";
+       version = "0.1.4";
+       sha256 = "1zh71fcp2qp516lzvqc7n3yamg1lwbdjh74k5f3ni1j9ynz6zh28";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "curve25519";
-       version = "0.2.5";
-       sha256 = "1j2fc1wv6xx95sicx2m44dm41gdfspb74qmh58592pp5fcv54vbb";
+       version = "0.2.6";
+       sha256 = "11xrr8d4a8mwagqy8wfmja9aj875854bc0ns37x01wdcpwsr3s2h";
        libraryHaskellDepends = [ base bytestring crypto-api ];
        testHaskellDepends = [
          base bytestring crypto-api DRBG HUnit QuickCheck tagged
···
      }) {};
 
   "data-pdf-fieldreader" = callPackage
-    ({ mkDerivation, base, bytestring, containers, optparse-applicative
-     , text
+    ({ mkDerivation, base, bytestring, containers, megaparsec
+     , optparse-applicative, text
      }:
      mkDerivation {
        pname = "data-pdf-fieldreader";
-       version = "0.1.0.0";
-       sha256 = "1h57hva0dkhnshallf2yxwfmzfqzd6wm20cbxn8qm94jp95a627d";
+       version = "0.1.1.0";
+       sha256 = "0mcf676mgjgckzk97qi60z03530zk05mby73dxv7dnbdxw340zn7";
        isLibrary = true;
        isExecutable = true;
-       libraryHaskellDepends = [ base bytestring containers text ];
+       libraryHaskellDepends = [
+         base bytestring containers megaparsec text
+       ];
        executableHaskellDepends = [
          base bytestring containers optparse-applicative text
        ];
···
        license = lib.licenses.mit;
      }) {};
 
+  "dejafu_2_4_0_3" = callPackage
+    ({ mkDerivation, base, concurrency, containers, contravariant
+     , deepseq, exceptions, leancheck, profunctors, random, transformers
+     }:
+     mkDerivation {
+       pname = "dejafu";
+       version = "2.4.0.3";
+       sha256 = "1qzc8jbl6zwbncfmfmcwwmmhwzgbwc7wmnxxxa3mbcjbwhyibf92";
+       libraryHaskellDepends = [
+         base concurrency containers contravariant deepseq exceptions
+         leancheck profunctors random transformers
+       ];
+       description = "A library for unit-testing concurrent programs";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "deka" = callPackage
     ({ mkDerivation, base, bytestring, mpdec, parsec, transformers }:
      mkDerivation {
···
        pname = "diagrams-canvas";
        version = "1.4.1";
        sha256 = "1ihmv42412d8dk3s894zd70xd386wrk9ycxkid19barry1vz5plj";
+       revision = "1";
+       editedCabalFile = "12p6n6g4ab81b39d031vzwfj89qi5wm27srpyigf2v0zswppdyvn";
        libraryHaskellDepends = [
          base blank-canvas cmdargs containers data-default-class
          diagrams-core diagrams-lib lens mtl NumInstances
···
        pname = "diagrams-core";
        version = "1.5.0";
        sha256 = "0y3smp3hiyfdirdak3j4048cgqv7a5q9p2jb6z8na2llys5mrmdn";
+       revision = "1";
+       editedCabalFile = "1718pkifs74nq8bdwcm6firahy8riiinwarcxkk087brmm2rbfli";
        libraryHaskellDepends = [
          adjunctions base containers distributive dual-tree lens linear
          monoid-extras mtl profunctors semigroups unordered-containers
···
 
   "diagrams-haddock" = callPackage
     ({ mkDerivation, ansi-terminal, base, base64-bytestring, bytestring
-     , Cabal, cautious-file, cmdargs, containers, cpphs
-     , diagrams-builder, diagrams-lib, diagrams-svg, directory, filepath
-     , haskell-src-exts, lens, linear, mtl, parsec, QuickCheck, split
-     , strict, svg-builder, tasty, tasty-quickcheck, text, uniplate
+     , Cabal, cmdargs, containers, cpphs, diagrams-builder, diagrams-lib
+     , diagrams-svg, directory, filepath, haskell-src-exts, lens, linear
+     , mtl, parsec, QuickCheck, split, strict, svg-builder, tasty
+     , tasty-quickcheck, text, uniplate, unliftio
      }:
      mkDerivation {
        pname = "diagrams-haddock";
-       version = "0.4.0.3";
-       sha256 = "1kv1m9hg2npm2k11svh0c27xknvh2j7x662wcbnpxnc44cxlqyak";
+       version = "0.4.1";
+       sha256 = "0p978saxsfad6d8wkjnp6i300cf58ps02yw7a1zzhjfgk5ih2qlb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         ansi-terminal base base64-bytestring bytestring cautious-file
-         containers cpphs diagrams-builder diagrams-lib diagrams-svg
-         directory filepath haskell-src-exts lens linear mtl parsec split
-         strict svg-builder text uniplate
+         ansi-terminal base base64-bytestring bytestring containers cpphs
+         diagrams-builder diagrams-lib diagrams-svg directory filepath
+         haskell-src-exts lens linear mtl parsec split strict svg-builder
+         text uniplate unliftio
        ];
        executableHaskellDepends = [
          base Cabal cmdargs cpphs directory filepath
···
        pname = "diagrams-solve";
        version = "0.1.3";
        sha256 = "09qqwcvbvd3a0j5fnp40dbzw0i3py9c7kgizj2aawajwbyjvpd17";
+       revision = "1";
+       editedCabalFile = "0dp61igq17l7hvhs3167skdi1vmlm773qrrmsqmj08951l4cgv0h";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base deepseq tasty tasty-hunit tasty-quickcheck
···
        pname = "dual-tree";
        version = "0.2.3.0";
        sha256 = "0qyn7kb42wvlcvb1wbf1qx3isc2y6k3hzp5iq6ab0r0llw9g6qlg";
+       revision = "1";
+       editedCabalFile = "1babd7ybsgk73x57yl35q0n1i7mbbqmv4am710kq1hzg3in4g9dv";
        libraryHaskellDepends = [
          base monoid-extras newtype-generics semigroups
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "filepath-bytestring_1_4_2_1_8" = callPackage
+    ({ mkDerivation, base, bytestring, criterion, filepath, QuickCheck
+     , unix
+     }:
+     mkDerivation {
+       pname = "filepath-bytestring";
+       version = "1.4.2.1.8";
+       sha256 = "0qrrvbjpjsk75ghqrdqzwqg7wjgm3rr9kk7p04ax98ilv90pm0ip";
+       libraryHaskellDepends = [ base bytestring unix ];
+       testHaskellDepends = [ base bytestring filepath QuickCheck ];
+       benchmarkHaskellDepends = [ base criterion filepath ];
+       description = "Library for manipulating RawFilePaths in a cross platform way";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "filepath-crypto" = callPackage
     ({ mkDerivation, base, binary, bytestring, case-insensitive
      , cryptoids, cryptoids-class, cryptoids-types, exceptions, filepath
···
 
   "flatparse" = callPackage
     ({ mkDerivation, attoparsec, base, bytesmith, bytestring
-     , containers, gauge, megaparsec, parsec, primitive
+     , containers, gauge, integer-gmp, megaparsec, parsec, primitive
      , template-haskell
      }:
      mkDerivation {
        pname = "flatparse";
-       version = "0.2.1.0";
-       sha256 = "19vwh9fqda7fp7nv7sgxafvvc5kckaayizjw2vvmd634ka0bsyrr";
+       version = "0.2.2.0";
+       sha256 = "13cm882c2n0p52dwn802cqgfqrgkmlrb1kaxm2l89yfpb6wqynfz";
        libraryHaskellDepends = [
-         base bytestring containers template-haskell
+         base bytestring containers integer-gmp template-haskell
        ];
        benchmarkHaskellDepends = [
-         attoparsec base bytesmith bytestring gauge megaparsec parsec
-         primitive
+         attoparsec base bytesmith bytestring gauge integer-gmp megaparsec
+         parsec primitive
        ];
        description = "High-performance parsing from strict bytestrings";
        license = lib.licenses.mit;
···
 
   "futhark-data" = callPackage
     ({ mkDerivation, base, binary, bytestring, bytestring-to-vector
-     , containers, half, megaparsec, mtl, QuickCheck, tasty, tasty-hunit
-     , tasty-quickcheck, text, vector, vector-binary-instances
+     , containers, half, megaparsec, mtl, QuickCheck, scientific, tasty
+     , tasty-hunit, tasty-quickcheck, text, vector
+     , vector-binary-instances
      }:
      mkDerivation {
        pname = "futhark-data";
-       version = "1.0.1.1";
-       sha256 = "1rd3hrsr0zq6v5wwhgn5mam5262lmvihaa8g4pxnl47lh3hc8q5w";
+       version = "1.0.2.0";
+       sha256 = "1z5arzvd3n7cjmws2cwz7i8ji14xngrnza55781h06qh0pakg8dd";
        libraryHaskellDepends = [
          base binary bytestring bytestring-to-vector containers half
-         megaparsec mtl text vector vector-binary-instances
+         megaparsec mtl scientific text vector vector-binary-instances
        ];
        testHaskellDepends = [
          base binary bytestring megaparsec QuickCheck tasty tasty-hunit
···
     ({ mkDerivation, base, generics-sop }:
      mkDerivation {
        pname = "generic-match";
-       version = "0.3.0.0";
-       sha256 = "1h27gd7f0px3xgan9liqwav8xhl0smn6nhdmi7ggd18mjafa1ngv";
+       version = "0.3.0.1";
+       sha256 = "1qznsnb2d3dd9h5bdn54nkmqas4l4rsnp3fzj0bcpmbj3g245lc4";
        libraryHaskellDepends = [ base generics-sop ];
        description = "First class pattern matching";
        license = lib.licenses.mit;
···
      }) {};
 
   "geomancy" = callPackage
-    ({ mkDerivation, base, criterion, deepseq, hedgehog, linear }:
+    ({ mkDerivation, base, containers, criterion, deepseq, hedgehog
+     , linear
+     }:
      mkDerivation {
        pname = "geomancy";
-       version = "0.2.2.3";
-       sha256 = "17xg6cxyl83dxlb1yv85cnavw8cgqj3mbr1v9sa46fawb4mlv9i8";
-       revision = "1";
-       editedCabalFile = "06cfw1jf1380cxqc5ywj768svym7nm0rmrglhjkfz6p29arc6hwr";
-       libraryHaskellDepends = [ base deepseq ];
+       version = "0.2.2.4";
+       sha256 = "0vx2dz7fxd4hq50whsx0g6i3v1aidr7rpbylf169q1vshhrl8yaf";
+       libraryHaskellDepends = [ base containers deepseq ];
        testHaskellDepends = [ base deepseq hedgehog linear ];
        benchmarkHaskellDepends = [ base criterion deepseq linear ];
        description = "Geometry and matrix manipulation";
···
 
   "gf" = callPackage
     ({ mkDerivation, alex, array, base, bytestring, Cabal, cgi
-     , containers, directory, exceptions, filepath, happy, haskeline
-     , httpd-shed, json, mtl, network, network-uri, parallel, pretty
-     , process, random, terminfo, time, time-compat, unix, utf8-string
+     , containers, directory, exceptions, filepath, ghc-prim, happy
+     , haskeline, httpd-shed, json, mtl, network, network-uri, parallel
+     , pretty, process, random, terminfo, time, transformers-compat
+     , unix, utf8-string
      }:
      mkDerivation {
        pname = "gf";
-       version = "3.10";
-       sha256 = "1f0wwrhid0iqk2lmf9aprkzml8xpc3vsvvfpqfywf8qk8i76wwkv";
-       revision = "3";
-       editedCabalFile = "1c6gv692pz1xf41ajdji62xs41l8yy35nlcn6x7rs7symgx1v1bg";
+       version = "3.11";
+       sha256 = "18fx0kba86hyyimrahvgs7jsd5g718psis4drmxmxmx3bdvxj3bd";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        setupHaskellDepends = [ base Cabal directory filepath process ];
        libraryHaskellDepends = [
          array base bytestring cgi containers directory exceptions filepath
-         haskeline httpd-shed json mtl network network-uri parallel pretty
-         process random terminfo time time-compat unix utf8-string
+         ghc-prim haskeline httpd-shed json mtl network network-uri parallel
+         pretty process random terminfo time transformers-compat unix
+         utf8-string
        ];
        libraryToolDepends = [ alex happy ];
        executableHaskellDepends = [ base ];
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "ghc-api-compat" = callPackage
+  "ghc-api-compat_8_6" = callPackage
     ({ mkDerivation, ghc }:
      mkDerivation {
        pname = "ghc-api-compat";
···
        revision = "1";
        editedCabalFile = "01i6h8358n148nzjx6k774d2i2hm6dhgpx162ppkmwmim17f3zyn";
        libraryHaskellDepends = [ ghc ];
+       doHaddock = false;
+       description = "GHC-API compatibility helpers";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "ghc-api-compat" = callPackage
+    ({ mkDerivation, base, ghc }:
+     mkDerivation {
+       pname = "ghc-api-compat";
+       version = "8.10.5";
+       sha256 = "09g04k7zvzjs312yn9hhk8bk3l6k2vbb8qrdpnlr12a6az4adq3s";
+       libraryHaskellDepends = [ base ghc ];
        doHaddock = false;
        description = "GHC-API compatibility helpers";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, base, filepath, optparse-applicative, process }:
      mkDerivation {
        pname = "ghc-prof-flamegraph";
-       version = "0.2.0.0";
-       sha256 = "1jvn243v0fhckqk3yjw2qf3zj3smhk2wjxqbj389gpxh790183cd";
+       version = "0.2.0.1";
+       sha256 = "11d9p9rb4z2ysmx5z076vaw0hr5y0h7bszwwx24vylkfddawv7v5";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "ghci-dap";
-       version = "0.0.15.0";
-       sha256 = "1m4ypd2d9bjdkdqrnqijc1na5g14mmjrcr5msgr7spsnskhzi4yg";
+       version = "0.0.16.0";
+       sha256 = "1ywlk4bf7m868vvd07vmzpv7d7xmw9haa16p13rx3kdf5rqc7wcv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "ghcide";
        version = "1.4.0.3";
        sha256 = "1znf54l3g44cskx5blfaibf1frgyhy5z7906rdvyzb0dqfmkbzpw";
+       revision = "1";
+       editedCabalFile = "1qm3zj7c8qkc0ncm9bl57zj5nj7jm8c4lg2wzjrgmz3vvfmsd11c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        description = "Gio bindings";
        license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) glib;};
+
+  "gi-gio-hs-list-model" = callPackage
+    ({ mkDerivation, base, containers, gi-gio, gi-gobject
+     , haskell-gi-base
+     }:
+     mkDerivation {
+       pname = "gi-gio-hs-list-model";
+       version = "0.1.0.1";
+       sha256 = "03gyr2fj8jaqrb6r7j14ylw1za7aqdblw0aihp6nr9s8hvqr80c2";
+       libraryHaskellDepends = [
+         base containers gi-gio gi-gobject haskell-gi-base
+       ];
+       description = "Haskell implementation of GListModel interface from gi-gio";
+       license = lib.licenses.lgpl21Only;
+     }) {};
 
   "gi-girepository" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, gi-glib
···
      , hslogger, HStringTemplate, HTTP, http-client-tls, http-conduit
      , json, mtl, network, network-bsd, network-uri, old-locale
      , old-time, pandoc, pandoc-types, parsec, pretty, process, random
-     , recaptcha, safe, SHA, skylighting, split, syb, tagsoup, text
-     , time, uri-bytestring, url, utf8-string, uuid, xhtml, xml
+     , recaptcha, safe, SHA, skylighting, split, syb, tagsoup, temporary
+     , text, time, uri-bytestring, url, utf8-string, uuid, xhtml, xml
      , xml-conduit, xml-types, xss-sanitize, zlib
      }:
      mkDerivation {
        pname = "gitit";
-       version = "0.13.0.0";
-       sha256 = "1d9vfjhr38xxpm0fq0b6dy581a1qacqg643njp8z2fz37rma3z15";
+       version = "0.15.0.0";
+       sha256 = "05kz7dxmiabp0gkivn5ngmn3xah3h7a14a421qw6nx2ld1cr9vgf";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
          http-client-tls http-conduit json mtl network network-bsd
          network-uri old-locale old-time pandoc pandoc-types parsec pretty
          process random recaptcha safe SHA skylighting split syb tagsoup
-         text time uri-bytestring url utf8-string uuid xhtml xml xml-conduit
-         xml-types xss-sanitize zlib
+         temporary text time uri-bytestring url utf8-string uuid xhtml xml
+         xml-conduit xml-types xss-sanitize zlib
        ];
        executableHaskellDepends = [
          base bytestring directory filepath hslogger HTTP mtl network
···
      }:
      mkDerivation {
        pname = "haskell-debug-adapter";
-       version = "0.0.34.0";
-       sha256 = "00z9yhs2c34rdki404gcwf938a2lshr0a7mrvzpknk70n1a0gall";
+       version = "0.0.35.0";
+       sha256 = "1n8v7wgx5lqqw150lj9p8nzzxnmnjm2ksdvm7gcgb85shii7r2nf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "haskell-src";
        version = "1.0.3.1";
        sha256 = "0cjigvshk4b8wqdk0v0hz9ag1kyjjsmqsy4a1m3n28ac008cg746";
-       revision = "3";
-       editedCabalFile = "0hjridmgm95lrb9qs972zicipsqcfwpr35gwkzxncpgwcm0vn0b6";
+       revision = "4";
+       editedCabalFile = "0cyqdw77clzz7mq0b4c0jg2d1kdz9xii41268w2psmqmfpyn29pc";
        libraryHaskellDepends = [ array base pretty syb ];
        libraryToolDepends = [ happy ];
        description = "Support for manipulating Haskell source code";
···
   "hasklepias" = callPackage
     ({ mkDerivation, aeson, base, bytestring, cmdargs, co-log
      , containers, flow, ghc-prim, hspec, interval-algebra, lens
-     , lens-aeson, mtl, nonempty-containers, process, QuickCheck, safe
+     , lens-aeson, mtl, nonempty-containers, QuickCheck, safe
      , semiring-simple, tasty, tasty-hspec, tasty-hunit, text, time
      , unordered-containers, vector, witherable
      }:
      mkDerivation {
        pname = "hasklepias";
-       version = "0.13.1";
-       sha256 = "1fhlw490bwyblsgjrzgms4lzkv0zd8bhsvl2ywlpz0flhdd999zr";
+       version = "0.15.1";
+       sha256 = "00n9fan0g3xdl9k0f0rw32xgrwzxb8x85vrj98yyk1dk490pgfhm";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson base bytestring cmdargs co-log containers flow ghc-prim
-         interval-algebra lens lens-aeson mtl nonempty-containers process
-         QuickCheck safe semiring-simple tasty tasty-hunit text time
+         interval-algebra lens lens-aeson mtl nonempty-containers QuickCheck
+         safe semiring-simple tasty tasty-hunit text time
          unordered-containers vector witherable
        ];
        testHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "haskoin-node";
-       version = "0.17.12";
-       sha256 = "0jb1ypscy5hgvbw5jrd5qjl7mdi2qgc7h3amyi50zh2m3lhmgjnv";
+       version = "0.17.14";
+       sha256 = "0a8lmap19gj2f6xyzz7mk4jdb8rc8vvzrri4jsb10n8xl5g9c2jj";
        libraryHaskellDepends = [
          base bytestring cereal conduit conduit-extra containers
          data-default hashable haskoin-core monad-logger mtl network nqe
···
      }:
      mkDerivation {
        pname = "haskoin-store";
-       version = "0.53.8";
-       sha256 = "1djlq58v6wm3kr8jsvr612qxaxz1k03mfxvywd6ia45f761ry1ks";
+       version = "0.53.10";
+       sha256 = "0a20808l907wvgcdvbv7jvkpphpfj64x9cm7a07hpldsi2r3c26p";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "haskoin-store-data";
-       version = "0.53.8";
-       sha256 = "06q9h1n9c8gz6fycc8nsjxp98c98zin1f7y7qiyy80cddhcj1jzf";
+       version = "0.53.10";
+       sha256 = "0rnqa294j909s06nadg58vdblfvswb6si04m6gyf4k3ihmd1nj39";
        libraryHaskellDepends = [
          aeson base binary bytes bytestring cereal containers data-default
          deepseq hashable haskoin-core http-client http-types lens mtl
···
      }:
      mkDerivation {
        pname = "helf";
-       version = "0.2016.12.25";
-       sha256 = "03hslws4v8md2m89ppawh9gfqri7f2rjjiklgc5nvc8nfyxvg5kx";
+       version = "0.2021.8.12";
+       sha256 = "020ri4yjlascjmj4ywc2hji05673bszsb3q5frg1a66nbadzbi2h";
        revision = "1";
-       editedCabalFile = "11a3k59ig549dm3pg5wh2brrdiss1ln0yw3j0j4mgcvqi7kzzmd3";
+       editedCabalFile = "1573q8d39hgb4jq1bwpb7glxcv5bxv9vi27smhngk2wxxby9l4w3";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        ];
        executableToolDepends = [ alex happy ];
        description = "Typechecking terms of the Edinburgh Logical Framework (LF)";
-       license = "unknown";
-       hydraPlatforms = lib.platforms.none;
+       license = lib.licenses.mit;
      }) {};
 
   "helics" = callPackage
···
      }:
      mkDerivation {
        pname = "hevm";
-       version = "0.47.0";
-       sha256 = "1rhs3vyf7kwzlyyc0xjp696vh11wm3jz8k27w01blniris5kch9l";
+       version = "0.48.0";
+       sha256 = "12clxkhkap4j0xkn5s2i6cphkhri8vccalg92znlm5drjpbmf457";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         abstract-par aeson ansi-wl-pprint base base16-bytestring binary
-         brick bytestring cereal containers cryptonite data-dword Decimal
-         deepseq directory fgl filepath free haskeline here lens lens-aeson
-         megaparsec memory monad-par mtl multiset operational
+         abstract-par aeson ansi-wl-pprint async base base16-bytestring
+         binary brick bytestring cereal containers cryptonite data-dword
+         Decimal deepseq directory fgl filepath free haskeline here lens
+         lens-aeson megaparsec memory monad-par mtl multiset operational
          optparse-generic process QuickCheck quickcheck-text regex-tdfa
          restless-git rosezipper s-cargot sbv scientific semver-range
          temporary text text-format time transformers tree-view
···
          base base-compat containers ivory monadLib tasty tasty-hunit
          base base-compat containers ivory monadLib tasty tasty-hunit
          base base-compat containers ivory monadLib tasty tasty-hunit
+       revision = "1";
+       editedCabalFile = "1vyvnk64397kmlhflq1vp9rswhxbcywdw20738z3wq1pig2hqf7b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
+  "hledger-interest_1_6_2" = callPackage
+         base base-compat containers ivory monadLib tasty tasty-hunit
+     }:
+     mkDerivation {
+         base base-compat containers ivory monadLib tasty tasty-hunit
+       version = "1.6.2";
+       sha256 = "06gx19vld2lqq5w15hj7amcn1yi7rx8dxrb32hb05aari8b9qdzz";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base base-compat containers ivory monadLib tasty tasty-hunit
+       ];
+         base base-compat containers ivory monadLib tasty tasty-hunit
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ peti ];
+     }) {};
+
          base base-compat containers ivory monadLib tasty tasty-hunit
          base base-compat containers ivory monadLib tasty tasty-hunit
          base base-compat containers ivory monadLib tasty tasty-hunit
···
          base base-compat containers ivory monadLib tasty tasty-hunit
        version = "0.3.2.0";
          base base-compat containers ivory monadLib tasty tasty-hunit
-       revision = "1";
-         base base-compat containers ivory monadLib tasty tasty-hunit
+       revision = "2";
+       editedCabalFile = "15z6f2qqis3qi1cfq43hhcqgcsinx58ha3bghh0pfybqysvbjmmd";
        libraryHaskellDepends = [
          base base-compat containers ivory monadLib tasty tasty-hunit
          base base-compat containers ivory monadLib tasty tasty-hunit
···
          base base-compat containers ivory monadLib tasty tasty-hunit
        version = "1.1.0.2";
          base base-compat containers ivory monadLib tasty tasty-hunit
+       revision = "1";
+       editedCabalFile = "0pgicyph7zz2c7pbcair4wp4x5vvkmigbxxzrsxsgmvavki8r904";
        libraryHaskellDepends = [
          base base-compat containers ivory monadLib tasty tasty-hunit
          base base-compat containers ivory monadLib tasty tasty-hunit
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "hpack-dhall_0_5_3" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, Cabal
+     , dhall, dhall-json, Diff, directory, filepath, hlint, hpack
+     , megaparsec, microlens, optparse-applicative, prettyprinter, tasty
+     , tasty-golden, text, transformers, utf8-string, yaml
+     }:
+     mkDerivation {
+       pname = "hpack-dhall";
+       version = "0.5.3";
+       sha256 = "1prpk9lppz8h5bp6slhl7lm28jw6jf746py9vras0m0g6mrcc3l7";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson aeson-pretty base bytestring dhall dhall-json filepath hpack
+         megaparsec microlens prettyprinter text transformers yaml
+       ];
+       executableHaskellDepends = [
+         aeson aeson-pretty base bytestring dhall dhall-json filepath hpack
+         megaparsec microlens optparse-applicative prettyprinter text
+         transformers yaml
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty base bytestring Cabal dhall dhall-json Diff
+         directory filepath hlint hpack megaparsec microlens prettyprinter
+         tasty tasty-golden text transformers utf8-string yaml
+       ];
+       description = "hpack's dhalling";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hpaco" = callPackage
     ({ mkDerivation, aeson, base, cmdargs, filepath, hpaco-lib, strict
      , utf8-string, yaml
···
 
   "hpath-directory" = callPackage
     ({ mkDerivation, base, bytestring, exceptions, hpath-filepath
-     , hpath-posix, hspec, HUnit, IfElse, process, safe-exceptions
-     , streamly, streamly-bytestring, streamly-posix, time, transformers
-     , unix, unix-bytestring, utf8-string
+     , hpath-posix, hspec, hspec-discover, HUnit, IfElse, process
+     , safe-exceptions, streamly, streamly-bytestring, streamly-posix
+     , time, transformers, unix, unix-bytestring, utf8-string
      }:
      mkDerivation {
        pname = "hpath-directory";
-       version = "0.14.2";
-       sha256 = "04lkan37v8i1clw459csn8jvkzasz0p8ik8q8slqb9g3a5j68hjy";
+       version = "0.14.2.2";
+       sha256 = "0541pd1ac47wyxwz07yvk8yg1ldbfwzgfaq6rfl8pf182p607a6m";
        libraryHaskellDepends = [
          base bytestring exceptions hpath-filepath hpath-posix IfElse
          safe-exceptions streamly streamly-bytestring streamly-posix time
···
          base bytestring hpath-filepath hpath-posix hspec HUnit IfElse
          process time unix unix-bytestring utf8-string
        ];
+       testToolDepends = [ hspec-discover ];
        description = "Alternative to 'directory' package with ByteString based filepaths";
        license = lib.licenses.bsd3;
      }) {};
···
        license = lib.licenses.mit;
      }) {};
 
-  "hspec_2_8_2" = callPackage
+  "hspec_2_8_3" = callPackage
     ({ mkDerivation, base, hspec-core, hspec-discover
      , hspec-expectations, QuickCheck
      }:
      mkDerivation {
        pname = "hspec";
-       version = "2.8.2";
-       sha256 = "1s03c1928ndl8bqi3n9fb8a5adr0lycl9qs3x1i6aprzr851myh5";
+       version = "2.8.3";
+       sha256 = "1ryv1qad2rw40ak6n7agfd0sib1xk2iyqpz0qhgyxwp3kkjhrn49";
        libraryHaskellDepends = [
          base hspec-core hspec-discover hspec-expectations QuickCheck
        ];
···
        license = lib.licenses.mit;
      }) {};
 
-  "hspec-core_2_8_2" = callPackage
+  "hspec-core_2_8_3" = callPackage
     ({ mkDerivation, ansi-terminal, array, base, call-stack, clock
      , deepseq, directory, filepath, hspec-expectations, hspec-meta
      , HUnit, process, QuickCheck, quickcheck-io, random, setenv
···
      }:
      mkDerivation {
        pname = "hspec-core";
-       version = "2.8.2";
-       sha256 = "0id4c70hq46y2s623y4zsj9pycqp90a3ig991shrhxxd6836c4cx";
+       version = "2.8.3";
+       sha256 = "0khq0xa6agqcvbngzlxnvd9xwh7dmp4rsb2nzvfwsaknw2674i0k";
        libraryHaskellDepends = [
          ansi-terminal array base call-stack clock deepseq directory
          filepath hspec-expectations HUnit QuickCheck quickcheck-io random
···
        license = lib.licenses.mit;
      }) {};
 
-  "hspec-discover_2_8_2" = callPackage
-    ({ mkDerivation, base, directory, filepath, hspec-meta, QuickCheck
+  "hspec-discover_2_8_3" = callPackage
+    ({ mkDerivation, base, directory, filepath, hspec-meta, mockery
+     , QuickCheck
      }:
      mkDerivation {
        pname = "hspec-discover";
-       version = "2.8.2";
-       sha256 = "0bmdph9q4rg5rgr6s65h7si2l5rxyyqv80j5rri6zb4d1n9ih6hs";
+       version = "2.8.3";
+       sha256 = "09rjrq289si08cza48gcp29780rv21rs0b12xglkmbd6vfqzp6cs";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base directory filepath ];
        executableHaskellDepends = [ base directory filepath ];
        testHaskellDepends = [
-         base directory filepath hspec-meta QuickCheck
+         base directory filepath hspec-meta mockery QuickCheck
        ];
        testToolDepends = [ hspec-meta ];
        description = "Automatically discover and run Hspec tests";
···
        license = lib.licenses.mit;
      }) {};
 
+  "html-conduit_1_3_2_2" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, conduit
+     , conduit-extra, containers, deepseq, hspec, HUnit, resourcet, text
+     , transformers, xml-conduit, xml-types
+     }:
+     mkDerivation {
+       pname = "html-conduit";
+       version = "1.3.2.2";
+       sha256 = "09bwrdam3y47kqllgg6w098ghqb8jb10dp4wxirsvx5ddpx9zpi6";
+       libraryHaskellDepends = [
+         attoparsec base bytestring conduit conduit-extra containers
+         resourcet text transformers xml-conduit xml-types
+       ];
+       testHaskellDepends = [
+         base bytestring containers deepseq hspec HUnit text xml-conduit
+       ];
+       description = "Parse HTML documents using xml-conduit datatypes";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "html-email-validate" = callPackage
     ({ mkDerivation, attoparsec, base, criterion, hspec, QuickCheck
      , regex-pcre-builtin, text
···
        license = lib.licenses.mit;
      }) {};
 
+  "hunit-dejafu_2_0_0_5" = callPackage
+    ({ mkDerivation, base, dejafu, exceptions, HUnit }:
+     mkDerivation {
+       pname = "hunit-dejafu";
+       version = "2.0.0.5";
+       sha256 = "0pbsbj70a2m7zvk25wa8mi0ymxv4c49g2vgg8819wpjcrxw8sy64";
+       libraryHaskellDepends = [ base dejafu exceptions HUnit ];
+       description = "Deja Fu support for the HUnit test framework";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hunit-gui" = callPackage
     ({ mkDerivation, base, cairo, gtk, haskell98, HUnit }:
      mkDerivation {
···
     ({ mkDerivation, base, hvega, text }:
      mkDerivation {
        pname = "hvega-theme";
-       version = "0.2.0.4";
-       sha256 = "0g2h5is0gbr43fn8pbfj2nzh4wlgx6kjayq4lcnbr10z0j3vpqpv";
+       version = "0.2.0.5";
+       sha256 = "19pkrv92wr0bzalrzz15fmz74ylzcab8klqppnjzpdmym43zd0rm";
        libraryHaskellDepends = [ base hvega text ];
        description = "Theme for hvega";
        license = lib.licenses.gpl3Only;
···
      }:
      mkDerivation {
        pname = "interval-algebra";
-       version = "0.8.6";
-       sha256 = "1k9x1c7hrbrq6zgj82k8w28ak1jp1v9iq19bicl5355r4p2wiqsa";
+       version = "0.10.0";
+       sha256 = "1b1a78rssxaqiw42hbb1zqmlq4lmxkxxkhrm3ybqpmrqk492mckv";
        libraryHaskellDepends = [
          base containers foldl QuickCheck safe time witherable
        ];
···
        maintainers = with lib.maintainers; [ sternenseemann ];
      }) {};
 
+  "irc-client_1_1_2_2" = callPackage
+    ({ mkDerivation, base, bytestring, conduit, connection, containers
+     , contravariant, exceptions, irc-conduit, irc-ctcp, mtl
+     , network-conduit-tls, old-locale, profunctors, stm, stm-chans
+     , text, time, tls, transformers, x509, x509-store, x509-validation
+     }:
+     mkDerivation {
+       pname = "irc-client";
+       version = "1.1.2.2";
+       sha256 = "0hhaf7xhy3q48gkp2j01jjiiz0ww9mwwjh8brbqs8phlal03ks70";
+       libraryHaskellDepends = [
+         base bytestring conduit connection containers contravariant
+         exceptions irc-conduit irc-ctcp mtl network-conduit-tls old-locale
+         profunctors stm stm-chans text time tls transformers x509
+         x509-store x509-validation
+       ];
+       description = "An IRC client library";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ sternenseemann ];
+     }) {};
+
   "irc-colors" = callPackage
     ({ mkDerivation, base, text }:
      mkDerivation {
···
        license = lib.licenses.mit;
      }) {};
 
+  "irc-conduit_0_3_0_5" = callPackage
+    ({ mkDerivation, async, base, bytestring, conduit, conduit-extra
+     , connection, irc, irc-ctcp, network-conduit-tls, profunctors, text
+     , time, tls, transformers, x509-validation
+     }:
+     mkDerivation {
+       pname = "irc-conduit";
+       version = "0.3.0.5";
+       sha256 = "02ziqjzqdyaizhrrzlbq4ddkfjfjf58jvwqfzrbf0mf0f5scv9cz";
+       libraryHaskellDepends = [
+         async base bytestring conduit conduit-extra connection irc irc-ctcp
+         network-conduit-tls profunctors text time tls transformers
+         x509-validation
+       ];
+       description = "Streaming IRC message library using conduits";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "irc-core" = callPackage
     ({ mkDerivation, attoparsec, base, base64-bytestring, bytestring
      , hashable, HUnit, primitive, text, time, vector
···
        libraryHaskellDepends = [ base bytestring text ];
        description = "A CTCP encoding and decoding library for IRC clients";
        license = lib.licenses.mit;
+     }) {};
+
+  "irc-ctcp_0_1_3_1" = callPackage
+    ({ mkDerivation, base, bytestring, text }:
+     mkDerivation {
+       pname = "irc-ctcp";
+       version = "0.1.3.1";
+       sha256 = "1ckdbxnjv96bpyhcpdi0vj6pjjq8wm4zyh75fps57wi1j61c4v2n";
+       libraryHaskellDepends = [ base bytestring text ];
+       description = "A CTCP encoding and decoding library for IRC clients";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "irc-dcc" = callPackage
···
 
   "jenkinsPlugins2nix" = callPackage
     ({ mkDerivation, attoparsec, base, bimap, bytestring, containers
-     , cryptohash, hnix, http-conduit, mtl, optparse-applicative
+     , cryptonite, hnix, http-conduit, mtl, optparse-applicative
      , prettyprinter, prettyprinter-ansi-terminal, tasty-hspec, text
      , zip-archive
      }:
      mkDerivation {
        pname = "jenkinsPlugins2nix";
-       version = "0.4.0.0";
-       sha256 = "0s2k4irml4hahnv9qzsw1vvlqc651gmwgiscz97pcgb25v5slmcz";
+       version = "0.5.0.0";
+       sha256 = "15nalymjgvzsv6pyhy4fx70cdnffd1kamhl94w0xg0vrzrqq17rc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         attoparsec base bytestring containers cryptohash hnix http-conduit
+         attoparsec base bytestring containers cryptonite hnix http-conduit
          mtl prettyprinter text zip-archive
        ];
        executableHaskellDepends = [
···
        license = lib.licenses.asl20;
      }) {};
 
+  "jose_0_8_4_1" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
+     , bytestring, concise, containers, cryptonite, hspec, lens, memory
+     , monad-time, mtl, network-uri, pem, QuickCheck
+     , quickcheck-instances, safe, tasty, tasty-hspec, tasty-quickcheck
+     , template-haskell, text, time, unordered-containers, vector, x509
+     }:
+     mkDerivation {
+       pname = "jose";
+       version = "0.8.4.1";
+       sha256 = "0zwac71gqxf2wz840gfwnpv0ax7c4wpiwkcxqwcfil7fn4bqjlpw";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson attoparsec base base64-bytestring bytestring concise
+         containers cryptonite lens memory monad-time mtl network-uri
+         QuickCheck quickcheck-instances safe template-haskell text time
+         unordered-containers vector x509
+       ];
+       testHaskellDepends = [
+         aeson attoparsec base base64-bytestring bytestring concise
+         containers cryptonite hspec lens memory monad-time mtl network-uri
+         pem QuickCheck quickcheck-instances safe tasty tasty-hspec
+         tasty-quickcheck template-haskell text time unordered-containers
+         vector x509
+       ];
+       description = "Javascript Object Signing and Encryption and JSON Web Token library";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "jose-jwt" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, cereal
      , containers, criterion, cryptonite, hspec, HUnit, memory, mtl
···
      }:
      mkDerivation {
        pname = "lambdabot";
-       version = "5.3.0.1";
-       sha256 = "0jkp4qr2d37pd0nr074fzrvjn95jg7x7zjwnddsqw5m4m2l1iqsr";
+       version = "5.3.0.2";
+       sha256 = "0c5qwgzisvqxlyh378bbnabb9lbinknwvcf46sjpm6355krcw3g7";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        license = "GPL";
      }) {};
 
+  "lambdabot-core_5_3_0_2" = callPackage
+    ({ mkDerivation, base, binary, bytestring, containers
+     , dependent-map, dependent-sum, dependent-sum-template, directory
+     , edit-distance, exceptions, filepath, haskeline, hslogger, HTTP
+     , lifted-base, monad-control, mtl, network, network-bsd, parsec
+     , prim-uniq, random, random-fu, random-source, regex-tdfa
+     , SafeSemaphore, split, syb, template-haskell, time, transformers
+     , transformers-base, unix, utf8-string, zlib
+     }:
+     mkDerivation {
+       pname = "lambdabot-core";
+       version = "5.3.0.2";
+       sha256 = "1i375kiw98j5gd4pixh59lcqk0lakwmrgxzpkr0431a48kxffq7r";
+       libraryHaskellDepends = [
+         base binary bytestring containers dependent-map dependent-sum
+         dependent-sum-template directory edit-distance exceptions filepath
+         haskeline hslogger HTTP lifted-base monad-control mtl network
+         network-bsd parsec prim-uniq random random-fu random-source
+         regex-tdfa SafeSemaphore split syb template-haskell time
+         transformers transformers-base unix utf8-string zlib
+       ];
+       description = "Lambdabot core functionality";
+       license = "GPL";
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "lambdabot-haskell-plugins" = callPackage
     ({ mkDerivation, array, arrows, base, bytestring, containers
      , data-memocombinators, directory, filepath
···
      }:
      mkDerivation {
        pname = "lambdabot-haskell-plugins";
-       version = "5.3";
-       sha256 = "1vlyjkz0dammzf5v8i9sfyswbnpfv0vpwpxybc1dhzm1qv04vbwh";
+       version = "5.3.0.2";
+       sha256 = "1h2f86dw3356n66n1nfcqi5hsnj6kvlc1px8s4nrw3zvjlkangzq";
        libraryHaskellDepends = [
          array arrows base bytestring containers data-memocombinators
          directory filepath haskell-src-exts-simple hoogle HTTP IOSpec
···
      }:
      mkDerivation {
        pname = "lambdabot-irc-plugins";
-       version = "5.3";
-       sha256 = "0dm5bsr8hly43hzfja8h6i3n3jai38ln9629p4dlsr8s1himcjbm";
+       version = "5.3.0.2";
+       sha256 = "1pwl77dh474sqvhd4nfqcqvzicz36xww13sw49qs5wd2fkp50zqi";
        libraryHaskellDepends = [
          base bytestring containers directory filepath lambdabot-core
          lifted-base mtl network SafeSemaphore split time
···
      }:
      mkDerivation {
        pname = "lambdabot-misc-plugins";
-       version = "5.3";
-       sha256 = "03cj8bzmg7q6b66mblmxv39aw5jd586w1w90zyl632rff4j5f0bh";
+       version = "5.3.0.2";
+       sha256 = "0m2rarvcmmas78ghzvzjf1flicj2sf4d14i7y5cxfpc5l3zcyqwq";
        libraryHaskellDepends = [
          base bytestring containers filepath lambdabot-core lifted-base mtl
          network network-uri parsec process random random-fu random-source
···
      }:
      mkDerivation {
        pname = "lambdabot-novelty-plugins";
-       version = "5.3";
-       sha256 = "0f7frjj41wpkhzvzi2xz7hsv8cr0fg653iqf8gqxlprk4k1sag5n";
+       version = "5.3.0.2";
+       sha256 = "09rqshkh1k7536b9zw4rga370l35v47vf28xdlnrh7knwh88yr70";
        libraryHaskellDepends = [
          base binary brainfuck bytestring containers dice directory
          lambdabot-core misfortune process random-fu regex-tdfa unlambda
···
      }:
      mkDerivation {
        pname = "lambdabot-reference-plugins";
-       version = "5.3";
-       sha256 = "0xg8cpd25d01a35y2qmrhp402iphhdjb8sld5lnwc8rzyn6nd7gb";
+       version = "5.3.0.2";
+       sha256 = "1n9r29gmllmad2nr83gnbafka7gp99qji1pj0hhcr7gb31asz2xl";
        libraryHaskellDepends = [
          base bytestring containers HTTP lambdabot-core mtl network
          network-uri oeis process regex-tdfa split tagsoup utf8-string
···
      }:
      mkDerivation {
        pname = "lambdabot-social-plugins";
-       version = "5.3";
-       sha256 = "0gncll1z2x26v4g874vbwpg8yh9kang6wcvb4ywmfmlrs7kqw9fn";
+       version = "5.3.0.2";
+       sha256 = "10yl1z562cnnx0ml343c7psaw5zsil66zrbsgvij6cy2b2p2d3m2";
        libraryHaskellDepends = [
          base binary bytestring containers lambdabot-core mtl split time
        ];
···
     ({ mkDerivation, base, oeis, QuickCheck, QuickCheck-safe }:
      mkDerivation {
        pname = "lambdabot-trusted";
-       version = "5.3";
-       sha256 = "0847bxdnwh15szrhjb42y9nrb6qbaq6qyylwbmk1hkavp1baw77b";
+       version = "5.3.0.2";
+       sha256 = "1mwgamd75llraiafk7s43j6qz495j96s1dprckrisww37gv3nn8d";
        libraryHaskellDepends = [ base oeis QuickCheck QuickCheck-safe ];
        description = "Lambdabot trusted code";
        license = "GPL";
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "lapack-hmatrix" = callPackage
+    ({ mkDerivation, base, comfort-array, hmatrix, lapack, netlib-ffi
+     , transformers, utility-ht, vector
+     }:
+     mkDerivation {
+       pname = "lapack-hmatrix";
+       version = "0.0";
+       sha256 = "024lfbj5v4rgxvfs4cgfr6xajf3svdlxv7sl9wkyzwi7dk1zh9pr";
+       libraryHaskellDepends = [
+         base comfort-array hmatrix lapack netlib-ffi transformers
+         utility-ht vector
+       ];
+       description = "Conversion of objects between 'lapack' and 'hmatrix'";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "large-hashable" = callPackage
     ({ mkDerivation, aeson, base, base16-bytestring, byteable, bytes
      , bytestring, cereal, containers, cryptohash, deepseq, hashable
···
      }:
      mkDerivation {
        pname = "lti13";
-       version = "0.2.0.2";
-       sha256 = "1a8ag4ny61rjyy15fa4mihrgqkinipzj5cvpasscl9yw8jik9s1i";
+       version = "0.2.0.3";
+       sha256 = "1ls1hfyivmx5yi9i15m95j9j12agyrmfiwza3w9dfa23c210fcxh";
        libraryHaskellDepends = [
          aeson base bytestring containers http-client http-types jose-jwt
          oidc-client safe-exceptions text
···
      }:
      mkDerivation {
        pname = "monomer";
-       version = "1.0.0.0";
-       sha256 = "136ja518hybhdl336772pyl5gfpvq7bzbm4gka53fmw3f42a1gkw";
+       version = "1.0.0.1";
+       sha256 = "1ns4zm1vny8r49k0iq77b75s17gqmzxjv3kj70a4k5j4jx5s70fr";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "mwc-random_0_15_0_2" = callPackage
+    ({ mkDerivation, base, bytestring, doctest, gauge, math-functions
+     , mersenne-random, primitive, QuickCheck, random, tasty
+     , tasty-hunit, tasty-quickcheck, time, vector
+     }:
+     mkDerivation {
+       pname = "mwc-random";
+       version = "0.15.0.2";
+       sha256 = "0ny2mw4am24d6ykrm8rbcjnrq6p2cjmzjb4m6qfk54wfdxflvmim";
+       libraryHaskellDepends = [
+         base math-functions primitive random time vector
+       ];
+       testHaskellDepends = [
+         base bytestring doctest primitive QuickCheck random tasty
+         tasty-hunit tasty-quickcheck vector
+       ];
+       benchmarkHaskellDepends = [
+         base gauge mersenne-random random vector
+       ];
+       doCheck = false;
+       description = "Fast, high quality pseudo random number generation";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "mwc-random-accelerate" = callPackage
     ({ mkDerivation, accelerate, base, mwc-random }:
      mkDerivation {
···
      }) {};
 
   "nanovg" = callPackage
-    ({ mkDerivation, base, bytestring, c2hs, containers, GLEW, glew
-     , hspec, inline-c, libGL, libGLU, QuickCheck, text, vector
+    ({ mkDerivation, base, bytestring, c2hs, containers, freetype, GLEW
+     , glew, hspec, inline-c, libGL, libGLU, libX11, QuickCheck, text
+     , vector
      }:
      mkDerivation {
        pname = "nanovg";
-       version = "0.6.0.0";
-       sha256 = "15nljmlcgj1pw9ydy3a9nmk6zpgfp3p71arw04b1krx2y9r2fnp3";
-       revision = "1";
-       editedCabalFile = "1lhfsq50r9bdby7mfscw8ih3wsz2m19lr2a2z9b6diaf5kz76vij";
+       version = "0.7.0.0";
+       sha256 = "1mrn5dy05nl5kkxw5vfgf57wifllq7jnv0akd1wi9wnlgvvqjnqz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring containers text vector ];
-       librarySystemDepends = [ GLEW libGL libGLU ];
+       librarySystemDepends = [ freetype GLEW libGL libGLU libX11 ];
        libraryPkgconfigDepends = [ glew ];
        libraryToolDepends = [ c2hs ];
        testHaskellDepends = [ base containers hspec inline-c QuickCheck ];
···
        license = lib.licenses.isc;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {GLEW = null; inherit (pkgs) glew; inherit (pkgs) libGL; 
-         inherit (pkgs) libGLU;};
+     }) {GLEW = null; inherit (pkgs) freetype; inherit (pkgs) glew; 
+         inherit (pkgs) libGL; inherit (pkgs) libGLU; 
+         inherit (pkgs.xorg) libX11;};
 
   "nanovg-simple" = callPackage
     ({ mkDerivation, base, GLFW-b, monad-loops, nanovg, OpenGL
···
        pname = "optparse-generic";
        version = "1.4.4";
        sha256 = "0xy0kc8qximsiqpnc1fmh5zlsh6n26s7scrixin5bwnylg056j74";
-       revision = "2";
-       editedCabalFile = "172x8990wx4jhyb7yp9k18nd6q4sis8km09x2afr238siqviclrc";
+       revision = "3";
+       editedCabalFile = "1y5m84d72z2fhnzznlyq4hj4hfg04hgszng3ps4dz4s1wd565m1s";
        libraryHaskellDepends = [
          base bytestring Only optparse-applicative system-filepath text time
          transformers void
···
        pname = "palette";
        version = "0.3.0.2";
        sha256 = "0820n3cj4zy9s46diln2rrs4lrxbipkhdw74p2w42gc7k1nlj54i";
-       revision = "1";
-       editedCabalFile = "0x536r15zzxlkf5p5a2x64qr5szdf9yh04vaiiwfhsm232qb6fjq";
+       revision = "2";
+       editedCabalFile = "134w4bm1p6piyx594dx4hncf3adycqld4935bs2wbrq634w7ngxg";
        libraryHaskellDepends = [
          array base colour containers MonadRandom
        ];
···
      }:
      mkDerivation {
        pname = "parsley";
-       version = "1.0.0.1";
-       sha256 = "0z4w6hwa0yj34xsqp63kqy3wkk51k343fv8ijbk0s4w4hdx7d7jb";
-       revision = "1";
-       editedCabalFile = "0bv13k090bn5jy1qi3palrp7sri1xbd6xvh7ymhd9l0431yfzadv";
+       version = "1.0.0.2";
+       sha256 = "06rc8zcgp5zyvf17pgzf1nqlc3avdl8rmbwabkggk4v4x9rxwkjx";
        libraryHaskellDepends = [
          base parsley-core template-haskell text
        ];
        testHaskellDepends = [
-         base deepseq parsley-garnish tasty tasty-hunit tasty-quickcheck
-         template-haskell th-test-utils
+         base deepseq parsley-core parsley-garnish tasty tasty-hunit
+         tasty-quickcheck template-haskell th-test-utils
        ];
        benchmarkHaskellDepends = [
          array attoparsec base bytestring containers criterion deepseq
···
   "parsley-core" = callPackage
     ({ mkDerivation, array, base, bytestring, containers, cpphs
      , dependent-map, dependent-sum, ghc-prim, hashable, mtl
-     , pretty-terminal, template-haskell, text, unordered-containers
+     , pretty-terminal, tasty, tasty-hunit, tasty-quickcheck
+     , template-haskell, text, unordered-containers
      }:
      mkDerivation {
        pname = "parsley-core";
-       version = "1.4.0.0";
-       sha256 = "1w9pilgaajaycxr0nvjwdzk5fjf7pg4spnwh2197gbpqhbkj75q3";
+       version = "1.6.0.0";
+       sha256 = "1hjsnwh3gxwk1jmc0xylvjpsa3shzvjb5sn1imypgnnb887iabv6";
        libraryHaskellDepends = [
          array base bytestring containers dependent-map dependent-sum
          ghc-prim hashable mtl pretty-terminal template-haskell text
          unordered-containers
        ];
        libraryToolDepends = [ cpphs ];
+       testHaskellDepends = [
+         base containers tasty tasty-hunit tasty-quickcheck
+       ];
        description = "A fast parser combinator library backed by Typed Template Haskell";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "phonetic-languages-rhythmicity";
-       version = "0.6.0.1";
-       sha256 = "0rhn5xsqy4b330y17saa78v72dc7lq24y2k5p5r3xfbw621plwba";
+       version = "0.9.0.0";
+       sha256 = "1xymd8r5lp4jn0qb4p1dyzbhdyb3nsnvphx7f9nvf46kjbz18670";
        libraryHaskellDepends = [ base ];
        description = "Allows to estimate the rhythmicity properties for the text";
        license = lib.licenses.mit;
···
      , phonetic-languages-simplified-base
      , phonetic-languages-simplified-examples-common
      , phonetic-languages-simplified-properties-array
-     , phonetic-languages-ukrainian-array, subG
+     , phonetic-languages-ukrainian-array, string-interpreter, subG
      , ukrainian-phonetics-basic-array, uniqueness-periods-vector-stats
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-examples-array";
-       version = "0.7.0.0";
-       sha256 = "13v2wizjrnpwi7x42c9aqgsa5yr2x3blpmyqv9jkqxx7ksx0fbfg";
+       version = "0.10.0.0";
+       sha256 = "0m7p4iddilaf0v81kjya41m6rczplhw8cl3gq4axwq5lw0x5nppf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          phonetic-languages-rhythmicity phonetic-languages-simplified-base
          phonetic-languages-simplified-examples-common
          phonetic-languages-simplified-properties-array
-         phonetic-languages-ukrainian-array subG
+         phonetic-languages-ukrainian-array string-interpreter subG
          ukrainian-phonetics-basic-array uniqueness-periods-vector-stats
        ];
        executableHaskellDepends = [
···
          phonetic-languages-rhythmicity phonetic-languages-simplified-base
          phonetic-languages-simplified-examples-common
          phonetic-languages-simplified-properties-array
-         phonetic-languages-ukrainian-array subG
+         phonetic-languages-ukrainian-array string-interpreter subG
          ukrainian-phonetics-basic-array uniqueness-periods-vector-stats
        ];
        description = "Helps to create Ukrainian texts with the given phonetic properties";
···
      , phonetic-languages-simplified-base
      , phonetic-languages-simplified-generalized-examples-common
      , phonetic-languages-simplified-generalized-properties-array
-     , process, subG
+     , process, string-interpreter, subG
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-generalized-examples-array";
-       version = "0.7.0.0";
-       sha256 = "1qy4j61mkrkpa5451bzqg92jcbr77djn1jpvdd008pmvzijhnwqr";
+       version = "0.10.0.0";
+       sha256 = "169ln5g5gz4lshsk2qfmj6h25x3xch0ar4mm0i9wn07wa7g1yyvj";
        libraryHaskellDepends = [
          base heaps mmsyn2-array mmsyn3 parallel
          phonetic-languages-constraints-array
···
          phonetic-languages-simplified-base
          phonetic-languages-simplified-generalized-examples-common
          phonetic-languages-simplified-generalized-properties-array process
-         subG
+         string-interpreter subG
        ];
        description = "Helps to create texts with the given phonetic properties (e. g. poetic).";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-generalized-properties-array";
-       version = "0.5.0.0";
-       sha256 = "0hxlii3d522ikh6czh720p1x97ixjh3b4s16zr6a2vk3h6pkvqw4";
+       version = "0.8.0.0";
+       sha256 = "0fi76agkx6i55121pcj3wxrfw4ymqyqb5l8sa8vm78nvx5r54nsd";
        libraryHaskellDepends = [
          base phonetic-languages-phonetics-basics
          phonetic-languages-rhythmicity phonetic-languages-simplified-base
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-properties-array";
-       version = "0.5.0.0";
-       sha256 = "1zv3ax3idvlhvaspmsalrrw1816rf3w1sza3yscdv221yn1783g7";
+       version = "0.8.0.0";
+       sha256 = "1h32g5cqib72j2ib26ch6b1r50j506arx0pz6zfxl968095vmcan";
        libraryHaskellDepends = [
          base phonetic-languages-rhythmicity
          phonetic-languages-simplified-base ukrainian-phonetics-basic-array
···
        pname = "polysemy-methodology";
        version = "0.2.1.0";
        sha256 = "17md6l5smy1ssn99kij6rnb42bx3fx8h49z85cm9sf41k6lb5k1g";
-       revision = "1";
-       editedCabalFile = "1sn9447cxpxmw1jkijbv2039xv3ya08mdgd7kmrwp8ljzj1922ni";
+       revision = "2";
+       editedCabalFile = "0dpancn85f8j3pxhk43lik6fbznp502cc68rkhqkan791kh1bbc7";
        libraryHaskellDepends = [
          base polysemy polysemy-kvstore polysemy-several
        ];
···
        pname = "polysemy-methodology-composite";
        version = "0.1.4.0";
        sha256 = "014kfaxxi24n99gvrvf9c6c8cx8csbb9a8fbfb2md5g2d2q4v08g";
-       revision = "1";
-       editedCabalFile = "1vf5l2c3k370x0rl4js2hfrc0z434zzkgbkgnhjixbkbqcq2ig2p";
+       revision = "2";
+       editedCabalFile = "0sz200c83xjj22ifx9babvps0cnqk9gz42h081m5wb6s1w58dnib";
        libraryHaskellDepends = [
          base composite-base polysemy polysemy-extra polysemy-methodology
          polysemy-vinyl vinyl
···
        pname = "polysemy-several";
        version = "0.1.0.0";
        sha256 = "1mw6a6fz3879yqnpq6h0221i8b8f05j90b1zydhzr57nsbklxzps";
-       revision = "1";
-       editedCabalFile = "0d0632ayig8f66604ncad7y4gjlxsss9awlscxd5hsa2r49l4m7q";
+       revision = "3";
+       editedCabalFile = "0ig9jqrv9dqasgjhshapcxjqp4vdpl1p09q0fy34847vchg5jgpb";
        libraryHaskellDepends = [ base polysemy ];
        description = "Run several effects at once, taken from the polysemy-zoo";
        license = lib.licenses.mit;
···
        pname = "polysemy-video";
        version = "0.2.0.1";
        sha256 = "1lbjjq6q3i6v41ssqy69p4iwvybidrmxcxwjzddbxcrmymr0rmlc";
-       revision = "1";
-       editedCabalFile = "0bz6zb6zn1q4swj2szzrjakjm8qfmzasin6fgpz01g5m2payfc3c";
+       revision = "2";
+       editedCabalFile = "1jjwn6ysygc3dz963zqhlmcqvhv79ll7kp6mbpm73fhad4jbrfvs";
        libraryHaskellDepends = [
          base formatting path path-formatting polysemy
          simple-media-timestamp simple-media-timestamp-formatting text
···
      }:
      mkDerivation {
        pname = "quickcheck-state-machine";
-       version = "0.7.0";
-       sha256 = "053fc1hxkpfpmwn5dq5x5vd094g978hwc145qpzknwbk6hrc28ka";
+       version = "0.7.1";
+       sha256 = "0s6j3y0fkbbhmid0skqxx2m3mpbphz6npw9fvim5kx7w4i6jrvfz";
        libraryHaskellDepends = [
          ansi-wl-pprint base containers directory exceptions filepath
          generic-data graphviz markov-chain-usage-model matrix mtl
···
        broken = true;
      }) {};
 
+  "rattletrap_11_2_1" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, array, base, bytestring
+     , containers, filepath, http-client, http-client-tls, HUnit, text
+     }:
+     mkDerivation {
+       pname = "rattletrap";
+       version = "11.2.1";
+       sha256 = "0kmr3178rilifbqs2zkifx47fdq279n4wzxbcr6kn71450xi5xyx";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson aeson-pretty array base bytestring containers filepath
+         http-client http-client-tls text
+       ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [ base bytestring filepath HUnit ];
+       description = "Parse and generate Rocket League replays";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "raven-haskell" = callPackage
     ({ mkDerivation, aeson, base, bytestring, hspec, http-conduit, mtl
      , network, random, resourcet, text, time, unordered-containers
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "realworldhaskell";
-       version = "0.0.1.0";
-       sha256 = "0695y4af42vm50njpldx3i03ia4bws0lx3yhw6p2rv032jhmp5w6";
+       version = "0.0.1.1";
+       sha256 = "1gys7lcpl50nza5jgbmacw7n42c6s4f0jk7ga351w1g4z4ysrblg";
        libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base ];
        description = "The Real World Haskell Book";
        license = lib.licenses.publicDomain;
      }) {};
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "record-operations" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "record-operations";
+       version = "0.0.1";
+       sha256 = "07wasqlzl1flrm16429mg5wcryd3p1sj1w7q8h59y31rm2ap643j";
+       libraryHaskellDepends = [ base ];
+       description = "polymorphic record operations";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "record-preprocessor" = callPackage
     ({ mkDerivation, base, base-prelude, basic-lens, conversion
      , conversion-text, record, record-syntax, text
···
        pname = "regex-base";
        version = "0.94.0.1";
        sha256 = "1ngdmmrxs1rhvib052c6shfa40yad82jylylikz327r0zxpxkcbi";
+       revision = "1";
+       editedCabalFile = "19rzll80mpr4licfzz6qfy4i9xbmhxy4r7n1d523db73q09jvzrm";
        libraryHaskellDepends = [
          array base bytestring containers mtl text
        ];
···
        pname = "regex-compat";
        version = "0.95.2.1";
        sha256 = "0ivrdrcphrz3g6nr5wbsmfiv8i82caw0kf6z5qlmlq7xf9n3hywg";
+       revision = "1";
+       editedCabalFile = "1r9gvk0lifppydlns81zh8052941saaaahydvbcgnrz0jwn1di9j";
        libraryHaskellDepends = [ array base regex-base regex-posix ];
        description = "Replaces/enhances \"Text.Regex\"";
        license = lib.licenses.bsd3;
···
        pname = "regex-pcre";
        version = "0.95.0.0";
        sha256 = "0nn76q4bsjnxim0j0d01jifmh36as9jdpcvm001a851vvq86zb8n";
-       revision = "2";
-       editedCabalFile = "0bvpy3rswyawv23s14nbxvgz5761s61g0shcj7p032i95iq7dj6d";
+       revision = "3";
+       editedCabalFile = "1mxy2y7dmv37hhsasm17x2mb9dhmzza13pc7jfrk77inpig78ib8";
        libraryHaskellDepends = [
          array base bytestring containers regex-base
        ];
···
        pname = "regex-tdfa";
        version = "1.3.1.1";
        sha256 = "1msrq31k4jmn2lmrdzn87jqarqhw265ca69rfg5jpa5adrzm3gmi";
+       revision = "1";
+       editedCabalFile = "02gwf740vs0jy3l6dgw72r8c04yggshia6w16n140ncpsici8c4r";
        libraryHaskellDepends = [
          array base bytestring containers mtl parsec regex-base text
        ];
···
      }:
      mkDerivation {
        pname = "risc386";
-       version = "0.0.20210125";
-       sha256 = "0fc551nvmqgl1sj3c45bwjzc9ksqbwg17dzkipyyzdrgi1shawn2";
+       version = "0.0.20210812";
+       sha256 = "0fxwmah8f4jhs480hrvbvchkmxgfmnsswg0d5zlbdgsiqfln42qv";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base containers mtl pretty ];
···
      }) {};
 
   "sequence" = callPackage
-    ({ mkDerivation, base, containers, transformers }:
+    ({ mkDerivation, base, containers, QuickCheck, tasty
+     , tasty-quickcheck, transformers
+     }:
      mkDerivation {
        pname = "sequence";
-       version = "0.9.8";
-       sha256 = "0ayxy0lbkah90kpyjac0llv6lrbwymvfz2d3pdfrz1079si65jsh";
+       version = "0.9.9.0";
+       sha256 = "17jklfz4w73i7k4w22czc81wll8bi614wh513ra6hcnd06ba70rs";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [ base containers transformers ];
+       testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ];
        description = "A type class for sequences and various sequence data structures";
        license = lib.licenses.bsd3;
      }) {};
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "servant-streamly" = callPackage
+    ({ mkDerivation, base, bytestring, hspec, http-client, resourcet
+     , servant, servant-client, servant-server, streamly
+     , streamly-bytestring, wai, warp
+     }:
+     mkDerivation {
+       pname = "servant-streamly";
+       version = "0.1.0.0";
+       sha256 = "10f0pqhaypdk46v5gkpv3001k14v7ppfffv89x25lqlls9yrqfvf";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base resourcet servant streamly ];
+       executableHaskellDepends = [
+         base bytestring http-client resourcet servant servant-client
+         servant-server streamly streamly-bytestring wai warp
+       ];
+       testHaskellDepends = [
+         base hspec resourcet servant servant-server streamly
+       ];
+       description = "Servant Stream support for streamly";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "servant-subscriber" = callPackage
     ({ mkDerivation, aeson, async, attoparsec, base, blaze-builder
      , bytestring, case-insensitive, containers, directory, filepath
···
      }:
      mkDerivation {
        pname = "shake-cabal";
-       version = "0.2.2.1";
-       sha256 = "1vyz95qa5f6k0lqf24w60dmlszs1sv0sqv2p0sncn8ll7g785sx1";
-       revision = "1";
-       editedCabalFile = "04b9kd2jaim8qsgpji4xv7c9kmbfw089zla877qr67kvfwp6qy6m";
+       version = "0.2.2.2";
+       sha256 = "1z1l4mah7nmpa6ycx9f5ynr9rn24irs1w44nq1j3ck25b408g460";
        libraryHaskellDepends = [
          base binary Cabal composition-prelude deepseq directory filepath
          hashable shake
···
 
   "snowchecked" = callPackage
     ({ mkDerivation, base, bytestring, data-default, deepseq, hedgehog
-     , time, wide-word
+     , text, text-conversions, time, wide-word
      }:
      mkDerivation {
        pname = "snowchecked";
-       version = "0.0.0.3";
-       sha256 = "08a4v3i3ky4vbllag7wmmf4qbnf6dan93h7ipcngxk9vhx9wh4vh";
+       version = "0.0.1.0";
+       sha256 = "1128b0a4q7vnzz07ddalp6rjcmyvg98r8z77pzj573scrp214abn";
        libraryHaskellDepends = [
-         base bytestring data-default deepseq time wide-word
+         base bytestring data-default deepseq text text-conversions time
+         wide-word
        ];
        testHaskellDepends = [
-         base bytestring data-default deepseq hedgehog time wide-word
+         base bytestring data-default deepseq hedgehog text text-conversions
+         time wide-word
        ];
        description = "A checksummed variation on Twitter's Snowflake UID generation algorithm";
        license = lib.licenses.asl20;
···
        license = lib.licenses.mit;
      }) {};
 
+  "store_0_7_12" = callPackage
+    ({ mkDerivation, array, async, base, base-orphans
+     , base64-bytestring, bifunctors, bytestring, cereal, cereal-vector
+     , clock, containers, contravariant, criterion, cryptohash, deepseq
+     , directory, filepath, free, ghc-prim, hashable, hspec
+     , hspec-smallcheck, integer-gmp, lifted-base, monad-control
+     , mono-traversable, nats, network, primitive, resourcet, safe
+     , smallcheck, store-core, syb, template-haskell, text, th-lift
+     , th-lift-instances, th-orphans, th-reify-many, th-utilities, time
+     , transformers, unordered-containers, vector
+     , vector-binary-instances, void, weigh
+     }:
+     mkDerivation {
+       pname = "store";
+       version = "0.7.12";
+       sha256 = "1r6wajaxjlh38bivzmcdx8p0x89g04p6alddlibpa356drzl3jbp";
+       libraryHaskellDepends = [
+         array async base base-orphans base64-bytestring bifunctors
+         bytestring containers contravariant cryptohash deepseq directory
+         filepath free ghc-prim hashable hspec hspec-smallcheck integer-gmp
+         lifted-base monad-control mono-traversable nats network primitive
+         resourcet safe smallcheck store-core syb template-haskell text
+         th-lift th-lift-instances th-orphans th-reify-many th-utilities
+         time transformers unordered-containers vector void
+       ];
+       testHaskellDepends = [
+         array async base base-orphans base64-bytestring bifunctors
+         bytestring clock containers contravariant cryptohash deepseq
+         directory filepath free ghc-prim hashable hspec hspec-smallcheck
+         integer-gmp lifted-base monad-control mono-traversable nats network
+         primitive resourcet safe smallcheck store-core syb template-haskell
+         text th-lift th-lift-instances th-orphans th-reify-many
+         th-utilities time transformers unordered-containers vector void
+       ];
+       benchmarkHaskellDepends = [
+         array async base base-orphans base64-bytestring bifunctors
+         bytestring cereal cereal-vector containers contravariant criterion
+         cryptohash deepseq directory filepath free ghc-prim hashable hspec
+         hspec-smallcheck integer-gmp lifted-base monad-control
+         mono-traversable nats network primitive resourcet safe smallcheck
+         store-core syb template-haskell text th-lift th-lift-instances
+         th-orphans th-reify-many th-utilities time transformers
+         unordered-containers vector vector-binary-instances void weigh
+       ];
+       description = "Fast binary serialization";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "store-core" = callPackage
     ({ mkDerivation, base, bytestring, ghc-prim, primitive, text
      , transformers
···
      }:
      mkDerivation {
        pname = "streamly-posix";
-       version = "0.1.0.1";
-       sha256 = "1z6hmnhgglr5zwsaakn7c6d0cgq32pwcdds8fkn28y9p3yc89bvv";
+       version = "0.1.0.2";
+       sha256 = "14ncn4k0nd05rgbyf0apy4lk2w4lzsz4cbhykvfwxgf871yxd9lf";
        libraryHaskellDepends = [
          base bytestring hpath-posix safe-exceptions streamly
          streamly-bytestring transformers unix word8
···
        ];
        description = "Haskell string/text/bytestring interpolation that just works";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "string-interpreter" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "string-interpreter";
+       version = "0.2.0.0";
+       sha256 = "1bwdfbpmlfqixfwc02jxdyyv0pkiysh24pnmna12cwpvb9582f6n";
+       libraryHaskellDepends = [ base ];
+       description = "Is used in the recursive mode for phonetic languages approach";
+       license = lib.licenses.mit;
      }) {};
 
   "string-isos" = callPackage
···
      }:
      mkDerivation {
        pname = "taskell";
-       version = "1.11.2";
-       sha256 = "0ycv054gh28c5llyfjvsdbyq1w5jhj25b9zphj2kya0jnvpkmm81";
+       version = "1.11.3";
+       sha256 = "1wymiy9cp8d3h17nbk6qfb1visdr30c6ivrygm6dwxrbambarvd8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "tasty-checklist";
-       version = "1.0.2.0";
-       sha256 = "0smd93c1zs44nwiz0dk87izg0c9cyvx2klzy126w0p0xcxwwbhlr";
+       version = "1.0.3.0";
+       sha256 = "0vlhpc50w8gzdix1ys42cgpdv8rnkffal2zn283pccf1lfbimbjk";
        libraryHaskellDepends = [
          base exceptions parameterized-utils text
        ];
···
        libraryHaskellDepends = [ base dejafu random tagged tasty ];
        description = "Deja Fu support for the Tasty test framework";
        license = lib.licenses.mit;
+     }) {};
+
+  "tasty-dejafu_2_0_0_8" = callPackage
+    ({ mkDerivation, base, dejafu, random, tagged, tasty }:
+     mkDerivation {
+       pname = "tasty-dejafu";
+       version = "2.0.0.8";
+       sha256 = "0v0vkbj8nr4jg62a5c0qygj1pjkz1vnssiicafv87qis02j36myx";
+       libraryHaskellDepends = [ base dejafu random tagged tasty ];
+       description = "Deja Fu support for the Tasty test framework";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "tasty-discover" = callPackage
···
        license = lib.licenses.gpl2Only;
      }) {};
 
+  "texmath_0_12_3_1" = callPackage
+    ({ mkDerivation, base, bytestring, containers, directory, filepath
+     , mtl, pandoc-types, parsec, process, split, syb, temporary, text
+     , utf8-string, xml
+     }:
+     mkDerivation {
+       pname = "texmath";
+       version = "0.12.3.1";
+       sha256 = "1qyiihb9h7w7074p495yd4s8dj9adz0dy865gyp822z69jvmkcki";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers mtl pandoc-types parsec split syb text xml
+       ];
+       testHaskellDepends = [
+         base bytestring directory filepath process temporary text
+         utf8-string xml
+       ];
+       description = "Conversion between formats used to represent mathematics";
+       license = lib.licenses.gpl2Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "texrunner" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, directory, filepath
      , HUnit, io-streams, lens, mtl, process, semigroups, temporary
···
        license = lib.licenses.mit;
      }) {};
 
+  "typed-process_0_2_6_1" = callPackage
+    ({ mkDerivation, async, base, base64-bytestring, bytestring, hspec
+     , process, stm, temporary, transformers, unliftio-core
+     }:
+     mkDerivation {
+       pname = "typed-process";
+       version = "0.2.6.1";
+       sha256 = "0w4c76qln49967nnhf7f1zj3gbdfqp2qgf5ym8svhqyhp5gh61ws";
+       libraryHaskellDepends = [
+         async base bytestring process stm transformers unliftio-core
+       ];
+       testHaskellDepends = [
+         async base base64-bytestring bytestring hspec process stm temporary
+         transformers unliftio-core
+       ];
+       description = "Run external processes, with strong typing of streams";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "typed-spreadsheet" = callPackage
     ({ mkDerivation, async, base, diagrams-cairo, diagrams-gtk
      , diagrams-lib, foldl, gtk, microlens, stm, text, transformers
···
        pname = "universum";
        version = "1.7.2";
        sha256 = "1ka7q5vr9xkf8z5mzpkp648mpf8az7b14lnhbvfakg3v5xy3f7gb";
+       revision = "1";
+       editedCabalFile = "17w3zpbv5ap9as506fn43xlnh6sqxni8mmczlp5l86hvn7zd8y6z";
        libraryHaskellDepends = [
          base bytestring containers deepseq ghc-prim hashable microlens
          microlens-mtl mtl safe-exceptions stm text transformers
···
      }:
      mkDerivation {
        pname = "vulkan";
-       version = "3.11.5";
-       sha256 = "18g8ckarjqz4nws1gihx3wpywqwkiwg88qq071sjs7wvsnwbjf2s";
+       version = "3.12.1";
+       sha256 = "0y9ykv0dx5hvh2683yyn8mdl3jxqk9zaf2a1rkyr5zgc43wsbm05";
        libraryHaskellDepends = [ base bytestring transformers vector ];
        libraryPkgconfigDepends = [ vulkan ];
        testHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "vulkan-utils";
-       version = "0.5.1";
-       sha256 = "1552vk9nzvcpkgh5b9lln9gl6rxg1jr8z7blgp3sss3pjsvi3s11";
+       version = "0.5.2";
+       sha256 = "05h54dzci8ahnxshrcd7l6bpg1q8llnrwycgpbpn12cf6ddmdc59";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base bytestring containers dependent-map dependent-sum extra
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "wgpu-raw-hs" = callPackage
+    ({ mkDerivation, base, GLFW-b, unix }:
+     mkDerivation {
+       pname = "wgpu-raw-hs";
+       version = "0.1.0.2";
+       sha256 = "1hagn99jdmwjcyz2afmmd9ws31dncas9fssv6lx75kshar6x4rah";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base GLFW-b unix ];
+       executableHaskellDepends = [ base GLFW-b ];
+       description = "WGPU Raw";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "what4" = callPackage
     ({ mkDerivation, attoparsec, base, bifunctors, bimap, bv-sized
      , bytestring, config-value, containers, contravariant
···
      }:
      mkDerivation {
        pname = "xmobar";
-       version = "0.38";
-       sha256 = "1h7y5bnrsxc9k92zn5pfyimpdvm9245b93rxf0ff1avssnp1i31s";
+       version = "0.39";
+       sha256 = "1k1n3ff0ikdmfq0mi8r2vpqg1iq6hsw1drvxps6k98rvvn87pws6";
        configureFlags = [
          "-fwith_alsa" "-fwith_conduit" "-fwith_datezone" "-fwith_dbus"
          "-fwith_inotify" "-fwith_iwlib" "-fwith_mpd" "-fwith_mpris"
···
   "yesod-auth-lti13" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, base64-bytestring
      , bytestring, containers, cryptonite, http-client, http-conduit
-     , jose-jwt, load-env, lti13, microlens, oidc-client, random
+     , jose-jwt, load-env, lti13, microlens, oidc-client
      , safe-exceptions, text, time, warp, yesod, yesod-auth, yesod-core
      }:
      mkDerivation {
        pname = "yesod-auth-lti13";
-       version = "0.2.0.2";
-       sha256 = "19x8a3jfwrsrizg8lj8wrc9k2b0p4lga3q5fqqa60jjsr6lm73j3";
+       version = "0.2.0.3";
+       sha256 = "06xlpdirr7s4l9a9sxydn7vj0z9dy600yn6nmccv042awkdg5l0f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-pretty base base64-bytestring bytestring containers
          cryptonite http-client http-conduit jose-jwt load-env lti13
-         microlens oidc-client random safe-exceptions text time warp yesod
+         microlens oidc-client safe-exceptions text time warp yesod
          yesod-auth yesod-core
        ];
        description = "A yesod-auth plugin for LTI 1.3";
···
      }:
      mkDerivation {
        pname = "yst";
-       version = "0.7.1";
-       sha256 = "0clvfkdrmw7lmrcyn8cilgf0k7438c384vwvjx256pyl46y3ym5m";
+       version = "0.7.1.2";
+       sha256 = "1wg1vvf7wna5pv2mgs66c82rjan0ig4vv6vv2vlsnxzbpkn7vvf5";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
          split text time unordered-containers yaml
        ];
        description = "Builds a static website from templates and data in YAML or CSV files";
-       license = "GPL";
+       license = lib.licenses.gpl2Plus;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};